@slock-ai/daemon 0.32.2-alpha.0 → 0.34.0

package/dist/index.js

@@ -1,2343 +1,26 @@
 #!/usr/bin/env node
 import {
-  buildWebSocketOptions
-} from "./chunk-GX2DVINN.js";
+  DAEMON_CLI_USAGE,
+  DaemonCore,
+  parseDaemonCliArgs
+} from "./chunk-ZXIMDHR7.js";
+import "./chunk-GX2DVINN.js";
 
 // src/index.ts
-import path5 from "path";
-import os2 from "os";
-import { createRequire } from "module";
-import { execSync as execSync2 } from "child_process";
-import { accessSync } from "fs";
-import { fileURLToPath } from "url";
-
-// src/connection.ts
-import WebSocket from "ws";
-
-// src/logger.ts
-function timestamp() {
-  const d = /* @__PURE__ */ new Date();
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
-function format(level, msg) {
-  return `${timestamp()} [${level}] ${msg}`;
-}
-var logger = {
-  info(msg) {
-    console.log(format("INFO", msg));
-  },
-  warn(msg) {
-    console.warn(format("WARN", msg));
-  },
-  error(msg, err) {
-    if (err) {
-      console.error(format("ERROR", msg), err);
-    } else {
-      console.error(format("ERROR", msg));
-    }
-  }
-};
-
-// src/connection.ts
-var systemClock = {
-  now: () => Date.now(),
-  setTimeout: (fn, ms) => setTimeout(fn, ms),
-  clearTimeout: (timer) => clearTimeout(timer)
-};
-var INBOUND_WATCHDOG_MS = 7e4;
-var DaemonConnection = class {
-  ws = null;
-  options;
-  clock;
-  reconnectTimer = null;
-  watchdogTimer = null;
-  reconnectDelay;
-  maxReconnectDelay = 3e4;
-  shouldConnect = true;
-  reconnectAttempt = 0;
-  lastDroppedSendLogAt = 0;
-  constructor(options) {
-    this.options = options;
-    this.clock = options.clock ?? systemClock;
-    this.reconnectDelay = options.minReconnectDelayMs ?? 1e3;
-  }
-  connect() {
-    this.shouldConnect = true;
-    if (this.reconnectTimer) return;
-    if (this.ws && this.ws.readyState !== WebSocket.CLOSED) return;
-    this.doConnect();
-  }
-  disconnect() {
-    this.shouldConnect = false;
-    this.clearWatchdog();
-    if (this.reconnectTimer) {
-      this.clock.clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      logger.info("[Daemon] Disconnect requested");
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  send(msg) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-      return;
-    }
-    const now = this.clock.now();
-    if (now - this.lastDroppedSendLogAt > 5e3) {
-      this.lastDroppedSendLogAt = now;
-      logger.warn(`[Daemon] Dropping outbound message while disconnected: ${msg.type}`);
-    }
-  }
-  get connected() {
-    return this.ws?.readyState === WebSocket.OPEN;
-  }
-  doConnect() {
-    if (!this.shouldConnect) return;
-    if (this.ws && this.ws.readyState !== WebSocket.CLOSED) return;
-    const wsUrl = this.options.serverUrl.replace(/^http/, "ws") + `/daemon/connect?key=${this.options.apiKey}`;
-    const wsOptions = buildWebSocketOptions(wsUrl, this.options.proxyEnv ?? process.env);
-    logger.info(`[Daemon] Connecting to ${this.options.serverUrl}...`);
-    if (wsOptions?.agent) {
-      logger.info("[Daemon] Using configured proxy for WebSocket connection");
-    }
-    const ws = this.options.wsFactory ? this.options.wsFactory(wsUrl, wsOptions) : new WebSocket(wsUrl, wsOptions);
-    this.ws = ws;
-    ws.on("open", () => {
-      if (this.ws !== ws) return;
-      if (!this.shouldConnect) return;
-      logger.info("[Daemon] Connected to server");
-      this.reconnectAttempt = 0;
-      this.reconnectDelay = this.options.minReconnectDelayMs ?? 1e3;
-      this.resetWatchdog();
-      this.options.onConnect();
-    });
-    ws.on("message", (data) => {
-      if (this.ws !== ws) return;
-      this.resetWatchdog();
-      try {
-        const msg = JSON.parse(data.toString());
-        this.options.onMessage(msg);
-      } catch (err) {
-        logger.error("[Daemon] Invalid message from server", err);
-      }
-    });
-    ws.on("close", (code, reasonBuffer) => {
-      if (this.ws !== ws) return;
-      this.ws = null;
-      this.clearWatchdog();
-      const reason = reasonBuffer.toString("utf8");
-      logger.warn(
-        `[Daemon] Disconnected from server (code=${code}, reason=${JSON.stringify(reason)}, reconnecting=${this.shouldConnect})`
-      );
-      this.options.onDisconnect();
-      this.scheduleReconnect();
-    });
-    ws.on("error", (err) => {
-      if (this.ws !== ws) return;
-      logger.error(`[Daemon] WebSocket error: ${err.message}`);
-    });
-  }
-  scheduleReconnect() {
-    if (!this.shouldConnect) return;
-    if (this.reconnectTimer) return;
-    this.reconnectAttempt += 1;
-    logger.info(`[Daemon] Reconnecting to server in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempt})`);
-    this.reconnectTimer = this.clock.setTimeout(() => {
-      this.reconnectTimer = null;
-      this.doConnect();
-    }, this.reconnectDelay);
-    this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
-  }
-  resetWatchdog() {
-    this.clearWatchdog();
-    const ms = this.options.inboundWatchdogMs ?? INBOUND_WATCHDOG_MS;
-    this.watchdogTimer = this.clock.setTimeout(() => {
-      logger.warn(`[Daemon] No inbound traffic for ${ms / 1e3}s \u2014 forcing reconnect`);
-      try {
-        this.ws?.terminate();
-      } catch {
-      }
-    }, ms);
-  }
-  clearWatchdog() {
-    if (this.watchdogTimer) {
-      this.clock.clearTimeout(this.watchdogTimer);
-      this.watchdogTimer = null;
-    }
-  }
-};
-
-// src/agentProcessManager.ts
-import { mkdir, writeFile, access, readdir, stat, readFile, rm } from "fs/promises";
-import path4 from "path";
-import os from "os";
-
-// src/drivers/claude.ts
-import { spawn } from "child_process";
-import { writeFileSync } from "fs";
-import path from "path";
-
-// src/drivers/systemPrompt.ts
-function toolRef(prefix, name) {
-  return `${prefix}${name}`;
-}
-function buildBaseSystemPrompt(config, opts) {
-  const t = (name) => toolRef(opts.toolPrefix, name);
-  const messageDeliveryText = opts.includeStdinNotificationSection ? "New messages will be delivered to you automatically via stdin." : "The daemon will automatically restart you when new messages arrive.";
-  const criticalRules = [
-    `- Always communicate through ${t("send_message")}. This is your only output channel.`,
-    ...opts.extraCriticalRules,
-    `- Use only the provided MCP tools for messaging \u2014 they are already available and ready.`,
-    `- Always claim a task via ${t("claim_tasks")} before starting work on it. If the claim fails, move on to a different task.`
-  ];
-  const startupSteps = [
-    `1. If this turn already includes a concrete incoming message, first decide whether that message needs a visible acknowledgment, blocker question, or ownership signal. If it does, send it early with ${t("send_message")} before deep context gathering.`,
-    `2. Read MEMORY.md (in your cwd) and then only the additional memory/files you need to handle the current turn well.`,
-    `3. If there is no concrete incoming message to handle, stop and wait. ${messageDeliveryText}`,
-    `4. When you receive a message, process it and reply with ${t("send_message")}.`,
-    `5. **Complete ALL your work before stopping.** If a task requires multi-step work (research, code changes, testing), finish everything, report results, then stop. New messages arrive automatically \u2014 you do not need to poll or wait for them.`
-  ];
-  let prompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration.
-
-## Who you are
-
-Your workspace and MEMORY.md persist across turns, so you can recover context when resumed. You will be started, put to sleep when idle, and woken up again when someone sends you a message. Think of yourself as a colleague 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("check_messages")}** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
-2. **${t("send_message")}** \u2014 Send a message to a channel or DM.
-3. **${t("list_server")}** \u2014 List all channels in this server, which ones you have joined, plus all agents and humans.
-4. **${t("read_history")}** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
-5. **${t("search_messages")}** \u2014 Search messages visible to you, then inspect a hit with \`${t("read_history")}\`.
-6. **${t("list_tasks")}** \u2014 View a channel's task board.
-7. **${t("create_tasks")}** \u2014 Create new task-messages in a channel (supports batch; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
-8. **${t("claim_tasks")}** \u2014 Claim tasks by number (supports batch, handles conflicts).
-9. **${t("unclaim_task")}** \u2014 Release your claim on a task.
-10. **${t("update_task_status")}** \u2014 Change a task's status (e.g. to in_review or done).
-11. **${t("upload_file")}** \u2014 Upload an image file to attach to a message. Returns an attachment ID to pass to send_message.
-12. **${t("view_file")}** \u2014 Download an attached image by its attachment ID so you can view it. Use when messages contain image attachments.
-
-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 have a single RFC 5424-style structured data header followed by the sender and content:
-
-\`\`\`
-[target=#general msg=a1b2c3d4 time=2026-03-15T01:00:00] @richard: hello everyone
-[target=#general msg=e5f6a7b8 time=2026-03-15T01:00:01 type=agent] @Alice: hi there
-[target=dm:@richard msg=c9d0e1f2 time=2026-03-15T01:00:02] @richard: hey, can you help?
-[target=#general:a1b2c3d4 msg=f3a4b5c6 time=2026-03-15T01:00:03] @richard: thread reply
-[target=dm:@richard:x9y8z7a0 msg=d7e8f9a0 time=2026-03-15T01:00:04] @richard: DM thread reply
-\`\`\`
-
-Header fields:
-- \`target=\` \u2014 where the message came from. Reuse as the \`target\` parameter when replying.
-- \`msg=\` \u2014 message short ID (first 8 chars of UUID). Use as thread suffix to start/reply in a thread.
-- \`time=\` \u2014 timestamp.
-- \`type=agent\` \u2014 present only if the sender is an agent.
-
-### Sending messages
-
-- **Reply to a channel**: \`send_message(target="#channel-name", content="...")\`
-- **Reply to a DM**: \`send_message(target="dm:@peer-name", content="...")\`
-- **Reply in a thread**: \`send_message(target="#channel:shortid", content="...")\` or \`send_message(target="dm:@peer:shortid", content="...")\`
-- **Start a NEW DM**: \`send_message(target="dm:@person-name", content="...")\`
-
-**IMPORTANT**: To reply to any message, always reuse the exact \`target\` from the received message. This ensures your reply goes to the right place \u2014 whether it's a channel, DM, or thread.
-
-### Threads
-
-Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main channel.
-
-- **Thread targets** have a colon and short ID suffix: \`#general:a1b2c3d4\` (thread in #general) or \`dm:@richard:x9y8z7a0\` (thread in a DM).
-- When you receive a message from a thread (the target has a \`:shortid\` suffix), **always reply using that same target** to keep the conversation in the thread.
-- **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=a1b2c3d4 ...]\`, reply with \`send_message(target="#general:a1b2c3d4", content="...")\`. The thread will be auto-created if it doesn't exist yet.
-- When you send a message, the response includes the message ID. You can use it to start a thread on your own message.
-- You can read thread history: \`read_history(channel="#general:a1b2c3d4")\`
-- Threads cannot be nested \u2014 you cannot start a thread inside a thread.
-
-### Discovering people and channels
-
-Call \`list_server\` to see all channels in this server, which ones you have joined, other agents, and humans.
-
-### Channel awareness
-
-Each channel has a **name** and optionally a **description** that define its purpose (visible via \`list_server\`). Respect them:
-- **Reply in context** \u2014 always respond in the channel/thread the message came from.
-- **Stay on topic** \u2014 when proactively sharing results or updates, post in the channel most relevant to the work. Don't scatter messages across unrelated channels.
-- If unsure where something belongs, call \`list_server\` to review channel descriptions.
-
-### Reading history
-
-\`read_history(channel="#channel-name")\` or \`read_history(channel="dm:@peer-name")\` or \`read_history(channel="#channel:shortid")\`
-
-To jump directly to a specific hit with nearby context, use \`read_history(channel="...", around="messageId")\` or \`read_history(channel="...", around=12345)\`.
-
-### Tasks
-
-When someone sends a message that asks you to do something \u2014 fix a bug, write code, review a PR, deploy, investigate an issue \u2014 that is work. Claim it before you start.
-
-**Decision rule:** if fulfilling a message requires you to take action beyond just replying (running tools, writing code, making changes), claim the message first. If you're only answering a question or having a conversation, no claim needed.
-
-**What you see in messages:**
-- A message already marked as a task: \`@Alice: Fix the login bug [task #3 status=in_progress]\`
-- A regular message (no task suffix): \`@Alice: Can someone look into the login bug?\`
-- A system notification about task changes: \`\u{1F4CB} Alice converted a message to task #3 "Fix the login bug"\`
-
-Only top-level channel / DM messages can become tasks. Messages inside threads are discussion context \u2014 reply there, but keep claims and conversions to top-level messages.
-
-\`read_history\` shows messages in their current state. If a message was later converted to a task, it will show the \`[task #N ...]\` suffix.
-
-**Status flow:** \`todo\` \u2192 \`in_progress\` \u2192 \`in_review\` \u2192 \`done\`
-
-**Assignee** is independent from status \u2014 a task can be claimed or unclaimed at any status except \`done\`.
-
-**Workflow:**
-1. Receive a message that requires action \u2192 claim it first (by task number if already a task, or by message ID if it's a regular message)
-2. If the claim fails, someone else is working on it \u2014 move on to another task
-3. Post updates in the task's thread: \`send_message(target="#channel:msgShortId", ...)\`
-4. When done, set status to \`in_review\` so a human can validate
-5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
-
-**What \`${t("create_tasks")}\` really means:**
-- Tasks live in the same chat flow as messages. A task is just a message with task metadata, not a separate source of truth.
-- \`${t("create_tasks")}\` is a convenience helper for a specific sequence: create a brand-new message, then publish that new message as a task-message.
-- \`${t("create_tasks")}\` only creates the task \u2014 to own it, call \`${t("claim_tasks")}\` afterward.
-- Typical uses for \`${t("create_tasks")}\` are breaking down a larger task into parallel subtasks, or batch-creating genuinely new work for others to claim.
-- If someone already sent the work item as a message, just claim that existing message/task instead of creating a new one.
-- If the work already exists as a message, reuse it via \`${t("claim_tasks")}\` with \`message_ids\`.
-
-**Creating new tasks:**
-- The task system exists to prevent duplicate work. If you see an existing task for the work, either claim that task or leave it alone.
-- If a message already shows a \`[task #N ...]\` suffix, claim \`#N\` if it is yours to take; otherwise move on.
-- Before calling \`${t("create_tasks")}\`, first check whether the work already exists on the task board or is already being handled.
-- Reuse existing tasks and threads instead of creating duplicates.
-- Use \`${t("create_tasks")}\` only for genuinely new subtasks or follow-up work that does not already have a canonical task.
-
-### Splitting tasks for parallel execution
-
-When you need to break down a large task into subtasks, structure them so agents can work **in parallel**:
-- **Group by phase** if tasks have dependencies. Label them clearly (e.g. "Phase 1: ...", "Phase 2: ...") so agents know what can run concurrently and what must wait.
-- **Prefer independent subtasks** that don't block each other. Each subtask should be completable without waiting for another.
-- **Avoid creating sequential chains** where each task depends on the previous one \u2014 this forces agents to work one at a time, wasting capacity.
-
-When you receive a notification about new tasks, check the task board and claim tasks relevant to your skills.
-
-## @Mentions
-
-In channel group chats, you can @mention people by their unique name (e.g. "@alice" or "@bob").
-- Your stable Slock @mention handle is \`@${config.name}\`.
-- Your display name is \`${config.displayName || config.name}\`. Treat it as presentation only \u2014 when reasoning about identity and @mentions, prefer your stable \`name\`.
-- Every human and agent has a unique \`name\` \u2014 this is their stable identifier for @mentions.
-- Mention others, not yourself \u2014 assign reviews and follow-ups to teammates.
-- @mentions only reach people inside 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.
-
-### Conversation etiquette
-
-- **Respect ongoing conversations.** If a human is having a back-and-forth with another person (human or agent) on a topic, their follow-up messages are directed at that person \u2014 only join if you are explicitly @mentioned or clearly addressed.
-- **Only the person doing the work should report on it.** If someone else completed a task or submitted a PR, don't echo or summarize their work \u2014 let them respond to questions about it.
-- **Claim before you start.** Always call \`${t("claim_tasks")}\` before doing any work on a task. If the claim fails, stop immediately and pick a different task.
-- **Before stopping, check for concrete blockers you own.** If you still owe a specific handoff, review, decision, or reply that is currently blocking a specific person, send one minimal actionable message to that person or channel before stopping.
-- **Skip idle narration.** Only send messages when you have actionable content \u2014 avoid broadcasting that you are waiting or idle.
-
-### Formatting \u2014 No HTML
-
-Use plain-text @mentions (e.g. \`@alice\`) and #channel references (e.g. \`#general\`, \`#1\`) \u2014 no HTML tags.
-
-When referencing a channel or mentioning someone, write them as plain text without backticks. Backtick-wrapped mentions render as code instead of interactive links.
-
-### Formatting \u2014 URLs in non-English text
-
-When writing a URL next to non-ASCII punctuation (Chinese, Japanese, etc.), always wrap the URL in angle brackets or use markdown link syntax. Otherwise the punctuation may be rendered as part of the URL.
-
-- **Wrong**: \`\u6D4B\u8BD5\u73AF\u5883\uFF1Ahttp://localhost:3000\uFF0C\u8BF7\u67E5\u770B\` (the \`\uFF0C\` gets swallowed into the link)
-- **Correct**: \`\u6D4B\u8BD5\u73AF\u5883\uFF1A<http://localhost:3000>\uFF0C\u8BF7\u67E5\u770B\`
-- **Also correct**: \`\u6D4B\u8BD5\u73AF\u5883\uFF1A[http://localhost:3000](http://localhost:3000)\uFF0C\u8BF7\u67E5\u770B\`
-
-## 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.
-- Keep MEMORY.md complete enough that context compression preserves: which channel is about what, what tasks are in progress, what the user has asked for, and 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 check_messages to read them when you're ready.]\`
-
-How to handle these:
-- Call \`${t("check_messages")}()\` to check for new messages. You are encouraged to do this frequently \u2014 at natural breakpoints in your work, or whenever you see a notification.
-- If the new message is higher priority, you may pivot to it. If not, continue your current work.
-- \`check_messages\` returns instantly with any pending messages (or "no new messages"). It is always safe to call.`;
-  }
-  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
-        }
-      }
-    });
-    let mcpConfigArg;
-    if (process.platform === "win32") {
-      const mcpConfigPath = path.join(ctx.workingDirectory, ".slock-claude-mcp.json");
-      writeFileSync(mcpConfigPath, mcpConfig, "utf8");
-      mcpConfigArg = mcpConfigPath;
-    } else {
-      mcpConfigArg = mcpConfig;
-    }
-    const args2 = [
-      "--allow-dangerously-skip-permissions",
-      "--dangerously-skip-permissions",
-      "--verbose",
-      "--output-format",
-      "stream-json",
-      "--input-format",
-      "stream-json",
-      "--mcp-config",
-      mcpConfigArg,
-      "--model",
-      ctx.config.model || "sonnet",
-      "--disallowed-tools",
-      "EnterPlanMode,ExitPlanMode"
-    ];
-    if (ctx.config.sessionId) {
-      args2.push("--resume", ctx.config.sessionId);
-    }
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", ...ctx.config.envVars || {} };
-    delete spawnEnv.CLAUDECODE;
-    const proc = spawn("claude", args2, {
-      cwd: ctx.workingDirectory,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: spawnEnv,
-      shell: process.platform === "win32"
-    });
-    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 = [];
-    const pushResultError = (message, fallback) => {
-      const parts = [];
-      if (Array.isArray(message.errors)) {
-        for (const err of message.errors) {
-          if (typeof err === "string" && err.trim()) parts.push(err.trim());
-        }
-      }
-      if (typeof message.result === "string" && message.result.trim()) {
-        parts.push(message.result.trim());
-      }
-      const detail = parts.join(" | ") || fallback;
-      events.push({ kind: "error", message: detail });
-    };
-    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": {
-        const subtype = typeof event.subtype === "string" ? event.subtype : "success";
-        const stopReason = typeof event.stop_reason === "string" ? event.stop_reason : null;
-        switch (subtype) {
-          case "success":
-            if (event.is_error && stopReason !== "max_tokens") {
-              pushResultError(event, "Execution failed");
-            }
-            break;
-          case "error_during_execution":
-            if (stopReason !== "max_tokens") {
-              pushResultError(event, "Execution failed");
-            }
-            break;
-          case "error_max_budget_usd":
-            pushResultError(event, "Budget limit exceeded");
-            break;
-          case "error_max_turns":
-            pushResultError(event, "Max turns exceeded");
-            break;
-          case "error_max_structured_output_retries":
-            pushResultError(event, "Structured output retries exceeded");
-            break;
-        }
-        events.push({ kind: "turn_end", sessionId: event.session_id });
-        break;
-      }
-    }
-    return events;
-  }
-  encodeStdinMessage(text, sessionId, _opts) {
-    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 === "mcp__chat__upload_file") return "Uploading file\u2026";
-    if (name === "mcp__chat__view_file") return "Viewing file\u2026";
-    if (name === "mcp__chat__list_tasks") return "Listing tasks\u2026";
-    if (name === "mcp__chat__create_tasks") return "Creating tasks\u2026";
-    if (name === "mcp__chat__claim_tasks") return "Claiming tasks\u2026";
-    if (name === "mcp__chat__unclaim_task") return "Unclaiming task\u2026";
-    if (name === "mcp__chat__update_task_status") return "Updating task status\u2026";
-    if (name === "mcp__chat__list_server") return "Listing server\u2026";
-    if (name === "mcp__chat__read_history") return "Reading history\u2026";
-    if (name === "mcp__chat__search_messages") return "Searching messages\u2026";
-    if (name === "mcp__chat__check_messages") return "Checking messages\u2026";
-    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.target || input.channel || (input.dm_to ? `DM:@${input.dm_to}` : "");
-      }
-      if (name === "mcp__chat__read_history") return input.target || input.channel || "";
-      if (name === "mcp__chat__search_messages") return input.query || "";
-      if (name === "mcp__chat__list_tasks") return input.channel || "";
-      if (name === "mcp__chat__create_tasks") return input.channel || "";
-      if (name === "mcp__chat__claim_tasks") {
-        const nums = input.task_numbers;
-        return input.channel ? `${input.channel} #${Array.isArray(nums) ? nums.join(",#t") : nums}` : "";
-      }
-      if (name === "mcp__chat__unclaim_task") {
-        return input.channel ? `${input.channel} #${input.task_number}` : "";
-      }
-      if (name === "mcp__chat__update_task_status") {
-        return input.channel ? `${input.channel} #${input.task_number}` : "";
-      }
-      if (name === "mcp__chat__upload_file") return input.file_path || "";
-      return "";
-    } catch {
-      return "";
-    }
-  }
-};
-
-// src/drivers/codex.ts
-import { spawn as spawn2, execSync } from "child_process";
-import { existsSync } from "fs";
-import path2 from "path";
-var CodexDriver = class {
-  id = "codex";
-  supportsStdinNotification = false;
-  mcpToolPrefix = "mcp_chat_";
-  spawn(ctx) {
-    const gitDir = path2.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(
-      "--dangerously-bypass-approvals-and-sandbox",
-      "--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=300",
-      "-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", ...ctx.config.envVars || {} };
-    let spawnCmd = "codex";
-    let spawnArgs = args2;
-    if (process.platform === "win32") {
-      let codexEntry = null;
-      try {
-        const globalRoot = execSync("npm root -g", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-        const candidate = path2.join(globalRoot, "@openai", "codex", "bin", "codex.js");
-        if (existsSync(candidate)) codexEntry = candidate;
-      } catch {
-      }
-      if (!codexEntry) {
-        try {
-          const cmdPath = execSync("where codex", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim().split(/\r?\n/)[0];
-          const candidate = path2.join(path2.dirname(cmdPath), "node_modules", "@openai", "codex", "bin", "codex.js");
-          if (existsSync(candidate)) codexEntry = candidate;
-        } catch {
-        }
-      }
-      if (!codexEntry) {
-        throw new Error(
-          "Cannot resolve Codex CLI entry point on Windows. Ensure @openai/codex is installed globally via npm (npm i -g @openai/codex)."
-        );
-      }
-      spawnCmd = process.execPath;
-      spawnArgs = [codexEntry, ...args2];
-    }
-    const proc = spawn2(spawnCmd, spawnArgs, {
-      cwd: ctx.workingDirectory,
-      stdio: ["ignore", "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, _opts) {
-    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."
-      ],
-      postStartupNotes: [
-        "**IMPORTANT**: Your process exits after each turn completes. You will be automatically restarted when new messages arrive. Complete all your work, then stop \u2014 new messages will wake you up."
-      ],
-      includeStdinNotificationSection: false
-    });
-  }
-  toolDisplayName(name) {
-    if (name === `${this.mcpToolPrefix}upload_file`) return "Uploading file\u2026";
-    if (name === `${this.mcpToolPrefix}view_file`) return "Viewing file\u2026";
-    if (name === `${this.mcpToolPrefix}list_tasks`) return "Listing tasks\u2026";
-    if (name === `${this.mcpToolPrefix}create_tasks`) return "Creating tasks\u2026";
-    if (name === `${this.mcpToolPrefix}claim_tasks`) return "Claiming tasks\u2026";
-    if (name === `${this.mcpToolPrefix}unclaim_task`) return "Unclaiming task\u2026";
-    if (name === `${this.mcpToolPrefix}update_task_status`) return "Updating task status\u2026";
-    if (name === `${this.mcpToolPrefix}list_server`) return "Listing server\u2026";
-    if (name === `${this.mcpToolPrefix}read_history`) return "Reading history\u2026";
-    if (name === `${this.mcpToolPrefix}search_messages`) return "Searching messages\u2026";
-    if (name === `${this.mcpToolPrefix}check_messages`) return "Checking messages\u2026";
-    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.target || input.channel || (input.dm_to ? `DM:@${input.dm_to}` : "");
-      }
-      if (name === `${this.mcpToolPrefix}read_history`) return input.target || input.channel || "";
-      if (name === `${this.mcpToolPrefix}search_messages`) return input.query || "";
-      if (name === `${this.mcpToolPrefix}list_tasks`) return input.channel || "";
-      if (name === `${this.mcpToolPrefix}create_tasks`) return input.channel || "";
-      if (name === `${this.mcpToolPrefix}claim_tasks`) {
-        const nums = input.task_numbers;
-        return input.channel ? `${input.channel} #${Array.isArray(nums) ? nums.join(",#") : nums}` : "";
-      }
-      if (name === `${this.mcpToolPrefix}unclaim_task`) {
-        return input.channel ? `${input.channel} #${input.task_number}` : "";
-      }
-      if (name === `${this.mcpToolPrefix}update_task_status`) {
-        return input.channel ? `${input.channel} #${input.task_number}` : "";
-      }
-      if (name === `${this.mcpToolPrefix}upload_file`) return input.file_path || "";
-      return "";
-    } catch {
-      return "";
-    }
-  }
-};
-
-// src/drivers/kimi.ts
-import { randomUUID } from "crypto";
-import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync2, writeFileSync as writeFileSync2 } from "fs";
-import path3 from "path";
-var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
-var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
-var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
-var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
-function parseToolArguments(raw) {
-  if (typeof raw !== "string") return raw;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return raw;
-  }
-}
-var KimiDriver = class {
-  id = "kimi";
-  supportsStdinNotification = true;
-  mcpToolPrefix = "";
-  deliverMessageDirectlyWhileBusy = true;
-  sessionId = null;
-  sessionAnnounced = false;
-  promptRequestId = null;
-  spawn(ctx) {
-    const isResume = !!ctx.config.sessionId;
-    this.sessionId = ctx.config.sessionId || randomUUID();
-    this.sessionAnnounced = false;
-    this.promptRequestId = randomUUID();
-    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 systemPromptPath = path3.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
-    const agentFilePath = path3.join(ctx.workingDirectory, KIMI_AGENT_FILE);
-    const mcpConfigPath = path3.join(ctx.workingDirectory, KIMI_MCP_FILE);
-    if (!isResume || !existsSync2(systemPromptPath)) {
-      writeFileSync2(systemPromptPath, ctx.prompt, "utf8");
-    }
-    writeFileSync2(agentFilePath, [
-      "version: 1",
-      "agent:",
-      "  extend: default",
-      `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
-      ""
-    ].join("\n"), "utf8");
-    writeFileSync2(mcpConfigPath, JSON.stringify({
-      mcpServers: {
-        chat: {
-          command,
-          args: bridgeArgs
-        }
-      }
-    }), "utf8");
-    const args2 = [
-      "--wire",
-      "--yolo",
-      "--agent-file",
-      agentFilePath,
-      "--mcp-config-file",
-      mcpConfigPath,
-      "--session",
-      this.sessionId
-    ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args2.push("--model", ctx.config.model);
-    }
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" };
-    const proc = spawn3("kimi", args2, {
-      cwd: ctx.workingDirectory,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: spawnEnv,
-      shell: process.platform === "win32"
-    });
-    proc.stdin?.write(JSON.stringify({
-      jsonrpc: "2.0",
-      id: randomUUID(),
-      method: "initialize",
-      params: {
-        protocol_version: KIMI_WIRE_PROTOCOL_VERSION,
-        client: { name: "slock-daemon", version: "1.0.0" },
-        capabilities: {
-          supports_question: false,
-          supports_plan_mode: false
-        }
-      }
-    }) + "\n");
-    proc.stdin?.write(JSON.stringify({
-      jsonrpc: "2.0",
-      id: this.promptRequestId,
-      method: "prompt",
-      params: {
-        user_input: isResume ? ctx.prompt : "Your system prompt contains your standing instructions. Follow it now and begin listening for messages."
-      }
-    }) + "\n");
-    return { process: proc };
-  }
-  parseLine(line) {
-    let message;
-    try {
-      message = JSON.parse(line);
-    } catch {
-      return [];
-    }
-    const events = [];
-    if (!this.sessionAnnounced && this.sessionId) {
-      events.push({ kind: "session_init", sessionId: this.sessionId });
-      this.sessionAnnounced = true;
-    }
-    if ("method" in message && message.method === "event") {
-      const eventType = message.params?.type;
-      const payload = message.params?.payload || {};
-      switch (eventType) {
-        case "StepBegin":
-          events.push({ kind: "thinking", text: "" });
-          break;
-        case "ContentPart":
-          if (payload.type === "think" && payload.think) {
-            events.push({ kind: "thinking", text: payload.think });
-          } else if (payload.type === "text" && payload.text) {
-            events.push({ kind: "text", text: payload.text });
-          }
-          break;
-        case "ToolCall":
-          events.push({
-            kind: "tool_call",
-            name: payload.function?.name || "unknown_tool",
-            input: parseToolArguments(payload.function?.arguments)
-          });
-          break;
-        case "TurnEnd":
-          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
-          break;
-        case "StepInterrupted":
-          events.push({ kind: "error", message: "Turn interrupted" });
-          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
-          break;
-      }
-      return events;
-    }
-    if ("error" in message) {
-      events.push({ kind: "error", message: message.error?.message || "Unknown Kimi error" });
-      events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
-    }
-    return events;
-  }
-  encodeStdinMessage(_text, _sessionId, opts) {
-    const mode = opts?.mode || "busy";
-    if (mode === "idle") {
-      return JSON.stringify({
-        jsonrpc: "2.0",
-        id: randomUUID(),
-        method: "prompt",
-        params: {
-          user_input: _text
-        }
-      });
-    }
-    return JSON.stringify({
-      jsonrpc: "2.0",
-      id: randomUUID(),
-      method: "steer",
-      params: {
-        user_input: _text
-      }
-    });
-  }
-  buildSystemPrompt(config, _agentId) {
-    return buildBaseSystemPrompt(config, {
-      toolPrefix: "",
-      extraCriticalRules: [
-        "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything."
-      ],
-      postStartupNotes: [],
-      includeStdinNotificationSection: true
-    });
-  }
-  toolDisplayName(name) {
-    if (name === "list_tasks") return "Viewing task board\u2026";
-    if (name === "create_tasks") return "Creating tasks\u2026";
-    if (name === "claim_tasks") return "Claiming tasks\u2026";
-    if (name === "unclaim_task") return "Unclaiming task\u2026";
-    if (name === "update_task_status") return "Updating task\u2026";
-    if (name === "send_message" || name === "receive_message" || name === "read_history" || name === "list_server") return "";
-    if (name === "Shell") return "Running command\u2026";
-    if (name === "ReadFile") return "Reading file\u2026";
-    if (name === "WriteFile" || name === "StrReplaceFile") return "Editing file\u2026";
-    if (name === "Glob" || name === "Grep") return "Searching code\u2026";
-    if (name === "SearchWeb") return "Searching web\u2026";
-    if (name === "FetchURL") return "Fetching web\u2026";
-    if (name === "SetTodoList") 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 === "Shell") {
-        const cmd = input.command || "";
-        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
-      }
-      if (name === "ReadFile" || name === "WriteFile" || name === "StrReplaceFile") {
-        return input.path || "";
-      }
-      if (name === "Glob" || name === "Grep") return input.pattern || input.query || "";
-      if (name === "SearchWeb") return input.query || "";
-      if (name === "FetchURL") return input.url || "";
-      if (name === "send_message") return input.target || input.channel || "";
-      if (name === "read_history") return input.target || input.channel || "";
-      if (name === "list_tasks") return input.channel || "";
-      if (name === "create_tasks") return input.channel || "";
-      if (name === "claim_tasks") {
-        const nums = input.task_numbers;
-        return input.channel ? `${input.channel} #t${Array.isArray(nums) ? nums.join(",#t") : nums}` : "";
-      }
-      if (name === "unclaim_task" || name === "update_task_status") {
-        return input.channel ? `${input.channel} #t${input.task_number}` : "";
-      }
-      return "";
-    } catch {
-      return "";
-    }
-  }
-};
-
-// src/drivers/index.ts
-var driverFactories = {
-  claude: () => new ClaudeDriver(),
-  codex: () => new CodexDriver(),
-  kimi: () => new KimiDriver()
-};
-function getDriver(runtimeId) {
-  const createDriver = driverFactories[runtimeId];
-  const driver = createDriver?.();
-  if (!driver) {
-    throw new Error(`Unknown runtime: ${runtimeId}. Available: ${Object.keys(driverFactories).join(", ")}`);
-  }
-  return driver;
-}
-
-// src/agentProcessManager.ts
-var DATA_DIR = path4.join(os.homedir(), ".slock", "agents");
-function toLocalTime(iso) {
-  const d = new Date(iso);
-  if (isNaN(d.getTime())) return iso;
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
-function formatChannelLabel(message) {
-  return message.channel_type === "dm" ? `DM:@${message.channel_name}` : `#${message.channel_name}`;
-}
-function formatMessageTarget(message) {
-  if (message.channel_type === "thread" && message.parent_channel_name) {
-    const shortId = message.channel_name.startsWith("thread-") ? message.channel_name.slice(7) : message.channel_name;
-    if (message.parent_channel_type === "dm") {
-      return `dm:@${message.parent_channel_name}:${shortId}`;
-    }
-    return `#${message.parent_channel_name}:${shortId}`;
-  }
-  if (message.channel_type === "dm") {
-    return `dm:@${message.channel_name}`;
-  }
-  return `#${message.channel_name}`;
-}
-function formatIncomingMessage(message) {
-  const target = formatMessageTarget(message);
-  const msgId = message.message_id ? message.message_id.slice(0, 8) : "-";
-  const time = message.timestamp ? toLocalTime(message.timestamp) : "-";
-  const senderType = message.sender_type === "agent" ? " type=agent" : "";
-  const renderedContent = message.content;
-  const attachSuffix = message.attachments?.length ? ` [${message.attachments.length} image${message.attachments.length > 1 ? "s" : ""}: ${message.attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to see]` : "";
-  const taskSuffix = message.task_status ? ` [task #${message.task_number} status=${message.task_status}${message.task_assignee_id ? ` assignee=${message.task_assignee_type}:${message.task_assignee_id}` : ""}]` : "";
-  return `[target=${target} msg=${msgId} time=${time}${senderType}] @${message.sender_name}: ${renderedContent}${attachSuffix}${taskSuffix}`;
-}
-function buildUnreadSummary(messages, excludeChannel) {
-  const summary = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    const label = formatChannelLabel(message);
-    if (excludeChannel && label === excludeChannel) continue;
-    summary.set(label, (summary.get(label) || 0) + 1);
-  }
-  return summary.size > 0 ? Object.fromEntries(summary) : void 0;
-}
-var MAX_TRAJECTORY_TEXT = 2e3;
-var TRAJECTORY_COALESCE_MS = 350;
-var ACTIVITY_HEARTBEAT_MS = 6e4;
-var MAX_STDOUT_LINES = 8;
-var MAX_STDOUT_LINE_LENGTH = 240;
-var MAX_STDERR_LINES = 8;
-var MAX_STDERR_LINE_LENGTH = 240;
-function pushRecentLines(lines, chunk, maxLines, maxLineLength) {
-  const next = [...lines];
-  for (const rawLine of chunk.split(/\r?\n/)) {
-    const text = rawLine.trim();
-    if (!text) continue;
-    next.push(
-      text.length > maxLineLength ? `${text.slice(0, maxLineLength)}...` : text
-    );
-  }
-  return next.slice(-maxLines);
-}
-function pushRecentStderr(lines, chunk) {
-  return pushRecentLines(lines, chunk, MAX_STDERR_LINES, MAX_STDERR_LINE_LENGTH);
-}
-function pushRecentStdout(lines, chunk) {
-  return pushRecentLines(lines, chunk, MAX_STDOUT_LINES, MAX_STDOUT_LINE_LENGTH);
-}
-function formatCrashReason(code, signal, ap) {
-  const parts = [];
-  if (signal) {
-    parts.push(`signal ${signal}`);
-  } else if (typeof code === "number") {
-    parts.push(`exit code ${code}`);
-  } else {
-    parts.push("unknown exit");
-  }
-  if (ap.spawnError) {
-    parts.push(`spawn error: ${ap.spawnError}`);
-  }
-  if (ap.lastRuntimeError) {
-    parts.push(`runtime error: ${ap.lastRuntimeError}`);
-  }
-  if (ap.recentStderr.length > 0) {
-    parts.push(`stderr: ${ap.recentStderr.join(" | ")}`);
-  }
-  if (!ap.lastRuntimeError && ap.recentStdout.length > 0) {
-    parts.push(`stdout: ${ap.recentStdout.join(" | ")}`);
-  }
-  return parts.join(" | ");
-}
-function summarizeCrash(code, signal) {
-  if (signal) return `signal ${signal}`;
-  if (typeof code === "number") return `exit code ${code}`;
-  return "unknown exit";
-}
-function isMissingResumeSession(ap) {
-  if (ap.driver.id !== "claude") return false;
-  if (!ap.sessionId) return false;
-  return /No conversation found with session ID/i.test(ap.lastRuntimeError || "");
-}
-function getMessageDeliveryText(supportsStdinNotification) {
-  return supportsStdinNotification ? "New messages will be delivered to you automatically via stdin." : "The daemon will automatically restart you when new messages arrive.";
-}
-var AgentProcessManager = class _AgentProcessManager {
-  agents = /* @__PURE__ */ new Map();
-  agentsStarting = /* @__PURE__ */ new Set();
-  // Prevent concurrent starts of same agent
-  startingInboxes = /* @__PURE__ */ new Map();
-  /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
-  idleAgentConfigs = /* @__PURE__ */ new Map();
-  chatBridgePath;
-  sendToServer;
-  daemonApiKey;
-  dataDir;
-  driverResolver;
-  constructor(chatBridgePath2, sendToServer, daemonApiKey, opts = {}) {
-    this.chatBridgePath = chatBridgePath2;
-    this.sendToServer = sendToServer;
-    this.daemonApiKey = daemonApiKey;
-    this.dataDir = opts.dataDir || DATA_DIR;
-    this.driverResolver = opts.driverResolver || getDriver;
-  }
-  async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
-    if (this.agents.has(agentId)) {
-      logger.info(`[Agent ${agentId}] Start ignored (already running)`);
-      return;
-    }
-    if (this.agentsStarting.has(agentId)) {
-      logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
-      return;
-    }
-    this.agentsStarting.add(agentId);
-    try {
-      const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path4.join(this.dataDir, agentId);
-      await mkdir(agentDataDir, { recursive: true });
-      const memoryMdPath = path4.join(agentDataDir, "MEMORY.md");
-      try {
-        await access(memoryMdPath);
-      } catch {
-        const agentName = config.displayName || config.name;
-        const initialMemoryMd = `# ${agentName}
-
-## Role
-${config.description || "No role defined yet."}
-
-## Key Knowledge
-- No notes yet.
-
-## Active Context
-- First startup.
-`;
-        await writeFile(memoryMdPath, initialMemoryMd);
-      }
-      await mkdir(path4.join(agentDataDir, "notes"), { recursive: true });
-      const isResume = !!config.sessionId;
-      let prompt;
-      if (isResume && resumePrompt) {
-        prompt = resumePrompt;
-        if (driver.supportsStdinNotification) {
-          prompt += `
-
-Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.`;
-        }
-      } else if (wakeMessage) {
-        const channelLabel = formatChannelLabel(wakeMessage);
-        prompt = `New message received:
-
-${formatIncomingMessage(wakeMessage)}`;
-        if (unreadSummary && Object.keys(unreadSummary).length > 0) {
-          const otherUnread = Object.entries(unreadSummary).filter(([key]) => key !== channelLabel);
-          if (otherUnread.length > 0) {
-            prompt += `
-
-You also have unread messages in other channels:`;
-            for (const [ch, count] of otherUnread) {
-              prompt += `
-- ${ch}: ${count} unread`;
-            }
-            prompt += `
-
-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. Complete ALL your work before stopping.
-
-IMPORTANT: If the message requires multi-step work (e.g. research, code changes, testing), complete ALL steps before stopping. Sending a progress update does NOT mean your task is done \u2014 only stop when you have NO more work to do. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
-        if (driver.supportsStdinNotification) {
-          prompt += `
-
-Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.`;
-        }
-      } 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)) {
-          prompt += `
-- ${ch}: ${count} unread`;
-        }
-        prompt += `
-
-Use read_history to catch up on the channels listed above, then stop. Read each listed channel at most once unless a read fails. Do NOT call check_messages in this mode. If the history reveals a direct request, assignment, @mention, review request, or task clearly addressed to you, switch into active handling instead of stopping: reply with send_message and claim the relevant task before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
-      } else if (isResume) {
-        prompt = `No new messages while you were away. Nothing to do \u2014 just stop. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
-        if (driver.supportsStdinNotification) {
-          prompt += `
-
-Note: While you are busy, you may receive [System notification: ...] messages about new messages. Finish your current step, then call check_messages to check for messages.`;
-        }
-      } else {
-        prompt = driver.buildSystemPrompt(config, agentId);
-      }
-      const { process: proc } = driver.spawn({
-        agentId,
-        config,
-        prompt,
-        workingDirectory: agentDataDir,
-        chatBridgePath: this.chatBridgePath,
-        daemonApiKey: this.daemonApiKey
-      });
-      const agentProcess = {
-        process: proc,
-        driver,
-        inbox: this.startingInboxes.get(agentId) || [],
-        config,
-        sessionId: config.sessionId || null,
-        launchId: launchId || null,
-        isIdle: false,
-        notificationTimer: null,
-        pendingNotificationCount: 0,
-        activityHeartbeat: null,
-        lastActivity: "",
-        lastActivityDetail: "",
-        recentStdout: [],
-        recentStderr: [],
-        lastRuntimeError: null,
-        spawnError: null,
-        exitCode: null,
-        exitSignal: null,
-        pendingTrajectory: null
-      };
-      this.startingInboxes.delete(agentId);
-      this.agents.set(agentId, agentProcess);
-      this.agentsStarting.delete(agentId);
-      let buffer = "";
-      proc.stdout?.on("data", (chunk) => {
-        const chunkText = chunk.toString();
-        const current = this.agents.get(agentId);
-        if (current) {
-          current.recentStdout = pushRecentStdout(current.recentStdout, chunkText);
-        }
-        buffer += chunkText;
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          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) return;
-        if (/Reconnecting\.\.\.|Falling back from WebSockets/i.test(text)) return;
-        const current = this.agents.get(agentId);
-        if (current) {
-          current.recentStderr = pushRecentStderr(current.recentStderr, text);
-        }
-        logger.error(`[Agent ${agentId} stderr]: ${text}`);
-      });
-      proc.on("error", (err) => {
-        const current = this.agents.get(agentId);
-        if (current) current.spawnError = err.message;
-        logger.error(`[Agent ${agentId}] Process error: ${err.message}`);
-      });
-      proc.on("exit", (code, signal) => {
-        const current = this.agents.get(agentId);
-        if (current && current.process === proc) {
-          current.exitCode = code;
-          current.exitSignal = signal;
-        }
-        logger.info(`[Agent ${agentId}] Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}`);
-      });
-      proc.on("close", (code, signal) => {
-        if (this.agents.has(agentId)) {
-          const ap = this.agents.get(agentId);
-          if (ap.process !== proc) return;
-          if (ap.notificationTimer) {
-            clearTimeout(ap.notificationTimer);
-          }
-          if (ap.pendingTrajectory?.timer) {
-            clearTimeout(ap.pendingTrajectory.timer);
-          }
-          if (ap.activityHeartbeat) {
-            clearInterval(ap.activityHeartbeat);
-          }
-          this.agents.delete(agentId);
-          const finalCode = ap.exitCode ?? code;
-          const finalSignal = ap.exitSignal ?? signal;
-          if (finalCode === 0) {
-            const queuedWakeMessage = !ap.driver.supportsStdinNotification ? ap.inbox.shift() : void 0;
-            const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
-            if (queuedWakeMessage) {
-              logger.info(`[Agent ${agentId}] Turn completed; restarting immediately for queued message`);
-              const nextConfig = { ...ap.config, sessionId: ap.sessionId };
-              this.idleAgentConfigs.set(agentId, {
-                config: nextConfig,
-                sessionId: ap.sessionId,
-                launchId: ap.launchId
-              });
-              this.broadcastActivity(agentId, "working", "Message received");
-              this.idleAgentConfigs.delete(agentId);
-              this.startAgent(agentId, nextConfig, queuedWakeMessage, unreadSummary2, void 0, ap.launchId || void 0).catch((err) => {
-                logger.error(`[Agent ${agentId}] Failed to continue with queued message`, err);
-                this.idleAgentConfigs.set(agentId, {
-                  config: nextConfig,
-                  sessionId: ap.sessionId,
-                  launchId: ap.launchId
-                });
-                this.broadcastActivity(agentId, "online", "Process idle");
-              });
-              return;
-            }
-            this.idleAgentConfigs.set(agentId, {
-              config: { ...ap.config, sessionId: ap.sessionId },
-              sessionId: ap.sessionId,
-              launchId: ap.launchId
-            });
-            if (!ap.driver.supportsStdinNotification) {
-              logger.info(`[Agent ${agentId}] Turn completed; cached idle state for future restart`);
-            }
-            this.broadcastActivity(agentId, "online", "Process idle");
-          } else {
-            this.idleAgentConfigs.delete(agentId);
-            const reason = formatCrashReason(finalCode, finalSignal, ap);
-            const summary = summarizeCrash(finalCode, finalSignal);
-            if (isMissingResumeSession(ap)) {
-              const staleSessionId = ap.sessionId;
-              const restartConfig = { ...ap.config, sessionId: null };
-              logger.warn(
-                `[Agent ${agentId}] Stored Claude session ${staleSessionId} is unavailable locally; falling back to cold start`
-              );
-              this.broadcastActivity(
-                agentId,
-                "working",
-                "Stored Claude session missing; cold-starting a new session\u2026",
-                [{ kind: "text", text: `Stored Claude session ${staleSessionId} was not found locally. Falling back to a cold start.` }]
-              );
-              this.startAgent(agentId, restartConfig, void 0, void 0, void 0, ap.launchId || void 0).catch((err) => {
-                logger.error(`[Agent ${agentId}] Cold start recovery failed`, err);
-                this.sendAgentStatus(agentId, "inactive", ap.launchId);
-                this.broadcastActivity(agentId, "offline", `Crashed (${summary})`);
-              });
-              return;
-            }
-            logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
-            this.sendAgentStatus(agentId, "inactive", ap.launchId);
-            this.broadcastActivity(agentId, "offline", `Crashed (${summary})`);
-          }
-        }
-      });
-      this.sendAgentStatus(agentId, "active", launchId || null);
-      this.broadcastActivity(agentId, "working", "Starting\u2026");
-    } catch (err) {
-      this.agentsStarting.delete(agentId);
-      throw err;
-    }
-  }
-  async stopAgent(agentId, { wait = false, silent = false } = {}) {
-    this.idleAgentConfigs.delete(agentId);
-    const ap = this.agents.get(agentId);
-    if (!ap) {
-      if (!silent) {
-        logger.info(`[Agent ${agentId}] Stop requested but no running process was found`);
-      }
-      return;
-    }
-    if (ap.notificationTimer) {
-      clearTimeout(ap.notificationTimer);
-    }
-    if (ap.activityHeartbeat) {
-      clearInterval(ap.activityHeartbeat);
-    }
-    this.agents.delete(agentId);
-    ap.process.kill("SIGTERM");
-    if (!silent) {
-      this.sendAgentStatus(agentId, "inactive", ap.launchId);
-      this.broadcastActivity(agentId, "offline", "Stopped");
-      logger.info(`[Agent ${agentId}] Stopped by request`);
-    }
-    if (wait) {
-      await new Promise((resolve) => {
-        const forceKillTimer = setTimeout(() => {
-          if (!silent) {
-            logger.warn(`[Agent ${agentId}] Stop timed out; force killing`);
-          }
-          try {
-            ap.process.kill("SIGKILL");
-          } catch {
-          }
-          resolve();
-        }, 5e3);
-        ap.process.on("exit", () => {
-          clearTimeout(forceKillTimer);
-          resolve();
-        });
-        if (ap.process.exitCode !== null || ap.process.signalCode !== null) {
-          clearTimeout(forceKillTimer);
-          resolve();
-        }
-      });
-    }
-  }
-  deliverMessage(agentId, message) {
-    const ap = this.agents.get(agentId);
-    if (!ap) {
-      if (this.agentsStarting.has(agentId)) {
-        const pending = this.startingInboxes.get(agentId) || [];
-        pending.push(message);
-        this.startingInboxes.set(agentId, pending);
-        return;
-      }
-      const cached = this.idleAgentConfigs.get(agentId);
-      if (cached) {
-        logger.info(`[Agent ${agentId}] Starting from idle state for new message`);
-        this.idleAgentConfigs.delete(agentId);
-        this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).catch((err) => {
-          logger.error(`[Agent ${agentId}] Failed to auto-restart`, err);
-        });
-      }
-      return;
-    }
-    if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
-      ap.isIdle = false;
-      this.broadcastActivity(agentId, "working", "Message received");
-      this.deliverMessagesViaStdin(agentId, ap, [message], "idle");
-      return;
-    }
-    ap.inbox.push(message);
-    if (!ap.driver.supportsStdinNotification) return;
-    if (!ap.sessionId) return;
-    ap.pendingNotificationCount++;
-    if (!ap.notificationTimer) {
-      ap.notificationTimer = setTimeout(() => {
-        this.sendStdinNotification(agentId);
-      }, 3e3);
-    }
-  }
-  async resetWorkspace(agentId) {
-    const agentDataDir = path4.join(this.dataDir, agentId);
-    try {
-      await rm(agentDataDir, { recursive: true, force: true });
-      logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
-    } catch (err) {
-      logger.error(`[Agent ${agentId}] Workspace reset failed`, err);
-    }
-  }
-  async stopAll() {
-    this.idleAgentConfigs.clear();
-    const ids = [...this.agents.keys()];
-    await Promise.all(ids.map((id) => this.stopAgent(id, { wait: true, silent: true })));
-  }
-  getRunningAgentIds() {
-    return [...this.agents.keys()];
-  }
-  getAgentSessionId(agentId) {
-    return this.agents.get(agentId)?.sessionId ?? null;
-  }
-  getAgentLaunchId(agentId) {
-    return this.agents.get(agentId)?.launchId ?? null;
-  }
-  getIdleAgentSessionIds() {
-    const result = [];
-    for (const [agentId, { sessionId, launchId }] of this.idleAgentConfigs) {
-      if (sessionId) result.push({ agentId, sessionId, launchId });
-    }
-    return result;
-  }
-  // Machine-level workspace scanning
-  async scanAllWorkspaces() {
-    const results = [];
-    let entries;
-    try {
-      entries = await readdir(this.dataDir, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const dirPath = path4.join(this.dataDir, 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 = path4.join(dirPath, item.name);
-          try {
-            const info = await stat(itemPath);
-            if (item.isFile()) {
-              totalSize += info.size;
-              fileCount++;
-            }
-            if (info.mtime > latestMtime) {
-              latestMtime = info.mtime;
-            }
-          } catch {
-            continue;
-          }
-        }
-        results.push({
-          directoryName: entry.name,
-          totalSizeBytes: totalSize,
-          lastModified: latestMtime.toISOString(),
-          fileCount
-        });
-      } catch {
-        continue;
-      }
-    }
-    return results;
-  }
-  async deleteWorkspaceDirectory(directoryName) {
-    if (directoryName.includes("/") || directoryName.includes("..") || directoryName.includes("\\")) {
-      return false;
-    }
-    const targetDir = path4.join(this.dataDir, directoryName);
-    try {
-      await rm(targetDir, { recursive: true, force: true });
-      logger.info(`[Workspace] Deleted directory: ${targetDir}`);
-      return true;
-    } catch (err) {
-      logger.error(`[Workspace] Failed to delete directory ${targetDir}`, err);
-      return false;
-    }
-  }
-  // Workspace file browsing
-  async getFileTree(agentId, dirPath) {
-    const agentDir = path4.join(this.dataDir, agentId);
-    try {
-      await stat(agentDir);
-    } catch {
-      return [];
-    }
-    let targetDir = agentDir;
-    if (dirPath) {
-      const resolved = path4.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path4.sep) && resolved !== agentDir) {
-        return [];
-      }
-      targetDir = resolved;
-    }
-    return this.listDirectoryChildren(targetDir, agentDir);
-  }
-  async readFile(agentId, filePath) {
-    const agentDir = path4.join(this.dataDir, agentId);
-    const resolved = path4.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path4.sep) && resolved !== agentDir) {
-      throw new Error("Access denied");
-    }
-    const info = await stat(resolved);
-    if (info.isDirectory()) throw new Error("Cannot read a directory");
-    const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".md",
-      ".txt",
-      ".json",
-      ".js",
-      ".ts",
-      ".jsx",
-      ".tsx",
-      ".yaml",
-      ".yml",
-      ".toml",
-      ".log",
-      ".csv",
-      ".xml",
-      ".html",
-      ".css",
-      ".sh",
-      ".py"
-    ]);
-    const ext = path4.extname(resolved).toLowerCase();
-    if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
-      return { content: null, binary: true };
-    }
-    if (info.size > 1048576) throw new Error("File too large");
-    const content = await readFile(resolved, "utf-8");
-    return { content, binary: false };
-  }
-  // Skill scanning
-  // Per-runtime skill search paths (relative to home dir for global, workspace dir for workspace).
-  // To add a new runtime, add an entry here.
-  static SKILL_PATHS = {
-    claude: {
-      // Claude reads shared skills via symlinks in ~/.claude/skills/, not from ~/.agents/skills/
-      global: [".claude/skills", ".claude/commands"],
-      workspace: [".claude/skills", ".claude/commands"]
-    },
-    codex: {
-      // Codex natively scans ~/.agents/skills/ and has built-in .system skills
-      global: [".codex/skills", ".codex/skills/.system", ".agents/skills"],
-      workspace: [".codex/skills", ".agents/skills"]
-    }
-  };
-  async listSkills(agentId, runtimeHint) {
-    const agent = this.agents.get(agentId);
-    const runtime = runtimeHint || agent?.config.runtime || "claude";
-    const home = os.homedir();
-    const workspaceDir = path4.join(this.dataDir, agentId);
-    const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
-    const globalResults = await Promise.all(
-      paths.global.map((p) => this.scanSkillsDir(path4.join(home, p)))
-    );
-    const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path4.join(workspaceDir, p)))
-    );
-    const dedup = (skills) => {
-      const seen = /* @__PURE__ */ new Set();
-      return skills.filter((s) => {
-        if (seen.has(s.name)) return false;
-        seen.add(s.name);
-        return true;
-      });
-    };
-    const shorten = (skills) => skills.map((s) => ({
-      ...s,
-      sourcePath: s.sourcePath?.startsWith(home) ? "~" + s.sourcePath.slice(home.length) : s.sourcePath
-    }));
-    return {
-      global: shorten(dedup(globalResults.flat())),
-      workspace: shorten(dedup(workspaceResults.flat()))
-    };
-  }
-  async scanSkillsDir(dir) {
-    let entries;
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-    const skills = [];
-    for (const entry of entries) {
-      if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path4.join(dir, entry.name, "SKILL.md");
-        try {
-          const content = await readFile(skillMd, "utf-8");
-          const skill = this.parseSkillMd(entry.name, content);
-          skill.sourcePath = dir;
-          skills.push(skill);
-        } catch {
-        }
-      } else if (entry.name.endsWith(".md")) {
-        const cmdName = entry.name.replace(/\.md$/, "");
-        try {
-          const content = await readFile(path4.join(dir, entry.name), "utf-8");
-          const skill = this.parseSkillMd(cmdName, content);
-          skill.sourcePath = dir;
-          skills.push(skill);
-        } catch {
-        }
-      }
-    }
-    return skills;
-  }
-  parseSkillMd(dirName, content) {
-    const info = {
-      name: dirName,
-      displayName: dirName,
-      description: "",
-      userInvocable: false
-    };
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!match) return info;
-    const frontmatter = match[1];
-    for (const line of frontmatter.split("\n")) {
-      const colonIdx = line.indexOf(":");
-      if (colonIdx === -1) continue;
-      const key = line.slice(0, colonIdx).trim();
-      const value = line.slice(colonIdx + 1).trim();
-      if (key === "name") info.displayName = value;
-      if (key === "description") info.description = value;
-      if (key === "user-invocable") info.userInvocable = value === "true";
-    }
-    return info;
-  }
-  // Private methods
-  /**
-   * Broadcast an activity change — emits a single agent:activity event that carries
-   * both the status (for the dot indicator) and trajectory entries (for the activity log).
-   */
-  broadcastActivity(agentId, activity, detail, extraTrajectory = []) {
-    const ap = this.agents.get(agentId);
-    const entries = [...extraTrajectory];
-    const hasToolStart = entries.some((e) => e.kind === "tool_start");
-    if (!hasToolStart) {
-      entries.push({ kind: "status", activity, detail });
-    }
-    this.sendToServer({ type: "agent:activity", agentId, activity, detail, entries, launchId: ap?.launchId || void 0 });
-    if (ap) {
-      ap.lastActivity = activity;
-      ap.lastActivityDetail = detail;
-      if (activity === "working" || activity === "thinking") {
-        if (!ap.activityHeartbeat) {
-          ap.activityHeartbeat = setInterval(() => {
-            this.sendToServer({
-              type: "agent:activity",
-              agentId,
-              activity: ap.lastActivity,
-              detail: ap.lastActivityDetail,
-              launchId: ap.launchId || void 0
-            });
-          }, ACTIVITY_HEARTBEAT_MS);
-        }
-      } else {
-        if (ap.activityHeartbeat) {
-          clearInterval(ap.activityHeartbeat);
-          ap.activityHeartbeat = null;
-        }
-      }
-    }
-  }
-  flushPendingTrajectory(agentId) {
-    const ap = this.agents.get(agentId);
-    const pending = ap?.pendingTrajectory;
-    if (!ap || !pending) return;
-    if (pending.timer) clearTimeout(pending.timer);
-    ap.pendingTrajectory = null;
-    const text = pending.text.length > MAX_TRAJECTORY_TEXT ? pending.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : pending.text;
-    if (!text) return;
-    if (pending.kind === "thinking") {
-      this.broadcastActivity(agentId, "thinking", "", [{ kind: "thinking", text }]);
-    } else {
-      this.broadcastActivity(agentId, "thinking", "", [{ kind: "text", text }]);
-    }
-  }
-  queueTrajectoryText(agentId, kind, text) {
-    const ap = this.agents.get(agentId);
-    if (!ap) return;
-    if (!text) {
-      this.broadcastActivity(agentId, "thinking", "");
-      return;
-    }
-    const pending = ap.pendingTrajectory;
-    if (pending && pending.kind === kind) {
-      pending.text += text;
-      if (pending.timer) clearTimeout(pending.timer);
-      pending.timer = setTimeout(() => this.flushPendingTrajectory(agentId), TRAJECTORY_COALESCE_MS);
-      return;
-    }
-    this.flushPendingTrajectory(agentId);
-    if (ap.lastActivity !== "thinking" || ap.lastActivityDetail !== "") {
-      this.broadcastActivity(agentId, "thinking", "");
-    }
-    ap.pendingTrajectory = {
-      kind,
-      text,
-      timer: setTimeout(() => this.flushPendingTrajectory(agentId), TRAJECTORY_COALESCE_MS)
-    };
-  }
-  /** Handle a single ParsedEvent from any runtime driver */
-  handleParsedEvent(agentId, event, driver) {
-    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, launchId: ap?.launchId || void 0 });
-        break;
-      case "thinking": {
-        this.queueTrajectoryText(agentId, "thinking", event.text);
-        if (ap) ap.isIdle = false;
-        break;
-      }
-      case "text": {
-        this.queueTrajectoryText(agentId, "text", event.text);
-        if (ap) ap.isIdle = false;
-        break;
-      }
-      case "tool_call": {
-        this.flushPendingTrajectory(agentId);
-        const toolName = event.name;
-        const inputSummary = driver.summarizeToolInput(toolName, event.input);
-        const detail = toolName === `${driver.mcpToolPrefix}check_messages` ? "Checking messages\u2026" : toolName === `${driver.mcpToolPrefix}send_message` ? "Sending message\u2026" : driver.toolDisplayName(toolName);
-        this.broadcastActivity(agentId, "working", detail, [{ kind: "tool_start", toolName, toolInput: inputSummary }]);
-        if (ap) ap.isIdle = false;
-        break;
-      }
-      case "turn_end":
-        this.flushPendingTrajectory(agentId);
-        if (ap) {
-          if (event.sessionId) ap.sessionId = event.sessionId;
-          if (ap.inbox.length > 0 && ap.driver.supportsStdinNotification && ap.sessionId) {
-            const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-            this.broadcastActivity(agentId, "working", "Message received");
-            this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle");
-          } else {
-            ap.isIdle = true;
-            this.broadcastActivity(agentId, "online", "Idle");
-          }
-        }
-        if (event.sessionId) {
-          this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId, launchId: ap?.launchId || void 0 });
-        }
-        break;
-      case "error": {
-        this.flushPendingTrajectory(agentId);
-        if (ap) ap.lastRuntimeError = event.message;
-        this.broadcastActivity(agentId, "error", event.message, [
-          { kind: "text", text: `Error: ${event.message}` }
-        ]);
-        break;
-      }
-    }
-  }
-  sendAgentStatus(agentId, status, launchId) {
-    this.sendToServer({ type: "agent:status", agentId, status, launchId: launchId || void 0 });
-  }
-  /** Send a batched notification to the agent via stdin about pending messages */
-  sendStdinNotification(agentId) {
-    const ap = this.agents.get(agentId);
-    if (!ap) return;
-    const count = ap.pendingNotificationCount;
-    ap.pendingNotificationCount = 0;
-    ap.notificationTimer = null;
-    if (count === 0) return;
-    if (ap.isIdle) return;
-    if (!ap.sessionId) return;
-    if (ap.driver.deliverMessageDirectlyWhileBusy && ap.inbox.length > 0) {
-      const queuedMessages = ap.inbox.splice(0, ap.inbox.length);
-      console.log(`[Agent ${agentId}] Delivering queued message via stdin while busy`);
-      this.broadcastActivity(agentId, "working", "Message received");
-      this.deliverMessagesViaStdin(agentId, ap, queuedMessages, "busy");
-      return;
-    }
-    const notification = `[System notification: You have ${count} new message${count > 1 ? "s" : ""} waiting. Call check_messages to read ${count > 1 ? "them" : "it"} when you're ready.]`;
-    logger.info(`[Agent ${agentId}] Sending stdin notification: ${count} message(s)`);
-    const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
-    if (encoded) {
-      ap.process.stdin?.write(encoded + "\n");
-    }
-  }
-  /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
-  deliverMessagesViaStdin(agentId, ap, messages, mode) {
-    if (messages.length === 0) return;
-    const prompt = messages.length === 1 ? `New message received:
-
-${formatIncomingMessage(messages[0])}
-
-Respond as appropriate. Complete all your work before stopping.` : `New messages received:
-
-${messages.map((message) => formatIncomingMessage(message)).join("\n")}
-
-Respond as appropriate. Complete all your work before stopping.`;
-    const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
-    if (encoded) {
-      const senders = [...new Set(messages.map((message) => `@${message.sender_name}`))].join(", ");
-      logger.info(
-        `[Agent ${agentId}] Delivering ${mode} ${messages.length === 1 ? "message" : `${messages.length} messages`} via stdin from ${senders}`
-      );
-      ap.process.stdin?.write(encoded + "\n");
-    }
-  }
-  /** List ONE level of a directory — directories returned without children (lazy-loaded on demand) */
-  async listDirectoryChildren(dir, rootDir) {
-    let entries;
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-    entries.sort((a, b) => {
-      if (a.isDirectory() && !b.isDirectory()) return -1;
-      if (!a.isDirectory() && b.isDirectory()) return 1;
-      return a.name.localeCompare(b.name);
-    });
-    const nodes = [];
-    for (const entry of entries) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = path4.join(dir, entry.name);
-      const relativePath = path4.relative(rootDir, fullPath);
-      let info;
-      try {
-        info = await stat(fullPath);
-      } catch {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        nodes.push({ name: entry.name, path: relativePath, isDirectory: true, size: 0, modifiedAt: info.mtime.toISOString() });
-      } else {
-        nodes.push({ name: entry.name, path: relativePath, isDirectory: false, size: info.size, modifiedAt: info.mtime.toISOString() });
-      }
-    }
-    return nodes;
-  }
-};
-
-// ../shared/src/serverPermissions.ts
-var EMPTY_SERVER_CAPABILITIES = Object.freeze({
-  manageServer: false,
-  manageChannels: false,
-  manageAgents: false,
-  manageMachines: false,
-  manageMembers: false,
-  changeMemberRoles: false,
-  manageBilling: false,
-  joinPublicChannels: false
-});
-var SERVER_CAPABILITY_MATRIX = {
-  owner: Object.freeze({
-    manageServer: true,
-    manageChannels: true,
-    manageAgents: true,
-    manageMachines: true,
-    manageMembers: true,
-    changeMemberRoles: true,
-    manageBilling: true,
-    joinPublicChannels: true
-  }),
-  admin: Object.freeze({
-    manageServer: true,
-    manageChannels: true,
-    manageAgents: true,
-    manageMachines: true,
-    manageMembers: true,
-    changeMemberRoles: false,
-    manageBilling: false,
-    joinPublicChannels: true
-  }),
-  member: Object.freeze({
-    manageServer: false,
-    manageChannels: false,
-    manageAgents: false,
-    manageMachines: false,
-    manageMembers: false,
-    changeMemberRoles: false,
-    manageBilling: false,
-    joinPublicChannels: true
-  })
-};
-
-// ../shared/src/index.ts
-var RUNTIMES = [
-  { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
-  { 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: true }
-];
-var PLAN_CONFIG = {
-  free: {
-    displayName: "Hobby",
-    limits: { maxMachines: 2, maxAgents: 5, maxChannels: 5, messageHistoryDays: 30, includedAgents: 5 },
-    comingSoon: false,
-    price: 0,
-    extraAgentPrice: 0
-  },
-  founder: {
-    displayName: "Founder",
-    limits: { maxMachines: -1, maxAgents: -1, maxChannels: -1, messageHistoryDays: -1, includedAgents: -1 },
-    comingSoon: false,
-    price: 0,
-    extraAgentPrice: 0
-  }
-};
-var DISPLAY_PLAN_CONFIG = {
-  free: PLAN_CONFIG.free,
-  pro: {
-    displayName: "Team",
-    limits: { maxMachines: 8, maxAgents: 40, maxChannels: 20, messageHistoryDays: -1, includedAgents: 40 },
-    comingSoon: true,
-    price: 20,
-    extraAgentPrice: 0
-  },
-  max: {
-    displayName: "Business",
-    limits: { maxMachines: 40, maxAgents: 200, maxChannels: -1, messageHistoryDays: -1, includedAgents: 200 },
-    comingSoon: true,
-    price: 200,
-    extraAgentPrice: 0
-  }
-};
-
-// src/index.ts
-var require2 = createRequire(import.meta.url);
-var DAEMON_VERSION = require2("../package.json").version;
-function formatChannelTarget(msg) {
-  return msg.message.channel_type === "dm" ? `dm:@${msg.message.channel_name}` : `#${msg.message.channel_name}`;
-}
-function summarizeIncomingMessage(msg) {
-  switch (msg.type) {
-    case "agent:start":
-      return `(agent=${msg.agentId}, runtime=${msg.config.runtime}, model=${msg.config.model}, session=${msg.config.sessionId || "new"}${msg.wakeMessage ? ", wake=true" : ""})`;
-    case "agent:stop":
-      return `(agent=${msg.agentId})`;
-    case "agent:reset-workspace":
-      return `(agent=${msg.agentId})`;
-    case "agent:deliver":
-      return `(agent=${msg.agentId}, seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`;
-    case "agent:workspace:list":
-      return `(agent=${msg.agentId}, dir=${msg.dirPath || "."})`;
-    case "agent:workspace:read":
-      return `(agent=${msg.agentId}, path=${msg.path})`;
-    case "agent:skills:list":
-      return `(agent=${msg.agentId}, runtime=${msg.runtime || "auto"})`;
-    case "machine:workspace:delete":
-      return `(directory=${msg.directoryName})`;
-    default:
-      return "";
-  }
-}
-function detectRuntimes() {
-  const ids = [];
-  const versions = {};
-  const cmd = process.platform === "win32" ? "where" : "which";
-  for (const rt of RUNTIMES) {
-    try {
-      execSync2(`${cmd} ${rt.binary}`, { stdio: "pipe" });
-      ids.push(rt.id);
-      try {
-        const ver = execSync2(`${rt.binary} --version`, { stdio: "pipe", timeout: 5e3 }).toString().trim().split("\n")[0];
-        versions[rt.id] = ver;
-      } catch {
-      }
-    } catch {
-    }
-  }
-  return { ids, versions };
-}
-var args = process.argv.slice(2);
-var serverUrl = "";
-var apiKey = "";
-for (let i = 0; i < args.length; i++) {
-  if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
-  if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
-}
-if (!serverUrl || !apiKey) {
-  console.error("Usage: slock-daemon --server-url <url> --api-key <key>");
+var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));
+if (!parsedArgs) {
+  console.error(DAEMON_CLI_USAGE);
   process.exit(1);
 }
-var __dirname = path5.dirname(fileURLToPath(import.meta.url));
-var chatBridgePath = path5.resolve(__dirname, "chat-bridge.js");
-try {
-  accessSync(chatBridgePath);
-} catch {
-  chatBridgePath = path5.resolve(__dirname, "chat-bridge.ts");
-}
-var connection;
-var agentManager = new AgentProcessManager(chatBridgePath, (msg) => {
-  connection.send(msg);
-}, apiKey);
-connection = new DaemonConnection({
-  serverUrl,
-  apiKey,
-  onMessage: (msg) => {
-    const summary = summarizeIncomingMessage(msg);
-    logger.info(`[Daemon] Received ${msg.type}${summary ? ` ${summary}` : ""}`);
-    switch (msg.type) {
-      case "agent:start":
-        logger.info(`[Agent ${msg.agentId}] Start requested (runtime=${msg.config.runtime}, model=${msg.config.model}, session=${msg.config.sessionId || "new"}${msg.wakeMessage ? ", wake=true" : ""})`);
-        agentManager.startAgent(msg.agentId, msg.config, msg.wakeMessage, msg.unreadSummary, msg.resumePrompt, msg.launchId).catch((err) => {
-          const reason = err instanceof Error ? err.message : String(err);
-          logger.error(`[Agent ${msg.agentId}] Start failed (${reason})`);
-          connection.send({ type: "agent:status", agentId: msg.agentId, status: "inactive", launchId: msg.launchId });
-          connection.send({ type: "agent:activity", agentId: msg.agentId, activity: "offline", detail: `Start failed: ${reason}`, launchId: msg.launchId });
-        });
-        break;
-      case "agent:stop":
-        logger.info(`[Agent ${msg.agentId}] Stop requested`);
-        agentManager.stopAgent(msg.agentId);
-        break;
-      case "agent:reset-workspace":
-        logger.info(`[Agent ${msg.agentId}] Workspace reset requested`);
-        agentManager.resetWorkspace(msg.agentId);
-        break;
-      case "agent:deliver":
-        logger.info(`[Agent ${msg.agentId}] Delivery received (seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`);
-        agentManager.deliverMessage(msg.agentId, msg.message);
-        connection.send({ type: "agent:deliver:ack", agentId: msg.agentId, seq: msg.seq });
-        break;
-      case "agent:workspace:list":
-        agentManager.getFileTree(msg.agentId, msg.dirPath).then((files) => {
-          connection.send({ type: "agent:workspace:file_tree", agentId: msg.agentId, files, dirPath: msg.dirPath });
-        });
-        break;
-      case "agent:workspace:read":
-        agentManager.readFile(msg.agentId, msg.path).then(({ content, binary }) => {
-          connection.send({
-            type: "agent:workspace:file_content",
-            agentId: msg.agentId,
-            requestId: msg.requestId,
-            content,
-            binary
-          });
-        }).catch(() => {
-          connection.send({
-            type: "agent:workspace:file_content",
-            agentId: msg.agentId,
-            requestId: msg.requestId,
-            content: null,
-            binary: false
-          });
-        });
-        break;
-      case "agent:skills:list":
-        agentManager.listSkills(msg.agentId, msg.runtime).then(({ global, workspace }) => {
-          connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global, workspace });
-        }).catch((err) => {
-          logger.error(`[Daemon] Failed to list skills for ${msg.agentId}`, err);
-          connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global: [], workspace: [] });
-        });
-        break;
-      case "machine:workspace:scan":
-        logger.info("[Daemon] Scanning all workspace directories");
-        agentManager.scanAllWorkspaces().then((directories) => {
-          connection.send({ type: "machine:workspace:scan_result", directories });
-        });
-        break;
-      case "machine:workspace:delete":
-        logger.info(`[Daemon] Deleting workspace directory: ${msg.directoryName}`);
-        agentManager.deleteWorkspaceDirectory(msg.directoryName).then((success) => {
-          connection.send({ type: "machine:workspace:delete_result", directoryName: msg.directoryName, success });
-        });
-        break;
-      case "ping":
-        connection.send({ type: "pong" });
-        break;
-    }
-  },
-  onConnect: () => {
-    const { ids: runtimes, versions: runtimeVersions } = detectRuntimes();
-    const runtimeInfo = runtimes.map((id) => runtimeVersions[id] ? `${id} (${runtimeVersions[id]})` : id);
-    logger.info(`[Daemon] Detected runtimes: ${runtimeInfo.join(", ") || "none"}`);
-    connection.send({
-      type: "ready",
-      capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
-      runtimes,
-      runningAgents: agentManager.getRunningAgentIds(),
-      hostname: os2.hostname(),
-      os: `${os2.platform()} ${os2.arch()}`,
-      daemonVersion: DAEMON_VERSION
-    });
-    for (const agentId of agentManager.getRunningAgentIds()) {
-      const sessionId = agentManager.getAgentSessionId(agentId);
-      const launchId = agentManager.getAgentLaunchId(agentId);
-      if (sessionId) {
-        connection.send({ type: "agent:session", agentId, sessionId, launchId: launchId || void 0 });
-      }
-    }
-    for (const { agentId, sessionId, launchId } of agentManager.getIdleAgentSessionIds()) {
-      connection.send({ type: "agent:session", agentId, sessionId, launchId: launchId || void 0 });
-    }
-  },
-  onDisconnect: () => {
-    logger.warn("[Daemon] Lost connection \u2014 agents continue running locally");
-  }
-});
-logger.info("[Slock Daemon] Starting...");
-connection.connect();
+var daemon = new DaemonCore(parsedArgs);
+daemon.start();
 var shutdown = async () => {
-  logger.info("[Slock Daemon] Shutting down...");
-  await agentManager.stopAll();
-  connection.disconnect();
+  await daemon.stop();
   process.exit(0);
 };
-process.on("SIGTERM", shutdown);
-process.on("SIGINT", shutdown);
+process.on("SIGTERM", () => {
+  void shutdown();
+});
+process.on("SIGINT", () => {
+  void shutdown();
+});