akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/workflows/authoring/authoring.js

@@ -4,109 +4,78 @@
 import fs from "node:fs";
 import path from "node:path";
 import workflowTemplate from "../../assets/workflows/workflow-template.md" with { type: "text" };
-import { isWithin, resolveStashDir } from "../../core/common.js";
+import { ensureAkmMarkdownType } from "../../core/asset/akm-markdown.js";
+import { makeBundleRef } from "../../core/asset/asset-ref.js";
+import { isWithin, writeFileAtomic } from "../../core/common.js";
+import { loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
+import { defaultBundleForTarget } from "../../core/mutation-target.js";
 import { canonicalizeWorkflowName, WORKFLOW_EXTENSIONS } from "../../core/recognition-util.js";
 import { warn } from "../../core/warn.js";
-import { compileWorkflowProgram } from "../ir/compile.js";
+import { prepareWriteTargetForMutation, resolveWriteTarget, withWriteTargetMutation } from "../../core/write-source.js";
+import { compileWorkflowPlan } from "../ir/compile.js";
 import { parseWorkflow } from "../parser.js";
-import { parseWorkflowProgram } from "../program/parser.js";
-import workflowProgramTemplate from "./workflow-program-template.yaml" with { type: "text" };
-const DEFAULT_WORKFLOW_TEMPLATE = renderWorkflowTemplate({
-    title: "Example Workflow",
-    firstStepTitle: "First Step",
-    firstStepId: "first-step",
-});
+const DEFAULT_WORKFLOW_TEMPLATE = renderWorkflowTemplate("New Workflow");
 export function getWorkflowTemplate() {
     return DEFAULT_WORKFLOW_TEMPLATE;
 }
-/**
- * Minimal valid YAML workflow *program* (redesign addendum, R1), printed by
- * `akm workflow template --yaml`. Kept as an external asset file per the repo
- * convention (see `workflow-program-template.yaml` next to this module);
- * `tests/workflows/program-assets.test.ts` pins that it parses AND compiles.
- */
-export function getWorkflowProgramTemplate() {
-    return workflowProgramTemplate;
-}
 export function buildWorkflowTemplate(name) {
     if (!name)
         return DEFAULT_WORKFLOW_TEMPLATE;
-    const title = humanizeWorkflowName(name);
-    const stepId = slugifyWorkflowStepId(name);
-    const customized = renderWorkflowTemplate({
-        title,
-        firstStepTitle: `${title} Setup`,
-        firstStepId: `${stepId}-setup`,
-    });
-    const result = parseWorkflow(customized, { path: `<template:${name}>` });
-    if (!result.ok) {
-        throw new UsageError(formatWorkflowErrors(`<template:${name}>`, result.errors));
-    }
+    // Only the H1 is customized. Step ids are STRUCTURAL under the unified format
+    // — each appears in `steps[].id`, as a body `## <id>` heading, and possibly in
+    // another step's `inputs:` — so rewriting them from a name would have to patch
+    // three places consistently to stay parseable. Generic `first-step`/
+    // `second-step` are the author's to rename.
+    const customized = renderWorkflowTemplate(humanizeWorkflowName(name));
+    validateWorkflowContent(customized, `<template:${name}>`);
     return customized;
 }
-/**
- * Customize the shipped YAML program template ({@link getWorkflowProgramTemplate})
- * for a named workflow: swap the placeholder `name:` for the workflow's slug so
- * a freshly created `.yaml`/`.yml` asset round-trips through the program parser
- * (its `title` becomes the slug). Parses AND compiles the result — mirroring
- * {@link buildWorkflowTemplate} — so a create never writes an asset that
- * `show`/`start`/`validate` would then reject.
- */
-export function buildWorkflowProgramTemplate(name) {
-    if (!name)
-        return workflowProgramTemplate;
-    const programName = slugifyWorkflowStepId(name);
-    const customized = workflowProgramTemplate.replace(/^name:.*$/m, `name: ${programName}`);
-    const parsed = parseWorkflowProgram(customized, { path: `<template:${name}>` });
-    if (!parsed.ok) {
-        throw new UsageError(formatWorkflowErrors(`<template:${name}>`, parsed.errors));
+/** Parse AND compile `content`, so a create never writes an asset that `show`/`start`/`validate` would then reject. */
+function validateWorkflowContent(content, sourcePath) {
+    const result = parseWorkflow(content, { path: sourcePath });
+    if (!result.ok) {
+        throw new UsageError(formatWorkflowErrors(sourcePath, result.errors));
     }
-    const compiled = compileWorkflowProgram(parsed.program);
+    const compiled = compileWorkflowPlan(result.document, slugifyWorkflowStepId(sourcePath));
     if (!compiled.ok) {
-        throw new UsageError(formatWorkflowErrors(`<template:${name}>`, compiled.errors));
+        throw new UsageError(formatWorkflowErrors(sourcePath, compiled.errors));
     }
-    return customized;
 }
-/** Recognized YAML workflow-program suffixes (see {@link WORKFLOW_EXTENSIONS}). */
-const WORKFLOW_PROGRAM_SUFFIX_RE = /\.ya?ml$/i;
+/** Recognized workflow-program suffixes — creating one is a lint-time usage error (workflow-format-unification). */
+const YAML_SUFFIX_RE = /\.ya?ml$/i;
+export function assertWorkflowMarkdownName(name) {
+    if (!YAML_SUFFIX_RE.test(name.trim()))
+        return;
+    throw new UsageError(`Workflows are markdown-only now (workflow-format-unification) — "${name}" cannot be created. ` +
+        `Use a plain name (no ".yaml"/".yml" suffix); the orchestration graph lives in the ".md" file's frontmatter.`);
+}
 export function createWorkflowAsset(input) {
-    const stashDir = resolveStashDir();
-    const typeRoot = path.join(stashDir, "workflows");
-    fs.mkdirSync(typeRoot, { recursive: true });
-    // A `.yaml`/`.yml` name selects the YAML *program* format (redesign
-    // addendum, R1); capture the exact suffix the user typed so the written file
-    // keeps it, then strip every workflow extension to get the canonical name.
-    const suffixMatch = input.name.trim().replace(/\\/g, "/").match(WORKFLOW_PROGRAM_SUFFIX_RE);
-    const programSuffix = suffixMatch ? suffixMatch[0].toLowerCase() : undefined;
-    const isProgram = programSuffix !== undefined;
+    assertWorkflowMarkdownName(input.name);
+    const config = loadConfig();
+    const resolvedTarget = resolveWriteTarget(config);
+    const target = prepareWriteTargetForMutation(resolvedTarget, { allowedAdapters: ["akm", "akm-workflow"] });
+    const stashDir = target.source.path;
+    const standaloneWorkflowBundle = target.source.adapterId === "akm-workflow";
+    const typeRoot = standaloneWorkflowBundle ? stashDir : path.join(stashDir, "workflows");
     const normalizedName = normalizeWorkflowName(input.name);
-    // The write target is DEFINITIVE — the canonical name plus the chosen format's
-    // extension (`.yaml`/`.yml` for a program, `.md` for markdown). We deliberately
-    // do NOT go through `assetPathForName`, which PROBES existing files and
-    // would redirect a markdown create onto an existing `foo.yaml` (writing
-    // markdown into a `.yaml`). Computing the target directly makes a markdown
-    // create always write `.md`, so the finding-C cross-extension check below sees
-    // the real collision instead of a self-match.
-    const targetSuffix = isProgram ? programSuffix : ".md";
-    const assetPath = path.join(typeRoot, `${normalizedName}${targetSuffix}`);
-    if (!isWithin(assetPath, typeRoot)) {
-        throw new UsageError(`Resolved workflow path escapes the stash: "${normalizedName}"`, "PATH_ESCAPE_VIOLATION");
-    }
-    // Codex round-3 finding C: a `workflows/<name>` ref is canonical across every
-    // recognized extension (`.md`/`.yaml`/`.yml`) and resolves `.md` BEFORE
-    // `.yaml`. So creating `foo.yaml` while `foo.md` exists would return the ref
-    // `workflows/foo` that still starts the OLD markdown workflow — a silently
-    // shadowed asset. Reject creation when ANY recognized extension already holds
-    // the same canonical name, naming the existing file. A same-extension collision
-    // (the target path itself exists) keeps the classic `--force` overwrite escape;
-    // a DIFFERENT-extension collision cannot be force-overwritten (writing a new
-    // file would leave the old one shadowing it) — remove the existing file first.
-    const existingPaths = WORKFLOW_EXTENSIONS.map((ext) => path.join(typeRoot, `${normalizedName}${ext}`)).filter((candidate) => fs.existsSync(candidate));
-    const conflicting = existingPaths.find((p) => p !== assetPath);
-    if (conflicting !== undefined) {
-        throw new UsageError(`Workflow "${normalizedName}" already exists as ${path.relative(stashDir, conflicting)} — the ` +
-            `\`workflows/${normalizedName}\` ref resolves to that file, so creating this one would shadow it. ` +
+    const conceptId = standaloneWorkflowBundle ? normalizedName : `workflows/${normalizedName}`;
+    const assetPath = path.join(typeRoot, `${normalizedName}.md`);
+    const relativeAssetPath = path.relative(path.resolve(typeRoot), path.resolve(assetPath));
+    if (relativeAssetPath === ".." ||
+        relativeAssetPath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativeAssetPath)) {
+        throw new UsageError(`Resolved workflow path escapes the bundle: "${normalizedName}"`, "PATH_ESCAPE_VIOLATION");
+    }
+    // A file whose canonical name matches but whose PATH differs can only be a
+    // case variant now (`upper.MD` vs `upper.md`) — the cross-EXTENSION case this
+    // guard also covered is gone with the unified `.md`-only format. It still
+    // matters: on a case-insensitive filesystem the two spellings are one file,
+    // so writing the target would silently clobber or shadow the existing asset.
+    const shadowing = findExistingWorkflowPaths(typeRoot, normalizedName).find((p) => p !== assetPath);
+    if (shadowing !== undefined) {
+        throw new UsageError(`Workflow "${normalizedName}" already exists as ${path.relative(stashDir, shadowing)} — the ` +
+            `\`${conceptId}\` ref resolves to that file, so creating this one would shadow it. ` +
             `Remove or rename the existing file first, or create the workflow under a different name.`, "RESOURCE_ALREADY_EXISTS");
     }
     if (fs.existsSync(assetPath) && !input.force) {
@@ -114,33 +83,19 @@ export function createWorkflowAsset(input) {
     }
     const content = input.from
         ? readWorkflowSource(input.from, stashDir)
-        : (input.content ??
-            (isProgram ? buildWorkflowProgramTemplate(normalizedName) : buildWorkflowTemplate(normalizedName)));
-    const sourcePath = input.from ?? `workflows/${normalizedName}${isProgram ? programSuffix : ".md"}`;
-    // Validate against the format the destination extension selects — a YAML
-    // program parses+compiles as a program, markdown as a document — so the
-    // created asset is guaranteed usable by show/start/validate, which pick
-    // their parser by the same extension.
-    if (isProgram) {
-        const parsed = parseWorkflowProgram(content, { path: sourcePath });
-        if (!parsed.ok) {
-            throw new UsageError(formatWorkflowErrors(sourcePath, parsed.errors));
-        }
-        const compiled = compileWorkflowProgram(parsed.program);
-        if (!compiled.ok) {
-            throw new UsageError(formatWorkflowErrors(sourcePath, compiled.errors));
-        }
-    }
-    else {
-        const result = parseWorkflow(content, { path: sourcePath });
-        if (!result.ok) {
-            throw new UsageError(formatWorkflowErrors(sourcePath, result.errors));
-        }
-    }
-    fs.mkdirSync(path.dirname(assetPath), { recursive: true });
-    fs.writeFileSync(assetPath, content.endsWith("\n") ? content : `${content}\n`, "utf8");
+        : (input.content ?? buildWorkflowTemplate(normalizedName));
+    const sourcePath = input.from ?? `workflows/${normalizedName}.md`;
+    validateWorkflowContent(content, sourcePath);
+    const authoredContent = ensureAkmMarkdownType(content, "workflow");
+    const mode = fs.existsSync(assetPath) ? fs.lstatSync(assetPath).mode & 0o777 : 0o644;
+    const defaultBundle = defaultBundleForTarget(config);
+    const ref = makeBundleRef(target.source.name === defaultBundle ? undefined : target.source.name, conceptId);
+    withWriteTargetMutation(target, [assetPath], { ignored: "reject", purpose: "workflow-authoring", message: `Create ${ref}` }, () => {
+        fs.mkdirSync(path.dirname(assetPath), { recursive: true });
+        writeFileAtomic(assetPath, authoredContent.endsWith("\n") ? authoredContent : `${authoredContent}\n`, mode);
+    });
     return {
-        ref: `workflows/${normalizedName}`,
+        ref,
         path: assetPath,
         stashDir,
     };
@@ -167,10 +122,9 @@ function readWorkflowSource(source, stashDir) {
     return fs.readFileSync(resolved, "utf8");
 }
 function normalizeWorkflowName(name) {
-    // Strip any recognized workflow extension (.md/.yaml/.yml) so the canonical
-    // name — and thus the `workflows/<name>` ref — is extension-free regardless of
-    // how the user spelled it. The chosen format is recovered from the raw suffix
-    // by the caller (createWorkflowAsset).
+    // Strip a recognized workflow extension (.md) so the canonical name — and
+    // thus the `workflows/<name>` ref — is extension-free regardless of how the
+    // user spelled it.
     const normalized = canonicalizeWorkflowName(name
         .trim()
         .replace(/\\/g, "/")
@@ -190,7 +144,7 @@ function humanizeWorkflowName(name) {
         .pop()
         ?.replace(/[-_]+/g, " ")
         .replace(/\b\w/g, (match) => match.toUpperCase())
-        .trim() || "Example Workflow");
+        .trim() || "New Workflow");
 }
 function slugifyWorkflowStepId(name) {
     return (name
@@ -222,34 +176,31 @@ export function validateWorkflowSource(target) {
     return { path: target, parse: parseWorkflow(content, { path: target }) };
 }
 /**
- * Validate a YAML workflow *program* by filesystem path: parse via
- * `parseWorkflowProgram`, then — only when the parse is clean — compile via
- * `compileWorkflowProgram` so expression/reference errors surface too. Both
- * error lists carry line numbers and are returned in the same
- * `WorkflowError[]` shape, ready for `formatWorkflowErrors`. Throws
- * `UsageError` only when the target cannot be located on disk.
+ * Every file under `typeRoot` whose canonical workflow name equals
+ * `normalizedName`. Extension matching is case-INSENSITIVE, so `foo.MD` and
+ * `foo.md` both match — the case-variant collision the create path must refuse
+ * rather than silently clobber on a case-insensitive filesystem.
  */
-export function validateWorkflowProgramSource(target) {
-    const resolved = path.resolve(target);
-    if (!fs.existsSync(resolved)) {
-        throw new UsageError(`Workflow file not found: "${target}".`);
-    }
-    const content = fs.readFileSync(resolved, "utf8");
-    const parse = parseWorkflowProgram(content, { path: target });
-    if (!parse.ok) {
-        return { path: target, result: { ok: false, errors: parse.errors } };
-    }
-    const compiled = compileWorkflowProgram(parse.program);
-    if (!compiled.ok) {
-        return { path: target, result: { ok: false, errors: compiled.errors } };
+function findExistingWorkflowPaths(typeRoot, normalizedName) {
+    const parent = path.join(typeRoot, path.dirname(normalizedName));
+    let entries;
+    try {
+        entries = fs.readdirSync(parent, { withFileTypes: true });
     }
-    // Non-fatal advisories ride along on a successful validation (additive) so
-    // `workflow validate` can surface them without changing the ok verdict.
-    return { path: target, result: { ok: true, program: parse.program, warnings: compiled.warnings } };
+    catch {
+        return [];
+    }
+    const basename = path.basename(normalizedName);
+    return WORKFLOW_EXTENSIONS.flatMap((extension) => entries
+        .filter((entry) => {
+        if (!entry.isFile() && !entry.isSymbolicLink())
+            return false;
+        const entryExtension = path.extname(entry.name);
+        return entryExtension.toLowerCase() === extension && entry.name.slice(0, -entryExtension.length) === basename;
+    })
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((entry) => path.join(parent, entry.name)));
 }
-function renderWorkflowTemplate(input) {
-    return workflowTemplate
-        .replace("{{TITLE}}", input.title)
-        .replace("{{FIRST_STEP_TITLE}}", input.firstStepTitle)
-        .replace("{{FIRST_STEP_ID}}", input.firstStepId);
+function renderWorkflowTemplate(title) {
+    return workflowTemplate.replace("{{TITLE}}", title);
 }

package/dist/workflows/authoring/scope-key.js

@@ -21,7 +21,7 @@ export function resolveWorkflowScopeAnchor(startDir) {
     if (gitRoot)
         return gitRoot;
     try {
-        const stashDir = safeRealpath(resolveStashDir({ readOnly: true }));
+        const stashDir = safeRealpath(resolveStashDir());
         if (isWithin(cwd, stashDir))
             return stashDir;
     }

package/dist/workflows/exec/frozen-judge.js

@@ -4,12 +4,37 @@
 import { deepMergeConfig } from "../../core/config/deep-merge.js";
 import { ConfigError } from "../../core/errors.js";
 /** Build a gate judge from a v3 catalog entry without consulting live config. */
-export function frozenSummaryJudge(plan, invocation) {
+export function frozenSummaryJudge(plan, invocation, signal, dispatcher) {
     if (!invocation)
         return null;
     const engine = plan.execution?.engines[invocation.engine];
-    if (!engine || engine.kind !== "llm")
+    if (!engine)
         throw new ConfigError(`Frozen gate engine "${invocation.engine}" is unavailable.`, "INVALID_CONFIG_FILE");
+    if (engine.kind === "agent") {
+        if (!dispatcher) {
+            throw new ConfigError(`Frozen agent gate engine "${invocation.engine}" has no unit dispatcher.`, "INVALID_CONFIG_FILE");
+        }
+        return async ({ system, user }) => {
+            const fallbackEngine = engine.fallbackLlmEngine ? plan.execution.engines[engine.fallbackLlmEngine] : undefined;
+            const result = await dispatcher({
+                runId: "gate",
+                stepId: "gate",
+                unitId: "gate",
+                nodeId: "gate",
+                prompt: user,
+                systemPrompt: system,
+                engine,
+                ...(fallbackEngine?.kind === "llm" ? { fallbackEngine } : {}),
+                invocation,
+                timeoutMs: invocation.timeoutMs,
+                ...(signal ? { signal } : {}),
+            });
+            if (!result.ok) {
+                throw new Error(result.error || `Verification engine "${invocation.engine}" failed.`);
+            }
+            return result.text;
+        };
+    }
     return async ({ system, user }) => {
         const { chatCompletion } = await import("../../llm/client.js");
         return chatCompletion(materialize(engine, invocation), [
@@ -17,6 +42,7 @@ export function frozenSummaryJudge(plan, invocation) {
             { role: "user", content: user },
         ], {
             timeoutMs: invocation.timeoutMs,
+            ...(signal ? { signal } : {}),
         });
     };
 }

package/dist/workflows/exec/native-executor.js

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * Native executor — executes ONE step's IR v2 subgraph (`IrStepPlan.root`) on
+ * Native executor — executes one frozen step subgraph (`IrStepPlan.root`) on
  * the local machine: fan-out through the scheduler, schema-validated
  * structured output through `runStructured` (core/structured.ts), per-unit
  * persistence through the serialized writer queue, and `workflow_unit_*`
@@ -33,12 +33,11 @@
  *
  * Empty free-text outputs (peer review): a SUCCESSFUL schemaless unit that
  * returns the empty string is normalized to "no output" — {@link dispatchUnit}
- * drops the falsy `text`, `finishUnit` journals `result_json = NULL`, and both
- * durable-row reuse and the R3 report surface rehydrate the same absence
- * (`unitOutcomeFromRow`). This is the ONLY empty-output resolution: `''` never
- * survives on any surface, so the live artifact cannot diverge from the
- * resume/report artifact (the cross-surface parity cardinal rule; the
- * `EMPTY_OUTPUT` driver-parity golden pins it). Consequences that follow from
+ * drops the falsy `text`, `finishUnit` journals `result_json = NULL`, and
+ * durable-row reuse rehydrates the same absence (`unitOutcomeFromRow`). This is
+ * the ONLY empty-output resolution: `''` never survives into the journal, so the
+ * live artifact cannot diverge from the artifact a resume rebuilds from the same
+ * rows (the byte-identical-graph cardinal rule). Consequences that follow from
  * "empty == absent", not special-cased anywhere:
  *   - a SOLO empty step promotes `output = null` (the unit's absent text ??
  *     null); a `collect` fan-out promotes `null` in that item's slot.
@@ -74,9 +73,7 @@
  *     never a silent re-dispatch — under a frozen plan the same identity must
  *     reproduce the same inputs, so a mismatch means the journal (or params
  *     row) was tampered with. Failed/running/missing rows dispatch live.
- *   - Pre-release R1 journals used positional ids (`node.unit[3]`). There is
- *     no back-compat shim: those rows simply never match a content-derived id
- *     and are ignored (the step re-runs cleanly on top of them).
+ *   - Rows with unrelated ids never match a content-derived id and are ignored.
  *
  * Gate loops (addendum, R2 `gate.max_loops`): when the engine re-executes a
  * step subgraph after a gate rejection, it threads the judge's feedback in as
@@ -136,17 +133,15 @@ import { validateJsonSchemaSubset } from "../../core/json-schema.js";
 import { collectSensitiveValues, isEnvPassthroughValueSafeToExpose, redactSensitiveValue } from "../../core/redaction.js";
 import { runStructured } from "../../core/structured.js";
 import { warn } from "../../core/warn.js";
+import { insertEventStrict } from "../../storage/repositories/events-repository.js";
 import { withWorkflowRunsRepo } from "../../storage/repositories/workflow-runs-repository.js";
 import { LIFETIME_UNIT_CAP, scheduleUnits, UnitCapExceededError } from "./scheduler.js";
-// Shared step semantics — the ONE implementation consumed by both the engine
-// (this module + run-workflow.ts) and, from R3, the brief/report driver
-// protocol. This module dispatches; step-work.ts owns the pure decisions.
-import { buildArtifactSummary, computeStepWorkList, DEFAULT_UNIT_TIMEOUT_MS, projectStepOutput, reduceEmptyStep, reduceStepOutcomes, stepOutputsFromEvidence, unitOutcomeFromRow, } from "./step-work.js";
+// Shared step semantics — the ONE implementation consumed by the engine
+// (this module + run-workflow.ts) on both the fresh-execution and the resume
+// path. This module dispatches; step-work.ts owns the pure decisions.
+import { computeStepWorkList, reduceEmptyStep, reduceStepOutcomes, stepOutputsFromEvidence, unitOutcomeFromRow, } from "./step-work.js";
 import { enqueueUnitWrite } from "./unit-writer.js";
 import { assertGitWorkTree, cleanupUnitWorktree, createUnitWorktree } from "./worktree.js";
-// Re-exported for existing consumers (run-workflow.ts, tests) that import these
-// from native-executor; they now live in the shared step-work module.
-export { buildArtifactSummary, DEFAULT_UNIT_TIMEOUT_MS, projectStepOutput };
 /**
  * Mutable per-step dispatch budget: the lifetime unit cap PLUS the declared
  * run-level budget ceilings (`budget.max_units` / `budget.max_tokens`,
@@ -248,10 +243,11 @@ export async function executeStepPlan(plan, ctx) {
     const dispatched = ctx.unitsDispatched ?? 0;
     // Work-list computation is the SHARED, PURE decision (step-work.ts): resolve
     // the fan-out list, derive content-derived unit ids, assemble each unit's
-    // prompt, and hash its resolved input. `brief` (R3) computes the identical
-    // list — that shared implementation is the anti-drift guarantee. This module
-    // owns only the impure remainder: env/worktree preflight, durable-row reuse,
-    // dispatch, journaling, budget.
+    // prompt, and hash its resolved input. A resume recomputes the identical list
+    // from the same frozen plan — that shared pure implementation is what lets
+    // journaled rows be matched instead of re-executed. This module owns only the
+    // impure remainder: env/worktree preflight, durable-row reuse, dispatch,
+    // journaling, budget.
     const workList = computeStepWorkList(plan, {
         runId: ctx.runId,
         params: ctx.params,
@@ -266,10 +262,9 @@ export async function executeStepPlan(plan, ctx) {
     const { template, reducer, isFanOut, items, units: workUnits } = workList.list;
     if (items.length === 0) {
         // Empty fan-out: the promoted artifact is the degenerate empty value, honored
-        // against the step's declared output schema. `reduceEmptyStep` is the SHARED
-        // decision (step-work.ts) the R3 report surface also uses to auto-complete an
-        // empty step the spine reaches, so both surfaces promote the identical
-        // artifact + schema verdict.
+        // against the step's declared output schema. `reduceEmptyStep` (step-work.ts)
+        // owns that decision so a zero-unit step promotes the identical artifact +
+        // schema verdict every time the spine reaches it.
         return { ...reduceEmptyStep(plan, reducer), unitsDispatched: dispatched };
     }
     const dispatcher = ctx.dispatcher ?? defaultUnitDispatcher;
@@ -466,7 +461,7 @@ async function runUnit(input) {
         ...(sensitiveValues.length > 0 ? { sensitiveValues } : {}),
         ...(input.signal ? { signal: input.signal } : {}),
     };
-    // Bounded retry (IR v2 failure policy): attempt 0 journals under the base
+    // Bounded retry: attempt 0 journals under the base
     // journal id (`<unitId>`, or `<unitId>~l<loop>` in a gate loop — computed by
     // the shared work-list), retry attempt N under `<baseId>~r<N>`. Every attempt
     // keeps its own row. Retries only fire when the failure reason is in
@@ -489,8 +484,8 @@ async function runUnit(input) {
     const reuse = classifyUnitReuse(workUnit, input.existingUnits, gateLoop);
     if (reuse.kind === "reuse") {
         // Identity in the durable step evidence is the CONTENT-derived base id, not
-        // the `~r<n>` attempt row it was reused from — the report surface reduces
-        // from the base id too, so both surfaces' evidence.units[].unitId agree.
+        // the `~r<n>` attempt row it was reused from — the work list only ever knows
+        // base ids, so evidence.units[].unitId stays stable across retries+resumes.
         return reuseCompletedUnit(unitId, reuse.row, workUnit.schema !== undefined);
     }
     if (reuse.kind === "diverge") {
@@ -504,6 +499,14 @@ async function runUnit(input) {
     }
     let outcome;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        if (input.signal?.aborted) {
+            return (outcome ?? {
+                unitId,
+                ok: false,
+                failureReason: "aborted",
+                error: "unit was not dispatched because the workflow invocation was interrupted",
+            });
+        }
         const attemptId = attemptIdFor(attempt);
         // Lifetime cap + declared budget ceilings, consumed per ACTUAL dispatch
         // (reuses above returned before reaching here). Refusal fails this unit
@@ -542,6 +545,8 @@ async function runUnit(input) {
             input.budget.addTokens(outcome.tokens);
         if (outcome.ok)
             return outcome;
+        if (input.signal?.aborted)
+            return outcome;
         const reason = outcome.failureReason;
         if (!retry || reason === undefined || !retry.on.includes(reason))
             return outcome;
@@ -596,8 +601,14 @@ async function dispatchJournaledAttempt(input) {
         metadata: { runId: ctx.runId, stepId: plan.stepId, unitId: attemptId },
     });
     const outcome = redactUnitOutcome(await dispatchUnit(request, dispatcher), request.sensitiveValues ?? []);
-    await enqueueUnitWrite(async () => {
-        await withWorkflowRunsRepo((repo) => repo.finishUnit({
+    const finishedAt = new Date().toISOString();
+    await enqueueUnitWrite(() => withWorkflowRunsRepo((repo) => repo.immediateTransaction((db) => {
+        const run = repo.getRunById(ctx.runId);
+        if (run?.status !== "active")
+            return;
+        if (ctx.leaseHolder !== undefined && run.engine_lease_holder !== ctx.leaseHolder)
+            return;
+        repo.finishUnit({
             runId: ctx.runId,
             unitId: attemptId,
             status: outcome.ok ? "completed" : "failed",
@@ -611,21 +622,22 @@ async function dispatchJournaledAttempt(input) {
             // Harness-native session id (P2): journaled so resume can replay the
             // harness's own context cache (e.g. `codex exec resume <id>`).
             sessionId: outcome.sessionId ?? null,
-            finishedAt: new Date().toISOString(),
-        }));
-    });
-    appendEvent({
-        eventType: "workflow_unit_finished",
-        ref: ctx.workflowRef,
-        metadata: {
-            runId: ctx.runId,
-            stepId: plan.stepId,
-            unitId: attemptId,
-            status: outcome.ok ? "completed" : "failed",
-            ...(outcome.failureReason ? { failureReason: outcome.failureReason } : {}),
-            ...(outcome.tokens !== undefined ? { tokens: outcome.tokens } : {}),
-        },
-    });
+            finishedAt,
+        });
+        insertEventStrict(db, {
+            eventType: "workflow_unit_finished",
+            ts: finishedAt,
+            ref: ctx.workflowRef,
+            metadata: {
+                runId: ctx.runId,
+                stepId: plan.stepId,
+                unitId: attemptId,
+                status: outcome.ok ? "completed" : "failed",
+                ...(outcome.failureReason ? { failureReason: outcome.failureReason } : {}),
+                ...(outcome.tokens !== undefined ? { tokens: outcome.tokens } : {}),
+            },
+        });
+    })));
     // Worktree lifecycle epilogue: a CLEAN worktree (`git status --porcelain`
     // empty) is removed; a DIRTY one is retained and logged — the unit left
     // uncollected work, and its journaled worktree_path says where. Cleanup is
@@ -701,12 +713,12 @@ async function dispatchUnit(request, dispatcher) {
         }
         const text = await dispatchOnce();
         // Normalize an EMPTY successful output to "no text". `finishUnit` journals
-        // result_json = NULL for a falsy text, so durable-reuse and the R3 report
-        // surface both rehydrate NO text from the row (unitOutcomeFromRow). Preserving
-        // `text: ""` only in this live outcome would make the LIVE step artifact ("")
-        // diverge from the resume/report artifact (null) — the exact byte-identical-
-        // graph violation the cardinal rule forbids. Treating empty as absent keeps
-        // the live engine, engine resume, and report surfaces identical.
+        // result_json = NULL for a falsy text, so durable-reuse rehydrates NO text
+        // from the row (unitOutcomeFromRow). Preserving `text: ""` only in this live
+        // outcome would make the LIVE step artifact ("") diverge from the artifact a
+        // resume rebuilds from the row (null) — the exact byte-identical-graph
+        // violation the cardinal rule forbids. Treating empty as absent keeps live
+        // dispatch and engine resume identical.
         return { unitId: request.unitId, ok: true, ...(text ? { text } : {}), ...captured() };
     }
     catch (err) {
@@ -778,6 +790,7 @@ async function resolveEnvBindings(refs) {
 export function buildAgentDispatchRequest(request, prompt) {
     return {
         prompt,
+        ...(request.systemPrompt ? { systemPrompt: request.systemPrompt } : {}),
         ...(request.invocation.model ? { model: request.invocation.model } : {}),
         ...(request.invocation.model ? { modelIsExact: true } : {}),
         ...(request.schema ? { schema: request.schema } : {}),
@@ -817,7 +830,13 @@ export const defaultUnitDispatcher = async (request, feedback) => {
         const { chatCompletion, LlmCallError } = await import("../../llm/client.js");
         const connection = resolved.connection;
         try {
-            const text = await chatCompletion(connection, [{ role: "user", content: prompt }], {
+            const messages = request.systemPrompt
+                ? [
+                    { role: "system", content: request.systemPrompt },
+                    { role: "user", content: prompt },
+                ]
+                : [{ role: "user", content: prompt }];
+            const text = await chatCompletion(connection, messages, {
                 timeoutMs: request.timeoutMs,
                 ...(request.signal ? { signal: request.signal } : {}),
                 // Native structured output where the connection supports it; the
@@ -923,9 +942,8 @@ function redactUnitOutcome(outcome, sensitiveValues) {
  * vocabulary `retry.on` accepts and the journal's `failure_reason` column
  * carries. Exhaustive over the code union (typecheck fails on drift):
  *
- *   - `timeout`        → `timeout`         (wall-clock expiry; also covers
- *                                           signal aborts, which chatCompletion
- *                                           folds into its timeout code)
+ *   - `timeout`        → `timeout`         (wall-clock expiry)
+ *   - `aborted`        → `aborted`         (caller/budget cancellation)
  *   - `rate_limited`   → `llm_rate_limit`  (HTTP 429 — the canonical transient)
  *   - `parse_error` / `provider_html_error`
  *                      → `parse_error`     (a response arrived but was not the
@@ -938,6 +956,8 @@ function redactUnitOutcome(outcome, sensitiveValues) {
  */
 export function llmFailureReasonFor(code) {
     switch (code) {
+        case "aborted":
+            return "aborted";
         case "timeout":
             return "timeout";
         case "rate_limited":
@@ -1014,8 +1034,8 @@ function materializeFrozenLlm(snapshot, invocation) {
  * Rehydrate a journaled completed unit row into a UnitOutcome (durable-row
  * reuse). Delegates to the shared {@link unitOutcomeFromRow} — the reuse path
  * only reaches here for completed rows (the caller guards `status ===
- * "completed"`), so the mapping is identical to what the R3 report path applies
- * when it replays the same journal.
+ * "completed"`), so a reused unit contributes exactly what its original
+ * dispatch did.
  */
 function reuseCompletedUnit(unitId, row, hasSchema) {
     return unitOutcomeFromRow(unitId, row, hasSchema);