akm-cli 0.9.17-alpha.7 → 0.9.17-alpha.8

package/dist/scripts/akm-migrate-node.js

@@ -28797,6 +28797,7 @@ function shapeShowOutput(result, detail, shape = "human") {
       "steps",
       "keys",
       "related",
+      "links",
       ...FRAGMENT_PROVENANCE_FIELDS,
       ...FRAGMENT_CONTEXT_FIELDS
     ]);
@@ -28818,6 +28819,7 @@ function shapeShowOutput(result, detail, shape = "human") {
       "origin",
       "keys",
       "related",
+      "links",
       ...FRAGMENT_PROVENANCE_FIELDS,
       ...FRAGMENT_CONTEXT_FIELDS
     ]);
@@ -28846,6 +28848,7 @@ function shapeShowOutput(result, detail, shape = "human") {
     "activeRun",
     "keys",
     "related",
+    "links",
     ...FRAGMENT_PROVENANCE_FIELDS,
     ...FRAGMENT_CONTEXT_FIELDS,
     "path",
@@ -30853,6 +30856,22 @@ function formatShowPlain(r, detail) {
       lines.push(`    relationCount: ${String(hit.relationCount ?? 0)}`);
     }
   }
+  const links = typeof r.links === "object" && r.links !== null ? r.links : undefined;
+  if (links) {
+    lines.push("");
+    lines.push("links:");
+    for (const part of ["outgoing", "incoming", "unresolved"]) {
+      const groups = links[part];
+      if (typeof groups !== "object" || groups === null)
+        continue;
+      lines.push(`  ${part}:`);
+      for (const [kind, group] of Object.entries(groups)) {
+        const refs = Array.isArray(group.refs) ? group.refs.map(String) : [];
+        const more = (group.total ?? refs.length) > refs.length ? ` (+${(group.total ?? 0) - refs.length} more)` : "";
+        lines.push(`    ${kind}: ${refs.join(", ")}${more}`);
+      }
+    }
+  }
   const payloads = [r.content, r.template, r.prompt].filter((value) => value != null).map(String);
   if (Array.isArray(r.steps) && r.steps.length > 0) {
     if (lines.length > 0)
@@ -44297,6 +44316,22 @@ function applyFrontmatterDescriptionAndTags(fm, out) {
     }
   }
 }
