akm-cli 0.9.5 → 0.9.7

package/dist/tasks/resolve-akm-bin.js

@@ -10,7 +10,11 @@
  * Resolution order:
  *
  *   1. `process.execPath` alone for a Bun standalone executable.
- *   2. Absolute Node plus the public `dist/akm` package launcher.
+ *   2. Absolute Node plus the public `dist/akm` package launcher — eligible
+ *      when it is the active npm global install, or when this process
+ *      cannot write to the directory containing it (a read-only mount, e.g.
+ *      an image-baked install, gives the same "won't change out from under
+ *      the scheduler" guarantee npm-global ownership does).
  *   3. Absolute runtime plus the source/build CLI entry, classified as a
  *      checkout that requires explicit `--rebind` for scheduler writes.
  *
@@ -51,12 +55,13 @@ export function resolveAkmInvocation(options = {}) {
             }
         }
         const npmGlobal = !checkout && packageBelongsToNpmGlobalRoot(launcherPath, npmGlobalRoot);
+        const readOnlyInstall = !checkout && !npmGlobal && !(options.isPathWritable ?? isPathWritable)(path.dirname(launcherPath));
         const kind = checkout ? "checkout" : npmGlobal ? "npm" : "package-local";
         return {
             argv: [absoluteInvocationPath(nodePath), absoluteInvocationPath(launcherPath)],
             via: kind,
             kind,
-            eligible: npmGlobal,
+            eligible: npmGlobal || readOnlyInstall,
         };
     }
     const checkoutEntry = resolveCheckoutEntry(options.cliEntryUrl ?? import.meta.url, runtime, mainPath);
@@ -117,6 +122,16 @@ function isCheckoutLauncher(file) {
     const packageRoot = path.dirname(path.dirname(launcher));
     return fs.existsSync(path.join(packageRoot, ".git"));
 }
