@lchase/yak 0.4.1 → 0.6.0

package/README.md

@@ -42,7 +42,9 @@ bug) for a guided walkthrough — also live at
   rather than failing it. `yak pending` lists every run across the repo
   awaiting a human answer; `yak resume <run-id>` replays and continues;
   `--interactive` prompts through open gates inline instead of exiting to
-  resume later.
+  resume later. `yak cancel <run-id>` terminates a live run's process tree
+  and journals a clean `failed`/`cancelled` terminal state, so any
+  out-of-process supervisor has a supported kill.
 - **Worktree isolation:** `yak run --isolation worktree` runs the whole
   workflow inside a fresh git worktree; `map` steps can additionally
   isolate each item into its own sibling worktree.

package/dist/index.js

@@ -100,6 +100,16 @@ function inputNamesOf(step) {
 function dependenciesOf(step, producerOf) {
   return inputNamesOf(step).map((need) => producerOf.get(need)).filter((id) => id !== void 0);
 }
+function earlierProducerIds(step, posIndex, producerOf, order) {
+  const deps = [];
+  for (const name of inputNamesOf(step)) {
+    const producerId = producerOf.get(name);
+    if (producerId === void 0) continue;
+    const producerPos = order.get(producerId);
+    if (producerPos !== void 0 && producerPos < posIndex) deps.push(producerId);
+  }
+  return deps;
+}
 function flattenSteps(steps) {
   const result = [];
   for (const step of steps) {
@@ -191,6 +201,7 @@ var rawStepSchema = z2.lazy(
     loop: z2.object({
       until: rawExprSchema,
       budget: rawBudgetSchema,
+      concurrency: z2.number().int().positive().optional(),
       onExhausted: z2.enum(["suspend", "fail", "continue"]).optional(),
       freshContext: z2.boolean().optional(),
       body: z2.array(rawStepSchema)
@@ -281,6 +292,7 @@ function normalizeStep(raw) {
       body: raw.loop.body.map(normalizeStep),
       until: raw.loop.until,
       budget: raw.loop.budget,
+      concurrency: raw.loop.concurrency ?? 1,
       onExhausted: raw.loop.onExhausted ?? "suspend",
       freshContext: raw.loop.freshContext ?? true,
       ...raw.produces !== void 0 ? { produces: raw.produces } : {}
@@ -331,14 +343,76 @@ import { promisify } from "util";
 // src/expr/template.ts
 import jexl from "jexl";
 var PLACEHOLDER_RE = /\{\{\s*([^}]+?)\s*\}\}/g;
+var IDENTIFIER = /[A-Za-z_$][A-Za-z0-9_$]*/y;
+var NOT_A_ROOT = /* @__PURE__ */ new Set(["true", "false", "in"]);
 function extractTemplateRoots(template) {
-  const roots = /* @__PURE__ */ new Set();
+  const roots = [];
+  const seen = /* @__PURE__ */ new Set();
   for (const match of template.matchAll(PLACEHOLDER_RE)) {
-    const expr = match[1].trim();
-    const root = expr.split(/[.[]/, 1)[0];
-    if (root) roots.add(root);
+    for (const ident of identifiersInExpr(match[1])) {
+      if (seen.has(ident)) continue;
+      seen.add(ident);
+      roots.push(ident);
+    }
+  }
+  return roots;
+}
+function identifiersInExpr(expr) {
+  const found = [];
+  let prev = "other";
+  let i = 0;
+  while (i < expr.length) {
+    const c = expr[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      i = skipString(expr, i);
+      prev = "other";
+      continue;
+    }
+    if (c === "|" && expr[i + 1] === "|") {
+      i += 2;
+      prev = "other";
+      continue;
+    }
+    if (c === "|") {
+      i++;
+      prev = "pipe";
+      continue;
+    }
+    if (c === ".") {
+      i++;
+      prev = "dot";
+      continue;
+    }
+    IDENTIFIER.lastIndex = i;
+    const ident = IDENTIFIER.exec(expr);
+    if (ident && ident.index === i) {
+      const name = ident[0];
+      if (prev !== "dot" && prev !== "pipe" && !NOT_A_ROOT.has(name)) found.push(name);
+      i += name.length;
+      prev = "other";
+      continue;
+    }
+    i++;
+    prev = "other";
   }
-  return [...roots];
+  return found;
+}
+function skipString(expr, start) {
+  const quote = expr[start];
+  let i = start + 1;
+  while (i < expr.length) {
+    if (expr[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (expr[i] === quote) return i + 1;
+    i++;
+  }
+  return i;
 }
 async function renderTemplate(template, inputs) {
   let result = "";
@@ -483,6 +557,7 @@ var KNOWN_AGENT_TOOLS = /* @__PURE__ */ new Set([
 async function validateWorkflow(workflow, cwd = process.cwd(), runIsolation = "none") {
   const flatSteps = flattenSteps(workflow.steps);
   checkKnownKinds(flatSteps);
+  checkLoopBodyKinds(workflow.steps);
   checkDuplicateIds(flatSteps);
   const producerOf = buildProducerMap(workflow.steps);
   checkReservedArtifactNames(flatSteps);
@@ -495,6 +570,7 @@ async function validateWorkflow(workflow, cwd = process.cwd(), runIsolation = "n
   await checkAgentPromptPlaceholders(flatSteps, cwd);
   checkSessionChainDepth(flatSteps);
   checkMapIsolation(workflow.steps, runIsolation);
+  checkLoopParallelWriters(workflow.steps);
   await checkGateSchemaKeys(flatSteps, cwd);
   await checkGateRenderPlaceholders(flatSteps, cwd);
   checkSandboxImage(flatSteps);
@@ -547,6 +623,83 @@ function checkMapIsolation(steps, runIsolation) {
     checkMapIsolation([step.step], runIsolation);
   }
 }
+var UNSUPPORTED_LOOP_BODY_KINDS = /* @__PURE__ */ new Set(["map", "loop", "gate"]);
+function checkLoopBodyKinds(steps) {
+  for (const step of steps) {
+    if (step.kind === "map") {
+      checkLoopBodyKinds([step.step]);
+      continue;
+    }
+    if (step.kind !== "loop") continue;
+    for (const bodyStep of step.body) {
+      if (UNSUPPORTED_LOOP_BODY_KINDS.has(bodyStep.kind)) {
+        throw new WorkflowValidationError(
+          `step "${bodyStep.id}": kind "${bodyStep.kind}" not supported inside a loop body in M3`
+        );
+      }
+    }
+    checkLoopBodyKinds(step.body);
+  }
+}
+function checkLoopParallelWriters(steps) {
+  for (const step of steps) {
+    if (step.kind === "loop") {
+      warnParallelWriteCapableBody(step);
+      checkLoopParallelWriters(step.body);
+    } else if (step.kind === "map") {
+      checkLoopParallelWriters([step.step]);
+    }
+  }
+}
+function writeCapableTool(step) {
+  if (step.kind !== "agent") return void 0;
+  return (step.tools ?? []).find((tool) => WRITE_CAPABLE_TOOLS.has(tool));
+}
+function waitsOn(step, targetId, stepsById, producerOf, order) {
+  const seen = /* @__PURE__ */ new Set();
+  const startPos = order.get(step.id);
+  if (startPos === void 0) return false;
+  const stack = earlierProducerIds(step, startPos, producerOf, order);
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (id === void 0 || seen.has(id)) continue;
+    if (id === targetId) return true;
+    seen.add(id);
+    const pred = stepsById.get(id);
+    const predPos = order.get(id);
+    if (!pred || predPos === void 0) continue;
+    stack.push(...earlierProducerIds(pred, predPos, producerOf, order));
+  }
+  return false;
+}
+function warnParallelWriteCapableBody(loop) {
+  const concurrency = loop.concurrency ?? 1;
+  if (concurrency <= 1 || loop.body.length < 2) return;
+  const order = new Map(loop.body.map((bodyStep, index) => [bodyStep.id, index]));
+  const stepsById = new Map(loop.body.map((bodyStep) => [bodyStep.id, bodyStep]));
+  const producerOf = buildProducerMap(loop.body);
+  const warned = /* @__PURE__ */ new Set();
+  for (let i = 0; i < loop.body.length; i++) {
+    for (let j = i + 1; j < loop.body.length; j++) {
+      const earlier = loop.body[i];
+      const later = loop.body[j];
+      if (!earlier || !later) continue;
+      if (waitsOn(later, earlier.id, stepsById, producerOf, order)) continue;
+      for (const bodyStep of [earlier, later]) {
+        if (warned.has(bodyStep.id)) continue;
+        const tool = writeCapableTool(bodyStep);
+        const command = bodyStep.kind === "command";
+        if (!tool && !command) continue;
+        const why = command ? "is a command step" : `declares write-capable tool "${tool}"`;
+        const fix = command ? "use concurrency: 1" : "use concurrency: 1 or drop the write-capable tool";
+        console.warn(
+          `step "${loop.id}": concurrency ${concurrency} runs body steps "${earlier.id}" and "${later.id}" in parallel, and "${bodyStep.id}" ${why} \u2014 concurrent body steps share one cwd and may race; ${fix}`
+        );
+        warned.add(bodyStep.id);
+      }
+    }
+  }
+}
 function checkAgentToolNames(steps) {
   for (const step of steps) {
     if (step.kind !== "agent") continue;
@@ -606,17 +759,17 @@ function checkNeedsSatisfied(steps, producerOf) {
 function checkNoCycles(steps, producerOf) {
   const stepsById = new Map(steps.map((s) => [s.id, s]));
   const state = /* @__PURE__ */ new Map();
-  function visit(step, path21) {
+  function visit(step, path22) {
     const mark = state.get(step.id);
     if (mark === "done") return;
     if (mark === "visiting") {
-      const cycle = [...path21, step.id].join(" -> ");
+      const cycle = [...path22, step.id].join(" -> ");
       throw new WorkflowValidationError(`cycle detected: ${cycle}`);
     }
     state.set(step.id, "visiting");
     for (const depId of dependenciesOf(step, producerOf)) {
       const dep = stepsById.get(depId);
-      if (dep) visit(dep, [...path21, step.id]);
+      if (dep) visit(dep, [...path22, step.id]);
     }
     state.set(step.id, "done");
   }
@@ -1038,7 +1191,7 @@ async function createWorktree(repoRoot, branchName, baseRef, worktreePath) {
 
 // src/engine/scheduler.ts
 import path14 from "path";
-import pLimit2 from "p-limit";
+import pLimit3 from "p-limit";
 import { z as z8 } from "zod";
 
 // src/adapters/claude-code.ts
@@ -1534,6 +1687,8 @@ function runCommandStep(step, cwd, extraEnv) {
 }
 
 // src/steps/loop.ts
+import assert from "assert/strict";
+import pLimit from "p-limit";
 import { z as z6 } from "zod";
 
 // src/engine/cache.ts
@@ -1652,11 +1807,28 @@ async function runLoopStep(step, ctx) {
     return "failed";
   }
   const resumeFrom = ctx.loopContinuation?.action === "continue" ? await buildResumeFrom(step, ctx) : void 0;
-  const status = await runLoopBody(step, ctx, resumeFrom);
-  if (status === "ok") {
-    await appendJournalEvent(ctx.runDir, ctx.runId, { t: "step.completed", stepId: step.id, cached: false });
+  const result = await runLoopBody(step, ctx, resumeFrom);
+  if (result.status === "ok") {
+    let artifact;
+    if (step.produces) {
+      const written = await writeArtifact(ctx.runDir, step.produces, result.untilContext, z6.unknown());
+      artifact = { name: step.produces, hash: written.hash };
+      ctx.outerArtifactHashes.set(step.produces, written.hash);
+      await appendJournalEvent(ctx.runDir, ctx.runId, {
+        t: "artifact.written",
+        name: step.produces,
+        hash: written.hash,
+        bytes: written.bytes
+      });
+    }
+    await appendJournalEvent(ctx.runDir, ctx.runId, {
+      t: "step.completed",
+      stepId: step.id,
+      ...artifact ? { artifact: artifact.name, artifactHash: artifact.hash } : {},
+      cached: false
+    });
   }
-  return status;
+  return result.status;
 }
 async function buildResumeFrom(step, ctx) {
   const events = await readJournal(ctx.runDir);
@@ -1692,22 +1864,18 @@ async function runLoopBody(step, ctx, resumeFrom) {
     const thisValues = /* @__PURE__ */ new Map();
     const thisHashes = /* @__PURE__ */ new Map();
     try {
-      for (const [posIndex, bodyStep] of step.body.entries()) {
-        await runOneBodyStep({
-          bodyStep,
-          posIndex,
-          iteration,
-          ctx,
-          localProducerOf,
-          bodyOrderIndex,
-          priorValues,
-          priorHashes,
-          thisValues,
-          thisHashes,
-          freshContext: step.freshContext ?? true,
-          bodySessionIds
-        });
-      }
+      await runLoopRound({
+        step,
+        iteration,
+        ctx,
+        localProducerOf,
+        bodyOrderIndex,
+        priorValues,
+        priorHashes,
+        thisValues,
+        thisHashes,
+        bodySessionIds
+      });
     } catch (err) {
       if (err instanceof CommandStepFailedError || err instanceof AgentStepFailedError) {
         await appendJournalEvent(ctx.runDir, ctx.runId, {
@@ -1719,12 +1887,12 @@ async function runLoopBody(step, ctx, resumeFrom) {
             recoverable: false
           }
         });
-        return "failed";
+        return { status: "failed" };
       }
       throw err;
     }
     const untilContext = Object.fromEntries(thisValues);
-    if (await evalExpr(step.until, untilContext, ctx.cwd)) return "ok";
+    if (await evalExpr(step.until, untilContext, ctx.cwd)) return { status: "ok", untilContext };
     let tripped;
     if (step.budget.noProgress) {
       lastSignal = await evalExpr(step.budget.noProgress.signal, untilContext, ctx.cwd);
@@ -1743,7 +1911,10 @@ async function runLoopBody(step, ctx, resumeFrom) {
       const tokensTotal = await sumBodyTokens(ctx.runDir, bodyStepIds);
       if (tokensTotal >= step.budget.maxTokens) tripped = "maxTokens";
     }
-    if (tripped) return await handleExhausted(step, ctx, iteration, tripped);
+    if (tripped) {
+      const outcome = await handleExhausted(step, ctx, iteration, tripped);
+      return outcome === "ok" ? { status: "ok", untilContext } : { status: outcome };
+    }
     priorValues = thisValues;
     priorHashes = thisHashes;
   }
@@ -1788,6 +1959,80 @@ async function handleExhausted(step, ctx, iteration, tripped) {
   await writeLoopExhaustedRequest(ctx.runDir, ctx.runId, step.id, iteration, tripped);
   return "suspended";
 }
+async function runLoopRound(args) {
+  const {
+    step,
+    iteration,
+    ctx,
+    localProducerOf,
+    bodyOrderIndex,
+    priorValues,
+    priorHashes,
+    thisValues,
+    thisHashes,
+    bodySessionIds
+  } = args;
+  const cap = Math.min(step.concurrency ?? 1, ctx.globalConcurrency);
+  const limit = pLimit(cap);
+  const remaining = new Set(step.body.map((bodyStep) => bodyStep.id));
+  const completed = /* @__PURE__ */ new Set();
+  const inFlight = /* @__PURE__ */ new Map();
+  let firstError;
+  const thisRoundDeps = (bodyStep, posIndex) => earlierProducerIds(bodyStep, posIndex, localProducerOf, bodyOrderIndex);
+  const launchEligible = () => {
+    if (firstError !== void 0) return;
+    for (const [posIndex, bodyStep] of step.body.entries()) {
+      if (!remaining.has(bodyStep.id) || inFlight.has(bodyStep.id)) continue;
+      const ready = thisRoundDeps(bodyStep, posIndex).every((dep) => completed.has(dep));
+      if (!ready) {
+        if (cap === 1) break;
+        continue;
+      }
+      inFlight.set(
+        bodyStep.id,
+        limit(async () => {
+          if (firstError !== void 0) return "skipped";
+          try {
+            await runOneBodyStep({
+              bodyStep,
+              posIndex,
+              iteration,
+              ctx,
+              localProducerOf,
+              bodyOrderIndex,
+              priorValues,
+              priorHashes,
+              thisValues,
+              thisHashes,
+              freshContext: step.freshContext ?? true,
+              bodySessionIds
+            });
+            return "ok";
+          } catch (err) {
+            if (firstError === void 0) firstError = err;
+            return "error";
+          }
+        })
+      );
+    }
+  };
+  launchEligible();
+  while (inFlight.size > 0) {
+    const [doneId, status] = await Promise.race(
+      [...inFlight.entries()].map(async ([id, p]) => [id, await p])
+    );
+    inFlight.delete(doneId);
+    remaining.delete(doneId);
+    if (status === "ok") completed.add(doneId);
+    launchEligible();
+  }
+  if (firstError !== void 0) throw firstError;
+  assert.equal(
+    remaining.size,
+    0,
+    `loop "${step.id}" stalled: body step(s) [${[...remaining].join(", ")}] never became eligible`
+  );
+}
 async function runOneBodyStep(args) {
   const {
     bodyStep,
@@ -1903,7 +2148,7 @@ async function runBodyStepKind(bodyStep, inputs, ctx, iteration, freshContext, b
 
 // src/steps/map.ts
 import path13 from "path";
-import pLimit from "p-limit";
+import pLimit2 from "p-limit";
 import { z as z7 } from "zod";
 var RETRY_ATTEMPTS = 2;
 async function runMapStep(step, ctx) {
@@ -1917,7 +2162,7 @@ async function runMapStep(step, ctx) {
     await commitAllIfDirty(ctx.cwd, `yak: checkpoint before map ${step.id}`);
   }
   const items = await readArtifactRaw(ctx.runDir, step.over);
-  const limit = pLimit(Math.min(step.concurrency ?? 4, ctx.globalConcurrency));
+  const limit = pLimit2(Math.min(step.concurrency ?? 4, ctx.globalConcurrency));
   const results = new Array(items.length);
   let anyFailed = false;
   await Promise.all(
@@ -2122,7 +2367,7 @@ function trustResumedSteps(remaining, producerOf, resumeState, completed, artifa
   }
 }
 async function runEligibleSteps(workflow, ctx, resumeState) {
-  const limit = pLimit2(ctx.concurrency ?? DEFAULT_CONCURRENCY);
+  const limit = pLimit3(ctx.concurrency ?? DEFAULT_CONCURRENCY);
   const producerOf = buildProducerMap(workflow.steps);
   const remaining = new Map(workflow.steps.map((s) => [s.id, s]));
   const completed = /* @__PURE__ */ new Set();
@@ -2188,6 +2433,7 @@ async function runStep(step, ctx, artifactHashes, workflowName, agentSessionIds)
       semanticKey: semanticKey2,
       definitionKey: definitionKey2,
       outerArtifactHashes: artifactHashes,
+      globalConcurrency: ctx.concurrency ?? DEFAULT_CONCURRENCY,
       buildAdapter: (step2, iteration) => buildAdapter(ctx.adapter, ctx, workflowName, step2, iteration),
       loopContinuation: ctx.loopContinuations?.get(step.id)
     });
@@ -2398,6 +2644,7 @@ async function executeWorkflowFile(workflowPath, opts = {}) {
     inputHash: inputWritten?.hash ?? sha256(JSON.stringify(workflow)),
     adapter,
     isolation,
+    pid: process.pid,
     ...opts.tag !== void 0 ? { tag: opts.tag } : {}
   });
   if (inputWritten) {
@@ -2486,6 +2733,7 @@ async function resumeRun(runId, opts = {}) {
   const { runsDir, cwd, cacheDir } = resolveDirs(opts.runsDir, opts.cwd, opts.cacheDir);
   const runDir = path15.join(runsDir, runId);
   const workflow = await readRunWorkflow(runDir);
+  await appendJournalEvent(runDir, runId, { t: "run.resumed", pid: process.pid });
   let events = await readJournal(runDir);
   const loopContinuations = await resolveOpenRequests(runId, runDir, workflow, cwd, events);
   events = await readJournal(runDir);
@@ -2549,6 +2797,99 @@ async function artifactsCommand(runId, opts = {}) {
   return 0;
 }
 
+// src/engine/cancel.ts
+import path17 from "path";
+var SIGKILL_GRACE_MS = 5e3;
+var LIVENESS_POLL_MS = 100;
+var LIVENESS_POLLS = Math.ceil(SIGKILL_GRACE_MS / LIVENESS_POLL_MS);
+var realSignal = (pid, signal) => {
+  process.kill(pid, signal);
+};
+function livePidFromJournal(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event?.t === "run.resumed") return event.pid;
+  }
+  const started = events.find((e) => e.t === "run.started");
+  return started?.t === "run.started" ? started.pid : void 0;
+}
+function isAlive(signal, pid) {
+  try {
+    signal(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function terminateProcessTree(signal, sleep, pid) {
+  if (!isAlive(signal, pid)) return "not-running";
+  try {
+    signal(-pid, "SIGTERM");
+  } catch {
+    try {
+      signal(pid, "SIGTERM");
+    } catch {
+      return "sigterm";
+    }
+  }
+  for (let poll = 0; poll < LIVENESS_POLLS; poll++) {
+    if (!isAlive(signal, pid)) return "sigterm";
+    await sleep(LIVENESS_POLL_MS);
+  }
+  if (!isAlive(signal, pid)) return "sigterm";
+  try {
+    signal(-pid, "SIGKILL");
+  } catch {
+    try {
+      signal(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  return "sigkill";
+}
+async function cancelRun(runId, opts = {}) {
+  const runsDir = opts.runsDir ?? defaultRunsDir();
+  const signal = opts.signal ?? realSignal;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const runDir = path17.join(runsDir, runId);
+  const events = await readJournal(runDir);
+  if (!events.some((e) => e.t === "run.started")) return { status: "not-found", runId };
+  const last = events.at(-1);
+  if (last?.t === "run.finished") {
+    return { status: "already-terminal", runId, finishedStatus: last.status };
+  }
+  const pid = livePidFromJournal(events);
+  const signalled = pid === void 0 ? "no-pid" : await terminateProcessTree(signal, sleep, pid);
+  const settled = (await readJournal(runDir)).at(-1);
+  if (settled?.t === "run.finished") {
+    return { status: "already-terminal", runId, finishedStatus: settled.status };
+  }
+  await appendJournalEvent(runDir, runId, {
+    t: "run.finished",
+    status: "failed",
+    reason: "cancelled"
+  });
+  return { status: "cancelled", runId, signalled };
+}
+
+// src/cli/commands/cancel.ts
+async function cancelCommand(runId, opts = {}) {
+  const outcome = await cancelRun(runId, { runsDir: opts.runsDir });
+  switch (outcome.status) {
+    case "not-found":
+      console.error(`run ${runId} not found`);
+      return 1;
+    case "already-terminal":
+      console.log(`run ${runId} already finished: ${outcome.finishedStatus} \u2014 nothing to cancel`);
+      return 0;
+    case "cancelled": {
+      const note = outcome.signalled === "no-pid" ? " (no pid recorded \u2014 marked cancelled without signalling)" : outcome.signalled === "not-running" ? " (process already gone \u2014 marked cancelled)" : outcome.signalled === "sigkill" ? " (SIGKILL after grace period)" : "";
+      console.log(`run ${runId} cancelled${note}`);
+      return 0;
+    }
+  }
+}
+
 // src/cli/commands/graph.ts
 async function graphCommand(workflowPath) {
   const raw = await loadWorkflowYaml(workflowPath);
@@ -2559,13 +2900,13 @@ async function graphCommand(workflowPath) {
 
 // src/cli/commands/pending.ts
 import { readdir as readdir3 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 async function pendingCommand(opts = {}) {
   const runsDir = opts.runsDir ?? defaultRunsDir();
   const runIds = (await readdir3(runsDir).catch(() => [])).sort();
   let anyPending = false;
   for (const runId of runIds) {
-    const runDir = path17.join(runsDir, runId);
+    const runDir = path18.join(runsDir, runId);
     const events = await readJournal(runDir);
     const last = events.at(-1);
     if (!last || last.t !== "run.finished" || last.status !== "suspended") continue;
@@ -2669,7 +3010,7 @@ async function resumeCommand(runId, adapter) {
 }
 
 // src/cli/commands/run.ts
-import path18 from "path";
+import path19 from "path";
 import { cancel, intro, log, outro } from "@clack/prompts";
 
 // src/cli/interactive.ts
@@ -2799,7 +3140,7 @@ ${text2}
 async function runCommand(workflowPath, opts = {}) {
   let result;
   try {
-    result = await executeWorkflowFile(path18.resolve(workflowPath), {
+    result = await executeWorkflowFile(path19.resolve(workflowPath), {
       adapter: opts.adapter,
       isolation: opts.isolation,
       input: opts.input,
@@ -2839,7 +3180,7 @@ async function runCommand(workflowPath, opts = {}) {
 }
 
 // src/cli/commands/status.ts
-import path19 from "path";
+import path20 from "path";
 async function statusCommand(runId, opts = {}) {
   const runsDir = opts.runsDir ?? defaultRunsDir();
   const resolvedRunId = runId ?? await findLatestRunId(runsDir);
@@ -2847,7 +3188,7 @@ async function statusCommand(runId, opts = {}) {
     console.error("no runs found");
     return 1;
   }
-  const runDir = path19.join(runsDir, resolvedRunId);
+  const runDir = path20.join(runsDir, resolvedRunId);
   const workflow = await readRunWorkflow(runDir).catch(() => void 0);
   if (!workflow) {
     console.error(`run ${resolvedRunId} not found`);
@@ -2873,7 +3214,7 @@ async function statusCommand(runId, opts = {}) {
 }
 
 // src/cli/commands/watch.ts
-import path20 from "path";
+import path21 from "path";
 import { render } from "ink";
 import React2 from "react";
 
@@ -2933,7 +3274,7 @@ async function watchCommand(runId, opts = {}) {
     console.error("no runs found");
     return 1;
   }
-  const runDir = path20.join(runsDir, resolvedRunId);
+  const runDir = path21.join(runsDir, resolvedRunId);
   const workflow = await readRunWorkflow(runDir).catch(() => void 0);
   if (!workflow) {
     console.error(`run ${resolvedRunId} not found`);
@@ -3010,6 +3351,9 @@ program.command("run").description("Run a workflow YAML file").argument("<workfl
 program.command("resume").description("Resume an interrupted run").argument("<run-id>", "id of the run to resume").option("--adapter <adapter>", "must match the adapter the run started with, if given").action(async (runId, options) => {
   process.exitCode = await resumeCommand(runId, options.adapter ? requireAdapterId(options.adapter) : void 0);
 });
+program.command("cancel").description("Terminate a live run and journal a clean 'cancelled' terminal state").argument("<run-id>", "id of the run to cancel").action(async (runId) => {
+  process.exitCode = await cancelCommand(runId);
+});
 program.command("status").description("Report a run's per-step status").argument("[run-id]", "id of the run to report on (default: most recent)").action(async (runId) => {
   process.exitCode = await statusCommand(runId);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lchase/yak",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "An agentic workflow engine",
   "license": "MIT",
   "type": "module",