@gobing-ai/spur 0.2.8 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.2.8",
+    "version": "0.2.9",
     "description": "Spur CLI — local-first harness for mainstream coding agents: constraint checking, workflow orchestration, agent health, and history analytics. Bun-native; exposes the `spur` command.",
     "keywords": [
         "spur",

package/spur-cli/config/rules/structure/test-location.yaml

@@ -52,3 +52,4 @@ rules:
       - "**/tests/**"
       ## pure re-export for UI components
       - "apps/web/src/ui.ts"
+      - "apps/web/src/modules/config.ts"

package/spur-cli/config/tasks/section-matrix.yaml

@@ -108,9 +108,11 @@ variants:
   # Plan and Review are optional at backlog/todo so the template renders cleanly;
   # Review becomes required at wip+.
   #
-  # Solution and Testing are optional at wip+ — not required, but tolerated so that
-  # a review-findings task that evolves into implementation work (the common dogfood
-  # follow-up path) can carry a change-map and coverage data without matrix violations.
+  # Requirements is optional from todo onward (the authoring stage where a refined
+  # review-findings task gains scoped requirements); Solution and Testing are optional
+  # at wip+ — none required, but tolerated so that a review-findings task that evolves
+  # into implementation work (the common dogfood follow-up path) can carry scoped
+  # requirements, a change-map, and coverage data without matrix violations.
   # The required list guards the real deliverables; optional is permissive on purpose.
   review:
     backlog:
@@ -119,17 +121,17 @@ variants:
       forbidden: [Testing]
     todo:
       required: [Background, Plan]
-      optional: [Q&A, Review]
+      optional: [Q&A, Requirements, Review]
       forbidden: [Testing]
     wip:
       required: [Background, Review]
-      optional: [Plan, Q&A, Solution, Testing]
+      optional: [Plan, Q&A, Requirements, Solution, Testing]
     testing:
       required: [Background, Review]
-      optional: [Plan, Solution, Testing]
+      optional: [Plan, Requirements, Solution, Testing]
     done:
       required: [Background, Review]
-      optional: [Plan, Q&A, Solution, Testing]
+      optional: [Plan, Q&A, Requirements, Solution, Testing]
       gate: true
     blocked:
       required: [Background]

package/spur-cli/config/tasks/templates/review.md

@@ -43,6 +43,11 @@ in the reviewed PR/commit/diff). Fix in priority order (P1 → P2 → …); re-r
 Post-implementation reflection — filled **after** the first fix round: what went wrong, what
 remains to fix before closing, and any **back-issues** (new findings surfaced by the fix).
 
+| Severity | File | Finding | Recommendation |
+| -------- | ---- | ------- | -------------- |
+| P1       |      |         |                |
+| P2       |      |         |                |
+
 ### References
 
 ### History

package/spur-cli/config/workflows/feature-dev.yaml

@@ -63,7 +63,7 @@ states:
     description: >
       Drive EVERY pending task under the feature to done. The agent enumerates the work with
       `spur task list --feature ${featureId} --status todo --json`, then runs each task through
-      task-pipeline.yaml (refine → implement → test → review → verify → record → done). It
+      task-pipeline.yaml (precheck → implement → test → review → approve → verify → record → done). It
       stops and reports on the first non-PASS verdict — a failing task fails the feature.
     onEnter:
       - kind: agent.run
@@ -71,9 +71,13 @@ states:
           agent: ${vars.agent}
           input: >
             Run every pending task under feature ${vars.featureId} to done. Enumerate with
-            `${vars.spurBin} task list --feature ${vars.featureId} --status todo --json`, then
-            for each task run the task-pipeline (e.g. /sp:dev-refine <wbs> --auto --next, which
-            chains implement → verify → done). Stop and report on the first non-PASS verdict.
+            `${vars.spurBin} task list --feature ${vars.featureId} --status todo --json`; then
+            for each WBS run the standard single-task pipeline VERBATIM:
+            `${vars.spurBin} workflow run config/workflows/task-pipeline.yaml --vars
+            '{"wbs":"<wbs>","profile":"${vars.profile}","agent":"${vars.agent}"}' --async --json`,
+            polling `${vars.spurBin} workflow trace <run-id>` until terminal and inspecting
+            `.spur/run/<wbs>-verdict.json`. Stop and report on the first non-PASS verdict
+            (a failing task fails the feature).
 
   - id: feature-verify
     description: >

