akm-cli 0.9.11 → 0.9.12

package/dist/workflows/freeze/targets/child-workflow.js

@@ -28,10 +28,11 @@
 import { createHash } from "node:crypto";
 import { parseBundleRef } from "../../../core/asset/asset-ref.js";
 import { UsageError } from "../../../core/errors.js";
+import { warn } from "../../../core/warn.js";
 import { GuardedExecutionSourceCollector } from "../../../execution/guarded-source.js";
 import { workflowParamContract } from "../../ir/params.js";
 import { canonicalJson, canonicalPlanJson } from "../../ir/plan-hash.js";
-import { utf8Bytes, WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES } from "../../resource-limits.js";
+import { utf8Bytes } from "../../resource-limits.js";
 import { loadWorkflowAsset } from "../../runtime/workflow-asset-loader.js";
 import { resolveOwnedAsset } from "../environment.js";
 import { declaredParamNames, earlierStepIds } from "../step-values.js";
@@ -62,15 +63,14 @@ function childWorkflowContentHash(fields) {
  * `freezeEnvironment`): literal `env:` values and `unit: {env: [...]}` refs.
  * An absent/empty `env:` is not authored and stays valid.
  */
-function assertNoStepEnvironment(stepId, childRef, source) {
+function warnIfStepEnvironment(stepId, childRef, source) {
     const hasLiteralEnv = Object.keys(source.env ?? {}).length > 0;
     const hasEnvRefs = (source.unit?.env ?? []).length > 0;
     if (!hasLiteralEnv && !hasEnvRefs)
         return;
-    throw new UsageError(`Workflow step ${stepId} cannot pass env: while composing ${childRef}: a child run carries its own frozen ` +
-        `environment inside its own plan, so a parent-level env: on the composing step cannot be honored. Remove ` +
-        `env: from this step, or move it into ${childRef}'s own source.`, "COMPOSITION_INVALID", "Remove the env: (or unit: env:) block from this step, or set those variables inside the child workflow's " +
-        "own source — a composing step's environment is never delivered into a child run.");
+    warn(`Workflow step ${stepId} declares env: while composing ${childRef}: a child run carries its own frozen ` +
+        `environment inside its own plan, so this composing step's env: (or unit: env:) is not delivered into it ` +
+        `and has no effect. Set those variables inside ${childRef}'s own source instead.`);
 }
 /** A workflow entry of a composition `refPath` — the only entries a cycle can close through (§4.5: a task target can never itself be a task, so no task->task chain exists to close one). */
 function isWorkflowRef(ref) {
@@ -98,14 +98,8 @@ function assertNoCompositionCycle(stepId, childRef, refPath) {
  * total exactly as it was, matching every other freeze-time failure's
  * no-partial-effect shape.
  */
-function chargeEmbeddedBudget(stepId, childRef, childPlanBytes, budget) {
-    const projected = budget.embeddedBytes + childPlanBytes;
-    if (projected > WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES) {
-        throw new UsageError(`Workflow step ${stepId} cannot compose ${childRef}: the embedded child plans would total ${projected} ` +
-            `bytes, over the ${WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES}-byte limit for one workflow run.`, "COMPOSITION_INVALID", "Reduce the number or size of workflows composed into this run — split the work across separate " +
-            "top-level runs, or trim the composed children's own plans.");
-    }
-    budget.embeddedBytes = projected;
+function chargeEmbeddedBudget(_stepId, _childRef, childPlanBytes, budget) {
+    budget.embeddedBytes += childPlanBytes;
 }
 export async function childWorkflowDispatch(input) {
     const { source, baseUnit, childRefInput, context, via, taskRef, authoredInputs } = input;
@@ -115,10 +109,10 @@ export async function childWorkflowDispatch(input) {
     const owned = await resolveOwnedAsset(childRefInput, "workflow", context);
     const childAsset = await loadWorkflowAsset(owned.ref);
     const childRef = childAsset.ref;
-    // Code-review finding: an authored env: on the composing step has no
-    // path to reach the child run and must reject, not vanish (see
-    // assertNoStepEnvironment's doc comment).
-    assertNoStepEnvironment(source.id, childRef, source);
+    // Issue 10: an authored env: on the composing step has no path to reach
+    // the child run — warn rather than vanish silently (see
+    // warnIfStepEnvironment's doc comment).
+    warnIfStepEnvironment(source.id, childRef, source);
     // §4.2 step 2: the composition cycle check, before any child compilation.
     assertNoCompositionCycle(source.id, childRef, context.composition.refPath);
     const childDepth = context.composition.depth + 1;

package/dist/workflows/freeze/targets/command.js

@@ -2,7 +2,9 @@
 // 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/.
 import { createHash } from "node:crypto";
+import { parseBuiltinCommandAction } from "../../../commands/command/builtin-action.js";
 import { prepareCommandInvocation } from "../../../commands/command/command-execution.js";
+import { PORTABLE_ARGUMENTS_PLACEHOLDER } from "../../../commands/command/portable-template.js";
 import { captureFrozenDirectoryIdentity } from "../../../execution/directory-identity.js";
 import { freezeExecutableIdentity } from "../../../execution/executable-identity.js";
 import { canonicalResolvedExecutionRequest, } from "../../../execution/resolved-request.js";
@@ -13,15 +15,25 @@ import { prepareInlineExecution } from "../../../integrations/agent/inline-execu
 import { freezeEnvironment, guardedExecutionSource } from "../environment.js";
 import { gitIdentity } from "../identity.js";
 import { durableRequest, executionUnitValues, executionValues, targetConcurrency, } from "../step-values.js";
+function inlineWorkflowCommandAction(action, commandMode) {
+    if (commandMode !== "portable-template")
+        return action;
+    const parsed = parseBuiltinCommandAction(action);
+    if (parsed.kind !== "inline")
+        return action;
+    return { content: parsed.content.split(PORTABLE_ARGUMENTS_PLACEHOLDER).join(parsed.arguments ?? "") };
+}
 export async function commandDispatch(source, baseUnit, action, context) {
     const prepared = await prepareCommandInvocation({
-        action,
+        action: inlineWorkflowCommandAction(action, source.commandMode),
         config: context.config,
         invocationKind: "workflow",
         ...(context.sourceIr.defaults
             ? { invocationDefaults: executionUnitValues(context.sourceIr.defaults, context.asset.sourcePath) }
             : {}),
-        ...(source.commandMode === "literal" ? { inlineContentMode: "literal" } : {}),
+        ...(source.commandMode === "literal" || source.commandMode === "portable-template"
+            ? { inlineContentMode: "literal" }
+            : {}),
         current: executionValues(source, context.asset.sourcePath),
         sourceLoader: (ref, kind) => guardedExecutionSource(ref, kind, context),
     });

package/dist/workflows/ir/environment-v4.js

@@ -16,6 +16,7 @@ import dotenv from "dotenv";
 import { assetPathForName } from "../../core/asset/asset-placement.js";
 import { isWithin } from "../../core/common.js";
 import { NotFoundError, UsageError } from "../../core/errors.js";
+import { warn } from "../../core/warn.js";
 import { captureGuardedExecutionSource, GuardedExecutionSourceCollector } from "../../execution/guarded-source.js";
 const SECRET_TOKEN_RE = /\$\{secret:([A-Za-z0-9_./-]+)\}/g;
 const ENVIRONMENT_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -33,7 +34,7 @@ export function freezeWorkflowEnvironment(refs, options) {
             throw new UsageError(`Workflow env ref ${JSON.stringify(inputRef)} did not resolve to a canonical fully-qualified owner.`, "WORKFLOW_SOURCE_INVALID");
         }
         if (logical.has(resolved.ref)) {
-            throw new UsageError(`Workflow environment contains duplicate ref ${resolved.ref}.`, "WORKFLOW_SOURCE_INVALID");
+            continue;
         }
         logical.add(resolved.ref);
         trackParentDirectories(collector, resolved.root, resolved.path);
@@ -48,7 +49,8 @@ export function freezeWorkflowEnvironment(refs, options) {
         const physicalKey = `${captured.containmentPhysicalIdentity}\0${captured.physicalIdentity}`;
         const alias = physical.get(physicalKey);
         if (alias !== undefined && alias !== resolved.ref) {
-            throw new UsageError(`${resolved.ref} aliases the same physical environment source as ${alias} under a different logical owner.`, "RESOURCE_ALREADY_EXISTS");
+            warn(`Workflow env ref ${resolved.ref} aliases the same physical environment source as ${alias} under a different logical owner. Using ${alias}.`);
+            continue;
         }
         physical.set(physicalKey, resolved.ref);
         const parsed = dotenv.parse(Buffer.from(captured.bytesBase64, "base64"));

package/dist/workflows/ir/freeze-v4.js

@@ -51,11 +51,8 @@ export async function compileResolveFreezeWorkflowV4(asset, config, options = {}
         throw new UsageError(compiled.errors.map((error) => `${asset.path}:${error.line}: ${error.message}`).join("\n"), code, isMultiJob ? COMPOSITION_INVALID_MULTI_JOB_HINT : undefined);
     }
     const steps = compiled.plan.steps.map((step) => {
-        const frozenJudge = step.gate.criteria.length === 0 ? null : resolved.judges.get(step.stepId);
-        if (step.gate.criteria.length > 0 && !frozenJudge) {
-            throw new Error(`resolved workflow judge missing for step ${step.stepId}`);
-        }
-        const gate = Object.freeze({ ...step.gate, maxLoops: step.gate.maxLoops ?? 1, frozenJudge: frozenJudge ?? null });
+        const frozenJudge = step.gate.criteria.length === 0 ? null : (resolved.judges.get(step.stepId) ?? null);
+        const gate = Object.freeze({ ...step.gate, maxLoops: step.gate.maxLoops ?? 1, frozenJudge });
         if (!step.root) {
             const { root: _root, ...withoutRoot } = step;
             return Object.freeze({ ...withoutRoot, gate });

package/dist/workflows/ir/plan-hash.js

@@ -13,7 +13,6 @@
  * Pure module: no IO beyond node:crypto, no engine imports.
  */
 import { createHash } from "node:crypto";
-import { utf8Bytes, WORKFLOW_MAX_PLAN_BYTES } from "../resource-limits.js";
 import { decodeWorkflowPlanV4, WORKFLOW_IR_V5_VERSION } from "./schema-v4.js";
 /** sha256 hex of the canonical (recursively sorted-keys) JSON of the plan. */
 export function computePlanHash(plan) {
@@ -29,8 +28,6 @@ export function canonicalJson(value) {
 }
 /** Decode, require stored canonical bytes, then verify the stored SHA-256. */
 export function decodeCanonicalPlan(runId, planJson, planHash, expectedVersion) {
-    if (utf8Bytes(planJson) > WORKFLOW_MAX_PLAN_BYTES)
-        throw new Error(`Workflow run ${runId} frozen plan exceeds the 2 MiB resource limit.`);
     let parsed;
     try {
         parsed = JSON.parse(planJson);

package/dist/workflows/ir/schema-v4.js

@@ -19,7 +19,7 @@ import { decodeExecutionSourceIdentity } from "../../execution/source.js";
 import { decodeFrozenRunnerSpec } from "../../integrations/agent/execution-lowering.js";
 import { parseReference } from "../program/expressions.js";
 import { PROGRAM_PARAM_NAME_PATTERN } from "../program/schema.js";
-import { utf8Bytes, WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES } from "../resource-limits.js";
+import { utf8Bytes } from "../resource-limits.js";
 import { decodeWorkflowExecSpec, validateWorkflowPlanStructure, } from "./schema.js";
 export const WORKFLOW_IR_V5_VERSION = 5;
 /**
@@ -152,8 +152,18 @@ function decodeGateV4(value, stepId, requiredSources) {
             frozenJudge: null,
         });
     }
-    if (!Object.hasOwn(gate, "frozenJudge") || gate.frozenJudge === null) {
-        fail(`gate ${stepId} with criteria requires a frozen judge target`);
+    if (!Object.hasOwn(gate, "frozenJudge")) {
+        fail(`gate ${stepId} with criteria is missing its frozenJudge field`);
+    }
+    if (gate.frozenJudge === null) {
+        return Object.freeze({
+            kind: "gate",
+            id: gate.id,
+            stepId,
+            criteria,
+            maxLoops: gate.maxLoops,
+            frozenJudge: null,
+        });
     }
     const identity = {
         kind: "unit",
@@ -239,12 +249,7 @@ function decodeChildWorkflowTarget(target, unit, depth, budget) {
     if (actualPlanHash !== planHash) {
         fail(`unit ${unit.id} child workflow embedded plan does not match its frozen planHash`);
     }
-    const projectedBytes = budget.embeddedBytes + utf8Bytes(embeddedPlanJson);
-    if (projectedBytes > WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES) {
-        fail(`unit ${unit.id} child workflow ${target.ref} embedded plans total ${projectedBytes} bytes, over the ` +
-            `${WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES}-byte limit`);
-    }
-    budget.embeddedBytes = projectedBytes;
+    budget.embeddedBytes += utf8Bytes(embeddedPlanJson);
     return Object.freeze({
         kind: "child-workflow",
         ref: target.ref,

package/dist/workflows/ir/schema.js

@@ -5,7 +5,7 @@ import { isContainedRelativePath, isRecord } from "../../core/common.js";
 import { UsageError } from "../../core/errors.js";
 import { parseReference } from "../program/expressions.js";
 import { PROGRAM_PARAM_NAME_PATTERN, PROGRAM_RETRY_REASONS, PROGRAM_STEP_ID_PATTERN } from "../program/schema.js";
-import { jsonBytes, utf8Bytes, WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_CONCURRENCY, WORKFLOW_MAX_INSTRUCTION_BYTES, WORKFLOW_MAX_PLAN_BYTES, WORKFLOW_MAX_SCHEMA_BYTES, WORKFLOW_MAX_TIMEOUT_MS, } from "../resource-limits.js";
+import { jsonBytes, utf8Bytes, WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_CONCURRENCY, WORKFLOW_MAX_INSTRUCTION_BYTES, WORKFLOW_MAX_SCHEMA_BYTES, WORKFLOW_MAX_TIMEOUT_MS, } from "../resource-limits.js";
 // Shared dispatch-significant bounds now live in `../resource-limits` so the
 // parser, the published JSON Schema, and this decoder enforce identical
 // values. Re-exported here for existing importers (e.g. `commands/workflow-cli.ts`).
@@ -18,8 +18,6 @@ export function validateWorkflowPlanStructure(input, options) {
         fail(`irVersion must be ${options.expectedVersion}`);
     }
     assertJson(input);
-    if (jsonBytes(input) > WORKFLOW_MAX_PLAN_BYTES)
-        fail("plan exceeds the 2 MiB resource limit");
     const plan = input;
     assertKeys(input, ["irVersion", "title", "params", "paramSchemas", "budget", "execution", "steps", ...(options.planExtraKeys ?? [])], "plan");
     assertString(plan.title, "title");

package/dist/workflows/resource-limits.js

@@ -2,7 +2,6 @@
 // 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/.
 import { EXECUTION_MAX_TIMEOUT_MS } from "../execution/limits.js";
-export const WORKFLOW_MAX_PLAN_BYTES = 2 * 1024 * 1024;
 export const WORKFLOW_MAX_SOURCE_BYTES = 1024 * 1024;
 export const WORKFLOW_MAX_INSTRUCTION_BYTES = 256 * 1024;
 export const WORKFLOW_MAX_SCHEMA_BYTES = 256 * 1024;
@@ -73,24 +72,22 @@ export const DEFAULT_EXEC_TIMEOUT_MS = 600_000;
  *     corrupt every downstream reference. That is the residual failure the cap
  *     genuinely justifies.
  *
- * 8 MiB is deliberately generous — 8× the whole-row evidence cap
- * ({@link WORKFLOW_MAX_EVIDENCE_JSON_BYTES}), so any output that could survive
- * persistence intact fits many times over, and an ordinary full test/build log
- * is nowhere near it.
+ * 8 MiB is deliberately generous, so any output a step is likely to produce
+ * fits many times over and an ordinary full test/build log is nowhere near
+ * it.
  */
 export const WORKFLOW_MAX_EXEC_OUTPUT_BYTES = 8 * 1024 * 1024;
 /**
  * Marker stamped on an exec artifact that was RETAINED ONLY IN PART because the
  * command wrote past {@link WORKFLOW_MAX_EXEC_OUTPUT_BYTES}.
  *
- * Deliberately ugly and unique, exactly like `WORKFLOW_EVIDENCE_TRUNCATED_MARKER`
- * (`runtime/runs.ts`) — the same idiom for the same reason: a truncated value
- * must NEVER be mistakable for a complete one by a downstream
- * `steps.<id>.output` reference, by a gate judge, by `akm workflow status`, or
- * by a human reading the row. The artifact is TEXT here rather than a JSON
- * value, so the marker is appended as a trailing block instead of replacing the
- * value with an envelope: the retained prefix is still genuinely useful (it is
- * the head of a real log), and the block says exactly how much is missing.
+ * Deliberately ugly and unique: a truncated value must NEVER be mistakable
+ * for a complete one by a downstream `steps.<id>.output` reference, by a gate
+ * judge, by `akm workflow status`, or by a human reading the row. The
+ * artifact is TEXT here rather than a JSON value, so the marker is appended
+ * as a trailing block instead of replacing the value with an envelope: the
+ * retained prefix is still genuinely useful (it is the head of a real log),
+ * and the block says exactly how much is missing.
  */
 export const WORKFLOW_EXEC_OUTPUT_TRUNCATED_MARKER = "__akm_exec_output_truncated__";
 // Per-var: Win32 `SetEnvironmentVariable` caps one variable at 32 767 UTF-16
@@ -143,27 +140,17 @@ export function clip(text, max) {
     return text.length > max ? `${text.slice(0, max)}…` : text;
 }
 // ── Persistence bounds ───────────────────────────────────────────────────────
-/**
- * Max serialized size of one `workflow_run_steps.evidence_json` row value.
- *
- * The promoted step artifact (`evidence.output`) is deliberately NOT clipped
- * when it is built — gates judge the full artifact and downstream
- * `steps.<id>.output` references need it intact — but a `collect` reducer
- * over an unbounded fan-out (each unit contributing up to a full unit
- * result) would otherwise write an unbounded blob into a single SQLite row.
- * Persistence is therefore bounded here, at the write boundary, by
- * `clipStepEvidenceForPersistence` (`runtime/runs.ts`), which replaces
- * oversized values with an explicitly-marked truncation envelope rather than
- * silently shortening them.
- *
- * 1 MiB is deliberately generous: it is 4× the per-instruction cap and half the
- * whole-plan cap, so no realistic authored workflow reaches it, while a runaway
- * fan-out is still bounded to something SQLite and `akm workflow status` can
- * handle.
- */
-export const WORKFLOW_MAX_EVIDENCE_JSON_BYTES = 1024 * 1024;
-/** Chars of the original value retained (as a marked preview) in a truncation envelope. */
-export const WORKFLOW_EVIDENCE_TRUNCATION_PREVIEW_CHARS = 1000;
+//
+// `workflow_run_steps.evidence_json` is persisted WHOLE and unclipped. It used
+// to be capped at 1 MiB, past which the row was replaced by a marked
+// truncation envelope — but the run still looked successful, and the NEXT
+// invocation (a resume, or any later step referencing the artifact) failed
+// permanently: the value was gone from the only place a resumed run can read
+// it from, so every prior paid step had to be re-run from scratch. SQLite has
+// no practical row-size problem here (its own ceiling is ~1 GB), so there is
+// nothing this cap protected that a full write does not already handle
+// correctly. `JSON.stringify` throwing on genuinely unserializable evidence
+// is unchanged.
 export function utf8Bytes(value) {
     return Buffer.byteLength(value, "utf8");
 }
@@ -173,21 +160,21 @@ export function jsonBytes(value) {
 // ── Recursive child-workflow composition bounds (spec docs/plans/specs/
 // ── p3a-plan-v5-child-freeze.md §4.5, A-N6) ──────────────────────────────────
 //
-// Enforced ONCE, at freeze, before publication, in
-// `src/workflows/freeze/targets/child-workflow.ts` — the ONE resolver both the
-// direct `uses: workflows/<ref>` form and the task-wrapped form route through
-// — and re-enforced as a corruption gate whenever a parent plan is DECODED
-// (`src/workflows/ir/schema-v4.ts`'s recursive `decodeChildWorkflowTarget`).
-// Full design history, including the rejected alternative for the byte cap:
-// docs/architecture/decisions/0007-workflow-composition-bounds.md.
-//
 // Composition DEPTH is unbounded — `assertNoCompositionCycle` (freeze/targets/
 // child-workflow.ts) already makes infinite composition mathematically
 // impossible, so a depth ceiling on top of it only bounded how many
 // legitimately distinct workflows an author could nest.
-/**
- * Max AGGREGATE canonical-JSON bytes of every embedded child plan in ONE root
- * freeze (the sum across the whole composition tree, not per child).
- * Deliberately HALF of {@link WORKFLOW_MAX_PLAN_BYTES} — see ADR 0007.
- */
-export const WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES = 1024 * 1024;
+//
+// This section used to also cap the AGGREGATE canonical-JSON bytes of every
+// embedded child plan in one root freeze (`WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES`,
+// enforced in `freeze/targets/child-workflow.ts` and re-checked on every
+// decode in `ir/schema-v4.ts`'s `decodeChildWorkflowTarget`), alongside a
+// standalone cap on any one frozen plan's own bytes
+// (`WORKFLOW_MAX_PLAN_BYTES`, enforced in `ir/plan-hash.ts` and
+// `ir/schema.ts`). A large plan is not a wrong plan: composing several
+// substantial workflows together is a legitimate, deliberate authoring
+// choice, and SQLite has no practical row-size problem here (its own
+// ceiling is ~1 GB) — there was nothing left for either cap to protect that
+// `planHash`/`contentHash` verification does not already cover. Both caps
+// are removed; the hash/canonical-JSON integrity checks they sat next to
+// are unchanged.

package/dist/workflows/runtime/plan-classifier.js

@@ -2,6 +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/.
 import { UsageError } from "../../core/errors.js";
+import { warnOnce } from "../../core/warn.js";
 import { decodeCanonicalPlan } from "../ir/plan-hash.js";
 import { WORKFLOW_IR_V5_VERSION } from "../ir/schema-v4.js";
 /** Validate that a live run carries exactly the current frozen-plan format. */
@@ -21,31 +22,33 @@ export function classifyWorkflowRunPlan(row) {
             support: "unsupported-version",
             irVersion: row.plan_ir_version,
             // §3.2's exact complete-or-abandon policy string (A-N2): pre-irVersion-5
-            // plans keep status/list/abandon working but can no longer execute.
-            error: `Workflow run ${runId} was frozen as workflow plan irVersion ${row.plan_ir_version}; pre-irVersion-5 ` +
-                `plans cannot execute after the 0.9.2 upgrade. Complete them before upgrading, or run ` +
-                `'akm workflow abandon ${runId}' and start a new run from the authored workflow. ` +
-                `'akm workflow status' and 'akm workflow list' still work on this run.`,
-        };
-    }
-    if (row.plan_ir_version !== WORKFLOW_IR_V5_VERSION) {
-        return {
-            support: "corrupt-plan",
-            irVersion: null,
-            error: `Workflow run ${runId} does not declare a supported workflow IR version.`,
+            // plans keep status/list/abandon working but can no longer execute. A
+            // version ABOVE the current one (#919) is a distinct situation — never
+            // an "upgrade" problem — so it gets its own text below rather than
+            // being folded into the pre-5 wording.
+            error: row.plan_ir_version < WORKFLOW_IR_V5_VERSION
+                ? // Issue 8: leads with the remedy available to a user who has
+                    `Workflow run ${runId} was frozen as workflow plan irVersion ${row.plan_ir_version}; pre-irVersion-5 ` +
+                        `plans cannot execute after the 0.9.2 upgrade. Run 'akm workflow abandon ${runId}' and start a new ` +
+                        `run from the authored workflow to continue. 'akm workflow status' and 'akm workflow list' still ` +
+                        `work on this run.`
+                : `Workflow run ${runId} was frozen with workflow plan irVersion ${row.plan_ir_version}, which this akm ` +
+                    `(irVersion ${WORKFLOW_IR_V5_VERSION}) does not understand; it was probably written by a newer akm. ` +
+                    `Complete it with that akm version, or run 'akm workflow abandon ${runId}' and start a new run from ` +
+                    `the authored workflow. 'akm workflow status' and 'akm workflow list' still work on this run.`,
         };
     }
     try {
         return {
             support: "supported",
-            irVersion: row.plan_ir_version,
+            irVersion: WORKFLOW_IR_V5_VERSION,
             plan: decodeCanonicalPlan(runId, row.plan_json, row.plan_hash, row.plan_ir_version),
         };
     }
     catch (cause) {
         return {
             support: "corrupt-plan",
-            irVersion: row.plan_ir_version,
+            irVersion: row.plan_ir_version ?? null,
             error: cause instanceof Error ? cause.message : String(cause),
         };
     }
@@ -80,37 +83,82 @@ export function frozenStepRows(plan) {
         sequenceIndex: step.sequenceIndex,
     }));
 }
-/** Verify the durable spine still agrees with the decoded/hash-verified plan before any mutation. */
-export function assertWorkflowSpineMatchesPlan(plan, run, rows) {
-    const expected = frozenStepRows(plan);
+/**
+ * Verify the durable spine's STEP IDENTITY still agrees with the
+ * decoded/hash-verified plan: the same number of steps, and the same set of
+ * step ids. A published plan's own step ids are fixed forever at freeze
+ * time, so a mismatch here means the row set itself is wrong — genuine
+ * corruption, not something a later akm release could have caused by
+ * changing how a field is FORMATTED (that is
+ * {@link reconcileWorkflowSpineWithPlan}'s concern, issue 7).
+ */
+function assertSpineIdentityMatchesPlan(runId, expected, rows) {
     if (rows.length !== expected.length)
-        corruptSpine(run.id, "step count differs from the frozen plan");
-    for (let index = 0; index < expected.length; index++) {
-        const actual = rows[index];
-        const planned = expected[index];
-        // The length check above (corruptSpine returns `never`) guarantees both are
-        // present; the guard narrows them and preserves the "missing row" message.
-        if (!actual || !planned) {
-            corruptSpine(run.id, `step row ${index} differs from the frozen plan (missing row)`);
-        }
-        if (actual.step_id !== planned.stepId ||
-            actual.step_title !== planned.stepTitle ||
-            actual.instructions !== planned.instructions ||
-            actual.completion_json !== planned.completionJson ||
-            actual.sequence_index !== planned.sequenceIndex) {
-            const fields = [
-                actual.step_id !== planned.stepId ? "step_id" : "",
-                actual.step_title !== planned.stepTitle ? "step_title" : "",
-                actual.instructions !== planned.instructions ? "instructions" : "",
-                actual.completion_json !== planned.completionJson ? "completion_json" : "",
-                actual.sequence_index !== planned.sequenceIndex ? "sequence_index" : "",
-            ].filter(Boolean);
-            corruptSpine(run.id, `step row ${index} differs from the frozen plan (${fields.join(", ")})`);
+        corruptSpine(runId, "step count differs from the frozen plan");
+    const expectedIds = new Set(expected.map((step) => step.stepId));
+    for (const row of rows) {
+        if (!expectedIds.has(row.step_id))
+            corruptSpine(runId, `step "${row.step_id}" is not in the frozen plan`);
+    }
+}
+/**
+ * Reconcile the durable spine's PURE-DERIVATION fields (title, instructions,
+ * completion criteria, sequence position) against the plan (issue 7).
+ *
+ * These are recomputed from the plan by {@link frozenStepRows} on every
+ * read; a later akm release changing how one of them is FORMATTED from the
+ * SAME plan data used to mark every in-flight run from the previous release
+ * "corrupt" the moment anything (`akm workflow status`, `resume`, a step
+ * completion) touched it. A mismatch here is warned about, once per run,
+ * rather than blocking the caller — never step identity (row count, which
+ * step ids exist), which stays a hard failure in
+ * {@link assertSpineIdentityMatchesPlan} because the plan cannot have
+ * produced a different step id for an already-frozen run.
+ *
+ * The durable row — not the plan — is what a driving agent actually acts
+ * on: `getNextWorkflowStep` reads `instructions` straight off this row
+ * (`toWorkflowRunStepState`/`projectNextResult` in `runtime/runs.ts`), and
+ * `exec/run-workflow.ts`/`exec/step-work.ts` dispatch from that result. So
+ * warning and proceeding with the STORED row (rather than rewriting it to
+ * match the plan's current formatting) is the conservative choice: the
+ * durable spine is the contract this run has been executing against since
+ * freeze, and a newer akm formatting the same plan data differently should
+ * not retroactively change an in-flight run's instructions out from under
+ * it mid-execution. This module has no write path for that anyway
+ * (`workflow_run_steps` is owned by
+ * `storage/repositories/workflow-runs-repository.ts`) — and it should not
+ * gain one for this purpose. Step
+ * identity (row count, which step ids exist) is the part that would
+ * actually desynchronize execution from the plan, which is exactly why
+ * {@link assertSpineIdentityMatchesPlan} keeps that a hard failure.
+ */
+export function reconcileWorkflowSpineWithPlan(plan, run, rows) {
+    const expected = frozenStepRows(plan);
+    assertSpineIdentityMatchesPlan(run.id, expected, rows);
+    const expectedById = new Map(expected.map((step) => [step.stepId, step]));
+    const drifted = [];
+    for (const row of rows) {
+        const planned = expectedById.get(row.step_id);
+        if (!planned)
+            continue; // unreachable after assertSpineIdentityMatchesPlan; kept defensive.
+        if (row.step_title !== planned.stepTitle ||
+            row.instructions !== planned.instructions ||
+            row.completion_json !== planned.completionJson ||
+            row.sequence_index !== planned.sequenceIndex) {
+            drifted.push(row.step_id);
         }
     }
-    if (run.current_step_id !== null && !expected.some((step) => step.stepId === run.current_step_id))
-        corruptSpine(run.id, `current step ${run.current_step_id} is not in the frozen plan`);
+    if (drifted.length > 0) {
+        warnOnce(`workflow-spine-drift:${run.id}`, `Workflow run ${run.id}: durable step row(s) [${drifted.join(", ")}] no longer match the frozen plan's ` +
+            "title/instructions/completion-criteria/sequence derivation (an akm upgrade likely changed how one of " +
+            "these is formatted from the same plan data). Continuing with the stored row(s) as-is — this run keeps " +
+            "executing against the instructions it was frozen with, rather than having them rewritten mid-flight.");
+    }
+}
+export function assertRunStatusMatchesSpine(run, rows) {
     const current = run.current_step_id ? rows.find((row) => row.step_id === run.current_step_id) : undefined;
+    if (run.current_step_id !== null && !current)
+        corruptSpine(run.id, `current step ${run.current_step_id} is not in the frozen plan`);
     if (run.status === "active") {
         const firstPending = rows.find((row) => row.status === "pending");
         if (!current || current.status !== "pending" || firstPending?.step_id !== current.step_id)

package/dist/workflows/runtime/run-outputs.js

@@ -19,13 +19,6 @@
  */
 import { validateJsonSchemaSubset } from "../../core/json-schema.js";
 import { parseReference, resolveReferenceString } from "../program/expressions.js";
-/** Mirrors `runs.ts`'s `WORKFLOW_EVIDENCE_TRUNCATED_MARKER` byte-for-byte — see this file's header for why it is reproduced, not imported. */
-const EVIDENCE_TRUNCATED_MARKER = "__akm_evidence_truncated__";
-function isTruncatedEvidenceValue(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        value[EVIDENCE_TRUNCATED_MARKER] === true);
-}
 /** Project a step artifact out of its persisted evidence — mirrors `exec/step-work.ts`'s `projectStepOutput`. */
 function projectStepOutput(evidence) {
     return Object.hasOwn(evidence, "output") ? evidence.output : evidence;
@@ -60,22 +53,11 @@ export function resolveWorkflowRunOutputs(plan, steps) {
             errors.push(`output "${name}": "${declaration.from}" is not a valid step-output reference.`);
             continue;
         }
-        const rootValue = Object.hasOwn(stepOutputs, parsed.expr.stepId) ? stepOutputs[parsed.expr.stepId] : undefined;
-        if (isTruncatedEvidenceValue(rootValue)) {
-            errors.push(`output "${name}" reads step "${parsed.expr.stepId}"'s artifact, which was truncated — it exceeded the ` +
-                `evidence persistence cap and was not stored.`);
-            continue;
-        }
         const resolved = resolveReferenceString(declaration.from, scope);
         if (!resolved.ok) {
             errors.push(`output "${name}": ${resolved.error.message}`);
             continue;
         }
-        if (isTruncatedEvidenceValue(resolved.value)) {
-            errors.push(`output "${name}" reads step "${parsed.expr.stepId}"'s artifact, which was truncated — it exceeded the ` +
-                `evidence persistence cap and was not stored.`);
-            continue;
-        }
         if (declaration.schema) {
             const schemaErrors = validateJsonSchemaSubset(resolved.value, declaration.schema);
             if (schemaErrors.length > 0) {
@@ -86,9 +68,7 @@ export function resolveWorkflowRunOutputs(plan, steps) {
         }
         outputs[name] = resolved.value;
     }
-    if (errors.length > 0)
-        return { ok: false, errors };
-    return { ok: true, outputs };
+    return { outputs, errors };
 }
 /**
  * What a completed run EXPORTS: the resolved declared outputs, or