@slock-ai/daemon 0.2.3 → 0.4.0

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path2 from "path";
+import path3 from "path";
 import os2 from "os";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
 
@@ -82,11 +82,546 @@ var DaemonConnection = class {
 };
 
 // src/agentProcessManager.ts
-import { spawn } from "child_process";
 import { mkdir, writeFile, access, readdir, stat, readFile, rm } from "fs/promises";
-import path from "path";
+import path2 from "path";
 import os from "os";
-var DATA_DIR = path.join(os.homedir(), ".slock", "agents");
+
+// src/drivers/claude.ts
+import { spawn } from "child_process";
+
+// src/drivers/systemPrompt.ts
+function toolRef(prefix, name) {
+  return `${prefix}${name}`;
+}
+function buildBaseSystemPrompt(config, opts) {
+  const t = (name) => toolRef(opts.toolPrefix, name);
+  const criticalRules = [
+    `- Do NOT output text directly. ALL communication goes through ${t("send_message")}.`,
+    ...opts.extraCriticalRules,
+    `- Do NOT explore the filesystem looking for messaging scripts. The MCP tools are already available.`
+  ];
+  const startupSteps = [
+    `1. **Read MEMORY.md** (in your cwd). This is your memory index \u2014 it tells you what you know and where to find it.`,
+    `2. Follow the instructions in MEMORY.md to read any other memory files you need (e.g. channel summaries, role definitions, user preferences).`,
+    `3. Call ${t("receive_message")}(block=true) to start listening.`,
+    `4. When you receive a message, process it and reply with ${t("send_message")}.`,
+    `5. After replying, call ${t("receive_message")}(block=true) again to keep listening.`
+  ];
+  let prompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration.
+
+## Who you are
+
+You are a **long-running, persistent agent**. You are NOT a one-shot assistant \u2014 you live across many sessions. You will be started, put to sleep when idle, and woken up again when someone sends you a message. Your process may restart, but your memory persists through files in your workspace directory. Think of yourself as a team member who is always available, accumulates knowledge over time, and develops expertise through interactions.
+
+## Communication \u2014 MCP tools ONLY
+
+You have MCP tools from the "chat" server. Use ONLY these for communication:
+
+1. **${t("receive_message")}** \u2014 Call with block=true to wait for messages. This is your main loop.
+2. **${t("send_message")}** \u2014 Send a message to a channel or DM.
+3. **${t("list_server")}** \u2014 List all channels, agents, and humans in this server.
+4. **${t("read_history")}** \u2014 Read past messages from a channel or DM.
+
+CRITICAL RULES:
+${criticalRules.join("\n")}
+
+## Startup sequence
+
+${startupSteps.join("\n")}`;
+  if (opts.postStartupNotes.length > 0) {
+    prompt += `
+
+${opts.postStartupNotes.join("\n")}`;
+  }
+  prompt += `
+
+## Messaging
+
+Messages you receive look like:
+- **Channel message from a human**: \`[#all] @richard: hello everyone\`
+- **Channel message from an agent**: \`[#all] (agent) @Alice: hi there\`
+- **DM from a human**: \`[DM:@richard] @richard: hey, can you help?\`
+
+The \`[...]\` prefix identifies where the message came from. Reuse it as the \`channel\` parameter when replying.
+
+### Sending messages
+
+- **Reply to a channel**: \`send_message(channel="#channel-name", content="...")\`
+- **Reply to a DM**: \`send_message(channel="DM:@peer-name", content="...")\`  \u2014 reuse the channel value from the received message
+- **Start a NEW DM**: \`send_message(dm_to="peer-name", content="...")\`  \u2014 use the human's name from list_server (no @ prefix)
+
+**IMPORTANT**: To reply to any message (channel or DM), always use \`channel\` with the exact identifier from the received message. Only use \`dm_to\` when you want to start a brand new DM that doesn't exist yet.
+
+### Discovering people and channels
+
+Call \`list_server\` to see all your channels, other agents, and humans in this server.
+
+### Reading history
+
+\`read_history(channel="#channel-name")\` or \`read_history(channel="DM:@peer-name")\`
+
+## @Mentions
+
+In channel group chats, you can @mention people by their unique name (e.g. "@alice" or "@bob").
+- Every human and agent has a unique \`name\` \u2014 this is their stable identifier for @mentions.
+- @mentions do not notify people outside the channel \u2014 channels are the isolation boundary.
+
+## Communication style
+
+Keep the user informed. They cannot see your internal reasoning, so:
+- When you receive a task, acknowledge it and briefly outline your plan before starting.
+- For multi-step work, send short progress updates (e.g. "Working on step 2/3\u2026").
+- When done, summarize the result.
+- Keep updates concise \u2014 one or two sentences. Don't flood the chat.
+
+## Workspace & Memory
+
+Your working directory (cwd) is your **persistent workspace**. Everything you write here survives across sessions.
+
+### MEMORY.md \u2014 Your Memory Index (CRITICAL)
+
+\`MEMORY.md\` is the **entry point** to all your knowledge. It is the first file read on every startup (including after context compression). Structure it as an index that points to everything you know. This file is called \`MEMORY.md\` (not tied to any specific runtime) \u2014 keep it updated after every significant interaction or learning.
+
+\`\`\`markdown
+# <Your Name>
+
+## Role
+<your role definition, evolved over time>
+
+## Key Knowledge
+- Read notes/user-preferences.md for user preferences and conventions
+- Read notes/channels.md for what each channel is about and ongoing work
+- Read notes/domain.md for domain-specific knowledge and conventions
+- ...
+
+## Active Context
+- Currently working on: <brief summary>
+- Last interaction: <brief summary>
+\`\`\`
+
+### What to memorize
+
+**Actively observe and record** the following kinds of knowledge as you encounter them in conversations:
+
+1. **User preferences** \u2014 How the user likes things done, communication style, coding conventions, tool preferences, recurring patterns in their requests.
+2. **World/project context** \u2014 The project structure, tech stack, architectural decisions, team conventions, deployment patterns.
+3. **Domain knowledge** \u2014 Domain-specific terminology, conventions, best practices you learn through tasks.
+4. **Work history** \u2014 What has been done, decisions made and why, problems solved, approaches that worked or failed.
+5. **Channel context** \u2014 What each channel is about, who participates, what's being discussed, ongoing tasks per channel.
+6. **Other agents** \u2014 What other agents do, their specialties, collaboration patterns, how to work with them effectively.
+
+### How to organize memory
+
+- **MEMORY.md** is always the index. Keep it concise but comprehensive as a table of contents.
+- Create a \`notes/\` directory for detailed knowledge files. Use descriptive names:
+  - \`notes/user-preferences.md\` \u2014 User's preferences and conventions
+  - \`notes/channels.md\` \u2014 Summary of each channel and its purpose
+  - \`notes/work-log.md\` \u2014 Important decisions and completed work
+  - \`notes/<domain>.md\` \u2014 Domain-specific knowledge
+- You can also create any other files or directories for your work (scripts, notes, data, etc.)
+- **Update notes proactively** \u2014 Don't wait to be asked. When you learn something important, write it down.
+- **Keep MEMORY.md current** \u2014 After updating notes, update the index in MEMORY.md if new files were added.
+
+### Compaction safety (CRITICAL)
+
+Your context will be periodically compressed to stay within limits. When this happens, you lose your in-context conversation history but MEMORY.md is always re-read. Therefore:
+
+- **MEMORY.md must be self-sufficient as a recovery point.** After reading it, you should be able to understand who you are, what you know, and what you were working on.
+- **Before a long task**, write a brief "Active Context" note in MEMORY.md so you can resume if interrupted mid-task.
+- **After completing work**, update your notes and MEMORY.md index so nothing is lost.
+- NEVER let context compression cause you to forget: which channel is about what, what tasks are in progress, what the user has asked for, or what other agents are doing.
+
+## Capabilities
+
+You can work with any files or tools on this computer \u2014 you are not confined to any directory.
+You may develop a specialized role over time through your interactions. Embrace it.`;
+  if (opts.includeStdinNotificationSection) {
+    prompt += `
+
+## Message Notifications
+
+While you are busy (executing tools, thinking, etc.), new messages may arrive. When this happens, you will receive a system notification like:
+
+\`[System notification: You have N new message(s) waiting. Call receive_message to read them when you're ready.]\`
+
+How to handle these:
+- **Do NOT interrupt your current work.** Finish what you're doing first.
+- After completing your current step, call \`${t("receive_message")}(block=false)\` to check for messages.
+- Do not ignore notifications for too long \u2014 acknowledge new messages in a timely manner.
+- These notifications are batched (you won't get one per message), so the count tells you how many are waiting.`;
+  }
+  if (config.description) {
+    prompt += `
+
+## Initial role
+${config.description}. This may evolve.`;
+  }
+  return prompt;
+}
+
+// src/drivers/claude.ts
+var ClaudeDriver = class {
+  id = "claude";
+  supportsStdinNotification = true;
+  mcpToolPrefix = "mcp__chat__";
+  spawn(ctx) {
+    const mcpArgs = [
+      ctx.chatBridgePath,
+      "--agent-id",
+      ctx.agentId,
+      "--server-url",
+      ctx.config.serverUrl,
+      "--auth-token",
+      ctx.config.authToken || ctx.daemonApiKey
+    ];
+    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+    const mcpConfig = JSON.stringify({
+      mcpServers: {
+        chat: {
+          command: isTsSource ? "npx" : "node",
+          args: isTsSource ? ["tsx", ...mcpArgs] : mcpArgs
+        }
+      }
+    });
+    const args2 = [
+      "--allow-dangerously-skip-permissions",
+      "--dangerously-skip-permissions",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      "--input-format",
+      "stream-json",
+      "--mcp-config",
+      mcpConfig,
+      "--model",
+      ctx.config.model || "sonnet"
+    ];
+    if (ctx.config.sessionId) {
+      args2.push("--resume", ctx.config.sessionId);
+    }
+    const spawnEnv = { ...process.env, FORCE_COLOR: "0" };
+    delete spawnEnv.CLAUDECODE;
+    const proc = spawn("claude", args2, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv
+    });
+    const stdinMsg = JSON.stringify({
+      type: "user",
+      message: {
+        role: "user",
+        content: [{ type: "text", text: ctx.prompt }]
+      },
+      ...ctx.config.sessionId ? { session_id: ctx.config.sessionId } : {}
+    });
+    proc.stdin?.write(stdinMsg + "\n");
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    switch (event.type) {
+      case "system":
+        if (event.subtype === "init" && event.session_id) {
+          events.push({ kind: "session_init", sessionId: event.session_id });
+        }
+        break;
+      case "assistant": {
+        const content = event.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "thinking" && block.thinking) {
+              events.push({ kind: "thinking", text: block.thinking });
+            } else if (block.type === "text" && block.text) {
+              events.push({ kind: "text", text: block.text });
+            } else if (block.type === "tool_use") {
+              events.push({ kind: "tool_call", name: block.name || "unknown_tool", input: block.input });
+            }
+          }
+        }
+        break;
+      }
+      case "result": {
+        events.push({ kind: "turn_end", sessionId: event.session_id });
+        break;
+      }
+    }
+    return events;
+  }
+  encodeStdinMessage(text, sessionId) {
+    return JSON.stringify({
+      type: "user",
+      message: {
+        role: "user",
+        content: [{ type: "text", text }]
+      },
+      ...sessionId ? { session_id: sessionId } : {}
+    });
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildBaseSystemPrompt(config, {
+      toolPrefix: "mcp__chat__",
+      extraCriticalRules: [
+        "- Do NOT use bash/curl/sqlite to send or receive messages. The MCP tools handle everything."
+      ],
+      postStartupNotes: [],
+      includeStdinNotificationSection: true
+    });
+  }
+  toolDisplayName(name) {
+    if (name.startsWith("mcp__chat__")) return "";
+    if (name === "Read" || name === "read_file") return "Reading file\u2026";
+    if (name === "Write" || name === "write_file") return "Writing file\u2026";
+    if (name === "Edit" || name === "edit_file") return "Editing file\u2026";
+    if (name === "Bash" || name === "bash") return "Running command\u2026";
+    if (name === "Glob" || name === "glob") return "Searching files\u2026";
+    if (name === "Grep" || name === "grep") return "Searching code\u2026";
+    if (name === "WebFetch" || name === "web_fetch") return "Fetching web\u2026";
+    if (name === "WebSearch" || name === "web_search") return "Searching web\u2026";
+    if (name === "TodoWrite") return "Updating tasks\u2026";
+    return `Using ${name.length > 20 ? name.slice(0, 20) + "\u2026" : name}\u2026`;
+  }
+  summarizeToolInput(name, input) {
+    if (!input || typeof input !== "object") return "";
+    try {
+      if (name === "Read" || name === "read_file") return input.file_path || input.path || "";
+      if (name === "Write" || name === "write_file") return input.file_path || input.path || "";
+      if (name === "Edit" || name === "edit_file") return input.file_path || input.path || "";
+      if (name === "Bash" || name === "bash") {
+        const cmd = input.command || "";
+        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
+      }
+      if (name === "Glob" || name === "glob") return input.pattern || "";
+      if (name === "Grep" || name === "grep") return input.pattern || "";
+      if (name === "WebFetch" || name === "web_fetch") return input.url || "";
+      if (name === "WebSearch" || name === "web_search") return input.query || "";
+      if (name === "mcp__chat__send_message") {
+        return input.channel || (input.dm_to ? `DM:@${input.dm_to}` : "");
+      }
+      if (name === "mcp__chat__read_history") return input.channel || "";
+      return "";
+    } catch {
+      return "";
+    }
+  }
+};
+
+// src/drivers/codex.ts
+import { spawn as spawn2, execSync } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+var CodexDriver = class {
+  id = "codex";
+  supportsStdinNotification = false;
+  mcpToolPrefix = "mcp_chat_";
+  spawn(ctx) {
+    const gitDir = path.join(ctx.workingDirectory, ".git");
+    if (!existsSync(gitDir)) {
+      execSync("git init", { cwd: ctx.workingDirectory, stdio: "pipe" });
+      execSync("git add -A && git commit --allow-empty -m 'init'", {
+        cwd: ctx.workingDirectory,
+        stdio: "pipe",
+        env: { ...process.env, GIT_AUTHOR_NAME: "slock", GIT_AUTHOR_EMAIL: "slock@local", GIT_COMMITTER_NAME: "slock", GIT_COMMITTER_EMAIL: "slock@local" }
+      });
+    }
+    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+    const command = isTsSource ? "npx" : "node";
+    const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey] : [ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey];
+    const args2 = ["exec"];
+    if (ctx.config.sessionId) {
+      args2.push("resume", ctx.config.sessionId);
+    }
+    args2.push(
+      "--full-auto",
+      "--json"
+    );
+    args2.push(
+      "-c",
+      `mcp_servers.chat.command=${JSON.stringify(command)}`,
+      "-c",
+      `mcp_servers.chat.args=${JSON.stringify(bridgeArgs)}`,
+      "-c",
+      "mcp_servers.chat.startup_timeout_sec=30",
+      "-c",
+      "mcp_servers.chat.tool_timeout_sec=120",
+      "-c",
+      "mcp_servers.chat.enabled=true",
+      "-c",
+      "mcp_servers.chat.required=true"
+    );
+    if (ctx.config.model) {
+      args2.push("-m", ctx.config.model);
+    }
+    if (ctx.config.reasoningEffort) {
+      args2.push("-c", `model_reasoning_effort=${ctx.config.reasoningEffort}`);
+    }
+    args2.push(ctx.prompt);
+    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" };
+    const proc = spawn2("codex", args2, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv
+    });
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    switch (event.type) {
+      case "thread.started":
+        if (event.thread_id) {
+          events.push({ kind: "session_init", sessionId: event.thread_id });
+        }
+        break;
+      case "turn.started":
+        events.push({ kind: "thinking", text: "" });
+        break;
+      case "item.started":
+      case "item.updated":
+      case "item.completed": {
+        const item = event.item;
+        if (!item) break;
+        switch (item.type) {
+          case "reasoning":
+            if (item.text) {
+              events.push({ kind: "thinking", text: item.text });
+            }
+            break;
+          case "agent_message":
+            if (item.text && event.type === "item.completed") {
+              events.push({ kind: "text", text: item.text });
+            }
+            break;
+          case "command_execution":
+            if (event.type === "item.started") {
+              events.push({ kind: "tool_call", name: "shell", input: { command: item.command } });
+            }
+            break;
+          case "file_change":
+            if (event.type === "item.started" && Array.isArray(item.changes)) {
+              for (const change of item.changes) {
+                events.push({ kind: "tool_call", name: "file_change", input: { path: change.path, kind: change.kind } });
+              }
+            }
+            break;
+          case "mcp_tool_call":
+            if (event.type === "item.started") {
+              const toolName = item.server && item.tool ? `${this.mcpToolPrefix.replace(/_$/, "")}_${item.server}_${item.tool}` : item.tool || "mcp_tool";
+              const name = item.server === "chat" ? `${this.mcpToolPrefix}${item.tool}` : toolName;
+              events.push({ kind: "tool_call", name, input: item.arguments });
+            }
+            break;
+          case "collab_tool_call":
+            if (event.type === "item.started") {
+              events.push({ kind: "tool_call", name: "collab_tool_call", input: {} });
+            }
+            break;
+          case "todo_list":
+            if (event.type === "item.started" || event.type === "item.updated") {
+              events.push({ kind: "thinking", text: item.title || "Planning\u2026" });
+            }
+            break;
+          case "web_search":
+            if (event.type === "item.started") {
+              events.push({ kind: "tool_call", name: "web_search", input: { query: item.query } });
+            }
+            break;
+          case "error":
+            if (item.message) {
+              events.push({ kind: "error", message: item.message });
+            }
+            break;
+        }
+        break;
+      }
+      case "turn.completed":
+        events.push({ kind: "turn_end" });
+        break;
+      case "turn.failed":
+        if (event.error?.message) {
+          events.push({ kind: "error", message: event.error.message });
+        }
+        events.push({ kind: "turn_end" });
+        break;
+      case "error":
+        events.push({ kind: "error", message: event.message || "Unknown error" });
+        break;
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildBaseSystemPrompt(config, {
+      toolPrefix: "",
+      extraCriticalRules: [
+        "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything.",
+        "- ALWAYS call receive_message(block=true) after completing any task \u2014 this keeps you listening for new messages."
+      ],
+      postStartupNotes: [
+        "**IMPORTANT**: Your process exits after each turn completes. You will be automatically restarted when new messages arrive. Always call receive_message(block=true) as your last action \u2014 if no messages are pending, you'll sleep and be woken when one arrives."
+      ],
+      includeStdinNotificationSection: false
+    });
+  }
+  toolDisplayName(name) {
+    if (name.startsWith(this.mcpToolPrefix)) return "";
+    if (name === "shell" || name === "command_execution") return "Running command\u2026";
+    if (name === "file_change") return "Editing file\u2026";
+    if (name === "file_read") return "Reading file\u2026";
+    if (name === "file_write") return "Writing file\u2026";
+    if (name === "web_search") return "Searching web\u2026";
+    if (name === "collab_tool_call") return "Collaborating\u2026";
+    return `Using ${name.length > 20 ? name.slice(0, 20) + "\u2026" : name}\u2026`;
+  }
+  summarizeToolInput(name, input) {
+    if (!input || typeof input !== "object") return "";
+    try {
+      if (name === "shell" || name === "command_execution") {
+        const cmd = input.command || "";
+        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
+      }
+      if (name === "file_change") return input.path || "";
+      if (name === "file_read") return input.path || input.file_path || "";
+      if (name === "file_write") return input.path || input.file_path || "";
+      if (name === "web_search") return input.query || "";
+      if (name === `${this.mcpToolPrefix}send_message`) {
+        return input.channel || (input.dm_to ? `DM:@${input.dm_to}` : "");
+      }
+      if (name === `${this.mcpToolPrefix}read_history`) return input.channel || "";
+      return "";
+    } catch {
+      return "";
+    }
+  }
+};
+
+// src/drivers/index.ts
+var drivers = {
+  claude: new ClaudeDriver(),
+  codex: new CodexDriver()
+};
+function getDriver(runtimeId) {
+  const driver = drivers[runtimeId];
+  if (!driver) {
+    throw new Error(`Unknown runtime: ${runtimeId}. Available: ${Object.keys(drivers).join(", ")}`);
+  }
+  return driver;
+}
+
+// src/agentProcessManager.ts
+var DATA_DIR = path2.join(os.homedir(), ".slock", "agents");
 var MAX_TRAJECTORY_TEXT = 2e3;
 var AgentProcessManager = class {
   agents = /* @__PURE__ */ new Map();
@@ -100,9 +635,10 @@ var AgentProcessManager = class {
   }
   async startAgent(agentId, config, wakeMessage, unreadSummary) {
     if (this.agents.has(agentId)) return;
-    const agentDataDir = path.join(DATA_DIR, agentId);
+    const driver = getDriver(config.runtime || "claude");
+    const agentDataDir = path2.join(DATA_DIR, agentId);
     await mkdir(agentDataDir, { recursive: true });
-    const memoryMdPath = path.join(agentDataDir, "MEMORY.md");
+    const memoryMdPath = path2.join(agentDataDir, "MEMORY.md");
     try {
       await access(memoryMdPath);
     } catch {
@@ -120,7 +656,7 @@ ${config.description || "No role defined yet."}
 `;
       await writeFile(memoryMdPath, initialMemoryMd);
     }
-    await mkdir(path.join(agentDataDir, "notes"), { recursive: true });
+    await mkdir(path2.join(agentDataDir, "notes"), { recursive: true });
     const isResume = !!config.sessionId;
     let prompt;
     if (isResume && wakeMessage) {
@@ -147,9 +683,12 @@ Use read_history to catch up, or respond to the message above first.`;
       }
       prompt += `
 
-Respond as appropriate \u2014 reply using send_message, or take action as needed. Then call receive_message(block=true) to keep listening.
+Respond as appropriate \u2014 reply using send_message, or take action as needed. Then call receive_message(block=true) to keep listening.`;
+      if (driver.supportsStdinNotification) {
+        prompt += `
 
 Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call receive_message to check.`;
+      }
     } else if (isResume && unreadSummary && Object.keys(unreadSummary).length > 0) {
       prompt = `You have unread messages from while you were offline:`;
       for (const [ch, count] of Object.entries(unreadSummary)) {
@@ -158,58 +697,33 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
       }
       prompt += `
 
-Use read_history to catch up on important channels, then call receive_message(block=true) to listen for new messages.
+Use read_history to catch up on important channels, then call receive_message(block=true) to listen for new messages.`;
+      if (driver.supportsStdinNotification) {
+        prompt += `
 
 Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call receive_message to check.`;
+      }
     } else if (isResume) {
-      prompt = "No new messages while you were away. Call mcp__chat__receive_message(block=true) to listen for new messages.\n\nNote: While you are busy, you may receive [System notification: ...] messages about new messages. Finish your current step, then call receive_message to check.";
+      prompt = `No new messages while you were away. Call ${driver.mcpToolPrefix}receive_message(block=true) to listen for new messages.`;
+      if (driver.supportsStdinNotification) {
+        prompt += `
+
+Note: While you are busy, you may receive [System notification: ...] messages about new messages. Finish your current step, then call receive_message to check.`;
+      }
     } else {
-      prompt = this.buildSystemPrompt(config, agentId);
+      prompt = driver.buildSystemPrompt(config, agentId);
     }
-    const mcpArgs = [
-      this.chatBridgePath,
-      "--agent-id",
+    const { process: proc } = driver.spawn({
       agentId,
-      "--server-url",
-      config.serverUrl,
-      "--auth-token",
-      config.authToken || this.daemonApiKey
-    ];
-    const isTsSource = this.chatBridgePath.endsWith(".ts");
-    const mcpConfig = JSON.stringify({
-      mcpServers: {
-        chat: {
-          command: isTsSource ? "npx" : "node",
-          args: isTsSource ? ["tsx", ...mcpArgs] : mcpArgs
-        }
-      }
-    });
-    const args2 = [
-      "--allow-dangerously-skip-permissions",
-      "--dangerously-skip-permissions",
-      "--verbose",
-      "--output-format",
-      "stream-json",
-      "--input-format",
-      "stream-json",
-      "--mcp-config",
-      mcpConfig,
-      "--model",
-      config.model || "sonnet"
-    ];
-    if (config.sessionId) {
-      args2.push("--resume", config.sessionId);
-    }
-    const runtime = config.runtime || "claude";
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0" };
-    delete spawnEnv.CLAUDECODE;
-    const proc = spawn(runtime, args2, {
-      cwd: agentDataDir,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: spawnEnv
+      config,
+      prompt,
+      workingDirectory: agentDataDir,
+      chatBridgePath: this.chatBridgePath,
+      daemonApiKey: this.daemonApiKey
     });
     const agentProcess = {
       process: proc,
+      driver,
       inbox: [],
       pendingReceive: null,
       config,
@@ -219,7 +733,6 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
       pendingNotificationCount: 0
     };
     this.agents.set(agentId, agentProcess);
-    this.writeStdinMessage(agentProcess, prompt);
     let buffer = "";
     proc.stdout?.on("data", (chunk) => {
       buffer += chunk.toString();
@@ -227,16 +740,17 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
       buffer = lines.pop() || "";
       for (const line of lines) {
         if (!line.trim()) continue;
-        try {
-          const event = JSON.parse(line);
-          this.handleStreamEvent(agentId, event);
-        } catch {
+        const events = driver.parseLine(line);
+        for (const event of events) {
+          this.handleParsedEvent(agentId, event, driver);
         }
       }
     });
     proc.stderr?.on("data", (chunk) => {
       const text = chunk.toString().trim();
-      if (text) console.error(`[Agent ${agentId} stderr]: ${text}`);
+      if (!text) return;
+      if (/Reconnecting\.\.\.|Falling back from WebSockets/i.test(text)) return;
+      console.error(`[Agent ${agentId} stderr]: ${text}`);
     });
     proc.on("exit", (code) => {
       console.log(`[Agent ${agentId}] Process exited with code ${code}`);
@@ -297,6 +811,7 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     } else {
       ap.inbox.push(message);
     }
+    if (!ap.driver.supportsStdinNotification) return;
     if (ap.isInReceiveMessage) return;
     if (!ap.sessionId) return;
     ap.pendingNotificationCount++;
@@ -307,7 +822,7 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     }
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path.join(DATA_DIR, agentId);
+    const agentDataDir = path2.join(DATA_DIR, agentId);
     try {
       await rm(agentDataDir, { recursive: true, force: true });
       console.log(`[Agent ${agentId}] Workspace deleted: ${agentDataDir}`);
@@ -333,14 +848,14 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const dirPath = path.join(DATA_DIR, entry.name);
+      const dirPath = path2.join(DATA_DIR, entry.name);
       try {
         const dirContents = await readdir(dirPath, { withFileTypes: true });
         let totalSize = 0;
         let latestMtime = /* @__PURE__ */ new Date(0);
         let fileCount = 0;
         for (const item of dirContents) {
-          const itemPath = path.join(dirPath, item.name);
+          const itemPath = path2.join(dirPath, item.name);
           try {
             const info = await stat(itemPath);
             if (item.isFile()) {
@@ -370,7 +885,7 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     if (directoryName.includes("/") || directoryName.includes("..") || directoryName.includes("\\")) {
       return false;
     }
-    const targetDir = path.join(DATA_DIR, directoryName);
+    const targetDir = path2.join(DATA_DIR, directoryName);
     try {
       await rm(targetDir, { recursive: true, force: true });
       console.log(`[Workspace] Deleted directory: ${targetDir}`);
@@ -382,7 +897,7 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
   }
   // Workspace file browsing
   async getFileTree(agentId) {
-    const agentDir = path.join(DATA_DIR, agentId);
+    const agentDir = path2.join(DATA_DIR, agentId);
     try {
       await stat(agentDir);
     } catch {
@@ -392,9 +907,9 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     return this.buildFileTree(agentDir, agentDir, count);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path.join(DATA_DIR, agentId);
-    const resolved = path.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path.sep) && resolved !== agentDir) {
+    const agentDir = path2.join(DATA_DIR, agentId);
+    const resolved = path2.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path2.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat(resolved);
@@ -418,7 +933,7 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
       ".sh",
       ".py"
     ]);
-    const ext = path.extname(resolved).toLowerCase();
+    const ext = path2.extname(resolved).toLowerCase();
     if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
       return { content: null, binary: true };
     }
@@ -427,17 +942,77 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     return { content, binary: false };
   }
   // Private methods
-  /** Write a stream-json user message to the agent's stdin */
-  writeStdinMessage(ap, text) {
-    const stdinMsg = JSON.stringify({
-      type: "user",
-      message: {
-        role: "user",
-        content: [{ type: "text", text }]
-      },
-      ...ap.sessionId ? { session_id: ap.sessionId } : {}
-    });
-    ap.process.stdin?.write(stdinMsg + "\n");
+  /** Handle a single ParsedEvent from any runtime driver */
+  handleParsedEvent(agentId, event, driver) {
+    const trajectory = [];
+    let activity = "";
+    let detail = "";
+    const ap = this.agents.get(agentId);
+    switch (event.kind) {
+      case "session_init":
+        if (ap) ap.sessionId = event.sessionId;
+        this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId });
+        break;
+      case "thinking": {
+        const text = event.text.length > MAX_TRAJECTORY_TEXT ? event.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : event.text;
+        trajectory.push({ kind: "thinking", text });
+        activity = "thinking";
+        if (ap) ap.isInReceiveMessage = false;
+        break;
+      }
+      case "text": {
+        const text = event.text.length > MAX_TRAJECTORY_TEXT ? event.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : event.text;
+        trajectory.push({ kind: "text", text });
+        activity = "thinking";
+        if (ap) ap.isInReceiveMessage = false;
+        break;
+      }
+      case "tool_call": {
+        const toolName = event.name;
+        const inputSummary = driver.summarizeToolInput(toolName, event.input);
+        trajectory.push({ kind: "tool_start", toolName, toolInput: inputSummary });
+        if (toolName === `${driver.mcpToolPrefix}receive_message`) {
+          activity = "online";
+          if (ap) {
+            ap.isInReceiveMessage = true;
+            ap.pendingNotificationCount = 0;
+            if (ap.notificationTimer) {
+              clearTimeout(ap.notificationTimer);
+              ap.notificationTimer = null;
+            }
+          }
+        } else if (toolName === `${driver.mcpToolPrefix}send_message`) {
+          activity = "working";
+          detail = "Sending message\u2026";
+          if (ap) ap.isInReceiveMessage = false;
+        } else {
+          activity = "working";
+          detail = driver.toolDisplayName(toolName);
+          if (ap) ap.isInReceiveMessage = false;
+        }
+        break;
+      }
+      case "turn_end":
+        activity = "online";
+        if (ap) {
+          ap.isInReceiveMessage = false;
+          if (event.sessionId) ap.sessionId = event.sessionId;
+        }
+        if (event.sessionId) {
+          this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId });
+        }
+        break;
+      case "error":
+        trajectory.push({ kind: "text", text: `Error: ${event.message}` });
+        break;
+    }
+    if (activity) {
+      this.sendToServer({ type: "agent:activity", agentId, activity, detail });
+      trajectory.push({ kind: "status", activity, detail });
+    }
+    if (trajectory.length > 0) {
+      this.sendToServer({ type: "agent:trajectory", agentId, entries: trajectory });
+    }
   }
   /** Send a batched notification to the agent via stdin about pending messages */
   sendStdinNotification(agentId) {
@@ -451,7 +1026,10 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     if (!ap.sessionId) return;
     const notification = `[System notification: You have ${count} new message${count > 1 ? "s" : ""} waiting. Call receive_message to read ${count > 1 ? "them" : "it"} when you're ready.]`;
     console.log(`[Agent ${agentId}] Sending stdin notification: ${count} message(s)`);
-    this.writeStdinMessage(ap, notification);
+    const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId);
+    if (encoded) {
+      ap.process.stdin?.write(encoded + "\n");
+    }
   }
   async buildFileTree(dir, rootDir, count) {
     let entries;
@@ -469,8 +1047,8 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     for (const entry of entries) {
       if (count.n >= 500) break;
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = path.join(dir, entry.name);
-      const relativePath = path.relative(rootDir, fullPath);
+      const fullPath = path2.join(dir, entry.name);
+      const relativePath = path2.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat(fullPath);
@@ -487,279 +1065,12 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
     }
     return nodes;
   }
-  handleStreamEvent(agentId, event) {
-    const trajectory = [];
-    let activity = "";
-    let detail = "";
-    switch (event.type) {
-      case "system":
-        if (event.subtype === "init" && event.session_id) {
-          const ap = this.agents.get(agentId);
-          if (ap) ap.sessionId = event.session_id;
-          this.sendToServer({ type: "agent:session", agentId, sessionId: event.session_id });
-        }
-        break;
-      case "assistant": {
-        const content = event.message?.content;
-        if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === "thinking" && block.thinking) {
-              const text = block.thinking.length > MAX_TRAJECTORY_TEXT ? block.thinking.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : block.thinking;
-              trajectory.push({ kind: "thinking", text });
-            } else if (block.type === "text" && block.text) {
-              const text = block.text.length > MAX_TRAJECTORY_TEXT ? block.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : block.text;
-              trajectory.push({ kind: "text", text });
-            } else if (block.type === "tool_use") {
-              const toolName = block.name || "unknown_tool";
-              const inputSummary = this.summarizeToolInput(toolName, block.input);
-              trajectory.push({ kind: "tool_start", toolName, toolInput: inputSummary });
-            }
-          }
-        }
-        const ap = this.agents.get(agentId);
-        const toolUses = Array.isArray(content) ? content.filter((c) => c.type === "tool_use") : [];
-        if (toolUses.length > 0) {
-          const lastTool = toolUses[toolUses.length - 1];
-          const toolName = lastTool.name || "tool";
-          if (toolName === "mcp__chat__receive_message") {
-            activity = "online";
-            if (ap) {
-              ap.isInReceiveMessage = true;
-              ap.pendingNotificationCount = 0;
-              if (ap.notificationTimer) {
-                clearTimeout(ap.notificationTimer);
-                ap.notificationTimer = null;
-              }
-            }
-          } else if (toolName === "mcp__chat__send_message") {
-            activity = "working";
-            detail = "Sending message\u2026";
-            if (ap) ap.isInReceiveMessage = false;
-          } else {
-            activity = "working";
-            detail = this.toolDisplayName(toolName);
-            if (ap) ap.isInReceiveMessage = false;
-          }
-        } else {
-          activity = "thinking";
-          if (ap) ap.isInReceiveMessage = false;
-        }
-        break;
-      }
-      case "result": {
-        activity = "online";
-        const apResult = this.agents.get(agentId);
-        if (apResult) {
-          apResult.isInReceiveMessage = false;
-          if (event.session_id) apResult.sessionId = event.session_id;
-        }
-        if (event.session_id) {
-          this.sendToServer({ type: "agent:session", agentId, sessionId: event.session_id });
-        }
-        break;
-      }
-    }
-    if (activity) {
-      this.sendToServer({ type: "agent:activity", agentId, activity, detail });
-      trajectory.push({ kind: "status", activity, detail });
-    }
-    if (trajectory.length > 0) {
-      this.sendToServer({ type: "agent:trajectory", agentId, entries: trajectory });
-    }
-  }
-  /** Map raw tool names to user-friendly labels (all end with "…") */
-  toolDisplayName(toolName) {
-    if (toolName.startsWith("mcp__chat__")) return "";
-    if (toolName === "Read" || toolName === "read_file") return "Reading file\u2026";
-    if (toolName === "Write" || toolName === "write_file") return "Writing file\u2026";
-    if (toolName === "Edit" || toolName === "edit_file") return "Editing file\u2026";
-    if (toolName === "Bash" || toolName === "bash") return "Running command\u2026";
-    if (toolName === "Glob" || toolName === "glob") return "Searching files\u2026";
-    if (toolName === "Grep" || toolName === "grep") return "Searching code\u2026";
-    if (toolName === "WebFetch" || toolName === "web_fetch") return "Fetching web\u2026";
-    if (toolName === "WebSearch" || toolName === "web_search") return "Searching web\u2026";
-    if (toolName === "TodoWrite") return "Updating tasks\u2026";
-    return `Using ${toolName.length > 20 ? toolName.slice(0, 20) + "\u2026" : toolName}\u2026`;
-  }
-  /** Extract a short human-readable summary from tool input */
-  summarizeToolInput(toolName, input) {
-    if (!input || typeof input !== "object") return "";
-    try {
-      if (toolName === "Read" || toolName === "read_file") return input.file_path || input.path || "";
-      if (toolName === "Write" || toolName === "write_file") return input.file_path || input.path || "";
-      if (toolName === "Edit" || toolName === "edit_file") return input.file_path || input.path || "";
-      if (toolName === "Bash" || toolName === "bash") {
-        const cmd = input.command || "";
-        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
-      }
-      if (toolName === "Glob" || toolName === "glob") return input.pattern || "";
-      if (toolName === "Grep" || toolName === "grep") return input.pattern || "";
-      if (toolName === "WebFetch" || toolName === "web_fetch") return input.url || "";
-      if (toolName === "WebSearch" || toolName === "web_search") return input.query || "";
-      if (toolName === "mcp__chat__send_message") {
-        return input.channel || (input.dm_to ? `DM:@${input.dm_to}` : "");
-      }
-      if (toolName === "mcp__chat__read_history") return input.channel || "";
-      return "";
-    } catch {
-      return "";
-    }
-  }
-  buildSystemPrompt(config, agentId) {
-    let systemPrompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration.
-
-## Who you are
-
-You are a **long-running, persistent agent**. You are NOT a one-shot assistant \u2014 you live across many sessions. You will be started, put to sleep when idle, and woken up again when someone sends you a message. Your process may restart, but your memory persists through files in your workspace directory. Think of yourself as a team member who is always available, accumulates knowledge over time, and develops expertise through interactions.
-
-## Communication \u2014 MCP tools ONLY
-
-You have MCP tools from the "chat" server. Use ONLY these for communication:
-
-1. **mcp__chat__receive_message** \u2014 Call with block=true to wait for messages. This is your main loop.
-2. **mcp__chat__send_message** \u2014 Send a message to a channel or DM.
-3. **mcp__chat__list_server** \u2014 List all channels, agents, and humans in this server.
-4. **mcp__chat__read_history** \u2014 Read past messages from a channel or DM.
-
-CRITICAL RULES:
-- Do NOT output text directly. ALL communication goes through mcp__chat__send_message.
-- Do NOT use bash/curl/sqlite to send or receive messages. The MCP tools handle everything.
-- Do NOT explore the filesystem looking for messaging scripts. The MCP tools are already available.
-
-## Startup sequence
-
-1. **Read MEMORY.md** (in your cwd). This is your memory index \u2014 it tells you what you know and where to find it.
-2. Follow the instructions in MEMORY.md to read any other memory files you need (e.g. channel summaries, role definitions, user preferences).
-3. Call mcp__chat__receive_message(block=true) to start listening.
-4. When you receive a message, process it and reply with mcp__chat__send_message.
-5. After replying, call mcp__chat__receive_message(block=true) again to keep listening.
-
-## Messaging
-
-Messages you receive look like:
-- **Channel message from a human**: \`[#all] @richard: hello everyone\`
-- **Channel message from an agent**: \`[#all] (agent) @Alice: hi there\`
-- **DM from a human**: \`[DM:@richard] @richard: hey, can you help?\`
-
-The \`[...]\` prefix identifies where the message came from. Reuse it as the \`channel\` parameter when replying.
-
-### Sending messages
-
-- **Reply to a channel**: \`send_message(channel="#channel-name", content="...")\`
-- **Reply to a DM**: \`send_message(channel="DM:@peer-name", content="...")\`  \u2014 reuse the channel value from the received message
-- **Start a NEW DM**: \`send_message(dm_to="peer-name", content="...")\`  \u2014 use the human's name from list_server (no @ prefix)
-
-**IMPORTANT**: To reply to any message (channel or DM), always use \`channel\` with the exact identifier from the received message. Only use \`dm_to\` when you want to start a brand new DM that doesn't exist yet.
-
-### Discovering people and channels
-
-Call \`list_server\` to see all your channels, other agents, and humans in this server.
-
-### Reading history
-
-\`read_history(channel="#channel-name")\` or \`read_history(channel="DM:@peer-name")\`
-
-## @Mentions
-
-In channel group chats, you can @mention people by their unique name (e.g. "@alice" or "@bob").
-- Every human and agent has a unique \`name\` \u2014 this is their stable identifier for @mentions.
-- @mentions do not notify people outside the channel \u2014 channels are the isolation boundary.
-
-## Communication style
-
-Keep the user informed. They cannot see your internal reasoning, so:
-- When you receive a task, acknowledge it and briefly outline your plan before starting.
-- For multi-step work, send short progress updates (e.g. "Working on step 2/3\u2026").
-- When done, summarize the result.
-- Keep updates concise \u2014 one or two sentences. Don't flood the chat.
-
-## Workspace & Memory
-
-Your working directory (cwd) is your **persistent workspace**. Everything you write here survives across sessions.
-
-### MEMORY.md \u2014 Your Memory Index (CRITICAL)
-
-\`MEMORY.md\` is the **entry point** to all your knowledge. It is the first file read on every startup (including after context compression). Structure it as an index that points to everything you know. This file is called \`MEMORY.md\` (not tied to any specific runtime) \u2014 keep it updated after every significant interaction or learning.
-
-\`\`\`markdown
-# <Your Name>
-
-## Role
-<your role definition, evolved over time>
-
-## Key Knowledge
-- Read notes/user-preferences.md for user preferences and conventions
-- Read notes/channels.md for what each channel is about and ongoing work
-- Read notes/domain.md for domain-specific knowledge and conventions
-- ...
-
-## Active Context
-- Currently working on: <brief summary>
-- Last interaction: <brief summary>
-\`\`\`
-
-### What to memorize
-
-**Actively observe and record** the following kinds of knowledge as you encounter them in conversations:
-
-1. **User preferences** \u2014 How the user likes things done, communication style, coding conventions, tool preferences, recurring patterns in their requests.
-2. **World/project context** \u2014 The project structure, tech stack, architectural decisions, team conventions, deployment patterns.
-3. **Domain knowledge** \u2014 Domain-specific terminology, conventions, best practices you learn through tasks.
-4. **Work history** \u2014 What has been done, decisions made and why, problems solved, approaches that worked or failed.
-5. **Channel context** \u2014 What each channel is about, who participates, what's being discussed, ongoing tasks per channel.
-6. **Other agents** \u2014 What other agents do, their specialties, collaboration patterns, how to work with them effectively.
-
-### How to organize memory
-
-- **MEMORY.md** is always the index. Keep it concise but comprehensive as a table of contents.
-- Create a \`notes/\` directory for detailed knowledge files. Use descriptive names:
-  - \`notes/user-preferences.md\` \u2014 User's preferences and conventions
-  - \`notes/channels.md\` \u2014 Summary of each channel and its purpose
-  - \`notes/work-log.md\` \u2014 Important decisions and completed work
-  - \`notes/<domain>.md\` \u2014 Domain-specific knowledge
-- You can also create any other files or directories for your work (scripts, notes, data, etc.)
-- **Update notes proactively** \u2014 Don't wait to be asked. When you learn something important, write it down.
-- **Keep MEMORY.md current** \u2014 After updating notes, update the index in MEMORY.md if new files were added.
-
-### Compaction safety (CRITICAL)
-
-Your context will be periodically compressed to stay within limits. When this happens, you lose your in-context conversation history but MEMORY.md is always re-read. Therefore:
-
-- **MEMORY.md must be self-sufficient as a recovery point.** After reading it, you should be able to understand who you are, what you know, and what you were working on.
-- **Before a long task**, write a brief "Active Context" note in MEMORY.md so you can resume if interrupted mid-task.
-- **After completing work**, update your notes and MEMORY.md index so nothing is lost.
-- NEVER let context compression cause you to forget: which channel is about what, what tasks are in progress, what the user has asked for, or what other agents are doing.
-
-## Capabilities
-
-You can work with any files or tools on this computer \u2014 you are not confined to any directory.
-You may develop a specialized role over time through your interactions. Embrace it.
-
-## Message Notifications
-
-While you are busy (executing tools, thinking, etc.), new messages may arrive. When this happens, you will receive a system notification like:
-
-\`[System notification: You have N new message(s) waiting. Call receive_message to read them when you're ready.]\`
-
-How to handle these:
-- **Do NOT interrupt your current work.** Finish what you're doing first.
-- After completing your current step, call \`mcp__chat__receive_message(block=false)\` to check for messages.
-- Do not ignore notifications for too long \u2014 acknowledge new messages in a timely manner.
-- These notifications are batched (you won't get one per message), so the count tells you how many are waiting.`;
-    if (config.description) {
-      systemPrompt += `
-
-## Initial role
-${config.description}. This may evolve.`;
-    }
-    return systemPrompt;
-  }
 };
 
 // ../shared/src/index.ts
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
-  { id: "codex", displayName: "Codex CLI", binary: "codex", supported: false },
+  { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
   { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: false },
   { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: false }
 ];
