akm-cli 0.9.2-alpha.4 → 0.9.2

package/dist/assets/tasks/improve/akm-improve-catchup.yml

@@ -1,9 +1,9 @@
-version: 3
+version: 4
 run: akm improve --strategy catchup --skip-if-locked
-akm:
-  schedule: "0 4 * * *"
+description: Manual recovery — consolidation + triage drain (run on demand via `akm task run akm-improve-catchup`)
 # Manual-recovery task: ships disabled (the retired registerDefaultTasks
 # marked it enableMode: "manual"). `akm task run` works while disabled;
-# opting into the schedule is `enabled: true` + `akm task sync`.
-  enabled: false
-  description: Manual recovery — consolidation + triage drain (run on demand via `akm task run akm-improve-catchup`)
+# opting into the schedule is `schedule[].enabled: true` + `akm task sync`.
+schedule:
+  - cron: "0 4 * * *"
+    enabled: false

package/dist/assets/tasks/improve/akm-improve-consolidate.yml

@@ -1,6 +1,4 @@
-version: 3
+version: 4
 run: akm improve --strategy consolidate --skip-if-locked
-akm:
-  schedule: "20 */4 * * *"
-  enabled: true
-  description: Consolidation-only pass (every 4h at :20)
+description: Consolidation-only pass (every 4h at :20)
+schedule: "20 */4 * * *"

package/dist/assets/tasks/improve/akm-improve-frequent.yml

@@ -1,6 +1,4 @@
-version: 3
+version: 4
 run: akm improve --strategy frequent --skip-if-locked
-akm:
-  schedule: "40 * * * *"
-  enabled: true
-  description: Frequent inference pass (hourly at :40; improve-stage extract off)
+description: Frequent inference pass (hourly at :40; improve-stage extract off)
+schedule: "40 * * * *"

package/dist/assets/tasks/improve/akm-improve-nightly.yml

@@ -1,6 +1,4 @@
-version: 3
+version: 4
 run: akm improve --strategy thorough --skip-if-locked
-akm:
-  schedule: "15 2 * * *"
-  enabled: true
-  description: Full nightly quality sweep (daily 2:15am; suggested for server installs)
+description: Full nightly quality sweep (daily 2:15am; suggested for server installs)
+schedule: "15 2 * * *"

package/dist/cli/unknown-flags.js