+/** Whether this process can write to `dir` — false also covers a read-only mount. */
+function isPathWritable(dir) {
+    try {
+        fs.accessSync(dir, fs.constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function packageBelongsToNpmGlobalRoot(launcherPath, npmGlobalRoot) {
     if (!npmGlobalRoot)
         return false;

package/dist/tasks/run/run-native-task.js

@@ -20,7 +20,7 @@
 import path from "node:path";
 import { assertNever } from "../../core/assert.js";
 import { runManagedSubprocess, streamCaptureFailure } from "../../core/subprocess.js";
-import { assertFrozenDirectoryIdentity } from "../../execution/directory-identity.js";
+import { assertFrozenDirectoryContained } from "../../execution/directory-identity.js";
 import { cleanupFrozenScript, frozenScriptCommand, materializeFrozenScript } from "../frozen-script.js";
 import { resolveAkmInvocation } from "../resolve-akm-bin.js";
 import { finishAttempt } from "./attempt-lifecycle.js";
@@ -146,11 +146,13 @@ export async function runNativeTask(input) {
     const dbLines = [{ line: header }];
     let exitCode = null;
     try {
-        // The projector froze both canonical paths and filesystem identities before
-        // history mutation. Re-resolve the authored root/cwd immediately before
-        // spawn so a symlink, ancestor, bundle-root, or directory/file swap cannot
-        // redirect execution outside that physical workspace.
-        assertFrozenDirectoryIdentity(task.cwdIdentity);
+        // Re-resolve the authored root/cwd immediately before spawn so a
+        // symlink, ancestor, bundle-root, or directory/file swap cannot redirect
+        // execution outside that physical workspace. This is a live containment
+        // check, not an identity comparison — it does not care whether the
+        // underlying device/inode changed (e.g. a remount), only whether the
+        // resolved cwd still lives inside its root.
+        assertFrozenDirectoryContained(task.cwdIdentity);
         if (task.kind === "script") {
             materialized = materializeFrozenScript(task);
             cmd = frozenScriptCommand(task, materialized.file);

package/dist/tasks/scheduler-invocation.js

@@ -189,7 +189,14 @@ export function parseScheduledBindingArgv(argv) {
         ...(publicInvocation.target !== undefined ? { target: publicInvocation.target } : {}),
     };
 }
-function parsePublicSchedulerInvocation(invocation) {
+/**
+ * Parse just the public `task run …` / `workflow run …` tail, with no
+ * `--scheduler-context` wrapper. Exported so a backend can recognize a
+ * pre-`--scheduler-context` invocation still sitting inside akm's own
+ * ownership-marked block (see `extractCronInvocation` in
+ * `src/tasks/backends/cron.ts`) without re-implementing this grammar.
+ */
+export function parsePublicSchedulerInvocation(invocation) {
     if (invocation[0] === "task" && invocation[1] === "run" && invocation[2]) {
         try {
             if (normaliseTaskConceptId(invocation[2]) !== invocation[2])

package/dist/tasks/source/bounded-document.js

@@ -53,13 +53,14 @@ import { EXECUTION_MAX_TIMEOUT_MS } from "../../execution/limits.js";
 import { snapshotStrictRecord } from "../../execution/record.js";
 import { WORKFLOW_ENV_VAR_NAME_PATTERN } from "../../workflows/resource-limits.js";
 // ── Resource bounds (D2-N4: owned here, re-exported by source-v3.ts) ───────
-export const TASK_V3_MAX_SOURCE_BYTES = 1024 * 1024;
 export const TASK_V3_MAX_JSON_DEPTH = 64;
 export const TASK_V3_MAX_JSON_NODES = 10_000;
 export const TASK_V3_MAX_COLLECTION_ITEMS = 1024;
 export const TASK_V3_MAX_OBJECT_KEYS = 256;
 export const TASK_V3_MAX_STRING_BYTES = 256 * 1024;
 export const TASK_V3_MAX_SCHEDULES = 64;
+/** Max entries in a task's `redact:` env-name list. */
+export const TASK_V3_MAX_REDACT_NAMES = 32;
 export function own(value, key) {
     return Object.hasOwn(value, key);
 }
@@ -414,9 +415,6 @@ export function readBoundedTaskSourceYaml(input, options) {
     if (typeof input.yaml !== "string") {
         throw new UsageError(`Invalid ${sourceLabel} at ${input.filePath}: source must be a string.`, "TASK_SOURCE_INVALID");
     }
-    if (utf8Bytes(input.yaml) > TASK_V3_MAX_SOURCE_BYTES) {
-        throw new UsageError(`Invalid ${sourceLabel} at ${input.filePath}: source exceeds the 1 MiB (${TASK_V3_MAX_SOURCE_BYTES}-byte) resource limit.`, "TASK_SOURCE_INVALID");
-    }
     const lineCounter = new LineCounter();
     let document;
     try {

package/dist/tasks/source/parse-task-source.js

@@ -17,7 +17,7 @@
  *   | root `version`        | outcome                                                        |
  *   |------------------------|-----------------------------------------------------------------|
  *   | `4`                    | `parseTaskSourceV4Document` — the new grammar (row B-13)        |
- *   | `2` or `3`             | in-memory read shim (below): the SAME pure planners `akm migrate apply` uses (`./task-to-v3.ts`, `./task-to-v4.ts`) convert the bytes already in hand to v4 in memory; the result is parsed and returned with a one-line stderr deprecation warning. If the deterministic conversion itself fails (an unmigratable shape), falls back to `TASK_SCHEMA_VERSION_UNSUPPORTED`, naming the migrator (B-14/B-15) — the shim removes friction for the deterministic case, it never hides a real problem |
+ *   | `2` or `3`             | in-memory read shim (below): the SAME pure planners `akm migrate apply` uses (`./task-to-v3.ts`, `./task-to-v4.ts`) convert the bytes already in hand to v4 in memory; the result is parsed and returned with a one-line stderr deprecation warning. If the deterministic conversion itself fails (an unmigratable shape — the file needs a human decision, not a re-run), falls back to `TASK_SCHEMA_VERSION_UNSUPPORTED` naming the specific blocked reason (issue #869) — the shim removes friction for the deterministic case, it never hides a real problem |
  *   | any other number       | `TASK_SCHEMA_VERSION_UNSUPPORTED`, naming the migrator (B-14/B-15) |
  *   | absent / not a number  | `parseTaskSourceV4Document` — its own `TASK_SOURCE_INVALID` "version is required and must be 4" / "must be exactly 4" wording (row B-16) |
  *
@@ -57,6 +57,18 @@ export function peekTaskSourceVersion(root) {
     return typeof value === "number" ? value : undefined;
 }
 const TASK_MIGRATE_HINT = "Run `akm migrate apply --dry-run` to preview the task-v3 to task-source-v4 conversion, then run `akm migrate apply`.";
+/**
+ * Thrown only when the deterministic conversion itself could not produce a
+ * task source v4 document — a case where a person must decide the intended
+ * behavior (e.g. an ambiguous shell command), not one the migrator can just
+ * be re-run to fix. `reason`/`detail` are the SAME blocked outcome
+ * `akm migrate status`/`apply` reports for this file, so the message names
+ * the actual decision instead of pointing at a command that will report the
+ * identical block.
+ */
+function unmigratableVersionError(filePath, version, reason, detail) {
+    return new UsageError(`TASK_SCHEMA_VERSION_UNSUPPORTED: Task at ${filePath} uses task schema version ${version} and needs a human decision before it can run — the deterministic migrator cannot convert it automatically (${reason}${detail ? `: ${detail}` : ""}).`, "TASK_SCHEMA_VERSION_UNSUPPORTED", "Review the file and resolve the ambiguity by hand, then it will convert normally; `akm migrate status` reports the same reason.");
+}
 function unsupportedVersionError(filePath, version) {
     return new UsageError(`TASK_SCHEMA_VERSION_UNSUPPORTED: Task at ${filePath} uses task schema version ${version}, which this release does not accept.`, "TASK_SCHEMA_VERSION_UNSUPPORTED", TASK_MIGRATE_HINT);
 }
@@ -64,9 +76,10 @@ function unsupportedVersionError(filePath, version) {
  * Plan the SAME bytes already in hand through the pure v3->v4 (and, for v2,
  * chained v2->v3->v4) migration planner(s) — never touches disk, never
  * writes the file, never re-reads it from disk. Returns the produced v4
- * YAML text, or `undefined` when the deterministic conversion cannot
- * proceed (an unmigratable v2/v3 shape) — the caller falls back to the same
- * hard error this gate threw before the shim existed.
+ * YAML text, or the blocked reason/detail when the deterministic conversion
+ * cannot proceed (an unmigratable v2/v3 shape) — the caller falls back to
+ * the same hard error this gate threw before the shim existed, now naming
+ * that reason.
  */
 function planInMemoryV4Bytes(version, yaml, filePath, workspaceRoot) {
     const bytes = Buffer.from(yaml, "utf8");
@@ -89,12 +102,12 @@ function planInMemoryV4Bytes(version, yaml, filePath, workspaceRoot) {
     else {
         const v3Outcome = planTaskToV3File(baseInput);
         if (v3Outcome.status !== "changed")
-            return undefined;
+            return { reason: v3Outcome.reason, detail: v3Outcome.detail };
         v3Bytes = v3Outcome.after;
     }
     const v4Outcome = planTaskToV4File({ ...baseInput, bytes: v3Bytes });
     if (v4Outcome.status !== "changed")
-        return undefined;
+        return { reason: v4Outcome.reason, detail: v4Outcome.detail };
     return v4Outcome.after.toString("utf8");
 }
 /** Parse task source YAML, routing per the terminal table above. */
@@ -103,16 +116,17 @@ export function parseTaskSource(input) {
     const version = peekTaskSourceVersion(root);
     if (version !== undefined && version !== TASK_SOURCE_V4_VERSION) {
         if (version === 2 || version === 3) {
-            const v4Yaml = planInMemoryV4Bytes(version, input.yaml, input.filePath, input.workspaceRoot);
-            if (v4Yaml !== undefined) {
+            const shimmed = planInMemoryV4Bytes(version, input.yaml, input.filePath, input.workspaceRoot);
+            if (typeof shimmed === "string") {
                 const v4 = parseTaskSourceV4({
-                    yaml: v4Yaml,
+                    yaml: shimmed,
                     filePath: input.filePath,
                     ...(input.workspaceRoot ? { workspaceRoot: input.workspaceRoot } : {}),
                 });
                 warn(`akm: task ${input.filePath} uses schema v${version} — auto-read as v4; run \`akm migrate apply\` to rewrite it and silence this`);
                 return Object.freeze({ version: 4, v4 });
             }
+            throw unmigratableVersionError(input.filePath, version, shimmed.reason, shimmed.detail);
         }
         throw unsupportedVersionError(input.filePath, version);
     }

package/dist/tasks/source/task-source-v3-frozen.js

@@ -42,8 +42,8 @@ import { parseBuiltinCommandAction } from "../../commands/command/builtin-action
 import { bundleRefToString, parseBundleRef } from "../../core/asset/asset-ref.js";
 import { UsageError } from "../../core/errors.js";
 import { checkJsonSchemaDefinition } from "../../core/json-schema.js";
-import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_RETRIES, } from "../../workflows/resource-limits.js";
-import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, parseTimeout, parseTools, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, TASK_V3_MAX_SCHEDULES, validateWorkingDirectory, } from "./bounded-document.js";
+import { WORKFLOW_ENV_VAR_NAME_PATTERN } from "../../workflows/resource-limits.js";
+import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, parseTimeout, parseTools, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, TASK_V3_MAX_REDACT_NAMES, TASK_V3_MAX_SCHEDULES, validateWorkingDirectory, } from "./bounded-document.js";
 export const TASK_V3_SCHEMA_VERSION = 3;
 /** Closed authoring vocabulary. Arbitrary GitHub `{0}` shell templates are not accepted. */
 export const TASK_V3_HOST_SHELLS = ["bash", "sh", "zsh", "pwsh", "powershell", "cmd"];
@@ -146,7 +146,7 @@ function parseAkm(value, ctx) {
         out.timeout = parseTimeout(input.timeout, ctx);
     if (own(input, "redact")) {
         const names = parseStringArray(input.redact, ctx, ["akm", "redact"], {
-            max: WORKFLOW_MAX_EXEC_PASS_ENV,
+            max: TASK_V3_MAX_REDACT_NAMES,
             pattern: WORKFLOW_ENV_VAR_NAME_PATTERN,
         });
         if (new Set(names).size !== names.length)
@@ -160,10 +160,8 @@ function parseAkm(value, ctx) {
         out.maxSteps = input.maxSteps;
     }
     if (own(input, "maxRetries")) {
-        if (!Number.isSafeInteger(input.maxRetries) ||
-            input.maxRetries < 0 ||
-            input.maxRetries > WORKFLOW_MAX_RETRIES) {
-            sourceError(ctx, ["akm", "maxRetries"], `must be an integer from 0 through ${WORKFLOW_MAX_RETRIES}.`);
+        if (!Number.isSafeInteger(input.maxRetries) || input.maxRetries < 0) {
+            sourceError(ctx, ["akm", "maxRetries"], "must be a non-negative safe integer.");
         }
         out.maxRetries = input.maxRetries;
     }

package/dist/tasks/source/task-source-v4.js

@@ -42,10 +42,10 @@ import { applyInputDefaults, INPUT_NAME_PATTERN, validateInputs, } from "../../e
 import { EXECUTION_MAX_TIMEOUT_MS } from "../../execution/limits.js";
 import { classifyTargetRef } from "../../execution/target-ref.js";
 import { detectSecretShapedParams } from "../../workflows/exec/param-secrets.js";
-import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_PARAMS, WORKFLOW_MAX_RETRIES, WORKFLOW_MAX_SCHEMA_BYTES, } from "../../workflows/resource-limits.js";
+import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_SCHEMA_BYTES } from "../../workflows/resource-limits.js";
 import { TASK_V3_HOST_SHELLS, TASK_V3_MAX_SCHEDULES } from "../source-v3.js";
 import { TASK_RUN_RESERVED_FLAG_NAMES, TASK_RUN_SELF_DIAGNOSED_FLAGS } from "../task-run-reserved-flags.js";
-import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, utf8Bytes, validateWorkingDirectory, } from "./bounded-document.js";
+import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, TASK_V3_MAX_REDACT_NAMES, utf8Bytes, validateWorkingDirectory, } from "./bounded-document.js";
 // ── Closed constants (D1, D2-N3, D2-N7) ─────────────────────────────────────
 export const TASK_SOURCE_V4_VERSION = 4;
 /** The exact, closed top-level key set (D2-N7) — `akm` and `on` are deliberately absent. */
@@ -298,7 +298,7 @@ function parseExecutionControls(input, ctx) {
         out.timeout = parseTimeoutTopLevel(input.timeout, ctx);
     if (own(input, "redact")) {
         const names = parseStringArray(input.redact, ctx, ["redact"], {
-            max: WORKFLOW_MAX_EXEC_PASS_ENV,
+            max: TASK_V3_MAX_REDACT_NAMES,
             pattern: WORKFLOW_ENV_VAR_NAME_PATTERN,
         });
         if (new Set(names).size !== names.length)
@@ -312,10 +312,8 @@ function parseExecutionControls(input, ctx) {
         out.maxSteps = input.maxSteps;
     }
     if (own(input, "maxRetries")) {
-        if (!Number.isSafeInteger(input.maxRetries) ||
-            input.maxRetries < 0 ||
-            input.maxRetries > WORKFLOW_MAX_RETRIES) {
-            sourceError(ctx, ["maxRetries"], `must be an integer from 0 through ${WORKFLOW_MAX_RETRIES}.`);
+        if (!Number.isSafeInteger(input.maxRetries) || input.maxRetries < 0) {
+            sourceError(ctx, ["maxRetries"], "must be a non-negative safe integer.");
         }
         out.maxRetries = input.maxRetries;
     }
@@ -376,9 +374,6 @@ function parseInputDeclaration(name, raw, ctx) {
 function parseInputDeclarations(value, ctx) {
     const input = asRecord(value, ctx, ["inputs"]);
     const names = Object.keys(input);
-    if (names.length > WORKFLOW_MAX_PARAMS) {
-        sourceError(ctx, ["inputs"], `accepts at most ${WORKFLOW_MAX_PARAMS} declared inputs.`);
-    }
     const result = {};
     for (const name of names) {
         if (!INPUT_NAME_PATTERN.test(name)) {

package/dist/tasks/source/task-to-v3.js

@@ -7,9 +7,9 @@ import path from "node:path";
 import { LineCounter, parseDocument, stringify as stringifyYaml } from "yaml";
 import { bundleRefToString, parseBundleRef } from "../../core/asset/asset-ref.js";
 import { formatExtraParamsIssue, validateExtraParams } from "../../core/extra-params.js";
-import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_RETRIES, WORKFLOW_MAX_TIMEOUT_MS, } from "../../workflows/resource-limits.js";
+import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_TIMEOUT_MS } from "../../workflows/resource-limits.js";
 import { validateTaskId } from "../task-id.js";
-import { assertBoundedTaskYamlDocument, TASK_V3_MAX_SOURCE_BYTES } from "./bounded-document.js";
+import { assertBoundedTaskYamlDocument, TASK_V3_MAX_REDACT_NAMES } from "./bounded-document.js";
 import { classifyTaskV3Uses, parseTaskV3Yaml } from "./task-source-v3-frozen.js";
 import { parseTaskSourceV4 } from "./task-source-v4.js";
 const V2_KEYS = new Set([
@@ -135,9 +135,6 @@ function optionalString(value, label) {
     return exactString(value, label);
 }
 function parseLegacyTaskYaml(input) {
-    if (input.bytes.byteLength > TASK_V3_MAX_SOURCE_BYTES) {
-        throw new Error(`task YAML exceeds the 1 MiB (${TASK_V3_MAX_SOURCE_BYTES}-byte) source resource limit`);
-    }
     let source;
     try {
         source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input.bytes);
@@ -189,7 +186,7 @@ function validateCommonV2(data) {
     }
     if (data.redact !== undefined && data.redact !== null) {
         if (!Array.isArray(data.redact) ||
-            data.redact.length > WORKFLOW_MAX_EXEC_PASS_ENV ||
+            data.redact.length > TASK_V3_MAX_REDACT_NAMES ||
             data.redact.some((entry) => typeof entry !== "string" || !WORKFLOW_ENV_VAR_NAME_PATTERN.test(entry))) {
             throw new Error("redact must contain only bounded environment variable names");
         }
@@ -321,10 +318,8 @@ function migratedObject(data) {
             akm.maxSteps = data.maxSteps;
         }
         if (data.maxRetries !== undefined && data.maxRetries !== null) {
-            if (!Number.isSafeInteger(data.maxRetries) ||
-                data.maxRetries < 0 ||
-                data.maxRetries > WORKFLOW_MAX_RETRIES) {
-                throw new Error(`maxRetries must be from 0 through ${WORKFLOW_MAX_RETRIES}`);
+            if (!Number.isSafeInteger(data.maxRetries) || data.maxRetries < 0) {
+                throw new Error("maxRetries must be a non-negative integer");
             }
             akm.maxRetries = data.maxRetries;
         }

package/dist/tasks/source/task-to-v4.js

@@ -18,7 +18,7 @@
 import crypto from "node:crypto";
 import path from "node:path";
 import { LineCounter, parseDocument, stringify as stringifyYaml } from "yaml";
-import { assertBoundedTaskYamlDocument, TASK_V3_MAX_SOURCE_BYTES } from "./bounded-document.js";
+import { assertBoundedTaskYamlDocument } from "./bounded-document.js";
 import { classifyTaskV3Uses } from "./task-source-v3-frozen.js";
 import { parseTaskSourceV4 } from "./task-source-v4.js";
 /** The closed v3 top-level key set (`src/tasks/source-v3.ts`'s own, vendored — not exported there). */
@@ -114,9 +114,6 @@ function exactString(value, label, nonempty = false) {
  * away (C-N1).
  */
 function parseV3RawYaml(input) {
-    if (input.bytes.byteLength > TASK_V3_MAX_SOURCE_BYTES) {
-        throw new Error(`task YAML exceeds the 1 MiB (${TASK_V3_MAX_SOURCE_BYTES}-byte) source resource limit`);
-    }
     let source;
     try {
         source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input.bytes);

package/dist/tasks/source-v3.js

@@ -1,13 +1,13 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // 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 { TASK_V3_MAX_SCHEDULES, TASK_V3_MAX_SOURCE_BYTES } from "./source/bounded-document.js";
+import { TASK_V3_MAX_SCHEDULES } from "./source/bounded-document.js";
 // D2-N4 (spec docs/plans/specs/p2a-task-source-v4.md §3.1, §9): re-exported
-// at their EXISTING names so no importer changes. Only the two names a
-// surviving `src` consumer still imports (task-source-v4.ts,
-// commands/tasks/tasks.ts) — every other bounded-document re-export this
-// file used to carry was dropped in P4 §3.2.3.
-export { TASK_V3_MAX_SCHEDULES, TASK_V3_MAX_SOURCE_BYTES };
+// at its EXISTING name so no importer changes. The one name a surviving
+// `src` consumer still imports (task-source-v4.ts) — every other
+// bounded-document re-export this file used to carry was dropped in P4
+// §3.2.3.
+export { TASK_V3_MAX_SCHEDULES };
 export const TASK_EXTENSION = ".yml";
 export const TASK_NEAR_MISS_EXTENSION = ".yaml";
 /** Explain why the near-miss `.yaml` spelling is not a task source. */

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

@@ -115,7 +115,7 @@ import { appendEvent } from "../../core/events.js";
 import { validateJsonSchemaSubset } from "../../core/json-schema.js";
 import { runStructured } from "../../core/structured.js";
 import { warn } from "../../core/warn.js";
-import { assertFrozenDirectoryIdentity } from "../../execution/directory-identity.js";
+import { assertFrozenDirectoryContained } from "../../execution/directory-identity.js";
 import { assertFrozenExecutableIdentity } from "../../execution/executable-identity.js";
 import { withWorkflowRunsConnection, withWorkflowRunsRepo, } from "../../storage/repositories/workflow-runs-repository.js";
 import { materializeFrozenWorkflowEnvironment } from "../ir/environment-v4.js";
@@ -132,7 +132,7 @@ import { collectWorkflowDispatchSensitiveValues, redactUnitOutcome } from "./dis
 // and the process-outcome → failure-reason mapping.
 import { runExecUnit } from "./exec-unit.js";
 import { mergeLoweringNotices } from "./lowering-notices.js";
-import { LIFETIME_UNIT_CAP, scheduleUnits, UnitCapExceededError } from "./scheduler.js";
+import { scheduleUnits } from "./scheduler.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.
@@ -142,13 +142,13 @@ import { cleanupFrozenScript, frozenScriptCommand, materializeFrozenScript } fro
 import { enqueueUnitWrite } from "./unit-writer.js";
 import { assertGitWorkTree, cleanupUnitWorktree, createUnitWorktree } from "./worktree.js";
 /**
- * Mutable per-step dispatch budget: the lifetime unit cap PLUS the declared
- * run-level budget ceilings (`budget.max_units` / `budget.max_tokens`,
- * addendum R2). Consumed once per journaled dispatch attempt (including
- * retries); durable-row reuses never touch it — the peer-review fix that
- * keeps large partially-completed fan-outs resumable instead of tripping the
- * cap on `journaled + items`. Token usage accumulates per actual dispatch on
- * top of the journal-seeded run total (reused rows' tokens are already in the
+ * Mutable per-step dispatch budget: the declared run-level budget ceilings
+ * (`budget.max_units` / `budget.max_tokens`, addendum R2). Consumed once per
+ * journaled dispatch attempt (including retries); durable-row reuses never
+ * touch it — the peer-review fix that keeps large partially-completed
+ * fan-outs resumable instead of tripping a pre-batch check on
+ * `journaled + items`. Token usage accumulates per actual dispatch on top of
+ * the journal-seeded run total (reused rows' tokens are already in the
  * seed). Check-and-increment is synchronous, so concurrent units cannot race
  * it; crossing a declared ceiling fires `onExceeded` ONCE (the executor's
  * chained AbortController), aborting pending and in-flight dispatches.
@@ -157,8 +157,6 @@ class DispatchBudget {
     used;
     /** Run-total tokens: journal-seeded input + this step's dispatch usage. */
     tokens;
-    /** Set (once) when a dispatch was refused; the step fails with this message. */
-    capMessage;
     /** Set (once) when a declared budget ceiling was hit; the step fails hard with it. */
     budgetMessage;
     maxUnits;
@@ -185,10 +183,6 @@ class DispatchBudget {
                 `against the workflow's declared budget.max_tokens of ${this.maxTokens} — refusing further dispatch.`);
             return false;
         }
-        if (this.used >= LIFETIME_UNIT_CAP) {
-            this.capMessage ??= new UnitCapExceededError(LIFETIME_UNIT_CAP).message;
-            return false;
-        }
         this.used++;
         return true;
     }
@@ -343,7 +337,7 @@ async function prepareStepDispatchPrerequisites(input) {
         const target = workUnits[0]?.frozenTarget;
         const frozenCwd = target && "cwdIdentity" in target ? target.cwdIdentity : undefined;
         if (frozenCwd)
-            assertFrozenDirectoryIdentity(frozenCwd);
+            assertFrozenDirectoryContained(frozenCwd);
         const base = frozenCwd?.realRoot ?? ctx.workDir ?? process.cwd();
         const preflightWorktree = ctx.preflightWorktree ?? assertGitWorkTree;
         const gitError = preflightWorktree(base);
@@ -464,15 +458,12 @@ async function executeStepPlanInConnection(plan, ctx) {
     // journal-write failures must not erase notices already observed from real
     // dispatches; durable row reuses naturally contribute none.
     const notices = mergeLoweringNotices(...outcomes.map((outcome) => outcome?.notices));
-    // Declared budget ceilings and the lifetime cap are hard backstops: a step
-    // that hit one FAILS regardless of on_error policy (a capped run must never
-    // quietly pass its gate). The budget message names WHICH ceiling tripped.
+    // A declared budget ceiling is a hard backstop: a step that hit one FAILS
+    // regardless of on_error policy (a capped run must never quietly pass its
+    // gate). The budget message names WHICH ceiling tripped.
     if (budget.budgetMessage) {
         return { ...failedStep(budget.used, budget.budgetMessage, notices), tokensUsed: budget.tokens };
     }
-    if (budget.capMessage) {
-        return { ...failedStep(budget.used, budget.capMessage, notices), tokensUsed: budget.tokens };
-    }
     const units = outcomes.map((outcome, index) => outcome ?? {
         unitId: workUnits[index].unitId,
         ok: false,
@@ -597,17 +588,16 @@ async function runUnit(input) {
             });
         }
         const attemptId = attemptIdFor(attempt);
-        // Lifetime cap + declared budget ceilings, consumed per ACTUAL dispatch
-        // (reuses above returned before reaching here). Refusal fails this unit
-        // without journaling a row — nothing was dispatched — and the sticky
-        // capMessage/budgetMessage fails the step.
+        // Declared budget ceilings, consumed per ACTUAL dispatch (reuses above
+        // returned before reaching here). Refusal fails this unit without
+        // journaling a row — nothing was dispatched — and the sticky
+        // budgetMessage fails the step.
         if (!input.budget.tryConsume()) {
-            const budgetHit = input.budget.budgetMessage !== undefined;
             return (outcome ?? {
                 unitId,
                 ok: false,
-                failureReason: budgetHit ? "budget_exceeded" : "unit_cap_exceeded",
-                error: input.budget.budgetMessage ?? input.budget.capMessage ?? "lifetime unit cap exceeded",
+                failureReason: "budget_exceeded",
+                error: input.budget.budgetMessage ?? "budget exceeded",
             });
         }
         outcome = await dispatchJournaledAttempt({
@@ -1055,7 +1045,7 @@ async function dispatchUnit(request, dispatcher) {
 export const defaultUnitDispatcher = async (request, feedback) => {
     const frozenTarget = request.frozenTarget;
     if (frozenTarget.kind === "script") {
-        assertFrozenDirectoryIdentity(frozenTarget.cwdIdentity);
+        assertFrozenDirectoryContained(frozenTarget.cwdIdentity);
         if (frozenTarget.executable) {
             assertFrozenExecutableIdentity(frozenTarget.executable, `unit ${request.unitId} executable`);
         }
@@ -1099,7 +1089,7 @@ export const defaultUnitDispatcher = async (request, feedback) => {
     }
     if (frozenTarget.kind === "shell") {
         if (frozenTarget.cwdIdentity)
-            assertFrozenDirectoryIdentity(frozenTarget.cwdIdentity);
+            assertFrozenDirectoryContained(frozenTarget.cwdIdentity);
         if (frozenTarget.executable) {
             assertFrozenExecutableIdentity(frozenTarget.executable, `unit ${request.unitId} executable`);
         }

package/dist/workflows/exec/run-workflow.js

@@ -332,12 +332,11 @@ function workflowSummaryJudge(options, stepPlan, signal, owner) {
     return frozenSummaryJudge(stepPlan.gate.frozenJudge, signal, options.dispatcher ?? defaultUnitDispatcher, owner, options.eventSource);
 }
 /**
- * Seed the lifetime unit cap AND the budget ceilings from the journal so
- * both are truly per-RUN: a resumed or re-invoked run must not restart the
- * runaway backstop — or a declared `budget` — at zero. The append-only attempt
- * journal is authoritative: dispatch attempts count against
- * `budget.max_units`, and their known tokens count against
- * `budget.max_tokens`. Durable result reuse is free.
+ * Seed the declared budget ceilings from the journal so they are truly
+ * per-RUN: a resumed or re-invoked run must not restart a declared `budget`
+ * at zero. The append-only attempt journal is authoritative: dispatch
+ * attempts count against `budget.max_units`, and their known tokens count
+ * against `budget.max_tokens`. Durable result reuse is free.
  *
  * Gate-evaluation rows (`phase = "gate"`, journaled by the completion-gate
  * judge) are EXCLUDED from the seed: the live path never consumes

package/dist/workflows/exec/scheduler.js

@@ -15,17 +15,9 @@
  *   - Cooperative cancellation via AbortSignal (workers stop claiming items;
  *     the same signal is passed into each dispatch so in-flight units can be
  *     preempted too).
- *
- * The lifetime unit cap ({@link LIFETIME_UNIT_CAP}) is DECLARED here but
- * enforced per actual dispatch by the native executor: a pre-batch check
- * (`journaled + items.length`) counted durable-row REUSES as new dispatches,
- * which made any partially-completed fan-out with more than ~cap/2 journaled
- * units impossible to resume (peer review R1). Only work that really
- * dispatches consumes the cap.
  */
 import { concurrentMap } from "../../core/concurrent.js";
 import { cpuDerivedUnitConcurrency, workflowMaxConcurrency } from "../concurrency-policy.js";
-import { WORKFLOW_MAX_MAP_EXPANSION } from "../resource-limits.js";
 export { clampMaxConcurrency, cpuDerivedUnitConcurrency, WORKFLOW_MAX_CONCURRENCY_CEILING, } from "../concurrency-policy.js";
 /**
  * Hard ceiling on an EXPLICIT `workflow.maxConcurrency`. A user value above
@@ -49,21 +41,13 @@ export { clampMaxConcurrency, cpuDerivedUnitConcurrency, WORKFLOW_MAX_CONCURRENC
 export function maxUnitConcurrency(cpuCount, configured) {
     return workflowMaxConcurrency(configured, cpuCount);
 }
-/** Lifetime unit cap per run — a runaway-loop backstop, far above real use. */
-export const LIFETIME_UNIT_CAP = WORKFLOW_MAX_MAP_EXPANSION;
-export class UnitCapExceededError extends Error {
-    constructor(cap) {
-        super(`workflow run exceeded the lifetime unit cap (${cap}). Aborting dispatch — check for a runaway fan-out.`);
-        this.name = "UnitCapExceededError";
-    }
-}
 /**
  * Run `dispatch` over `items` under the engine concurrency caps. Individual
  * failures do not cancel siblings (allSettled semantics from `concurrentMap`);
  * a slot whose dispatch threw or that was never claimed after an abort stays
- * `undefined` in the result array. The lifetime unit cap is NOT checked here
- * — the executor consumes it per actual dispatch, so durable-row reuses on
- * resume stay free.
+ * `undefined` in the result array. A declared `budget.max_units` ceiling is
+ * NOT checked here — the executor consumes it per actual dispatch, so
+ * durable-row reuses on resume stay free.
  */
 export async function scheduleUnits(items, dispatch, options = {}) {
     const concurrency = Math.max(1, Math.min(options.concurrency ?? 1, options.maxConcurrency ?? Number.POSITIVE_INFINITY, options.llmConcurrency ?? Number.POSITIVE_INFINITY, options.hostConcurrency ?? cpuDerivedUnitConcurrency()));

package/dist/workflows/exec/step-work.js

@@ -22,7 +22,7 @@ import { canonicalInputJson, validateInputs } from "../../execution/input-contra
 import { withWorkflowRunsRepo, } from "../../storage/repositories/workflow-runs-repository.js";
 import { canonicalJson as canonicalJsonString } from "../ir/plan-hash.js";
 import { parseReference, resolveReferenceString, } from "../program/expressions.js";
-import { clip, WORKFLOW_MAX_MAP_EXPANSION, WORKFLOW_UNIT_DIAGNOSTIC_CLIP } from "../resource-limits.js";
+import { clip, WORKFLOW_UNIT_DIAGNOSTIC_CLIP } from "../resource-limits.js";
 import { completeWorkflowStep, isTruncatedEvidence, } from "../runtime/runs.js";
 import { GATE_EVALUATION_PHASE } from "../runtime/unit-phases.js";
 import { parseJudgeVerdict } from "../validate-summary.js";
@@ -60,9 +60,6 @@ const GATE_ARTIFACT_CLIP = 4_000;
  * deterministically, before dispatch.
  */
 function validateFanOutItems(stepId, items) {
-    if (items.length > WORKFLOW_MAX_MAP_EXPANSION) {
-        return `Step "${stepId}" fan-out expands to ${items.length} units, exceeding the ${WORKFLOW_MAX_MAP_EXPANSION}-unit resource limit.`;
-    }
     const nullIndex = items.findIndex((item) => item === null || item === undefined);
     if (nullIndex !== -1) {
         return (`Step "${stepId}" fan-out list contains a null item (index ${nullIndex}). ` +

package/dist/workflows/exec/unit-dispatch.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/.
 import { ConfigError } from "../../core/errors.js";
-import { assertFrozenDirectoryIdentity } from "../../execution/directory-identity.js";
+import { assertFrozenDirectoryContained } from "../../execution/directory-identity.js";
 import { assertFrozenExecutableIdentity } from "../../execution/executable-identity.js";
 import { canonicalResolvedExecutionRequest, decodeResolvedExecutionRequest, } from "../../execution/resolved-request.js";
 import { dispatchLoweredExecutionRequest, lowerResolvedExecutionRequestWithRunner, } from "../../integrations/agent/execution-lowering.js";
@@ -11,7 +11,7 @@ import { getHarness } from "../../integrations/harnesses/index.js";
 export function prepareWorkflowExecution(request, prompt = request.prompt) {
     const target = request.frozenTarget;
     if (target.cwdIdentity)
-        assertFrozenDirectoryIdentity(target.cwdIdentity);
+        assertFrozenDirectoryContained(target.cwdIdentity);
     if (target.executable)
         assertFrozenExecutableIdentity(target.executable, `unit ${request.unitId} executable`);
     const wire = JSON.parse(canonicalResolvedExecutionRequest(target.request));

package/dist/workflows/exec/worktree.js

@@ -67,7 +67,7 @@ import { spawnSync } from "node:child_process";
 import fsp from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { isWithinAsync, safeRealpathAsync } from "../../core/common.js";
+import { isProcessAlive, isWithinAsync, safeRealpathAsync } from "../../core/common.js";
 import { serializeByKey } from "../../core/concurrent.js";
 import { runManagedSubprocess } from "../../core/subprocess.js";
 import { warn } from "../../core/warn.js";
@@ -417,18 +417,6 @@ async function isWorktreeLeaseLive(candidate) {
         return false;
     return isProcessAlive(lease.pid);
 }
-/** `kill(pid, 0)` liveness probe. EPERM proves the process exists but is not ours. */
-function isProcessAlive(pid) {
-    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        return err.code === "EPERM";
-    }
-}
 // ── Garbage collection ──────────────────────────────────────────────────────
 /**
  * Drop the run-scoped root once its last unit worktree is gone. `rmdir`