akm-cli 0.10.261012-beta → 0.10.261014-beta

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

@@ -7,21 +7,26 @@ import { DEFAULT_SCHEDULED_TASK_TIMEOUT_MS } from "./run-workflow-task.js";
 import { appendHistory } from "./task-history.js";
 import { persistRunLog, scrubTaskOutput, streamLines } from "./task-log.js";
 export async function runPreparedCommandTask(input) {
-    const { task, logPath, startedAt, now, agentOptions, provenance } = input;
+    const { task, logPath, startedAt, now, provenance } = input;
     const dispatchOptions = {
         ...(input.runAgentImpl ? { runAgent: input.runAgentImpl } : {}),
-        ...(input.chatCompletionImpl ? { chat: input.chatCompletionImpl } : {}),
-        ...(agentOptions ? { runOptions: agentOptions } : {}),
-        // F-1 (R-07 fix, spec §5.2 point 3): threads the resolved event source
-        // into the dispatched engine's child env and the recorded usage events.
+        // Threads the resolved event source into the dispatched harness's child env
+        // and the recorded usage events.
         eventSource: provenance.eventSource,
     };
-    // Unset anywhere (task `timeout:`, command asset, engine) → the unattended
-    // default; an explicit value or `null` (opt-out) already sits on the request.
-    const { request, runner } = task.invocation;
-    const unset = !Object.hasOwn(request.runtime, "timeoutMs") && runner.timeoutMs === undefined;
+    // Unset anywhere (task `timeout:`, command asset, connection or harness) → the
+    // unattended default; an explicit value or `null` (opt-out) was set by one of them.
+    const { runner, request, provenance: provenances } = task.invocation;
+    const unset = provenances["runtime.timeoutMs"]?.via === "default";
     const invocation = unset
-        ? { ...task.invocation, runner: { ...runner, timeoutMs: DEFAULT_SCHEDULED_TASK_TIMEOUT_MS } }
+        ? {
+            ...task.invocation,
+            request: {
+                ...request,
+                runtime: { ...request.runtime, timeoutMs: DEFAULT_SCHEDULED_TASK_TIMEOUT_MS },
+            },
+            runner: { ...runner, timeoutMs: DEFAULT_SCHEDULED_TASK_TIMEOUT_MS },
+        }
         : task.invocation;
     const result = await dispatchPreparedCommandInvocation(invocation, dispatchOptions);
     const engineName = result.engine;

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

@@ -6,21 +6,15 @@
  * shell-command builders (`shellCommand`, `resolveLeadingBareAkmCommand`,
  * `quoteShellArgument`).
  *
- * Moved from src/tasks/runner.ts (spec docs/plans/specs/p1b-model-extraction.md
- * §5.1, §9, runner.ts:294-455).
+ * The child env's `AKM_EVENT_SOURCE` stamp reads `provenance.eventSource`
+ * (`"task"` under the default provenance context, run/provenance.ts).
  *
- * F-1 (spec §5.2 point 1): the child env's `AKM_EVENT_SOURCE` stamp now reads
- * `provenance.eventSource` instead of the hardcoded literal `"task"` — with
- * the default provenance context (run/provenance.ts) this is byte-equivalent
- * to before (P-06 stays green unchanged).
- *
- * F-2 (D8, spec §5.3): the result's `target` is now `{kind:"shell", cmd}` or
- * `{kind:"script", cmd}` — formerly one shared `{kind:"command", cmd}`.
+ * The result's `target` is `{kind:"shell", cmd}` or `{kind:"script", cmd}`.
  */
 import path from "node:path";
 import { assertNever } from "../../core/assert.js";
+import { childProcessEnv } from "../../core/paths.js";
 import { runManagedSubprocess, streamCaptureFailure } from "../../core/subprocess.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";
@@ -152,7 +146,7 @@ export async function runNativeTask(input) {
     // above) — a timeout or SIGTERM to the direct child would reap the whole
     // group, but nothing tied THIS process's own termination to that same
     // ladder, so a signal to the runner left its child running as an orphan.
-    // Aborting `runManagedSubprocess` here runs its normal SIGTERM→SIGKILL
+    // Aborting `runManagedSubprocess` here runs its normal SIGINT→SIGTERM→SIGKILL
     // kill ladder against the child's process group.
     const abortController = new AbortController();
     const forwardTerminationSignal = (signal) => {
@@ -163,20 +157,13 @@ export async function runNativeTask(input) {
     process.once("SIGTERM", onSigterm);
     process.once("SIGINT", onSigint);
     try {
-        // 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);
         }
         // Managed spawn (src/core/subprocess.ts): process-GROUP kill so a timeout
-        // reaps the whole command tree (no orphans), and a SIGTERM→SIGKILL ladder
-        // so a child that ignores SIGTERM can't wedge the run forever. `signal`
+        // reaps the whole command tree (no orphans), and a SIGINT→SIGTERM→SIGKILL
+        // ladder so a child that ignores both can't wedge the run forever. `signal`
         // ties that same ladder to a termination signal received by this
         // process itself (#956), not only to the timeout.
         const result = await runManagedSubprocess(cmd, {
@@ -187,7 +174,7 @@ export async function runNativeTask(input) {
             // A more specific stamp already in the environment (e.g. improve's
             // AKM_EVENT_SOURCE=improve on its child spawns) still wins in children.
             env: {
-                ...process.env,
+                ...childProcessEnv(),
                 ...task.environment,
                 AKM_EVENT_SOURCE: process.env.AKM_EVENT_SOURCE ?? provenance.eventSource,
             },

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

@@ -6,22 +6,21 @@
  * scheduled moment.
  *
  * The durable boundary is intentional: id/bundle resolution, source read,
- * strict task source parsing, target resolution, command
- * authorization/lowering, workflow projectability, and frozen script-byte
+ * strict task source parsing, target resolution, command lowering, workflow
+ * projectability, and frozen script-byte
  * capture (load-task.ts) all finish before an attempt is reserved or a log is
  * created (attempt-lifecycle.ts). Once prepared, the runner dispatches the
  * immutable command, workflow, shell, or script projection to its own arm
  * module (run-command-task.ts, run-workflow-task.ts, run-native-task.ts) and
  * records that actual attempt. Task source v4 has no document-level disabled
- * state to skip at fire time (P4-N6) — a schedule binding that should not
+ * state to skip at fire time — a schedule binding that should not
  * fire is never installed with the OS scheduler in the first place
  * (scheduler-sync.ts), so every invocation that reaches `runTask` dispatches.
  *
  * Orchestration only.
  *
- * D5 (spec §1.2/§5.2, "Threading"): resolves `options.provenance` against the
- * default context (run/provenance.ts) ONCE per call, and threads the result
- * into every dispatch arm.
+ * Resolves `options.provenance` against the default context (run/provenance.ts)
+ * ONCE per call, and threads the result into every dispatch arm.
  */
 import { runWorkflowSteps } from "../../workflows/exec/run-workflow.js";
 import { recordTaskAttemptFailure, reserveTaskAttempt } from "./attempt-lifecycle.js";
@@ -67,8 +66,6 @@ export async function runTask(id, options) {
                 historyReserved: attempt.historyReserved,
                 provenance,
                 runAgentImpl: options.runAgentImpl,
-                agentOptions: options.agentOptions,
-                chatCompletionImpl: options.chatCompletionImpl,
             });
         }
         options.beforeNativeDispatch?.(task);

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

@@ -7,18 +7,12 @@
  * (`DEFAULT_WORKFLOW_TASK_TIMEOUT_MS`, `DEFAULT_SCHEDULED_TASK_TIMEOUT_MS`)
  * every arm reads.
  *
- * Moved from src/tasks/runner.ts (spec docs/plans/specs/p1b-model-extraction.md
- * §5.1, §9, runner.ts:456-675).
- *
- * F-1 (spec §5.2 point 2): the global `process.env.AKM_EVENT_SOURCE` stamp
- * and its `finally` restore are DELETED outright — `process.env` is never
- * written by this arm any more. The resolved event source is instead passed
- * into `runWorkflowStepsImpl` via a new optional `eventSource` option,
- * `process.env.AKM_EVENT_SOURCE ?? provenance.eventSource` (ambient still
- * wins, matching the native arm's own precedence — D5 clause d). Threading
- * that option to an exec-unit child's env is owned by
- * src/workflows/exec/run-workflow.ts / step-work.ts / exec-unit.ts, not this
- * file.
+ * `process.env` is never written by this arm. The resolved event source is
+ * passed into `runWorkflowStepsImpl` via the optional `eventSource` option,
+ * `process.env.AKM_EVENT_SOURCE ?? provenance.eventSource` (ambient wins,
+ * matching the native arm's own precedence). Threading that option to an
+ * exec-unit child's env is owned by src/workflows/exec/run-workflow.ts /
+ * step-work.ts / exec-unit.ts, not this file.
  */
 import { armAbortDeadline } from "../../core/abort-deadline.js";
 import { assertNever } from "../../core/assert.js";
@@ -71,7 +65,7 @@ export async function runWorkflowTask(input) {
     // aborted by a timer. The engine reads `options.signal` at every step
     // boundary and breaks GRACEFULLY — in-flight units are cancelled, the journal
     // and the run lease are retained, and the run is left `active`, i.e.
-    // resumable with `akm workflow resume`.
+    // continuable with `akm workflow run <run-id>`.
     const controller = new AbortController();
     const deadline = armAbortDeadline(controller, {
         timeoutMs,
@@ -85,13 +79,12 @@ export async function runWorkflowTask(input) {
     // The prompt path logs the engine-fallback announcement; a workflow-backed
     // task must leave the same trace rather than silently using a chosen engine.
     let runWarnings = [];
-    // F-1 (D5, spec §5.2 point 2): thread the resolved event source through
-    // explicitly instead of stamping process.env — this arm executes IN-PROCESS,
-    // so a global stamp used to be how child akm invocations made by workflow
-    // steps inherited it; the explicit eventSource option (threaded to
-    // src/workflows/exec/run-workflow.ts -> step-work.ts -> exec-unit.ts's
-    // childEnv) now does that job without ever mutating process.env. A more
-    // specific ambient stamp already present still wins, matching the native arm.
+    // Thread the resolved event source through explicitly instead of stamping
+    // process.env — this arm executes IN-PROCESS, so the explicit eventSource option
+    // (threaded to src/workflows/exec/run-workflow.ts -> step-work.ts -> exec-unit.ts's
+    // childEnv) is how child akm invocations made by workflow steps inherit it,
+    // without ever mutating process.env. A more specific ambient stamp already
+    // present still wins, matching the native arm.
     const eventSource = process.env.AKM_EVENT_SOURCE ?? provenance.eventSource;
     try {
         const execution = await runWorkflowStepsImpl({
@@ -130,7 +123,7 @@ export async function runWorkflowTask(input) {
     const timeoutError = timedOutAfterMs === undefined
         ? undefined
         : new Error(`Workflow run timed out after ${timedOutAfterMs}ms and was aborted at a step boundary` +
-            (detail?.id ? ` — resume it with \`akm workflow resume ${detail.id}\`.` : "."));
+            (detail?.id ? ` — continue it with \`akm workflow run ${detail.id}\`.` : "."));
     // One failure value for the three sinks below (status, log line, history
     // detail): a thrown error outranks a gate rejection, which outranks the
     // deadline. Re-laddering per sink is how a log line ends up naming a

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

@@ -5,24 +5,16 @@
  * The task_history read/write boundary: `appendHistory` (write) and
  * `readTaskHistory` / `taskHistoryRowToResult` (read).
  *
- * Moved from src/tasks/runner.ts (spec docs/plans/specs/p1b-model-extraction.md
- * §5.1, §9, runner.ts:1071-1158). `appendHistory` was module-private at head;
- * it is exported here because every dispatch arm (run-native-task.ts,
- * run-workflow-task.ts, run-command-task.ts), attempt-lifecycle.ts, and
- * run-task.ts's disabled-task path all call it (spec §5.1's module split
- * moves what was one file's internal call graph across several files).
+ * `appendHistory` is exported because every dispatch arm (run-native-task.ts,
+ * run-workflow-task.ts, run-command-task.ts) and attempt-lifecycle.ts call it.
  *
- * D8 result-vocabulary re-code (why, and the WRITE side's exact shape): see
- * docs/architecture/decisions/0005-task-result-vocabulary-and-legacy-read-mapping.md.
- * The READ side used to carry a permanent legacy-vocabulary mapping here
- * (row B-51 of docs/plans/specs/p4-deletions-closeout.md called deleting it
- * "review-blocking") — SUPERSEDED: `task_history` is DB-owned data, so the
- * remap is now a one-time schema migration
- * (`025-task-history-vocabulary-backfill` in src/core/state/migrations.ts)
- * instead of a read-side shim run forever. Every row this function sees now
- * carries the current vocabulary's `target_kind` strings; the P0-pinned null
- * fallbacks still apply (workflow `ref` falls back to `""`, the command
- * arm's `engine` falls back to `null`).
+ * The READ side carries no legacy-vocabulary mapping: `task_history` is
+ * DB-owned data, so the remap to the current vocabulary is a one-time schema
+ * migration (`025-task-history-vocabulary-backfill` in
+ * src/core/state/migrations.ts) rather than a read-side shim run forever.
+ * Every row this function sees carries the current vocabulary's `target_kind`
+ * strings; the null fallbacks still apply (workflow `ref` falls back to `""`,
+ * the command arm's `engine` falls back to `null`).
  *
  * A DAG leaf with respect to the rest of src/tasks/run/**: this module
  * imports TaskRunResult/TaskRunStatus's TYPE from ./task-result but no VALUE

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

@@ -6,14 +6,10 @@
  * structured logs.db rows, and the shared redaction pass both sinks go
  * through before either is written.
  *
- * Moved body-intact from src/tasks/runner.ts (spec
- * docs/plans/specs/p1b-model-extraction.md §5.1, runner.ts:779-968).
- *
  * A DAG leaf with respect to the rest of src/tasks/run/**: nothing here
  * imports ./task-result, ./task-history, or ./attempt-lifecycle, so every
  * other run/** module can depend on this one without risking an import
- * cycle (tests/architecture/import-cycle-ratchet.test.ts counts type-only
- * imports as real edges too).
+ * cycle.
  */
 import fs from "node:fs";
 import path from "node:path";

package/dist/tasks/scheduler-invocation.js

@@ -52,11 +52,7 @@ export const SCHEDULED_TASK_CONTEXT_KEYS = [
  * held their locks in a `locks/` directory no interactive command could see.
  */
 const EXPLICIT_CONTEXT_KEYS = ["AKM_CONFIG_DIR", "AKM_DATA_DIR", "AKM_CACHE_DIR", "AKM_STATE_DIR"];
-/**
- * The AKM directory context of the current process. Child environments that
- * are built from an allowlist must forward this closed set explicitly so
- * nested AKM commands stay in the same installation.
- */
+/** The AKM directory context of the current process, so nested AKM commands stay in the same installation. */
 export function scheduledTaskContextEnv(env = process.env) {
     const out = {};
     for (const key of SCHEDULED_TASK_CONTEXT_KEYS) {
@@ -207,11 +203,10 @@ function parsePublicSchedulerInvocation(invocation) {
         }
         if (invocation[index] !== "--scheduled")
             return undefined;
-        // P2b Lane B (spec §4.4, §1.7 B-N3): zero or more `--<name> <value>`
-        // schedule-supplied input flags may follow `--scheduled` — the same
-        // trailing tail `compileTaskSchedulerBindings` compiles from
-        // `schedule[i].inputs`. Absent/empty is the pre-P2b shape, byte-identical
-        // (B-03).
+        // Zero or more `--<name> <value>` schedule-supplied input flags may follow
+        // `--scheduled` — the same trailing tail `compileTaskSchedulerBindings`
+        // compiles from `schedule[i].inputs`. Absent/empty is the earlier,
+        // byte-identical shape.
         if (!isValidSchedulerInputFlagTail(invocation.slice(index + 1)))
             return undefined;
         return { invocation: [...invocation], ...(target !== undefined ? { target } : {}) };
@@ -233,23 +228,23 @@ function parsePublicSchedulerInvocation(invocation) {
     }
 }
 /**
- * Validate an OPTIONAL trailing schedule-input flag tail (spec §1.7 B-N3):
- * empty is valid (the pre-P2b shape). Otherwise the tail is a sequence of
+ * Validate an OPTIONAL trailing schedule-input flag tail: empty is valid
+ * (the earlier shape). Otherwise the tail is a sequence of
  * entries, each EITHER:
  *
- *   - a single inline `--<name>=<value>` token (code-review finding,
- *     scheduler-binding.ts:536 — the ONLY encoding a dash-leading value's
- *     exact text can round-trip through, since `<value>` here is everything
- *     after the first `=`, whatever its leading character); or
+ *   - a single inline `--<name>=<value>` token (the ONLY encoding a
+ *     dash-leading value's exact text can round-trip through, since `<value>`
+ *     here is everything after the first `=`, whatever its leading character);
+ *     or
  *   - a `(--<name>, <value>)` pair, where `<value>` is a single non-flag
- *     token (does not start with `-`) — the pre-P2b shape.
+ *     token (does not start with `-`) — the earlier shape.
  *
  * In both forms `<name>` matches {@link INPUT_NAME_PATTERN} and no name
  * repeats. A bare flag, a repeated name, a flag-shaped value in the pair
  * form, or a malformed token are all refused. This validates SHAPE only;
  * the real materialization against the task's declared contract happens
  * through the same `parseTaskInputFlags` + `materializeInputFlags` path
- * `akm task run --<name>` already uses (B-48) — `parseTaskInputFlags`
+ * `akm task run --<name>` already uses — `parseTaskInputFlags`
  * accepts both forms natively (its inline-`=` branch never inspects the
  * value's leading character).
  */

package/dist/tasks/scheduler-sync.js

@@ -49,7 +49,6 @@ async function compileTaskSources(input, desired, failures) {
             const parsed = parseTaskSource({
                 yaml: fs.readFileSync(file, "utf8"),
                 filePath: file,
-                workspaceRoot: input.sourceRoot,
             });
             // A task with no `schedule:` is run by hand or by a workflow step; it
             // contributes no binding and is not sync's to validate.

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

@@ -3,48 +3,29 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * The bounded-document front end and field helpers both task source grammars
- * share (spec docs/plans/specs/p2a-task-source-v4.md §1.5 D2-N4, §3.1).
- *
- * This is the actual D2-N4 move, not a parallel reimplementation: every
- * helper below — including the `TASK_V3_MAX_*` resource bounds and
- * `assertBoundedTaskYamlDocument` — is now OWNED here, body-intact from
- * `src/tasks/source-v3.ts`. `source-v3.ts` imports every one of them (and
- * re-exports `assertBoundedTaskYamlDocument` / the `TASK_V3_MAX_*` constants
- * at their existing names, since those were already part of its public
- * surface) instead of declaring its own copies. §9's acceptance criterion is
- * structural: "src/tasks/source/bounded-document.ts exists and owns the
- * D2-N4 helpers; src/tasks/source-v3.ts imports them and contains no copy of
- * any of them" — `tests/tasks/bounded-document.test.ts`'s last describe
- * block pins this with an AST scan of `source-v3.ts`, not just a runtime
- * behavior check (a copy-instead-of-move implementation would pass every
- * OTHER test in that file and in `tests/tasks/source-v3.test.ts`, because
- * both files would still call functions they have in scope either way).
+ * share. Every helper below — including the `TASK_V3_MAX_*` resource bounds and
+ * `assertBoundedTaskYamlDocument` — is owned here. `source-v3.ts` imports every
+ * one of them (and re-exports `assertBoundedTaskYamlDocument` and the
+ * `TASK_V3_MAX_*` constants at their existing names, since those were already
+ * part of its public surface) and declares no copy of any of them.
+ * `tests/tasks/bounded-document.test.ts`'s last describe block pins this with
+ * an AST scan of `source-v3.ts`, not just a runtime behavior check (a copy
+ * would pass every other test in that file and in
+ * `tests/tasks/source-v3.test.ts`, because both files would still call
+ * functions they have in scope either way).
  *
  * This module deliberately imports NOTHING from `../source-v3` (not even a
- * type) — `tests/architecture/import-cycle-ratchet.test.ts` is an ABSOLUTE
- * no-cycle gate over all of `src/**` (its baseline emptied at chunk-8 and
- * counts type-only imports as real graph edges), and `source-v3.ts` now
- * imports from this file, so a reverse edge here would close a cycle. Where
- * a moved helper's signature referenced a v3-only type
- * (`TaskV3AkmOptions["tools"]`, `TaskV3Environment`) the return type is
- * inlined structurally instead — invisible at runtime, and TypeScript's
- * structural typing makes the inlined shape and the named alias
- * interchangeable at every call site.
+ * type): `source-v3.ts` imports from this file, so a reverse edge here would
+ * close an import cycle. Where a helper's signature referenced a v3-only type
+ * (`TaskV3Environment`) the return type is inlined structurally instead —
+ * invisible at runtime, and TypeScript's structural typing makes the inlined
+ * shape and the named alias interchangeable at every call site.
  *
- * `parseTimeout` and `parseTools` stay v3-only in the sense that they
- * hardcode the `["akm", …]` field path (byte-identical to v3's existing
- * behavior — that hardcoding is exactly what D2-N4's binding resolution asks
- * to preserve). Task source v4's top-level `timeout:`/`tools:` fields have
- * their own siblings in `src/tasks/source/task-source-v4.ts`
- * (`parseTimeoutTopLevel`/`parseToolsTopLevel`) with the same accept/reject
- * semantics at a different, un-prefixed field path — v3 imports the two
- * below rather than declaring them itself, purely because D2-N4 homes every
- * one of these named helpers here. `nullableSelector` is the same kind of
- * `["akm", …]`-hardcoding helper but is NOT in D2-N4's named list and stays
- * declared directly in `source-v3.ts`.
+ * `parseTimeout` hardcodes the `["akm", …]` field path. Task source v4's
+ * top-level `timeout:` field has its own sibling in
+ * `src/tasks/source/task-source-v4.ts` (`parseTimeoutTopLevel`) with the same
+ * accept/reject semantics at a different, un-prefixed field path.
  */
-import fs from "node:fs";
-import path from "node:path";
 import { types as utilTypes } from "node:util";
 import { isAlias, isMap, isScalar, isSeq, LineCounter, parseDocument } from "yaml";
 import { wellFormedUnicode } from "../../core/common.js";
@@ -238,63 +219,6 @@ export function parseTimeout(value, ctx) {
     }
     return value;
 }
-/**
- * `akm.tools` — v3-only (hardcodes the `["akm", "tools"]` field path, see
- * this module's header). Body-intact from `source-v3.ts`; the return type is
- * inlined (was `TaskV3AkmOptions["tools"]`) so this module imports nothing
- * from `../source-v3` (see header — the import-cycle ratchet is absolute).
- */
-export function parseTools(value, ctx) {
-    if (value === null || typeof value === "string")
-        return value;
-    if (Array.isArray(value)) {
-        if (value.some((entry) => typeof entry !== "string"))
-            sourceError(ctx, ["akm", "tools"], "array values must be strings.");
-        return value;
-    }
-    if (typeof value === "object")
-        return value;
-    sourceError(ctx, ["akm", "tools"], "must be a string, string array, mapping, or null.");
-}
-/**
- * `working-directory:` is already a top-level field in both grammars —
- * reused body-intact, field path unchanged (`source-v3.ts:677-714`).
- */
-export function validateWorkingDirectory(value, ctx) {
-    if (value.trim().length === 0 ||
-        value.includes("\0") ||
-        path.posix.isAbsolute(value.replaceAll("\\", "/")) ||
-        /^[A-Za-z]:[\\/]/.test(value) ||
-        value.startsWith("\\\\")) {
-        sourceError(ctx, ["working-directory"], "must be a non-empty relative path contained by the workspace root.");
-    }
-    const segments = value.replaceAll("\\", "/").split("/");
-    if (segments.some((segment) => segment === ".." || segment.length === 0)) {
-        sourceError(ctx, ["working-directory"], "must not contain empty or escaping path segments.");
-    }
-    if (!ctx.workspaceRoot) {
-        sourceError(ctx, ["working-directory"], "requires a workspace root so physical containment can be verified.");
-    }
-    let realRoot;
-    let realCandidate;
-    try {
-        realRoot = fs.realpathSync(ctx.workspaceRoot);
-        const candidate = path.resolve(realRoot, value);
-        const stat = fs.statSync(candidate);
-        if (!stat.isDirectory())
-            sourceError(ctx, ["working-directory"], "must resolve to a directory.");
-        realCandidate = fs.realpathSync(candidate);
-    }
-    catch (cause) {
-        if (cause instanceof UsageError)
-            throw cause;
-        sourceError(ctx, ["working-directory"], `cannot be physically verified: ${cause instanceof Error ? cause.message : String(cause)}.`);
-    }
-    const relative = path.relative(realRoot, realCandidate);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        sourceError(ctx, ["working-directory"], "resolves outside the workspace root and is not physically contained.");
-    }
-}
 export function yamlProblem(message) {
     return message.split("\n")[0]?.trim() || "invalid YAML";
 }
@@ -373,32 +297,22 @@ export function assertBoundedTaskYamlDocument(document, options) {
 }
 /**
  * Parse hostile YAML without aliases/tags/merges, then hand back the bounded
- * `{root, lineAt}` pair both grammars that read a task document consume —
- * originally lifted from the now-deleted `parseTaskV3Yaml`
- * (`source-v3.ts:894-952`), generalized only by `sourceLabel`.
+ * `{root, lineAt}` pair both grammars that read a task document consume,
+ * generalized by `sourceLabel`.
  *
- * P4 (docs/plans/specs/p4-deletions-closeout.md §3.2) deleted task v3
- * acceptance from `src` entirely — `parseTaskV3Yaml` and its `"task v3
- * source"` label no longer exist here (the grammar survives only in the
- * vendored, frozen `scripts/akm-migrate/migrate/task-source-v3-frozen.ts`
- * copy, which does not call this function). The two live `src` callers
- * today: `parseTaskSourceV4`'s standalone YAML-string entry
- * (`task-source-v4.ts:790`) passes `sourceLabel: "task source v4"`; the
- * version router (`parse-task-source.ts:61`) calls this directly with
- * `sourceLabel: "task source"` — not "task v3 source" — because its front
- * end runs before `root.version` is even read, so it cannot yet know which
- * schema version the document will turn out to be.
+ * The two live `src` callers: `parseTaskSourceV4`'s standalone YAML-string entry
+ * (`task-source-v4.ts`) passes `sourceLabel: "task source v4"`; the version
+ * router (`parse-task-source.ts`) calls this directly with
+ * `sourceLabel: "task source"` because its front end runs before
+ * `root.version` is even read, so it cannot yet know which schema version the
+ * document will turn out to be.
  */
 export function readBoundedTaskSourceYaml(input, options) {
     const sourceLabel = options.sourceLabel;
-    // P4 (docs/plans/specs/p4-deletions-closeout.md §5.2, row R-R8): these six
-    // throws used to omit their `code` argument and rely on the constructor's
-    // `INVALID_FLAG_VALUE` default (a pre-P4 ratchet-gaming trick that kept the
-    // literal string out of the grep-style count while the effective code
-    // stayed generic). §5.2's target table closes that gap: every pre-version
-    // failure in this bounded YAML front end (not a string, too large, YAML
-    // parse/expansion) is a task-source defect, not a flag-parsing one, so each
-    // now carries `TASK_SOURCE_INVALID` explicitly.
+    // Every pre-version failure in this bounded YAML front end (not a string, too
+    // large, YAML parse/expansion) is a task-source defect, not a flag-parsing
+    // one, so each throw carries `TASK_SOURCE_INVALID` explicitly instead of the
+    // constructor's `INVALID_FLAG_VALUE` default.
     if (typeof input.yaml !== "string") {
         throw new UsageError(`Invalid ${sourceLabel} at ${input.filePath}: source must be a string.`, "TASK_SOURCE_INVALID");
     }

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

@@ -75,7 +75,6 @@ export function parseTaskSource(input) {
     }
     const documentOptions = {
         filePath: input.filePath,
-        ...(input.workspaceRoot ? { workspaceRoot: input.workspaceRoot } : {}),
         lineAt,
     };
     return Object.freeze({ version: 4, v4: parseTaskSourceV4Document(root, documentOptions) });

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

@@ -21,14 +21,16 @@ function projectAkm(document) {
     const execution = document.execution;
     if (execution.agent !== undefined)
         out.agent = execution.agent;
+    if (execution.connection !== undefined)
+        out.connection = execution.connection;
+    if (execution.harness !== undefined)
+        out.harness = execution.harness;
     if (execution.engine !== undefined)
         out.engine = execution.engine;
     if (execution.model !== undefined)
         out.model = execution.model;
     if (execution.inference !== undefined)
         out.inference = execution.inference;
-    if (execution.tools !== undefined)
-        out.tools = execution.tools;
     if (execution.timeout !== undefined)
         out.timeout = execution.timeout;
     if (execution.redact !== undefined)
@@ -41,7 +43,7 @@ function projectAkm(document) {
         out.outputSchema = document.output;
     return Object.keys(out).length > 0 ? Object.freeze(out) : undefined;
 }
-/** Project one parsed task source v4 document into the prepare seam's existing input shape (spec §3.5). */
+/** Project one parsed task source v4 document into the prepare seam's existing input shape. */
 export function projectTaskSourceV4(document) {
     const akm = projectAkm(document);
     const schedules = Object.freeze(document.schedule.map((entry) => Object.freeze({ cron: entry.cron, source: entry.source, ordinal: entry.ordinal })));

package/dist/tasks/source/task-input-diagnostics.js

@@ -3,8 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * `TASK_INPUT_DIAGNOSTICS` — the task-side message/code vocabulary for
- * `materializeInputFlags` (spec docs/plans/specs/p2a-task-source-v4.md §1.5
- * D3-N3, §4.2, §5.1).
+ * `materializeInputFlags`.
  *
  * `materializeInputFlags` (`src/execution/input-contract.ts`) contains no
  * literal user-facing string of its own — every message/code it raises comes
@@ -13,8 +12,8 @@
  * is that same seam's task-side sibling, consumed by `akm task run`'s Stage 2
  * (`src/tasks/run/load-task.ts`). Mirrors `WORKFLOW_PARAMETER_DIAGNOSTICS`'s
  * shape exactly (`unknownFlag`'s declared-name enumeration in the SEPARATE
- * `hint`, not the message — `params.ts:65-72`) with task-flavored nouns and
- * the codes §5.1 binds: `UNKNOWN_FLAG` for an undeclared name,
+ * `hint`, not the message) with task-flavored nouns and
+ * the codes `UNKNOWN_FLAG` for an undeclared name,
  * `INPUT_BINDING_INVALID` for every value/contract failure.
  */
 import { UsageError } from "../../core/errors.js";