@@ -181,7 +181,18 @@ export function assertKnownFlags(root, rawArgs) {
     const known = collectKnownArgs(root, rawArgs);
     if (!known.resolved)
         return;
-    const dynamicWorkflowParams = known.path.join(" ") === "workflow run";
+    // `workflow run`, `task run`, and `task explain` each own one deliberately
+    // dynamic namespace: long options become exact-name parameter/input flags
+    // and are checked against the frozen plan / task source's own contract
+    // before this gate would otherwise reject them (spec
+    // docs/plans/specs/p2a-task-source-v4.md §5.1 — task run's
+    // UNKNOWN_FLAG/INPUT_BINDING_INVALID must be raised from INSIDE the command
+    // body, where runWithJsonErrors renders the JSON envelope, not from this
+    // generic pre-dispatch gate; docs/plans/specs/p2b-input-bindings.md §4.5,
+    // B-55 — `task explain` reuses the identical `parseTaskInputFlags`
+    // scanner, so it needs the identical exemption).
+    const dynamicNamedFlagCommands = new Set(["workflow run", "task run", "task explain"]);
+    const dynamicWorkflowParams = dynamicNamedFlagCommands.has(known.path.join(" "));
     const selfDiagnosed = SELF_DIAGNOSED_FLAGS.get(known.path.join(" "));
     for (let i = 0; i < ownArgs.length; i += 1) {
         const token = ownArgs[i];

package/dist/cli.js

@@ -557,7 +557,14 @@ export const main = defineCommand({
     },
 });
 const MAIN_TOP_LEVEL_ARGS = main.args;
-function isTaskRunWithId(argv) {
+/**
+ * F-5 (spec docs/plans/specs/p2a-task-source-v4.md §6): exported so
+ * `akm task run`'s input-flags coverage can pin that an undeclared,
+ * per-task dynamic flag (e.g. `--scope all`) does not change this
+ * classification — it parses only `args.id` off the declared args and
+ * tolerates extra tokens (citty's non-strict `parseArgs`).
+ */
+export function isTaskRunWithId(argv) {
     const args = argv.slice(2);
     const commandIndex = findCittyTopLevelCommandIndex(args, MAIN_TOP_LEVEL_ARGS);
     const command = commandIndex >= 0 ? args[commandIndex] : undefined;

package/dist/commands/command/command-execution.js

@@ -14,6 +14,23 @@ import { prepareResolvedExecution } from "../../integrations/agent/execution-pre
 import { parseBuiltinCommandAction } from "./builtin-action.js";
 import { loadAdapterExecutionSource, } from "./execution-source-loader.js";
 import { applyPortableCommandArguments } from "./portable-template.js";
+/**
+ * F-1 (spec §5.2 point 3): resolve the ambient-first provenance stamp
+ * (matching the native arm's own `process.env.AKM_EVENT_SOURCE ?? …`) and
+ * hand it to `dispatchLoweredExecutionRequest`'s dedicated, single-purpose
+ * `eventSource` field — never through `runOptions`/`agentOptions`, which
+ * stays exactly as untrusted for overriding resolved content as it was
+ * before P1b (a caller-supplied `runOptions.env` still cannot replace frozen
+ * request data, including a scheduler-restored directory value — see
+ * `tests/integration/tasks-runner.test.ts`'s "forwards scheduled AKM
+ * directory context … without trusting task or caller overrides").
+ */
+function loweredDispatchOptions(options) {
+    const { eventSource, ...rest } = options;
+    if (eventSource === undefined)
+        return rest;
+    return { ...rest, eventSource: process.env.AKM_EVENT_SOURCE ?? eventSource };
+}
 function own(value, key) {
     return Object.hasOwn(value, key);
 }
@@ -291,13 +308,17 @@ export async function dispatchPreparedCommandInvocation(prepared, options = {})
     if (!selectedEngine) {
         throw new ConfigError(`command ${NO_ENGINE_MESSAGE_SUFFIX} ${NO_ENGINE_REMEDY}`, "INVALID_CONFIG_FILE");
     }
-    const result = await dispatchLoweredExecutionRequest(lowered, options);
+    const result = await dispatchLoweredExecutionRequest(lowered, loweredDispatchOptions(options));
     const consumedRefs = new Set();
     if (request.command.source)
         consumedRefs.add(request.command.source.ref);
     if (request.persona)
         consumedRefs.add(request.persona.source.ref);
-    const eventSource = resolveUsageEventSource();
+    // F-1 (spec §5.2 point 3): options.eventSource is only a FALLBACK — an
+    // ambient AKM_EVENT_SOURCE still wins (D5 clause d). Absent, this is
+    // byte-identical to the pre-P1b bare resolveUsageEventSource() call (P-07's
+    // own default is "user").
+    const eventSource = resolveUsageEventSource(process.env, options.eventSource ?? "user");
     for (const ref of consumedRefs)
         recordIndexedShowUsage(ref, eventSource);
     const announcement = fallbackAnnouncement(prepared.fallbackEngineName, selectedEngine);

package/dist/commands/health/improve-metrics.js

@@ -15,6 +15,44 @@ export function parseTaskMetadata(row) {
         ...(metadata.engine !== undefined ? { engine: metadata.engine } : {}),
     };
 }
+/**
+ * D8 read-boundary predicate (spec docs/plans/specs/p1b-model-extraction.md
+ * §5.3) for `akm health`'s `agentFailureRate`: true for a `task_history` row
+ * that represents a prepared command (agent/LLM) result, across both
+ * vocabularies. Mirrors src/tasks/run/task-history.ts's
+ * `taskHistoryRowToResult` read mapping:
+ *   - NEW rows mark themselves with metadata `targetVocab: 2` and store
+ *     `target_kind: "command"` for the agent/LLM arm.
+ *   - LEGACY rows (no marker, written before P1b's F-2 re-code) stored
+ *     `target_kind: "prompt"` for the same arm — and `"command"` for the
+ *     UNRELATED native shell/script arm, which must NOT be counted here.
+ * So an unmarked `"command"` row is a legacy shell/script run, not an
+ * agent/LLM one; a marked `"command"` row (or an unmarked `"prompt"` row) is.
+ */
+export function isAgentTaskHistoryRow(row) {
+    // Check target_kind BEFORE decoding metadata: some rows in the wild
+    // (e.g. improve-pipeline task_history rows, target_kind "improve") carry
+    // metadata_json that predates the metadataVersion:2 shape entirely, and
+    // decodeTaskHistoryMetadata throws on that — exactly like the pre-fix
+    // `target_kind === "prompt"` filter, which never called it for a row this
+    // function isn't going to count anyway. Only decode for the two target
+    // kinds this predicate can return true for.
+    if (row.target_kind !== "command" && row.target_kind !== "prompt")
+        return false;
+    // An undecodable metadata_json is by definition unmarked: pre-P1b rows can
+    // carry shapes decodeTaskHistoryMetadata rejects, and `akm health` must
+    // classify them as legacy rather than throw (round-3 review advisory).
+    let marked = false;
+    try {
+        marked = decodeTaskHistoryMetadata(row.metadata_json).targetVocab === 2;
+    }
+    catch {
+        marked = false;
+    }
+    if (row.target_kind === "command")
+        return marked;
+    return !marked;
+}
 function createUnknownImproveMetrics() {
     return {
         invoked: 0,

package/dist/commands/health/windows.js

@@ -11,7 +11,7 @@ import { readEvents } from "../../core/events.js";
 import { buildTaskRunId, getLoggedRunIds } from "../../core/logs-db.js";
 import { DURATION_UNITS, parseDuration } from "../../core/time.js";
 import { queryTaskHistory } from "../../storage/repositories/task-history-repository.js";
-import { buildImproveSkipSummary, computeWallTimeStats, parseTaskMetadata, roundRate, summarizeImproveCompleted, summarizeImproveRuns, } from "./improve-metrics.js";
+import { buildImproveSkipSummary, computeWallTimeStats, isAgentTaskHistoryRow, parseTaskMetadata, roundRate, summarizeImproveCompleted, summarizeImproveRuns, } from "./improve-metrics.js";
 import { readLlmUsageAggregate } from "./llm-usage.js";
 import { computeDegradationMetrics, computeDenominatorFixedCoverage } from "./metrics.js";
 import { buildPerRunSummaries } from "./task-runs.js";
@@ -148,14 +148,18 @@ export function buildWindowMetrics(db, stateDbPath, since, until, now = () => Da
     const failedTaskRows = taskRows.filter((row) => row.status === "failed");
     const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
     const stuckActiveRuns = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS).length;
-    const promptRows = taskRows.filter((row) => row.target_kind === "prompt");
-    const promptFailures = promptRows.filter((row) => {
+    // D8 (spec §5.3): a marked "command" row or a legacy (unmarked) "prompt"
+    // row is the agent/LLM arm; an unmarked "command" row is the legacy
+    // native shell/script arm and must not be counted here (see
+    // isAgentTaskHistoryRow's header comment for the full mapping).
+    const agentRows = taskRows.filter((row) => isAgentTaskHistoryRow(row));
+    const agentFailures = agentRows.filter((row) => {
         const detail = parseTaskMetadata(row).detail;
         return typeof detail?.reason === "string" && detail.reason.length > 0;
     });
     const logBackingRate = taskRowsWithLogs.length === 0 ? 1 : existingLogRows.length / taskRowsWithLogs.length;
     const taskFailRate = taskRows.length === 0 ? 0 : failedTaskRows.length / taskRows.length;
-    const agentFailureRate = promptRows.length === 0 ? 0 : promptFailures.length / promptRows.length;
+    const agentFailureRate = agentRows.length === 0 ? 0 : agentFailures.length / agentRows.length;
     const improveInvoked = readEvents({ since, type: "improve_invoked" }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime()).length;
     const improveCompletedEvents = readEvents({ since, type: IMPROVE_COMPLETED_EVENT }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime());
     const improveSkippedEvents = readEvents({ since, type: "improve_skipped" }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime());

package/dist/commands/health.js

@@ -20,7 +20,7 @@ import { queryTaskHistory } from "../storage/repositories/task-history-repositor
 import { pkgVersion } from "../version.js";
 import { collectImproveAdvisories } from "./health/advisories.js";
 import { HEALTH_CHECKS, runHealthEngineProbes } from "./health/checks.js";
-import { buildImproveSkipSummary, computeWallTimeStats, parseTaskMetadata, roundRate, summarizeImproveCompleted, summarizeImproveRuns, } from "./health/improve-metrics.js";
+import { buildImproveSkipSummary, computeWallTimeStats, isAgentTaskHistoryRow, parseTaskMetadata, roundRate, summarizeImproveCompleted, summarizeImproveRuns, } from "./health/improve-metrics.js";
 import { emptyLlmUsageAggregate, readLlmUsageAggregate } from "./health/llm-usage.js";
 import { computeDegradationMetrics, computeDenominatorFixedCoverage, computeEnrichmentMintingRollup, probeStateDbRoundTrip, } from "./health/metrics.js";
 import { collectPluginStalenessAdvisories } from "./health/plugin-staleness.js";
@@ -124,14 +124,18 @@ function gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now) {
     const failedTaskRows = taskRows.filter((row) => row.status === "failed");
     const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
     const stuckActiveRows = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS);
-    const promptRows = taskRows.filter((row) => row.target_kind === "prompt");
-    const promptFailures = promptRows.filter((row) => {
+    // D8 (spec §5.3): a marked "command" row or a legacy (unmarked) "prompt"
+    // row is the agent/LLM arm; an unmarked "command" row is the legacy
+    // native shell/script arm and must not be counted here (see
+    // isAgentTaskHistoryRow's header comment for the full mapping).
+    const agentRows = taskRows.filter((row) => isAgentTaskHistoryRow(row));
+    const agentFailures = agentRows.filter((row) => {
         const detail = parseTaskMetadata(row).detail;
         return typeof detail?.reason === "string" && detail.reason.length > 0;
     });
     const logBackingRate = taskRowsWithLogs.length === 0 ? 1 : existingLogRows.length / taskRowsWithLogs.length;
     const taskFailRate = taskRows.length === 0 ? 0 : failedTaskRows.length / taskRows.length;
-    const agentFailureRate = promptRows.length === 0 ? 0 : promptFailures.length / promptRows.length;
+    const agentFailureRate = agentRows.length === 0 ? 0 : agentFailures.length / agentRows.length;
     return {
         tableNames,
         missingTables,

package/dist/commands/lint/index.js

@@ -18,7 +18,7 @@ import { warn } from "../../core/warn.js";
 import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { TASK_EXTENSION, TASK_NEAR_MISS_EXTENSION, taskExtensionDetail } from "../../tasks/source-v3.js";
 import { resolveWorkflowSourceDomains } from "../../workflows/source-files.js";
-import { compareWorkflowSourceCodePoints } from "../../workflows/source-ir/ordering.js";
+import { compareWorkflowSourceCodePoints } from "../../workflows/source-ir/compare.js";
 import { runBaseChecks } from "./base-linter.js";
 import { checkEnvForDangerousKeys } from "./env-key-rules.js";
 import { isAdvisoryLintIssue } from "./types.js";

package/dist/commands/migrate-cli.js

@@ -1,44 +1,149 @@
 // 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 { defineGroupCommand, defineJsonCommand, output } from "../cli/shared.js";
+import { defineGroupCommand, defineJsonCommand, EXIT_CODES, output } from "../cli/shared.js";
 import { runMigrationTool } from "./migration-tool.js";
-/**
- * Run the task-only migrator and render its one JSON plan through the normal
- * output pipeline.
- */
-async function runMigrateSubcommand(command, args) {
-    const result = await runMigrationTool(args);
+async function callMigrateTool(args, runTool) {
+    const result = await runTool(args);
     if (result.stderr)
         process.stderr.write(result.stderr);
     const resultLine = result.stdout.trim();
-    if (resultLine) {
-        try {
-            output(command, JSON.parse(resultLine));
-        }
-        catch {
-            console.log(resultLine);
-        }
+    if (!resultLine)
+        return { status: result.status };
+    try {
+        return { status: result.status, plan: JSON.parse(resultLine) };
+    }
+    catch {
+        console.log(resultLine);
+        return { status: result.status };
+    }
+}
+function worstStatus(left, right) {
+    if (left === "blocked" || right === "blocked")
+        return "blocked";
+    if (left === "ready" || right === "ready")
+        return "ready";
+    return "current";
+}
+/**
+ * Resolve one generation's contribution to the combined status — fail
+ * CLOSED, never open (code-review finding: this tool advertises itself as
+ * "blocked-not-guessed").
+ *
+ * A generation that exited SUCCESS with no plan on stdout legitimately means
+ * "nothing to report" and defaults to `"current"`. A generation that exited
+ * NON-SUCCESS (by the caller's own guard, this can only be `EXIT_CODES.
+ * GENERAL` — the "blocked" code) with a parsed `plan.status` reports that
+ * status verbatim, same as before.
+ *
+ * The gap this closes: NON-SUCCESS with NO parseable plan at all —
+ * `runMigrationTool` coerces a `spawnSync` `status` of `null` (the child was
+ * killed by a signal — OOM, a timeout, a manual kill — never scheduled to
+ * exit) to `1`, indistinguishable from the migrator's own legitimate
+ * "blocked" exit code, and truncated/malformed stdout hits the same
+ * `JSON.parse` catch in `callMigrateTool`. Previously `?? "current"` silently
+ * read a crashed generation as "nothing to migrate"; this reports it as
+ * `"blocked"` with an explanatory blocker instead, so the combined exit code
+ * (`EXIT_CODES.GENERAL` below) actually reflects that the generation's real
+ * state is unknown, rather than reporting success at exit 0.
+ */
+export function resolveGenerationStatus(call, label) {
+    const planStatus = call.plan?.status;
+    if (planStatus !== undefined)
+        return { status: planStatus };
+    if (call.status !== EXIT_CODES.SUCCESS) {
+        return {
+            status: "blocked",
+            error: `${label}: the child process exited without printing a plan (exit status ${call.status}) — its real migration state is unknown.`,
+        };
     }
-    // R-067: `process.exitCode = …; return;` (not `process.exit()`) so the
-    // command's normal cleanup (`disposeDispatchResources()` in `runCommand`,
-    // src/cli.ts) still runs before the process exits with the child's status.
-    if (result.status !== 0) {
-        process.exitCode = result.status;
+    return { status: "current" };
+}
+/**
+ * Run BOTH migration generations — task-v2-to-v3, then task-v3-to-task-
+ * source-v4 — and print one combined plan (spec
+ * docs/plans/specs/p4-deletions-closeout.md §3.2.5, rows B-31/B-32).
+ *
+ * Each generation is its OWN subprocess call into the standalone migrator
+ * (`scripts/akm-migrate.ts`'s `status`/`apply` and `task-v4-status`/
+ * `task-v4-apply` verbs, UNCHANGED — row B-33), so each keeps its own
+ * `withConfigLock` + `O_EXCL` backup root + prevalidate + TOCTOU recheck +
+ * atomic replace + reverse rollback + convergence check, and the two are
+ * NEVER interleaved. The two calls are unconditional and independent of
+ * each other's outcome: a blocked (or otherwise incomplete) generation-1
+ * result does not stop generation 2 from running against whatever is
+ * already task source v4 — exactly `akm-migrate status`/`task-v4-status`
+ * (or `apply`/`task-v4-apply`) run back to back by hand. Only a genuine
+ * hard failure (a status neither SUCCESS nor the "blocked" GENERAL code —
+ * a config error, a crash) aborts the second call, since generation 1 never
+ * got to look at a stable tree in that case.
+ */
+export async function runMigrateSubcommand(command, genOneArgs, genTwoArgs, runTool = runMigrationTool) {
+    const first = await callMigrateTool(genOneArgs, runTool);
+    if (first.status !== EXIT_CODES.SUCCESS && first.status !== EXIT_CODES.GENERAL) {
+        process.exitCode = first.status;
+        return;
+    }
+    const second = await callMigrateTool(genTwoArgs, runTool);
+    if (second.status !== EXIT_CODES.SUCCESS && second.status !== EXIT_CODES.GENERAL) {
+        process.exitCode = second.status;
+        return;
+    }
+    if (!first.plan && !second.plan) {
+        if (first.status !== EXIT_CODES.SUCCESS)
+            process.exitCode = first.status;
         return;
     }
+    const combined = combineMigrationPlans(first, second);
+    output(command, combined);
+    if (combined.status === "blocked")
+        process.exitCode = EXIT_CODES.GENERAL;
+}
+/**
+ * Merge both generations' plans into the one combined envelope the command
+ * prints. Deliberately PURE — every rule the combined plan encodes (the
+ * {@link worstStatus} rollup, the fail-closed
+ * {@link resolveGenerationStatus} contribution, and the blockers merge, which
+ * orders generation 1's own blockers after its resolution error and before
+ * generation 2's) is decided here from two plain values, so it is provable
+ * without a subprocess, a CLI dispatch, or an output-mode singleton. The
+ * caller keeps the only two effectful decisions: whether generation 2 runs at
+ * all, and the process exit code.
+ */
+export function combineMigrationPlans(first, second) {
+    const firstResolved = resolveGenerationStatus(first, "task-v2-to-v3");
+    const secondResolved = resolveGenerationStatus(second, "task-v3-to-task-source-v4");
+    return {
+        schemaVersion: 1,
+        status: worstStatus(firstResolved.status, secondResolved.status),
+        blockers: [
+            ...(firstResolved.error ? [firstResolved.error] : []),
+            ...(first.plan?.blockers ?? []),
+            ...(secondResolved.error ? [secondResolved.error] : []),
+            ...(second.plan?.blockers ?? []),
+        ],
+        taskV3Migration: first.plan?.taskV3Migration,
+        taskV4Migration: second.plan?.taskV4Migration,
+        ...(first.plan?.backupPath !== undefined ? { backupPath: first.plan.backupPath } : {}),
+        ...(first.plan?.applied !== undefined ? { applied: first.plan.applied } : {}),
+        ...(second.plan?.backupPath !== undefined ? { taskV4BackupPath: second.plan.backupPath } : {}),
+        ...(second.plan?.applied !== undefined ? { taskV4Applied: second.plan.applied } : {}),
+    };
 }
 export const migrateCommand = defineGroupCommand({
-    meta: { name: "migrate", description: "Inspect or apply task-v2 to task-v3 migrations" },
+    meta: { name: "migrate", description: "Inspect or apply task-v2 and task-v3 sources to task source v4" },
     subCommands: {
         status: defineJsonCommand({
-            meta: { name: "status", description: "Read-only task-v2 migration check" },
+            meta: { name: "status", description: "Read-only task-v2 and task-v3 migration check" },
             run() {
-                return runMigrateSubcommand("migrate-status", ["status"]);
+                return runMigrateSubcommand("migrate-status", ["status"], ["task-v4-status"]);
             },
         }),
         apply: defineJsonCommand({
-            meta: { name: "apply", description: "Back up and atomically convert task-v2 files to task v3" },
+            meta: {
+                name: "apply",
+                description: "Back up and atomically convert task-v2 and task-v3 files to task source v4",
+            },
             args: {
                 "dry-run": {
                     type: "boolean",
@@ -47,7 +152,8 @@ export const migrateCommand = defineGroupCommand({
                 },
             },
             run({ args }) {
-                return runMigrateSubcommand("migrate-apply", ["apply", ...(args.dryRun ? ["--dry-run"] : [])]);
+                const dryRunFlag = args.dryRun ? ["--dry-run"] : [];
+                return runMigrateSubcommand("migrate-apply", ["apply", ...dryRunFlag], ["task-v4-apply", ...dryRunFlag]);
             },
         }),
     },

package/dist/commands/proposal/validators/proposal-validators.js

@@ -5,7 +5,7 @@ import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { parseRefInput } from "../../../core/asset/resolve-ref.js";
 import { proposalContent } from "../../../core/file-change.js";
 import { lintLessonContent } from "../../../core/lesson-lint.js";
-import { parseTaskV3Yaml } from "../../../tasks/source-v3.js";
+import { parseTaskSource } from "../../../tasks/source/parse-task-source.js";
 import { compileWorkflowSource } from "../../../workflows/source-ir/compile.js";
 import { defaultProposalQualityValidators } from "./proposal-quality-validators.js";
 const genericProposalValidator = {
@@ -52,7 +52,12 @@ const canonicalProposalValidators = {
         const name = ctx.parsedRef?.name;
         if (!name)
             return [];
-        parseTaskV3Yaml({
+        // Version-routing seam (spec docs/plans/specs/p2a-task-source-v4.md
+        // §3.6): a proposal body is validated by parsing alone — neither arm's
+        // parsed document is inspected further, so routing through the union is
+        // a pure swap; any parse failure (either version) is turned into an
+        // `invalid-task-structure` finding by the try/catch this call sits in.
+        parseTaskSource({
             yaml: proposalContent(proposal),
             filePath: proposal.changes[0]?.path || proposal.ref,
         });