@slock-ai/daemon 0.39.0 → 0.39.1-alpha.0

package/dist/{chunk-72UW4SIL.js → chunk-SDJ4NOR7.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-E6OOH3IC.js";
 
 // src/core.ts
-import path10 from "path";
+import path11 from "path";
 import os4 from "os";
 import { createRequire } from "module";
 import { accessSync } from "fs";
@@ -37,6 +37,9 @@ var TOOL_DISPLAY_METADATA = {
   web_fetch: { logLabel: "Fetching web", activityLabel: "Fetching web\u2026", summaryKind: "url" },
   web_search: { logLabel: "Searching web", activityLabel: "Searching web\u2026", summaryKind: "query" },
   todo_write: { logLabel: "Updating tasks", activityLabel: "Updating tasks\u2026", summaryKind: "none" },
+  schedule_reminder: { logLabel: "Scheduling reminder", activityLabel: "Scheduling reminder\u2026", summaryKind: "reminder_title" },
+  list_reminders: { logLabel: "Listing reminders", activityLabel: "Listing reminders\u2026", summaryKind: "none" },
+  cancel_reminder: { logLabel: "Canceling reminder", activityLabel: "Canceling reminder\u2026", summaryKind: "reminder_id" },
   collab_tool_call: { logLabel: "Collaborating", activityLabel: "Collaborating\u2026", summaryKind: "none" }
 };
 var KNOWN_TOOL_ALIASES = {
@@ -89,6 +92,9 @@ var KNOWN_TOOL_ALIASES = {
   SearchWeb: "web_search",
   TodoWrite: "todo_write",
   SetTodoList: "todo_write",
+  schedule_reminder: "schedule_reminder",
+  list_reminders: "list_reminders",
+  cancel_reminder: "cancel_reminder",
   collab_tool_call: "collab_tool_call"
 };
 var MCP_CHAT_NAMESPACE_PREFIXES = ["mcp__chat__", "mcp_chat_"];
@@ -119,6 +125,198 @@ function resolveToolSemantic(toolName) {
   const normalized = normalizeToolLookupName(toolName);
   return KNOWN_TOOL_ALIASES[normalized] ?? null;
 }
+function tokenizeShellCommand(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  for (const ch of command) {
+    if (escaping) {
+      current += ch;
+      escaping = false;
+      continue;
+    }
+    if (quote === "'") {
+      if (ch === "'") {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (quote === '"') {
+      if (ch === '"') {
+        quote = null;
+      } else if (ch === "\\") {
+        escaping = true;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (escaping || quote) return null;
+  if (current) tokens.push(current);
+  return tokens;
+}
+function isEnvAssignmentToken(token) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=.*/.test(token);
+}
+function isSlockExecutableToken(token) {
+  const lastSep = Math.max(token.lastIndexOf("/"), token.lastIndexOf("\\"));
+  const base = (lastSep >= 0 ? token.slice(lastSep + 1) : token).toLowerCase();
+  return base === "slock" || base === "slock.cmd";
+}
+function isShellExecutableToken(token) {
+  const lastSep = Math.max(token.lastIndexOf("/"), token.lastIndexOf("\\"));
+  const base = (lastSep >= 0 ? token.slice(lastSep + 1) : token).toLowerCase();
+  return base === "bash" || base === "zsh" || base === "sh";
+}
+function findSlockExecutableIndex(tokens) {
+  const commandStartIndexes = [0];
+  for (let i = 0; i < tokens.length; i += 1) {
+    if (tokens[i] === "|" || tokens[i] === "&&" || tokens[i] === "||" || tokens[i] === ";") {
+      commandStartIndexes.push(i + 1);
+    }
+  }
+  for (const start of commandStartIndexes) {
+    let executableIndex = start;
+    while (executableIndex < tokens.length && isEnvAssignmentToken(tokens[executableIndex])) {
+      executableIndex += 1;
+    }
+    if (executableIndex < tokens.length && isSlockExecutableToken(tokens[executableIndex])) {
+      return executableIndex;
+    }
+  }
+  return -1;
+}
+function unwrapShellPayload(tokens, executableIndex) {
+  if (!isShellExecutableToken(tokens[executableIndex])) return null;
+  for (let i = executableIndex + 1; i < tokens.length; i++) {
+    const arg = tokens[i];
+    if (arg.startsWith("-") && arg.endsWith("c")) {
+      return i + 1 < tokens.length ? tokens[i + 1] : null;
+    }
+    if (!arg.startsWith("-")) break;
+  }
+  return null;
+}
+function readOptionValues(args, flag) {
+  const values = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === flag && i + 1 < args.length) {
+      values.push(args[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith(`${flag}=`)) {
+      values.push(arg.slice(flag.length + 1));
+    }
+  }
+  return values;
+}
+function readOptionValue(args, flag) {
+  return readOptionValues(args, flag).at(-1);
+}
+function parsePositiveIntegers(args, flag) {
+  return readOptionValues(args, flag).map((value) => Number(value)).filter((value) => Number.isFinite(value) && Number.isInteger(value) && value > 0);
+}
+function resolveSlockCliInvocation(toolName, input) {
+  if (resolveToolSemantic(toolName) !== "bash") return null;
+  const value = asObject(input);
+  if (!value || typeof value.command !== "string") return null;
+  const tokens = tokenizeShellCommand(value.command);
+  if (!tokens || tokens.length === 0) return null;
+  const firstExecutableIndex = (() => {
+    let index = 0;
+    while (index < tokens.length && isEnvAssignmentToken(tokens[index])) index += 1;
+    return index;
+  })();
+  if (firstExecutableIndex >= tokens.length) return null;
+  if (isShellExecutableToken(tokens[firstExecutableIndex])) {
+    const innerCommand = unwrapShellPayload(tokens, firstExecutableIndex);
+    if (innerCommand) {
+      return resolveSlockCliInvocation(toolName, { command: innerCommand });
+    }
+  }
+  const executableIndex = findSlockExecutableIndex(tokens);
+  if (executableIndex < 0) return null;
+  const cliArgs = tokens.slice(executableIndex + 1);
+  const [resource, action, ...rest] = cliArgs;
+  if (!resource || !action) return null;
+  switch (`${resource} ${action}`) {
+    case "message send":
+      return { toolName: "send_message", input: { target: readOptionValue(rest, "--target") } };
+    case "message check":
+      return { toolName: "check_messages", input: {} };
+    case "message read":
+      return { toolName: "read_history", input: { channel: readOptionValue(rest, "--channel") } };
+    case "message search":
+      return { toolName: "search_messages", input: { query: readOptionValue(rest, "--query") } };
+    case "server info":
+      return { toolName: "list_server", input: {} };
+    case "task list":
+      return { toolName: "list_tasks", input: { channel: readOptionValue(rest, "--channel") } };
+    case "task create":
+      return { toolName: "create_tasks", input: { channel: readOptionValue(rest, "--channel") } };
+    case "task claim":
+      return {
+        toolName: "claim_tasks",
+        input: {
+          channel: readOptionValue(rest, "--channel"),
+          task_numbers: parsePositiveIntegers(rest, "--number")
+        }
+      };
+    case "task unclaim":
+      return {
+        toolName: "unclaim_task",
+        input: {
+          channel: readOptionValue(rest, "--channel"),
+          task_number: parsePositiveIntegers(rest, "--number")[0]
+        }
+      };
+    case "task update":
+      return {
+        toolName: "update_task_status",
+        input: {
+          channel: readOptionValue(rest, "--channel"),
+          task_number: parsePositiveIntegers(rest, "--number")[0]
+        }
+      };
+    case "attachment upload":
+      return { toolName: "upload_file", input: { path: readOptionValue(rest, "--path") } };
+    case "attachment view":
+      return { toolName: "view_file", input: {} };
+    case "reminder schedule":
+      return { toolName: "schedule_reminder", input: { title: readOptionValue(rest, "--title") } };
+    case "reminder list":
+      return { toolName: "list_reminders", input: {} };
+    case "reminder cancel":
+      return { toolName: "cancel_reminder", input: { reminder_id: readOptionValue(rest, "--id") } };
+    default:
+      return null;
+  }
+}
+function normalizeToolDisplayInvocation(toolName, input) {
+  return resolveSlockCliInvocation(toolName, input) ?? { toolName, input };
+}
 function getToolActivityLabel(toolName) {
   const semantic = resolveToolSemantic(toolName);
   if (semantic) return TOOL_DISPLAY_METADATA[semantic].activityLabel;
@@ -157,6 +355,14 @@ function summarizeToolInput(toolName, input) {
       return value.channel && value.task_number != null ? `${value.channel} #t${value.task_number}` : "";
     case "target":
       return value.target || "";
+    case "reminder_title": {
+      const title = value.title;
+      return typeof title === "string" ? truncateLabel(title, 40) : "";
+    }
+    case "reminder_id": {
+      const id = value.reminder_id;
+      return typeof id === "string" ? `#${id.slice(0, 8)}` : "";
+    }
   }
 }
 
@@ -270,129 +476,203 @@ var DISPLAY_PLAN_CONFIG = {
 
 // src/agentProcessManager.ts
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 import os3 from "os";
 
 // src/drivers/claude.ts
 import { spawn } from "child_process";
-import { writeFileSync } from "fs";
-import path2 from "path";
+import path3 from "path";
+
+// src/drivers/cliTransport.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
 
 // src/drivers/systemPrompt.ts
 function toolRef(prefix, name) {
   return `${prefix}${name}`;
 }
-function buildBaseSystemPrompt(config, opts) {
+function buildPrompt(config, variant, opts) {
+  const isCli = variant === "cli";
   const t = (name) => toolRef(opts.toolPrefix, name);
+  const sendCmd = isCli ? "`slock message send`" : `\`${t("send_message")}\``;
+  const readCmd = isCli ? "`slock message read`" : `\`${t("read_history")}\``;
+  const checkCmd = isCli ? "`slock message check`" : `\`${t("check_messages")}\``;
+  const taskClaimCmd = isCli ? "`slock task claim`" : `\`${t("claim_tasks")}\``;
+  const taskCreateCmd = isCli ? "`slock task create`" : `\`${t("create_tasks")}\``;
+  const taskUpdateCmd = isCli ? "`slock task update`" : `\`${t("update_task_status")}\``;
+  const serverInfoCmd = isCli ? "`slock server info`" : `\`${t("list_server")}\``;
   const messageDeliveryText = opts.includeStdinNotificationSection ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
-  const criticalRules = [
-    `- Always communicate through ${t("send_message")}. This is your only output channel.`,
+  const criticalRules = isCli ? [
+    "- Always communicate through `slock` CLI commands. 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.`
+    "- Use only the provided `slock` CLI commands for messaging.",
+    "- Always claim a task via `slock task claim` before starting work on it. If the claim fails, move on to a different task."
+  ] : [
+    `- Always communicate through ${sendCmd}. 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 ${taskClaimCmd} 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.`,
+  const startupSteps = isCli ? [
+    "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 `slock message send` 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 `slock message send`.",
+    "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."
+  ] : [
+    `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 ${sendCmd} 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.`
+    `4. When you receive a message, process it and reply with ${sendCmd}.`,
+    "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
+  const communicationSection = isCli ? `## Communication \u2014 slock CLI ONLY
+
+Use the \`slock\` CLI for chat / task / attachment operations. The daemon injects a local \`slock\` wrapper into PATH for you. Use ONLY these commands for communication:
+
+1. **\`slock message check\`** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
+2. **\`slock message send\`** \u2014 Send a message to a channel or DM.
+3. **\`slock server info\`** \u2014 List channels in this server, which ones you have joined, plus all agents and humans.
+4. **\`slock message read\`** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
+5. **\`slock message search\`** \u2014 Search messages visible to you, then inspect a hit with \`slock message read\`.
+6. **\`slock task list\`** \u2014 View a channel's task board.
+7. **\`slock task create\`** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
+8. **\`slock task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
+9. **\`slock task unclaim\`** \u2014 Release your claim on a task.
+10. **\`slock task update\`** \u2014 Change a task's status (e.g. to in_review or done).
+11. **\`slock attachment upload\`** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to \`slock message send\`.
+12. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
+
+The CLI prints human-readable canonical text on success (matching the format you see in received messages and history). On failure it prints JSON to stderr:
+- failure \u2192 stderr \`{"ok":false,"code":"...","message":"..."}\` with non-zero exit
+
+Error code prefixes tell you the layer:
+- \`MISSING_*\` / \`TOKEN_*\` = local auth bootstrap
+- \`*_FAILED\` = 4xx from server
+- \`SERVER_5XX\` = server unreachable / crashed` : `## Communication \u2014 MCP tools ONLY
 
-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.
+You have MCP tools from the "chat" server. Use ONLY these for communication:
 
-## Communication \u2014 MCP tools ONLY
+1. **${checkCmd}** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
+2. **${sendCmd}** \u2014 Send a message to a channel or DM.
+3. **${serverInfoCmd}** \u2014 List all channels in this server, which ones you have joined, plus all agents and humans.
+4. **${readCmd}** \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 ${readCmd}.
+6. **\`${t("list_tasks")}\`** \u2014 View a channel's task board.
+7. **${taskCreateCmd}** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
+8. **${taskClaimCmd}** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
+9. **\`${t("unclaim_task")}\`** \u2014 Release your claim on a task.
+10. **${taskUpdateCmd}** \u2014 Change a task's status (e.g. to in_review or done).
+11. **\`${t("upload_file")}\`** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to ${sendCmd}.
+12. **\`${t("view_file")}\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.`;
+  const sendingMessagesSection = isCli ? `### Sending messages
+
+- **Reply to a channel**: \`slock message send --target "#channel-name" <<'EOF'\` followed by the message body and \`EOF\`
+- **Reply to a DM**: \`slock message send --target "dm:@peer-name" <<'EOF'\` followed by the message body and \`EOF\`
+- **Reply in a thread**: \`slock message send --target "#channel:shortid" <<'EOF'\` followed by the message body and \`EOF\`
+- **Start a NEW DM**: \`slock message send --target "dm:@person-name" <<'EOF'\` followed by the message body and \`EOF\`
+
+Message content is always read from stdin. Use a heredoc so quotes, backticks, code blocks, and newlines are not interpreted by the shell:
+\`\`\`bash
+slock message send --target "#channel-name" <<'EOF'
+Long message with "quotes", $vars, \`backticks\`, and code blocks.
+EOF
+\`\`\`
 
-You have MCP tools from the "chat" server. Use ONLY these for communication:
+**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.` : `### Sending messages
 
-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 a file to attach to a message. Returns an attachment ID to pass to send_message.
-12. **${t("view_file")}** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
+- **Reply to a channel**: \`${t("send_message")}(target="#channel-name", content="...")\`
+- **Reply to a DM**: \`${t("send_message")}(target="dm:@peer-name", content="...")\`
+- **Reply in a thread**: \`${t("send_message")}(target="#channel:shortid", content="...")\` or \`${t("send_message")}(target="dm:@peer:shortid", content="...")\`
+- **Start a NEW DM**: \`${t("send_message")}(target="dm:@person-name", content="...")\`
 
-CRITICAL RULES:
-${criticalRules.join("\n")}
+**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.`;
+  const threadsSection = isCli ? `### Threads
 
-## Startup sequence
+Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main channel.
 
-${startupSteps.join("\n")}`;
-  if (opts.postStartupNotes.length > 0) {
-    prompt += `
+- **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 \`slock message send --target "#general:a1b2c3d4" <<'EOF'\` followed by the message body and \`EOF\`. 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: \`slock message read --channel "#general:a1b2c3d4"\`
+- Threads cannot be nested \u2014 you cannot start a thread inside a thread.` : `### Threads
 
-${opts.postStartupNotes.join("\n")}`;
-  }
-  prompt += `
+Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main channel.
 
-## Messaging
+- **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 ...]\`, call \`${t("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 via ${readCmd} with the same thread target.
+- Threads cannot be nested \u2014 you cannot start a thread inside a thread.`;
+  const discoverySection = isCli ? `### Discovering people and channels
 
-Messages you receive have a single RFC 5424-style structured data header followed by the sender and content:
+Call \`slock server info\` to see all channels in this server, which ones you have joined, other agents, and humans.
+Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`slock message read\`, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel.` : `### Discovering people and channels
 
-\`\`\`
-[target=#general msg=a1b2c3d4 time=2026-03-15T01:00:00 type=human] @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 type=human] @richard: hey, can you help?
-[target=#general:a1b2c3d4 msg=f3a4b5c6 time=2026-03-15T01:00:03 type=human] @richard: thread reply
-[target=dm:@richard:x9y8z7a0 msg=d7e8f9a0 time=2026-03-15T01:00:04 type=human] @richard: DM thread reply
-\`\`\`
+Call ${serverInfoCmd} to see all channels in this server, which ones you have joined, other agents, and humans.
+Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with ${readCmd}, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel.`;
+  const channelAwarenessSection = isCli ? `### Channel awareness
 
-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=\` \u2014 sender kind. Values are \`human\`, \`agent\`, or \`system\`.
+Each channel has a **name** and optionally a **description** that define its purpose (visible via \`slock server info\`). 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 \`slock server info\` to review channel descriptions.` : `### Channel awareness
 
-\`type=system\` messages announce state changes in the channel (task events, channel archived/unarchived, etc.). They are informational \u2014 don't reply to them unless they clearly request action (e.g. a task was just assigned to you). In particular, archive/unarchive notifications do not need any response. If a channel is archived, further writes there will be rejected.
+Each channel has a **name** and optionally a **description** that define its purpose (visible via ${serverInfoCmd}). 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 ${serverInfoCmd} to review channel descriptions.`;
+  const readingHistorySection = isCli ? `### Reading history
 
-### Sending messages
+\`slock message read --channel "#channel-name"\` or \`slock message read --channel "dm:@peer-name"\` or \`slock message read --channel "#channel:shortid"\`
 
-- **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="...")\`
+To jump directly to a specific hit with nearby context, use \`slock message read --channel "..." --around "messageId"\` or \`slock message read --channel "..." --around 12345\`.` : `### Reading history
 
-**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.
+Use ${readCmd} with the \`channel\` parameter set to \`"#channel-name"\`, \`"dm:@peer-name"\`, or a thread target like \`"#channel:shortid"\`.
 
-### Threads
+To jump directly to a specific hit with nearby context, pass \`around\` set to a message ID or seq number.`;
+  const tasksSection = isCli ? `### Tasks
 
-Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main channel.
+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.
 
-- **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.
+**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.
 
-### Discovering people and channels
+**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"\`
 
-Call \`list_server\` to see all channels in this server, which ones you have joined, other agents, and humans.
-Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`read_history\`, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel.
+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.
 
-### Channel awareness
+\`slock message read\` shows messages in their current state. If a message was later converted to a task, it will show the \`[task #N ...]\` suffix.
 
-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.
+**Status flow:** \`todo\` \u2192 \`in_progress\` \u2192 \`in_review\` \u2192 \`done\`
 
-### Reading history
+**Assignee** is independent from status \u2014 a task can be claimed or unclaimed at any status except \`done\`.
 
-\`read_history(channel="#channel-name")\` or \`read_history(channel="dm:@peer-name")\` or \`read_history(channel="#channel:shortid")\`
+**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: \`slock message send --target "#channel:msgShortId" <<'EOF'\` followed by the message body and \`EOF\`
+4. When done, set status to \`in_review\` so a human can validate via \`slock task update\`
+5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
 
-To jump directly to a specific hit with nearby context, use \`read_history(channel="...", around="messageId")\` or \`read_history(channel="...", around=12345)\`.
+**What \`slock task create\` 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.
+- \`slock task create\` is a convenience helper for a specific sequence: create a brand-new message, then publish that new message as a task-message.
+- \`slock task create\` only creates the task \u2014 to own it, call \`slock task claim\` afterward.
+- Typical uses for \`slock task create\` 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 \`slock task claim --message-id ...\`.
 
-### Tasks
+**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 \`slock task create\`, 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 \`slock task create\` only for genuinely new subtasks or follow-up work that does not already have a canonical task.` : `### 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.
 
@@ -405,7 +685,7 @@ When someone sends a message that asks you to do something \u2014 fix a bug, wri
 
 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.
+${readCmd} 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\`
 
@@ -414,24 +694,77 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 **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
+3. Post updates in the task's thread via ${sendCmd} with \`target="#channel:msgShortId"\`
+4. When done, set status to \`in_review\` so a human can validate via ${taskUpdateCmd}
 5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
 
-**What \`${t("create_tasks")}\` really means:**
+**What ${taskCreateCmd} 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.
+- ${taskCreateCmd} is a convenience helper for a specific sequence: create a brand-new message, then publish that new message as a task-message.
+- ${taskCreateCmd} only creates the task \u2014 to own it, call ${taskClaimCmd} afterward.
+- Typical uses for ${taskCreateCmd} 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\`.
+- If the work already exists as a message, reuse it via ${taskClaimCmd} with the message ID.
 
 **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.
+- Before calling ${taskCreateCmd}, 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.
+- Use ${taskCreateCmd} only for genuinely new subtasks or follow-up work that does not already have a canonical task.`;
+  const claimForEtiquette = isCli ? "`slock task claim`" : taskClaimCmd;
+  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.
+
+${communicationSection}
+
+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 type=human] @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 type=human] @richard: hey, can you help?
+[target=#general:a1b2c3d4 msg=f3a4b5c6 time=2026-03-15T01:00:03 type=human] @richard: thread reply
+[target=dm:@richard:x9y8z7a0 msg=d7e8f9a0 time=2026-03-15T01:00:04 type=human] @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=\` \u2014 sender kind. Values are \`human\`, \`agent\`, or \`system\`.
+
+\`type=system\` messages announce state changes in the channel (task events, channel archived/unarchived, etc.). They are informational \u2014 don't reply to them unless they clearly request action (e.g. a task was just assigned to you). In particular, archive/unarchive notifications do not need any response. If a channel is archived, further writes there will be rejected.
+
+${sendingMessagesSection}
+
+${threadsSection}
+
+${discoverySection}
+
+${channelAwarenessSection}
+
+${readingHistorySection}
+
+${tasksSection}
 
 ### Splitting tasks for parallel execution
 
@@ -445,8 +778,8 @@ When you receive a notification about new tasks, check the task board and claim
 ## @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.
+- 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.
@@ -463,7 +796,7 @@ Keep the user informed. They cannot see your internal reasoning, so:
 
 - **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.
+- **Claim before you start.** Always call ${claimForEtiquette} 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.
 
@@ -559,20 +892,21 @@ How to handle these:
 - Treat direct follow-up messages as new user input for the same live session.
 - Adapt if the new message changes priority or direction.
 - You do NOT need to poll just because direct follow-up delivery is available.
-- Use \`${t("check_messages")}()\` only when you need to inspect other pending channels or recover broader context.`;
+- Use ${checkCmd} only when you need to inspect other pending channels or recover broader context.`;
     } else {
+      const notifyExample = isCli ? `\`[System notification: You have N new message(s) waiting. Call slock message check to read them when you're ready.]\`` : `\`[System notification: You have N new message(s) waiting. Call ${t("check_messages")} to read them when you're ready.]\``;
       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.]\`
+${notifyExample}
 
 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.
+- Call ${checkCmd} 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.`;
+- ${checkCmd} returns instantly with any pending messages (or "no new messages"). It is always safe to call.`;
     }
   }
   if (config.description) {
@@ -583,11 +917,62 @@ ${config.description}. This may evolve.`;
   }
   return prompt;
 }
+function buildCliSystemPrompt(config, opts) {
+  return buildPrompt(config, "cli", opts);
+}
+function buildMcpSystemPrompt(config, opts) {
+  return buildPrompt(config, "mcp", opts);
+}
+
+// src/drivers/cliTransport.ts
+var shellSingleQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+function buildCliTransportSystemPrompt(config, opts) {
+  return buildCliSystemPrompt(config, opts);
+}
+function prepareCliTransport(ctx, extraEnv = {}, platform = process.platform) {
+  if (!ctx.slockCliPath) {
+    throw new Error(`${ctx.config.runtime} driver: slockCliPath is required (daemon must inject it)`);
+  }
+  const slockDir = path.join(ctx.workingDirectory, ".slock");
+  mkdirSync(slockDir, { recursive: true });
+  const tokenFile = path.join(slockDir, "agent-token");
+  writeFileSync(tokenFile, ctx.config.authToken || ctx.daemonApiKey, { mode: 384 });
+  const posixWrapper = path.join(slockDir, "slock");
+  const posixBody = `#!/usr/bin/env bash
+exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(ctx.slockCliPath)} "$@"
+`;
+  writeFileSync(posixWrapper, posixBody, { mode: 493 });
+  if (platform === "win32") {
+    const cmdWrapper = path.join(slockDir, "slock.cmd");
+    const cmdBody = `@echo off\r
+"${process.execPath}" "${ctx.slockCliPath}" %*\r
+`;
+    writeFileSync(cmdWrapper, cmdBody);
+  }
+  const wrapperPath = platform === "win32" ? path.join(slockDir, "slock.cmd") : posixWrapper;
+  const spawnEnv = {
+    ...process.env,
+    FORCE_COLOR: "0",
+    ...ctx.config.envVars || {},
+    ...extraEnv,
+    SLOCK_AGENT_ID: ctx.agentId,
+    SLOCK_SERVER_URL: ctx.config.serverUrl,
+    SLOCK_AGENT_TOKEN_FILE: tokenFile,
+    PATH: `${slockDir}${path.delimiter}${process.env.PATH ?? ""}`
+  };
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
+  return {
+    slockDir,
+    tokenFile,
+    wrapperPath,
+    spawnEnv
+  };
+}
 
 // src/drivers/probe.ts
 import { execFileSync } from "child_process";
 import { existsSync } from "fs";
-import path from "path";
+import path2 from "path";
 function normalizeExecOutput(raw) {
   return Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw ?? "");
 }
@@ -653,12 +1038,19 @@ function readCommandVersion(command, args = [], deps = {}) {
 }
 function resolveHomePath(relativePath, deps = {}) {
   const homeDir = deps.homeDir ?? deps.env?.HOME ?? process.env.HOME ?? "";
-  return path.join(homeDir, relativePath);
+  return path2.join(homeDir, relativePath);
 }
 
 // src/drivers/claude.ts
-var CLAUDE_DESKTOP_CLI_RELATIVE_PATH = path2.join("Applications", "Claude Code URL Handler.app", "Contents", "MacOS", "claude");
+var CLAUDE_DESKTOP_CLI_RELATIVE_PATH = path3.join("Applications", "Claude Code URL Handler.app", "Contents", "MacOS", "claude");
 var CLAUDE_DESKTOP_CLI_SYSTEM_PATH = "/Applications/Claude Code URL Handler.app/Contents/MacOS/claude";
+var CLAUDE_DISALLOWED_TOOLS = [
+  "EnterPlanMode",
+  "ExitPlanMode",
+  "CronCreate",
+  "CronList",
+  "CronDelete"
+].join(",");
 function resolveClaudeCommand(deps = {}) {
   const pathCommand = resolveCommandOnPath("claude", deps);
   if (pathCommand) return pathCommand;
@@ -681,36 +1073,11 @@ var ClaudeDriver = class {
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp__chat__";
   busyDeliveryMode = "notification";
+  supportsNativeStandingPrompt = true;
   probe() {
     return probeClaude();
   }
-  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 = path2.join(ctx.workingDirectory, ".slock-claude-mcp.json");
-      writeFileSync(mcpConfigPath, mcpConfig, "utf8");
-      mcpConfigArg = mcpConfigPath;
-    } else {
-      mcpConfigArg = mcpConfig;
-    }
+  buildClaudeArgs(config, standingPrompt) {
     const args = [
       "--allow-dangerously-skip-permissions",
       "--dangerously-skip-permissions",
@@ -719,18 +1086,25 @@ var ClaudeDriver = class {
       "stream-json",
       "--input-format",
       "stream-json",
-      "--mcp-config",
-      mcpConfigArg,
+      "--append-system-prompt",
+      standingPrompt,
       "--model",
-      ctx.config.model || "sonnet",
+      config.model || "sonnet",
       "--disallowed-tools",
-      "EnterPlanMode,ExitPlanMode"
+      CLAUDE_DISALLOWED_TOOLS
     ];
-    if (ctx.config.sessionId) {
-      args.push("--resume", ctx.config.sessionId);
+    if (config.sessionId) {
+      args.push("--resume", config.sessionId);
     }
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", ...ctx.config.envVars || {} };
+    return args;
+  }
+  spawn(ctx) {
+    const { tokenFile, spawnEnv } = prepareCliTransport(ctx);
+    const args = this.buildClaudeArgs(ctx.config, ctx.standingPrompt);
     delete spawnEnv.CLAUDECODE;
+    logger.info(
+      `[Agent ${ctx.agentId}] transport=cli cli=${ctx.slockCliPath} token_file=${tokenFile}`
+    );
     const proc = spawn(resolveClaudeCommand() ?? "claude", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
@@ -774,6 +1148,12 @@ var ClaudeDriver = class {
         if (event.subtype === "init" && event.session_id) {
           events.push({ kind: "session_init", sessionId: event.session_id });
         }
+        if (event.subtype === "status" && event.status === "compacting") {
+          events.push({ kind: "compaction_started" });
+        }
+        if (event.subtype === "compact_boundary") {
+          events.push({ kind: "compaction_finished" });
+        }
         break;
       case "assistant": {
         const content = event.message?.content;
@@ -831,11 +1211,9 @@ var ClaudeDriver = class {
     });
   }
   buildSystemPrompt(config, _agentId) {
-    return buildBaseSystemPrompt(config, {
+    return buildCliTransportSystemPrompt(config, {
       toolPrefix: "mcp__chat__",
-      extraCriticalRules: [
-        "- Do NOT use bash/curl/sqlite to send or receive messages. The MCP tools handle everything."
-      ],
+      extraCriticalRules: [],
       postStartupNotes: [],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "poll"
@@ -847,7 +1225,7 @@ var ClaudeDriver = class {
 import { spawn as spawn2, execSync } from "child_process";
 import { existsSync as existsSync2, readFileSync } from "fs";
 import os from "os";
-import path3 from "path";
+import path4 from "path";
 function getCodexNotificationErrorMessage(params) {
   const topLevelMessage = params?.message;
   if (typeof topLevelMessage === "string" && topLevelMessage.trim()) {
@@ -859,21 +1237,19 @@ function getCodexNotificationErrorMessage(params) {
   }
   return null;
 }
-function ensureGitRepo(workingDirectory) {
-  const gitDir = path3.join(workingDirectory, ".git");
-  if (existsSync2(gitDir)) return;
-  execSync("git init", { cwd: workingDirectory, stdio: "pipe" });
-  execSync("git add -A && git commit --allow-empty -m 'init'", {
-    cwd: workingDirectory,
-    stdio: "pipe",
-    env: {
-      ...process.env,
-      GIT_AUTHOR_NAME: "slock",
-      GIT_AUTHOR_EMAIL: "slock@local",
-      GIT_COMMITTER_NAME: "slock",
-      GIT_COMMITTER_EMAIL: "slock@local"
-    }
-  });
+function ensureGitRepoForCodex(workingDirectory, deps = {}) {
+  const existsSyncFn = deps.existsSyncFn ?? existsSync2;
+  const execSyncFn = deps.execSyncFn ?? execSync;
+  const gitDir = path4.join(workingDirectory, ".git");
+  if (existsSyncFn(gitDir)) return;
+  execSyncFn("git init", { cwd: workingDirectory, stdio: "pipe" });
+  execSyncFn(
+    "git -c user.name=slock -c user.email=slock@local -c commit.gpgsign=false add -A && git -c user.name=slock -c user.email=slock@local -c commit.gpgsign=false commit --allow-empty -m 'init'",
+    {
+      cwd: workingDirectory,
+      stdio: "pipe"
+    }
+  );
 }
 var CODEX_DESKTOP_BUNDLE_PATH = "/Applications/Codex.app/Contents/Resources/codex";
 function resolveCodexCommand(deps = {}) {
@@ -908,14 +1284,14 @@ function resolveCodexSpawn(commandArgs, deps = {}) {
   let codexEntry = null;
   try {
     const globalRoot = execSync("npm root -g", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const candidate = path3.join(globalRoot, "@openai", "codex", "bin", "codex.js");
+    const candidate = path4.join(globalRoot, "@openai", "codex", "bin", "codex.js");
     if (existsSync2(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 = path3.join(path3.dirname(cmdPath), "node_modules", "@openai", "codex", "bin", "codex.js");
+      const candidate = path4.join(path4.dirname(cmdPath), "node_modules", "@openai", "codex", "bin", "codex.js");
       if (existsSync2(candidate)) codexEntry = candidate;
     } catch {
     }
@@ -930,12 +1306,6 @@ function resolveCodexSpawn(commandArgs, deps = {}) {
     args: [codexEntry, ...commandArgs]
   };
 }
-function buildBridgeArgs(ctx) {
-  const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-  const command = isTsSource ? "npx" : "node";
-  const args = 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];
-  return { command, args };
-}
 function joinReasoningText(item) {
   const summary = Array.isArray(item.summary) ? item.summary.filter((entry) => typeof entry === "string") : [];
   const content = Array.isArray(item.content) ? item.content.filter((entry) => typeof entry === "string") : [];
@@ -946,9 +1316,37 @@ var CodexDriver = class {
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp_chat_";
   busyDeliveryMode = "direct";
+  supportsNativeStandingPrompt = true;
   probe() {
     return probeCodex();
   }
+  buildThreadRequest(ctx) {
+    const threadParams = {
+      cwd: ctx.workingDirectory,
+      approvalPolicy: "never",
+      sandbox: "danger-full-access",
+      developerInstructions: ctx.standingPrompt
+    };
+    if (ctx.config.model) {
+      threadParams.model = ctx.config.model;
+    }
+    if (ctx.config.reasoningEffort) {
+      threadParams.config = { model_reasoning_effort: ctx.config.reasoningEffort };
+    }
+    if (ctx.config.sessionId) {
+      return {
+        method: "thread/resume",
+        params: {
+          threadId: ctx.config.sessionId,
+          ...threadParams
+        }
+      };
+    }
+    return {
+      method: "thread/start",
+      params: threadParams
+    };
+  }
   process = null;
   requestId = 0;
   threadId = null;
@@ -961,7 +1359,8 @@ var CodexDriver = class {
   streamedAgentMessageIds = /* @__PURE__ */ new Set();
   streamedReasoningIds = /* @__PURE__ */ new Set();
   spawn(ctx) {
-    ensureGitRepo(ctx.workingDirectory);
+    ensureGitRepoForCodex(ctx.workingDirectory);
+    const { spawnEnv } = prepareCliTransport(ctx, { NO_COLOR: "1" });
     this.process = null;
     this.requestId = 0;
     this.threadId = ctx.config.sessionId || null;
@@ -973,26 +1372,8 @@ var CodexDriver = class {
     this.sessionAnnounced = false;
     this.streamedAgentMessageIds.clear();
     this.streamedReasoningIds.clear();
-    const bridge = buildBridgeArgs(ctx);
-    const args = [
-      "app-server",
-      "--listen",
-      "stdio://",
-      "-c",
-      `mcp_servers.chat.command=${JSON.stringify(bridge.command)}`,
-      "-c",
-      `mcp_servers.chat.args=${JSON.stringify(bridge.args)}`,
-      "-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"
-    ];
+    const args = ["app-server", "--listen", "stdio://"];
     const { command, args: spawnArgs } = resolveCodexSpawn(args);
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", ...ctx.config.envVars || {} };
     const proc = spawn2(command, spawnArgs, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
@@ -1005,31 +1386,7 @@ var CodexDriver = class {
         clientInfo: { name: "slock-daemon", version: "1.0.0" },
         capabilities: { experimentalApi: true }
       });
-      const threadParams = {
-        cwd: ctx.workingDirectory,
-        approvalPolicy: "never",
-        sandbox: "danger-full-access"
-      };
-      if (ctx.config.model) {
-        threadParams.model = ctx.config.model;
-      }
-      if (ctx.config.reasoningEffort) {
-        threadParams.config = { model_reasoning_effort: ctx.config.reasoningEffort };
-      }
-      if (ctx.config.sessionId) {
-        this.pendingThreadRequest = {
-          method: "thread/resume",
-          params: {
-            threadId: ctx.config.sessionId,
-            ...threadParams
-          }
-        };
-      } else {
-        this.pendingThreadRequest = {
-          method: "thread/start",
-          params: threadParams
-        };
-      }
+      this.pendingThreadRequest = this.buildThreadRequest(ctx);
     });
     return { process: proc };
   }
@@ -1145,6 +1502,14 @@ var CodexDriver = class {
               events.push({ kind: "tool_call", name: "shell", input: { command: item.command } });
             }
             break;
+          case "contextCompaction":
+            if (isStarted) {
+              events.push({ kind: "compaction_started" });
+            }
+            if (isCompleted) {
+              events.push({ kind: "compaction_finished" });
+            }
+            break;
           case "fileChange":
             if (isStarted && Array.isArray(item.changes)) {
               for (const change of item.changes) {
@@ -1225,11 +1590,9 @@ var CodexDriver = class {
     });
   }
   buildSystemPrompt(config, _agentId) {
-    return buildBaseSystemPrompt(config, {
+    return buildCliTransportSystemPrompt(config, {
       toolPrefix: "",
-      extraCriticalRules: [
-        "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything."
-      ],
+      extraCriticalRules: [],
       postStartupNotes: [
         "**IMPORTANT**: Your process stays alive across turns. New messages may be delivered directly into the current thread while you are working."
       ],
@@ -1281,8 +1644,8 @@ var CodexDriver = class {
   }
 };
 function detectCodexModels(home = os.homedir()) {
-  const cachePath = path3.join(home, ".codex", "models_cache.json");
-  const configPath = path3.join(home, ".codex", "config.toml");
+  const cachePath = path4.join(home, ".codex", "models_cache.json");
+  const configPath = path4.join(home, ".codex", "config.toml");
   let models = [];
   try {
     const raw = readFileSync(cachePath, "utf8");
@@ -1312,7 +1675,7 @@ function detectCodexModels(home = os.homedir()) {
 
 // src/drivers/copilot.ts
 import { spawn as spawn3 } from "child_process";
-import path4 from "path";
+import path5 from "path";
 import { writeFileSync as writeFileSync2 } from "fs";
 var CopilotDriver = class {
   id = "copilot";
@@ -1327,7 +1690,7 @@ var CopilotDriver = class {
     const isTsSource = ctx.chatBridgePath.endsWith(".ts");
     const mcpCommand = isTsSource ? "npx" : "node";
     const mcpArgs = 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 mcpConfigPath = path4.join(ctx.workingDirectory, ".slock-copilot-mcp.json");
+    const mcpConfigPath = path5.join(ctx.workingDirectory, ".slock-copilot-mcp.json");
     writeFileSync2(mcpConfigPath, JSON.stringify({
       mcpServers: {
         chat: {
@@ -1436,7 +1799,7 @@ var CopilotDriver = class {
     return null;
   }
   buildSystemPrompt(config, _agentId) {
-    return buildBaseSystemPrompt(config, {
+    return buildMcpSystemPrompt(config, {
       toolPrefix: "",
       extraCriticalRules: [
         "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything."
@@ -1450,22 +1813,22 @@ var CopilotDriver = class {
 
 // src/drivers/cursor.ts
 import { spawn as spawn4 } from "child_process";
-import { writeFileSync as writeFileSync3, mkdirSync, existsSync as existsSync3 } from "fs";
-import path5 from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import path6 from "path";
 var CursorDriver = class {
   id = "cursor";
   supportsStdinNotification = false;
   mcpToolPrefix = "mcp__chat__";
   busyDeliveryMode = "none";
   spawn(ctx) {
-    const cursorDir = path5.join(ctx.workingDirectory, ".cursor");
+    const cursorDir = path6.join(ctx.workingDirectory, ".cursor");
     if (!existsSync3(cursorDir)) {
-      mkdirSync(cursorDir, { recursive: true });
+      mkdirSync2(cursorDir, { recursive: true });
     }
     const isTsSource = ctx.chatBridgePath.endsWith(".ts");
     const mcpCommand = isTsSource ? "npx" : "node";
     const mcpArgs = 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 mcpConfigPath = path5.join(cursorDir, "mcp.json");
+    const mcpConfigPath = path6.join(cursorDir, "mcp.json");
     writeFileSync3(mcpConfigPath, JSON.stringify({
       mcpServers: {
         chat: {
@@ -1510,6 +1873,10 @@ var CursorDriver = class {
       case "system":
         if (event.subtype === "init" && event.session_id) {
           events.push({ kind: "session_init", sessionId: event.session_id });
+        } else if (event.subtype === "status" && event.status === "compacting") {
+          events.push({ kind: "compaction_started" });
+        } else if (event.subtype === "compact_boundary") {
+          events.push({ kind: "compaction_finished" });
         }
         break;
       case "assistant": {
@@ -1552,7 +1919,7 @@ var CursorDriver = class {
     return null;
   }
   buildSystemPrompt(config, _agentId) {
-    return buildBaseSystemPrompt(config, {
+    return buildMcpSystemPrompt(config, {
       toolPrefix: "mcp__chat__",
       extraCriticalRules: [
         "- Do NOT use bash/curl/sqlite to send or receive messages. The MCP tools handle everything."
@@ -1566,8 +1933,8 @@ var CursorDriver = class {
 
 // src/drivers/gemini.ts
 import { spawn as spawn5 } from "child_process";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
-import path6 from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import path7 from "path";
 var GeminiDriver = class {
   id = "gemini";
   supportsStdinNotification = false;
@@ -1578,14 +1945,14 @@ var GeminiDriver = class {
   spawn(ctx) {
     this.sessionId = ctx.config.sessionId || null;
     this.sessionAnnounced = false;
-    const geminiDir = path6.join(ctx.workingDirectory, ".gemini");
+    const geminiDir = path7.join(ctx.workingDirectory, ".gemini");
     if (!existsSync4(geminiDir)) {
-      mkdirSync2(geminiDir, { recursive: true });
+      mkdirSync3(geminiDir, { recursive: true });
     }
     const isTsSource = ctx.chatBridgePath.endsWith(".ts");
     const mcpCommand = isTsSource ? "npx" : "node";
     const mcpArgs = 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 settingsPath = path6.join(geminiDir, "settings.json");
+    const settingsPath = path7.join(geminiDir, "settings.json");
     writeFileSync4(settingsPath, JSON.stringify({
       mcpServers: {
         chat: {
@@ -1667,7 +2034,7 @@ var GeminiDriver = class {
     return null;
   }
   buildSystemPrompt(config, _agentId) {
-    return buildBaseSystemPrompt(config, {
+    return buildMcpSystemPrompt(config, {
       toolPrefix: "",
       extraCriticalRules: [
         "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything."
@@ -1684,7 +2051,7 @@ import { randomUUID } from "crypto";
 import { spawn as spawn6 } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
 import os2 from "os";
-import path7 from "path";
+import path8 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";
@@ -1713,9 +2080,9 @@ var KimiDriver = class {
     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 = path7.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
-    const agentFilePath = path7.join(ctx.workingDirectory, KIMI_AGENT_FILE);
-    const mcpConfigPath = path7.join(ctx.workingDirectory, KIMI_MCP_FILE);
+    const systemPromptPath = path8.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
+    const agentFilePath = path8.join(ctx.workingDirectory, KIMI_AGENT_FILE);
+    const mcpConfigPath = path8.join(ctx.workingDirectory, KIMI_MCP_FILE);
     if (!isResume || !existsSync5(systemPromptPath)) {
       writeFileSync5(systemPromptPath, ctx.prompt, "utf8");
     }
@@ -1796,6 +2163,12 @@ var KimiDriver = class {
         case "StepBegin":
           events.push({ kind: "thinking", text: "" });
           break;
+        case "CompactionBegin":
+          events.push({ kind: "compaction_started" });
+          break;
+        case "CompactionEnd":
+          events.push({ kind: "compaction_finished" });
+          break;
         case "ContentPart":
           if (payload.type === "think" && payload.think) {
             events.push({ kind: "thinking", text: payload.think });
@@ -1848,7 +2221,7 @@ var KimiDriver = class {
     });
   }
   buildSystemPrompt(config, _agentId) {
-    return buildBaseSystemPrompt(config, {
+    return buildMcpSystemPrompt(config, {
       toolPrefix: "",
       extraCriticalRules: [
         "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything."
@@ -1863,7 +2236,7 @@ var KimiDriver = class {
   }
 };
 function detectKimiModels(home = os2.homedir()) {
-  const configPath = path7.join(home, ".kimi", "config.toml");
+  const configPath = path8.join(home, ".kimi", "config.toml");
   let raw;
   try {
     raw = readFileSync2(configPath, "utf8");
@@ -1908,7 +2281,7 @@ function getDriver(runtimeId) {
 
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -1916,7 +2289,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path8.join(dataDir, directoryName);
+  return path9.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -1965,7 +2338,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path8.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path9.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -1984,7 +2357,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path8.join(dataDir, entry.name);
+      const dirPath = path9.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -2016,7 +2389,7 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
 }
 
 // src/agentProcessManager.ts
-var DATA_DIR = path9.join(os3.homedir(), ".slock", "agents");
+var DATA_DIR = path10.join(os3.homedir(), ".slock", "agents");
 function toLocalTime(iso) {
   const d = new Date(iso);
   if (isNaN(d.getTime())) return iso;
@@ -2170,6 +2543,7 @@ function getBusyDeliveryNote(driver) {
   }
   return "\n\nNote: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.";
 }
+var NATIVE_STANDING_PROMPT_STARTUP_INPUT = "Your system prompt contains your standing instructions. Follow it now and begin listening for messages.";
 var AgentProcessManager = class _AgentProcessManager {
   agents = /* @__PURE__ */ new Map();
   agentsStarting = /* @__PURE__ */ new Set();
@@ -2178,6 +2552,7 @@ var AgentProcessManager = class _AgentProcessManager {
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
   chatBridgePath;
+  slockCliPath;
   sendToServer;
   daemonApiKey;
   serverUrl;
@@ -2186,6 +2561,7 @@ var AgentProcessManager = class _AgentProcessManager {
   defaultAgentEnvVarsProvider;
   constructor(chatBridgePath, sendToServer, daemonApiKey, opts) {
     this.chatBridgePath = chatBridgePath;
+    this.slockCliPath = opts.slockCliPath ?? "";
     this.sendToServer = sendToServer;
     this.daemonApiKey = daemonApiKey;
     this.serverUrl = opts.serverUrl;
@@ -2205,9 +2581,9 @@ var AgentProcessManager = class _AgentProcessManager {
     this.agentsStarting.add(agentId);
     try {
       const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path9.join(this.dataDir, agentId);
+      const agentDataDir = path10.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
-      const memoryMdPath = path9.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path10.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
@@ -2225,8 +2601,9 @@ ${config.description || "No role defined yet."}
 `;
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      await mkdir(path9.join(agentDataDir, "notes"), { recursive: true });
+      await mkdir(path10.join(agentDataDir, "notes"), { recursive: true });
       const isResume = !!config.sessionId;
+      const standingPrompt = driver.buildSystemPrompt(config, agentId);
       let prompt;
       if (isResume && resumePrompt) {
         prompt = resumePrompt;
@@ -2270,15 +2647,17 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         prompt = `No new messages while you were away. Nothing to do \u2014 just stop. ${getMessageDeliveryText(driver)}`;
         prompt += getBusyDeliveryNote(driver);
       } else {
-        prompt = driver.buildSystemPrompt(config, agentId);
+        prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : standingPrompt;
       }
       const effectiveConfig = await this.buildSpawnConfig(agentId, config);
       const { process: proc } = driver.spawn({
         agentId,
         config: effectiveConfig,
+        standingPrompt,
         prompt,
         workingDirectory: agentDataDir,
         chatBridgePath: this.chatBridgePath,
+        slockCliPath: this.slockCliPath,
         daemonApiKey: this.daemonApiKey
       });
       const agentProcess = {
@@ -2566,7 +2945,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path9.join(this.dataDir, agentId);
+    const agentDataDir = path10.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -2604,7 +2983,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path9.join(this.dataDir, agentId);
+    const agentDir = path10.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -2612,8 +2991,8 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path9.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path9.sep) && resolved !== agentDir) {
+      const resolved = path10.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path10.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -2621,9 +3000,9 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     return this.listDirectoryChildren(targetDir, agentDir);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path9.join(this.dataDir, agentId);
-    const resolved = path9.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path9.sep) && resolved !== agentDir) {
+    const agentDir = path10.join(this.dataDir, agentId);
+    const resolved = path10.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path10.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat2(resolved);
@@ -2647,7 +3026,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       ".sh",
       ".py"
     ]);
-    const ext = path9.extname(resolved).toLowerCase();
+    const ext = path10.extname(resolved).toLowerCase();
     if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
       return { content: null, binary: true };
     }
@@ -2674,13 +3053,13 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
     const home = os3.homedir();
-    const workspaceDir = path9.join(this.dataDir, agentId);
+    const workspaceDir = path10.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(path9.join(home, p)))
+      paths.global.map((p) => this.scanSkillsDir(path10.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path9.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path10.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -2709,7 +3088,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path9.join(dir, entry.name, "SKILL.md");
+        const skillMd = path10.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -2720,7 +3099,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(path9.join(dir, entry.name), "utf-8");
+          const content = await readFile(path10.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -2852,13 +3231,27 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       }
       case "tool_call": {
         this.flushPendingTrajectory(agentId);
-        const toolName = event.name;
-        const inputSummary = summarizeToolInput(toolName, event.input);
-        const detail = getToolActivityLabel(toolName);
-        this.broadcastActivity(agentId, "working", detail, [{ kind: "tool_start", toolName, toolInput: inputSummary }]);
+        const invocation = normalizeToolDisplayInvocation(event.name, event.input);
+        const inputSummary = summarizeToolInput(invocation.toolName, invocation.input);
+        const detail = getToolActivityLabel(invocation.toolName);
+        this.broadcastActivity(agentId, "working", detail, [{
+          kind: "tool_start",
+          toolName: invocation.toolName,
+          toolInput: inputSummary
+        }]);
         if (ap) ap.isIdle = false;
         break;
       }
+      case "compaction_started":
+        this.flushPendingTrajectory(agentId);
+        this.broadcastActivity(agentId, "working", "Compacting context", [{ kind: "compaction_started" }]);
+        if (ap) ap.isIdle = false;
+        break;
+      case "compaction_finished":
+        this.flushPendingTrajectory(agentId);
+        this.broadcastActivity(agentId, "working", "Context compaction finished", [{ kind: "compaction_finished" }]);
+        if (ap) ap.isIdle = false;
+        break;
       case "turn_end":
         this.flushPendingTrajectory(agentId);
         if (ap) {
@@ -2965,8 +3358,8 @@ Respond as appropriate. Complete all your work before stopping.`;
     const nodes = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = path9.join(dir, entry.name);
-      const relativePath = path9.relative(rootDir, fullPath);
+      const fullPath = path10.join(dir, entry.name);
+      const relativePath = path10.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -3116,6 +3509,85 @@ var DaemonConnection = class {
   }
 };
 
+// src/reminderCache.ts
+var DEFAULT_MAX_DELAY_MS = 24 * 60 * 60 * 1e3;
+var ReminderCache = class {
+  entries = /* @__PURE__ */ new Map();
+  clock;
+  onFire;
+  maxDelayMs;
+  constructor(opts) {
+    this.clock = opts.clock ?? systemClock;
+    this.onFire = opts.onFire;
+    this.maxDelayMs = opts.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  }
+  upsert(job) {
+    const existing = this.entries.get(job.reminderId);
+    if (existing && existing.job.version >= job.version) {
+      logger.info(`[ReminderCache] Stale upsert for ${job.reminderId} (incoming v${job.version} <= cached v${existing.job.version}) \u2014 ignored`);
+      return;
+    }
+    if (existing?.timer) this.clock.clearTimeout(existing.timer);
+    const timer = this.scheduleTimer(job);
+    this.entries.set(job.reminderId, { job, timer });
+  }
+  cancel(reminderId, version) {
+    const existing = this.entries.get(reminderId);
+    if (!existing) return;
+    if (existing.job.version > version) {
+      logger.info(`[ReminderCache] Stale cancel for ${reminderId} (incoming v${version} < cached v${existing.job.version}) \u2014 ignored`);
+      return;
+    }
+    if (existing.timer) this.clock.clearTimeout(existing.timer);
+    this.entries.delete(reminderId);
+  }
+  snapshot(agentId, jobs) {
+    for (const [reminderId, entry] of this.entries) {
+      if (entry.job.ownerAgentId !== agentId) continue;
+      if (entry.timer) this.clock.clearTimeout(entry.timer);
+      this.entries.delete(reminderId);
+    }
+    for (const job of jobs) {
+      if (job.ownerAgentId !== agentId) {
+        logger.warn(
+          `[ReminderCache] snapshot for agent ${agentId} carried job ${job.reminderId} owned by ${job.ownerAgentId} \u2014 skipping`
+        );
+        continue;
+      }
+      const timer = this.scheduleTimer(job);
+      this.entries.set(job.reminderId, { job, timer });
+    }
+  }
+  clear() {
+    for (const entry of this.entries.values()) {
+      if (entry.timer) this.clock.clearTimeout(entry.timer);
+    }
+    this.entries.clear();
+  }
+  size() {
+    return this.entries.size;
+  }
+  getJob(reminderId) {
+    return this.entries.get(reminderId)?.job ?? null;
+  }
+  scheduleTimer(job) {
+    const fireAt = Date.parse(job.fireAt);
+    if (Number.isNaN(fireAt)) {
+      logger.warn(`[ReminderCache] Invalid fireAt for ${job.reminderId}: ${job.fireAt}`);
+      return null;
+    }
+    const delay = Math.max(0, Math.min(this.maxDelayMs, fireAt - this.clock.now()));
+    return this.clock.setTimeout(() => {
+      this.entries.delete(job.reminderId);
+      try {
+        this.onFire(job);
+      } catch (err) {
+        logger.error(`[ReminderCache] onFire threw for ${job.reminderId}`, err);
+      }
+    }, delay);
+  }
+};
+
 // src/core.ts
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 function parseDaemonCliArgs(args) {
@@ -3137,13 +3609,25 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path10.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path10.resolve(dirname, "chat-bridge.js");
+  const dirname = path11.dirname(fileURLToPath(moduleUrl));
+  const jsPath = path11.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path10.resolve(dirname, "chat-bridge.ts");
+    return path11.resolve(dirname, "chat-bridge.ts");
+  }
+}
+function resolveSlockCliPath(moduleUrl = import.meta.url) {
+  const thisDir = path11.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path11.resolve(thisDir, "cli", "index.js");
+  try {
+    accessSync(bundledDistPath);
+    return bundledDistPath;
+  } catch {
+    const workspaceDistPath = path11.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    accessSync(workspaceDistPath);
+    return workspaceDistPath;
   }
 }
 function detectRuntimes() {
@@ -3196,6 +3680,12 @@ function summarizeIncomingMessage(msg) {
       return `(directory=${msg.directoryName})`;
     case "machine:runtime_models:detect":
       return `(runtime=${msg.runtime}, req=${msg.requestId})`;
+    case "reminder.upsert":
+      return `(agent=${msg.agentId}, id=${msg.reminder.reminderId}, v${msg.reminder.version}, fireAt=${msg.reminder.fireAt})`;
+    case "reminder.cancel":
+      return `(agent=${msg.agentId}, id=${msg.reminderId}, v${msg.version})`;
+    case "reminder.snapshot":
+      return `(agent=${msg.agentId}, count=${msg.reminders.length})`;
     default:
       return "";
   }
@@ -3204,19 +3694,27 @@ var DaemonCore = class {
   options;
   daemonVersion;
   chatBridgePath;
+  slockCliPath;
   runtimeDetector;
   agentManager;
   connection;
+  reminderCache;
   constructor(options) {
     this.options = options;
     this.daemonVersion = options.daemonVersion ?? readDaemonVersion();
     this.chatBridgePath = options.chatBridgePath ?? resolveChatBridgePath();
+    this.slockCliPath = options.slockCliPath ?? resolveSlockCliPath();
     this.runtimeDetector = options.runtimeDetector ?? detectRuntimes;
+    this.reminderCache = new ReminderCache({
+      clock: options.reminderClock,
+      onFire: (job) => this.onReminderFire(job)
+    });
     let connection;
     const agentManagerOptions = {
       dataDir: options.dataDir,
       serverUrl: options.serverUrl,
-      defaultAgentEnvVarsProvider: options.defaultAgentEnvVarsProvider
+      defaultAgentEnvVarsProvider: options.defaultAgentEnvVarsProvider,
+      slockCliPath: this.slockCliPath
     };
     this.agentManager = options.agentManagerFactory ? options.agentManagerFactory(this.chatBridgePath, (msg) => connection.send(msg), options.apiKey, agentManagerOptions) : new AgentProcessManager(this.chatBridgePath, (msg) => connection.send(msg), options.apiKey, agentManagerOptions);
     const connectionFactory = options.connectionFactory ?? ((connOptions) => new DaemonConnection(connOptions));
@@ -3236,6 +3734,7 @@ var DaemonCore = class {
   }
   async stop() {
     logger.info("[Slock Daemon] Shutting down...");
+    this.reminderCache.clear();
     await this.agentManager.stopAll();
     this.connection.disconnect();
   }
@@ -3330,11 +3829,31 @@ var DaemonCore = class {
         });
         break;
       }
+      case "reminder.upsert":
+        this.reminderCache.upsert(msg.reminder);
+        break;
+      case "reminder.cancel":
+        this.reminderCache.cancel(msg.reminderId, msg.version);
+        break;
+      case "reminder.snapshot":
+        logger.info(`[Daemon] Reminder snapshot for agent ${msg.agentId}: ${msg.reminders.length} entries`);
+        this.reminderCache.snapshot(msg.agentId, msg.reminders);
+        break;
       case "ping":
         this.connection.send({ type: "pong" });
         break;
     }
   }
+  onReminderFire(job) {
+    logger.info(`[Daemon] Reminder ${job.reminderId} fired locally (agent=${job.ownerAgentId})`);
+    this.connection.send({
+      type: "reminder.fire_attempt",
+      agentId: job.ownerAgentId,
+      reminderId: job.reminderId,
+      version: job.version,
+      firedAtClient: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
   handleConnect() {
     const { ids: runtimes, versions: runtimeVersions } = this.runtimeDetector();
     const runtimeInfo = runtimes.map((id) => runtimeVersions[id] ? `${id} (${runtimeVersions[id]})` : id);
@@ -3358,6 +3877,13 @@ var DaemonCore = class {
     for (const { agentId, sessionId, launchId } of this.agentManager.getIdleAgentSessionIds()) {
       this.connection.send({ type: "agent:session", agentId, sessionId, launchId: launchId || void 0 });
     }
+    const agentsForSnapshot = new Set(this.agentManager.getRunningAgentIds());
+    for (const { agentId } of this.agentManager.getIdleAgentSessionIds()) {
+      agentsForSnapshot.add(agentId);
+    }
+    for (const agentId of agentsForSnapshot) {
+      this.connection.send({ type: "reminder.snapshot.request", agentId });
+    }
     this.options.lifecycleHooks?.onConnect?.();
   }
   handleDisconnect() {
@@ -3374,6 +3900,7 @@ export {
   parseDaemonCliArgs,
   readDaemonVersion,
   resolveChatBridgePath,
+  resolveSlockCliPath,
   detectRuntimes,
   DaemonCore
 };