chatroom-cli 1.58.6 → 1.59.0

package/dist/index.js

@@ -28762,6 +28762,747 @@ var init_claude = __esm(() => {
   init_claude_code_agent_service();
 });
 
+// src/infrastructure/services/remote-agents/wire-native-stream-adapter.ts
+function wireNativeStreamAdapter(args2) {
+  args2.adapter.setAssistantTextCapture((text) => {
+    for (const cb of args2.assistantTextCallbacks)
+      cb(text);
+  });
+  args2.adapter.onOutput(() => {
+    args2.entry.lastOutputAt = Date.now();
+    for (const cb of args2.outputCallbacks)
+      cb();
+  });
+  args2.adapter.onAgentEnd(() => {
+    for (const cb of args2.agentEndCallbacks)
+      cb();
+  });
+}
+
+// src/infrastructure/services/remote-agents/with-timeout.ts
+async function withTimeout(p, ms, label) {
+  let timer;
+  try {
+    return await Promise.race([
+      p,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+
+// src/infrastructure/services/remote-agents/claude-sdk/claude-sdk-package.ts
+import { existsSync, readFileSync as readFileSync3 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname2, join as join7 } from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
+function resolveChatroomCliRoot(moduleRef = import.meta.url) {
+  const filePath = moduleRef.startsWith("file:") ? fileURLToPath2(moduleRef) : moduleRef;
+  let dir = dirname2(filePath);
+  while (dir !== dirname2(dir)) {
+    const packageJsonPath = join7(dir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+      if (pkg.name === "chatroom-cli") {
+        return dir;
+      }
+    }
+    dir = dirname2(dir);
+  }
+  throw new ClaudeSdkPackageError(`Could not locate chatroom-cli package root while resolving ${CLAUDE_AGENT_SDK_PKG}. ${REINSTALL_HINT}`);
+}
+function readPinnedSdkVersion(chatroomCliRoot) {
+  const pkg = JSON.parse(readFileSync3(join7(chatroomCliRoot, "package.json"), "utf8"));
+  const specifier = pkg.dependencies?.[CLAUDE_AGENT_SDK_PKG];
+  const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
+  const match17 = pinned.match(/^(\d+\.\d+\.\d+)/);
+  if (!match17) {
+    throw new ClaudeSdkPackageError(`chatroom-cli must pin an exact ${CLAUDE_AGENT_SDK_PKG} version (found "${specifier ?? "none"}"). ${REINSTALL_HINT}`);
+  }
+  return match17[1];
+}
+function readInstalledSdkVersion(entryPath) {
+  const packageJsonPath = join7(dirname2(entryPath), "package.json");
+  const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+  return pkg.version;
+}
+function resolvePlatformPackageName() {
+  const key = `${process.platform}-${process.arch}`;
+  const map18 = {
+    "darwin-arm64": "@anthropic-ai/claude-agent-sdk-darwin-arm64",
+    "darwin-x64": "@anthropic-ai/claude-agent-sdk-darwin-x64",
+    "linux-arm64": "@anthropic-ai/claude-agent-sdk-linux-arm64",
+    "linux-x64": "@anthropic-ai/claude-agent-sdk-linux-x64",
+    "win32-arm64": "@anthropic-ai/claude-agent-sdk-win32-arm64",
+    "win32-x64": "@anthropic-ai/claude-agent-sdk-win32-x64"
+  };
+  const pkg = map18[key];
+  if (!pkg) {
+    throw new ClaudeSdkPackageError(`Unsupported platform for ${CLAUDE_AGENT_SDK_PKG}: ${key}. ${REINSTALL_HINT}`);
+  }
+  return pkg;
+}
+function resolveNativeCliBinaryPath(sdkEntryPath) {
+  const require3 = createRequire3(sdkEntryPath);
+  const platformPkg = resolvePlatformPackageName();
+  const binaryName = process.platform === "win32" ? "claude.exe" : "claude";
+  let pkgDir;
+  try {
+    pkgDir = dirname2(require3.resolve(`${platformPkg}/package.json`));
+  } catch {
+    throw new ClaudeSdkPackageError(`Native CLI binary package ${platformPkg} is not installed. ${REINSTALL_HINT}`);
+  }
+  const binaryPath = join7(pkgDir, binaryName);
+  if (!existsSync(binaryPath)) {
+    throw new ClaudeSdkPackageError(`Native CLI binary is missing: ${binaryPath}. ${REINSTALL_HINT}`);
+  }
+  return binaryPath;
+}
+async function resolvePathToClaudeCodeExecutable(moduleRef = import.meta.url) {
+  if (cachedExecutablePath)
+    return cachedExecutablePath;
+  const chatroomCliRoot = resolveChatroomCliRoot(moduleRef);
+  const require3 = createRequire3(join7(chatroomCliRoot, "package.json"));
+  const sdkEntryPath = require3.resolve(CLAUDE_AGENT_SDK_PKG, { paths: [chatroomCliRoot] });
+  const embeddedPath = resolveNativeCliBinaryPath(sdkEntryPath);
+  const { extractFromBunfs } = await import("@anthropic-ai/claude-agent-sdk/extract");
+  cachedExecutablePath = extractFromBunfs(embeddedPath);
+  return cachedExecutablePath;
+}
+async function importBundledClaudeSdk(moduleRef = import.meta.url) {
+  const chatroomCliRoot = resolveChatroomCliRoot(moduleRef);
+  const require3 = createRequire3(join7(chatroomCliRoot, "package.json"));
+  const pinnedVersion = readPinnedSdkVersion(chatroomCliRoot);
+  const entryPath = require3.resolve(CLAUDE_AGENT_SDK_PKG, { paths: [chatroomCliRoot] });
+  const installedVersion = readInstalledSdkVersion(entryPath);
+  if (installedVersion !== pinnedVersion) {
+    throw new ClaudeSdkPackageError(`${CLAUDE_AGENT_SDK_PKG}@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT}`);
+  }
+  if (!existsSync(entryPath)) {
+    throw new ClaudeSdkPackageError(`${CLAUDE_AGENT_SDK_PKG} entry file is missing: ${entryPath}. ${REINSTALL_HINT}`);
+  }
+  return import(pathToFileURL(entryPath).href);
+}
+function getBundledClaudeSdkVersion(moduleRef = import.meta.url) {
+  const chatroomCliRoot = resolveChatroomCliRoot(moduleRef);
+  const require3 = createRequire3(join7(chatroomCliRoot, "package.json"));
+  const entryPath = require3.resolve(CLAUDE_AGENT_SDK_PKG, { paths: [chatroomCliRoot] });
+  return readInstalledSdkVersion(entryPath);
+}
+function formatClaudeSdkLoadError(err) {
+  if (err instanceof ClaudeSdkPackageError) {
+    return err.message;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.includes("Native CLI binary")) {
+    return `${message} ${REINSTALL_HINT}`;
+  }
+  return message;
+}
+var CLAUDE_AGENT_SDK_PKG = "@anthropic-ai/claude-agent-sdk", REINSTALL_HINT = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", ClaudeSdkPackageError, cachedExecutablePath;
+var init_claude_sdk_package = __esm(() => {
+  ClaudeSdkPackageError = class ClaudeSdkPackageError extends Error {
+    code = "CLAUDE_SDK_PACKAGE_INCOMPLETE";
+    constructor(message) {
+      super(message);
+      this.name = "ClaudeSdkPackageError";
+    }
+  };
+});
+
+// src/infrastructure/services/remote-agents/assistant-text-capture.ts
+function createAssistantTextCapture() {
+  let onAssistantText;
+  return {
+    setAssistantTextCapture(cb) {
+      onAssistantText = cb;
+    },
+    captureAssistantText(text) {
+      onAssistantText?.(text);
+    }
+  };
+}
+
+// src/infrastructure/services/remote-agents/native-stream-adapter-base.ts
+class NativeStreamAdapterBase {
+  logPrefix;
+  emitLogLine;
+  agentEndCallbacks = [];
+  outputCallbacks = [];
+  agentEndEmitted = false;
+  assistantTextCapture = createAssistantTextCapture();
+  constructor(logPrefix, emitLogLine) {
+    this.logPrefix = logPrefix;
+    this.emitLogLine = emitLogLine;
+  }
+  setAssistantTextCapture(cb) {
+    this.assistantTextCapture.setAssistantTextCapture(cb);
+  }
+  onAgentEnd(cb) {
+    this.agentEndCallbacks.push(cb);
+  }
+  onOutput(cb) {
+    this.outputCallbacks.push(cb);
+  }
+  notifyOutput() {
+    for (const cb of this.outputCallbacks)
+      cb();
+  }
+  writeLine(line) {
+    this.emitLogLine?.(line);
+  }
+}
+var init_native_stream_adapter_base = () => {};
+
+// src/infrastructure/services/remote-agents/claude-sdk/claude-sdk-stream-adapter.ts
+var ClaudeSdkStreamAdapter;
+var init_claude_sdk_stream_adapter = __esm(() => {
+  init_native_stream_adapter_base();
+  ClaudeSdkStreamAdapter = class ClaudeSdkStreamAdapter extends NativeStreamAdapterBase {
+    textBuffer = "";
+    thinkingBuffer = "";
+    handleMessage(message) {
+      this.notifyOutput();
+      switch (message.type) {
+        case "stream_event":
+          this.handleStreamEvent(message);
+          break;
+        case "assistant":
+          this.handleAssistant(message);
+          break;
+        case "user":
+          this.handleUser(message);
+          break;
+        case "system":
+          if (message.subtype === "init") {
+            this.writeLine(formatAgentLogLine(this.logPrefix, "system: init"));
+          }
+          break;
+        case "result":
+          if (message.is_error) {
+            const errors2 = "errors" in message && Array.isArray(message.errors) ? message.errors.join("; ") : "turn failed";
+            this.writeLine(formatAgentLogLine(this.logPrefix, "run-error", errors2));
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    finish() {
+      this.flushText();
+      this.flushThinking();
+      this.emitAgentEnd();
+    }
+    handleStreamEvent(message) {
+      const event = message.event;
+      if (event.type === "content_block_delta") {
+        const delta = event.delta;
+        if (delta.type === "text_delta") {
+          this.appendText(delta.text);
+        } else if (delta.type === "thinking_delta") {
+          this.appendThinking(delta.thinking);
+        }
+      }
+    }
+    handleAssistant(message) {
+      if (message.error) {
+        this.writeLine(formatAgentLogLine(this.logPrefix, "run-error", `assistant error: ${message.error}`));
+      }
+      for (const block of message.message.content) {
+        if (block.type === "text") {
+          this.appendText(block.text);
+          this.flushText();
+        } else if (block.type === "thinking") {
+          this.appendThinking(block.thinking);
+          this.flushThinking();
+        } else if (block.type === "tool_use") {
+          this.flushText();
+          this.flushThinking();
+          const bashCmd = resolveBashCommandForLog(block.name, block.input);
+          if (bashCmd !== null) {
+            this.writeLine(formatAgentLogLine(this.logPrefix, BASH_TOOL_KIND, formatBashRunningPayload(bashCmd)));
+            break;
+          }
+          const argsStr = block.input != null ? ` args: ${JSON.stringify(block.input)}` : "";
+          this.writeLine(formatAgentLogLine(this.logPrefix, "tool", `${block.name}${argsStr}`));
+        }
+      }
+    }
+    handleUser(message) {
+      if (message.tool_use_result === undefined)
+        return;
+      const content = message.message.content;
+      const blocks = Array.isArray(content) ? content : [content];
+      for (const block of blocks) {
+        if (typeof block === "string")
+          continue;
+        if (block.type === "tool_result") {
+          const resultStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+          this.writeLine(formatAgentLogLine(this.logPrefix, "tool_result", `tool result: ${resultStr}`));
+        }
+      }
+    }
+    emitAgentEnd() {
+      if (this.agentEndEmitted)
+        return;
+      this.agentEndEmitted = true;
+      this.writeLine(formatAgentLogLine(this.logPrefix, "agent_end"));
+      for (const cb of this.agentEndCallbacks)
+        cb();
+    }
+    appendText(delta) {
+      this.flushThinking();
+      this.textBuffer += delta;
+      this.assistantTextCapture.captureAssistantText(delta);
+      if (this.textBuffer.includes(`
+`))
+        this.flushText();
+    }
+    appendThinking(delta) {
+      this.flushText();
+      this.thinkingBuffer += delta;
+      if (this.thinkingBuffer.includes(`
+`))
+        this.flushThinking();
+    }
+    flushText() {
+      if (!this.textBuffer)
+        return;
+      const lines = this.textBuffer.split(`
+`);
+      const remaining = this.textBuffer.endsWith(`
+`) ? "" : lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.length > 0) {
+          this.writeLine(formatAgentLogLine(this.logPrefix, "text", line));
+        }
+      }
+      this.textBuffer = remaining;
+    }
+    flushThinking() {
+      if (!this.thinkingBuffer)
+        return;
+      const lines = this.thinkingBuffer.split(`
+`);
+      const remaining = this.thinkingBuffer.endsWith(`
+`) ? "" : lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.length > 0) {
+          this.writeLine(formatAgentLogLine(this.logPrefix, "thinking", line));
+        }
+      }
+      this.thinkingBuffer = remaining;
+    }
+    writeLine(line) {
+      process.stderr.write(`${line}
+`);
+      this.emitLogLine?.(line);
+    }
+  };
+});
+
+// src/infrastructure/services/remote-agents/claude-sdk/claude-sdk-agent-service.ts
+async function loadSdk() {
+  if (_sdkCache)
+    return _sdkCache;
+  if (_sdkLoadError)
+    throw _sdkLoadError;
+  try {
+    _sdkCache = await importBundledClaudeSdk();
+    return _sdkCache;
+  } catch (err) {
+    _sdkLoadError = err;
+    throw err;
+  }
+}
+function getSdkPackageVersion() {
+  if (cachedSdkPackageVersion)
+    return cachedSdkPackageVersion;
+  cachedSdkPackageVersion = getBundledClaudeSdkVersion();
+  return cachedSdkPackageVersion;
+}
+function waitForResumeOrAbort(session2) {
+  if (session2.aborted)
+    return Promise.resolve(null);
+  const queued = session2.pendingResumePrompt;
+  if (queued !== undefined) {
+    session2.pendingResumePrompt = undefined;
+    return Promise.resolve(queued);
+  }
+  return Promise.race([
+    new Promise((resolve2) => {
+      session2.resumeResolve = (prompt) => {
+        session2.resumeResolve = undefined;
+        session2.abortResolve = undefined;
+        resolve2(prompt);
+      };
+    }),
+    new Promise((resolve2) => {
+      session2.abortResolve = () => {
+        session2.resumeResolve = undefined;
+        session2.abortResolve = undefined;
+        resolve2(null);
+      };
+    })
+  ]);
+}
+function writeSpawnError(logPrefix, err, emitLogLine) {
+  const line = formatAgentLogLine(logPrefix, "spawn-error", formatClaudeSdkLoadError(err));
+  process.stderr.write(`${line}
+`);
+  emitLogLine?.(line);
+  console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
+}
+function captureSessionId(message, session2) {
+  if ("session_id" in message && typeof message.session_id === "string") {
+    session2.sessionId = message.session_id;
+  }
+}
+var CLAUDE_SDK_COMMAND = "claude-sdk", DEFAULT_MAX_TURNS2 = 200, TURN_TIMEOUT_MS = 3600000, _sdkCache, _sdkLoadError, cachedSdkPackageVersion, ClaudeSdkAgentService;
+var init_claude_sdk_agent_service = __esm(() => {
+  init_esm();
+  init_base_cli_agent_service();
+  init_claude_models();
+  init_detection_result();
+  init_claude_sdk_package();
+  init_claude_sdk_stream_adapter();
+  ClaudeSdkAgentService = class ClaudeSdkAgentService extends BaseCLIAgentService {
+    id = "claude-sdk";
+    displayName = "Claude Code (SDK)";
+    command = CLAUDE_SDK_COMMAND;
+    sessions = new Map;
+    constructor(deps) {
+      super(deps);
+    }
+    async isInstalled() {
+      try {
+        await loadSdk();
+        await resolvePathToClaudeCodeExecutable();
+        return true;
+      } catch (err) {
+        console.warn(`[claude-sdk] unavailable: ${formatClaudeSdkLoadError(err)}`);
+        return false;
+      }
+    }
+    detectInstallationEffect() {
+      return exports_Effect.promise(async () => {
+        const installed = await this.isInstalled();
+        return installed ? DetectionResult.Installed() : DetectionResult.NotInstalled();
+      });
+    }
+    async getVersion() {
+      const match17 = getSdkPackageVersion().match(/^(\d+)\.(\d+)\.(\d+)/);
+      if (!match17)
+        return null;
+      return {
+        version: `${match17[1]}.${match17[2]}.${match17[3]}`,
+        major: parseInt(match17[1], 10)
+      };
+    }
+    async listModels() {
+      const dynamic = await fetchClaudeModels();
+      if (dynamic)
+        return dynamic;
+      return [...CLAUDE_FALLBACK_MODELS];
+    }
+    async resumeTurn(pid, prompt) {
+      const session2 = this.sessions.get(pid);
+      if (!session2) {
+        throw new Error(`No claude-sdk session for pid=${pid}`);
+      }
+      if (session2.resumeResolve) {
+        const resolve2 = session2.resumeResolve;
+        session2.resumeResolve = undefined;
+        session2.abortResolve = undefined;
+        resolve2(prompt);
+        return;
+      }
+      session2.pendingResumePrompt = prompt;
+    }
+    async stop(pid, _options) {
+      const session2 = this.sessions.get(pid);
+      if (session2) {
+        session2.aborted = true;
+        session2.abortResolve?.();
+        try {
+          await withTimeout(session2.activeQuery?.interrupt() ?? Promise.resolve(), 5000, "interrupt");
+        } catch (err) {
+          console.warn(`[claude-sdk] interrupt for pid=${pid} failed:`, err instanceof Error ? err.message : err);
+        }
+        try {
+          session2.keeper.kill();
+        } catch {}
+        this.sessions.delete(pid);
+      }
+      await super.stop(pid);
+    }
+    spawnKeeper(workingDir) {
+      const keeper = this.deps.spawn(process.execPath, ["-e", "setInterval(()=>{},2147483647)"], {
+        cwd: workingDir,
+        stdio: "ignore",
+        shell: false,
+        detached: true
+      });
+      if (!keeper.pid) {
+        keeper.kill();
+        throw new Error("Failed to spawn claude-sdk keeper process");
+      }
+      return keeper;
+    }
+    startRunningSession(args2) {
+      const {
+        pid,
+        keeper,
+        context: context5,
+        workingDir,
+        model,
+        initialPrompt,
+        deferInitialTurn = false,
+        storedSystemPrompt,
+        executablePath
+      } = args2;
+      const entry = this.registerProcess(pid, context5);
+      const logPrefix = buildAgentLogPrefix("claude-sdk", context5);
+      const sdkSession = {
+        keeper,
+        aborted: false,
+        storedSystemPrompt
+      };
+      this.sessions.set(pid, sdkSession);
+      const exitCallbacks = [];
+      const outputCallbacks = [];
+      const agentEndCallbacks = [];
+      const logLineCallbacks = [];
+      const assistantTextCallbacks = [];
+      const emitLogLine = (line) => {
+        for (const cb of logLineCallbacks)
+          cb(line);
+      };
+      const finishExit = (code2, signal) => {
+        sdkSession.activeQuery = undefined;
+        this.sessions.delete(pid);
+        this.deleteProcess(pid);
+        for (const cb of exitCallbacks) {
+          cb({ code: code2, signal, context: context5 });
+        }
+      };
+      this.runTurnLoop({
+        sdkSession,
+        entry,
+        logPrefix,
+        workingDir,
+        model,
+        executablePath,
+        initialPrompt,
+        deferInitialTurn,
+        finishExit,
+        outputCallbacks,
+        agentEndCallbacks,
+        assistantTextCallbacks,
+        emitLogLine
+      });
+      return {
+        pid,
+        harnessSessionId: undefined,
+        onExit: (cb) => {
+          exitCallbacks.push(cb);
+        },
+        onOutput: (cb) => {
+          outputCallbacks.push(cb);
+        },
+        onAgentEnd: (cb) => {
+          agentEndCallbacks.push(cb);
+        },
+        onLogLine: (cb) => {
+          logLineCallbacks.push(cb);
+        },
+        onAssistantText: (cb) => {
+          assistantTextCallbacks.push(cb);
+        }
+      };
+    }
+    runTurnLoop(args2) {
+      const {
+        sdkSession,
+        logPrefix,
+        workingDir,
+        model,
+        executablePath,
+        initialPrompt,
+        deferInitialTurn = false,
+        finishExit,
+        entry,
+        outputCallbacks,
+        agentEndCallbacks,
+        assistantTextCallbacks,
+        emitLogLine
+      } = args2;
+      let exited = false;
+      this.executeTurnLoop({
+        sdkSession,
+        logPrefix,
+        workingDir,
+        model,
+        executablePath,
+        initialPrompt,
+        deferInitialTurn,
+        finishExit,
+        entry,
+        outputCallbacks,
+        agentEndCallbacks,
+        assistantTextCallbacks,
+        emitLogLine,
+        isExited: () => exited,
+        markExited: () => {
+          exited = true;
+        }
+      }).catch((err) => {
+        writeSpawnError(logPrefix, err, emitLogLine);
+        if (exited)
+          return;
+        exited = true;
+        try {
+          sdkSession.keeper.kill();
+        } catch {}
+        finishExit(1, null);
+      });
+    }
+    async executeTurnLoop(args2) {
+      const {
+        sdkSession,
+        logPrefix,
+        workingDir,
+        model,
+        executablePath,
+        initialPrompt,
+        deferInitialTurn,
+        finishExit,
+        entry,
+        outputCallbacks,
+        agentEndCallbacks,
+        assistantTextCallbacks,
+        emitLogLine,
+        isExited,
+        markExited
+      } = args2;
+      let exitCode = 0;
+      let exitSignal = null;
+      let nextPrompt = deferInitialTurn ? null : initialPrompt;
+      let isFirstQuery = true;
+      try {
+        const { query } = await loadSdk();
+        while (!sdkSession.aborted) {
+          try {
+            if (nextPrompt === null) {
+              const deferredResume = await waitForResumeOrAbort(sdkSession);
+              if (deferredResume === null || sdkSession.aborted) {
+                if (sdkSession.aborted) {
+                  exitCode = 1;
+                  exitSignal = "SIGTERM";
+                }
+                break;
+              }
+              nextPrompt = deferredResume;
+            }
+            const adapter = new ClaudeSdkStreamAdapter(logPrefix, emitLogLine);
+            wireNativeStreamAdapter({
+              adapter,
+              assistantTextCallbacks,
+              outputCallbacks,
+              agentEndCallbacks,
+              entry
+            });
+            const queryInstance = query({
+              prompt: nextPrompt,
+              options: {
+                cwd: workingDir,
+                model,
+                maxTurns: DEFAULT_MAX_TURNS2,
+                pathToClaudeCodeExecutable: executablePath,
+                includePartialMessages: true,
+                systemPrompt: isFirstQuery ? sdkSession.storedSystemPrompt : undefined,
+                resume: !isFirstQuery ? sdkSession.sessionId : undefined,
+                settingSources: []
+              }
+            });
+            sdkSession.activeQuery = queryInstance;
+            isFirstQuery = false;
+            nextPrompt = null;
+            await withTimeout((async () => {
+              for await (const message of queryInstance) {
+                if (sdkSession.aborted)
+                  break;
+                captureSessionId(message, sdkSession);
+                adapter.handleMessage(message);
+                if (message.type === "result")
+                  break;
+              }
+            })(), TURN_TIMEOUT_MS, "query");
+            sdkSession.activeQuery = undefined;
+            if (sdkSession.aborted) {
+              exitCode = 1;
+              exitSignal = "SIGTERM";
+              break;
+            }
+            adapter.finish();
+          } catch (turnErr) {
+            exitCode = 1;
+            writeSpawnError(logPrefix, turnErr, emitLogLine);
+            break;
+          }
+        }
+      } catch (err) {
+        exitCode = 1;
+        writeSpawnError(logPrefix, err, emitLogLine);
+      } finally {
+        if (isExited())
+          return;
+        markExited();
+        try {
+          sdkSession.keeper.kill();
+        } catch {}
+        finishExit(exitCode, exitSignal);
+      }
+    }
+    async spawn(options) {
+      const deferInitialTurn = options.deferInitialTurn ?? false;
+      const keeper = this.spawnKeeper(options.workingDir);
+      const pid = keeper.pid;
+      const context5 = options.context;
+      const fullPrompt = deferInitialTurn ? "" : options.prompt;
+      let executablePath;
+      try {
+        await loadSdk();
+        executablePath = await resolvePathToClaudeCodeExecutable();
+      } catch (err) {
+        keeper.kill();
+        this.deleteProcess(pid);
+        throw err;
+      }
+      return this.startRunningSession({
+        pid,
+        keeper,
+        context: context5,
+        workingDir: options.workingDir,
+        model: options.model,
+        initialPrompt: fullPrompt,
+        deferInitialTurn,
+        storedSystemPrompt: options.systemPrompt,
+        executablePath
+      });
+    }
+  };
+});
+
+// src/infrastructure/services/remote-agents/claude-sdk/index.ts
+var init_claude_sdk = __esm(() => {
+  init_claude_sdk_agent_service();
+});
+
 // src/infrastructure/services/remote-agents/commandcode/command-code-stream-reader.ts
 import { createInterface as createInterface3 } from "node:readline";
 
@@ -28962,23 +29703,6 @@ var init_commandcode = __esm(() => {
   init_command_code_agent_service();
 });
 
-// src/infrastructure/services/remote-agents/wire-native-stream-adapter.ts
-function wireNativeStreamAdapter(args2) {
-  args2.adapter.setAssistantTextCapture((text) => {
-    for (const cb of args2.assistantTextCallbacks)
-      cb(text);
-  });
-  args2.adapter.onOutput(() => {
-    args2.entry.lastOutputAt = Date.now();
-    for (const cb of args2.outputCallbacks)
-      cb();
-  });
-  args2.adapter.onAgentEnd(() => {
-    for (const cb of args2.agentEndCallbacks)
-      cb();
-  });
-}
-
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-models.ts
 function resolveCursorSdkModel(model) {
   const prefix = `${CURSOR_PROVIDER2}/`;
@@ -29006,68 +29730,68 @@ __export(exports_cursor_sdk_package, {
   getBundledCursorSdkVersion: () => getBundledCursorSdkVersion,
   formatCursorSdkLoadError: () => formatCursorSdkLoadError
 });
-import { existsSync, readFileSync as readFileSync3 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname2, join as join7 } from "node:path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
-function resolveChatroomCliRoot(moduleRef = import.meta.url) {
-  const filePath = moduleRef.startsWith("file:") ? fileURLToPath2(moduleRef) : moduleRef;
-  let dir = dirname2(filePath);
-  while (dir !== dirname2(dir)) {
-    const packageJsonPath = join7(dir, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
+import { dirname as dirname3, join as join8 } from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
+function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
+  const filePath = moduleRef.startsWith("file:") ? fileURLToPath3(moduleRef) : moduleRef;
+  let dir = dirname3(filePath);
+  while (dir !== dirname3(dir)) {
+    const packageJsonPath = join8(dir, "package.json");
+    if (existsSync2(packageJsonPath)) {
+      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
       if (pkg.name === "chatroom-cli") {
         return dir;
       }
     }
-    dir = dirname2(dir);
+    dir = dirname3(dir);
   }
-  throw new CursorSdkPackageError(`Could not locate chatroom-cli package root while resolving @cursor/sdk. ${REINSTALL_HINT}`);
+  throw new CursorSdkPackageError(`Could not locate chatroom-cli package root while resolving @cursor/sdk. ${REINSTALL_HINT2}`);
 }
-function readPinnedSdkVersion(chatroomCliRoot) {
-  const pkg = JSON.parse(readFileSync3(join7(chatroomCliRoot, "package.json"), "utf8"));
+function readPinnedSdkVersion2(chatroomCliRoot) {
+  const pkg = JSON.parse(readFileSync4(join8(chatroomCliRoot, "package.json"), "utf8"));
   const specifier = pkg.dependencies?.["@cursor/sdk"];
   const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
   const match17 = pinned.match(/^(\d+\.\d+\.\d+)/);
   if (!match17) {
-    throw new CursorSdkPackageError(`chatroom-cli must pin an exact @cursor/sdk version (found "${specifier ?? "none"}"). ${REINSTALL_HINT}`);
+    throw new CursorSdkPackageError(`chatroom-cli must pin an exact @cursor/sdk version (found "${specifier ?? "none"}"). ${REINSTALL_HINT2}`);
   }
   return match17[1];
 }
-function readInstalledSdkVersion(entryPath) {
-  const packageJsonPath = join7(dirname2(entryPath), "..", "..", "package.json");
-  const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+function readInstalledSdkVersion2(entryPath) {
+  const packageJsonPath = join8(dirname3(entryPath), "..", "..", "package.json");
+  const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
   return pkg.version;
 }
 function resolveSdkEsmImportPath(cjsEntryPath) {
   const importPath = cjsEntryPath.includes("/dist/cjs/") ? cjsEntryPath.replace("/dist/cjs/", "/dist/esm/") : cjsEntryPath;
-  if (!existsSync(importPath)) {
-    throw new CursorSdkPackageError(`@cursor/sdk ESM entry file is missing: ${importPath}. ${REINSTALL_HINT}`);
+  if (!existsSync2(importPath)) {
+    throw new CursorSdkPackageError(`@cursor/sdk ESM entry file is missing: ${importPath}. ${REINSTALL_HINT2}`);
   }
   return importPath;
 }
 async function importBundledCursorSdk(moduleRef = import.meta.url) {
-  const chatroomCliRoot = resolveChatroomCliRoot(moduleRef);
-  const require3 = createRequire3(join7(chatroomCliRoot, "package.json"));
-  const pinnedVersion = readPinnedSdkVersion(chatroomCliRoot);
+  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
+  const require3 = createRequire4(join8(chatroomCliRoot, "package.json"));
+  const pinnedVersion = readPinnedSdkVersion2(chatroomCliRoot);
   const entryPath = require3.resolve("@cursor/sdk", { paths: [chatroomCliRoot] });
-  const installedVersion = readInstalledSdkVersion(entryPath);
+  const installedVersion = readInstalledSdkVersion2(entryPath);
   if (installedVersion !== pinnedVersion) {
-    throw new CursorSdkPackageError(`@cursor/sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT}`);
+    throw new CursorSdkPackageError(`@cursor/sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT2}`);
   }
-  if (!existsSync(entryPath)) {
-    throw new CursorSdkPackageError(`@cursor/sdk entry file is missing: ${entryPath}. ${REINSTALL_HINT}`);
+  if (!existsSync2(entryPath)) {
+    throw new CursorSdkPackageError(`@cursor/sdk entry file is missing: ${entryPath}. ${REINSTALL_HINT2}`);
   }
-  const sdk = await import(pathToFileURL(resolveSdkEsmImportPath(entryPath)).href);
+  const sdk = await import(pathToFileURL2(resolveSdkEsmImportPath(entryPath)).href);
   sdk.configureCursorSdk({ local: { useHttp1ForAgent: true } });
   return sdk;
 }
 function getBundledCursorSdkVersion(moduleRef = import.meta.url) {
-  const chatroomCliRoot = resolveChatroomCliRoot(moduleRef);
-  const require3 = createRequire3(join7(chatroomCliRoot, "package.json"));
+  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
+  const require3 = createRequire4(join8(chatroomCliRoot, "package.json"));
   const entryPath = require3.resolve("@cursor/sdk", { paths: [chatroomCliRoot] });
-  return readInstalledSdkVersion(entryPath);
+  return readInstalledSdkVersion2(entryPath);
 }
 function formatCursorSdkLoadError(err) {
   if (err instanceof CursorSdkPackageError) {
@@ -29076,11 +29800,11 @@ function formatCursorSdkLoadError(err) {
   const message = err instanceof Error ? err.message : String(err);
   const chunkMatch = message.match(/(\d+)\.index\.js/);
   if (chunkMatch) {
-    return `@cursor/sdk installation is incomplete (missing ${chunkMatch[1]}.index.js). ${REINSTALL_HINT}`;
+    return `@cursor/sdk installation is incomplete (missing ${chunkMatch[1]}.index.js). ${REINSTALL_HINT2}`;
   }
   return message;
 }
-var REINSTALL_HINT = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", CursorSdkPackageError;
+var REINSTALL_HINT2 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", CursorSdkPackageError;
 var init_cursor_sdk_package = __esm(() => {
   CursorSdkPackageError = class CursorSdkPackageError extends Error {
     code = "CURSOR_SDK_PACKAGE_INCOMPLETE";
@@ -29103,50 +29827,6 @@ function closeCursorAgentOnFailure(agent, session2, exitCode, force = false) {
   } catch {}
 }
 
-// src/infrastructure/services/remote-agents/assistant-text-capture.ts
-function createAssistantTextCapture() {
-  let onAssistantText;
-  return {
-    setAssistantTextCapture(cb) {
-      onAssistantText = cb;
-    },
-    captureAssistantText(text) {
-      onAssistantText?.(text);
-    }
-  };
-}
-
-// src/infrastructure/services/remote-agents/native-stream-adapter-base.ts
-class NativeStreamAdapterBase {
-  logPrefix;
-  emitLogLine;
-  agentEndCallbacks = [];
-  outputCallbacks = [];
-  agentEndEmitted = false;
-  assistantTextCapture = createAssistantTextCapture();
-  constructor(logPrefix, emitLogLine) {
-    this.logPrefix = logPrefix;
-    this.emitLogLine = emitLogLine;
-  }
-  setAssistantTextCapture(cb) {
-    this.assistantTextCapture.setAssistantTextCapture(cb);
-  }
-  onAgentEnd(cb) {
-    this.agentEndCallbacks.push(cb);
-  }
-  onOutput(cb) {
-    this.outputCallbacks.push(cb);
-  }
-  notifyOutput() {
-    for (const cb of this.outputCallbacks)
-      cb();
-  }
-  writeLine(line) {
-    this.emitLogLine?.(line);
-  }
-}
-var init_native_stream_adapter_base = () => {};
-
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-sdk-stream-adapter.ts
 var CursorSdkStreamAdapter;
 var init_cursor_sdk_stream_adapter = __esm(() => {
@@ -29230,47 +29910,31 @@ var init_cursor_sdk_stream_adapter = __esm(() => {
   };
 });
 
-// src/infrastructure/services/remote-agents/with-timeout.ts
-async function withTimeout(p, ms, label) {
-  let timer;
-  try {
-    return await Promise.race([
-      p,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
-      })
-    ]);
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
-
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-sdk-agent-service.ts
 import { randomUUID } from "node:crypto";
-async function loadSdk() {
-  if (_sdkCache)
-    return _sdkCache;
-  if (_sdkLoadError)
-    throw _sdkLoadError;
+async function loadSdk2() {
+  if (_sdkCache2)
+    return _sdkCache2;
+  if (_sdkLoadError2)
+    throw _sdkLoadError2;
   try {
-    _sdkCache = await importBundledCursorSdk();
-    return _sdkCache;
+    _sdkCache2 = await importBundledCursorSdk();
+    return _sdkCache2;
   } catch (err) {
-    _sdkLoadError = err;
+    _sdkLoadError2 = err;
     throw err;
   }
 }
-function getSdkPackageVersion() {
-  if (cachedSdkPackageVersion)
-    return cachedSdkPackageVersion;
-  cachedSdkPackageVersion = getBundledCursorSdkVersion();
-  return cachedSdkPackageVersion;
+function getSdkPackageVersion2() {
+  if (cachedSdkPackageVersion2)
+    return cachedSdkPackageVersion2;
+  cachedSdkPackageVersion2 = getBundledCursorSdkVersion();
+  return cachedSdkPackageVersion2;
 }
 function buildAgentName(context5) {
   return `${context5.role}@${context5.chatroomId.slice(-6)}`;
 }
-function waitForResumeOrAbort(session2) {
+function waitForResumeOrAbort2(session2) {
   if (session2.aborted)
     return Promise.resolve(null);
   const queued = session2.pendingResumePrompt;
@@ -29298,14 +29962,14 @@ function waitForResumeOrAbort(session2) {
 function resolveModelId(model) {
   return model ? resolveCursorSdkModel(model) : DEFAULT_MODEL;
 }
-function writeSpawnError(logPrefix, err, emitLogLine) {
+function writeSpawnError2(logPrefix, err, emitLogLine) {
   const line = formatAgentLogLine(logPrefix, "spawn-error", formatCursorSdkLoadError(err));
   process.stderr.write(`${line}
 `);
   emitLogLine?.(line);
   console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
 }
-var NO_SUBAGENT_DIRECTIVE2 = "NEVER spawn subagents. Follow the chatroom instructions strictly.", _sdkCache, _sdkLoadError, CURSOR_SDK_COMMAND = "cursor-sdk", DEFAULT_MODEL = "composer-2.5", AGENT_CREATE_TIMEOUT_MS = 60000, SEND_TIMEOUT_MS = 60000, RUN_WAIT_TIMEOUT_MS = 3600000, MODELS_LIST_TIMEOUT_MS = 60000, RUN_CANCEL_TIMEOUT_MS = 5000, cachedSdkPackageVersion, CursorSdkAgentService;
+var NO_SUBAGENT_DIRECTIVE2 = "NEVER spawn subagents. Follow the chatroom instructions strictly.", _sdkCache2, _sdkLoadError2, CURSOR_SDK_COMMAND = "cursor-sdk", DEFAULT_MODEL = "composer-2.5", AGENT_CREATE_TIMEOUT_MS = 60000, SEND_TIMEOUT_MS = 60000, RUN_WAIT_TIMEOUT_MS = 3600000, MODELS_LIST_TIMEOUT_MS = 60000, RUN_CANCEL_TIMEOUT_MS = 5000, cachedSdkPackageVersion2, CursorSdkAgentService;
 var init_cursor_sdk_agent_service = __esm(() => {
   init_esm();
   init_base_cli_agent_service();
@@ -29324,7 +29988,7 @@ var init_cursor_sdk_agent_service = __esm(() => {
       if (!process.env.CURSOR_API_KEY?.trim())
         return false;
       try {
-        await loadSdk();
+        await loadSdk2();
         return true;
       } catch (err) {
         console.warn(`[cursor-sdk] unavailable: ${formatCursorSdkLoadError(err)}`);
@@ -29338,7 +30002,7 @@ var init_cursor_sdk_agent_service = __esm(() => {
       });
     }
     async getVersion() {
-      const match17 = getSdkPackageVersion().match(/^(\d+)\.(\d+)\.(\d+)/);
+      const match17 = getSdkPackageVersion2().match(/^(\d+)\.(\d+)\.(\d+)/);
       if (!match17)
         return null;
       return {
@@ -29351,7 +30015,7 @@ var init_cursor_sdk_agent_service = __esm(() => {
       if (!apiKey)
         return [];
       try {
-        const { Cursor } = await loadSdk();
+        const { Cursor } = await loadSdk2();
         const models = await withTimeout(Cursor.models.list({ apiKey }), MODELS_LIST_TIMEOUT_MS, "Cursor.models.list");
         const listedModelIds = models.map((m) => m.id).filter((id3) => id3.length > 0);
         return normalizeCursorSdkListedModels(listedModelIds);
@@ -29428,7 +30092,7 @@ ${options.systemPrompt}` : NO_SUBAGENT_DIRECTIVE2;
 ${options.prompt}`;
       let agent;
       try {
-        const { Agent } = await loadSdk();
+        const { Agent } = await loadSdk2();
         agent = await withTimeout(Agent.resume(stored.harnessSessionId, {
           apiKey,
           model: { id: modelId },
@@ -29578,7 +30242,7 @@ ${options.prompt}`;
           while (!session2.aborted) {
             try {
               if (nextPrompt === null) {
-                const deferredResume = await waitForResumeOrAbort(session2);
+                const deferredResume = await waitForResumeOrAbort2(session2);
                 if (deferredResume === null || session2.aborted) {
                   if (session2.aborted) {
                     exitCode = 1;
@@ -29616,7 +30280,7 @@ ${deferredResume}` : deferredResume;
                 }
               } catch (streamErr) {
                 exitCode = 1;
-                writeSpawnError(logPrefix, streamErr, emitLogLine);
+                writeSpawnError2(logPrefix, streamErr, emitLogLine);
                 break;
               }
               if (session2.aborted) {
@@ -29629,7 +30293,7 @@ ${deferredResume}` : deferredResume;
                 result = await withTimeout(run3.wait(), RUN_WAIT_TIMEOUT_MS, "run.wait");
               } catch (waitErr) {
                 exitCode = 1;
-                writeSpawnError(logPrefix, waitErr, emitLogLine);
+                writeSpawnError2(logPrefix, waitErr, emitLogLine);
                 break;
               }
               adapter.flushPendingOutput();
@@ -29646,13 +30310,13 @@ ${deferredResume}` : deferredResume;
               nextPrompt = null;
             } catch (turnErr) {
               exitCode = 1;
-              writeSpawnError(logPrefix, turnErr, emitLogLine);
+              writeSpawnError2(logPrefix, turnErr, emitLogLine);
               break;
             }
           }
         } catch (err) {
           exitCode = 1;
-          writeSpawnError(logPrefix, err, emitLogLine);
+          writeSpawnError2(logPrefix, err, emitLogLine);
         } finally {
           if (exited)
             return;
@@ -29664,7 +30328,7 @@ ${deferredResume}` : deferredResume;
           finishExit(exitCode, exitSignal);
         }
       })().catch((err) => {
-        writeSpawnError(logPrefix, err, emitLogLine);
+        writeSpawnError2(logPrefix, err, emitLogLine);
         if (exited)
           return;
         exited = true;
@@ -29694,7 +30358,7 @@ ${options.systemPrompt}` : NO_SUBAGENT_DIRECTIVE2;
 ${options.prompt}`;
       let agent;
       try {
-        const { Agent } = await loadSdk();
+        const { Agent } = await loadSdk2();
         agent = await withTimeout(Agent.create({
           apiKey,
           name: agentName,
@@ -32140,27 +32804,27 @@ var init_session_event_forwarder = __esm(() => {
 });
 
 // src/infrastructure/services/remote-agents/opencode-sdk/session-metadata-store.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "node:fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 
 class FileSessionMetadataStore {
   filePath;
   constructor(filePath) {
-    this.filePath = filePath ?? join8(homedir2(), ".chatroom", "opencode-sdk-sessions.json");
+    this.filePath = filePath ?? join9(homedir2(), ".chatroom", "opencode-sdk-sessions.json");
   }
   load() {
     try {
-      if (existsSync2(this.filePath)) {
-        return JSON.parse(readFileSync4(this.filePath, "utf-8"));
+      if (existsSync3(this.filePath)) {
+        return JSON.parse(readFileSync5(this.filePath, "utf-8"));
       }
     } catch {}
     return {};
   }
   save(sessions) {
     try {
-      const dir = dirname3(this.filePath);
-      if (!existsSync2(dir)) {
+      const dir = dirname4(this.filePath);
+      if (!existsSync3(dir)) {
         mkdirSync(dir, { recursive: true });
       }
       writeFileSync(this.filePath, JSON.stringify(sessions, null, 2));
@@ -32694,47 +33358,47 @@ __export(exports_pi_sdk_package, {
   getBundledPiSdkVersion: () => getBundledPiSdkVersion,
   formatPiSdkLoadError: () => formatPiSdkLoadError
 });
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname4, join as join9 } from "node:path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
-function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
-  const filePath = moduleRef.startsWith("file:") ? fileURLToPath3(moduleRef) : moduleRef;
-  let dir = dirname4(filePath);
-  while (dir !== dirname4(dir)) {
-    const packageJsonPath = join9(dir, "package.json");
-    if (existsSync3(packageJsonPath)) {
-      const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname5, join as join10 } from "node:path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
+function resolveChatroomCliRoot3(moduleRef = import.meta.url) {
+  const filePath = moduleRef.startsWith("file:") ? fileURLToPath4(moduleRef) : moduleRef;
+  let dir = dirname5(filePath);
+  while (dir !== dirname5(dir)) {
+    const packageJsonPath = join10(dir, "package.json");
+    if (existsSync4(packageJsonPath)) {
+      const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
       if (pkg.name === "chatroom-cli") {
         return dir;
       }
     }
-    dir = dirname4(dir);
+    dir = dirname5(dir);
   }
-  throw new PiSdkPackageError(`Could not locate chatroom-cli package root while resolving ${PI_CODING_AGENT_PKG}. ${REINSTALL_HINT2}`);
+  throw new PiSdkPackageError(`Could not locate chatroom-cli package root while resolving ${PI_CODING_AGENT_PKG}. ${REINSTALL_HINT3}`);
 }
-function readPinnedSdkVersion2(chatroomCliRoot) {
-  const pkg = JSON.parse(readFileSync5(join9(chatroomCliRoot, "package.json"), "utf8"));
+function readPinnedSdkVersion3(chatroomCliRoot) {
+  const pkg = JSON.parse(readFileSync6(join10(chatroomCliRoot, "package.json"), "utf8"));
   const specifier = pkg.dependencies?.[PI_CODING_AGENT_PKG];
   const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
   const match17 = pinned.match(/^(\d+\.\d+\.\d+)/);
   if (!match17) {
-    throw new PiSdkPackageError(`chatroom-cli must pin an exact ${PI_CODING_AGENT_PKG} version (found "${specifier ?? "none"}"). ${REINSTALL_HINT2}`);
+    throw new PiSdkPackageError(`chatroom-cli must pin an exact ${PI_CODING_AGENT_PKG} version (found "${specifier ?? "none"}"). ${REINSTALL_HINT3}`);
   }
   return match17[1];
 }
-function readInstalledSdkVersion2(entryPath) {
-  const packageJsonPath = join9(dirname4(entryPath), "..", "package.json");
-  const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
+function readInstalledSdkVersion3(entryPath) {
+  const packageJsonPath = join10(dirname5(entryPath), "..", "package.json");
+  const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
   return pkg.version;
 }
 function resolvePiSdkEntryPathFromNodeModules(chatroomCliRoot) {
   let dir = chatroomCliRoot;
-  while (dir !== dirname4(dir)) {
-    const entryPath = join9(dir, "node_modules", PI_CODING_AGENT_PKG, "dist", "index.js");
-    if (existsSync3(entryPath)) {
+  while (dir !== dirname5(dir)) {
+    const entryPath = join10(dir, "node_modules", PI_CODING_AGENT_PKG, "dist", "index.js");
+    if (existsSync4(entryPath)) {
       return entryPath;
     }
-    dir = dirname4(dir);
+    dir = dirname5(dir);
   }
   return;
 }
@@ -32742,32 +33406,32 @@ function resolvePiSdkEntryPath(chatroomCliRoot) {
   const resolveMeta = import.meta.resolve;
   if (typeof resolveMeta === "function") {
     try {
-      const parentUrl = pathToFileURL2(join9(chatroomCliRoot, "package.json")).href;
-      return fileURLToPath3(resolveMeta(PI_CODING_AGENT_PKG, parentUrl));
+      const parentUrl = pathToFileURL3(join10(chatroomCliRoot, "package.json")).href;
+      return fileURLToPath4(resolveMeta(PI_CODING_AGENT_PKG, parentUrl));
     } catch {}
   }
   const entryPath = resolvePiSdkEntryPathFromNodeModules(chatroomCliRoot);
   if (entryPath) {
     return entryPath;
   }
-  throw new PiSdkPackageError(`Could not resolve ${PI_CODING_AGENT_PKG} from ${chatroomCliRoot}. ${REINSTALL_HINT2}`);
+  throw new PiSdkPackageError(`Could not resolve ${PI_CODING_AGENT_PKG} from ${chatroomCliRoot}. ${REINSTALL_HINT3}`);
 }
 async function importBundledPiSdk(moduleRef = import.meta.url) {
-  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
-  const pinnedVersion = readPinnedSdkVersion2(chatroomCliRoot);
+  const chatroomCliRoot = resolveChatroomCliRoot3(moduleRef);
+  const pinnedVersion = readPinnedSdkVersion3(chatroomCliRoot);
   const entryPath = resolvePiSdkEntryPath(chatroomCliRoot);
-  const installedVersion = readInstalledSdkVersion2(entryPath);
+  const installedVersion = readInstalledSdkVersion3(entryPath);
   if (installedVersion !== pinnedVersion) {
-    throw new PiSdkPackageError(`${PI_CODING_AGENT_PKG}@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT2}`);
+    throw new PiSdkPackageError(`${PI_CODING_AGENT_PKG}@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT3}`);
   }
-  if (!existsSync3(entryPath)) {
-    throw new PiSdkPackageError(`${PI_CODING_AGENT_PKG} entry file is missing: ${entryPath}. ${REINSTALL_HINT2}`);
+  if (!existsSync4(entryPath)) {
+    throw new PiSdkPackageError(`${PI_CODING_AGENT_PKG} entry file is missing: ${entryPath}. ${REINSTALL_HINT3}`);
   }
-  return import(pathToFileURL2(entryPath).href);
+  return import(pathToFileURL3(entryPath).href);
 }
 function getBundledPiSdkVersion(moduleRef = import.meta.url) {
-  const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
-  return readInstalledSdkVersion2(resolvePiSdkEntryPath(chatroomCliRoot));
+  const chatroomCliRoot = resolveChatroomCliRoot3(moduleRef);
+  return readInstalledSdkVersion3(resolvePiSdkEntryPath(chatroomCliRoot));
 }
 function formatPiSdkLoadError(err) {
   if (err instanceof PiSdkPackageError) {
@@ -32775,7 +33439,7 @@ function formatPiSdkLoadError(err) {
   }
   return err instanceof Error ? err.message : String(err);
 }
-var PI_CODING_AGENT_PKG = "@earendil-works/pi-coding-agent", REINSTALL_HINT2 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", PiSdkPackageError;
+var PI_CODING_AGENT_PKG = "@earendil-works/pi-coding-agent", REINSTALL_HINT3 = "Reinstall chatroom-cli: npm install -g chatroom-cli@latest", PiSdkPackageError;
 var init_pi_sdk_package = __esm(() => {
   PiSdkPackageError = class PiSdkPackageError extends Error {
     code = "PI_SDK_PACKAGE_INCOMPLETE";
@@ -32894,26 +33558,26 @@ var init_pi_sdk_stream_adapter = __esm(() => {
 });
 
 // src/infrastructure/services/remote-agents/pi-sdk/pi-sdk-agent-service.ts
-async function loadSdk2() {
-  if (_sdkCache2)
-    return _sdkCache2;
-  if (_sdkLoadError2)
-    throw _sdkLoadError2;
+async function loadSdk3() {
+  if (_sdkCache3)
+    return _sdkCache3;
+  if (_sdkLoadError3)
+    throw _sdkLoadError3;
   try {
-    _sdkCache2 = await importBundledPiSdk();
-    return _sdkCache2;
+    _sdkCache3 = await importBundledPiSdk();
+    return _sdkCache3;
   } catch (err) {
-    _sdkLoadError2 = err;
+    _sdkLoadError3 = err;
     throw err;
   }
 }
-function getSdkPackageVersion2() {
-  if (cachedSdkPackageVersion2)
-    return cachedSdkPackageVersion2;
-  cachedSdkPackageVersion2 = getBundledPiSdkVersion();
-  return cachedSdkPackageVersion2;
+function getSdkPackageVersion3() {
+  if (cachedSdkPackageVersion3)
+    return cachedSdkPackageVersion3;
+  cachedSdkPackageVersion3 = getBundledPiSdkVersion();
+  return cachedSdkPackageVersion3;
 }
-function waitForResumeOrAbort2(session2) {
+function waitForResumeOrAbort3(session2) {
   if (session2.aborted)
     return Promise.resolve(null);
   const queued = session2.pendingResumePrompt;
@@ -32950,14 +33614,14 @@ function resolveModel(modelRegistry, model) {
   }
   return modelRegistry.getAvailable()[0];
 }
-function writeSpawnError2(logPrefix, err, emitLogLine) {
+function writeSpawnError3(logPrefix, err, emitLogLine) {
   const line = formatAgentLogLine(logPrefix, "spawn-error", formatPiSdkLoadError(err));
   process.stderr.write(`${line}
 `);
   emitLogLine?.(line);
   console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
 }
-var PI_SDK_COMMAND = "pi-sdk", SESSION_CREATE_TIMEOUT_MS2 = 60000, PROMPT_TIMEOUT_MS = 3600000, _sdkCache2, _sdkLoadError2, cachedSdkPackageVersion2, PiSdkAgentService;
+var PI_SDK_COMMAND = "pi-sdk", SESSION_CREATE_TIMEOUT_MS2 = 60000, PROMPT_TIMEOUT_MS = 3600000, _sdkCache3, _sdkLoadError3, cachedSdkPackageVersion3, PiSdkAgentService;
 var init_pi_sdk_agent_service = __esm(() => {
   init_esm();
   init_base_cli_agent_service();
@@ -32975,7 +33639,7 @@ var init_pi_sdk_agent_service = __esm(() => {
     }
     async isInstalled() {
       try {
-        const { ModelRegistry, AuthStorage } = await loadSdk2();
+        const { ModelRegistry, AuthStorage } = await loadSdk3();
         const authStorage = AuthStorage.create();
         const modelRegistry = ModelRegistry.create(authStorage);
         return modelRegistry.getAvailable().length > 0;
@@ -32991,7 +33655,7 @@ var init_pi_sdk_agent_service = __esm(() => {
       });
     }
     async getVersion() {
-      const match17 = getSdkPackageVersion2().match(/^(\d+)\.(\d+)\.(\d+)/);
+      const match17 = getSdkPackageVersion3().match(/^(\d+)\.(\d+)\.(\d+)/);
       if (!match17)
         return null;
       return {
@@ -33001,7 +33665,7 @@ var init_pi_sdk_agent_service = __esm(() => {
     }
     async listModels() {
       try {
-        const { ModelRegistry, AuthStorage } = await loadSdk2();
+        const { ModelRegistry, AuthStorage } = await loadSdk3();
         const authStorage = AuthStorage.create();
         const modelRegistry = ModelRegistry.create(authStorage);
         return modelRegistry.getAvailable().map((entry) => `${entry.provider}/${entry.id}`);
@@ -33066,7 +33730,7 @@ var init_pi_sdk_agent_service = __esm(() => {
         getAgentDir,
         ModelRegistry,
         SessionManager
-      } = await loadSdk2();
+      } = await loadSdk3();
       const authStorage = AuthStorage.create();
       const modelRegistry = ModelRegistry.create(authStorage);
       const resolvedModel = resolveModel(modelRegistry, args2.model);
@@ -33182,7 +33846,7 @@ var init_pi_sdk_agent_service = __esm(() => {
           while (!sdkSession.aborted) {
             try {
               if (nextPrompt === null) {
-                const deferredResume = await waitForResumeOrAbort2(sdkSession);
+                const deferredResume = await waitForResumeOrAbort3(sdkSession);
                 if (deferredResume === null || sdkSession.aborted) {
                   if (sdkSession.aborted) {
                     exitCode = 1;
@@ -33220,13 +33884,13 @@ ${deferredResume}` : deferredResume;
               nextPrompt = null;
             } catch (turnErr) {
               exitCode = 1;
-              writeSpawnError2(logPrefix, turnErr, emitLogLine);
+              writeSpawnError3(logPrefix, turnErr, emitLogLine);
               break;
             }
           }
         } catch (err) {
           exitCode = 1;
-          writeSpawnError2(logPrefix, err, emitLogLine);
+          writeSpawnError3(logPrefix, err, emitLogLine);
         } finally {
           if (exited)
             return;
@@ -33241,7 +33905,7 @@ ${deferredResume}` : deferredResume;
           finishExit(exitCode, exitSignal);
         }
       })().catch((err) => {
-        writeSpawnError2(logPrefix, err, emitLogLine);
+        writeSpawnError3(logPrefix, err, emitLogLine);
         if (exited)
           return;
         exited = true;
@@ -33321,6 +33985,7 @@ function initHarnessRegistry() {
   registerHarness(new CursorAgentService);
   registerHarness(new CursorSdkAgentService);
   registerHarness(new ClaudeCodeAgentService);
+  registerHarness(new ClaudeSdkAgentService);
   registerHarness(new CommandCodeAgentService);
   registerHarness(new CopilotAgentService);
   initialized = true;
@@ -33328,6 +33993,7 @@ function initHarnessRegistry() {
 var initialized = false;
 var init_init_registry = __esm(() => {
   init_claude();
+  init_claude_sdk();
   init_commandcode();
   init_copilot();
   init_cursor();
@@ -33415,16 +34081,16 @@ var MACHINE_CONFIG_VERSION = "1";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import * as fs4 from "node:fs/promises";
 import { homedir as homedir3, hostname as hostname2 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function chatroomConfigDir() {
-  return join10(homedir3(), ".chatroom");
+  return join11(homedir3(), ".chatroom");
 }
 async function ensureConfigDir2() {
   const dir = chatroomConfigDir();
   await fs4.mkdir(dir, { recursive: true, mode: 448 });
 }
 function getMachineConfigPath() {
-  return join10(chatroomConfigDir(), MACHINE_FILE);
+  return join11(chatroomConfigDir(), MACHINE_FILE);
 }
 async function loadConfigFile() {
   const configPath = getMachineConfigPath();
@@ -33516,7 +34182,7 @@ var init_storage2 = __esm(() => {
 // src/infrastructure/machine/daemon-state.ts
 import * as fs5 from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function agentKey(chatroomId, role) {
   return `${chatroomId}/${role}`;
 }
@@ -33524,7 +34190,7 @@ async function ensureStateDir() {
   await fs5.mkdir(STATE_DIR, { recursive: true, mode: 448 });
 }
 function stateFilePath(machineId) {
-  return join11(STATE_DIR, `${machineId}.json`);
+  return join12(STATE_DIR, `${machineId}.json`);
 }
 async function loadDaemonState(machineId) {
   const filePath = stateFilePath(machineId);
@@ -33606,8 +34272,8 @@ async function loadEventCursor(machineId) {
 }
 var CHATROOM_DIR2, STATE_DIR, STATE_VERSION = "1";
 var init_daemon_state = __esm(() => {
-  CHATROOM_DIR2 = join11(homedir4(), ".chatroom");
-  STATE_DIR = join11(CHATROOM_DIR2, "machines", "state");
+  CHATROOM_DIR2 = join12(homedir4(), ".chatroom");
+  STATE_DIR = join12(CHATROOM_DIR2, "machines", "state");
 });
 
 // src/infrastructure/machine/index.ts
@@ -34049,9 +34715,9 @@ var init_init = __esm(() => {
 });
 
 // src/tools/output.ts
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function resolveChatroomDir(workingDir) {
-  return join12(workingDir, CHATROOM_DIR3);
+  return join13(workingDir, CHATROOM_DIR3);
 }
 async function ensureChatroomDir(deps, workingDir) {
   const dir = resolveChatroomDir(workingDir);
@@ -34059,7 +34725,7 @@ async function ensureChatroomDir(deps, workingDir) {
   return dir;
 }
 async function ensureGitignore(deps, workingDir) {
-  const gitignorePath = join12(workingDir, ".gitignore");
+  const gitignorePath = join13(workingDir, ".gitignore");
   const entry = CHATROOM_DIR3;
   let content = "";
   try {
@@ -34089,7 +34755,7 @@ function formatOutputTimestamp(date = new Date) {
 function generateOutputPath(workingDir, toolName, extension, date) {
   const timestamp = formatOutputTimestamp(date);
   const filename = `${toolName}-${timestamp}.${extension}`;
-  return join12(resolveChatroomDir(workingDir), filename);
+  return join13(resolveChatroomDir(workingDir), filename);
 }
 var CHATROOM_DIR3 = ".chatroom";
 var init_output = () => {};
@@ -34898,8 +35564,8 @@ var init_index_esm = __esm(() => {
       var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer";
       var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
       if (ENVIRONMENT_IS_NODE) {
-        const { createRequire: createRequire4 } = await import("module");
-        var require3 = createRequire4(import.meta.url);
+        const { createRequire: createRequire5 } = await import("module");
+        var require3 = createRequire5(import.meta.url);
       }
       var thisProgram = "./this.program";
       var _scriptName = import.meta.url;
@@ -40105,7 +40771,7 @@ var require_filesystem = __commonJS((exports, module) => {
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync6 = (path2) => {
+  var readFileSync7 = (path2) => {
     const fd = fs6.openSync(path2, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
     const bytesRead = fs6.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -40128,7 +40794,7 @@ var require_filesystem = __commonJS((exports, module) => {
   module.exports = {
     LDD_PATH,
     SELF_PATH,
-    readFileSync: readFileSync6,
+    readFileSync: readFileSync7,
     readFile: readFile4
   };
 });
@@ -40171,7 +40837,7 @@ var require_elf = __commonJS((exports, module) => {
 var require_detect_libc = __commonJS((exports, module) => {
   var childProcess = __require("child_process");
   var { isLinux, getReport } = require_process();
-  var { LDD_PATH, SELF_PATH, readFile: readFile4, readFileSync: readFileSync6 } = require_filesystem();
+  var { LDD_PATH, SELF_PATH, readFile: readFile4, readFileSync: readFileSync7 } = require_filesystem();
   var { interpreterPath } = require_elf();
   var cachedFamilyInterpreter;
   var cachedFamilyFilesystem;
@@ -40262,7 +40928,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = readFileSync6(LDD_PATH);
+      const lddContent = readFileSync7(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e) {}
     return cachedFamilyFilesystem;
@@ -40285,7 +40951,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyInterpreter = null;
     try {
-      const selfContent = readFileSync6(SELF_PATH);
+      const selfContent = readFileSync7(SELF_PATH);
       const path2 = interpreterPath(selfContent);
       cachedFamilyInterpreter = familyFromInterpreterPath(path2);
     } catch (e) {}
@@ -40347,7 +41013,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = readFileSync6(LDD_PATH);
+      const lddContent = readFileSync7(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -46545,12 +47211,12 @@ var init_pdfium_renderer = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/engines/pdf/pdfjsImporter.js
-import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { dirname as dirname5 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { dirname as dirname6 } from "node:path";
 async function importPdfJs() {
   const pdfUrl = new URL("../../vendor/pdfjs/pdf.mjs", import.meta.url);
   const pdfjs = await import(pdfUrl.href);
-  const dirPath = dirname5(fileURLToPath4(pdfUrl));
+  const dirPath = dirname6(fileURLToPath5(pdfUrl));
   return {
     fn: pdfjs.getDocument,
     dir: dirPath
@@ -67899,7 +68565,7 @@ function applyMarkupTags(markup, text) {
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/processing/gridDebugLogger.js
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 
 class GridDebugLogger {
   config;
@@ -68226,14 +68892,14 @@ class GridDebugLogger {
   flushSync() {
     if (!this.config.outputPath || this.entries.length === 0)
       return;
-    mkdirSync2(dirname6(this.config.outputPath), { recursive: true });
+    mkdirSync2(dirname7(this.config.outputPath), { recursive: true });
     writeFileSync2(this.config.outputPath, this.formatEntries(), "utf-8");
     this.entries = [];
   }
   async flush() {
     if (!this.config.outputPath || this.entries.length === 0)
       return;
-    await mkdir4(dirname6(this.config.outputPath), { recursive: true });
+    await mkdir4(dirname7(this.config.outputPath), { recursive: true });
     await writeFile4(this.config.outputPath, this.formatEntries(), "utf-8");
     this.entries = [];
   }
@@ -76409,6 +77075,22 @@ var init_next_step = __esm(() => {
 // ../../services/backend/prompts/sections/session-vs-chatroom-task.ts
 var init_session_vs_chatroom_task = () => {};
 
+// ../../services/backend/src/domain/entities/harness/claude-sdk.config.ts
+var claudeSdkCapabilities;
+var init_claude_sdk_config = __esm(() => {
+  claudeSdkCapabilities = {
+    runtimeKind: "sdk",
+    supportsDaemonMemoryResume: false,
+    supportsNativeIntegration: true,
+    lifecycle: {
+      turnCompleted: true,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: ["sdk.claude.message"]
+  };
+});
+
 // ../../services/backend/src/domain/entities/harness/claude.config.ts
 var claudeCapabilities;
 var init_claude_config = __esm(() => {
@@ -76572,6 +77254,7 @@ function isNativeHarness(harness) {
 }
 var HARNESS_CAPABILITIES;
 var init_types = __esm(() => {
+  init_claude_sdk_config();
   init_claude_config();
   init_commandcode_config();
   init_copilot_config();
@@ -76583,6 +77266,7 @@ var init_types = __esm(() => {
   init_pi_config();
   HARNESS_CAPABILITIES = {
     claude: claudeCapabilities,
+    "claude-sdk": claudeSdkCapabilities,
     commandcode: commandcodeCapabilities,
     copilot: copilotCapabilities,
     cursor: cursorCapabilities,
@@ -79341,35 +80025,35 @@ function formatTimestamp() {
 import { createHash as createHash2 } from "node:crypto";
 import {
   appendFileSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   renameSync,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function getUrlHash() {
   const url2 = getConvexUrl();
   return createHash2("sha256").update(url2).digest("hex").substring(0, 8);
 }
 function getChildPidsFilePath() {
-  const dir = join14(homedir5(), ".chatroom");
-  return join14(dir, `daemon-children-${getUrlHash()}.pids`);
+  const dir = join15(homedir5(), ".chatroom");
+  return join15(dir, `daemon-children-${getUrlHash()}.pids`);
 }
 function ensureChatroomDir2() {
-  const dir = join14(homedir5(), ".chatroom");
-  if (!existsSync4(dir)) {
+  const dir = join15(homedir5(), ".chatroom");
+  if (!existsSync5(dir)) {
     mkdirSync4(dir, { recursive: true, mode: 448 });
   }
 }
 function readPids() {
   const filePath = getChildPidsFilePath();
-  if (!existsSync4(filePath))
+  if (!existsSync5(filePath))
     return [];
   try {
-    return readFileSync6(filePath, "utf-8").split(`
+    return readFileSync7(filePath, "utf-8").split(`
 `).map((line) => parseInt(line.trim(), 10)).filter((n) => Number.isFinite(n) && n > 0);
   } catch {
     return [];
@@ -79387,9 +80071,9 @@ function trackChildPid(pid) {
 function untrackChildPid(pid) {
   try {
     const filePath = getChildPidsFilePath();
-    if (!existsSync4(filePath))
+    if (!existsSync5(filePath))
       return;
-    const remaining = readFileSync6(filePath, "utf-8").split(`
+    const remaining = readFileSync7(filePath, "utf-8").split(`
 `).filter((line) => {
       const n = parseInt(line.trim(), 10);
       return Number.isFinite(n) && n > 0 && n !== pid;
@@ -79406,7 +80090,7 @@ function untrackChildPid(pid) {
 function clearTrackedPids() {
   try {
     const filePath = getChildPidsFilePath();
-    if (existsSync4(filePath)) {
+    if (existsSync5(filePath)) {
       unlinkSync(filePath);
     }
   } catch {}
@@ -79691,7 +80375,7 @@ var init_log_observer_sync = __esm(() => {
 // src/commands/machine/daemon-start/handlers/process/output-store.ts
 import { appendFile as appendFile2, mkdir as mkdir7, readFile as readFile6, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 
 class TempFileOutputStore {
   state;
@@ -79754,7 +80438,7 @@ function createOutputStore(runId) {
   if (!RUN_ID_RE.test(runId)) {
     throw new Error(`Invalid runId: ${runId}`);
   }
-  const filePath = join15(TEMP_DIR, `${runId}.log`);
+  const filePath = join16(TEMP_DIR, `${runId}.log`);
   return new TempFileOutputStore(filePath);
 }
 async function ensureTempDir() {
@@ -79768,7 +80452,7 @@ async function cleanOrphanTempFiles() {
 var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE, MAX_TAIL_LINES_V2 = 50;
 var init_output_store = __esm(() => {
   TAIL_WINDOW_BYTES = 32 * 1024;
-  TEMP_DIR = join15(tmpdir(), "chatroom-cli", "runs");
+  TEMP_DIR = join16(tmpdir(), "chatroom-cli", "runs");
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
@@ -80863,9 +81547,9 @@ var init_local_actions = __esm(() => {
 
 // src/commands/machine/pid.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function getUrlHash2() {
   const url2 = getConvexUrl();
   return createHash3("sha256").update(url2).digest("hex").substring(0, 8);
@@ -80874,12 +81558,12 @@ function getPidFileName() {
   return `daemon-${getUrlHash2()}.pid`;
 }
 function ensureChatroomDir3() {
-  if (!existsSync5(CHATROOM_DIR4)) {
+  if (!existsSync6(CHATROOM_DIR4)) {
     mkdirSync5(CHATROOM_DIR4, { recursive: true, mode: 448 });
   }
 }
 function getPidFilePath() {
-  return join16(CHATROOM_DIR4, getPidFileName());
+  return join17(CHATROOM_DIR4, getPidFileName());
 }
 function isProcessRunning(pid) {
   try {
@@ -80891,11 +81575,11 @@ function isProcessRunning(pid) {
 }
 function readPid() {
   const pidPath = getPidFilePath();
-  if (!existsSync5(pidPath)) {
+  if (!existsSync6(pidPath)) {
     return null;
   }
   try {
-    const content = readFileSync7(pidPath, "utf-8").trim();
+    const content = readFileSync8(pidPath, "utf-8").trim();
     const pid = parseInt(content, 10);
     if (isNaN(pid) || pid <= 0) {
       return null;
@@ -80913,7 +81597,7 @@ function writePid() {
 function removePid() {
   const pidPath = getPidFilePath();
   try {
-    if (existsSync5(pidPath)) {
+    if (existsSync6(pidPath)) {
       unlinkSync2(pidPath);
     }
   } catch {}
@@ -80976,7 +81660,7 @@ function releaseLock() {
 var CHATROOM_DIR4, LOCK_RETRY_INTERVAL_MS = 500, LOCK_RETRY_MAX_WAIT_MS = 15000;
 var init_pid = __esm(() => {
   init_client2();
-  CHATROOM_DIR4 = join16(homedir6(), ".chatroom");
+  CHATROOM_DIR4 = join17(homedir6(), ".chatroom");
 });
 
 // src/commands/machine/daemon-start/workspace-cache.ts
@@ -81889,16 +82573,16 @@ var init_jsonc = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
 import { readFile as readFile7, readdir, stat as stat2 } from "node:fs/promises";
-import { join as join17, basename, resolve as resolve3 } from "node:path";
+import { join as join18, basename, resolve as resolve3 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
-  const parentDir = join17(rootDir, cleaned.slice(0, -2));
+  const parentDir = join18(rootDir, cleaned.slice(0, -2));
   try {
     const entries2 = await readdir(parentDir, { withFileTypes: true });
     const dirs = [];
     for (const entry of entries2) {
       if (!entry.isDirectory())
         continue;
-      const dirPath = join17(parentDir, entry.name);
+      const dirPath = join18(parentDir, entry.name);
       if (resolve3(dirPath).startsWith(resolve3(rootDir))) {
         dirs.push(dirPath);
       }
@@ -81909,7 +82593,7 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
   }
 }
 async function resolveLiteralPath(rootDir, cleaned) {
-  const dir = join17(rootDir, cleaned);
+  const dir = join18(rootDir, cleaned);
   try {
     if (!resolve3(dir).startsWith(resolve3(rootDir)))
       return [];
@@ -81929,7 +82613,7 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile7(join17(dir, "package.json"), "utf-8");
+    const content = await readFile7(join18(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
       name: pkg.name || basename(dir),
@@ -81941,7 +82625,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join17(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile7(join18(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -81968,7 +82652,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join17(rootDir, "package.json"), "utf-8");
+    const content = await readFile7(join18(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -82017,11 +82701,11 @@ var init_workspace_resolver = () => {};
 
 // src/infrastructure/services/workspace/command-discovery.ts
 import { access as access4, readFile as readFile8 } from "node:fs/promises";
-import { join as join18, relative, basename as basename2 } from "node:path";
+import { join as join19, relative, basename as basename2 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file, manager } of LOCKFILE_MAP) {
     try {
-      await access4(join18(workingDir, file));
+      await access4(join19(workingDir, file));
       return manager;
     } catch {}
   }
@@ -82090,7 +82774,7 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
   let rootPackageName = basename2(workingDir);
-  const pkg = await readJsonFile(join18(workingDir, "package.json"), "root package.json");
+  const pkg = await readJsonFile(join19(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
   if (pkg.name)
@@ -82106,7 +82790,7 @@ async function readRootPackageJson(workingDir, pm, scriptPrefix) {
 }
 async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
   const turboTaskNames = [];
-  const turbo = await readJsonFile(join18(workingDir, "turbo.json"), "turbo.json");
+  const turbo = await readJsonFile(join19(workingDir, "turbo.json"), "turbo.json");
   if (!turbo?.tasks || typeof turbo.tasks !== "object")
     return turboTaskNames;
   for (const taskName of Object.keys(turbo.tasks)) {
@@ -83110,16 +83794,16 @@ var SEND_TIMEOUT_MS2 = 60000, RUN_WAIT_TIMEOUT_MS2 = 3600000;
 var init_cursor_session = () => {};
 
 // src/infrastructure/harnesses/cursor-sdk/cursor-harness.ts
-async function loadSdk3() {
-  if (_sdkCache3)
-    return _sdkCache3;
-  if (_sdkLoadError3)
-    throw _sdkLoadError3;
+async function loadSdk4() {
+  if (_sdkCache4)
+    return _sdkCache4;
+  if (_sdkLoadError4)
+    throw _sdkLoadError4;
   try {
-    _sdkCache3 = await importBundledCursorSdk();
-    return _sdkCache3;
+    _sdkCache4 = await importBundledCursorSdk();
+    return _sdkCache4;
   } catch (err) {
-    _sdkLoadError3 = err;
+    _sdkLoadError4 = err;
     throw err;
   }
 }
@@ -83154,7 +83838,7 @@ class CursorSdkHarness {
     const apiKey = process.env.CURSOR_API_KEY?.trim();
     if (!apiKey)
       return [];
-    const { Cursor } = await loadSdk3();
+    const { Cursor } = await loadSdk4();
     const listed = await withTimeout(Cursor.models.list({ apiKey }), MODELS_LIST_TIMEOUT_MS2, "Cursor.models.list");
     const modelIds = normalizeCursorSdkListedModels(listed.map((m) => m.id).filter((id3) => id3.length > 0));
     return [
@@ -83172,7 +83856,7 @@ class CursorSdkHarness {
     if (!apiKey)
       throw new Error("CURSOR_API_KEY is not set");
     const modelId = resolveCursorSdkModel(config3.model ?? DEFAULT_MODEL2);
-    const { Agent } = await loadSdk3();
+    const { Agent } = await loadSdk4();
     const agent = await withTimeout(Agent.create({
       apiKey,
       model: { id: modelId },
@@ -83196,7 +83880,7 @@ class CursorSdkHarness {
     const apiKey = process.env.CURSOR_API_KEY?.trim();
     if (!apiKey)
       throw new Error("CURSOR_API_KEY is not set");
-    const { Agent } = await loadSdk3();
+    const { Agent } = await loadSdk4();
     const agent = await withTimeout(Agent.resume(sessionId, {
       apiKey,
       model: { id: DEFAULT_MODEL2 },
@@ -83226,9 +83910,9 @@ class CursorSdkHarness {
     this.sessions.clear();
   }
 }
-var DEFAULT_MODEL2 = "composer-2.5", MODELS_LIST_TIMEOUT_MS2 = 60000, AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache3, _sdkLoadError3, startCursorSdkHarness = async (config3) => {
+var DEFAULT_MODEL2 = "composer-2.5", MODELS_LIST_TIMEOUT_MS2 = 60000, AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache4, _sdkLoadError4, startCursorSdkHarness = async (config3) => {
   try {
-    await loadSdk3();
+    await loadSdk4();
   } catch (err) {
     throw new Error(`cursor-sdk unavailable: ${formatCursorSdkLoadError(err)}`);
   }
@@ -83893,16 +84577,16 @@ var PROMPT_TIMEOUT_MS2 = 3600000;
 var init_pi_session = () => {};
 
 // src/infrastructure/harnesses/pi-sdk/pi-harness.ts
-async function loadSdk4() {
-  if (_sdkCache4)
-    return _sdkCache4;
-  if (_sdkLoadError4)
-    throw _sdkLoadError4;
+async function loadSdk5() {
+  if (_sdkCache5)
+    return _sdkCache5;
+  if (_sdkLoadError5)
+    throw _sdkLoadError5;
   try {
-    _sdkCache4 = await importBundledPiSdk();
-    return _sdkCache4;
+    _sdkCache5 = await importBundledPiSdk();
+    return _sdkCache5;
   } catch (err) {
-    _sdkLoadError4 = err;
+    _sdkLoadError5 = err;
     throw err;
   }
 }
@@ -83974,7 +84658,7 @@ class PiSdkHarness {
     const existing = this.sessions.get(sessionId);
     if (existing)
       return existing;
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk4();
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk5();
     const sessions = await SessionManager.list(this.cwd, getPiSessionDir(this.cwd));
     const match17 = sessions.find((s) => s.id === sessionId);
     if (!match17) {
@@ -84022,7 +84706,7 @@ class PiSdkHarness {
     this.sessions.clear();
   }
   async createAgentSession(systemPrompt, model) {
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk4();
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk5();
     const resolvedModel = resolveModel2(this.modelRegistry, model ?? DEFAULT_MODEL3);
     if (!resolvedModel) {
       throw new Error("No Pi model available — configure provider credentials in ~/.pi/agent/auth.json");
@@ -84044,9 +84728,9 @@ class PiSdkHarness {
     return session2;
   }
 }
-var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL3 = "opencode/big-pickle", _sdkCache4, _sdkLoadError4, startPiSdkHarness = async (config3) => {
+var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL3 = "opencode/big-pickle", _sdkCache5, _sdkLoadError5, startPiSdkHarness = async (config3) => {
   try {
-    const { AuthStorage, ModelRegistry } = await loadSdk4();
+    const { AuthStorage, ModelRegistry } = await loadSdk5();
     const authStorage = AuthStorage.create();
     const modelRegistry = ModelRegistry.create(authStorage);
     if (modelRegistry.getAvailable().length === 0) {
@@ -106204,4 +106888,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=2E6B4710975E536E64756E2164756E21
+//# debugId=B4F2E215BBCC825564756E2164756E21