+function storedCommandRef(action) {
+  return action?.kind === "stored" ? action.ref : undefined;
+}
+function workflowStepTarget(spec) {
+  if (!spec?.uses)
+    return;
+  if (spec.uses !== "akm/command")
+    return spec.uses;
+  if (spec.commandMode !== "stored-ref")
+    return;
+  try {
+    return storedCommandRef(parseBuiltinCommandAction(spec.with));
+  } catch {
+    return;
+  }
+}
 function finalizeHints(out, hints) {
   if (hints.size > 0)
     out.searchHints = Array.from(hints).filter(Boolean);
@@ -44390,6 +44425,9 @@ function foldRecognizedMetadata(rendererName, file) {
             hints.add(`prompt:${target.command.ref}`);
           else
             hints.add(`uses:${target.uses.ref}`);
+          const used = target.uses.kind !== "builtin-command" ? target.uses.ref : storedCommandRef(target.command);
+          if (used)
+            out.uses = [used];
         } else {
           hints.add(`run:${target.run}`);
         }
@@ -44453,6 +44491,7 @@ function foldRecognizedMetadata(rendererName, file) {
           return out;
         const plan = result.plan;
         const hints = new Set;
+        const uses = new Set;
         if (plan.preamble)
           hints.add(plan.preamble);
         for (const step of plan.steps) {
@@ -44460,8 +44499,13 @@ function foldRecognizedMetadata(rendererName, file) {
           hints.add(workflowStepInstructions(step));
           if (step.gate.criteria[0])
             hints.add(step.gate.criteria[0]);
+          const used = workflowStepTarget(step.spec);
+          if (used)
+            uses.add(used);
         }
         out.searchHints = Array.from(hints).filter(Boolean);
+        if (uses.size > 0)
+          out.uses = [...uses];
         if (plan.paramSchemas) {
           const parameters = Object.entries(plan.paramSchemas).map(([name, schema]) => {
             const description = schema.description;
@@ -44495,6 +44539,8 @@ function applyFoldedMetadata(entry, folded) {
     entry.toc = folded.toc;
   if (folded.parameters)
     entry.parameters = folded.parameters;
+  if (folded.uses)
+    entry.uses = folded.uses;
 }
 
 // src/core/adapter/adapters/akm-adapter.ts
@@ -44553,6 +44599,7 @@ var DOCUMENT_JSON_CARRIED_FIELDS = [
   "wikiRole",
   "sources",
   "evidenceSources",
+  "uses",
   "provenance"
 ];
 function indexDocumentFromEntry(entry, base, rendererName) {
@@ -53249,14 +53296,14 @@ function removeDeadResidue(stashDir) {
 import { randomUUID as randomUUID3 } from "node:crypto";
 import fs40 from "node:fs";
 import os7 from "node:os";
-import path49 from "node:path";
+import path48 from "node:path";
 
 // scripts/akm-migrate/migrate/task-files.ts
-import crypto5 from "node:crypto";
+import crypto4 from "node:crypto";
 import fs39 from "node:fs";
-import path48 from "node:path";
+import path47 from "node:path";
 
-// src/tasks/source/task-to-v3.ts
+// src/tasks/source/task-to-v4.ts
 import crypto3 from "node:crypto";
 import path46 from "node:path";
 
@@ -53617,7 +53664,51 @@ function parseTaskV3Yaml(input) {
   });
 }
 
-// src/tasks/source/task-to-v3.ts
+// src/tasks/source/task-to-v4.ts
+var V3_TOP_LEVEL_KEYS = new Set([
+  "version",
+  "name",
+  "uses",
+  "run",
+  "with",
+  "env",
+  "shell",
+  "working-directory",
+  "akm",
+  "on"
+]);
+var V3_AKM_KEYS = new Set([
+  "schedule",
+  "enabled",
+  "description",
+  "when_to_use",
+  "tags",
+  "agent",
+  "engine",
+  "model",
+  "inference",
+  "outputSchema",
+  "tools",
+  "timeout",
+  "redact",
+  "maxSteps",
+  "maxRetries"
+]);
+var V3_ON_KEYS = new Set(["schedule", "workflow_dispatch"]);
+var AKM_HOIST_KEYS = [
+  "description",
+  "when_to_use",
+  "tags",
+  "agent",
+  "engine",
+  "model",
+  "inference",
+  "tools",
+  "timeout",
+  "redact",
+  "maxSteps",
+  "maxRetries"
+];
 var V2_KEYS = new Set([
   "version",
   "name",
@@ -53688,9 +53779,13 @@ var KNOWN_PROMPT_REF_FAMILIES = new Set([
   "tasks",
   "workflows"
 ]);
+var ARGV_ARRAY_BLOCK_DETAIL = "Manual conversion required: an array `command:` has no safe v3 `run:` string. Rewrite it by hand as " + "`run:` (string) plus `shell:` — see docs/migration/v0.9.1-to-v0.9.2.md for the full v2 to v4 field mapping.";
 function hash(bytes) {
   return crypto3.createHash("sha256").update(bytes).digest("hex");
 }
+function causeMessage(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
 function base(input) {
   return {
     filePath: input.filePath,
@@ -53702,16 +53797,17 @@ function base(input) {
     ...input.containmentRoot ? { containmentRoot: input.containmentRoot } : {}
   };
 }
-var ARGV_ARRAY_BLOCK_DETAIL = "Manual conversion required: an array `command:` has no safe v3 `run:` string. Rewrite it by hand as " + "`run:` (string) plus `shell:` — see docs/migration/v0.9.1-to-v0.9.2.md for the full v2 to v4 field mapping.";
 function blocked(input, reason, detail) {
   return Object.freeze({ status: "blocked", ...base(input), reason, ...detail ? { detail } : {} });
 }
 function plainRecord(value, label) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`${label} must be a mapping`);
+  }
   const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null)
+  if (prototype !== Object.prototype && prototype !== null) {
     throw new Error(`${label} must use a plain or null prototype`);
+  }
   return value;
 }
 function exactString(value, label, nonempty = false) {
@@ -53725,7 +53821,7 @@ function optionalString(value, label) {
     return;
   return exactString(value, label);
 }
-function parseLegacyTaskYaml(input) {
+function parseRawTaskYaml(input) {
   let source;
   try {
     source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input.bytes);
@@ -53737,7 +53833,7 @@ function parseLegacyTaskYaml(input) {
   try {
     document = $parseDocument(source, { lineCounter: lineCounter2, uniqueKeys: true });
   } catch (cause) {
-    throw new Error(`invalid YAML: ${cause instanceof Error ? cause.message : String(cause)}`);
+    throw new Error(`invalid YAML: ${causeMessage(cause)}`);
   }
   const [parseError] = document.errors;
   if (parseError)
@@ -53748,11 +53844,181 @@ function parseLegacyTaskYaml(input) {
     throw new Error(`unsupported YAML construct: ${parseWarning.message}`);
   assertBoundedTaskYamlDocument(document, {
     filePath: input.filePath,
-    sourceLabel: "task v2 migration source",
+    sourceLabel: "task migration source",
     lineCounter: lineCounter2
   });
   return { data: plainRecord(document.toJS({ maxAliasCount: 0 }), "task YAML"), source };
 }
+function planV3DataToV4(input, data) {
+  const unknownTop = Object.keys(data).filter((key) => !V3_TOP_LEVEL_KEYS.has(key));
+  if (unknownTop.length > 0) {
+    return blocked(input, "invalid-v3-task", `unknown v3 field(s): ${unknownTop.join(", ")}`);
+  }
+  const hasUses = Object.hasOwn(data, "uses");
+  const hasRun = Object.hasOwn(data, "run");
+  if (hasUses === hasRun) {
+    return blocked(input, "invalid-v3-task", "requires exactly one executable selector: uses or run");
+  }
+  let akm;
+  if (Object.hasOwn(data, "akm")) {
+    try {
+      akm = plainRecord(data.akm, "akm");
+    } catch (cause) {
+      return blocked(input, "invalid-v3-task", causeMessage(cause));
+    }
+    const unknownAkm = Object.keys(akm).filter((key) => !V3_AKM_KEYS.has(key));
+    if (unknownAkm.length > 0) {
+      return blocked(input, "unrecognized-akm-member", `akm has unknown field(s): ${unknownAkm.join(", ")}`);
+    }
+    if (Object.hasOwn(akm, "enabled") && typeof akm.enabled !== "boolean") {
+      return blocked(input, "invalid-v3-task", "akm.enabled must be a boolean");
+    }
+    if (Object.hasOwn(akm, "schedule") && typeof akm.schedule !== "string") {
+      return blocked(input, "invalid-v3-task", "akm.schedule must be a string");
+    }
+  }
+  const hasOn = Object.hasOwn(data, "on");
+  let onRecord;
+  if (hasOn) {
+    try {
+      onRecord = plainRecord(data.on, "on");
+    } catch (cause) {
+      return blocked(input, "invalid-v3-task", causeMessage(cause));
+    }
+    if (Object.keys(onRecord).length === 0) {
+      return blocked(input, "invalid-v3-task", "on must declare schedule and/or workflow_dispatch.");
+    }
+    const unknownOn = Object.keys(onRecord).filter((key) => !V3_ON_KEYS.has(key));
+    if (unknownOn.length > 0) {
+      return blocked(input, "invalid-v3-task", `on has unknown field(s): ${unknownOn.join(", ")}`);
+    }
+    if (Object.hasOwn(onRecord, "workflow_dispatch") && onRecord.workflow_dispatch !== null) {
+      let dispatchMapping;
+      try {
+        dispatchMapping = plainRecord(onRecord.workflow_dispatch, "on.workflow_dispatch");
+      } catch (cause) {
+        return blocked(input, "invalid-v3-task", causeMessage(cause));
+      }
+      if (Object.keys(dispatchMapping).length > 0) {
+        return blocked(input, "invalid-v3-task", "on.workflow_dispatch must be null or an empty mapping; inputs are unsupported.");
+      }
+    }
+  }
+  const hasAkmSchedule = akm !== undefined && Object.hasOwn(akm, "schedule");
+  if (hasAkmSchedule && hasOn) {
+    return blocked(input, "ambiguous-scheduling-source", "declares both akm.schedule and on:; task v3 requires exactly one scheduling source and the migrator will not guess which one wins.");
+  }
+  if (!hasAkmSchedule && !hasOn) {
+    return blocked(input, "invalid-v3-task", "requires exactly one scheduling source: akm.schedule or on.");
+  }
+  const hasWith = Object.hasOwn(data, "with");
+  let usesTarget;
+  if (hasUses) {
+    let usesValue;
+    try {
+      usesValue = exactString(data.uses, "uses", true);
+    } catch (cause) {
+      return blocked(input, "invalid-v3-task", causeMessage(cause));
+    }
+    try {
+      usesTarget = classifyTaskV3Uses(usesValue);
+    } catch (cause) {
+      return blocked(input, "invalid-v3-task", causeMessage(cause));
+    }
+    if (usesTarget.kind === "github-action") {
+      return blocked(input, "github-action-target-removed", `"${usesValue}" is a github-action target; the github-action uses: variant was removed in task source v4. Use commands/, scripts/, workflows/, or akm/command instead.`);
+    }
+    if (hasWith && usesTarget.kind !== "builtin-command") {
+      return blocked(input, "with-on-non-command-target", `a with: block on "${usesValue}" (a non-akm/command target) has no task source v4 equivalent; task-call inputs are declared and bound separately.`);
+    }
+  } else if (hasWith) {
+    return blocked(input, "invalid-v3-task", "with is legal only with uses");
+  }
+  if (!input.writable || input.onDiskWritable === false) {
+    return blocked(input, "read-only-source", !input.writable ? "the owning source is not writable" : "the source file or publication directory is read-only");
+  }
+  let scheduleField;
+  const notices = [];
+  if (hasAkmSchedule) {
+    const cron = akm.schedule;
+    scheduleField = cron;
+  } else {
+    const rawSchedule = onRecord !== undefined && Object.hasOwn(onRecord, "schedule") ? onRecord.schedule : undefined;
+    if (rawSchedule !== undefined) {
+      if (!Array.isArray(rawSchedule) || rawSchedule.length === 0) {
+        return blocked(input, "invalid-v3-task", "on.schedule must be a non-empty list of {cron} records");
+      }
+      const crons = [];
+      for (const entry of rawSchedule) {
+        let record;
+        try {
+          record = plainRecord(entry, "on.schedule[]");
+        } catch (cause) {
+          return blocked(input, "invalid-v3-task", causeMessage(cause));
+        }
+        const keys = Object.keys(record);
+        if (keys.length !== 1 || keys[0] !== "cron" || typeof record.cron !== "string" || record.cron.length === 0) {
+          return blocked(input, "invalid-v3-task", "each on.schedule entry must be exactly {cron: <non-empty string>}");
+        }
+        crons.push(record.cron);
+      }
+      scheduleField = crons.map((cron) => ({ cron }));
+    } else {
+      notices.push("schedule: is absent from the migrated document — the source's only trigger was on.workflow_dispatch (manual dispatch); task source v4 tasks are always runnable manually via `akm task run`, so no schedule: entry was emitted.");
+    }
+  }
+  const out = { version: 4 };
+  if (Object.hasOwn(data, "name"))
+    out.name = data.name;
+  if (hasUses)
+    out.uses = data.uses;
+  else
+    out.run = data.run;
+  if (Object.hasOwn(data, "shell"))
+    out.shell = data.shell;
+  if (hasWith)
+    out.with = data.with;
+  if (Object.hasOwn(data, "env"))
+    out.env = data.env;
+  if (Object.hasOwn(data, "working-directory"))
+    out["working-directory"] = data["working-directory"];
+  if (scheduleField !== undefined)
+    out.schedule = scheduleField;
+  if (akm) {
+    for (const key of AKM_HOIST_KEYS) {
+      if (Object.hasOwn(akm, key))
+        out[key] = akm[key];
+    }
+    if (Object.hasOwn(akm, "outputSchema") && akm.outputSchema !== null) {
+      if (usesTarget !== undefined && (usesTarget.kind === "command" || usesTarget.kind === "builtin-command")) {
+        out.output = akm.outputSchema;
+      } else {
+        const targetLabel = usesTarget === undefined ? "a run: target" : `the "${usesTarget.ref}" target`;
+        notices.push(`akm.outputSchema was dropped rather than hoisted to output: — task source v4 accepts output: only with a command target (uses: commands/<ref> or uses: akm/command), and ${targetLabel} never consumed the schema in v3 either, so nothing enforceable was lost.`);
+      }
+    }
+  }
+  const afterYaml = $stringify(out);
+  const after = Buffer.from(afterYaml, "utf8");
+  try {
+    parseTaskSourceV4({
+      yaml: afterYaml,
+      filePath: input.filePath,
+      ...input.containmentRoot ? { workspaceRoot: input.containmentRoot } : {}
+    });
+  } catch (cause) {
+    return blocked(input, "generated-v4-validation-failed", causeMessage(cause));
+  }
+  const notice = notices.join(" ");
+  return Object.freeze({
+    status: "changed",
+    ...base(input),
+    reason: "task-converted",
+    after,
+    afterHash: hash(after),
+    ...notice ? { notice } : {}
+  });
+}
 function validateCommonV2(data) {
   const unknown = Object.keys(data).filter((key) => !V2_KEYS.has(key));
   if (unknown.length > 0)
@@ -53947,424 +54213,120 @@ function migratedObject(data) {
 function isReason(value) {
   return typeof value === "string";
 }
-function planLegacyTaskDataToV3(input, data) {
-  if (data.version !== 2) {
-    return blocked(input, "unsupported-task-version", `expected normalized legacy version 2, got ${String(data.version)}`);
-  }
+function planV2DataToV4(input, data) {
   if (!input.writable || input.onDiskWritable === false) {
     return blocked(input, "read-only-source", !input.writable ? "the owning source is not writable" : "the source file or publication directory is read-only");
   }
   try {
     validateTaskId(path46.basename(input.filePath, ".yml"));
   } catch (cause) {
-    return blocked(input, "invalid-v2-task", cause instanceof Error ? cause.message : String(cause));
+    return blocked(input, "invalid-v2-task", causeMessage(cause));
   }
   let migrated;
   try {
     migrated = migratedObject(data);
   } catch (cause) {
-    return blocked(input, "invalid-v2-task", cause instanceof Error ? cause.message : String(cause));
+    return blocked(input, "invalid-v2-task", causeMessage(cause));
   }
   if (isReason(migrated)) {
     const detail = migrated === "argv-array-has-no-portable-shell-string" ? ARGV_ARRAY_BLOCK_DETAIL : undefined;
     return blocked(input, migrated, detail);
   }
-  const after = Buffer.from($stringify(migrated), "utf8");
+  const v3Yaml = $stringify(migrated);
   try {
     parseTaskV3Yaml({
-      yaml: after.toString("utf8"),
+      yaml: v3Yaml,
       filePath: input.filePath,
       ...input.containmentRoot ? { workspaceRoot: input.containmentRoot } : {}
     });
   } catch (cause) {
-    return blocked(input, "generated-v3-validation-failed", cause instanceof Error ? cause.message : String(cause));
+    return blocked(input, "generated-v3-validation-failed", causeMessage(cause));
   }
-  return Object.freeze({
-    status: "changed",
-    ...base(input),
-    reason: "task-converted",
-    after,
-    afterHash: hash(after)
-  });
-}
-function planTaskToV3File(input) {
-  let data;
-  let source;
+  let v3Data;
   try {
-    ({ data, source } = parseLegacyTaskYaml(input));
+    ({ data: v3Data } = parseRawTaskYaml({ ...input, bytes: Buffer.from(v3Yaml, "utf8") }));
   } catch (cause) {
-    return blocked(input, "invalid-task-yaml", cause instanceof Error ? cause.message : String(cause));
+    return blocked(input, "invalid-task-yaml", causeMessage(cause));
+  }
+  const v4Outcome = planV3DataToV4(input, v3Data);
+  return v4Outcome.status === "changed" ? { ...v4Outcome, reason: "task-converted" } : v4Outcome;
+}
+function planV4Cleanup(input, source) {
+  const document = $parseDocument(source, { uniqueKeys: true });
+  const schedule = document.get("schedule", true);
+  let removed = false;
+  if ($isSeq(schedule)) {
+    for (const entry of schedule.items) {
+      if (!$isMap(entry) || !entry.has("enabled"))
+        continue;
+      entry.delete("enabled");
+      removed = true;
+    }
   }
-  if (data.version === 3) {
+  if (removed) {
+    if (!input.writable || input.onDiskWritable === false) {
+      return blocked(input, "read-only-source", !input.writable ? "the owning source is not writable" : "the source file or publication directory is read-only");
+    }
+    const after = Buffer.from(document.toString(), "utf8");
     try {
-      parseTaskV3Yaml({
-        yaml: source,
+      parseTaskSourceV4({
+        yaml: after.toString("utf8"),
         filePath: input.filePath,
         ...input.containmentRoot ? { workspaceRoot: input.containmentRoot } : {}
       });
-      return Object.freeze({ status: "skipped", ...base(input), reason: "already-v3" });
-    } catch (cause) {
-      return blocked(input, "invalid-v3-task", cause instanceof Error ? cause.message : String(cause));
-    }
-  }
-  if (data.version === 4) {
-    return Object.freeze({ status: "skipped", ...base(input), reason: "already-v4" });
-  }
-  if (data.version !== 2) {
-    return blocked(input, "unsupported-task-version", `expected version 2, 3, or 4, got ${String(data.version)}`);
-  }
-  return planLegacyTaskDataToV3(input, data);
-}
-
-// src/tasks/source/task-to-v4.ts
-import crypto4 from "node:crypto";
-import path47 from "node:path";
-var V3_TOP_LEVEL_KEYS = new Set([
-  "version",
-  "name",
-  "uses",
-  "run",
-  "with",
-  "env",
-  "shell",
-  "working-directory",
-  "akm",
-  "on"
-]);
-var V3_AKM_KEYS = new Set([
-  "schedule",
-  "enabled",
-  "description",
-  "when_to_use",
-  "tags",
-  "agent",
-  "engine",
-  "model",
-  "inference",
-  "outputSchema",
-  "tools",
-  "timeout",
-  "redact",
-  "maxSteps",
-  "maxRetries"
-]);
-var V3_ON_KEYS = new Set(["schedule", "workflow_dispatch"]);
-var AKM_HOIST_KEYS = [
-  "description",
-  "when_to_use",
-  "tags",
-  "agent",
-  "engine",
-  "model",
-  "inference",
-  "tools",
-  "timeout",
-  "redact",
-  "maxSteps",
-  "maxRetries"
-];
-function hash2(bytes) {
-  return crypto4.createHash("sha256").update(bytes).digest("hex");
-}
-function causeMessage(cause) {
-  return cause instanceof Error ? cause.message : String(cause);
-}
-function base2(input) {
-  return {
-    filePath: input.filePath,
-    before: Buffer.from(input.bytes),
-    beforeHash: hash2(input.bytes),
-    mode: input.mode,
-    writable: input.writable,
-    ...input.onDiskWritable !== undefined ? { onDiskWritable: input.onDiskWritable } : {},
-    ...input.containmentRoot ? { containmentRoot: input.containmentRoot } : {}
-  };
-}
-function blocked2(input, reason, detail) {
-  return Object.freeze({ status: "blocked", ...base2(input), reason, ...detail ? { detail } : {} });
-}
-function plainRecord2(value, label) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${label} must be a mapping`);
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw new Error(`${label} must use a plain or null prototype`);
-  }
-  return value;
-}
-function exactString2(value, label, nonempty = false) {
-  if (typeof value !== "string" || nonempty && value.trim().length === 0) {
-    throw new Error(`${label} must be ${nonempty ? "a non-empty " : "a "}string`);
-  }
-  return value;
-}
-function parseV3RawYaml(input) {
-  let source;
-  try {
-    source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input.bytes);
-  } catch {
-    throw new Error("task YAML contains invalid UTF-8 bytes");
-  }
-  const lineCounter2 = new $LineCounter;
-  let document;
-  try {
-    document = $parseDocument(source, { lineCounter: lineCounter2, uniqueKeys: true });
-  } catch (cause) {
-    throw new Error(`invalid YAML: ${causeMessage(cause)}`);
-  }
-  const [parseError] = document.errors;
-  if (parseError)
-    throw new Error(`invalid YAML: ${parseError.message.split(`
-`)[0]}`);
-  const [parseWarning] = document.warnings;
-  if (parseWarning)
-    throw new Error(`unsupported YAML construct: ${parseWarning.message}`);
-  assertBoundedTaskYamlDocument(document, {
-    filePath: input.filePath,
-    sourceLabel: "task v3 migration source",
-    lineCounter: lineCounter2
-  });
-  return { data: plainRecord2(document.toJS({ maxAliasCount: 0 }), "task YAML"), source };
-}
-function planV3DataToV4(input, data) {
-  const unknownTop = Object.keys(data).filter((key) => !V3_TOP_LEVEL_KEYS.has(key));
-  if (unknownTop.length > 0) {
-    return blocked2(input, "invalid-v3-task", `unknown v3 field(s): ${unknownTop.join(", ")}`);
-  }
-  const hasUses = Object.hasOwn(data, "uses");
-  const hasRun = Object.hasOwn(data, "run");
-  if (hasUses === hasRun) {
-    return blocked2(input, "invalid-v3-task", "requires exactly one executable selector: uses or run");
-  }
-  let akm;
-  if (Object.hasOwn(data, "akm")) {
-    try {
-      akm = plainRecord2(data.akm, "akm");
-    } catch (cause) {
-      return blocked2(input, "invalid-v3-task", causeMessage(cause));
-    }
-    const unknownAkm = Object.keys(akm).filter((key) => !V3_AKM_KEYS.has(key));
-    if (unknownAkm.length > 0) {
-      return blocked2(input, "unrecognized-akm-member", `akm has unknown field(s): ${unknownAkm.join(", ")}`);
-    }
-    if (Object.hasOwn(akm, "enabled") && typeof akm.enabled !== "boolean") {
-      return blocked2(input, "invalid-v3-task", "akm.enabled must be a boolean");
-    }
-    if (Object.hasOwn(akm, "schedule") && typeof akm.schedule !== "string") {
-      return blocked2(input, "invalid-v3-task", "akm.schedule must be a string");
-    }
-  }
-  const hasOn = Object.hasOwn(data, "on");
-  let onRecord;
-  if (hasOn) {
-    try {
-      onRecord = plainRecord2(data.on, "on");
-    } catch (cause) {
-      return blocked2(input, "invalid-v3-task", causeMessage(cause));
-    }
-    if (Object.keys(onRecord).length === 0) {
-      return blocked2(input, "invalid-v3-task", "on must declare schedule and/or workflow_dispatch.");
-    }
-    const unknownOn = Object.keys(onRecord).filter((key) => !V3_ON_KEYS.has(key));
-    if (unknownOn.length > 0) {
-      return blocked2(input, "invalid-v3-task", `on has unknown field(s): ${unknownOn.join(", ")}`);
-    }
-    if (Object.hasOwn(onRecord, "workflow_dispatch") && onRecord.workflow_dispatch !== null) {
-      let dispatchMapping;
-      try {
-        dispatchMapping = plainRecord2(onRecord.workflow_dispatch, "on.workflow_dispatch");
-      } catch (cause) {
-        return blocked2(input, "invalid-v3-task", causeMessage(cause));
-      }
-      if (Object.keys(dispatchMapping).length > 0) {
-        return blocked2(input, "invalid-v3-task", "on.workflow_dispatch must be null or an empty mapping; inputs are unsupported.");
-      }
-    }
-  }
-  const hasAkmSchedule = akm !== undefined && Object.hasOwn(akm, "schedule");
-  if (hasAkmSchedule && hasOn) {
-    return blocked2(input, "ambiguous-scheduling-source", "declares both akm.schedule and on:; task v3 requires exactly one scheduling source and the migrator will not guess which one wins.");
-  }
-  if (!hasAkmSchedule && !hasOn) {
-    return blocked2(input, "invalid-v3-task", "requires exactly one scheduling source: akm.schedule or on.");
-  }
-  const hasWith = Object.hasOwn(data, "with");
-  let usesTarget;
-  if (hasUses) {
-    let usesValue;
-    try {
-      usesValue = exactString2(data.uses, "uses", true);
     } catch (cause) {
-      return blocked2(input, "invalid-v3-task", causeMessage(cause));
-    }
-    try {
-      usesTarget = classifyTaskV3Uses(usesValue);
-    } catch (cause) {
-      return blocked2(input, "invalid-v3-task", causeMessage(cause));
-    }
-    if (usesTarget.kind === "github-action") {
-      return blocked2(input, "github-action-target-removed", `"${usesValue}" is a github-action target; the github-action uses: variant was removed in task source v4. Use commands/, scripts/, workflows/, or akm/command instead.`);
-    }
-    if (hasWith && usesTarget.kind !== "builtin-command") {
-      return blocked2(input, "with-on-non-command-target", `a with: block on "${usesValue}" (a non-akm/command target) has no task source v4 equivalent; task-call inputs are declared and bound separately.`);
-    }
-  } else if (hasWith) {
-    return blocked2(input, "invalid-v3-task", "with is legal only with uses");
-  }
-  if (!input.writable || input.onDiskWritable === false) {
-    return blocked2(input, "read-only-source", !input.writable ? "the owning source is not writable" : "the source file or publication directory is read-only");
-  }
-  let scheduleField;
-  const notices = [];
-  if (hasAkmSchedule) {
-    const cron = akm.schedule;
-    scheduleField = cron;
-  } else {
-    const rawSchedule = onRecord !== undefined && Object.hasOwn(onRecord, "schedule") ? onRecord.schedule : undefined;
-    if (rawSchedule !== undefined) {
-      if (!Array.isArray(rawSchedule) || rawSchedule.length === 0) {
-        return blocked2(input, "invalid-v3-task", "on.schedule must be a non-empty list of {cron} records");
-      }
-      const crons = [];
-      for (const entry of rawSchedule) {
-        let record;
-        try {
-          record = plainRecord2(entry, "on.schedule[]");
-        } catch (cause) {
-          return blocked2(input, "invalid-v3-task", causeMessage(cause));
-        }
-        const keys = Object.keys(record);
-        if (keys.length !== 1 || keys[0] !== "cron" || typeof record.cron !== "string" || record.cron.length === 0) {
-          return blocked2(input, "invalid-v3-task", "each on.schedule entry must be exactly {cron: <non-empty string>}");
-        }
-        crons.push(record.cron);
-      }
-      scheduleField = crons.map((cron) => ({ cron }));
-    } else {
-      notices.push("schedule: is absent from the migrated document — the source's only trigger was on.workflow_dispatch (manual dispatch); task source v4 tasks are always runnable manually via `akm task run`, so no schedule: entry was emitted.");
-    }
-  }
-  const out = { version: 4 };
-  if (Object.hasOwn(data, "name"))
-    out.name = data.name;
-  if (hasUses)
-    out.uses = data.uses;
-  else
-    out.run = data.run;
-  if (Object.hasOwn(data, "shell"))
-    out.shell = data.shell;
-  if (hasWith)
-    out.with = data.with;
-  if (Object.hasOwn(data, "env"))
-    out.env = data.env;
-  if (Object.hasOwn(data, "working-directory"))
-    out["working-directory"] = data["working-directory"];
-  if (scheduleField !== undefined)
-    out.schedule = scheduleField;
-  if (akm) {
-    for (const key of AKM_HOIST_KEYS) {
-      if (Object.hasOwn(akm, key))
-        out[key] = akm[key];
-    }
-    if (Object.hasOwn(akm, "outputSchema") && akm.outputSchema !== null) {
-      if (usesTarget !== undefined && (usesTarget.kind === "command" || usesTarget.kind === "builtin-command")) {
-        out.output = akm.outputSchema;
-      } else {
-        const targetLabel = usesTarget === undefined ? "a run: target" : `the "${usesTarget.ref}" target`;
-        notices.push(`akm.outputSchema was dropped rather than hoisted to output: — task source v4 accepts output: only with a command target (uses: commands/<ref> or uses: akm/command), and ${targetLabel} never consumed the schema in v3 either, so nothing enforceable was lost.`);
-      }
+      return blocked(input, "generated-v4-validation-failed", causeMessage(cause));
     }
+    return Object.freeze({
+      status: "changed",
+      ...base(input),
+      reason: "source-enablement-removed",
+      after,
+      afterHash: hash(after),
+      notice: "Removed source-owned schedule enablement; scheduler activation is now host-local config."
+    });
   }
-  const afterYaml = $stringify(out);
-  const after = Buffer.from(afterYaml, "utf8");
   try {
     parseTaskSourceV4({
-      yaml: afterYaml,
+      yaml: source,
       filePath: input.filePath,
       ...input.containmentRoot ? { workspaceRoot: input.containmentRoot } : {}
     });
+    return Object.freeze({ status: "skipped", ...base(input), reason: "already-v4" });
   } catch (cause) {
-    return blocked2(input, "generated-v4-validation-failed", causeMessage(cause));
+    return blocked(input, "invalid-v4-task", causeMessage(cause));
   }
-  const notice = notices.join(" ");
-  return Object.freeze({
-    status: "changed",
-    ...base2(input),
-    reason: "task-converted",
-    after,
-    afterHash: hash2(after),
-    ...notice ? { notice } : {}
-  });
 }
 function planTaskToV4File(input) {
   let data;
   let source;
   try {
-    ({ data, source } = parseV3RawYaml(input));
+    ({ data, source } = parseRawTaskYaml(input));
   } catch (cause) {
-    return blocked2(input, "invalid-task-yaml", causeMessage(cause));
+    return blocked(input, "invalid-task-yaml", causeMessage(cause));
   }
   if (data.version === 4) {
-    const document = $parseDocument(source, { uniqueKeys: true });
-    const schedule = document.get("schedule", true);
-    let removed = false;
-    if ($isSeq(schedule)) {
-      for (const entry of schedule.items) {
-        if (!$isMap(entry) || !entry.has("enabled"))
-          continue;
-        entry.delete("enabled");
-        removed = true;
-      }
-    }
-    if (removed) {
-      if (!input.writable || input.onDiskWritable === false) {
-        return blocked2(input, "read-only-source", !input.writable ? "the owning source is not writable" : "the source file or publication directory is read-only");
-      }
-      const after = Buffer.from(document.toString(), "utf8");
-      try {
-        parseTaskSourceV4({
-          yaml: after.toString("utf8"),
-          filePath: input.filePath,
-          ...input.containmentRoot ? { workspaceRoot: input.containmentRoot } : {}
-        });
-      } catch (cause) {
-        return blocked2(input, "generated-v4-validation-failed", causeMessage(cause));
-      }
-      return Object.freeze({
-        status: "changed",
-        ...base2(input),
-        reason: "source-enablement-removed",
-        after,
-        afterHash: hash2(after),
-        notice: "Removed source-owned schedule enablement; scheduler activation is now host-local config."
-      });
-    }
+    return planV4Cleanup(input, source);
+  }
+  if (data.version === 3) {
     try {
-      parseTaskSourceV4({
+      parseTaskV3Yaml({
         yaml: source,
         filePath: input.filePath,
         ...input.containmentRoot ? { workspaceRoot: input.containmentRoot } : {}
       });
-      return Object.freeze({ status: "skipped", ...base2(input), reason: "already-v4" });
     } catch (cause) {
-      return blocked2(input, "invalid-v4-task", causeMessage(cause));
+      return blocked(input, "invalid-v3-task", causeMessage(cause));
     }
+    return planV3DataToV4(input, data);
   }
   if (data.version === 2) {
-    return Object.freeze({
-      status: "skipped",
-      ...base2(input),
-      reason: "pending-v2-to-v3-migration"
-    });
-  }
-  if (data.version !== 3) {
-    return blocked2(input, "unsupported-task-version", `expected version 2, 3, or 4, got ${String(data.version)}`);
+    return planV2DataToV4(input, data);
   }
-  return planV3DataToV4(input, data);
+  return blocked(input, "unsupported-task-version", `expected version 2, 3, or 4, got ${String(data.version)}`);
 }
 function generationFor(files) {
-  const digest = crypto4.createHash("sha256");
+  const digest = crypto3.createHash("sha256");
   digest.update("akm-task-to-v4-plan-v1\x00");
   for (const file of files) {
     digest.update(file.filePath);
@@ -54401,7 +54363,7 @@ function taskToV4PlanFromOutcomes(outcomes) {
   for (let index = 1;index < files.length; index += 1) {
     const previous = files[index - 1];
     const current = files[index];
-    if (previous && current && path47.resolve(previous.filePath) === path47.resolve(current.filePath)) {
+    if (previous && current && path46.resolve(previous.filePath) === path46.resolve(current.filePath)) {
       throw new Error(`duplicate task migration file path: ${current.filePath}`);
     }
   }
@@ -54413,8 +54375,8 @@ function migrationError(detail) {
   return new ConfigError(`Task migration failed: ${detail}`, "INVALID_CONFIG_FILE");
 }
 function contained2(root, candidate) {
-  const relative = path48.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path48.isAbsolute(relative);
+  const relative = path47.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path47.isAbsolute(relative);
 }
 function realDirectory(filePath) {
   const stat = fs39.lstatSync(filePath);
@@ -54442,7 +54404,7 @@ function walkTasks(root, tasksDir, out) {
       throw migrationError(`${directory} resolves outside bundle ${root.bundleId}.`);
     }
     for (const entry of fs39.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const candidate = path48.join(directory, entry.name);
+      const candidate = path47.join(directory, entry.name);
       if (entry.isSymbolicLink())
         throw migrationError(`task migration does not follow symbolic link ${candidate}.`);
       if (entry.isDirectory()) {
@@ -54468,7 +54430,7 @@ function walkTasks(root, tasksDir, out) {
 function inspectTaskFiles(roots) {
   const files = [];
   for (const root of [...roots].sort((a, b) => a.bundleId.localeCompare(b.bundleId))) {
-    const tasksDir = root.layout === "akm-task" ? root.root : path48.join(root.root, "tasks");
+    const tasksDir = root.layout === "akm-task" ? root.root : path47.join(root.root, "tasks");
     try {
       const stat = fs39.lstatSync(tasksDir);
       if (stat.isSymbolicLink())
@@ -54484,23 +54446,12 @@ function inspectTaskFiles(roots) {
   }
   return files.sort((a, b) => a.filePath.localeCompare(b.filePath));
 }
-function planTaskFileToV4(input) {
-  const v3 = planTaskToV3File(input);
-  if (v3.status === "blocked")
-    return v3;
-  if (v3.status === "skipped")
-    return planTaskToV4File(input);
-  const v4 = planTaskToV4File({ ...input, bytes: v3.after });
-  if (v4.status !== "changed")
-    return { ...v4, before: v3.before, beforeHash: v3.beforeHash };
-  return { ...v4, reason: "task-converted", before: v3.before, beforeHash: v3.beforeHash };
-}
 function planTaskFilesMigration(inputs) {
-  return taskToV4PlanFromOutcomes(inputs.map(planTaskFileToV4));
+  return taskToV4PlanFromOutcomes(inputs.map(planTaskToV4File));
 }
 function taskFileBackupPath(backupRoot, filePath) {
-  const digest = crypto5.createHash("sha256").update(path48.resolve(filePath)).digest("hex").slice(0, 16);
-  return path48.join(backupRoot, "files", `${digest}-${path48.basename(filePath)}`);
+  const digest = crypto4.createHash("sha256").update(path47.resolve(filePath)).digest("hex").slice(0, 16);
+  return path47.join(backupRoot, "files", `${digest}-${path47.basename(filePath)}`);
 }
 function fsyncDirectory(directory) {
   if (process.platform === "win32")
@@ -54519,7 +54470,7 @@ function fsyncDirectory(directory) {
   }
 }
 function writeDurable(filePath, bytes, mode, exclusive = false) {
-  fs39.mkdirSync(path48.dirname(filePath), { recursive: true });
+  fs39.mkdirSync(path47.dirname(filePath), { recursive: true });
   const fd = fs39.openSync(filePath, exclusive ? "wx" : "w", mode);
   try {
     fs39.writeFileSync(fd, bytes);
@@ -54528,14 +54479,14 @@ function writeDurable(filePath, bytes, mode, exclusive = false) {
     fs39.closeSync(fd);
   }
   fs39.chmodSync(filePath, mode);
-  fsyncDirectory(path48.dirname(filePath));
+  fsyncDirectory(path47.dirname(filePath));
 }
 function replaceAtomically(filePath, bytes, mode) {
-  const temporary = path48.join(path48.dirname(filePath), `.${path48.basename(filePath)}.migrate-${crypto5.randomUUID()}`);
+  const temporary = path47.join(path47.dirname(filePath), `.${path47.basename(filePath)}.migrate-${crypto4.randomUUID()}`);
   try {
     writeDurable(temporary, bytes, mode, true);
     fs39.renameSync(temporary, filePath);
-    fsyncDirectory(path48.dirname(filePath));
+    fsyncDirectory(path47.dirname(filePath));
   } finally {
     fs39.rmSync(temporary, { force: true });
   }
@@ -54572,7 +54523,7 @@ function expandTilde(value) {
   if (value === "~")
     return os7.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\"))
-    return path49.join(os7.homedir(), value.slice(2));
+    return path48.join(os7.homedir(), value.slice(2));
   return value;
 }
 function existingDirectory(target) {
@@ -54598,14 +54549,14 @@ function taskRoots(config, resolutionBase = process.cwd()) {
     const source = sources.get(bundleId);
     if (!source)
       continue;
-    const configuredRoot = source.type === "filesystem" && source.path ? path49.resolve(resolutionBase, expandTilde(source.path)) : lockContentRootFor(bundleId, source.type);
+    const configuredRoot = source.type === "filesystem" && source.path ? path48.resolve(resolutionBase, expandTilde(source.path)) : lockContentRootFor(bundleId, source.type);
     if (!configuredRoot || !existingDirectory(configuredRoot))
       continue;
-    const bundleRoot = path49.resolve(configuredRoot);
+    const bundleRoot = path48.resolve(configuredRoot);
     const component = bundleComponentConfig(bundle);
-    const componentRoot = path49.resolve(bundleRoot, component?.root ?? ".");
-    const relative = path49.relative(bundleRoot, componentRoot);
-    if (relative === ".." || relative.startsWith(`..${path49.sep}`) || path49.isAbsolute(relative)) {
+    const componentRoot = path48.resolve(bundleRoot, component?.root ?? ".");
+    const relative = path48.relative(bundleRoot, componentRoot);
+    if (relative === ".." || relative.startsWith(`..${path48.sep}`) || path48.isAbsolute(relative)) {
       throw new ConfigError(`Task migration component root ${componentRoot} escapes bundle ${bundleId} at ${bundleRoot}.`, "INVALID_CONFIG_FILE");
     }
     if (!existingDirectory(componentRoot))
@@ -54622,7 +54573,7 @@ function taskRoots(config, resolutionBase = process.cwd()) {
   }
   const envStash = process.env.AKM_BUNDLE_DIR?.trim();
   if (envStash && existingDirectory(envStash)) {
-    const stashRoot = path49.resolve(envStash);
+    const stashRoot = path48.resolve(envStash);
     if (!rootsByPath.has(stashRoot)) {
       const bundleId = deriveBundleId(undefined, stashRoot, new Set(Object.keys(config.bundles ?? {})));
       const candidate = taskRoot(bundleId, stashRoot, stashRoot, detectAdapterId(stashRoot), () => true);
@@ -54691,7 +54642,7 @@ function applyTaskFilesMigration() {
     const before = inspectCurrent();
     if (before.result.taskFiles.changed === 0)
       return before.result;
-    const backupPath = path49.join(getDataDir(), "backups", "tasks", `${Date.now()}-${randomUUID3()}`);
+    const backupPath = path48.join(getDataDir(), "backups", "tasks", `${Date.now()}-${randomUUID3()}`);
     const applied = applyTaskFilesPlan(before.plan, { backupRoot: backupPath });
     return { ...inspectCurrent().result, backupPath, applied: applied.changed.length };
   });