chatroom-cli 1.58.5 → 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";
 
@@ -28989,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) {
@@ -29059,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";
@@ -29087,144 +29828,113 @@ function closeCursorAgentOnFailure(agent, session2, exitCode, force = false) {
 }
 
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-sdk-stream-adapter.ts
-class CursorSdkStreamAdapter {
-  logPrefix;
-  emitLogLine;
-  agentEndCallbacks = [];
-  outputCallbacks = [];
-  agentEndEmitted = false;
-  textBuffer = "";
-  constructor(logPrefix, emitLogLine) {
-    this.logPrefix = logPrefix;
-    this.emitLogLine = emitLogLine;
-  }
-  onAgentEnd(cb) {
-    this.agentEndCallbacks.push(cb);
-  }
-  onOutput(cb) {
-    this.outputCallbacks.push(cb);
-  }
-  handleMessage(message) {
-    this.notifyOutput();
-    switch (message.type) {
-      case "assistant":
-        this.handleAssistant(message);
-        break;
-      case "tool_call": {
-        this.flushText();
-        const bashCmd = extractBashCommandFromToolInput(message.name, message.args);
-        if (bashCmd !== null) {
-          this.writeLine(formatAgentLogLine(this.logPrefix, BASH_TOOL_KIND, formatBashRunningPayload(bashCmd)));
+var CursorSdkStreamAdapter;
+var init_cursor_sdk_stream_adapter = __esm(() => {
+  init_native_stream_adapter_base();
+  CursorSdkStreamAdapter = class CursorSdkStreamAdapter extends NativeStreamAdapterBase {
+    textBuffer = "";
+    handleMessage(message) {
+      this.notifyOutput();
+      switch (message.type) {
+        case "assistant":
+          this.handleAssistant(message);
+          break;
+        case "tool_call": {
+          this.flushText();
+          const bashCmd = extractBashCommandFromToolInput(message.name, message.args);
+          if (bashCmd !== null) {
+            this.writeLine(formatAgentLogLine(this.logPrefix, BASH_TOOL_KIND, formatBashRunningPayload(bashCmd)));
+            break;
+          }
+          this.writeLine(formatAgentLogLine(this.logPrefix, `tool: ${message.call_id} ${message.name} ${JSON.stringify({ status: message.status, args: message.args })}`));
           break;
         }
-        this.writeLine(formatAgentLogLine(this.logPrefix, `tool: ${message.call_id} ${message.name} ${JSON.stringify({ status: message.status, args: message.args })}`));
-        break;
+        case "status":
+          this.writeLine(formatAgentLogLine(this.logPrefix, `status: ${message.status}`));
+          break;
+        case "thinking":
+          this.writeLine(formatAgentLogLine(this.logPrefix, "thinking", message.text));
+          break;
+        case "system":
+          if (message.subtype === "init") {
+            this.writeLine(formatAgentLogLine(this.logPrefix, "system: init"));
+          }
+          break;
+        default:
+          break;
       }
-      case "status":
-        this.writeLine(formatAgentLogLine(this.logPrefix, `status: ${message.status}`));
-        break;
-      case "thinking":
-        this.writeLine(formatAgentLogLine(this.logPrefix, "thinking", message.text));
-        break;
-      case "system":
-        if (message.subtype === "init") {
-          this.writeLine(formatAgentLogLine(this.logPrefix, "system: init"));
-        }
-        break;
-      default:
-        break;
     }
-  }
-  flushPendingOutput() {
-    this.flushText();
-  }
-  finish() {
-    this.flushText();
-    this.emitAgentEnd();
-  }
-  handleAssistant(message) {
-    for (const block of message.message.content) {
-      if (block.type === "text") {
-        this.textBuffer += block.text;
-        if (this.textBuffer.includes(`
+    flushPendingOutput() {
+      this.flushText();
+    }
+    finish() {
+      this.flushText();
+      this.emitAgentEnd();
+    }
+    handleAssistant(message) {
+      for (const block of message.message.content) {
+        if (block.type === "text") {
+          this.textBuffer += block.text;
+          this.assistantTextCapture.captureAssistantText(block.text);
+          if (this.textBuffer.includes(`
 `)) {
-          this.flushText();
+            this.flushText();
+          }
         }
       }
     }
-  }
-  flushText() {
-    if (!this.textBuffer)
-      return;
-    for (const line of this.textBuffer.split(`
+    flushText() {
+      if (!this.textBuffer)
+        return;
+      for (const line of this.textBuffer.split(`
 `)) {
-      if (line)
-        this.writeLine(formatAgentLogLine(this.logPrefix, "text", line));
+        if (line)
+          this.writeLine(formatAgentLogLine(this.logPrefix, "text", line));
+      }
+      this.textBuffer = "";
     }
-    this.textBuffer = "";
-  }
-  emitAgentEnd() {
-    if (this.agentEndEmitted)
-      return;
-    this.agentEndEmitted = true;
-    this.flushText();
-    this.writeLine(formatAgentLogLine(this.logPrefix, "agent_end"));
-    for (const cb of this.agentEndCallbacks)
-      cb();
-  }
-  writeLine(formatted) {
-    process.stdout.write(`${formatted}
+    emitAgentEnd() {
+      if (this.agentEndEmitted)
+        return;
+      this.agentEndEmitted = true;
+      this.flushText();
+      this.writeLine(formatAgentLogLine(this.logPrefix, "agent_end"));
+      for (const cb of this.agentEndCallbacks)
+        cb();
+    }
+    writeLine(formatted) {
+      process.stdout.write(`${formatted}
 `);
-    this.emitLogLine?.(formatted);
-  }
-  notifyOutput() {
-    for (const cb of this.outputCallbacks)
-      cb();
-  }
-}
-var init_cursor_sdk_stream_adapter = () => {};
-
-// 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);
-  }
-}
+      this.emitLogLine?.(formatted);
+    }
+  };
+});
 
 // 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;
@@ -29252,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();
@@ -29278,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)}`);
@@ -29292,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 {
@@ -29305,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);
@@ -29382,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 },
@@ -29453,6 +30163,7 @@ ${options.prompt}`;
       const outputCallbacks = [];
       const agentEndCallbacks = [];
       const logLineCallbacks = [];
+      const assistantTextCallbacks = [];
       const emitLogLine = (line) => {
         for (const cb of logLineCallbacks)
           cb(line);
@@ -29477,6 +30188,7 @@ ${options.prompt}`;
         finishExit,
         outputCallbacks,
         agentEndCallbacks,
+        assistantTextCallbacks,
         emitLogLine
       });
       return {
@@ -29497,6 +30209,9 @@ ${options.prompt}`;
         },
         onLogLine: (cb) => {
           logLineCallbacks.push(cb);
+        },
+        onAssistantText: (cb) => {
+          assistantTextCallbacks.push(cb);
         }
       };
     }
@@ -29512,6 +30227,7 @@ ${options.prompt}`;
         entry,
         outputCallbacks,
         agentEndCallbacks,
+        assistantTextCallbacks,
         emitLogLine
       } = args2;
       let exited = false;
@@ -29526,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;
@@ -29549,14 +30265,12 @@ ${deferredResume}` : deferredResume;
               session2.run = run3;
               isFirstTurn = false;
               const adapter = new CursorSdkStreamAdapter(logPrefix, emitLogLine);
-              adapter.onOutput(() => {
-                entry.lastOutputAt = Date.now();
-                for (const cb of outputCallbacks)
-                  cb();
-              });
-              adapter.onAgentEnd(() => {
-                for (const cb of agentEndCallbacks)
-                  cb();
+              wireNativeStreamAdapter({
+                adapter,
+                assistantTextCallbacks,
+                outputCallbacks,
+                agentEndCallbacks,
+                entry
               });
               try {
                 for await (const message of run3.stream()) {
@@ -29566,7 +30280,7 @@ ${deferredResume}` : deferredResume;
                 }
               } catch (streamErr) {
                 exitCode = 1;
-                writeSpawnError(logPrefix, streamErr, emitLogLine);
+                writeSpawnError2(logPrefix, streamErr, emitLogLine);
                 break;
               }
               if (session2.aborted) {
@@ -29579,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();
@@ -29596,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;
@@ -29614,7 +30328,7 @@ ${deferredResume}` : deferredResume;
           finishExit(exitCode, exitSignal);
         }
       })().catch((err) => {
-        writeSpawnError(logPrefix, err, emitLogLine);
+        writeSpawnError2(logPrefix, err, emitLogLine);
         if (exited)
           return;
         exited = true;
@@ -29644,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,
@@ -31920,8 +32634,10 @@ function startSessionEventForwarder(client4, options) {
   }
   async function handleTextPartUpdate(props, part) {
     const chunk2 = resolvePartContent(props?.delta, part.text);
-    if (chunk2)
+    if (chunk2) {
+      options.onAssistantText?.(chunk2);
       logLine(target, "text", chunk2);
+    }
   }
   async function handleReasoningPartUpdate(props, part) {
     const chunk2 = resolvePartContent(props?.delta, part.text);
@@ -32088,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));
@@ -32187,6 +32903,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
   init_terminal_provider_error();
   OpenCodeSdkAgentService = class OpenCodeSdkAgentService extends OpenCodeBinaryAgentService {
     agentEndCallbacksByPid = new Map;
+    assistantTextCallbacksByPid = new Map;
     id = "opencode-sdk";
     displayName = "OpenCode (SDK)";
     listModelsHarnessId = "opencode-sdk";
@@ -32312,6 +33029,9 @@ var init_opencode_sdk_agent_service = __esm(() => {
       const entry = this.registerProcess(pid, context5);
       if (forwarder)
         this.forwarders.set(pid, forwarder);
+      if (args2.assistantTextCallbacks) {
+        this.assistantTextCallbacksByPid.set(pid, args2.assistantTextCallbacks);
+      }
       const outputCallbacks = args2.outputCallbacks ?? [];
       this.wireChildOutput(childProcess, pid, entry, emitLogLine, outputCallbacks);
       return {
@@ -32330,6 +33050,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
             }
             this.sessionStore.remove(sessionId);
             this.agentEndCallbacksByPid.delete(pid);
+            this.assistantTextCallbacksByPid.delete(pid);
             this.deleteProcess(pid);
             cb({ code: code2, signal, context: context5 });
           });
@@ -32345,6 +33066,11 @@ var init_opencode_sdk_agent_service = __esm(() => {
         },
         onLogLine: (cb) => {
           logLineCallbacks.push(cb);
+        },
+        onAssistantText: (cb) => {
+          const callbacks = this.assistantTextCallbacksByPid.get(pid) ?? args2.assistantTextCallbacks ?? [];
+          callbacks.push(cb);
+          this.assistantTextCallbacksByPid.set(pid, callbacks);
         }
       };
     }
@@ -32358,6 +33084,16 @@ var init_opencode_sdk_agent_service = __esm(() => {
         }
       };
     }
+    createAssistantTextEmitter() {
+      const assistantTextCallbacks = [];
+      return {
+        assistantTextCallbacks,
+        emitAssistantText: (text) => {
+          for (const cb of assistantTextCallbacks)
+            cb(text);
+        }
+      };
+    }
     async startServeAndClient(workingDir, resolvedConvexUrl) {
       const childProcess = this.spawnServeProcess(workingDir, resolvedConvexUrl);
       const pid = childProcess.pid;
@@ -32406,7 +33142,12 @@ var init_opencode_sdk_agent_service = __esm(() => {
       const newSessionId2 = sessionCreateResult.data.id;
       const forwarder = startSessionEventForwarder(client4, {
         sessionId: newSessionId2,
-        role: args2.context.role
+        role: args2.context.role,
+        onAssistantText: (text) => {
+          const callbacks2 = this.assistantTextCallbacksByPid.get(args2.pid) ?? [];
+          for (const cb of callbacks2)
+            cb(text);
+        }
       });
       const callbacks = this.agentEndCallbacksByPid.get(args2.pid) ?? [];
       for (const cb of callbacks) {
@@ -32442,6 +33183,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
       const { childProcess, pid, baseUrl, client: client4 } = await this.startServeAndClient(workingDir, options.resolvedConvexUrl);
       let forwarder;
       const { logLineCallbacks, emitLogLine } = this.createLogLineEmitter();
+      const { assistantTextCallbacks, emitAssistantText } = this.createAssistantTextEmitter();
       const outputCallbacks = [];
       try {
         const sessionInfo = await withTimeout(client4.session.get({ path: { id: sessionId } }), SESSION_GET_TIMEOUT_MS, "session.get");
@@ -32452,6 +33194,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
           sessionId,
           role: context5.role,
           onLogLine: emitLogLine,
+          onAssistantText: emitAssistantText,
           onActivity: () => {
             for (const cb of outputCallbacks)
               cb();
@@ -32483,6 +33226,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
         model: modelForSession,
         workingDir,
         logLineCallbacks,
+        assistantTextCallbacks,
         outputCallbacks
       });
     }
@@ -32495,6 +33239,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
       let agentName;
       let deferredSystemPrompt;
       const { logLineCallbacks, emitLogLine } = this.createLogLineEmitter();
+      const { assistantTextCallbacks, emitAssistantText } = this.createAssistantTextEmitter();
       const outputCallbacks = [];
       try {
         const sessionCreateResult = await withTimeout(client4.session.create({ body: {} }), SESSION_CREATE_TIMEOUT_MS, "session.create");
@@ -32506,6 +33251,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
           sessionId,
           role: context5.role,
           onLogLine: emitLogLine,
+          onAssistantText: emitAssistantText,
           onActivity: () => {
             for (const cb of outputCallbacks)
               cb();
@@ -32545,6 +33291,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
         model,
         workingDir: options.workingDir,
         logLineCallbacks,
+        assistantTextCallbacks,
         deferredSystemPrompt,
         outputCallbacks
       });
@@ -32611,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;
 }
@@ -32659,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) {
@@ -32692,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";
@@ -32704,148 +33451,133 @@ var init_pi_sdk_package = __esm(() => {
 });
 
 // src/infrastructure/services/remote-agents/pi-sdk/pi-sdk-stream-adapter.ts
-class PiSdkStreamAdapter {
-  logPrefix;
-  emitLogLine;
-  agentEndCallbacks = [];
-  outputCallbacks = [];
-  agentEndEmitted = false;
-  textBuffer = "";
-  thinkingBuffer = "";
-  constructor(logPrefix, emitLogLine) {
-    this.logPrefix = logPrefix;
-    this.emitLogLine = emitLogLine;
-  }
-  onAgentEnd(cb) {
-    this.agentEndCallbacks.push(cb);
-  }
-  onOutput(cb) {
-    this.outputCallbacks.push(cb);
-  }
-  handleEvent(event) {
-    this.notifyOutput();
-    switch (event.type) {
-      case "message_update": {
-        const assistantEvent = event.assistantMessageEvent;
-        if (assistantEvent.type === "text_delta") {
-          this.appendText(assistantEvent.delta);
-        } else if (assistantEvent.type === "thinking_delta") {
-          this.appendThinking(assistantEvent.delta);
+var PiSdkStreamAdapter;
+var init_pi_sdk_stream_adapter = __esm(() => {
+  init_native_stream_adapter_base();
+  PiSdkStreamAdapter = class PiSdkStreamAdapter extends NativeStreamAdapterBase {
+    textBuffer = "";
+    thinkingBuffer = "";
+    handleEvent(event) {
+      this.notifyOutput();
+      switch (event.type) {
+        case "message_update": {
+          const assistantEvent = event.assistantMessageEvent;
+          if (assistantEvent.type === "text_delta") {
+            this.appendText(assistantEvent.delta);
+          } else if (assistantEvent.type === "thinking_delta") {
+            this.appendThinking(assistantEvent.delta);
+          }
+          break;
         }
-        break;
-      }
-      case "tool_execution_start": {
-        this.flushText();
-        this.flushThinking();
-        const bashCmd = resolveBashCommandForLog(event.toolName, event.args);
-        if (bashCmd !== null) {
-          this.writeLine(formatAgentLogLine(this.logPrefix, BASH_TOOL_KIND, formatBashRunningPayload(bashCmd)));
+        case "tool_execution_start": {
+          this.flushText();
+          this.flushThinking();
+          const bashCmd = resolveBashCommandForLog(event.toolName, event.args);
+          if (bashCmd !== null) {
+            this.writeLine(formatAgentLogLine(this.logPrefix, BASH_TOOL_KIND, formatBashRunningPayload(bashCmd)));
+            break;
+          }
+          const argsStr = event.args != null ? ` args: ${JSON.stringify(event.args)}` : "";
+          this.writeLine(formatAgentLogLine(this.logPrefix, "tool", `${event.toolName}${argsStr}`));
           break;
         }
-        const argsStr = event.args != null ? ` args: ${JSON.stringify(event.args)}` : "";
-        this.writeLine(formatAgentLogLine(this.logPrefix, "tool", `${event.toolName}${argsStr}`));
-        break;
-      }
-      case "tool_execution_end": {
-        const resultStr = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
-        this.writeLine(formatAgentLogLine(this.logPrefix, "tool_result", `${event.toolName} result: ${resultStr}`));
-        break;
+        case "tool_execution_end": {
+          const resultStr = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+          this.writeLine(formatAgentLogLine(this.logPrefix, "tool_result", `${event.toolName} result: ${resultStr}`));
+          break;
+        }
+        case "agent_end":
+          this.emitAgentEnd();
+          break;
+        default:
+          break;
       }
-      case "agent_end":
-        this.emitAgentEnd();
-        break;
-      default:
-        break;
     }
-  }
-  finish() {
-    this.flushText();
-    this.flushThinking();
-    this.emitAgentEnd();
-  }
-  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;
-    if (this.textBuffer.includes(`
+    finish() {
+      this.flushText();
+      this.flushThinking();
+      this.emitAgentEnd();
+    }
+    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();
-  }
-  appendThinking(delta) {
-    this.flushText();
-    this.thinkingBuffer += delta;
-    if (this.thinkingBuffer.includes(`
+      this.thinkingBuffer += delta;
+      if (this.thinkingBuffer.includes(`
 `))
-      this.flushThinking();
-  }
-  flushText() {
-    if (!this.textBuffer)
-      return;
-    const lines = this.textBuffer.split(`
+        this.flushThinking();
+    }
+    flushText() {
+      if (!this.textBuffer)
+        return;
+      const lines = this.textBuffer.split(`
 `);
-    const remaining = this.textBuffer.endsWith(`
+      const remaining = this.textBuffer.endsWith(`
 `) ? "" : lines.pop() ?? "";
-    for (const line of lines) {
-      if (line.length > 0) {
-        this.writeLine(formatAgentLogLine(this.logPrefix, "text", line));
+      for (const line of lines) {
+        if (line.length > 0) {
+          this.writeLine(formatAgentLogLine(this.logPrefix, "text", line));
+        }
       }
+      this.textBuffer = remaining;
     }
-    this.textBuffer = remaining;
-  }
-  flushThinking() {
-    if (!this.thinkingBuffer)
-      return;
-    const lines = this.thinkingBuffer.split(`
+    flushThinking() {
+      if (!this.thinkingBuffer)
+        return;
+      const lines = this.thinkingBuffer.split(`
 `);
-    const remaining = this.thinkingBuffer.endsWith(`
+      const remaining = this.thinkingBuffer.endsWith(`
 `) ? "" : lines.pop() ?? "";
-    for (const line of lines) {
-      if (line.length > 0) {
-        this.writeLine(formatAgentLogLine(this.logPrefix, "thinking", line));
+      for (const line of lines) {
+        if (line.length > 0) {
+          this.writeLine(formatAgentLogLine(this.logPrefix, "thinking", line));
+        }
       }
+      this.thinkingBuffer = remaining;
     }
-    this.thinkingBuffer = remaining;
-  }
-  notifyOutput() {
-    for (const cb of this.outputCallbacks)
-      cb();
-  }
-  writeLine(line) {
-    process.stderr.write(`${line}
+    writeLine(line) {
+      process.stderr.write(`${line}
 `);
-    this.emitLogLine?.(line);
-  }
-}
-var init_pi_sdk_stream_adapter = () => {};
+      this.emitLogLine?.(line);
+    }
+  };
+});
 
 // 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;
@@ -32882,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();
@@ -32907,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;
@@ -32923,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 {
@@ -32933,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}`);
@@ -32998,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);
@@ -33045,6 +33777,7 @@ var init_pi_sdk_agent_service = __esm(() => {
       const outputCallbacks = [];
       const agentEndCallbacks = [];
       const logLineCallbacks = [];
+      const assistantTextCallbacks = [];
       const emitLogLine = (line) => {
         for (const cb of logLineCallbacks)
           cb(line);
@@ -33066,6 +33799,7 @@ var init_pi_sdk_agent_service = __esm(() => {
         finishExit,
         outputCallbacks,
         agentEndCallbacks,
+        assistantTextCallbacks,
         emitLogLine
       });
       return {
@@ -33082,6 +33816,9 @@ var init_pi_sdk_agent_service = __esm(() => {
         },
         onLogLine: (cb) => {
           logLineCallbacks.push(cb);
+        },
+        onAssistantText: (cb) => {
+          assistantTextCallbacks.push(cb);
         }
       };
     }
@@ -33095,6 +33832,7 @@ var init_pi_sdk_agent_service = __esm(() => {
         entry,
         outputCallbacks,
         agentEndCallbacks,
+        assistantTextCallbacks,
         emitLogLine
       } = args2;
       let exited = false;
@@ -33108,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;
@@ -33122,14 +33860,12 @@ ${deferredResume}` : deferredResume;
                 prependSystemOnNextResume = false;
               }
               const adapter = new PiSdkStreamAdapter(logPrefix, emitLogLine);
-              adapter.onOutput(() => {
-                entry.lastOutputAt = Date.now();
-                for (const cb of outputCallbacks)
-                  cb();
-              });
-              adapter.onAgentEnd(() => {
-                for (const cb of agentEndCallbacks)
-                  cb();
+              wireNativeStreamAdapter({
+                adapter,
+                assistantTextCallbacks,
+                outputCallbacks,
+                agentEndCallbacks,
+                entry
               });
               const onSessionEvent = (event) => {
                 if (sdkSession.aborted)
@@ -33148,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;
@@ -33169,7 +33905,7 @@ ${deferredResume}` : deferredResume;
           finishExit(exitCode, exitSignal);
         }
       })().catch((err) => {
-        writeSpawnError2(logPrefix, err, emitLogLine);
+        writeSpawnError3(logPrefix, err, emitLogLine);
         if (exited)
           return;
         exited = true;
@@ -33249,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;
@@ -33256,6 +33993,7 @@ function initHarnessRegistry() {
 var initialized = false;
 var init_init_registry = __esm(() => {
   init_claude();
+  init_claude_sdk();
   init_commandcode();
   init_copilot();
   init_cursor();
@@ -33343,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();
@@ -33444,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}`;
 }
@@ -33452,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);
@@ -33534,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
@@ -33977,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);
@@ -33987,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 {
@@ -34017,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 = () => {};
@@ -34826,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;
@@ -40033,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);
@@ -40056,7 +40794,7 @@ var require_filesystem = __commonJS((exports, module) => {
   module.exports = {
     LDD_PATH,
     SELF_PATH,
-    readFileSync: readFileSync6,
+    readFileSync: readFileSync7,
     readFile: readFile4
   };
 });
@@ -40099,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;
@@ -40190,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;
@@ -40213,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) {}
@@ -40275,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];
@@ -46473,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
@@ -67827,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;
@@ -68154,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 = [];
   }
@@ -75581,10 +76319,7 @@ Put your **complete** deliverable in the handoff message — not in session text
 }
 
 // ../../services/backend/prompts/utils/code-change-verification.ts
-var CODE_CHANGE_VERIFICATION_COMMAND = "pnpm typecheck && pnpm test", CODE_CHANGE_VERIFICATION_CONFIRMATION;
-var init_code_change_verification = __esm(() => {
-  CODE_CHANGE_VERIFICATION_CONFIRMATION = `- [ ] I confirm that I have run \`${CODE_CHANGE_VERIFICATION_COMMAND}\` (only required if code changes were made)`;
-});
+var CODE_CHANGE_VERIFICATION_CONFIRMATION = "- [ ] I confirm that I have run typecheck and tests for the project (only required if code changes were made)";
 
 // ../../services/backend/prompts/cli/context/read.ts
 function contextReadCommand(params = {}) {
@@ -75663,7 +76398,6 @@ ${CODE_CHANGE_VERIFICATION_CONFIRMATION}
 \`\`\``;
 }
 var init_builder_to_planner = __esm(() => {
-  init_code_change_verification();
   init_context_disclosure();
   init_role_guidance_disclosure();
 });
@@ -75820,7 +76554,6 @@ ${CODE_CHANGE_VERIFICATION_CONFIRMATION}
 \`\`\``;
 }
 var init_planner_to_user = __esm(() => {
-  init_code_change_verification();
   init_context_disclosure();
   init_role_guidance_disclosure();
 });
@@ -75919,7 +76652,6 @@ ${CODE_CHANGE_VERIFICATION_CONFIRMATION}
 \`\`\``;
 }
 var init_solo_to_user = __esm(() => {
-  init_code_change_verification();
   init_context_disclosure();
   init_role_guidance_disclosure();
 });
@@ -76155,8 +76887,6 @@ var init_commands_reference = __esm(() => {
   init_command2();
   init_utils3();
 });
-// ../../services/backend/src/domain/usecase/skills/modules/attachments/index.ts
-var init_attachments = () => {};
 
 // ../../services/backend/prompts/cli/backlog/command.ts
 var init_command3 = __esm(() => {
@@ -76173,7 +76903,6 @@ var init_code_review = () => {};
 
 // ../../services/backend/src/domain/usecase/skills/registry.ts
 var init_registry3 = __esm(() => {
-  init_attachments();
   init_backlog();
   init_code_review();
 });
@@ -76203,8 +76932,7 @@ var init_glossary = __esm(() => {
     },
     {
       term: "attachments",
-      definition: "Message attachment types (task, backlog, message, snippet) and their compose, delivery, and task-read paths. " + "Use when adding or changing attachment UI, delivery XML, or agent-facing attachment formats.",
-      linkedSkillId: "attachments"
+      definition: "Message attachment types (task, backlog, message, snippet) delivered in agent prompts as XML when users attach context to messages."
     },
     {
       term: "code-review",
@@ -76347,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(() => {
@@ -76510,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();
@@ -76521,6 +77266,7 @@ var init_types = __esm(() => {
   init_pi_config();
   HARNESS_CAPABILITIES = {
     claude: claudeCapabilities,
+    "claude-sdk": claudeSdkCapabilities,
     commandcode: commandcodeCapabilities,
     copilot: copilotCapabilities,
     cursor: cursorCapabilities,
@@ -76599,15 +77345,6 @@ function handleHandoffError(err) {
     } else if (err._tag === "InvalidChatroomId") {
       formatChatroomIdError(err.id);
       process.exit(1);
-    } else if (err._tag === "ArtifactsInvalid") {
-      formatError("One or more artifacts not found", [
-        "Please create artifacts first:",
-        `chatroom artifact create <chatroom-id> --from-file=... --filename=...`
-      ]);
-      process.exit(1);
-    } else if (err._tag === "ArtifactValidationFailed") {
-      formatError("Failed to validate artifacts", [String(err.cause)]);
-      process.exit(1);
     } else if (err._tag === "HandoffFailed") {
       console.error(`
 ❌ ERROR: Handoff failed`);
@@ -76670,7 +77407,7 @@ async function handoff(chatroomId, options, deps) {
 var handoffEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const session2 = yield* SessionService;
   const backend2 = yield* BackendService;
-  const { role, message, nextRole, attachedArtifactIds = [] } = options;
+  const { role, message, nextRole } = options;
   const sessionId = yield* requireSessionIdEffect((a) => ({
     _tag: "NotAuthenticated",
     convexUrl: a.convexUrl,
@@ -76680,24 +77417,12 @@ var handoffEffect = (chatroomId, options) => exports_Effect.gen(function* () {
     _tag: "InvalidChatroomId",
     id: id3
   }));
-  if (attachedArtifactIds.length > 0) {
-    const areValid = yield* backend2.query(api.artifacts.validateArtifactIds, {
-      sessionId,
-      artifactIds: attachedArtifactIds
-    }).pipe(exports_Effect.mapError((cause3) => ({ _tag: "ArtifactValidationFailed", cause: cause3 })));
-    if (!areValid) {
-      return yield* exports_Effect.fail({ _tag: "ArtifactsInvalid" });
-    }
-  }
   const result = yield* backend2.mutation(api.messages.handoff, {
     sessionId,
     chatroomId,
     senderRole: role,
     content: message,
-    targetRole: nextRole,
-    ...attachedArtifactIds.length > 0 && {
-      attachedArtifactIds
-    }
+    targetRole: nextRole
   }).pipe(exports_Effect.mapError((cause3) => {
     let errorData;
     if (cause3 instanceof ConvexError) {
@@ -76720,12 +77445,6 @@ var handoffEffect = (chatroomId, options) => exports_Effect.gen(function* () {
       convexUrl,
       supportsNativeIntegration: result.supportsNativeIntegration
     }));
-    if (attachedArtifactIds.length > 0) {
-      console.log(`\uD83D\uDCCE Attached artifacts: ${attachedArtifactIds.length}`);
-      attachedArtifactIds.forEach((id3) => {
-        console.log(`   • ${id3}`);
-      });
-    }
   });
 });
 var init_handoff = __esm(() => {
@@ -79306,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 [];
@@ -79352,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;
@@ -79371,7 +80090,7 @@ function untrackChildPid(pid) {
 function clearTrackedPids() {
   try {
     const filePath = getChildPidsFilePath();
-    if (existsSync4(filePath)) {
+    if (existsSync5(filePath)) {
       unlinkSync(filePath);
     }
   } catch {}
@@ -79656,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;
@@ -79719,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() {
@@ -79733,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;
 });
 
@@ -80828,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);
@@ -80839,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 {
@@ -80856,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;
@@ -80878,7 +81597,7 @@ function writePid() {
 function removePid() {
   const pidPath = getPidFilePath();
   try {
-    if (existsSync5(pidPath)) {
+    if (existsSync6(pidPath)) {
       unlinkSync2(pidPath);
     }
   } catch {}
@@ -80941,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
@@ -81854,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);
       }
@@ -81874,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 [];
@@ -81894,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),
@@ -81906,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(`
@@ -81933,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 [];
@@ -81982,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 {}
   }
@@ -82055,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)
@@ -82071,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)) {
@@ -83075,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;
   }
 }
@@ -83119,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 [
@@ -83137,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 },
@@ -83161,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 },
@@ -83191,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)}`);
   }
@@ -83858,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;
   }
 }
@@ -83939,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) {
@@ -83987,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");
@@ -84009,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) {
@@ -85912,7 +86631,7 @@ var init_crash_loop_tracker = __esm(() => {
 });
 
 // ../../services/backend/src/domain/entities/participant.ts
-var NATIVE_WAITING_ACTION = "native:waiting", NATIVE_TASK_INJECTED_ACTION = "native:task-injected", ONLINE_OR_STARTING_STATUSES;
+var NATIVE_WAITING_ACTION = "native:waiting", NATIVE_TASK_INJECTED_ACTION = "native:task-injected", NATIVE_HANDOFF_REMINDER = "Reminder: Use the handoff command to send your response to the team.", ONLINE_OR_STARTING_STATUSES;
 var init_participant = __esm(() => {
   ONLINE_OR_STARTING_STATUSES = new Set([
     "agent.waiting",
@@ -86017,9 +86736,6 @@ function isInjectableNativeAction(action) {
     return true;
   return action === NATIVE_WAITING_ACTION;
 }
-function shouldEmitNativeWaitingOnTurnEnd(lastStatus) {
-  return lastStatus !== "task.acknowledged" && lastStatus !== "task.inProgress";
-}
 function isNativeIdleAfterTaskComplete(participant) {
   return participant.lastSeenAction === NATIVE_TASK_INJECTED_ACTION && participant.lastStatus === "task.completed";
 }
@@ -87137,6 +87853,16 @@ class AgentProcessManager {
     }
     await service3.resumeTurn(slot.pid, args2.prompt);
   }
+  async injectHarnessReminder(chatroomId, role, prompt) {
+    const key = agentKey3(chatroomId, role);
+    const slot = this.slots.get(key);
+    if (!slot?.pid || !slot.harness)
+      return;
+    const service3 = this.deps.agentServices.get(slot.harness);
+    if (!service3?.resumeTurn)
+      return;
+    await service3.resumeTurn(slot.pid, prompt);
+  }
   async stop(opts) {
     const key = agentKey3(opts.chatroomId, opts.role);
     const slot = this.slots.get(key);
@@ -87267,9 +87993,20 @@ class AgentProcessManager {
       console.log(`[AgentProcessManager] ⛔ Terminal provider error for ${opts.role} — emitted agent.startFailed`);
       return;
     }
-    const emitted = await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.harness, "turn-end");
-    if (emitted) {
-      console.log(`[AgentProcessManager] ✅ Native harness idle for ${opts.role} (native:waiting)`);
+    try {
+      const result = await this.deps.backend.mutation(api.participants.handleNativeAgentEnd, {
+        sessionId: this.deps.sessionId,
+        chatroomId: opts.chatroomId,
+        role: opts.role
+      });
+      if (result?.needsHandoffReminder) {
+        await this.injectHarnessReminder(opts.chatroomId, opts.role, NATIVE_HANDOFF_REMINDER);
+        console.log(`[AgentProcessManager] ⏩ Handoff reminder injected for ${opts.role}`);
+        return;
+      }
+      console.log(`[AgentProcessManager] ✅ Native agent_end handled for ${opts.role}`);
+    } catch (err) {
+      console.log(`   ⚠️  Failed native agent_end for ${opts.role}: ${err.message}`);
     }
   }
   async handleExit(opts) {
@@ -88035,25 +88772,9 @@ class AgentProcessManager {
     this.registerSpawnCallbacks(slot, opts, spawnResult, pid);
     await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.agentHarness);
   }
-  async emitNativeWaiting(chatroomId, role, harness, reason = "spawn") {
+  async emitNativeWaiting(chatroomId, role, harness) {
     if (!getHarnessCapabilities(harness).supportsNativeIntegration)
       return false;
-    if (reason === "turn-end") {
-      try {
-        const participant = await this.deps.backend.query(api.participants.getByRole, {
-          sessionId: this.deps.sessionId,
-          chatroomId,
-          role
-        });
-        if (!shouldEmitNativeWaitingOnTurnEnd(participant?.lastStatus)) {
-          console.log(`[AgentProcessManager] Skipping native:waiting for ${role} — active work (${participant?.lastStatus})`);
-          return false;
-        }
-      } catch (err) {
-        console.log(`   ⚠️  Failed to check status before native:waiting for ${role}: ${err.message}`);
-        return false;
-      }
-    }
     try {
       await this.deps.backend.mutation(api.participants.join, {
         sessionId: this.deps.sessionId,
@@ -88224,7 +88945,6 @@ var init_agent_process_manager = __esm(() => {
   init_classify_resume_storm_reason();
   init_terminal_provider_error();
   init_handle_turn_completed();
-  init_predicates();
   init_spawn_policy();
   init_agent_lifecycle_runtime();
   init_agent_lifecycle_types();
@@ -105859,7 +106579,7 @@ handoffCommandGroup.command("view-template").description("Print the handoff mess
     process.exit(1);
   }
 });
-handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--next-role <nextRole>", "Role to hand off to").option("--attach-artifact <artifactId>", "Attach artifact to handoff (can be used multiple times)", collectMultiValueOption, []).action(async (options) => {
+handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--next-role <nextRole>", "Role to hand off to").action(async (options) => {
   await maybeRequireAuth();
   const { decode: decode5 } = await Promise.resolve().then(() => exports_decode);
   const stdinContent = await readStdin();
@@ -105881,8 +106601,7 @@ handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").
   await handoff2(options.chatroomId, {
     role: options.role,
     message,
-    nextRole: options.nextRole,
-    attachedArtifactIds: options.attachArtifact || []
+    nextRole: options.nextRole
   });
 });
 var backlogCommand = program2.command("backlog").description("Manage task queue and backlog");
@@ -106169,4 +106888,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=2DFDF6706DFDE76764756E2164756E21
+//# debugId=B4F2E215BBCC825564756E2164756E21