fix(worker): stamp completedAt/durationSec when a cancelled run settles (#281)

Author: outof-place

apps/worker/src/lib/telemetry/run-telemetry.test.ts

@@ -747,6 +747,36 @@ describe("live clarification park status", () => {
     expect(await row("wrun_missing")).toBeUndefined();
   });
 
+  // RUN-CANCEL-BOOKKEEPING-001: "blocked" is terminal, so the cancel settle
+  // must finalize the same completion bookkeeping a normally-finished run gets,
+  // not leave the row terminal-yet-never-completed.
+  it("markRunBlockedOnCancel finalizes completedAt/durationSec like a completed run", async () => {
+    await db.insert(workflowRuns).values({
+      runId: "wrun_cancel_bookkeeping",
+      subjectKey: "ticket:jira:PROJ-1",
+      workflowId: "wf_agent",
+      workflowName: "Agent",
+      ticketKey: "PROJ-1",
+      status: "awaiting",
+      startedAt: new Date("2026-06-15T10:00:05Z"),
+    });
+    await markRunBlockedOnCancel(db, "wrun_cancel_bookkeeping");
+    const r = await row("wrun_cancel_bookkeeping");
+    expect(r.status).toBe("blocked");
+    expect(r.completedAt).not.toBeNull();
+    expect(r.durationSec).not.toBeNull();
+    expect(r.durationSec!).toBeGreaterThan(0); // now() - startedAt
+  });
+
+  it("markRunBlockedOnCancel stamps completedAt but no duration when no start was recorded", async () => {
+    await seed("wrun_cancel_no_start", "awaiting");
+    await markRunBlockedOnCancel(db, "wrun_cancel_no_start");
+    const r = await row("wrun_cancel_no_start");
+    expect(r.status).toBe("blocked");
+    expect(r.completedAt).not.toBeNull(); // the settle time itself
+    expect(r.durationSec).toBeNull(); // no start to measure from, no fabricated zero
+  });
+
   // A workflow step can be re-executed after a worker restart, so every writer
   // has to survive being called twice with the same argument.
   it("repeating any of the three writes changes nothing", async () => {
@@ -814,6 +844,25 @@ describe("markRunBlockedByOperator", () => {
     expect(await row("wrun_op_missing")).toBeUndefined();
   });
 
+  // RUN-CANCEL-BOOKKEEPING-001: the operator settle is terminal too, so it must
+  // finalize the same completion bookkeeping recordRunUsage writes.
+  it("finalizes completedAt/durationSec like a completed run", async () => {
+    await db.insert(workflowRuns).values({
+      runId: "wrun_op_bookkeeping",
+      subjectKey: "sched:demo:hourly",
+      workflowId: "wf_agent",
+      workflowName: "Agent",
+      status: "running",
+      startedAt: new Date("2026-06-15T10:00:05Z"),
+    });
+    await markRunBlockedByOperator(db, "wrun_op_bookkeeping", "cancelled by operator kate");
+    const r = await row("wrun_op_bookkeeping");
+    expect(r.status).toBe("blocked");
+    expect(r.completedAt).not.toBeNull();
+    expect(r.durationSec).not.toBeNull();
+    expect(r.durationSec!).toBeGreaterThan(0); // now() - startedAt
+  });
+
   // A workflow step can be re-executed after a worker restart, so the write has
   // to survive being called twice: the second call sees 'blocked' and no-ops.
   it("is idempotent under re-execution", async () => {

apps/worker/src/lib/telemetry/run-telemetry.ts

@@ -539,11 +539,23 @@ export async function markRunResumed(db: Db, runId: string): Promise<void> {
  * open). The run never resumes to clear it itself and the cron never downgrades
  * a frozen status, so without this the cancelled row keeps showing awaiting
  * input. Guarded on exactly "awaiting" so it only ever touches a parked run.
+ *
+ * "blocked" is terminal, so the settle also finalizes the lifecycle the way
+ * recordRunUsage does on completion: completedAt keeps a precise value if one
+ * was already recorded, else stamps now(); durationSec is filled from a known
+ * start. Without this a cancelled run reads terminal-yet-never-completed, with
+ * no duration, forever (the cron never touches a frozen status and keepIfNull
+ * only keeps what the settle wrote).
  */
 export async function markRunBlockedOnCancel(db: Db, runId: string): Promise<void> {
   await db
     .update(workflowRuns)
-    .set({ status: "blocked", updatedAt: sql`now()` })
+    .set({
+      status: "blocked",
+      completedAt: sql`coalesce(${workflowRuns.completedAt}, now())`,
+      durationSec: durationFromStart(),
+      updatedAt: sql`now()`,
+    })
     .where(and(eq(workflowRuns.runId, runId), eq(workflowRuns.status, "awaiting")));
 }
 
@@ -570,7 +582,15 @@ export async function markRunBlockedByOperator(
 ): Promise<void> {
   await db
     .update(workflowRuns)
-    .set({ status: "blocked", statusReason: reason, updatedAt: sql`now()` })
+    .set({
+      status: "blocked",
+      statusReason: reason,
+      // Terminal settle, so finalize completedAt/durationSec exactly like
+      // recordRunUsage does on completion (see markRunBlockedOnCancel).
+      completedAt: sql`coalesce(${workflowRuns.completedAt}, now())`,
+      durationSec: durationFromStart(),
+      updatedAt: sql`now()`,
+    })
     .where(
       and(
         eq(workflowRuns.runId, runId),