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

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

@@ -29036,6 +29036,7 @@ var PASSTHROUGH_COMMANDS = [
   "extract",
   "health",
   "improve",
+  "improve-judge",
   "improve-report",
   "import",
   "index",
@@ -35454,25 +35455,21 @@ var coerce = {
 };
 var NEVER = INVALID;
 // src/integrations/harnesses/ids.ts
-var OPENCODE_INFERENCE = ["temperature", "maxTokens", "contextLength", "enableThinking", "reasoningEffort"];
 var HARNESS_ID_TABLE = [
-  { id: "opencode", agentDispatch: true, enforcesModelWorkTools: true, inference: OPENCODE_INFERENCE },
-  { id: "claude", agentDispatch: true, enforcesModelWorkTools: true, inference: ["reasoningEffort"] },
-  { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true, inference: OPENCODE_INFERENCE },
-  { id: "codex", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-  { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-  { id: "pi", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-  { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-  { id: "aider", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-  { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-  { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false, inference: [] }
+  { id: "opencode", agentDispatch: true, enforcesModelWorkTools: true },
+  { id: "claude", agentDispatch: true, enforcesModelWorkTools: true },
+  { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true },
+  { id: "codex", agentDispatch: true, enforcesModelWorkTools: false },
+  { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false },
+  { id: "pi", agentDispatch: true, enforcesModelWorkTools: false },
+  { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false },
+  { id: "aider", agentDispatch: true, enforcesModelWorkTools: false },
+  { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false },
+  { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false }
 ];
 var VALID_HARNESS_IDS = Object.freeze(HARNESS_ID_TABLE.map((h) => h.id));
 var HARNESS_AGENT_DISPATCH_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.agentDispatch).map((h) => h.id));
 var HARNESS_MODEL_WORK_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.enforcesModelWorkTools).map((h) => h.id));
-function harnessInferenceKeys(platform) {
-  return HARNESS_ID_TABLE.find((h) => h.id === platform)?.inference ?? [];
-}
 
 // src/core/extra-params.ts
 var EXTRA_PARAMS_PROTECTED_TOP_LEVEL_KEYS = [
@@ -35777,13 +35774,6 @@ var LlmEngineSchema = exports_external.object({
     });
   }
 });
-var AGENT_INFERENCE_KEYS = [
-  "temperature",
-  "maxTokens",
-  "contextLength",
-  "enableThinking",
-  "reasoningEffort"
-];
 var AgentEngineSchema = exports_external.object({
   kind: exports_external.literal("agent"),
   platform: AgentPlatformSchema.refine((platform) => HARNESS_AGENT_DISPATCH_IDS.has(platform), {
@@ -35794,27 +35784,25 @@ var AgentEngineSchema = exports_external.object({
   workspace: nonEmptyString.optional(),
   model: nonEmptyString.optional(),
   timeoutMs: timeoutMsField,
-  llmEngine: engineName.optional(),
-  temperature: exports_external.number().finite().optional(),
-  maxTokens: positiveInt.optional(),
-  contextLength: positiveInt.optional(),
-  enableThinking: exports_external.boolean().optional(),
-  reasoningEffort: nonEmptyString.optional()
+  llmEngine: engineName.optional()
 }).passthrough().superRefine((value, ctx) => {
-  for (const key of ["provider", "endpoint", "apiKey", "apiKeyFile", "concurrency", "extraParams", "modelAliases"]) {
+  for (const key of [
+    "provider",
+    "endpoint",
+    "apiKey",
+    "apiKeyFile",
+    "temperature",
+    "maxTokens",
+    "concurrency",
+    "extraParams",
+    "contextLength",
+    "enableThinking",
+    "reasoningEffort",
+    "modelAliases"
+  ]) {
     if (key in value)
       ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: [key], message: `${key} is not valid on an agent engine` });
   }
-  const translated = harnessInferenceKeys(value.platform);
-  for (const key of AGENT_INFERENCE_KEYS) {
-    if (key in value && !translated.includes(key)) {
-      ctx.addIssue({
-        code: exports_external.ZodIssueCode.custom,
-        path: [key],
-        message: `${key} is not valid on a ${value.platform} engine: ${translated.length > 0 ? `the platform translates only ${translated.join(", ")}` : "the platform translates no inference fields"}`
-      });
-    }
-  }
   if (value.platform !== "opencode-sdk" && value.llmEngine !== undefined) {
     ctx.addIssue({
       code: exports_external.ZodIssueCode.custom,
@@ -35878,6 +35866,11 @@ var clsField = exports_external.object({
 }).passthrough().optional();
 var fidelityCheckField = exports_external.object({ enabled: exports_external.boolean().optional() }).passthrough().optional();
 var lowValueFilterField = exports_external.object({ enabled: exports_external.boolean().optional() }).passthrough().optional();
+var defectFilterField = exports_external.object({
+  placeholders: exports_external.array(nonEmptyString).optional(),
+  metaCommentary: exports_external.array(nonEmptyString).optional(),
+  frontmatterKeys: exports_external.array(nonEmptyString).optional()
+}).passthrough().optional();
 var extractTriageGateField = exports_external.object({
   enabled: exports_external.boolean().optional(),
   minScore: exports_external.number().min(0).optional()
@@ -35900,7 +35893,8 @@ var REFLECT_PROCESS_FIELDS = {
   excludeRefPrefixes: excludeRefPrefixesField,
   limit: processLimitField,
   qualityGate: qualityGateField,
-  lowValueFilter: lowValueFilterField
+  lowValueFilter: lowValueFilterField,
+  defectFilter: defectFilterField
 };
 var DISTILL_PROCESS_FIELDS = {
   allowedTypes: allowedTypesField,
@@ -37622,6 +37616,10 @@ var ENV_PASSTHROUGH_REDACTION_POLICY = {
   OPENCODE_CONFIG: "path",
   CLAUDE_CONFIG: "path",
   CODEX_CONFIG: "path",
+  XDG_CONFIG_HOME: "path",
+  XDG_DATA_HOME: "path",
+  XDG_CACHE_HOME: "path",
+  XDG_STATE_HOME: "path",
   AWS_PROFILE: "identifier",
   AWS_REGION: "identifier",
   LLM_MODEL: "identifier",
@@ -39674,10 +39672,7 @@ import { createHash as createHash3 } from "node:crypto";
 
 // src/execution/source.ts
 var EXECUTION_SOURCE_SCHEMA_VERSION = 1;
-var MODEL_WORK_TOOLS = Object.freeze(["read", "edit", "akm search", "akm show"]);
-function isModelWorkTools(tools) {
-  return Array.isArray(tools) && tools.length === MODEL_WORK_TOOLS.length && tools.every((tool, index) => tool === MODEL_WORK_TOOLS[index]);
-}
+var MODEL_WORK_POLICY_ID = "model-work";
 function requireRecord(value, path18) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new TypeError(`${path18} must be an object`);
@@ -51045,8 +51040,9 @@ function extensionFields(request) {
   ];
 }
 function createAgentRequestLowerer(options) {
-  return (profile, request) => {
-    const supportedInference = new Set(typeof options.inference === "function" ? options.inference(profile, request) : options.inference ?? []);
+  const supportedInference = new Set(options.inference ?? []);
+  return (_profile, request) => {
+    const modelWork = request.authorization.policy?.id === MODEL_WORK_POLICY_ID;
     const notices = [];
     const skip = (field) => {
       notices.push(untranslated(options.adapter, field));
@@ -51087,18 +51083,18 @@ function createAgentRequestLowerer(options) {
     if (Object.hasOwn(request, "inference")) {
       dispatch.inference = request.inference ?? null;
       for (const key of Object.keys(request.inference ?? {}).sort()) {
-        if (!supportedInference.has(key))
+        if (!(modelWork && supportedInference.has(key)))
           skip(`inference.${key}`);
       }
     }
-    if (isModelWorkTools(request.tools)) {
-      if (!options.modelWorkTools) {
+    if (modelWork) {
+      if (!HARNESS_MODEL_WORK_IDS.has(options.adapter)) {
         throw new ConfigError(`The ${options.adapter} transport cannot enforce the model-work tool policy.`, "INVALID_CONFIG_FILE");
       }
       if (dispatch.agent) {
         throw new ConfigError(`The ${options.adapter} transport cannot run native agent ${JSON.stringify(dispatch.agent)} under the model-work tool policy.`, "INVALID_CONFIG_FILE");
       }
-      dispatch.tools = request.tools;
+      dispatch.modelWork = true;
     } else if (request.tools !== undefined) {
       if (hasToolSelection(request.tools) && !translatesTools(options.tools, request.tools)) {
         throw new ConfigError(`The ${options.adapter} transport cannot enforce the resolved tool policy.`, "INVALID_CONFIG_FILE");
@@ -51294,12 +51290,10 @@ var claudeBuilder = {
     adapter: "claude",
     personaChannel: "native",
     nativeAgentSelector: true,
-    tools: "all",
-    modelWorkTools: true,
-    inference: ["reasoningEffort"]
+    tools: "all"
   }),
   build(profile, req) {
-    const modelWork = isModelWorkTools(req.tools);
+    const modelWork = req.modelWork === true;
     const args = modelWork ? [...MODEL_WORK_CLAUDE_FLAGS] : [...profile.args];
     if (req.agent) {
       args.push("--agent", req.agent);
@@ -51315,10 +51309,7 @@ var claudeBuilder = {
       if (model)
         args.push("--model", model);
     }
-    const effort = req.inference?.reasoningEffort;
-    if (typeof effort === "string" && effort.length > 0)
-      args.push("--effort", effort);
-    if (req.tools && !modelWork) {
+    if (req.tools) {
       args.push("--allowedTools", normalizeTools(req.tools));
     }
     if (req.schema) {
@@ -51776,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";
@@ -51783,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
   });
@@ -52080,101 +52237,87 @@ class GeminiHarness extends BaseHarness {
 }
 
 // src/integrations/harnesses/opencode/model-config.ts
+var MODEL_WORK_AGENT_INFERENCE = ["temperature", "reasoningEffort", "enableThinking"];
 var isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
-function carriedInference(inference) {
-  const carried = {};
+function opencodeInferenceConfig(inference, modelWork) {
   const { temperature, reasoningEffort, enableThinking, maxTokens, contextLength } = inference ?? {};
+  const options = {};
   if (typeof temperature === "number" && Number.isFinite(temperature))
-    carried.temperature = temperature;
+    options.temperature = temperature;
   if (typeof reasoningEffort === "string" && reasoningEffort.length > 0)
-    carried.reasoningEffort = reasoningEffort;
-  if (typeof enableThinking === "boolean")
-    carried.enableThinking = enableThinking;
-  const limit = isPositiveInteger(maxTokens) && isPositiveInteger(contextLength);
-  if (limit)
-    carried.limit = { context: contextLength, output: maxTokens };
-  const keys = [
-    ["temperature", carried.temperature !== undefined, temperature],
-    ["reasoningEffort", carried.reasoningEffort !== undefined, reasoningEffort],
-    ["enableThinking", carried.enableThinking !== undefined, enableThinking],
-    ["maxTokens", limit, maxTokens],
-    ["contextLength", limit, contextLength]
-  ].filter(([, isCarried, value]) => isCarried || value === null).map(([key]) => key);
-  return { carried, keys };
-}
-function splitOpencodeModel(model) {
-  const slash = model.indexOf("/");
-  if (slash <= 0 || slash === model.length - 1)
-    return;
-  return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
-}
-function opencodeCarriedKeys(attachable, inference, modelWork) {
-  const { keys } = carriedInference(inference);
-  if (attachable)
-    return keys;
-  return modelWork ? keys.filter((key) => key !== "maxTokens" && key !== "contextLength") : [];
-}
-function opencodeInferenceConfig(inference, modelWork) {
-  const { carried } = carriedInference(inference);
-  const options = {};
-  if (carried.temperature !== undefined)
-    options.temperature = carried.temperature;
-  if (carried.reasoningEffort !== undefined)
-    options.reasoningEffort = carried.reasoningEffort;
-  if (carried.enableThinking !== undefined) {
-    options.chat_template_kwargs = { enable_thinking: carried.enableThinking };
-    options.enable_thinking = carried.enableThinking;
+    options.reasoningEffort = reasoningEffort;
+  if (typeof enableThinking === "boolean") {
+    options.chat_template_kwargs = { enable_thinking: enableThinking };
+    options.enable_thinking = enableThinking;
   }
   const hasOptions = Object.keys(options).length > 0;
   return {
     entry: {
       ...hasOptions && !modelWork ? { options } : {},
-      ...carried.limit ? { limit: { ...carried.limit } } : {}
+      ...isPositiveInteger(maxTokens) && isPositiveInteger(contextLength) ? { limit: { context: contextLength, output: maxTokens } } : {}
     },
     ...hasOptions && modelWork ? { agentOptions: options } : {}
   };
 }
-function opencodeModelConfig(model, entry) {
-  const target = model === undefined ? undefined : splitOpencodeModel(model);
-  if (!target || Object.keys(entry).length === 0)
-    return;
-  return { provider: { [target.providerID]: { models: { [target.modelID]: entry } } } };
-}
 
 // src/integrations/harnesses/opencode/model-work-agent.ts
+import path44 from "node:path";
 var MODEL_WORK_OPENCODE_AGENT = "akm-model-work";
-var MODEL_WORK_STEPS = 8;
 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.";
-var MODEL_WORK_PERMISSION = {
-  "*": "deny",
-  read: "allow",
-  edit: "allow",
-  external_directory: "deny",
-  bash: "deny",
-  doom_loop: "deny",
-  glob: "deny",
-  grep: "deny",
-  list: "deny",
-  lsp: "deny",
-  question: "deny",
-  skill: "deny",
-  task: "deny",
-  todowrite: "deny",
-  webfetch: "deny",
-  websearch: "deny"
-};
+function modelWorkPermission(stash) {
+  return {
+    "*": "deny",
+    read: "allow",
+    grep: "allow",
+    glob: "allow",
+    edit: { "*": "allow", ...stash ? { [`${stash.slice(1)}/*`]: "deny" } : {} },
+    external_directory: {
+      ...stash ? { [`${stash}/*`]: "allow" } : {},
+      "~/.local/share/opencode/tool-output/*": "deny"
+    },
+    akm_search: "allow",
+    akm_show: "allow",
+    akm_feedback: "deny",
+    akm_remember: "deny",
+    akm_curate: "deny",
+    bash: "deny",
+    doom_loop: "deny",
+    list: "deny",
+    lsp: "deny",
+    question: "deny",
+    skill: "deny",
+    task: "deny",
+    todowrite: "deny",
+    webfetch: "deny",
+    websearch: "deny"
+  };
+}
+function modelWorkPluginEnv() {
+  return {
+    AKM_AUTO_CURATE: "0",
+    AKM_AUTO_LEARNING: "0",
+    AKM_AUTO_SKILL_PROPOSALS: "0",
+    AKM_WRITE_GATE: "off",
+    XDG_STATE_HOME: path44.join(getStateDir(), "opencode-model-work"),
+    ...process.platform === "win32" ? {} : { AKM_OPENCODE_CLI: "/bin/true" }
+  };
+}
 function modelWorkOpencodeConfig(options) {
+  let stash;
+  try {
+    stash = resolveStashDir();
+  } catch {}
+  const permission = modelWorkPermission(stash);
   return {
-    permission: { ...MODEL_WORK_PERMISSION },
+    permission: { ...permission },
     compaction: { auto: false },
     agent: {
       [MODEL_WORK_OPENCODE_AGENT]: {
         mode: "primary",
         description: "akm unattended model work: read and edit inside its working directory only.",
         prompt: MODEL_WORK_PROMPT,
-        steps: MODEL_WORK_STEPS,
         ...options ? { options } : {},
-        permission: { ...MODEL_WORK_PERMISSION }
+        permission: { ...permission }
       }
     }
   };
@@ -52189,18 +52332,12 @@ var opencodeBuilder = {
     personaChannel: "prompt",
     nativeAgentSelector: true,
     tools: "none",
-    modelWorkTools: true,
-    inference: (profile, request) => {
-      const model = request.model?.resolved ?? modelFromArgs(profile.args);
-      return opencodeCarriedKeys(model !== undefined && splitOpencodeModel(model) !== undefined, request.inference, isModelWorkTools(request.tools));
-    }
+    inference: MODEL_WORK_AGENT_INFERENCE
   }),
   build(profile, req) {
-    const model = req.model ?? modelFromArgs(profile.args);
-    const modelWork = isModelWorkTools(req.tools);
-    const { entry, agentOptions } = opencodeInferenceConfig(req.inference, modelWork);
-    const modelConfig = opencodeModelConfig(model, entry);
-    if (modelWork) {
+    if (req.modelWork) {
+      const model = req.model ?? modelFromArgs(profile.args);
+      const { agentOptions } = opencodeInferenceConfig(req.inference, true);
       return {
         argv: [
           profile.bin,
@@ -52211,7 +52348,10 @@ var opencodeBuilder = {
           "--",
           req.prompt
         ],
-        env: { OPENCODE_CONFIG_CONTENT: JSON.stringify({ ...modelWorkOpencodeConfig(agentOptions), ...modelConfig }) }
+        env: {
+          ...modelWorkPluginEnv(),
+          OPENCODE_CONFIG_CONTENT: JSON.stringify(modelWorkOpencodeConfig(agentOptions))
+        }
       };
     }
     const args = req.model ? [] : [...profile.args];
@@ -52236,23 +52376,20 @@ var opencodeBuilder = {
     }
     args.push("--");
     args.push(req.prompt);
-    return {
-      argv: [profile.bin, ...args],
-      ...modelConfig ? { env: { OPENCODE_CONFIG_CONTENT: JSON.stringify(modelConfig) } } : {}
-    };
+    return { argv: [profile.bin, ...args] };
   }
 };
 
 // src/integrations/harnesses/opencode/session-log.ts
-import fs37 from "node:fs";
-import os6 from "node:os";
-import path44 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 path43 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;
 
@@ -52264,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")
@@ -52274,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")
@@ -52296,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], {
@@ -52317,8 +52454,8 @@ function copyFileOutsideThisProcess(source, destination) {
 function openSqliteReadSnapshot(dbPath) {
   if (!pathExists(dbPath))
     return;
-  const snapshotDir = fs36.mkdtempSync(path43.join(os5.tmpdir(), "akm-sqlite-read-"));
-  const snapshotPath = path43.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;
@@ -52333,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;
@@ -52361,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);
@@ -52379,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;
   }
@@ -52388,9 +52525,9 @@ function openSqliteReadSnapshot(dbPath) {
 // src/integrations/harnesses/opencode/session-log.ts
 function getOpenCodeBaseDir() {
   if (process.platform === "darwin") {
-    return path44.join(os6.homedir(), "Library", "Application Support", "opencode");
+    return path46.join(os7.homedir(), "Library", "Application Support", "opencode");
   }
-  return path44.join(os6.homedir(), ".local", "share", "opencode");
+  return path46.join(os7.homedir(), ".local", "share", "opencode");
 }
 var OPENCODE_DB_FILENAME = "opencode.db";
 
@@ -52401,13 +52538,13 @@ class OpenCodeProvider extends AbstractSessionLogProvider {
     return this.#dbPath(this.#baseDir);
   }
   #dbPath(base) {
-    return path44.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);
   }
@@ -52539,8 +52676,7 @@ class OpencodeSdkHarness extends BaseHarness {
       personaChannel: "native",
       nativeAgentSelector: true,
       tools: "sdk",
-      modelWorkTools: true,
-      inference: (_profile, request) => opencodeCarriedKeys(Boolean(request.model?.resolved), request.inference, isModelWorkTools(request.tools))
+      inference: MODEL_WORK_AGENT_INFERENCE
     })
   };
   capabilities = caps({
@@ -52817,11 +52953,6 @@ var VALID_HARNESS_IDS2 = Object.freeze(HARNESS_REGISTRY.map((h) => h.id));
 var SESSION_LOG_HARNESSES = HARNESS_REGISTRY.filter(isSessionLogHarness);
 var AGENT_DISPATCH_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.agentDispatch);
 
-// src/integrations/agent/model-map.ts
-var ENGINE_KEY_PATTERN = new RegExp(ENGINE_NAME_PATTERN_SOURCE);
-var RESERVED_MAP_KEYS = new Set(["__proto__", "constructor", "prototype", "tostring"]);
-var PROFILE_FIELD_KEYS = new Set(["model", "inference", "engine"]);
-
 // src/core/spawn-env.ts
 var COMMON_SPAWN_ENV_PASSTHROUGH = [
   "HOME",
@@ -52833,6 +52964,12 @@ var COMMON_SPAWN_ENV_PASSTHROUGH = [
   "TMPDIR",
   "AKM_EVENT_SOURCE"
 ];
+var XDG_BASE_DIR_ENV_PASSTHROUGH = [
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_CACHE_HOME",
+  "XDG_STATE_HOME"
+];
 var supplementedPaths = new Map;
 
 // src/integrations/agent/profiles.ts
@@ -52843,7 +52980,7 @@ var BUILTINS = {
     bin: "opencode",
     args: ["run"],
     stdio: "interactive",
-    envPassthrough: [...COMMON_PASSTHROUGH, "OPENCODE_API_KEY", "OPENCODE_CONFIG"],
+    envPassthrough: [...COMMON_PASSTHROUGH, "OPENCODE_API_KEY", "OPENCODE_CONFIG", ...XDG_BASE_DIR_ENV_PASSTHROUGH],
     parseOutput: "text"
   },
   claude: {
@@ -52923,6 +53060,11 @@ var FALLBACK_ANNOUNCEMENT = `No engine is configured; falling back to \`${FALLBA
 var NO_ENGINE_MESSAGE_SUFFIX = `has no selected engine, and no usable \`${OPENCODE_SDK_SERVER_BIN}\` binary was found to fall back to.`;
 var NO_ENGINE_REMEDY = "Run `akm setup` to detect an installed agent, or set one explicitly: " + '`akm config set engines.claude \'{"kind":"agent","platform":"claude"}\'` ' + "then `akm config set defaults.engine claude`. " + `Installing the \`${OPENCODE_SDK_SERVER_BIN}\` binary also works ` + "(`npm i -g opencode-ai`) — akm falls back to it automatically.";
 
+// src/integrations/agent/model-map.ts
+var ENGINE_KEY_PATTERN = new RegExp(ENGINE_NAME_PATTERN_SOURCE);
+var RESERVED_MAP_KEYS = new Set(["__proto__", "constructor", "prototype", "tostring"]);
+var PROFILE_FIELD_KEYS = new Set(["model", "inference", "engine"]);
+
 // src/storage/repositories/improve-ledger-repository.ts
 var LEDGER_REJECTION_WINDOW_DAYS = Object.freeze({
   reflect: 14,
@@ -53311,8 +53453,8 @@ Commands:
 `;
 
 // scripts/akm-migrate/migrate/dead-residue.ts
-import fs38 from "node:fs";
-import path45 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" },
@@ -53329,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 = path45.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 = path45.dirname(getConfigPath());
+  const configDir = path47.dirname(getConfigPath());
   const named = [
-    { absolutePath: path45.join(data, "txn"), reason: "filesystem transaction journals (removed in 0.9.17)" },
-    { absolutePath: path45.join(data, "txn-quarantine"), reason: "quarantined transaction journals (removed in 0.9.17)" },
-    { absolutePath: path45.join(data, "maintenance.barrier.lock"), reason: "maintenance barrier (removed in 0.9.17)" },
-    { absolutePath: path45.join(data, "maintenance-activities"), reason: "per-process activity registry (removed in 0.9.17)" },
-    { absolutePath: path45.join(state, "maintenance-activities"), reason: "per-process activity registry (removed in 0.9.17)" },
-    { absolutePath: path45.join(state, "version-reconcile.json"), reason: "startup reconcile stamp (removed in 0.9.17)" },
-    { absolutePath: path45.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) });
@@ -53389,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 = path45.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)) {
@@ -53408,10 +53550,10 @@ function findDeadResidueEntries(stashDir) {
   const host = hostResidue();
   if (stashDir === undefined)
     return host;
-  const akmDir = path45.join(stashDir, ".akm");
+  const akmDir = path47.join(stashDir, ".akm");
   let names;
   try {
-    names = fs38.readdirSync(akmDir);
+    names = fs39.readdirSync(akmDir);
   } catch {
     return [];
   }
@@ -53421,14 +53563,14 @@ function findDeadResidueEntries(stashDir) {
     for (const name of matches) {
       if (!names.includes(name))
         continue;
-      const absolutePath = path45.join(akmDir, name);
+      const absolutePath = path47.join(akmDir, name);
       let sizeBytes;
       try {
         sizeBytes = sizeOf(absolutePath);
       } catch {
         continue;
       }
-      found.push({ relativePath: path45.join(".akm", name), absolutePath, sizeBytes, reason: spec.reason });
+      found.push({ relativePath: path47.join(".akm", name), absolutePath, sizeBytes, reason: spec.reason });
     }
   }
   return found;
@@ -53437,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 {
@@ -53452,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 path48 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 path47 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 path46 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._-]*$/;
@@ -54272,7 +54414,7 @@ function addSharedNonPromptOverrides(data, akm) {
 }
 function promptSourceKind(raw) {
   const trimmed = raw.trim();
-  if (trimmed.startsWith("./") || trimmed.startsWith("../") || path46.isAbsolute(trimmed) || /^[A-Za-z]:[\\/]/.test(trimmed)) {
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || path48.isAbsolute(trimmed) || /^[A-Za-z]:[\\/]/.test(trimmed)) {
     return "file";
   }
   try {
@@ -54376,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(path46.basename(input.filePath, ".yml"));
+    validateTaskId(path48.basename(input.filePath, ".yml"));
   } catch (cause) {
     return blocked(input, "invalid-v2-task", causeMessage(cause));
   }
@@ -54521,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 && path46.resolve(previous.filePath) === path46.resolve(current.filePath)) {
+    if (previous && current && path48.resolve(previous.filePath) === path48.resolve(current.filePath)) {
       throw new Error(`duplicate task migration file path: ${current.filePath}`);
     }
   }
@@ -54533,18 +54675,18 @@ function migrationError(detail) {
   return new ConfigError(`Task migration failed: ${detail}`, "INVALID_CONFIG_FILE");
 }
 function contained2(root, candidate) {
-  const relative = path47.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path47.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;
@@ -54557,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 = path47.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()) {
@@ -54571,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,
@@ -54588,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 : path47.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())
@@ -54608,18 +54750,18 @@ function planTaskFilesMigration(inputs) {
   return taskToV4PlanFromOutcomes(inputs.map(planTaskToV4File));
 }
 function taskFileBackupPath(backupRoot, filePath) {
-  const digest = crypto4.createHash("sha256").update(path47.resolve(filePath)).digest("hex").slice(0, 16);
-  return path47.join(backupRoot, "files", `${digest}-${path47.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;
@@ -54628,25 +54770,25 @@ function fsyncDirectory(directory) {
   }
 }
 function writeDurable(filePath, bytes, mode, exclusive = false) {
-  fs39.mkdirSync(path47.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(path47.dirname(filePath));
+  fs40.chmodSync(filePath, mode);
+  fsyncDirectory(path49.dirname(filePath));
 }
 function replaceAtomically(filePath, bytes, mode) {
-  const temporary = path47.join(path47.dirname(filePath), `.${path47.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(path47.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) {
@@ -54669,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;
   }
@@ -54679,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 path48.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;
@@ -54707,14 +54849,14 @@ function taskRoots(config, resolutionBase = process.cwd()) {
     const source = sources.get(bundleId);
     if (!source)
       continue;
-    const configuredRoot = source.type === "filesystem" && source.path ? path48.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 = path48.resolve(configuredRoot);
+    const bundleRoot = path50.resolve(configuredRoot);
     const component = bundleComponentConfig(bundle);
-    const componentRoot = path48.resolve(bundleRoot, component?.root ?? ".");
-    const relative = path48.relative(bundleRoot, componentRoot);
-    if (relative === ".." || relative.startsWith(`..${path48.sep}`) || path48.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))
@@ -54731,7 +54873,7 @@ function taskRoots(config, resolutionBase = process.cwd()) {
   }
   const envStash = process.env.AKM_BUNDLE_DIR?.trim();
   if (envStash && existingDirectory(envStash)) {
-    const stashRoot = path48.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);
@@ -54744,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");
     }
@@ -54800,7 +54942,7 @@ function applyTaskFilesMigration() {
     const before = inspectCurrent();
     if (before.result.taskFiles.changed === 0)
       return before.result;
-    const backupPath = path48.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 };
   });