package/spur-cli/config/workflows/task-pipeline.yaml

@@ -56,20 +56,26 @@ states:
 
   - id: implement
     description: >
-      Move the task to `wip` (via the normal verb — lifecycle guards apply, R3),
-      then run agent-driven implementation via /sp:dev-run --mode implement.
+      Run agent-driven implementation via /sp:dev-run --mode implement, THEN move the
+      task to `wip` via the normal verb. The lifecycle transition fires AFTER the
+      implement agent.run succeeds — onEnter runs in declaration order and the default
+      'fail' policy halts the sequence (routing the run to `failed`) if the agent.run
+      fails or times out, so a halted implement never leaves the task at `wip` with an
+      empty Solution (the F3 half-state). The `--no-lifecycle` flag is correct here: the
+      pipeline owns this transition; the FSM guard would otherwise re-run `spur task
+      check`, which is precheck's job.
       NOTE: this step must NOT call /sp:dev-run in full mode (the default) —
       that command DRIVES this pipeline, so calling it here recurses.
       --mode implement is the single-step implement entry.
     onEnter:
-      - kind: shell
-        options:
-          command: "${vars.spurBin} task update ${vars.wbs} wip --no-lifecycle"
       - kind: agent.run
         options:
           agent: ${vars.agent}
           input: /sp:dev-run --mode implement ${vars.wbs} --auto
           timeoutMs: ${vars.stepTimeoutMs}
+      - kind: shell
+        options:
+          command: "${vars.spurBin} task update ${vars.wbs} wip --no-lifecycle"
 
   - id: test
     description: Test execution + coverage via /sp:dev-unit.
@@ -81,7 +87,7 @@ states:
           timeoutMs: ${vars.stepTimeoutMs}
 
   - id: review
-    description: SECU code review via /sp:dev-review.
+    description: SECUA-framework code review via /sp:dev-review (Security, Efficiency, Correctness, Usability, Architecture).
     onEnter:
       - kind: agent.run
         options:

package/spur.js

