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
Rust agentsagiaiai-memoryaudio-recordingcomputer-visionhermeshermes-agentllmlocal-ailocal-firstmachine-learningmcpmultimodalopenclawprivacyrewindscreen-recordingspeech-to-textycombinator
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.tsxindex 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 counconst 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.tsindex 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.tsindex 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.rsindex 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.tsindex 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.tsxindex 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, updconst 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.tsxindex 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: Workfif (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);