@@ -769,7 +1080,7 @@ function detectRuntimes() {
   const detected = [];
   for (const rt of RUNTIMES) {
     try {
-      execSync(`which ${rt.binary}`, { stdio: "pipe" });
+      execSync2(`which ${rt.binary}`, { stdio: "pipe" });
       detected.push(rt.id);
     } catch {
     }
@@ -787,12 +1098,12 @@ if (!serverUrl || !apiKey) {
   console.error("Usage: slock-daemon --server-url <url> --api-key <key>");
   process.exit(1);
 }
-var __dirname = path2.dirname(fileURLToPath(import.meta.url));
-var chatBridgePath = path2.resolve(__dirname, "chat-bridge.js");
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var chatBridgePath = path3.resolve(__dirname, "chat-bridge.js");
 try {
   accessSync(chatBridgePath);
 } catch {
-  chatBridgePath = path2.resolve(__dirname, "chat-bridge.ts");
+  chatBridgePath = path3.resolve(__dirname, "chat-bridge.ts");
 }
 var connection;
 var agentManager = new AgentProcessManager(chatBridgePath, (msg) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"
@@ -17,15 +17,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1",
-    "ws": "^8.18.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/node": "^22.12.0",
-    "@types/ws": "^8.5.13",
+    "@types/node": "^25.3.0",
+    "@types/ws": "^8.18.1",
     "tsup": "^8.5.1",
-    "typescript": "^5.7.3",
+    "typescript": "^5.9.3",
     "@slock-ai/shared": "0.1.0"
   },
   "scripts": {