akm-cli 0.9.31 → 0.10.26101002-alpha

package/dist/setup/detect.js

@@ -14,6 +14,7 @@ import { runManagedSubprocess } from "../core/subprocess.js";
 import { defaultWhich } from "../integrations/agent/detect.js";
 import { getBuiltinAgentProfile, OPENCODE_SDK_SERVER_BIN } from "../integrations/agent/profiles.js";
 import { AGENT_DISPATCH_HARNESSES, SESSION_LOG_HARNESSES } from "../integrations/harnesses/index.js";
+import { detectOpencodeMajor, resolveOpencodeBin } from "../integrations/harnesses/opencode/version.js";
 import { detectHarnessConfigs } from "./harness-config-import.js";
 let detectOverrides;
 /** TEST-ONLY. Swap the network/host probes; pass undefined to restore. */
@@ -342,7 +343,8 @@ function findGitRepoRoot(start) {
  *   3. none.
  *
  * The SDK import resolving is NOT evidence the SDK path can run: `@opencode-ai/sdk`
- * is a hard dependency of akm-cli itself, so `import()` always succeeds and an
+ * (OpenCode 1) and `@opencode/client` (OpenCode 2; the binary's detected major
+ * selects) are hard dependencies of akm-cli itself, so `import()` always succeeds and an
  * import-only check would report `opencode-sdk` on every machine — including
  * ones where the first agentic command then dies with spawn ENOENT. The SDK
  * runner spawns `opencode serve` (see `harnesses/opencode-sdk/sdk-runner.ts`),
@@ -355,10 +357,14 @@ function findGitRepoRoot(start) {
 export async function detectHarness(whichFn = defaultWhich) {
     // Probed once; reused below so the `opencode` CLI fallback doesn't repeat
     // the identical full-PATH walk this just performed.
-    const opencodePath = whichFn(OPENCODE_SDK_SERVER_BIN);
+    const opencodePath = whichFn(resolveOpencodeBin(undefined, whichFn));
     if (opencodePath) {
         try {
-            await import("@opencode-ai/sdk");
+            // The client package of the major the binary reports.
+            if (detectOpencodeMajor(opencodePath).major === 1)
+                await import("@opencode-ai/sdk");
+            else
+                await import("@opencode/client");
             return "opencode-sdk";
         }
         catch {
@@ -368,7 +374,7 @@ export async function detectHarness(whichFn = defaultWhich) {
     }
     for (const harness of AGENT_DISPATCH_HARNESSES) {
         // The SDK harness dispatches without a CLI profile and was decided above;
-        // an explicit skip so a future BUILTINS entry for it can't silently
+        // an explicit skip so a future `profile` for it can't silently
         // reintroduce it here after the import guard already rejected it.
         if (harness.id === "opencode-sdk")
             continue;

package/dist/setup/harness-config-import.js

@@ -8,8 +8,8 @@
  * no network) and, if so, reads its config to extract LLM connection details.
  * API key VALUES are never stored — only the env var names that hold them.
  *
- * To add a new harness: implement {@link HarnessConfigImporter} and append it
- * to {@link HARNESS_CONFIG_IMPORTERS}.
+ * To add a new harness importer: declare `configImporter` on the harness
+ * descriptor (`integrations/harnesses/<id>/index.ts`).
  *
  * NOTE: The `detect()` method in each importer overlaps intentionally with
  * `detectAgentPlatforms()` in `detect.ts`. That function scans for harness
@@ -17,18 +17,9 @@
  * further by reading and parsing the harness config. They serve different
  * purposes and should not be deduplicated.
  */
-import { claudeCodeImporter } from "../integrations/harnesses/claude/config-import.js";
-import { openCodeImporter } from "../integrations/harnesses/opencode/config-import.js";
-// The Claude Code importer was migrated to its harness directory in #563
-// (`harnesses/claude/config-import.ts`) and the OpenCode importer in #564
-// (`harnesses/opencode/config-import.ts`). Both are imported back into
-// HARNESS_CONFIG_IMPORTERS below so detection order is unchanged.
-// ── Registry ─────────────────────────────────────────────────────────────────
-/**
- * Registry of all supported harness config importers.
- * To add a new harness: implement {@link HarnessConfigImporter} and append here.
- */
-export const HARNESS_CONFIG_IMPORTERS = [claudeCodeImporter, openCodeImporter];
+import { HARNESS_REGISTRY } from "../integrations/harnesses/index.js";
+/** Importers declared by the registered harnesses, in registry order. */
+export const HARNESS_CONFIG_IMPORTERS = HARNESS_REGISTRY.flatMap((h) => h.configImporter ? [h.configImporter] : []);
 /**
  * Run all importers whose `detect()` returns `true` and collect their configs.
  *

package/dist/setup/setup.js

@@ -625,7 +625,7 @@ export async function runSetupWizard(opts) {
         }
     }
     p.outro(`Configuration saved to ${configPath}\n` +
-        'Next: `akm bundle add <source>`, `akm index`, `akm search "<query>"`, `akm help agents`');
+        'Next: `akm bundle add <source>`, `akm index`, `akm search "<query>"`, `akm hints`');
 }
 // ── Non-interactive / scripting entry points ─────────────────────────────────
 /**

package/dist/setup/steps/tasks.js

@@ -19,13 +19,12 @@ import { parseSchedule } from "../../tasks/schedule.js";
 import { parseTaskSource } from "../../tasks/source/parse-task-source.js";
 import { prompt } from "../prompt.js";
 /**
- * A scheduled server-only nightly full sweep exists among the embedded
- * improve-schedule templates (folded in from the retired
- * `registerDefaultTasks`/`akm tasks init` path in 0.9, S6). This id is
- * preselected in the review multiselect on a detected server install — the
- * "battery heuristic" {@link detectServerDefault} preserved from that path.
+ * The nightly improve template (`core/improve`). This id is preselected in the
+ * review multiselect on a detected server install — the "battery heuristic"
+ * {@link detectServerDefault} preserved from the retired
+ * `registerDefaultTasks`/`akm tasks init` path (0.9, S6).
  */
-const SERVER_SUGGESTED_TASK_ID = "akm-improve-nightly";
+const SERVER_SUGGESTED_TASK_ID = "improve";
 let scheduledTasksEnvOverrides;
 /** TEST-ONLY. Swap the CI/server-detection probes; pass undefined to restore. */
 export function _setScheduledTasksEnvForTests(fakes) {
@@ -66,7 +65,7 @@ export function detectServerDefault() {
     }
     catch {
         // If we cannot read power-supply info, prefer the safe server default on
-        // Linux (the nightly sweep is low-impact and re-runnable).
+        // Linux (the nightly improve run is low-impact and re-runnable).
         return true;
     }
 }
@@ -200,11 +199,11 @@ export async function stepScheduledTasks(deps = DEFAULT_SCHEDULED_TASKS_DEPS, op
         p.log.info("Non-interactive setup leaves task files and scheduler state unchanged. Run `akm setup` interactively to review tasks.");
         return;
     }
-    // ALL templates are offered, including ships-disabled ones (e.g. the
-    // manual-recovery catchup task): an unselected template is still PREPARED,
-    // so its YAML exists for `akm task run <id>` while its ref remains absent
-    // from local scheduler activation. Filtering on `task.enabled`
-    // here would make ships-disabled templates invisible and unpreparable.
+    // ALL templates are offered, including ships-disabled ones: an unselected
+    // template is still PREPARED, so its YAML exists for `akm task run <id>`
+    // while its ref remains absent from local scheduler activation. Filtering on
+    // `task.enabled` here would make ships-disabled templates invisible and
+    // unpreparable.
     const embedded = listEmbeddedTasks();
     if (embedded.length === 0)
         return;
@@ -228,7 +227,7 @@ export async function stepScheduledTasks(deps = DEFAULT_SCHEDULED_TASKS_DEPS, op
         byId.set(normaliseTaskIdForMatch(task.id), task);
     const preChecked = embedded.filter((task) => byId.get(task.id)?.enabled === true).map((task) => task.id);
     // Battery heuristic preserved from the retired `registerDefaultTasks` path
-    // (S6): suggest the nightly full sweep on a detected server install, same
+    // (S6): suggest the nightly improve task on a detected server install, same
     // as every other embedded template, still gated behind the confirmation
     // below.
     if (!byId.has(SERVER_SUGGESTED_TASK_ID) &&

package/dist/storage/repositories/task-history-repository.js

@@ -67,10 +67,6 @@ export function decodeTaskHistoryMetadata(input) {
     // A malformed `engine` (wrong type) is dropped like any other unrecognized
     // field rather than rejecting the whole row over a non-essential value.
     const engine = parsed.engine === null || typeof parsed.engine === "string" ? parsed.engine : undefined;
-    if (parsed.targetVocab !== undefined && parsed.targetVocab !== 2) {
-        warnOnce(`task-history-target-vocab:${String(parsed.targetVocab)}`, `task_history row has targetVocab ${String(parsed.targetVocab)}, newer than this akm's 2 — falling back to ` +
-            "the legacy target_kind mapping rather than rejecting the row.");
-    }
     validateDetail(detail);
     const cleanDetail = detail
         ? {
@@ -85,7 +81,6 @@ export function decodeTaskHistoryMetadata(input) {
         durationMs: parsed.durationMs,
         detail: cleanDetail,
         ...(engine !== undefined ? { engine } : {}),
-        ...(parsed.targetVocab === 2 ? { targetVocab: 2 } : {}),
     };
 }
 /**

package/dist/storage/repositories/workflow-runs-repository.js

@@ -353,15 +353,6 @@ export class WorkflowRunsRepository {
             return db.prepare("SELECT * FROM workflow_runs WHERE id = ?").get(input.run.id);
         });
     }
-    /**
-     * Persist a run's resolved declared `outputs:` (migration 024, P3b §4.3).
-     * Called from INSIDE `completeWorkflowStep`'s own write transaction — this
-     * method opens none of its own, matching `updateStepCompletion` /
-     * `updateRunState` immediately above.
-     */
-    setRunOutputs(runId, outputsJson) {
-        this.db.prepare("UPDATE workflow_runs SET outputs_json = ? WHERE id = ?").run(outputsJson, runId);
-    }
     /** Every child run published under `parentRunId`, oldest first. `[]` when none. */
     childRunsOf(parentRunId) {
         return this.db
@@ -432,13 +423,13 @@ export class WorkflowRunsRepository {
             const dispatchId = randomUUID();
             db.prepare(`INSERT INTO workflow_run_unit_attempts (
            run_id, unit_id, attempt, dispatch_id, step_id, node_id, phase,
-           runner, engine, model, input_hash, status, worktree_path, started_at,
+           runner, engine, model, input_hash, status, started_at,
            claim_holder, claim_expires_at
-         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?)`).run(input.runId, input.unitId, attemptNumber, dispatchId, input.stepId, input.nodeId, input.phase, input.runner, input.engine, input.model, input.inputHash, input.worktreePath ?? null, input.now, holder, input.now);
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?)`).run(input.runId, input.unitId, attemptNumber, dispatchId, input.stepId, input.nodeId, input.phase, input.runner, input.engine, input.model, input.inputHash, input.now, holder, input.now);
             db.prepare(`INSERT INTO workflow_run_units (
            run_id, unit_id, step_id, node_id, parent_unit_id, phase, runner, engine, model,
-           status, input_hash, worktree_path, started_at, claim_holder, claim_expires_at, attempts
-         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?)
+           status, input_hash, started_at, claim_holder, claim_expires_at, attempts
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)
          ON CONFLICT(run_id, unit_id) DO UPDATE SET
            step_id = excluded.step_id,
            node_id = excluded.node_id,
@@ -449,7 +440,6 @@ export class WorkflowRunsRepository {
            model = excluded.model,
            status = 'running',
            input_hash = excluded.input_hash,
-           worktree_path = excluded.worktree_path,
            started_at = excluded.started_at,
            claim_holder = excluded.claim_holder,
            claim_expires_at = excluded.claim_expires_at,
@@ -458,7 +448,7 @@ export class WorkflowRunsRepository {
            failure_reason = NULL,
            session_id = NULL,
            finished_at = NULL,
-           attempts = excluded.attempts`).run(input.runId, input.unitId, input.stepId, input.nodeId, input.parentUnitId ?? null, input.phase, input.runner, input.engine, input.model, input.inputHash, input.worktreePath ?? null, input.now, holder, input.now, attemptNumber);
+           attempts = excluded.attempts`).run(input.runId, input.unitId, input.stepId, input.nodeId, input.parentUnitId ?? null, input.phase, input.runner, input.engine, input.model, input.inputHash, input.now, holder, input.now, attemptNumber);
             insertEventStrict(db, {
                 eventType: "workflow_unit_started",
                 ts: input.now,

package/dist/tasks/embedded.js

@@ -25,7 +25,8 @@ import { getDirname } from "../runtime.js";
 import { parseTaskSource } from "./source/parse-task-source.js";
 /** Directory holding the bundled task template categories. */
 const TASKS_ASSETS_DIR = path.join(getDirname(import.meta.url), "../assets/tasks");
-const DEFAULT_DISABLED_TASKS = new Set(["improve/akm-improve-catchup"]);
+/** Templates setup offers but ships disabled (`category/id`). None ship disabled since catchup was removed (#1130). */
+const DEFAULT_DISABLED_TASKS = new Set();
 /**
  * Enumerate the embedded task templates from every category subdirectory of
  * the bundled assets directory. Sorted by category then id for deterministic

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

@@ -49,8 +49,6 @@ export function appendHistory(result, historyReserved = false) {
             metadataVersion: 2,
             durationMs: result.durationMs,
             detail: result.detail ?? null,
-            // D8 (spec §5.3): every NEW row carries the vocabulary marker.
-            targetVocab: 2,
             ...(result.target.kind === "command" ? { engine: result.target.engine } : {}),
         }),
     };

package/dist/tasks/schedule-gates.js

@@ -0,0 +1,39 @@
+// 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/.
+/**
+ * The two per-source schedule gates `akm task sync` runs before it installs a
+ * schedule, kept in a leaf module so `akm lint` can run them without importing
+ * the scheduler's task-preparation graph (which reaches the adapter registry
+ * that lint itself is part of).
+ */
+import { UsageError } from "../core/errors.js";
+import { applyInputDefaults, validateInputs } from "../execution/input-contract.js";
+import { parseSchedule } from "./schedule.js";
+/**
+ * Validate every v4 `schedule:` entry's `inputs` against the task's own
+ * declared contract with defaults applied — the exact set of values a
+ * compiled invocation delivers — so a violation is reported at sync rather
+ * than when the scheduler fires. Shared with `akm lint`.
+ */
+export function assertTaskScheduleInputsSatisfyContract(v4, refLabel) {
+    const contract = v4.inputs ?? {};
+    for (const scheduleEntry of v4.schedule) {
+        const defaultedInputs = applyInputDefaults(contract, { ...scheduleEntry.inputs });
+        const errors = validateInputs(contract, defaultedInputs);
+        if (errors.length > 0) {
+            throw new UsageError(`Task ${JSON.stringify(refLabel)} schedule[${scheduleEntry.ordinal}].inputs does not satisfy ` +
+                `its declared inputs once defaults are applied: ${errors.join("; ")}`, "TASK_SOURCE_INVALID");
+        }
+    }
+}
+/**
+ * Validate every v4 `schedule:` entry's `cron` against the active backend's
+ * dialect: cron is the most permissive of the three, so a task authored on
+ * Linux can carry an expression launchd/schtasks cannot translate. Shared
+ * with `akm lint`.
+ */
+export function assertTaskScheduleCronValid(v4, backend) {
+    for (const scheduleEntry of v4.schedule)
+        parseSchedule(scheduleEntry.cron, backend);
+}

package/dist/tasks/scheduler-binding.js

@@ -62,22 +62,6 @@ function schedulerInputFlagValueText(value) {
         return String(value);
     return canonicalInputJson(value);
 }
-export function compileWorkflowSchedulerBindings(input) {
-    const ref = assertQualifiedRef(input.qualifiedRef, "workflow");
-    return Object.freeze(input.schedules.map((schedule) => {
-        const bindingId = digestBindingId("workflow", ref, schedule.ordinal);
-        return freezeBinding({
-            id: bindingId,
-            nativeId: bindingId,
-            logicalSource: { kind: "workflow", ref },
-            cron: schedule.cron,
-            source: schedule.source,
-            ordinal: schedule.ordinal,
-            enabled: true,
-            invocation: ["workflow", "run", ref],
-        });
-    }));
-}
 /**
  * Map a logical binding id to the flat portable token persisted by native
  * schedulers. Flat ids are byte-for-byte stable; only nested standalone

package/dist/tasks/scheduler-sync.js

@@ -3,7 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Scheduler reconciliation: compile the desired bindings from a bundle's
- * task and workflow sources, then diff them against the rows the native
+ * task sources, then diff them against the rows the native
  * scheduler holds.
  *
  * `compileSchedulerSources` reads each source once. One source that fails
@@ -17,14 +17,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { makeBundleRef, parseBundleRef } from "../core/asset/asset-ref.js";
 import { compareCodePoints, toPosix } from "../core/common.js";
-import { UsageError } from "../core/errors.js";
-import { canonicalizeWorkflowName, WORKFLOW_EXTENSIONS } from "../core/recognition-util.js";
-import { applyInputDefaults, validateInputs } from "../execution/input-contract.js";
-import { checkWorkflowPlan, compileWorkflowSource } from "../workflows/compile.js";
-import { WorkflowSourceCollisionError, WorkflowSourceNameError, workflowNameForSourcePath, } from "../workflows/source-files.js";
 import { prepareTaskV3Execution } from "./prepare/prepare.js";
-import { parseSchedule } from "./schedule.js";
-import { compileTaskSchedulerBindings, compileWorkflowSchedulerBindings, schedulerBindingNativeId, schedulerNativeBindingId, } from "./scheduler-binding.js";
+import { assertTaskScheduleCronValid, assertTaskScheduleInputsSatisfyContract } from "./schedule-gates.js";
+import { compileTaskSchedulerBindings, schedulerBindingNativeId, schedulerNativeBindingId, } from "./scheduler-binding.js";
 import { parseTaskSource } from "./source/parse-task-source.js";
 import { projectTaskSourceV4 } from "./source/project-v4.js";
 import { taskSourceErrorDetail } from "./source-v3.js";
@@ -37,7 +32,6 @@ export async function compileSchedulerSources(input) {
     const desired = [];
     const failures = [];
     await compileTaskSources({ ...input, sourceRoot }, desired, failures);
-    compileWorkflowSources({ ...input, sourceRoot }, desired, failures);
     return Object.freeze({
         desired: Object.freeze(desired),
         failures: Object.freeze(failures.sort((left, right) => compareCodePoints(left.path, right.path))),
@@ -107,67 +101,6 @@ function taskSourceFiles(sourceRoot, adapterId) {
         return walkFiles(sourceRoot).filter((file) => file.endsWith(".yml"));
     return [];
 }
-function compileWorkflowSources(input, desired, failures) {
-    if (input.adapterId !== "akm" && input.adapterId !== "akm-workflow")
-        return;
-    const root = input.adapterId === "akm" ? path.join(input.sourceRoot, "workflows") : input.sourceRoot;
-    const byName = new Map();
-    for (const file of walkFiles(root)) {
-        if (path.basename(file).toLowerCase() === "readme.md")
-            continue;
-        const authoredName = workflowNameForSourcePath(input.sourceRoot, input.adapterId, file);
-        if (authoredName === undefined)
-            continue;
-        const extension = path.posix.extname(authoredName).toLowerCase();
-        const stem = authoredName.slice(0, -extension.length).toLowerCase();
-        const nestedSuffix = WORKFLOW_EXTENSIONS.find((suffix) => stem.endsWith(suffix));
-        if (nestedSuffix) {
-            const relative = toPosix(path.relative(input.sourceRoot, file));
-            failures.push({ path: file, reason: new WorkflowSourceNameError(relative, nestedSuffix).message });
-            continue;
-        }
-        const canonicalName = canonicalizeWorkflowName(authoredName);
-        byName.set(canonicalName, [...(byName.get(canonicalName) ?? []), file]);
-    }
-    for (const [canonicalName, sources] of [...byName].sort(([left], [right]) => compareCodePoints(left, right))) {
-        const conceptId = input.adapterId === "akm" ? `workflows/${canonicalName}` : canonicalName;
-        const ref = sourceRef(input.bundleName, conceptId);
-        if (ref === undefined || (input.enabledRefs && !input.enabledRefs.has(ref)))
-            continue;
-        const file = sources[0];
-        try {
-            if (sources.length > 1) {
-                throw new WorkflowSourceCollisionError(conceptId, sources.map((source) => toPosix(path.relative(input.sourceRoot, source))));
-            }
-            const relative = toPosix(path.relative(input.sourceRoot, file));
-            const compiled = compileWorkflowSource(fs.readFileSync(file, "utf8"), {
-                path: relative,
-                workspaceRoot: input.sourceRoot,
-            });
-            if (!compiled.ok) {
-                throw new UsageError(compiled.errors
-                    .map((error) => `${error.path}:${error.line ?? 1} [${error.code}] ${error.message}`)
-                    .join("; "), "WORKFLOW_SOURCE_INVALID");
-            }
-            const planDraft = checkWorkflowPlan(compiled.plan);
-            if (!planDraft.ok) {
-                throw new UsageError(planDraft.errors.map((error) => `${relative}:${error.line} ${error.message}`).join("; "), "WORKFLOW_SOURCE_INVALID");
-            }
-            const schedules = (compiled.plan.schedules ?? []).map((schedule) => ({
-                cron: schedule.cron,
-                source: `${relative}:${schedule.line}`,
-                ordinal: schedule.ordinal,
-            }));
-            for (const binding of compileWorkflowSchedulerBindings({ qualifiedRef: ref, schedules })) {
-                parseSchedule(binding.cron, input.backend);
-                desired.push(binding);
-            }
-        }
-        catch (cause) {
-            failures.push({ path: file, ref, reason: errorMessage(cause) });
-        }
-    }
-}
 /** A file whose name cannot form a ref (a `#` in it) cannot be enabled, so it is not this sync's. */
 function sourceRef(bundleName, conceptId) {
     try {
@@ -213,33 +146,6 @@ function statOrUndefined(file) {
         return undefined;
     }
 }
-/**
- * Validate every v4 `schedule:` entry's `inputs` against the task's own
- * declared contract with defaults applied — the exact set of values a
- * compiled invocation delivers — so a violation is reported at sync rather
- * than when the scheduler fires. Shared with `akm task validate`.
- */
-export function assertTaskScheduleInputsSatisfyContract(v4, refLabel) {
-    const contract = v4.inputs ?? {};
-    for (const scheduleEntry of v4.schedule) {
-        const defaultedInputs = applyInputDefaults(contract, { ...scheduleEntry.inputs });
-        const errors = validateInputs(contract, defaultedInputs);
-        if (errors.length > 0) {
-            throw new UsageError(`Task ${JSON.stringify(refLabel)} schedule[${scheduleEntry.ordinal}].inputs does not satisfy ` +
-                `its declared inputs once defaults are applied: ${errors.join("; ")}`, "TASK_SOURCE_INVALID");
-        }
-    }
-}
-/**
- * Validate every v4 `schedule:` entry's `cron` against the active backend's
- * dialect: cron is the most permissive of the three, so a task authored on
- * Linux can carry an expression launchd/schtasks cannot translate. Shared
- * with `akm task validate`.
- */
-export function assertTaskScheduleCronValid(v4, backend) {
-    for (const scheduleEntry of v4.schedule)
-        parseSchedule(scheduleEntry.cron, backend);
-}
 export function installedRowNativeId(row) {
     return row.nativeId ?? schedulerNativeBindingId(row.id);
 }

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

@@ -380,7 +380,7 @@ export function assertBoundedTaskYamlDocument(document, options) {
  * 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 `src/tasks/source/task-source-v3-frozen.ts`
+ * 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

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

@@ -44,7 +44,7 @@ import { classifyTargetRef } from "../../execution/target-ref.js";
 import { detectSecretShapedParams } from "../../workflows/exec/param-secrets.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 { TASK_RUN_RESERVED_FLAG_NAMES } from "../task-run-reserved-flags.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;
@@ -391,18 +391,8 @@ function parseInputDeclarations(value, ctx) {
         // checked against this same contract below, so a banned name can never
         // reach compileTaskSchedulerBindings's invocation tail either) — see
         // ../task-run-reserved-flags.ts's own header.
-        //
-        // 0.9.2 review round 2: `target` joins that set from the CLI's DIAGNOSTIC
-        // side rather than its declared-arg side. `rejectRetiredTaskTargetFlag`
-        // (../../commands/tasks/tasks-cli.ts) throws the 0.9 `--target` ->
-        // `--bundle` rename hint for every spelling of the name, before
-        // parseTaskInputFlags scans argv at all, so an input declared under that
-        // name could never be supplied either — it is the same unusable
-        // declaration, reached by a different route (TASK_RUN_SELF_DIAGNOSED_FLAGS).
         if (TASK_RUN_RESERVED_FLAG_NAMES.has(name)) {
-            sourceError(ctx, ["inputs", name], TASK_RUN_SELF_DIAGNOSED_FLAGS.includes(name)
-                ? `collides with the retired \`akm task --${name}\` spelling, which every task subcommand still rejects with a rename hint, so no --${name} flag can ever reach this input; declare the input under a different name.`
-                : `collides with akm task run's own --${name} flag; declare the input under a different name.`);
+            sourceError(ctx, ["inputs", name], `collides with akm task run's own --${name} flag; declare the input under a different name.`);
         }
         result[name] = parseInputDeclaration(name, input[name], ctx);
     }

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

@@ -26,9 +26,7 @@
  * `src/commands/tasks/tasks-cli.ts` re-exports `TASK_RUN_VALUE_FLAGS` /
  * `TASK_RUN_BOOLEAN_FLAGS` from here unchanged, so this module is the single
  * source of truth both the CLI's own argv scanner and the source parser read
- * — the two can never drift apart. `TASK_RUN_SELF_DIAGNOSED_FLAGS` (below)
- * covers the third category the scanner sets cannot express: a name the CLI
- * claims by REJECTING it rather than by declaring it. This file imports
+ * — the two can never drift apart. This file imports
  * nothing, and nothing it
  * exports depends on IO, config, or any other `src/tasks/**` module, so it
  * can be imported from either side of that boundary without participating in
@@ -45,35 +43,8 @@ export const TASK_RUN_BOOLEAN_FLAGS = [
     "no-quiet",
     "no-verbose",
 ];
-/**
- * Flag names `akm task` claims WITHOUT declaring them as citty args, so they
- * appear in neither list above and must be reserved separately.
- *
- * `target` is the only member: the 0.9 rename of `akm task --target` to
- * `--bundle` (S8.4) is self-diagnosed rather than merely dropped —
- * `rejectRetiredTaskTargetFlag` (`../commands/tasks/tasks-cli.ts`) throws the
- * rename hint for a `--target` in ANY spelling, bare or `--target=<value>`,
- * and the generic pre-dispatch gate exempts the name on every `task`
- * subcommand precisely so that handler can answer (`../cli/unknown-flags.ts`'s
- * `SELF_DIAGNOSED_FLAGS`). That rejection runs before `parseTaskInputFlags`
- * ever scans argv, so a declared input named `target` is unreachable through
- * every spelling of its own flag — the exact value-misrouting hole the union
- * below exists to close, just reached from the CLI's diagnostic side instead
- * of from its declared-arg side (0.9.2 review round 2). Rejecting the
- * DECLARATION keeps the rename hint intact for everyone typing the retired
- * spelling while making the unusable declaration impossible to author, rather
- * than trading one silent failure for another.
- *
- * It deliberately stays OUT of `TASK_RUN_VALUE_FLAGS` /
- * `TASK_RUN_BOOLEAN_FLAGS`: those two are `parseTaskInputFlags`' own scanner
- * sets (a value flag makes the scanner swallow the following token), and
- * `--target` must keep reaching the rename diagnostic rather than being
- * silently consumed as one of `akm task run`'s own flags.
- */
-export const TASK_RUN_SELF_DIAGNOSED_FLAGS = ["target"];
-/** The union of all three lists above, for a single membership check against a candidate input name. */
+/** The union of the two lists above, for a single membership check against a candidate input name. */
 export const TASK_RUN_RESERVED_FLAG_NAMES = new Set([
     ...TASK_RUN_VALUE_FLAGS,
     ...TASK_RUN_BOOLEAN_FLAGS,
-    ...TASK_RUN_SELF_DIAGNOSED_FLAGS,
 ]);

package/dist/workflows/authoring/authoring.js

@@ -41,13 +41,13 @@ function validateWorkflowContent(content, sourcePath) {
         throw new UsageError(formatWorkflowErrors(sourcePath, compiled.errors));
     }
 }
-/** Peer YAML is executable, but `akm workflow create` emits the Markdown authoring form only. */
+/** Workflows are Markdown; `akm workflow create` rejects a YAML suffix. */
 const YAML_SUFFIX_RE = /\.ya?ml$/i;
 export function assertWorkflowMarkdownName(name) {
     if (!YAML_SUFFIX_RE.test(name.trim()))
         return;
     throw new UsageError(`akm workflow create is markdown-only: it emits Markdown and cannot create "${name}". ` +
-        `Use a plain name (no ".yaml"/".yml" suffix), or author a peer GitHub-shaped ".yml" workflow directly.`);
+        `Use a plain name (no ".yaml"/".yml" suffix).`);
 }
 // 0.9.2 review round 2 (P4 sweep criterion-21 caveat, spec
 // docs/plans/specs/p4-deletions-closeout.md §4.1 row B-49): this return's
@@ -75,7 +75,7 @@ export function createWorkflowAsset(input) {
         path.isAbsolute(relativeAssetPath)) {
         throw new UsageError(`Resolved workflow path escapes the bundle: "${normalizedName}"`, "PATH_ESCAPE_VIOLATION");
     }
-    // A peer `.md` or `.yml` file whose canonical name matches already owns this
+    // A `.md` file whose canonical name matches already owns this
     // ref. Case variants (`upper.MD` vs `upper.md`) may also name one physical
     // file on a case-insensitive filesystem, so writing the Markdown create
     // target would silently clobber or shadow the existing asset.
@@ -160,9 +160,9 @@ export function formatWorkflowErrors(path, errors) {
 }
 /**
  * Every file under `typeRoot` whose canonical workflow name equals
- * `normalizedName`. Peer `.md`/`.yml` extension matching is case-INSENSITIVE,
- * so both cross-format owners and case variants are returned for the create
- * path to refuse rather than silently clobber or shadow them.
+ * `normalizedName`. `.md` extension matching is case-INSENSITIVE, so case
+ * variants are returned for the create path to refuse rather than silently
+ * clobber or shadow them.
  */
 function findExistingWorkflowPaths(typeRoot, normalizedName) {
     const parent = path.join(typeRoot, path.dirname(normalizedName));