@adhdev/daemon-core 0.9.76-rc.11 → 0.9.76-rc.13

package/dist/cli-adapters/provider-cli-adapter.d.ts

@@ -21,6 +21,7 @@ export { normalizeCliProviderForRuntime, type CliApprovalInput, type CliChatMess
 export declare function appendBoundedText(current: string, chunk: string, maxChars: number): string;
 export declare class ProviderCliAdapter implements CliAdapter {
     private extraArgs;
+    private extraEnv;
     readonly cliType: string;
     readonly cliName: string;
     workingDir: string;
@@ -126,7 +127,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private readonly submitStrategy;
     private readonly requirePromptEchoBeforeSubmit;
     private static readonly SCRIPT_STATUS_DEBOUNCE_MS;
-    constructor(provider: CliProviderModule, workingDir: string, extraArgs?: string[], transportFactory?: PtyTransportFactory);
+    constructor(provider: CliProviderModule, workingDir: string, extraArgs?: string[], extraEnv?: Record<string, string>, transportFactory?: PtyTransportFactory);
     /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
     setCliScripts(scripts: CliScripts): void;
     /** Refresh provider scripts/config used by this adapter without restarting the PTY runtime. */

package/dist/cli-adapters/provider-cli-runtime.d.ts

@@ -15,6 +15,7 @@ export declare function resolveCliSpawnPlan(options: {
     runtimeSettings: Record<string, any>;
     workingDir: string;
     extraArgs: string[];
+    extraEnv?: Record<string, string>;
 }): CliSpawnPlan;
 export declare function buildCliLoginShellRetry(plan: Pick<CliSpawnPlan, 'binaryPath' | 'allArgs'>): {
     shellCmd: string;

package/dist/commands/cli-manager.d.ts

@@ -58,6 +58,11 @@ type CliSessionBinding = {
     providerSessionId?: string;
     launchMode: CliLaunchMode;
 };
+type CliStartOptions = {
+    resumeSessionId?: string;
+    settingsOverride?: Record<string, any>;
+    extraEnv?: Record<string, string>;
+};
 export declare function supportsExplicitSessionResume(resume?: ProviderResumeCapability): boolean;
 export declare function resolveCliSessionBinding(provider: ProviderModule | undefined, normalizedType: string, cliArgs?: string[], requestedResumeSessionId?: string): CliSessionBinding;
 export declare class DaemonCliManager {
@@ -73,10 +78,7 @@ export declare class DaemonCliManager {
     private createAdapter;
     private startCliExitMonitor;
     private registerCliInstance;
-    startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string, options?: {
-        resumeSessionId?: string;
-        settingsOverride?: Record<string, any>;
-    }): Promise<{
+    startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string, options?: CliStartOptions): Promise<{
         runtimeSessionId: string;
         providerSessionId?: string;
     }>;

package/dist/index.js

@@ -1630,7 +1630,7 @@ var init_provider_cli_config = __esm({
 
 // src/cli-adapters/provider-cli-runtime.ts
 function resolveCliSpawnPlan(options) {
-  const { provider, runtimeSettings, workingDir, extraArgs } = options;
+  const { provider, runtimeSettings, workingDir, extraArgs, extraEnv } = options;
   const { spawn: spawnConfig } = provider;
   const configuredCommand = typeof runtimeSettings.executablePath === "string" && runtimeSettings.executablePath.trim() ? runtimeSettings.executablePath.trim() : spawnConfig.command;
   const binaryPath = findBinary(configuredCommand);
@@ -1654,7 +1654,7 @@ function resolveCliSpawnPlan(options) {
     shellCmd = binaryPath;
     shellArgs = allArgs;
   }
-  const env = buildCliSpawnEnv(process.env, spawnConfig.env);
+  const env = buildCliSpawnEnv(process.env, { ...spawnConfig.env || {}, ...extraEnv || {} });
   env.TERMINAL_CWD = workingDir;
   return {
     binaryPath,
@@ -1757,8 +1757,9 @@ var init_provider_cli_adapter = __esm({
     init_provider_cli_runtime();
     init_provider_cli_shared();
     ProviderCliAdapter = class _ProviderCliAdapter {
-      constructor(provider, workingDir, extraArgs = [], transportFactory = new NodePtyTransportFactory()) {
+      constructor(provider, workingDir, extraArgs = [], extraEnv = {}, transportFactory = new NodePtyTransportFactory()) {
         this.extraArgs = extraArgs;
+        this.extraEnv = extraEnv;
         this.provider = provider;
         this.transportFactory = transportFactory;
         this.cliType = provider.type;
@@ -2074,7 +2075,8 @@ ${lastSnapshot}`;
           provider: this.provider,
           runtimeSettings: this.runtimeSettings,
           workingDir: this.workingDir,
-          extraArgs: this.extraArgs
+          extraArgs: this.extraArgs,
+          extraEnv: this.extraEnv
         });
         LOG.info("CLI", `[${this.cliType}] Spawning in ${this.workingDir}`);
         this.resetTraceSession();
@@ -5983,17 +5985,17 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os21 = (0, import_os2.platform)();
+  const os22 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
-    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os21] || []) || []);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os22] || []) || []);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os21 === "darwin") {
+    if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs4.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os21 === "win32") {
+    if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
       const appDir = dirname9(appPath);
       const candidates = [
@@ -6010,7 +6012,7 @@ async function detectIDEs(providerLoader) {
         }
       }
     }
-    const installed = os21 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+    const installed = os22 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
     results.push({
       id: def.id,
@@ -14943,7 +14945,7 @@ var CliProviderInstance = class {
     this.providerSessionId = options?.providerSessionId;
     this.launchMode = options?.launchMode || "new";
     this.onProviderSessionResolved = options?.onProviderSessionResolved;
-    this.adapter = new ProviderCliAdapter(provider, workingDir, cliArgs, transportFactory);
+    this.adapter = new ProviderCliAdapter(provider, workingDir, cliArgs, options?.extraEnv || {}, transportFactory);
     this.monitor = new StatusMonitor();
     this.historyWriter = new ChatHistoryWriter();
   }
@@ -17154,7 +17156,7 @@ var DaemonCliManager = class {
       attachExisting
     }) || void 0;
   }
-  createAdapter(cliType, workingDir, cliArgs, runtimeId, providerSessionId, attachExisting = false) {
+  createAdapter(cliType, workingDir, cliArgs, runtimeId, providerSessionId, attachExisting = false, extraEnv) {
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const provider = this.providerLoader.getMeta(normalizedType);
     if (provider && provider.category === "cli" && provider.patterns && provider.spawn) {
@@ -17168,7 +17170,7 @@ var DaemonCliManager = class {
         providerSessionId,
         attachExisting
       );
-      return new ProviderCliAdapter(resolvedProvider, workingDir, cliArgs, transportFactory);
+      return new ProviderCliAdapter(resolvedProvider, workingDir, cliArgs, extraEnv || {}, transportFactory);
     }
     throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
   }
@@ -17371,6 +17373,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         {
           providerSessionId: sessionBinding.providerSessionId,
           launchMode: sessionBinding.launchMode,
+          extraEnv: options?.extraEnv,
           onProviderSessionResolved: ({ providerSessionId, providerName, providerType, workspace }) => {
             this.persistRecentActivity({
               kind: "cli",
@@ -17391,7 +17394,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         resolvedCliArgs,
         key,
         sessionBinding.providerSessionId,
-        false
+        false,
+        options?.extraEnv
       );
       try {
         await adapter.spawn();
@@ -17620,7 +17624,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           dir,
           args?.cliArgs,
           args?.initialModel,
-          { resumeSessionId: args?.resumeSessionId, settingsOverride: args?.settings }
+          { resumeSessionId: args?.resumeSessionId, settingsOverride: args?.settings, extraEnv: args?.env }
         );
         return {
           success: true,
@@ -20159,11 +20163,14 @@ function getRecentCommands(count = 50) {
 cleanOldFiles();
 
 // src/commands/router.ts
+var yaml = __toESM(require("js-yaml"));
 init_logger();
 
 // src/commands/mesh-coordinator.ts
+var import_node_child_process3 = require("child_process");
 var import_node_fs3 = require("fs");
 var import_node_module2 = require("module");
+var os17 = __toESM(require("os"));
 var import_node_path = require("path");
 var DEFAULT_SERVER_NAME = "adhdev-mesh";
 var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
@@ -20197,13 +20204,13 @@ function resolveMeshCoordinatorSetup(options) {
     if (!mcpServer) {
       return {
         kind: "unsupported",
-        reason: "Could not resolve the ADHDev MCP server entrypoint without relying on a PATH bin shim"
+        reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
       };
     }
     return {
       kind: "auto_import",
       serverName,
-      configPath: (0, import_node_path.join)(workspace, path27),
+      configPath: resolveMcpConfigPath(path27, workspace),
       configFormat: mcpConfig.format,
       mcpServer
     };
@@ -20237,14 +20244,85 @@ function resolveMeshCoordinatorSetup(options) {
 function renderMeshCoordinatorTemplate(template, values) {
   return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_, key) => values[key] || "");
 }
+function resolveMcpConfigPath(configPath, workspace) {
+  const trimmed = configPath.trim();
+  if (trimmed === "~") return os17.homedir();
+  if (trimmed.startsWith("~/")) return (0, import_node_path.join)(os17.homedir(), trimmed.slice(2));
+  if ((0, import_node_path.isAbsolute)(trimmed)) return trimmed;
+  return (0, import_node_path.join)(workspace, trimmed);
+}
 function resolveAdhdevMcpServerLaunch(options) {
   const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
   if (!entryPath) return null;
+  const nodeExecutable = resolveMcpNodeExecutable(options.nodeExecutable);
+  if (!nodeExecutable) return null;
   return {
-    command: options.nodeExecutable?.trim() || process.execPath,
+    command: nodeExecutable,
     args: [entryPath, "--mode", "ipc", "--repo-mesh", options.meshId]
   };
 }
+function resolveMcpNodeExecutable(explicitExecutable) {
+  const explicit = explicitExecutable?.trim();
+  if (explicit) return explicit;
+  const candidates = [];
+  const addCandidate = (candidate) => {
+    const trimmed = candidate?.trim();
+    if (!trimmed) return;
+    const normalized = normalizeExistingPath(trimmed) || trimmed;
+    if (!candidates.includes(normalized)) candidates.push(normalized);
+  };
+  addCandidate(process.env.ADHDEV_MCP_NODE_EXECUTABLE);
+  addCandidate(process.env.ADHDEV_NODE_EXECUTABLE);
+  addCandidate(process.env.npm_node_execpath);
+  addNodeCandidatesFromPath(process.env.PATH, addCandidate);
+  addNodeCandidatesFromNvm(os17.homedir(), addCandidate);
+  addCandidate("/opt/homebrew/bin/node");
+  addCandidate("/usr/local/bin/node");
+  addCandidate("/usr/bin/node");
+  addCandidate(process.execPath);
+  for (const candidate of candidates) {
+    if (nodeRuntimeSupportsWebSocket(candidate)) return candidate;
+  }
+  return null;
+}
+function addNodeCandidatesFromPath(pathValue, addCandidate) {
+  for (const entry of (pathValue || "").split(":")) {
+    const dir = entry.trim();
+    if (!dir) continue;
+    addCandidate((0, import_node_path.join)(dir, "node"));
+  }
+}
+function addNodeCandidatesFromNvm(homeDir, addCandidate) {
+  const versionsDir = (0, import_node_path.join)(homeDir, ".nvm", "versions", "node");
+  try {
+    const versionDirs = (0, import_node_fs3.readdirSync)(versionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareNodeVersionNamesDescending);
+    for (const versionDir of versionDirs) {
+      addCandidate((0, import_node_path.join)(versionsDir, versionDir, "bin", "node"));
+    }
+  } catch {
+  }
+}
+function compareNodeVersionNamesDescending(a, b) {
+  const parse = (value) => value.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = parse(a);
+  const right = parse(b);
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const diff = (right[i] || 0) - (left[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return b.localeCompare(a);
+}
+function nodeRuntimeSupportsWebSocket(nodeExecutable) {
+  try {
+    (0, import_node_child_process3.execFileSync)(nodeExecutable, ["-e", "process.exit(typeof WebSocket === 'function' ? 0 : 42)"], {
+      stdio: "ignore",
+      timeout: 3e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function resolveAdhdevMcpEntryPath(explicitPath) {
   const explicit = explicitPath?.trim();
   if (explicit) return normalizeExistingPath(explicit) || explicit;
@@ -20288,7 +20366,7 @@ function normalizeExistingPath(filePath) {
 }
 
 // src/status/snapshot.ts
-var os17 = __toESM(require("os"));
+var os18 = __toESM(require("os"));
 init_config();
 init_terminal_screen();
 init_logger();
@@ -20344,8 +20422,8 @@ function buildAvailableProviders(providerLoader) {
 }
 function buildMachineInfo(profile = "full") {
   const base = {
-    hostname: os17.hostname(),
-    platform: os17.platform()
+    hostname: os18.hostname(),
+    platform: os18.platform()
   };
   if (profile === "live") {
     return base;
@@ -20354,23 +20432,23 @@ function buildMachineInfo(profile = "full") {
     const memSnap2 = getHostMemorySnapshot();
     return {
       ...base,
-      arch: os17.arch(),
-      cpus: os17.cpus().length,
+      arch: os18.arch(),
+      cpus: os18.cpus().length,
       totalMem: memSnap2.totalMem,
-      release: os17.release()
+      release: os18.release()
     };
   }
   const memSnap = getHostMemorySnapshot();
   return {
     ...base,
-    arch: os17.arch(),
-    cpus: os17.cpus().length,
+    arch: os18.arch(),
+    cpus: os18.cpus().length,
     totalMem: memSnap.totalMem,
     freeMem: memSnap.freeMem,
     availableMem: memSnap.availableMem,
-    loadavg: os17.loadavg(),
-    uptime: os17.uptime(),
-    release: os17.release()
+    loadavg: os18.loadavg(),
+    uptime: os18.uptime(),
+    release: os18.release()
   };
 }
 function parseMessageTime(value) {
@@ -20604,11 +20682,11 @@ function buildStatusSnapshot(options) {
 var import_child_process8 = require("child_process");
 var import_child_process9 = require("child_process");
 var fs9 = __toESM(require("fs"));
-var os18 = __toESM(require("os"));
+var os19 = __toESM(require("os"));
 var path21 = __toESM(require("path"));
 var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
 function getUpgradeLogPath() {
-  const home = os18.homedir();
+  const home = os19.homedir();
   const dir = path21.join(home, ".adhdev");
   fs9.mkdirSync(dir, { recursive: true });
   return path21.join(dir, "daemon-upgrade.log");
@@ -20800,7 +20878,7 @@ async function waitForPidExit(pid, timeoutMs) {
   }
 }
 function stopSessionHostProcesses(appName) {
-  const pidFile = path21.join(os18.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  const pidFile = path21.join(os19.homedir(), ".adhdev", `${appName}-session-host.pid`);
   try {
     if (fs9.existsSync(pidFile)) {
       const pid = Number.parseInt(fs9.readFileSync(pidFile, "utf8").trim(), 10);
@@ -20817,7 +20895,7 @@ function stopSessionHostProcesses(appName) {
   }
 }
 function removeDaemonPidFile() {
-  const pidFile = path21.join(os18.homedir(), ".adhdev", "daemon.pid");
+  const pidFile = path21.join(os19.homedir(), ".adhdev", "daemon.pid");
   try {
     fs9.unlinkSync(pidFile);
   } catch {
@@ -20955,6 +21033,22 @@ function normalizeReleaseChannel(value) {
 function resolveUpgradeChannel(args) {
   return normalizeReleaseChannel(args?.channel) || normalizeReleaseChannel(args?.updatePolicy?.channel) || normalizeReleaseChannel(args?.npmTag) || normalizeReleaseChannel(loadConfig().updateChannel) || "stable";
 }
+function loadYamlModule() {
+  return yaml;
+}
+function getMcpServersKey(format) {
+  return format === "hermes_config_yaml" ? "mcp_servers" : "mcpServers";
+}
+function parseMeshCoordinatorMcpConfig(text, format) {
+  if (!text.trim()) return {};
+  if (format === "claude_mcp_json") return JSON.parse(text);
+  const parsed = loadYamlModule().load(text);
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function serializeMeshCoordinatorMcpConfig(config, format) {
+  if (format === "claude_mcp_json") return JSON.stringify(config, null, 2);
+  return loadYamlModule().dump(config, { noRefs: true, lineWidth: 120 });
+}
 var CHAT_COMMANDS = [
   "send_chat",
   "new_chat",
@@ -21932,7 +22026,8 @@ var DaemonCommandRouter = class {
               meshCoordinatorSetup: coordinatorSetup
             };
           }
-          if (coordinatorSetup.configFormat !== "claude_mcp_json") {
+          const configFormat = coordinatorSetup.configFormat;
+          if (configFormat !== "claude_mcp_json" && configFormat !== "hermes_config_yaml") {
             return {
               success: false,
               code: "mesh_coordinator_unsupported",
@@ -21957,15 +22052,23 @@ var DaemonCommandRouter = class {
               workspace
             };
           }
-          const { existsSync: existsSync23, readFileSync: readFileSync15, writeFileSync: writeFileSync12, copyFileSync: copyFileSync3 } = await import("fs");
+          const { existsSync: existsSync23, readFileSync: readFileSync15, writeFileSync: writeFileSync12, copyFileSync: copyFileSync3, mkdirSync: mkdirSync14 } = await import("fs");
+          const { dirname: dirname9 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
+          mkdirSync14(dirname9(mcpConfigPath), { recursive: true });
           const hadExistingMcpConfig = existsSync23(mcpConfigPath);
           let existingMcpConfig = {};
           if (hadExistingMcpConfig) {
             try {
-              existingMcpConfig = JSON.parse(readFileSync15(mcpConfigPath, "utf-8"));
+              existingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync15(mcpConfigPath, "utf-8"), configFormat);
               copyFileSync3(mcpConfigPath, mcpConfigPath + ".backup");
-            } catch {
+            } catch (error) {
+              LOG.error("MeshCoordinator", `Failed to parse existing MCP config ${mcpConfigPath}: ${error?.message || error}`);
+              return {
+                success: false,
+                code: "mesh_coordinator_config_parse_failed",
+                error: `Failed to parse existing MCP config at ${mcpConfigPath}`
+              };
             }
           }
           const mcpServerEntry = {
@@ -21978,18 +22081,25 @@ var DaemonCommandRouter = class {
               ADHDEV_MCP_TRANSPORT: "ipc"
             };
           }
+          const mcpServersKey = getMcpServersKey(configFormat);
+          const existingServers = existingMcpConfig[mcpServersKey];
           const mcpConfig = {
             ...existingMcpConfig,
-            mcpServers: {
-              ...existingMcpConfig.mcpServers || {},
+            [mcpServersKey]: {
+              ...existingServers && typeof existingServers === "object" && !Array.isArray(existingServers) ? existingServers : {},
               [coordinatorSetup.serverName]: mcpServerEntry
             }
           };
-          writeFileSync12(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+          writeFileSync12(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
           LOG.info("MeshCoordinator", `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
           const cliArgs = [];
+          const launchEnv = {};
           if (systemPrompt) {
-            cliArgs.push("--append-system-prompt", systemPrompt);
+            if (configFormat === "hermes_config_yaml") {
+              launchEnv.HERMES_EPHEMERAL_SYSTEM_PROMPT = systemPrompt;
+            } else {
+              cliArgs.push("--append-system-prompt", systemPrompt);
+            }
           }
           if (cliType === "claude-cli") {
             cliArgs.push("--mcp-config", coordinatorSetup.configPath);
@@ -21998,6 +22108,7 @@ var DaemonCommandRouter = class {
             cliType,
             dir: workspace,
             cliArgs: cliArgs.length > 0 ? cliArgs : void 0,
+            env: Object.keys(launchEnv).length > 0 ? launchEnv : void 0,
             settings: {
               meshCoordinatorFor: meshId
             }
@@ -23659,10 +23770,10 @@ var ProviderInstanceManager = class {
 // src/providers/version-archive.ts
 var fs11 = __toESM(require("fs"));
 var path22 = __toESM(require("path"));
-var os19 = __toESM(require("os"));
+var os20 = __toESM(require("os"));
 var import_child_process10 = require("child_process");
 var import_os3 = require("os");
-var ARCHIVE_PATH = path22.join(os19.homedir(), ".adhdev", "version-history.json");
+var ARCHIVE_PATH = path22.join(os20.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
   history = {};
@@ -23765,7 +23876,7 @@ function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os19.homedir();
+      const home = os20.homedir();
       const resolved = p.replace(/\*/g, home.split(path22.sep).pop() || "");
       if (fs11.existsSync(resolved)) return resolved;
     } else {
@@ -26154,7 +26265,7 @@ async function handleCliRaw(ctx, req, res) {
 // src/daemon/dev-auto-implement.ts
 var fs14 = __toESM(require("fs"));
 var path25 = __toESM(require("path"));
-var os20 = __toESM(require("os"));
+var os21 = __toESM(require("os"));
 function getAutoImplPid(ctx) {
   const pid = ctx.autoImplProcess?.pid;
   return typeof pid === "number" && pid > 0 ? pid : null;
@@ -26355,7 +26466,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     });
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
-    const tmpDir = path25.join(os20.tmpdir(), "adhdev-autoimpl");
+    const tmpDir = path25.join(os21.tmpdir(), "adhdev-autoimpl");
     if (!fs14.existsSync(tmpDir)) fs14.mkdirSync(tmpDir, { recursive: true });
     const promptFile = path25.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
     fs14.writeFileSync(promptFile, prompt, "utf-8");
@@ -26510,7 +26621,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
     const baseArgs = [...spawn4.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
-    const isWin = os20.platform() === "win32";
+    const isWin = os21.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
     const promptMode = autoImpl?.promptMode ?? "stdin";
     const extraArgs = autoImpl?.extraArgs ?? [];
@@ -26549,7 +26660,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     try {
       const pty = require("node-pty");
       ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-      const isWin2 = os20.platform() === "win32";
+      const isWin2 = os21.platform() === "win32";
       child = pty.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
         name: "xterm-256color",
         cols: 120,