@@ -50876,6 +50876,13 @@ var init_run_dao = __esm(() => {
                  metadata_json = json_set(COALESCE(NULLIF(metadata_json, ''), '{}'), '$.staleReason', ?2)
              WHERE id = ?3 AND status IN ('running', 'pending')`, nowIso, reason, runId);
     }
+    async setPid(runId, pid) {
+      await this.adapter.run("UPDATE runs SET pid = ? WHERE id = ?", pid, runId);
+    }
+    async getPid(runId) {
+      const row = await this.adapter.queryFirst("SELECT pid FROM runs WHERE id = ?", runId);
+      return row?.pid ?? null;
+    }
   };
 });
 
@@ -55315,7 +55322,9 @@ CREATE TABLE IF NOT EXISTS queue_jobs (
 );
 
 CREATE INDEX IF NOT EXISTS queue_jobs_ready_idx ON queue_jobs (status, next_retry_at, created_at);
-`, CLI_SCHEMA_SQL, CLI_MIGRATIONS, CLI_MIGRATION_FILE_MARKER = "_spur_cli_";
+`, CLI_SCHEMA_SQL, RUN_PID_COLUMN_SCHEMA_SQL = `
+ALTER TABLE runs ADD COLUMN pid INTEGER;
+`, CLI_MIGRATIONS, CLI_MIGRATION_FILE_MARKER = "_spur_cli_";
 var init_migrations = __esm(() => {
   init_dist7();
   init_dist8();
@@ -55341,7 +55350,8 @@ ${QUEUE_JOBS_SCHEMA_SQL}
     { id: "0001_spur_cli_team_inbox", sql: INBOX_MESSAGES_SCHEMA_SQL },
     { id: "0002_spur_cli_rule_history", sql: RULE_ENGINE_SCHEMA_SQL },
     { id: "0003_spur_cli_planning", sql: PLANNING_SCHEMA_SQL },
-    { id: "0004_spur_cli_queue_jobs", sql: QUEUE_JOBS_SCHEMA_SQL }
+    { id: "0004_spur_cli_queue_jobs", sql: QUEUE_JOBS_SCHEMA_SQL },
+    { id: "0005_spur_cli_run_pid", sql: RUN_PID_COLUMN_SCHEMA_SQL }
   ];
 });
 
@@ -57807,7 +57817,7 @@ class PlanningWriteService {
       const raw = await this.fs.readFile(ref.filePath);
       doc2 = MarkdownDocument.parse(raw, domain2);
     }
-    const currentStatus = doc2.frontmatterData?.status ?? "";
+    const currentStatus = normalizeStatusForDomain(doc2.frontmatterData?.status ?? "", domain2);
     const phantomsBefore = new Set(phantomSections(doc2, domain2));
     applyMutation(doc2, mutation);
     assertNoNewPhantomSections(doc2, domain2, phantomsBefore);
@@ -57823,7 +57833,7 @@ class PlanningWriteService {
         throw new Error(`Frontmatter validation failed for feature ${ref.id}: ${result.error.issues.map((i2) => i2.message).join("; ")}`);
       }
     }
-    const newStatus = doc2.frontmatterData?.status ?? "";
+    const newStatus = normalizeStatusForDomain(doc2.frontmatterData?.status ?? "", domain2);
     const statusChanged = mutation.kind === "transition" && newStatus !== currentStatus;
     let fromStatus;
     let toStatus;
@@ -57916,6 +57926,16 @@ function resolveEventName(kind, domain2, statusChanged) {
   }
   return domain2 === "task" ? "task.updated" : "feature.updated";
 }
+function normalizeStatusForDomain(status, domain2) {
+  if (!status)
+    return status;
+  const normalize = domain2 === "task" ? normalizeTaskStatus : normalizeFeatureStatus;
+  try {
+    return normalize(status);
+  } catch {
+    return status;
+  }
+}
 var init_planning_write_service = __esm(() => {
   init_src2();
 });
@@ -58461,6 +58481,51 @@ function isPlaceholderBody(body) {
   const stripped = body.replace(/<!--[\s\S]*?-->/g, "").replace(/^\s*>\s*TBD\s*$/gim, "").trim();
   return stripped.length === 0;
 }
+function hasPopulatedPriorityTable(body) {
+  for (const line of body.split(`
+`)) {
+    const cells = line.split("|");
+    if (cells.length < 3)
+      continue;
+    const severityIdx = cells.findIndex((c3) => /^\s*P[1-4]\s*$/.test(c3));
+    if (severityIdx === -1)
+      continue;
+    const hasContent = cells.some((c3, i2) => i2 !== severityIdx && c3.trim().length > 0);
+    if (hasContent)
+      return true;
+  }
+  return false;
+}
+function isReviewScaffold(body) {
+  if (isPlaceholderBody(body))
+    return true;
+  if (hasPopulatedPriorityTable(body))
+    return false;
+  let sawEmptyPRow = false;
+  for (const line of body.split(`
+`)) {
+    if (!line.includes("|"))
+      continue;
+    const cells = line.split("|").map((c3) => c3.trim());
+    const isSeparator = cells.every((c3) => c3 === "" || /^:?-+:?$/.test(c3));
+    const isEmptyPRow = cells.every((c3) => c3 === "" || /^P[1-4]$/.test(c3)) && cells.some((c3) => /^P[1-4]$/.test(c3));
+    const isHeader = cells.some((c3) => /severity|file|finding|recommendation/i.test(c3));
+    if (isEmptyPRow)
+      sawEmptyPRow = true;
+    else if (!isSeparator && !isHeader)
+      return false;
+  }
+  return sawEmptyPRow;
+}
+function isProseOnlyReview(body) {
+  if (isPlaceholderBody(body))
+    return true;
+  if (hasPopulatedPriorityTable(body))
+    return false;
+  const stripped = body.replace(/<!--[\s\S]*?-->/g, "");
+  return !stripped.split(`
+`).some((l) => l.includes("|"));
+}
 var TaskCheckService;
 var init_task_check = __esm(() => {
   init_src2();
@@ -58531,10 +58596,11 @@ var init_task_check = __esm(() => {
         }
       }
       const revBody = doc2.getSection("Review");
-      const revAllowed = (entry?.required ?? []).includes("Review") || (entry?.optional ?? []).includes("Review");
-      if (revBody !== null && !isPlaceholderBody(revBody) && revAllowed) {
-        const hasPColumn = /P[1-4]/.test(revBody);
-        if (!hasPColumn) {
+      const revRequired = (entry?.required ?? []).includes("Review");
+      const revAllowed = revRequired || (entry?.optional ?? []).includes("Review");
+      const revScaffoldTolerated = revRequired ? isPlaceholderBody(revBody ?? "") : isReviewScaffold(revBody ?? "") || isProseOnlyReview(revBody ?? "");
+      if (revBody !== null && !revScaffoldTolerated && revAllowed) {
+        if (!hasPopulatedPriorityTable(revBody)) {
           findings.push({
             layer: "L3",
             severity: "error",
@@ -58557,7 +58623,7 @@ var init_task_check = __esm(() => {
       }
       const planBody = doc2.getSection("Plan");
       if (planBody !== null && !isPlaceholderBody(planBody)) {
-        const isList = /^\s*[-*]\s|^\s*\d+\.\s/.test(planBody.trimStart());
+        const isList = /^\s*[-*]\s|^\s*\d+\.\s/m.test(planBody);
         const isTable2 = /\|/.test(planBody);
         if (!isList && !isTable2) {
           findings.push({
@@ -58599,7 +58665,7 @@ var init_task_check = __esm(() => {
           layer: "L4",
           severity: "warning",
           section: "",
-          message: "Missing feature_id \u2014 every task should reference a feature (one direction, DD-07)"
+          message: "Missing feature_id \u2014 every task should reference a feature (one direction, DD-07). To link: `spur task update <wbs> --feature <id>`, or use the sp:spur-dev feature-link helper."
         });
       }
       if (parentWbs && parentWbs.length > 0) {
@@ -60514,6 +60580,44 @@ var now = () => new Date().toISOString();
 import { access as access2, readdir as readdir3, readFile as readFile2, realpath, stat as stat2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { join as join11, resolve as resolve3 } from "path";
+function signalSubprocess(pid) {
+  try {
+    process.kill(-pid, "SIGTERM");
+    return true;
+  } catch {}
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function withSelfPidRecording(inner, db2) {
+  const stamp = async (runId) => {
+    try {
+      await new RunDao(db2).setPid(runId, process.pid);
+    } catch {}
+  };
+  return new Proxy(inner, {
+    get(target, prop, receiver) {
+      if (prop === "createRun") {
+        return async (record2) => {
+          await target.createRun(record2);
+          await stamp(record2.id);
+        };
+      }
+      if (prop === "createOrAttachRun") {
+        return async (record2) => {
+          const result = await target.createOrAttachRun(record2);
+          await stamp(result.id);
+          return result;
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
 
 class WorkflowAppService {
   ctx;
@@ -60562,7 +60666,7 @@ class WorkflowAppService {
     }
   }
   async run(file2, opts = {}) {
-    const svc = await this.createEngineService();
+    const svc = await this.createEngineService({ recordSelfPid: opts.recordSelfPid === true });
     const runId = opts.runId ?? crypto.randomUUID();
     const isDry = opts.dryRun === true;
     const result = await svc.runFile(file2, {
@@ -60628,6 +60732,21 @@ class WorkflowAppService {
       cleaned: stale.map((r) => ({ runId: r.id, startedAt: r.started_at }))
     };
   }
+  async cancel(runId) {
+    const db2 = await this.ctx.getDb();
+    const dao2 = new RunDao(db2);
+    const before = await dao2.traceRowById(runId);
+    if (!before) {
+      return { runId, finalized: false, status: "not_found", killed: false };
+    }
+    const isNonTerminal = before.status === "running" || before.status === "pending";
+    const pid = isNonTerminal ? await dao2.getPid(runId) : null;
+    const killed = pid != null ? signalSubprocess(pid) : false;
+    await dao2.finalizeStale(runId, "cancelled by operator (spur workflow cancel)");
+    const after = await dao2.traceRowById(runId);
+    const finalized = after?.status === "failed" && before.status !== "failed";
+    return { runId, finalized, status: after?.status ?? "not_found", killed };
+  }
   async continuePaused(runId) {
     const svc = await this.createEngineService();
     const run = await svc.listPausedRuns();
@@ -60751,7 +60870,7 @@ class WorkflowAppService {
     }
     return { run, events: events2 };
   }
-  async createEngineService() {
+  async createEngineService(opts = {}) {
     const host = createDefaultWorkflowEngineHost();
     registerSpurBuiltins(host, {
       agentService: this.ctx.agentService(),
@@ -60760,7 +60879,11 @@ class WorkflowAppService {
       httpRequester: this.ctx.httpRequester?.(),
       hostAllowlist: this.ctx.hostAllowlist?.()
     });
-    const persistence2 = new DbWorkflowPersistenceAdapter(await this.ctx.getDb());
+    const db2 = await this.ctx.getDb();
+    let persistence2 = new DbWorkflowPersistenceAdapter(db2);
+    if (opts.recordSelfPid === true) {
+      persistence2 = withSelfPidRecording(persistence2, db2);
+    }
     const bus = this.ctx.observabilityBus?.();
     const adapter = bus ? new ObservableWorkflowAdapter(persistence2, bus) : persistence2;
     return new WorkflowService(host, adapter);
@@ -68478,12 +68601,21 @@ function resolveSpurBin() {
 }
 
 // src/workflow/make-lifecycle-adapter.ts
+function resolveWorkflowPath(context3, profile) {
+  const bundledRoot = bundledConfigRoot();
+  if (bundledRoot !== null) {
+    const bundledPath = join12(bundledRoot, "workflows", `${profile.workflowName}.yaml`);
+    if (existsSync4(bundledPath))
+      return bundledPath;
+  }
+  const projectPath = join12(context3.cwd, ".spur", "workflows", `${profile.workflowName}.yaml`);
+  if (existsSync4(projectPath))
+    return projectPath;
+  return null;
+}
 function makeLifecycleAdapter(context3, profile) {
-  const root = bundledConfigRoot();
-  if (root === null)
-    return;
-  const workflowPath = join12(root, "workflows", `${profile.workflowName}.yaml`);
-  if (!existsSync4(workflowPath))
+  const workflowPath = resolveWorkflowPath(context3, profile);
+  if (workflowPath === null)
     return;
   const spurBin = resolveSpurBin();
   return new LifecycleAdapter({
@@ -68732,7 +68864,7 @@ import { join as join13, resolve as resolve4 } from "path";
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.2.8",
+  binaryVersion: "0.2.9",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -77985,6 +78117,18 @@ ${result.content}`);
           context3.output.write(`Set ${key}=${value2} on task ${result.ref.id}`);
         }
       } else if (status !== undefined) {
+        if (options.lifecycle !== false && (status === "done" || status === "testing")) {
+          const adapter = makeLifecycleAdapter(context3, TASK_LIFECYCLE_PROFILE);
+          if (adapter === undefined) {
+            context3.output.error(`warning: lifecycle adapter unavailable \u2014 running \`spur task check\` inline as the ${status} gate. ` + "Restore the bundled task-lifecycle workflow to re-enable the real guard.");
+            const ok = await runDoneGateCheck(context3, wbs, options.folder);
+            if (!ok) {
+              context3.output.error(`Lifecycle transition blocked: \`spur task check ${wbs}\` failed. Fix the findings before transitioning to ${status}.`);
+              context3.setExitCode(1);
+              return;
+            }
+          }
+        }
         const result = await svc.updateStatus(wbs, status);
         if (options.json) {
           context3.output.write(toJson2(result));
@@ -78280,6 +78424,18 @@ function loadTemplateBodies(projectRoot, variant) {
 async function makeCheckService(context3) {
   return new TaskCheckService(context3.fs, await loadSectionMatrix(context3.cwd));
 }
+async function runDoneGateCheck(context3, wbs, folderOverride) {
+  const foldersConfig = (await resolvePlanningFolders(context3.fs)).foldersConfig;
+  const tasksDir = folderOverride ?? context3.fs.resolve(foldersConfig.active_folder);
+  const entries = await context3.fs.readDir(tasksDir);
+  const fileName = entries.find((n2) => n2.startsWith(`${wbs}_`) && n2.endsWith(".md"));
+  if (!fileName) {
+    return false;
+  }
+  const svc = new TaskCheckService(context3.fs, await loadSectionMatrix(context3.cwd));
+  const result = await svc.check(`${tasksDir}/${fileName}`, wbs, { strict: false });
+  return result.pass;
+}
 async function loadSectionMatrix(projectRoot) {
   const localPath = join18(projectRoot, ".spur", "tasks", "section-matrix.yaml");
   if (existsSync5(localPath)) {
@@ -78363,6 +78519,7 @@ init_src3();
 init_loader();
 init_dist7();
 init_dist5();
+import { spawn as spawn2 } from "child_process";
 import { resolve as resolve5 } from "path";
 function parseVars(raw2) {
   if (raw2 === undefined) {
@@ -78424,7 +78581,7 @@ ${result.errors.map((m) => `  - ${m}`).join(`
       const spurParts = resolveSpurBin().split(" ");
       const spurBin = spurParts[0] ?? process.execPath;
       const spurArgs = spurParts.slice(1);
-      const cmd = [spurBin, ...spurArgs, "workflow", "run", file2, "--run-id", runId];
+      const cmd = [...spurArgs, "workflow", "run", file2, "--run-id", runId];
       if (options.vars) {
         cmd.push("--vars", options.vars);
       }
@@ -78432,11 +78589,12 @@ ${result.errors.map((m) => `  - ${m}`).join(`
         cmd.push("--dry-run");
       }
       try {
-        Bun.spawn({
-          cmd,
-          stdio: ["ignore", "ignore", "ignore"],
-          env: process.env
-        }).unref();
+        const child = spawn2(spurBin, cmd, {
+          stdio: "ignore",
+          detached: true,
+          env: { ...process.env, SPUR_ASYNC_WORKER: "1" }
+        });
+        child.unref();
       } catch {
         const result2 = await makeSvc(options.json).run(file2, {
           runId,
@@ -78476,7 +78634,8 @@ Monitor with: spur workflow trace ${runId}`);
     const result = await makeSvc(options.json, bus).run(file2, {
       runId: options.runId || undefined,
       vars,
-      dryRun: options.dryRun || undefined
+      dryRun: options.dryRun || undefined,
+      recordSelfPid: process.env.SPUR_ASYNC_WORKER === "1"
     });
     context3.output.write(options.json ? toJson2(result) : `workflow ${result.status}: ${result.workflowName} -> ${result.finalState}`);
     context3.setExitCode(result.status === "done" ? 0 : 1);
@@ -78516,7 +78675,7 @@ Monitor with: spur workflow trace ${runId}`);
       context3.setExitCode(1);
     }
   });
-  workflow.command("clean").description("Finalize orphaned runs stuck in running/pending past a staleness threshold (mark as failed).").option("--older-than <minutes>", "Staleness threshold in minutes", "30").option("--force", "Clean ALL non-terminal runs regardless of age (overrides --older-than)").option("--dry-run", "List what would be cleaned without writing").option("--json", "Output machine-readable JSON where supported").action(async (options) => {
+  workflow.command("clean").description("Finalize orphaned runs stuck in running/pending past a staleness threshold (mark as failed). " + "To cancel a single live run by id, use `spur workflow cancel <run-id>` instead.").option("--older-than <minutes>", "Staleness threshold in minutes", "30").option("--force", "Clean ALL non-terminal runs regardless of age (overrides --older-than)").option("--dry-run", "List what would be cleaned without writing").option("--json", "Output machine-readable JSON where supported").action(async (options) => {
     const force = options.force === true;
     const minutes = force ? 0 : Number.parseInt(options.olderThan ?? "30", 10);
     if (!Number.isFinite(minutes) || minutes < 0) {
@@ -78540,6 +78699,24 @@ Monitor with: spur workflow trace ${runId}`);
       }
     }
   });
+  workflow.command("cancel").description("Cancel a single non-terminal run by id (mark as failed). The bulk/stale variant is `spur workflow clean`.").argument("<run-id>", "Run id to cancel").option("--json", "Output machine-readable JSON where supported").action(async (runId, options) => {
+    const result = await makeSvc(options.json).cancel(runId);
+    if (options.json) {
+      context3.output.write(toJson2(result));
+      return;
+    }
+    if (result.status === "not_found") {
+      context3.output.error(`Run ${runId} not found.`);
+      context3.setExitCode(1);
+      return;
+    }
+    if (result.finalized) {
+      const killNote = result.killed ? " + signalled worker process group" : "";
+      context3.output.write(`Cancelled run ${runId} (marked failed${killNote}).`);
+    } else {
+      context3.output.write(`Run ${runId} already terminal (${result.status}) \u2014 no change.`);
+    }
+  });
   workflow.command("list").description("List available workflow YAML files.").option("--json", "Output machine-readable JSON where supported").action(async (options) => {
     const paths = await resolveWorkflowPaths(context3.cwd);
     const result = await makeSvc().list(paths);