akm-cli 0.9.25-alpha.2 → 0.9.25-alpha.3

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

@@ -51767,6 +51767,170 @@ var codexResultExtractor = (result) => {
   return sessionId === undefined ? { text } : { text, sessionId };
 };
 
+// src/integrations/harnesses/codex/session-log.ts
+import fs36 from "node:fs";
+import os5 from "node:os";
+import path43 from "node:path";
+function codexSessionsDir() {
+  return path43.join(process.env.CODEX_HOME || path43.join(os5.homedir(), ".codex"), "sessions");
+}
+var META_PEEK_BYTES = 128 * 1024;
+var INJECTED_CONTEXT_RE = /^\s*(?:# AGENTS\.md instructions[\s\S]*<\/INSTRUCTIONS>|<(environment_context|user_instructions|recommended_plugins|skill|turn_aborted)>[\s\S]*<\/\1>)\s*$/i;
+function parseSessionMeta(entry) {
+  const e = entry;
+  if (e?.type !== "session_meta" || !e.payload)
+    return;
+  const { timestamp, cwd, source } = e.payload;
+  const startedAt = typeof timestamp === "string" ? Date.parse(timestamp) : Number.NaN;
+  return {
+    ...Number.isNaN(startedAt) ? {} : { startedAt },
+    ...typeof cwd === "string" ? { cwd } : {},
+    isAgent: typeof source === "object" && source !== null && (("subagent" in source) || ("internal" in source))
+  };
+}
+function blockText(blocks, keep = () => true) {
+  if (typeof blocks === "string")
+    return blocks;
+  if (!Array.isArray(blocks))
+    return "";
+  const parts = [];
+  for (const block of blocks) {
+    const text = block?.text;
+    if (typeof text === "string" && keep(text))
+      parts.push(text);
+  }
+  return parts.join(`
+`);
+}
+function toolInputText(input) {
+  let args = input;
+  if (typeof input === "string") {
+    try {
+      args = JSON.parse(input);
+    } catch {
+      return input;
+    }
+  }
+  const fields = args && typeof args === "object" ? args : {};
+  const cmd = fields.cmd ?? fields.command;
+  if (typeof cmd === "string")
+    return cmd;
+  if (Array.isArray(cmd))
+    return cmd.join(" ");
+  return typeof input === "string" ? input : JSON.stringify(input) ?? "";
+}
+function parseCodexRecord(entry, sessionId, filePath, fallbackTsMs) {
+  const e = entry;
+  const item = e?.type === "response_item" ? e.payload : undefined;
+  if (!item)
+    return;
+  const toolName2 = typeof item.name === "string" ? item.name : "tool";
+  let role = "assistant";
+  let text;
+  switch (item.type) {
+    case "message":
+      if (item.role !== "user" && item.role !== "assistant")
+        return;
+      role = item.role;
+      text = blockText(item.content, item.role === "user" ? (t) => !INJECTED_CONTEXT_RE.test(t) : undefined);
+      break;
+    case "function_call":
+      text = `[tool:${toolName2}] ${toolInputText(item.arguments)}`;
+      break;
+    case "custom_tool_call":
+      text = `[tool:${toolName2}] ${typeof item.input === "string" ? item.input : ""}`;
+      break;
+    case "local_shell_call":
+      text = `[tool:shell] ${toolInputText(item.action)}`;
+      break;
+    case "function_call_output":
+    case "custom_tool_call_output": {
+      role = "tool";
+      const output = blockText(item.output);
+      text = output ? `[tool_result] ${output}` : "";
+      break;
+    }
+    default:
+      return;
+  }
+  if (!text.trim())
+    return;
+  const ts = typeof e?.timestamp === "string" ? Date.parse(e.timestamp) || fallbackTsMs : fallbackTsMs;
+  return { harness: "codex", text, ts, sessionId, role, filePath };
+}
+
+class CodexProvider extends AbstractSessionLogProvider {
+  name = "codex";
+  availabilityRoot() {
+    return codexSessionsDir();
+  }
+  listSessions(input = {}) {
+    return this.listSessionsFromFiles({
+      sinceMs: input.sinceMs ?? 0,
+      enumerate: () => this.walkFiles(input.location ?? codexSessionsDir(), (name) => /^rollout-.+\.jsonl$/.test(name)),
+      summarize: (rolloutPath, stat) => {
+        const meta = this.#peekMeta(rolloutPath);
+        if (meta?.isAgent)
+          return;
+        return this.sessionRef({
+          sessionId: path43.basename(rolloutPath, ".jsonl").slice(-36),
+          filePath: rolloutPath,
+          startedAt: meta?.startedAt ?? stat.ctimeMs,
+          endedAt: stat.mtimeMs,
+          projectHint: meta?.cwd
+        });
+      }
+    });
+  }
+  readSession(ref) {
+    const stat = fs36.statSync(ref.filePath);
+    const events = [];
+    const inlineRefs = [];
+    let meta;
+    for (const line of fs36.readFileSync(ref.filePath, "utf8").split(`
+`).filter(Boolean)) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      meta ??= parseSessionMeta(entry);
+      const parsed = parseCodexRecord(entry, ref.sessionId, ref.filePath, stat.mtimeMs);
+      if (!parsed)
+        continue;
+      events.push(parsed);
+      inlineRefs.push(...extractInlineRefMentions(parsed.text, parsed.ts));
+    }
+    return {
+      ref: this.sessionRef({
+        sessionId: ref.sessionId,
+        filePath: ref.filePath,
+        startedAt: meta?.startedAt ?? events[0]?.ts ?? stat.ctimeMs,
+        endedAt: events[events.length - 1]?.ts ?? stat.mtimeMs,
+        projectHint: meta?.cwd
+      }),
+      events,
+      inlineRefs
+    };
+  }
+  #peekMeta(filePath) {
+    try {
+      const fd = fs36.openSync(filePath, "r");
+      try {
+        const head = Buffer.alloc(META_PEEK_BYTES);
+        const firstLine = head.toString("utf8", 0, fs36.readSync(fd, head, 0, head.length, 0)).split(`
+`, 1)[0] ?? "";
+        return parseSessionMeta(JSON.parse(firstLine));
+      } finally {
+        fs36.closeSync(fd);
+      }
+    } catch {
+      return;
+    }
+  }
+}
+
 // src/integrations/harnesses/codex/index.ts
 class CodexHarness extends BaseHarness {
   id = "codex";
@@ -51774,7 +51938,9 @@ class CodexHarness extends BaseHarness {
   agentBuilder = codexBuilder;
   resultExtractor = codexResultExtractor;
   presenceEnv = ["CODEX_SANDBOX"];
+  sessionLogProvider = () => new CodexProvider;
   capabilities = caps({
+    sessionLogs: true,
     agentDispatch: true,
     detection: true
   });
@@ -52095,7 +52261,7 @@ function opencodeInferenceConfig(inference, modelWork) {
 }
 
 // src/integrations/harnesses/opencode/model-work-agent.ts
-import path43 from "node:path";
+import path44 from "node:path";
 var MODEL_WORK_OPENCODE_AGENT = "akm-model-work";
 var MODEL_WORK_PROMPT = "You do one bounded task for akm. Use tools only to check what the task needs, never repeat a tool call, and reply with exactly what the task asks for.";
 function modelWorkPermission(stash) {
@@ -52132,7 +52298,7 @@ function modelWorkPluginEnv() {
     AKM_AUTO_LEARNING: "0",
     AKM_AUTO_SKILL_PROPOSALS: "0",
     AKM_WRITE_GATE: "off",
-    XDG_STATE_HOME: path43.join(getStateDir(), "opencode-model-work"),
+    XDG_STATE_HOME: path44.join(getStateDir(), "opencode-model-work"),
     ...process.platform === "win32" ? {} : { AKM_OPENCODE_CLI: "/bin/true" }
   };
 }
@@ -52215,15 +52381,15 @@ var opencodeBuilder = {
 };
 
 // src/integrations/harnesses/opencode/session-log.ts
-import fs37 from "node:fs";
-import os6 from "node:os";
-import path45 from "node:path";
+import fs38 from "node:fs";
+import os7 from "node:os";
+import path46 from "node:path";
 
 // src/storage/sqlite-read-snapshot.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import fs36 from "node:fs";
-import os5 from "node:os";
-import path44 from "node:path";
+import fs37 from "node:fs";
+import os6 from "node:os";
+import path45 from "node:path";
 var SNAPSHOT_MAX_ATTEMPTS = 8;
 var SNAPSHOT_BACKOFF_MS = 25;
 
@@ -52235,7 +52401,7 @@ class SqliteReadSnapshotUnavailableError extends Error {
 }
 function pathExists(filePath) {
   try {
-    fs36.lstatSync(filePath);
+    fs37.lstatSync(filePath);
     return true;
   } catch (error2) {
     if (error2.code === "ENOENT")
@@ -52245,7 +52411,7 @@ function pathExists(filePath) {
 }
 function fileFingerprint(filePath) {
   try {
-    const stat = fs36.statSync(filePath, { bigint: true });
+    const stat = fs37.statSync(filePath, { bigint: true });
     return { size: stat.size, mtimeNs: stat.mtimeNs, ctimeNs: stat.ctimeNs };
   } catch (error2) {
     if (error2.code === "ENOENT")
@@ -52267,7 +52433,7 @@ function fingerprintsEqual(left, right) {
 }
 function copyFileOutsideThisProcess(source, destination) {
   if (process.platform === "win32") {
-    fs36.copyFileSync(source, destination);
+    fs37.copyFileSync(source, destination);
     return;
   }
   const result = spawnSync5("cp", ["--", source, destination], {
@@ -52288,8 +52454,8 @@ function copyFileOutsideThisProcess(source, destination) {
 function openSqliteReadSnapshot(dbPath) {
   if (!pathExists(dbPath))
     return;
-  const snapshotDir = fs36.mkdtempSync(path44.join(os5.tmpdir(), "akm-sqlite-read-"));
-  const snapshotPath = path44.join(snapshotDir, "snapshot.db");
+  const snapshotDir = fs37.mkdtempSync(path45.join(os6.tmpdir(), "akm-sqlite-read-"));
+  const snapshotPath = path45.join(snapshotDir, "snapshot.db");
   let db;
   try {
     let copied = false;
@@ -52304,7 +52470,7 @@ function openSqliteReadSnapshot(dbPath) {
         if (before.wal)
           copyFileOutsideThisProcess(`${dbPath}-wal`, `${snapshotPath}-wal`);
         else
-          fs36.rmSync(`${snapshotPath}-wal`, { force: true });
+          fs37.rmSync(`${snapshotPath}-wal`, { force: true });
         const after = databaseFingerprint(dbPath);
         if (fingerprintsEqual(before, after) && !pathExists(`${dbPath}-journal`)) {
           copied = true;
@@ -52332,14 +52498,14 @@ function openSqliteReadSnapshot(dbPath) {
           closeSnapshot();
         } catch {}
         try {
-          fs36.rmSync(snapshotDir, { recursive: true, force: true });
+          fs37.rmSync(snapshotDir, { recursive: true, force: true });
         } catch {}
         return;
       }
       try {
         closeSnapshot();
       } finally {
-        fs36.rmSync(snapshotDir, { recursive: true, force: true });
+        fs37.rmSync(snapshotDir, { recursive: true, force: true });
       }
     };
     const cleanupOnExit = () => cleanup(true);
@@ -52350,7 +52516,7 @@ function openSqliteReadSnapshot(dbPath) {
     try {
       db?.close();
     } finally {
-      fs36.rmSync(snapshotDir, { recursive: true, force: true });
+      fs37.rmSync(snapshotDir, { recursive: true, force: true });
     }
     throw error2;
   }
@@ -52359,9 +52525,9 @@ function openSqliteReadSnapshot(dbPath) {
 // src/integrations/harnesses/opencode/session-log.ts
 function getOpenCodeBaseDir() {
   if (process.platform === "darwin") {
-    return path45.join(os6.homedir(), "Library", "Application Support", "opencode");
+    return path46.join(os7.homedir(), "Library", "Application Support", "opencode");
   }
-  return path45.join(os6.homedir(), ".local", "share", "opencode");
+  return path46.join(os7.homedir(), ".local", "share", "opencode");
 }
 var OPENCODE_DB_FILENAME = "opencode.db";
 
@@ -52372,13 +52538,13 @@ class OpenCodeProvider extends AbstractSessionLogProvider {
     return this.#dbPath(this.#baseDir);
   }
   #dbPath(base) {
-    return path45.join(base, OPENCODE_DB_FILENAME);
+    return path46.join(base, OPENCODE_DB_FILENAME);
   }
   listSessions(input = {}) {
     const base = input.location ?? this.#baseDir;
     const sinceMs = input.sinceMs ?? 0;
     const dbPath = this.#dbPath(base);
-    if (!fs37.existsSync(dbPath))
+    if (!fs38.existsSync(dbPath))
       return [];
     return this.#listSessionsFromDb(dbPath, sinceMs, input.isolatedSnapshot ?? false);
   }
@@ -53287,8 +53453,8 @@ Commands:
 `;
 
 // scripts/akm-migrate/migrate/dead-residue.ts
-import fs38 from "node:fs";
-import path46 from "node:path";
+import fs39 from "node:fs";
+import path47 from "node:path";
 var DEAD_RESIDUE_PATHS = [
   { name: "proposals", reason: "superseded by the `proposals` table in $DATA/state.db (0.9.0)" },
   { prefix: "runs.archived-", reason: "orphaned archive of a directory that no longer exists" },
@@ -53305,43 +53471,43 @@ function dirSizeBytes(target) {
   let total = 0;
   let entries;
   try {
-    entries = fs38.readdirSync(target, { withFileTypes: true });
+    entries = fs39.readdirSync(target, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const entryPath = path46.join(target, entry.name);
+    const entryPath = path47.join(target, entry.name);
     if (entry.isDirectory()) {
       total += dirSizeBytes(entryPath);
     } else if (entry.isFile()) {
       try {
-        total += fs38.statSync(entryPath).size;
+        total += fs39.statSync(entryPath).size;
       } catch {}
     }
   }
   return total;
 }
 function sizeOf(target) {
-  const st = fs38.statSync(target);
+  const st = fs39.statSync(target);
   return st.isDirectory() ? dirSizeBytes(target) : st.size;
 }
 function hostResidue() {
   const data = getDataDir();
   const state = getStateDir();
-  const configDir = path46.dirname(getConfigPath());
+  const configDir = path47.dirname(getConfigPath());
   const named = [
-    { absolutePath: path46.join(data, "txn"), reason: "filesystem transaction journals (removed in 0.9.17)" },
-    { absolutePath: path46.join(data, "txn-quarantine"), reason: "quarantined transaction journals (removed in 0.9.17)" },
-    { absolutePath: path46.join(data, "maintenance.barrier.lock"), reason: "maintenance barrier (removed in 0.9.17)" },
-    { absolutePath: path46.join(data, "maintenance-activities"), reason: "per-process activity registry (removed in 0.9.17)" },
-    { absolutePath: path46.join(state, "maintenance-activities"), reason: "per-process activity registry (removed in 0.9.17)" },
-    { absolutePath: path46.join(state, "version-reconcile.json"), reason: "startup reconcile stamp (removed in 0.9.17)" },
-    { absolutePath: path46.join(state, "locks", "version-reconcile.lock"), reason: "startup reconcile lock (removed in 0.9.17)" }
+    { absolutePath: path47.join(data, "txn"), reason: "filesystem transaction journals (removed in 0.9.17)" },
+    { absolutePath: path47.join(data, "txn-quarantine"), reason: "quarantined transaction journals (removed in 0.9.17)" },
+    { absolutePath: path47.join(data, "maintenance.barrier.lock"), reason: "maintenance barrier (removed in 0.9.17)" },
+    { absolutePath: path47.join(data, "maintenance-activities"), reason: "per-process activity registry (removed in 0.9.17)" },
+    { absolutePath: path47.join(state, "maintenance-activities"), reason: "per-process activity registry (removed in 0.9.17)" },
+    { absolutePath: path47.join(state, "version-reconcile.json"), reason: "startup reconcile stamp (removed in 0.9.17)" },
+    { absolutePath: path47.join(state, "locks", "version-reconcile.lock"), reason: "startup reconcile lock (removed in 0.9.17)" }
   ];
   const found = [];
   const claimed = new Set;
   for (const entry of named) {
-    if (claimed.has(entry.absolutePath) || !fs38.existsSync(entry.absolutePath))
+    if (claimed.has(entry.absolutePath) || !fs39.existsSync(entry.absolutePath))
       continue;
     try {
       found.push({ ...entry, relativePath: entry.absolutePath, sizeBytes: sizeOf(entry.absolutePath) });
@@ -53365,13 +53531,13 @@ function hostResidue() {
 function findSidecars(root, depth, skip) {
   let entries;
   try {
-    entries = fs38.readdirSync(root, { withFileTypes: true });
+    entries = fs39.readdirSync(root, { withFileTypes: true });
   } catch {
     return [];
   }
   const found = [];
   for (const entry of entries) {
-    const entryPath = path46.join(root, entry.name);
+    const entryPath = path47.join(root, entry.name);
     if (entry.isFile() && entry.name.endsWith(".operations.sensitive"))
       found.push(entryPath);
     else if (entry.isDirectory() && depth > 0 && !skip.has(entryPath)) {
@@ -53384,10 +53550,10 @@ function findDeadResidueEntries(stashDir) {
   const host = hostResidue();
   if (stashDir === undefined)
     return host;
-  const akmDir = path46.join(stashDir, ".akm");
+  const akmDir = path47.join(stashDir, ".akm");
   let names;
   try {
-    names = fs38.readdirSync(akmDir);
+    names = fs39.readdirSync(akmDir);
   } catch {
     return [];
   }
@@ -53397,14 +53563,14 @@ function findDeadResidueEntries(stashDir) {
     for (const name of matches) {
       if (!names.includes(name))
         continue;
-      const absolutePath = path46.join(akmDir, name);
+      const absolutePath = path47.join(akmDir, name);
       let sizeBytes;
       try {
         sizeBytes = sizeOf(absolutePath);
       } catch {
         continue;
       }
-      found.push({ relativePath: path46.join(".akm", name), absolutePath, sizeBytes, reason: spec.reason });
+      found.push({ relativePath: path47.join(".akm", name), absolutePath, sizeBytes, reason: spec.reason });
     }
   }
   return found;
@@ -53413,7 +53579,7 @@ function removeDeadResidue(stashDir) {
   const entries = findDeadResidueEntries(stashDir);
   return entries.map((entry) => {
     try {
-      fs38.rmSync(entry.absolutePath, { recursive: true, force: true });
+      fs39.rmSync(entry.absolutePath, { recursive: true, force: true });
       return { relativePath: entry.relativePath, sizeBytes: entry.sizeBytes, removed: true };
     } catch (error2) {
       return {
@@ -53428,18 +53594,18 @@ function removeDeadResidue(stashDir) {
 
 // scripts/akm-migrate/task-migrate.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import fs40 from "node:fs";
-import os7 from "node:os";
-import path49 from "node:path";
+import fs41 from "node:fs";
+import os8 from "node:os";
+import path50 from "node:path";
 
 // scripts/akm-migrate/migrate/task-files.ts
 import crypto4 from "node:crypto";
-import fs39 from "node:fs";
-import path48 from "node:path";
+import fs40 from "node:fs";
+import path49 from "node:path";
 
 // src/tasks/source/task-to-v4.ts
 import crypto3 from "node:crypto";
-import path47 from "node:path";
+import path48 from "node:path";
 
 // src/tasks/task-id.ts
 var VALID_TASK_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
@@ -54248,7 +54414,7 @@ function addSharedNonPromptOverrides(data, akm) {
 }
 function promptSourceKind(raw) {
   const trimmed = raw.trim();
-  if (trimmed.startsWith("./") || trimmed.startsWith("../") || path47.isAbsolute(trimmed) || /^[A-Za-z]:[\\/]/.test(trimmed)) {
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || path48.isAbsolute(trimmed) || /^[A-Za-z]:[\\/]/.test(trimmed)) {
     return "file";
   }
   try {
@@ -54352,7 +54518,7 @@ function planV2DataToV4(input, data) {
     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(path47.basename(input.filePath, ".yml"));
+    validateTaskId(path48.basename(input.filePath, ".yml"));
   } catch (cause) {
     return blocked(input, "invalid-v2-task", causeMessage(cause));
   }
@@ -54497,7 +54663,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 && path48.resolve(previous.filePath) === path48.resolve(current.filePath)) {
       throw new Error(`duplicate task migration file path: ${current.filePath}`);
     }
   }
@@ -54509,18 +54675,18 @@ 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 = path49.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path49.isAbsolute(relative);
 }
 function realDirectory(filePath) {
-  const stat = fs39.lstatSync(filePath);
+  const stat = fs40.lstatSync(filePath);
   if (stat.isSymbolicLink() || !stat.isDirectory())
     throw migrationError(`${filePath} must be a real directory.`);
-  return fs39.realpathSync(filePath);
+  return fs40.realpathSync(filePath);
 }
 function isWritable(filePath) {
   try {
-    fs39.accessSync(filePath, fs39.constants.W_OK);
+    fs40.accessSync(filePath, fs40.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -54533,12 +54699,12 @@ function walkTasks(root, tasksDir, out) {
     throw migrationError(`${root.root} resolves outside bundle ${root.bundleId}.`);
   }
   const visit2 = (directory) => {
-    const physicalDirectory = fs39.realpathSync(directory);
+    const physicalDirectory = fs40.realpathSync(directory);
     if (!contained2(physicalRoot, physicalDirectory)) {
       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);
+    for (const entry of fs40.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const candidate = path49.join(directory, entry.name);
       if (entry.isSymbolicLink())
         throw migrationError(`task migration does not follow symbolic link ${candidate}.`);
       if (entry.isDirectory()) {
@@ -54547,11 +54713,11 @@ function walkTasks(root, tasksDir, out) {
       }
       if (!entry.isFile() || !entry.name.endsWith(".yml"))
         continue;
-      const stat = fs39.lstatSync(candidate);
+      const stat = fs40.lstatSync(candidate);
       const mode = stat.mode & 511;
       out.push({
         filePath: candidate,
-        bytes: fs39.readFileSync(candidate),
+        bytes: fs40.readFileSync(candidate),
         mode,
         writable: root.writable,
         onDiskWritable: isWritable(candidate) && isWritable(directory) && (mode & 146) !== 0,
@@ -54564,9 +54730,9 @@ 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 : path49.join(root.root, "tasks");
     try {
-      const stat = fs39.lstatSync(tasksDir);
+      const stat = fs40.lstatSync(tasksDir);
       if (stat.isSymbolicLink())
         throw migrationError(`task migration does not follow symbolic link ${tasksDir}.`);
       if (!stat.isDirectory())
@@ -54584,18 +54750,18 @@ function planTaskFilesMigration(inputs) {
   return taskToV4PlanFromOutcomes(inputs.map(planTaskToV4File));
 }
 function taskFileBackupPath(backupRoot, filePath) {
-  const digest = crypto4.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(path49.resolve(filePath)).digest("hex").slice(0, 16);
+  return path49.join(backupRoot, "files", `${digest}-${path49.basename(filePath)}`);
 }
 function fsyncDirectory(directory) {
   if (process.platform === "win32")
     return;
   try {
-    const fd = fs39.openSync(directory, "r");
+    const fd = fs40.openSync(directory, "r");
     try {
-      fs39.fsyncSync(fd);
+      fs40.fsyncSync(fd);
     } finally {
-      fs39.closeSync(fd);
+      fs40.closeSync(fd);
     }
   } catch (cause) {
     const code = cause.code;
@@ -54604,25 +54770,25 @@ function fsyncDirectory(directory) {
   }
 }
 function writeDurable(filePath, bytes, mode, exclusive = false) {
-  fs39.mkdirSync(path48.dirname(filePath), { recursive: true });
-  const fd = fs39.openSync(filePath, exclusive ? "wx" : "w", mode);
+  fs40.mkdirSync(path49.dirname(filePath), { recursive: true });
+  const fd = fs40.openSync(filePath, exclusive ? "wx" : "w", mode);
   try {
-    fs39.writeFileSync(fd, bytes);
-    fs39.fsyncSync(fd);
+    fs40.writeFileSync(fd, bytes);
+    fs40.fsyncSync(fd);
   } finally {
-    fs39.closeSync(fd);
+    fs40.closeSync(fd);
   }
-  fs39.chmodSync(filePath, mode);
-  fsyncDirectory(path48.dirname(filePath));
+  fs40.chmodSync(filePath, mode);
+  fsyncDirectory(path49.dirname(filePath));
 }
 function replaceAtomically(filePath, bytes, mode) {
-  const temporary = path48.join(path48.dirname(filePath), `.${path48.basename(filePath)}.migrate-${crypto4.randomUUID()}`);
+  const temporary = path49.join(path49.dirname(filePath), `.${path49.basename(filePath)}.migrate-${crypto4.randomUUID()}`);
   try {
     writeDurable(temporary, bytes, mode, true);
-    fs39.renameSync(temporary, filePath);
-    fsyncDirectory(path48.dirname(filePath));
+    fs40.renameSync(temporary, filePath);
+    fsyncDirectory(path49.dirname(filePath));
   } finally {
-    fs39.rmSync(temporary, { force: true });
+    fs40.rmSync(temporary, { force: true });
   }
 }
 function applyTaskFilesPlan(plan, options) {
@@ -54645,7 +54811,7 @@ function applyTaskFilesPlan(plan, options) {
     }
   } catch (cause) {
     for (const change of [...replaced].reverse()) {
-      replaceAtomically(change.filePath, fs39.readFileSync(taskFileBackupPath(options.backupRoot, change.filePath)), change.mode);
+      replaceAtomically(change.filePath, fs40.readFileSync(taskFileBackupPath(options.backupRoot, change.filePath)), change.mode);
     }
     throw cause;
   }
@@ -54655,14 +54821,14 @@ function applyTaskFilesPlan(plan, options) {
 // scripts/akm-migrate/task-migrate.ts
 function expandTilde(value) {
   if (value === "~")
-    return os7.homedir();
+    return os8.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\"))
-    return path49.join(os7.homedir(), value.slice(2));
+    return path50.join(os8.homedir(), value.slice(2));
   return value;
 }
 function existingDirectory(target) {
   try {
-    return fs40.statSync(target).isDirectory();
+    return fs41.statSync(target).isDirectory();
   } catch (cause) {
     if (cause.code === "ENOENT")
       return false;
@@ -54683,14 +54849,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 ? path50.resolve(resolutionBase, expandTilde(source.path)) : lockContentRootFor(bundleId, source.type);
     if (!configuredRoot || !existingDirectory(configuredRoot))
       continue;
-    const bundleRoot = path49.resolve(configuredRoot);
+    const bundleRoot = path50.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 = path50.resolve(bundleRoot, component?.root ?? ".");
+    const relative = path50.relative(bundleRoot, componentRoot);
+    if (relative === ".." || relative.startsWith(`..${path50.sep}`) || path50.isAbsolute(relative)) {
       throw new ConfigError(`Task migration component root ${componentRoot} escapes bundle ${bundleId} at ${bundleRoot}.`, "INVALID_CONFIG_FILE");
     }
     if (!existingDirectory(componentRoot))
@@ -54707,7 +54873,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 = path50.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);
@@ -54720,7 +54886,7 @@ function taskRoots(config, resolutionBase = process.cwd()) {
 function taskRoot(bundleId, bundleRoot, componentRoot, configuredAdapter, writable) {
   const adapter = configuredAdapter ?? detectAdapterId(componentRoot, "");
   if (!configuredAdapter && adapter === "") {
-    const flatTasks = fs40.readdirSync(componentRoot, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".yml")).map((entry) => entry.name).sort();
+    const flatTasks = fs41.readdirSync(componentRoot, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".yml")).map((entry) => entry.name).sort();
     if (flatTasks.length > 0) {
       throw new ConfigError(`Task migration cannot classify top-level task file(s) ${flatTasks.join(", ")} in bundle ${bundleId}; configure adapter "akm-task" or move them under tasks/.`, "INVALID_CONFIG_FILE");
     }
@@ -54776,7 +54942,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 = path50.join(getDataDir(), "backups", "tasks", `${Date.now()}-${randomUUID3()}`);
     const applied = applyTaskFilesPlan(before.plan, { backupRoot: backupPath });
     return { ...inspectCurrent().result, backupPath, applied: applied.changed.length };
   });