Skip to content

YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context

fix(pipes): continue dependent tasks after manual runs (#7048)

Louis Beaumonte738c36d4c00
diff --git a/apps/screenpipe-app-tauri/components/workflows/workflow-run-progress.test.tsx b/apps/screenpipe-app-tauri/components/workflows/workflow-run-progress.test.tsx
index 8ab87b5f1..e428a0c9d 100644
--- a/apps/screenpipe-app-tauri/components/workflows/workflow-run-progress.test.tsx
+++ b/apps/screenpipe-app-tauri/components/workflows/workflow-run-progress.test.tsx
@@ -43,6 +43,15 @@ it("shows no-change success and never labels a failed run with older change coun
const view = render(<WorkflowRunProgress active={false} job={{ id: "1", status: "complete" }} changes={{ created: 0, updated: 0 }} analyze={vi.fn()} />);
expect(screen.getByRole("status")).toHaveTextContent("Up to date");
view.rerender(<WorkflowRunProgress active={false} job={{ id: "2", status: "failed" }} changes={{ created: 0, updated: 2 }} analyze={vi.fn()} />);
- expect(screen.getByRole("status")).toHaveTextContent("Update not saved");
+ expect(screen.getByRole("status")).toHaveTextContent("Update failed");
expect(screen.queryByText("0 new · 2 updated")).not.toBeInTheDocument();
});
+
+it("shows an incomplete pipeline as resumable without claiming the catalog saved", () => {
+ const analyze = vi.fn();
+ render(<WorkflowRunProgress active={false} job={{ id: "activity:48", status: "incomplete", message: "Resume to continue" }} changes={{ created: 0, updated: 2 }} analyze={analyze} />);
+ expect(screen.getByRole("status")).toHaveTextContent("Update incomplete");
+ expect(screen.queryByText("0 new · 2 updated")).not.toBeInTheDocument();
+ fireEvent.click(screen.getByRole("button", { name: "Resume update" }));
+ expect(analyze).toHaveBeenCalledOnce();
+});
diff --git a/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.test.ts b/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.test.ts
index 9eb97eda7..c94b029c1 100644
--- a/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.test.ts
+++ b/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.test.ts
@@ -82,6 +82,24 @@ describe("workflow scheduled-task adapter", () => {
});
expect(await getWorkflowJob("workflow-discovery:27")).toMatchObject({status:"complete",result:{changes:{created:0,updated:0}}});
});
+ it("allows scheduler handoff time, then offers to resume without a false save failure", async () => {
+ const finished = new Date(Date.now() - 45_000).toISOString();
+ const execution = {id:48,status:"completed",started_at:finished,finished_at:finished};
+ fetchMock.mockImplementation(async path => {
+ const url = String(path);
+ if (url.includes("/executions/")) return response({data:execution});
+ if (url.includes("/executions?")) return response({data:url.includes("workflow-activity")?[execution]:[]});
+ if (url.includes("/pipeline")) return response({inputRevision:0,upToDate:false,blockedReason:null});
+ return response({analyzedAt:"2026-09-14T12:00:00Z",pipelineRevision:0});
+ });
+ expect(await getWorkflowJob("workflow-activity:48")).toMatchObject({status:"queued"});
+ execution.finished_at = new Date(Date.now() - 120_000).toISOString();
+ expect(await getWorkflowJob("workflow-activity:48")).toMatchObject({status:"incomplete",message:expect.stringContaining("Resume")});
+ });
+ it("treats a timed-out task as a terminal failure instead of waiting forever", async () => {
+ fetchMock.mockResolvedValueOnce(response({data:{id:48,status:"timed_out"}}));
+ expect(await getWorkflowJob("48")).toMatchObject({status:"failed"});
+ });
it("saves only the edited correction, never a stale full catalog", async () => {
const prior = { analyzedAt: "2026-09-15T12:00:00Z", analysis: { workflows: [{ id: "wf-a", title: "Updated elsewhere", userCorrection: "Old" }] } };
fetchMock.mockResolvedValueOnce(response(prior)).mockResolvedValueOnce(response({ success: true }));
diff --git a/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.ts b/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.ts
index 544722559..5c412b318 100644
--- a/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.ts
+++ b/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.ts
@@ -56,7 +56,7 @@ export async function loadScheduledCatalog(): Promise<WorkflowAnalysis | null> {
function job(execution: any): WorkflowAnalysisJob {
const status = execution.status === "completed" ? "complete"
- : ["failed", "cancelled", "interrupted"].includes(execution.status) ? "failed"
+ : ["failed", "cancelled", "interrupted", "timed_out"].includes(execution.status) ? "failed"
: execution.status === "running" ? "processing" : "queued";
return { id: String(execution.id), status, startedAt: execution.started_at,
message: execution.status === "cancelled" ? "Update stopped. Your saved workflows are still available."
@@ -106,7 +106,7 @@ export async function getWorkflowJob(id: string): Promise<WorkflowAnalysisJob> {
// A later dependency can finish without input. It must not hide the failure
// that prevented this cycle's activity scan from producing any input.
const cycleStart = Date.parse(tasks.find(item => item.task === WORKFLOW_TASKS[0])?.execution?.started_at || data.started_at);
- const failure = tasks.find(item => item.execution && ["failed", "cancelled", "interrupted"].includes(item.execution.status)
+ const failure = tasks.find(item => item.execution && ["failed", "cancelled", "interrupted", "timed_out"].includes(item.execution.status)
&& Date.parse(item.execution.started_at) >= cycleStart);
if (failure) return tracked(failure.execution, failure.task);
const pipeline = await request(`/workflows/pipeline?task=${TASK}`);
@@ -122,7 +122,8 @@ export async function getWorkflowJob(id: string): Promise<WorkflowAnalysisJob> {
// so a missed event or disabled task never leaves a permanent spinner.
const latest = tasks.filter(item => item.execution).sort((a,b) => Date.parse(b.execution.finished_at || b.execution.started_at) - Date.parse(a.execution.finished_at || a.execution.started_at))[0];
const finished = Date.parse(latest?.execution.finished_at || data.started_at);
- if (Date.now() - finished > 30_000) return { ...original, status: "failed", message: "Workflow progress saved. Update now to resume the remaining stages." };
+ // Allow several 30-second scheduler ticks, including its run stagger.
+ if (Date.now() - finished > 90_000) return { ...original, status: "incomplete", message: "Update paused before all stages finished. Resume to continue; your saved workflows are still available." };
return { ...original, status: "queued", message: "Preparing the next enrichment task" };
}
diff --git a/crates/screenpipe-core/src/pipes/mod.rs b/crates/screenpipe-core/src/pipes/mod.rs
index 14aaf9cb8..89d240e09 100644
--- a/crates/screenpipe-core/src/pipes/mod.rs
+++ b/crates/screenpipe-core/src/pipes/mod.rs
@@ -4530,6 +4530,10 @@ impl PipeManager {
push_run_log_status(entry, log);
drop(l);
+ // Manual/API runs notify the same scheduler after saving output
+ // and clearing the running state, so dependents can safely start.
+ emit_pipe_completed(&name_for_cb, success, duration_secs);
+
if let Some(ref cb) = on_complete {
cb(
&name_for_cb,
@@ -4552,10 +4556,17 @@ impl PipeManager {
/// Run a pipe once with an explicit trigger type.
async fn run_pipe_with_trigger(&self, name: &str, trigger: &str) -> Result<PipeRunLog> {
- Ok(self
+ let outcome = self
.run_pipe_with_trigger_inner(name, trigger, 0, None, None)
- .await?
- .log)
+ .await?;
+ // The inner runner retries presets and is also called by the scheduler.
+ // Emit only the final outcome here, never intermediate attempts.
+ emit_pipe_completed(
+ name,
+ outcome.log.success,
+ (outcome.log.finished_at - outcome.log.started_at).num_milliseconds() as f64 / 1000.0,
+ );
+ Ok(outcome.log)
}
/// Inner implementation with retry depth tracking for preset fallback.
@@ -7247,16 +7258,7 @@ impl PipeManager {
}
// Emit pipe_completed event so other pipes can chain
- let event_name = format!("pipe_completed:{}", name_for_cb);
- let _ = screenpipe_events::send_event(
- &event_name,
- screenpipe_events::PipeCompletedEvent {
- pipe_name: name_for_cb.clone(),
- success,
- duration_secs,
- timestamp: chrono::Utc::now(),
- },
- );
+ emit_pipe_completed(&name_for_cb, success, duration_secs);
// Fire run-complete callback (analytics, etc.)
if let Some(ref cb) = on_complete {
@@ -8030,6 +8032,18 @@ fn event_dedupe_key(event_name: &str, data: &serde_json::Value) -> Option<String
})
}
+fn emit_pipe_completed(pipe_name: &str, success: bool, duration_secs: f64) {
+ let _ = screenpipe_events::send_event(
+ &format!("{PIPE_COMPLETED_EVENT_PREFIX}{pipe_name}"),
+ screenpipe_events::PipeCompletedEvent {
+ pipe_name: pipe_name.to_string(),
+ success,
+ duration_secs,
+ timestamp: Utc::now(),
+ },
+ );
+}
+
fn pipe_completed_source(event_name: &str) -> Option<&str> {
event_name.strip_prefix(PIPE_COMPLETED_EVENT_PREFIX)
}
@@ -8987,6 +9001,7 @@ mod tests {
use super::*;
use crate::agents::{AgentOutput, ExecutionHandle, SharedPid};
use chrono::{TimeZone, Timelike};
+ use futures::{FutureExt, StreamExt};
use std::path::Path;
use std::sync::atomic::Ordering;
@@ -9096,6 +9111,157 @@ mod tests {
}
}
+ #[tokio::test(start_paused = true)]
+ async fn manual_completion_starts_dependent_task_once() {
+ let temp = tempfile::tempdir().unwrap();
+ let pipes_dir = temp.path().join("pipes");
+ for (name, trigger) in [
+ ("manual-chain-source", ""),
+ (
+ "manual-chain-dependent",
+ "trigger:\n events:\n - pipe_completed:manual-chain-source\n",
+ ),
+ (
+ "manual-chain-disabled",
+ "enabled: false\ntrigger:\n events:\n - pipe_completed:manual-chain-source\n",
+ ),
+ ] {
+ let dir = pipes_dir.join(name);
+ std::fs::create_dir_all(&dir).unwrap();
+ std::fs::write(
+ dir.join("pipe.md"),
+ format!(
+ "---\nschedule: manual\nagent: mock\nmodel: test\n{trigger}---\nSave the result.\n"
+ ),
+ )
+ .unwrap();
+ }
+ let executor = Arc::new(SequencedExecutor {
+ outputs: std::sync::Mutex::new(VecDeque::from([
+ AgentOutput {
+ stdout: "source saved".into(),
+ stderr: String::new(),
+ success: true,
+ pid: None,
+ },
+ AgentOutput {
+ stdout: "dependent saved".into(),
+ stderr: String::new(),
+ success: true,
+ pid: None,
+ },
+ ])),
+ attempts: std::sync::Mutex::new(Vec::new()),
+ });
+ let mut executors: HashMap<String, Arc<dyn AgentExecutor>> = HashMap::new();
+ executors.insert("mock".into(), executor.clone());
+ let mut manager = PipeManager::new(pipes_dir, executors, None, 0);
+ manager.load_pipes().await.unwrap();
+ let mut events = screenpipe_events::subscribe_to_event::<serde_json::Value>(
+ "pipe_completed:manual-chain-source",
+ );
+ manager.start_scheduler().await.unwrap();
+ // Let the scheduler subscribe before the manual API entry point runs.
+ for _ in 0..10 {
+ tokio::task::yield_now().await;
+ }
+ manager
+ .start_pipe_background("manual-chain-source")
+ .await
+ .unwrap();
+ let event = tokio::time::timeout(std::time::Duration::from_secs(5), events.next())
+ .await
+ .expect("manual completion event missing")
+ .unwrap();
+ assert_eq!(event.data["success"], true);
+ assert!(
+ manager.logs.lock().await["manual-chain-source"]
+ .back()
+ .unwrap()
+ .success
+ );
+ assert!(!manager
+ .running
+ .lock()
+ .await
+ .contains_key("manual-chain-source"));
+ tokio::time::advance(std::time::Duration::from_secs(31)).await;
+ for _ in 0..100 {
+ if manager
+ .logs
+ .lock()
+ .await
+ .get("manual-chain-dependent")
+ .and_then(|logs| logs.back())
+ .is_some()
+ {
+ break;
+ }
+ tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+ }
+ manager.stop_scheduler().await;
+ assert!(
+ manager.logs.lock().await["manual-chain-dependent"]
+ .back()
+ .unwrap()
+ .success
+ );
+ assert_eq!(executor.attempts.lock().unwrap().len(), 2);
+ assert!(
+ events.next().now_or_never().is_none(),
+ "duplicate source completion"
+ );
+ assert!(!manager
+ .logs
+ .lock()
+ .await
+ .contains_key("manual-chain-disabled"));
+ }
+
+ #[tokio::test]
+ async fn manual_completion_reports_failure_after_persisting_log() {
+ let temp = tempfile::tempdir().unwrap();
+ let pipes_dir = temp.path().join("pipes");
+ let dir = pipes_dir.join("manual-failed-event");
+ std::fs::create_dir_all(&dir).unwrap();
+ std::fs::write(
+ dir.join("pipe.md"),
+ "---\nschedule: manual\nagent: mock\nmodel: test\n---\nDo work.\n",
+ )
+ .unwrap();
+ let executor = Arc::new(SequencedExecutor {
+ outputs: std::sync::Mutex::new(VecDeque::from([AgentOutput {
+ stdout: String::new(),
+ stderr: "missing output".into(),
+ success: false,
+ pid: None,
+ }])),
+ attempts: std::sync::Mutex::new(Vec::new()),
+ });
+ let mut executors: HashMap<String, Arc<dyn AgentExecutor>> = HashMap::new();
+ executors.insert("mock".into(), executor);
+ let manager = PipeManager::new(pipes_dir, executors, None, 0);
+ manager.load_pipes().await.unwrap();
+ let mut events = screenpipe_events::subscribe_to_event::<serde_json::Value>(
+ "pipe_completed:manual-failed-event",
+ );
+ manager
+ .start_pipe_background("manual-failed-event")
+ .await
+ .unwrap();
+ let event = tokio::time::timeout(std::time::Duration::from_secs(5), events.next())
+ .await
+ .unwrap()
+ .unwrap();
+ assert_eq!(event.data["success"], false);
+ assert!(
+ !manager.logs.lock().await["manual-failed-event"]
+ .back()
+ .unwrap()
+ .success
+ );
+ }
+
#[test]
fn cloud_scheduler_settings_preserve_task_and_provider_for_every_runner() {
for provider in ["codex", "claude", "cursor"] {
@@ -10807,6 +10973,9 @@ Do resilient work.
let manager = PipeManager::new(pipes_dir, executors, None, 0);
manager.load_pipes().await.unwrap();
+ let mut events = screenpipe_events::subscribe_to_event::<serde_json::Value>(
+ "pipe_completed:resilient-pipe",
+ );
let log = manager
.run_pipe_with_trigger("resilient-pipe", "manual")
.await
@@ -10814,6 +10983,12 @@ Do resilient work.
assert!(log.success);
assert_eq!(log.stdout, "fallback completed");
+ let event = events.next().await.unwrap();
+ assert_eq!(event.data["success"], true);
+ assert!(
+ events.next().now_or_never().is_none(),
+ "fallback attempts emitted extra completion events"
+ );
assert_eq!(
executor.attempts.lock().unwrap().as_slice(),
[
diff --git a/packages/workflows-ui/src/platform.ts b/packages/workflows-ui/src/platform.ts
index e714725f2..3a9dbd230 100644
--- a/packages/workflows-ui/src/platform.ts
+++ b/packages/workflows-ui/src/platform.ts
@@ -26,7 +26,7 @@ export type WorkflowRunActivity = {
export type WorkflowAnalysisJob = {
id: string;
- status: "queued" | "processing" | "complete" | "failed";
+ status: "queued" | "processing" | "complete" | "incomplete" | "failed";
progress?: number;
startedAt?: string;
message?: string;
diff --git a/packages/workflows-ui/src/workflow-run-progress.tsx b/packages/workflows-ui/src/workflow-run-progress.tsx
index 9e9c81adc..86a43014e 100644
--- a/packages/workflows-ui/src/workflow-run-progress.tsx
+++ b/packages/workflows-ui/src/workflow-run-progress.tsx
@@ -48,12 +48,12 @@ export function WorkflowRunProgress({ job, active, subscribe, stop, analyze, upd
const seconds = job?.startedAt ? Math.max(0, Math.floor((now - Date.parse(job.startedAt)) / 1000)) : NaN;
const result = changes ? changes.created === 0 && changes.updated === 0 ? "Up to date" : `${changes.created} new · ${changes.updated} updated` : "Workflows updated";
const label = active ? current?.label ?? (job?.message || (job?.status === "queued" ? "Waiting for agent" : "Agent working"))
- : job?.status === "failed" ? "Update not saved" : job?.status === "complete" ? result
+ : job?.status === "incomplete" ? "Update incomplete" : job?.status === "failed" ? "Update failed" : job?.status === "complete" ? result
: updatedAt ? `Updated ${new Date(updatedAt).toLocaleTimeString([], { hour: "numeric", minute: "2-digit" })}` : "";
return <div className={styles.refreshControls}>
{(active || items.length > 0) ? <div ref={root} className={styles.runProgress}>
<button ref={toggle} type="button" className={styles.runToggle} aria-expanded={open} aria-label={`${label}. Show agent activity`} onClick={() => setOpen(!open)}>
- {active ? <Loader2 size={14} className={styles.runSpinner} /> : job?.status === "failed" ? <AlertCircle size={14} /> : <Check size={14} />}
+ {active ? <Loader2 size={14} className={styles.runSpinner} /> : job?.status === "failed" ? <AlertCircle size={14} /> : job?.status === "incomplete" ? <Circle size={14} /> : <Check size={14} />}
<span role="status">{label}</span>
{active && Number.isFinite(seconds) && <time>{Math.floor(seconds / 60)}:{String(seconds % 60).padStart(2, "0")}</time>}
<ChevronDown size={12} style={{ transform: open ? "rotate(180deg)" : undefined }} />
@@ -64,10 +64,10 @@ export function WorkflowRunProgress({ job, active, subscribe, stop, analyze, upd
{item.status === "error" ? <AlertCircle size={13} /> : item.status === "complete" ? <Check size={13} /> : active ? <Loader2 size={13} className={styles.runSpinner} /> : <Circle size={13} />}
<span>{item.label}{!active && item.status === "running" ? " · ended" : ""}</span>
</li>)}</ol> : <p>{unavailable ? "Live activity is unavailable. The task status will keep updating." : "Waiting for the next agent action…"}</p>}
- <footer>{active ? "Your saved workflows stay available." : job?.status === "failed" ? job.message : result}</footer>
+ <footer>{active ? "Your saved workflows stay available." : (job?.status === "failed" || job?.status === "incomplete") ? job.message : result}</footer>
</section>}
</div> : <span role="status">{label}</span>}
{active && stop ? <button className={styles.secondaryButton} onClick={stop}><Square size={11} />Stop</button>
- : <button className={styles.secondaryButton} onClick={analyze} disabled={active || !!disabledReason} title={disabledReason}><RefreshCw size={14} />Update now</button>}
+ : <button className={styles.secondaryButton} onClick={analyze} disabled={active || !!disabledReason} title={disabledReason}><RefreshCw size={14} />{job?.status === "incomplete" ? "Resume update" : "Update now"}</button>}
</div>;
}
diff --git a/packages/workflows-ui/src/workflows-app.tsx b/packages/workflows-ui/src/workflows-app.tsx
index 6ae546246..849cf7188 100644
--- a/packages/workflows-ui/src/workflows-app.tsx
+++ b/packages/workflows-ui/src/workflows-app.tsx
@@ -127,7 +127,7 @@ async function completedJobResult(platform: WorkflowsPlatform, initialJob: Workf
if (job.result) return job.result;
throw new Error("The workflow report finished without a readable result.");
}
- if (job.status === "failed") throw new Error(job.message || "The workflow report failed.");
+ if (job.status === "failed" || job.status === "incomplete") throw new Error(job.message || "The workflow report failed.");
if (!platform.getAnalysisJob) throw new Error("The workflow report cannot be checked yet.");
await new Promise((resolve) => setTimeout(resolve, 2_000));
job = await platform.getAnalysisJob(job.id);