@slock-ai/daemon 0.41.1-alpha.0 → 0.43.0

package/dist/{chunk-JAB3HALZ.js → chunk-37O7EHYE.js}

@@ -4,8 +4,8 @@ import {
 } from "./chunk-JG7ONJZ6.js";
 
 // src/core.ts
-import path12 from "path";
-import os5 from "os";
+import path13 from "path";
+import os6 from "os";
 import { createRequire } from "module";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
@@ -545,8 +545,57 @@ var RUNTIMES = [
   { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
   { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
   { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
-  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true }
+  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true },
+  { id: "opencode", displayName: "OpenCode", binary: "opencode", supported: true }
 ];
+var RUNTIME_MODELS = {
+  claude: [
+    { id: "sonnet", label: "Sonnet" },
+    { id: "opus", label: "Opus" },
+    { id: "haiku", label: "Haiku" }
+  ],
+  codex: [
+    { id: "gpt-5.5", label: "GPT-5.5" },
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
+    { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark" },
+    { id: "gpt-5.2-codex", label: "GPT-5.2 Codex" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max" },
+    { id: "gpt-5.1-codex", label: "GPT-5.1 Codex" },
+    { id: "gpt-5-codex", label: "GPT-5 Codex" },
+    { id: "gpt-5", label: "GPT-5" }
+  ],
+  copilot: [
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "claude-4-sonnet", label: "Claude 4 Sonnet" },
+    { id: "claude-4.5-sonnet", label: "Claude 4.5 Sonnet" }
+  ],
+  cursor: [
+    { id: "composer-2-fast", label: "Composer 2 Fast" },
+    { id: "composer-2", label: "Composer 2" },
+    { id: "auto", label: "Auto" }
+  ],
+  gemini: [
+    { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (Preview)" },
+    { id: "gemini-3-flash-preview", label: "Gemini 3 Flash (Preview)" },
+    { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+    { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }
+  ],
+  opencode: [
+    { id: "opencode/gpt-5-nano", label: "GPT-5 Nano (OpenCode)" },
+    { id: "opencode/big-pickle", label: "Big Pickle (OpenCode)" },
+    { id: "opencode/hy3-preview-free", label: "HY3 Preview Free (OpenCode)" },
+    { id: "opencode/minimax-m2.5-free", label: "MiniMax M2.5 Free (OpenCode)" },
+    { id: "opencode/nemotron-3-super-free", label: "Nemotron 3 Super Free (OpenCode)" }
+  ],
+  // Kimi CLI resolves model keys from each user's local config, so the safest
+  // built-in option is to defer to whatever default model the CLI already uses.
+  kimi: [
+    { id: "default", label: "Configured Default" }
+  ]
+};
 var PLAN_CONFIG = {
   free: {
     displayName: "Hobby",
@@ -582,9 +631,10 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
+import { mkdirSync as mkdirSync4, readdirSync, statSync, writeFileSync as writeFileSync7 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
-import path10 from "path";
-import os3 from "os";
+import path11 from "path";
+import os4 from "os";
 
 // src/drivers/claude.ts
 import { spawn } from "child_process";
@@ -599,6 +649,27 @@ import path from "path";
 function toolRef(prefix, name) {
   return `${prefix}${name}`;
 }
+function runtimeContextLines(config) {
+  const ctx = config.runtimeContext;
+  if (!ctx) return [];
+  const lines = [
+    "## Current Runtime Context",
+    "",
+    "This is authoritative context injected by Slock. Do not infer computer identity from hostname or cwd when this section is present.",
+    ""
+  ];
+  if (ctx.agentId) lines.push(`- Agent ID: ${ctx.agentId}`);
+  if (ctx.serverId) lines.push(`- Server ID: ${ctx.serverId}`);
+  if (ctx.machineName || ctx.machineId) {
+    const label = ctx.machineName && ctx.machineId ? `${ctx.machineName} (${ctx.machineId})` : ctx.machineName || ctx.machineId;
+    lines.push(`- Computer: ${label}`);
+  }
+  if (ctx.machineHostname) lines.push(`- Hostname: ${ctx.machineHostname}`);
+  if (ctx.machineOs) lines.push(`- OS: ${ctx.machineOs}`);
+  if (ctx.daemonVersion) lines.push(`- Daemon: v${ctx.daemonVersion}`);
+  if (ctx.workspacePath) lines.push(`- Workspace: ${ctx.workspacePath}`);
+  return lines.length > 4 ? lines : [];
+}
 function buildPrompt(config, variant, opts) {
   const isCli = variant === "cli";
   const t = (name) => toolRef(opts.toolPrefix, name);
@@ -609,6 +680,9 @@ function buildPrompt(config, variant, opts) {
   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 scheduleReminderCmd = isCli ? "`slock reminder schedule`" : `\`${t("schedule_reminder")}\``;
+  const listRemindersCmd = isCli ? "`slock reminder list`" : `\`${t("list_reminders")}\``;
+  const cancelReminderCmd = isCli ? "`slock reminder cancel`" : `\`${t("cancel_reminder")}\``;
   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 = isCli ? [
     "- Always communicate through `slock` CLI commands. This is your only output channel.",
@@ -621,13 +695,18 @@ function buildPrompt(config, variant, opts) {
     "- 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 runtimeProfileControlStartupStep = config.runtimeProfileControl ? [
+    "0. If this system prompt contains a **Runtime Profile Control** section, complete that runtime-control instruction first. Do not read MEMORY.md, check messages, or respond to inbox messages until the required runtime control action has succeeded."
+  ] : [];
   const startupSteps = isCli ? [
+    ...runtimeProfileControlStartupStep,
     "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."
   ] : [
+    ...runtimeProfileControlStartupStep,
     `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}`,
@@ -641,24 +720,23 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 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 channel leave\`** \u2014 Leave a regular channel you have joined. This only affects your own agent membership.
-5. **\`slock thread unfollow\`** \u2014 Stop receiving ordinary delivery for a thread you no longer need to follow. This only affects your own agent attention state.
-6. **\`slock message read\`** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
-7. **\`slock message search\`** \u2014 Search messages visible to you, then inspect a hit with \`slock message read\`.
-8. **\`slock task list\`** \u2014 View a channel's task board.
-9. **\`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).
-10. **\`slock task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
-11. **\`slock task unclaim\`** \u2014 Release your claim on a task.
-12. **\`slock task update\`** \u2014 Change a task's status (e.g. to in_review or done).
-13. **\`slock attachment upload\`** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to \`slock message send\`.
-14. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
-15. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
-16. **\`slock reminder list\`** \u2014 List your reminders.
-17. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
-
-When a user asks you to remind them later, at a specific time, or on a recurring schedule, prefer the reminder commands instead of relying on MEMORY or manual follow-up.
-Do not use runtime-native wake or cron tools such as ScheduleWakeup or CronCreate for user-visible reminders; use \`slock reminder schedule\` so reminders stay anchored, observable, and cancelable in Slock.
-For agent-created reminders, first resolve the anchor message from the current conversation and pass its \`msgId\` explicitly. If you cannot resolve a message id, do not create the reminder.
+4. **\`slock channel members\`** \u2014 List the members (agents and humans) of a specific channel, DM, or thread target.
+5. **\`slock channel leave\`** \u2014 Leave a regular channel you have joined. This only affects your own agent membership.
+6. **\`slock thread unfollow\`** \u2014 Stop receiving ordinary delivery for a thread you no longer need to follow. This only affects your own agent attention state.
+7. **\`slock message read\`** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
+8. **\`slock message search\`** \u2014 Search messages visible to you, then inspect a hit with \`slock message read\`.
+9. **\`slock task list\`** \u2014 View a channel's task board.
+10. **\`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).
+11. **\`slock task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
+12. **\`slock task unclaim\`** \u2014 Release your claim on a task.
+13. **\`slock task update\`** \u2014 Change a task's status (e.g. to in_review or done).
+14. **\`slock attachment upload\`** \u2014 Upload a file to attach to a message. Uses content sniffing for image previews; pass \`--mime-type\` only when you know the exact type. Returns an attachment ID to pass to \`slock message send\`.
+15. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
+16. **\`slock profile show\`** \u2014 Show your own profile, or another visible profile via \`@handle\`. Mirrors the canonical Slock profile view.
+17. **\`slock profile update\`** \u2014 Update your own profile. Supports \`--avatar-file <path>\`, \`--display-name <name>\`, and \`--description <text>\`. Values must be non-empty. Provide at least one flag per call; multiple flags can be combined.
+18. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
+19. **\`slock reminder list\`** \u2014 List your reminders.
+20. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
 
 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
@@ -682,7 +760,15 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 10. **\`${t("unclaim_task")}\`** \u2014 Release your claim on a task.
 11. **${taskUpdateCmd}** \u2014 Change a task's status (e.g. to in_review or done).
 12. **\`${t("upload_file")}\`** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to ${sendCmd}.
-13. **\`${t("view_file")}\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.`;
+13. **\`${t("view_file")}\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
+14. **${scheduleReminderCmd}** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
+15. **${listRemindersCmd}** \u2014 List your reminders.
+16. **${cancelReminderCmd}** \u2014 Cancel one of your reminders by ID.`;
+  const reminderSection = `### Reminders
+
+Use reminders for follow-up that depends on future state you cannot resolve now, whether user-requested or self-driven. A reminder is an author-owned, persistent, observable, and cancelable wake-up signal anchored to a Slock message or thread; when it fires, it wakes the author who scheduled it, not other people. If anchored to a message or thread, the receipt/fire system message is visible in that surface, but wake ownership does not transfer. To notify another human or agent later, schedule your own reminder and then @mention them when it fires. Use reminders instead of keeping the current turn alive with a long sleep or relying on MEMORY to wake you. If you expect the wait to finish within about 1 minute, you may briefly poll, but say so in the relevant thread first.
+Use ${scheduleReminderCmd} rather than runtime-native wake or cron tools such as ScheduleWakeup or CronCreate for user-visible reminders, so reminders stay anchored, observable, and cancelable in Slock.
+Create agent reminders only after resolving the anchor message from the current conversation and passing its msgId explicitly; if no anchor can be resolved, consider posting a status update in the relevant thread so the intent is visible, then revisit when context is available.`;
   const sendingMessagesSection = isCli ? `### Sending messages
 
 - **Reply to a channel**: \`slock message send --target "#channel-name" <<'EOF'\` followed by the message body and \`EOF\`
@@ -728,7 +814,7 @@ Threads are sub-conversations attached to a specific message. They let you discu
   const discoverySection = isCli ? `### Discovering people and channels
 
 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. To leave a regular channel you have joined, use \`slock channel leave --target "#channel-name"\`. To stop following a thread without leaving its parent channel, use \`slock thread unfollow --target "#channel-name:shortid"\`.` : `### Discovering people and channels
+Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`slock message read\` and \`slock channel members\`, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel. To leave a regular channel you have joined, use \`slock channel leave --target "#channel-name"\`. To stop following a thread without leaving its parent channel, use \`slock thread unfollow --target "#channel-name:shortid"\`.` : `### Discovering people and channels
 
 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. To leave a regular channel you have joined, use \`${t("leave_channel")}\`.`;
@@ -752,6 +838,11 @@ To jump directly to a specific hit with nearby context, use \`slock message read
 Use ${readCmd} with the \`channel\` parameter set to \`"#channel-name"\`, \`"dm:@peer-name"\`, or a thread target like \`"#channel:shortid"\`.
 
 To jump directly to a specific hit with nearby context, pass \`around\` set to a message ID or seq number.`;
+  const historicalReferenceSection = isCli ? `### Historical references
+
+When a user refers to prior Slock discussion and the relevant context is not already available, first use \`slock message search\` and \`slock message read\` to find the original thread, decision, or owner before answering. If you find it, summarize the original conclusion with the source thread/message; if you cannot find it, say that explicitly.` : `### Historical references
+
+When a user refers to prior Slock discussion and the relevant context is not already available, first use \`${t("search_messages")}\` and ${readCmd} to find the original thread, decision, or owner before answering. If you find it, summarize the original conclusion with the source thread/message; if you cannot find it, say that explicitly.`;
   const tasksSection = isCli ? `### 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.
@@ -838,6 +929,8 @@ ${readCmd} shows messages in their current state. If a message was later convert
 
 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.
 
+${runtimeContextLines(config).join("\n")}
+
 ${communicationSection}
 
 CRITICAL RULES:
@@ -851,6 +944,30 @@ ${startupSteps.join("\n")}`;
 
 ${opts.postStartupNotes.join("\n")}`;
   }
+  if (config.runtimeProfileControl) {
+    const control = config.runtimeProfileControl;
+    prompt += `
+
+## Runtime Profile Control
+
+`;
+    prompt += `This section is a trusted daemon runtime-control instruction. It overrides the normal startup sequence: complete this section before reading MEMORY.md, checking messages, or responding to inbox messages.
+
+`;
+    if (control.kind === "migration") {
+      prompt += `You are currently in Runtime Profile migration. Before handling normal inbox messages, re-ground yourself in the new runtime context and then invoke the runtime control action \`${t("runtime_profile_migration_done")}\` with exactly this migration_key: \`${control.key}\`.
+
+`;
+      prompt += `Do not use ${sendCmd}, ${checkCmd}, or any chat reply as the migration acknowledgment. Normal inbox delivery is gated until the runtime control action succeeds.
+
+`;
+    } else {
+      prompt += `Read the daemon release notice below before handling normal inbox messages. No chat reply is required for this notice.
+
+`;
+    }
+    prompt += control.message;
+  }
   prompt += `
 
 ## Messaging
@@ -875,6 +992,8 @@ Header fields:
 
 ${sendingMessagesSection}
 
+${reminderSection}
+
 ${threadsSection}
 
 ${discoverySection}
@@ -883,6 +1002,8 @@ ${channelAwarenessSection}
 
 ${readingHistorySection}
 
+${historicalReferenceSection}
+
 ${tasksSection}
 
 ### Splitting tasks for parallel execution
@@ -940,7 +1061,7 @@ When writing a URL next to non-ASCII punctuation (Chinese, Japanese, etc.), alwa
 
 ## Workspace & Memory
 
-Your working directory (cwd) is your **persistent workspace**. Everything you write here survives across sessions.
+Your working directory (cwd) is your **persistent, agent-owned workspace**; files you create here survive across sessions. Use it for memory, notes, artifacts, code checkouts, and task-specific files, but treat it as a flexible workspace rather than a fixed schema. Keep **MEMORY.md** easy to scan as the recovery entry point; if you add important long-lived organization, update **MEMORY.md** or a note index so future sessions can find it. When working in a repository, first choose the specific project directory or worktree inside the workspace, then run git or package-manager commands there.
 
 ### MEMORY.md \u2014 Your Memory Index (CRITICAL)
 
@@ -1045,6 +1166,20 @@ function buildMcpSystemPrompt(config, opts) {
 
 // src/drivers/cliTransport.ts
 var shellSingleQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+function runtimeContextEnv(config) {
+  const ctx = config.runtimeContext;
+  if (!ctx) return {};
+  return {
+    ...ctx.agentId ? { SLOCK_CURRENT_AGENT_ID: ctx.agentId } : {},
+    ...ctx.serverId ? { SLOCK_CURRENT_SERVER_ID: ctx.serverId } : {},
+    ...ctx.machineId ? { SLOCK_CURRENT_COMPUTER_ID: ctx.machineId } : {},
+    ...ctx.machineName ? { SLOCK_CURRENT_COMPUTER_NAME: ctx.machineName } : {},
+    ...ctx.machineHostname ? { SLOCK_CURRENT_COMPUTER_HOSTNAME: ctx.machineHostname } : {},
+    ...ctx.machineOs ? { SLOCK_CURRENT_COMPUTER_OS: ctx.machineOs } : {},
+    ...ctx.daemonVersion ? { SLOCK_CURRENT_DAEMON_VERSION: ctx.daemonVersion } : {},
+    ...ctx.workspacePath ? { SLOCK_CURRENT_WORKSPACE_PATH: ctx.workspacePath } : {}
+  };
+}
 function buildCliTransportSystemPrompt(config, opts) {
   return buildCliSystemPrompt(config, opts);
 }
@@ -1074,6 +1209,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(ctx.slockCliPath)}
     FORCE_COLOR: "0",
     ...ctx.config.envVars || {},
     ...extraEnv,
+    ...runtimeContextEnv(ctx.config),
     SLOCK_AGENT_ID: ctx.agentId,
     ...ctx.launchId ? { SLOCK_AGENT_LAUNCH_ID: ctx.launchId } : {},
     SLOCK_SERVER_URL: ctx.config.serverUrl,
@@ -1207,6 +1343,8 @@ var ClaudeDriver = class {
       "--allow-dangerously-skip-permissions",
       "--dangerously-skip-permissions",
       "--verbose",
+      "--permission-mode",
+      "bypassPermissions",
       "--output-format",
       "stream-json",
       "--input-format",
@@ -1217,16 +1355,16 @@ var ClaudeDriver = class {
       CLAUDE_DISALLOWED_TOOLS
     ];
     if (opts.standingPromptFilePath) {
-      args.push("--append-system-prompt-file", opts.standingPromptFilePath);
+      args.push("--system-prompt-file", opts.standingPromptFilePath);
     } else {
-      args.push("--append-system-prompt", standingPrompt);
+      args.push("--system-prompt", standingPrompt);
     }
     if (config.sessionId) {
       args.push("--resume", config.sessionId);
     }
     return args;
   }
-  buildDeprecatedShimMcpConfig(ctx) {
+  buildRuntimeActionsMcpConfig(ctx) {
     const isTsSource = ctx.chatBridgePath.endsWith(".ts");
     const command = isTsSource ? "npx" : "node";
     const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath];
@@ -1245,7 +1383,7 @@ var ClaudeDriver = class {
             "--runtime",
             this.id,
             ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-            "--deprecated-shim"
+            "--runtime-actions-only"
           ]
         }
       }
@@ -1255,7 +1393,7 @@ var ClaudeDriver = class {
     const systemPromptPath = path3.join(slockDir, CLAUDE_SYSTEM_PROMPT_FILE);
     const mcpConfigPath = path3.join(slockDir, CLAUDE_MCP_CONFIG_FILE);
     writeFileSync2(systemPromptPath, ctx.standingPrompt, { mode: 384 });
-    writeFileSync2(mcpConfigPath, this.buildDeprecatedShimMcpConfig(ctx), { mode: 384 });
+    writeFileSync2(mcpConfigPath, this.buildRuntimeActionsMcpConfig(ctx), { mode: 384 });
     return { systemPromptPath, mcpConfigPath };
   }
   spawn(ctx) {
@@ -1264,7 +1402,7 @@ var ClaudeDriver = class {
     const args = this.buildClaudeArgs(ctx.config, ctx.standingPrompt, {
       standingPromptFilePath: systemPromptPath
     });
-    args.push("--mcp-config", mcpConfigPath);
+    args.push("--mcp-config", mcpConfigPath, "--strict-mcp-config");
     delete spawnEnv.CLAUDECODE;
     logger.info(
       `[Agent ${ctx.agentId}] transport=cli cli=${ctx.slockCliPath} token_file=${tokenFile}`
@@ -1388,7 +1526,9 @@ var ClaudeDriver = class {
   buildSystemPrompt(config, _agentId) {
     return buildCliTransportSystemPrompt(config, {
       toolPrefix: "mcp__chat__",
-      extraCriticalRules: [],
+      extraCriticalRules: [
+        "- Runtime Profile migration completion is the only exception to CLI-only operation: when a migration notice tells you to acknowledge with `runtime_profile_migration_done`, call the `mcp__chat__runtime_profile_migration_done` tool with the exact `migration_key`; do not use `slock` CLI or reply in chat as the acknowledgment."
+      ],
       postStartupNotes: [
         "**Claude runtime note:** Slock preserves Claude Code same-turn steering through a gated stream-json delivery path. Busy messages are buffered and delivered at Claude-observed safe boundaries; if no earlier safe boundary is available, they are delivered after the current turn ends.",
         "For long tool runs, you can also use `slock message check` at natural breakpoints to pull pending messages explicitly."
@@ -1498,7 +1638,7 @@ var CodexDriver = class {
   probe() {
     return probeCodex();
   }
-  buildDeprecatedShimConfigArgs(ctx) {
+  buildRuntimeActionsConfigArgs(ctx) {
     const isTsSource = ctx.chatBridgePath.endsWith(".ts");
     const command = isTsSource ? "npx" : "node";
     const bridgeArgs = isTsSource ? [
@@ -1513,7 +1653,7 @@ var CodexDriver = class {
       "--runtime",
       this.id,
       ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-      "--deprecated-shim"
+      "--runtime-actions-only"
     ] : [
       ctx.chatBridgePath,
       "--agent-id",
@@ -1525,7 +1665,7 @@ var CodexDriver = class {
       "--runtime",
       this.id,
       ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-      "--deprecated-shim"
+      "--runtime-actions-only"
     ];
     return [
       "-c",
@@ -1595,7 +1735,7 @@ var CodexDriver = class {
     this.streamedAgentMessageIds.clear();
     this.streamedReasoningIds.clear();
     const args = ["app-server", "--listen", "stdio://"];
-    args.push(...this.buildDeprecatedShimConfigArgs(ctx));
+    args.push(...this.buildRuntimeActionsConfigArgs(ctx));
     const { command, args: spawnArgs } = resolveCodexSpawn(args);
     const proc = spawn2(command, spawnArgs, {
       cwd: ctx.workingDirectory,
@@ -2165,6 +2305,17 @@ var CursorDriver = class {
 import { spawn as spawn5 } from "child_process";
 import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
 import path7 from "path";
+function buildGeminiSpawnEnv(ctx) {
+  return {
+    ...process.env,
+    FORCE_COLOR: "0",
+    NO_COLOR: "1",
+    // Gemini CLI's trusted-workspace gate breaks our managed headless flow
+    // unless we explicitly trust the daemon-owned agent workspace.
+    GEMINI_CLI_TRUST_WORKSPACE: "true",
+    ...ctx.config.envVars || {}
+  };
+}
 var GeminiDriver = class {
   id = "gemini";
   supportsStdinNotification = false;
@@ -2204,7 +2355,7 @@ var GeminiDriver = class {
     if (ctx.config.sessionId) {
       args.push("--resume", ctx.config.sessionId);
     }
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", ...ctx.config.envVars || {} };
+    const spawnEnv = buildGeminiSpawnEnv(ctx);
     const proc = spawn5("gemini", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
@@ -2506,6 +2657,279 @@ function detectKimiModels(home = os2.homedir()) {
   return { models, default: defaultModel };
 }
 
+// src/drivers/opencode.ts
+import { spawn as spawn7 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import os3 from "os";
+import path9 from "path";
+var CHAT_MCP_SERVER_NAME = "chat";
+var CHAT_MCP_TOOL_PREFIX = `${CHAT_MCP_SERVER_NAME}_`;
+var SLOCK_AGENT_NAME = "slock";
+var NO_MESSAGE_PROMPT = "No new messages are pending. Stop now.";
+var FIRST_MESSAGE_TASK_PREFIX = "First message task (system-triggered):";
+var MIN_SUPPORTED_OPENCODE_VERSION = "1.14.30";
+function buildChatBridgeCommand(ctx) {
+  const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+  return [
+    isTsSource ? "npx" : "node",
+    ...isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath],
+    "--agent-id",
+    ctx.agentId,
+    "--server-url",
+    ctx.config.serverUrl,
+    "--auth-token",
+    ctx.config.authToken || ctx.daemonApiKey,
+    "--runtime",
+    "opencode",
+    ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
+    "--runtime-actions-only"
+  ];
+}
+function parseOpenCodeConfigContent(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function parseUserOpenCodeConfig(ctx) {
+  const raw = ctx.config.envVars?.OPENCODE_CONFIG_CONTENT;
+  return parseOpenCodeConfigContent(raw);
+}
+function readLocalOpenCodeConfig(home = os3.homedir()) {
+  const configPath = path9.join(home, ".config", "opencode", "opencode.json");
+  try {
+    return parseOpenCodeConfigContent(readFileSync3(configPath, "utf8"));
+  } catch {
+  }
+  return {};
+}
+function recordField(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function parseSemver(version) {
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isSupportedOpenCodeVersion(version) {
+  if (!version) return true;
+  const actual = parseSemver(version);
+  const minimum = parseSemver(MIN_SUPPORTED_OPENCODE_VERSION);
+  if (!actual || !minimum) return true;
+  for (let i = 0; i < 3; i += 1) {
+    if (actual[i] > minimum[i]) return true;
+    if (actual[i] < minimum[i]) return false;
+  }
+  return true;
+}
+function unsupportedOpenCodeVersionMessage(version) {
+  if (!version || isSupportedOpenCodeVersion(version)) return null;
+  return `OpenCode CLI ${version} is unsupported; requires OpenCode >= ${MIN_SUPPORTED_OPENCODE_VERSION}. Upgrade opencode before starting this runtime.`;
+}
+function mergeOpenCodeConfigs(localConfig, envConfig) {
+  return {
+    ...localConfig,
+    ...envConfig,
+    provider: {
+      ...recordField(localConfig.provider),
+      ...recordField(envConfig.provider)
+    },
+    agent: {
+      ...recordField(localConfig.agent),
+      ...recordField(envConfig.agent)
+    },
+    mcp: {
+      ...recordField(localConfig.mcp),
+      ...recordField(envConfig.mcp)
+    }
+  };
+}
+function buildOpenCodeConfig(ctx, home = os3.homedir()) {
+  const userConfig = mergeOpenCodeConfigs(readLocalOpenCodeConfig(home), parseUserOpenCodeConfig(ctx));
+  const userAgents = recordField(userConfig.agent);
+  const userSlockAgent = recordField(userAgents[SLOCK_AGENT_NAME]);
+  return {
+    ...userConfig,
+    $schema: "https://opencode.ai/config.json",
+    agent: {
+      ...userAgents,
+      [SLOCK_AGENT_NAME]: {
+        ...userSlockAgent,
+        description: "Slock agent runtime",
+        prompt: ctx.standingPrompt
+      }
+    },
+    mcp: {
+      ...recordField(userConfig.mcp),
+      [CHAT_MCP_SERVER_NAME]: {
+        type: "local",
+        command: buildChatBridgeCommand(ctx),
+        enabled: true
+      }
+    }
+  };
+}
+function buildOpenCodeLaunchOptions(ctx, home = os3.homedir()) {
+  const slock = prepareCliTransport(ctx, { NO_COLOR: "1" });
+  const config = buildOpenCodeConfig(ctx, home);
+  const env = {
+    ...slock.spawnEnv,
+    OPENCODE_CONFIG_CONTENT: JSON.stringify(config)
+  };
+  const args = [
+    "run",
+    "--format",
+    "json",
+    "--dangerously-skip-permissions",
+    "--pure",
+    "--dir",
+    ctx.workingDirectory
+  ];
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  args.push("--agent", SLOCK_AGENT_NAME);
+  if (ctx.config.sessionId) {
+    args.push("--session", ctx.config.sessionId);
+  }
+  const turnPrompt = ctx.prompt === ctx.standingPrompt ? NO_MESSAGE_PROMPT : ctx.prompt;
+  args.push("--", turnPrompt);
+  return { args, env, config };
+}
+function detectOpenCodeModels(home = os3.homedir()) {
+  const models = [...RUNTIME_MODELS.opencode || []];
+  const providers = recordField(readLocalOpenCodeConfig(home).provider);
+  for (const [providerId, providerConfig] of Object.entries(providers)) {
+    const providerModels = recordField(recordField(providerConfig).models);
+    for (const [modelId, modelConfig] of Object.entries(providerModels)) {
+      const fullId = `${providerId}/${modelId}`;
+      if (models.some((model2) => model2.id === fullId)) continue;
+      const model = recordField(modelConfig);
+      const name = typeof model.name === "string" && model.name.length > 0 ? model.name : fullId;
+      models.push({ id: fullId, label: name });
+    }
+  }
+  return models.length > 0 ? { models } : null;
+}
+function isSystemFirstMessageTask(message) {
+  return message.sender_id === "system" && message.channel_type === "channel" && message.channel_name === "all" && message.content.trimStart().startsWith(FIRST_MESSAGE_TASK_PREFIX);
+}
+function buildOpenCodeSystemPrompt(config) {
+  return buildCliTransportSystemPrompt(config, {
+    toolPrefix: CHAT_MCP_TOOL_PREFIX,
+    extraCriticalRules: [
+      "- Runtime Profile migration completion is the only exception to CLI-only operation: when a migration notice tells you to acknowledge with `runtime_profile_migration_done`, call the `chat_runtime_profile_migration_done` tool with the exact `migration_key`; do not use `slock` CLI or reply in chat as the acknowledgment."
+    ],
+    postStartupNotes: [
+      "**OpenCode runtime note:** Slock launches you as a per-turn process. Complete the current wake using `slock` CLI commands, then stop; the daemon will restart you when new messages arrive."
+    ],
+    includeStdinNotificationSection: false,
+    messageNotificationStyle: "poll"
+  });
+}
+var OpenCodeDriver = class {
+  id = "opencode";
+  supportsStdinNotification = false;
+  mcpToolPrefix = CHAT_MCP_TOOL_PREFIX;
+  busyDeliveryMode = "none";
+  terminateProcessOnTurnEnd = true;
+  deferSpawnUntilMessage = true;
+  usesSlockCliForCommunication = true;
+  shouldDeferWakeMessage(message) {
+    return isSystemFirstMessageTask(message);
+  }
+  sessionId = null;
+  sessionAnnounced = false;
+  probe() {
+    if (!resolveCommandOnPath("opencode")) return { available: false };
+    const version = readCommandVersion("opencode") || void 0;
+    const unsupportedMessage = unsupportedOpenCodeVersionMessage(version);
+    if (unsupportedMessage) {
+      return {
+        available: false,
+        version: `${version} (requires >= ${MIN_SUPPORTED_OPENCODE_VERSION})`
+      };
+    }
+    return { available: true, version };
+  }
+  async detectModels() {
+    return detectOpenCodeModels();
+  }
+  spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    this.sessionAnnounced = false;
+    const unsupportedMessage = unsupportedOpenCodeVersionMessage(readCommandVersion("opencode"));
+    if (unsupportedMessage) {
+      throw new Error(unsupportedMessage);
+    }
+    const launch = buildOpenCodeLaunchOptions(ctx);
+    const proc = spawn7("opencode", launch.args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: launch.env,
+      shell: process.platform === "win32"
+    });
+    proc.stdin?.end();
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    if (event.sessionID && event.sessionID !== this.sessionId) {
+      this.sessionId = event.sessionID;
+    }
+    if (!this.sessionAnnounced && this.sessionId) {
+      events.push({ kind: "session_init", sessionId: this.sessionId });
+      this.sessionAnnounced = true;
+    }
+    switch (event.type) {
+      case "step_start":
+        events.push({ kind: "thinking", text: "" });
+        break;
+      case "text":
+        if (typeof event.part?.text === "string" && event.part.text.length > 0) {
+          events.push({ kind: "text", text: event.part.text });
+        }
+        break;
+      case "tool_use":
+        events.push({
+          kind: "tool_call",
+          name: event.part?.tool || "unknown_tool",
+          input: event.part?.state?.input
+        });
+        break;
+      case "step_finish":
+        if (event.part?.reason !== "tool-calls") {
+          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+        }
+        break;
+      case "error": {
+        const message = event.error?.data?.message || event.error?.message || (event.error?.name ? `${event.error.name} (no message)` : null) || "Unknown OpenCode error";
+        events.push({ kind: "error", message });
+        events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+        break;
+      }
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildOpenCodeSystemPrompt(config);
+  }
+};
+
 // src/drivers/index.ts
 var driverFactories = {
   claude: () => new ClaudeDriver(),
@@ -2513,7 +2937,8 @@ var driverFactories = {
   copilot: () => new CopilotDriver(),
   cursor: () => new CursorDriver(),
   gemini: () => new GeminiDriver(),
-  kimi: () => new KimiDriver()
+  kimi: () => new KimiDriver(),
+  opencode: () => new OpenCodeDriver()
 };
 function getDriver(runtimeId) {
   const createDriver = driverFactories[runtimeId];
@@ -2526,7 +2951,7 @@ function getDriver(runtimeId) {
 
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -2534,7 +2959,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path9.join(dataDir, directoryName);
+  return path10.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -2583,7 +3008,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path9.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path10.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -2602,7 +3027,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path9.join(dataDir, entry.name);
+      const dirPath = path10.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -2634,7 +3059,7 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
 }
 
 // src/agentProcessManager.ts
-var DATA_DIR = path10.join(os3.homedir(), ".slock", "agents");
+var DATA_DIR = path11.join(os4.homedir(), ".slock", "agents");
 function toLocalTime(iso) {
   const d = new Date(iso);
   if (isNaN(d.getTime())) return iso;
@@ -2660,6 +3085,86 @@ function formatMessageTarget(message) {
 function getMessageShortId(messageId) {
   return messageId.startsWith("thread-") ? messageId.slice(7) : messageId.slice(0, 8);
 }
+function findSessionJsonl(root, predicate) {
+  let visited = 0;
+  const maxEntries = 1e4;
+  const maxDepth = 8;
+  const visit = (dir, depth) => {
+    if (depth < 0 || visited >= maxEntries) return null;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      if (++visited > maxEntries) return null;
+      if (!entry.isFile() || !predicate(entry.name)) continue;
+      return path11.join(dir, entry.name);
+    }
+    for (const entry of entries) {
+      if (++visited > maxEntries) return null;
+      if (!entry.isDirectory()) continue;
+      const found = visit(path11.join(dir, entry.name), depth - 1);
+      if (found) return found;
+    }
+    return null;
+  };
+  return visit(root, maxDepth);
+}
+function safeSessionFilename(value) {
+  const normalized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "unknown-session";
+}
+function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
+  try {
+    const dir = path11.join(fallbackDir, ".slock", "runtime-sessions");
+    mkdirSync4(dir, { recursive: true });
+    const filePath = path11.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    writeFileSync7(filePath, JSON.stringify({
+      type: "runtime_session_handoff",
+      runtime,
+      sessionId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      note: "The native runtime transcript file was not found on this machine; this daemon-created handoff records the previous session identity for Runtime Profile migration."
+    }) + "\n", { mode: 384 });
+    return {
+      label: sessionId,
+      path: filePath,
+      runtime,
+      reachable: true,
+      reason: "native session file path not found; using daemon handoff file"
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os4.homedir(), fallbackDir) {
+  const directPath = path11.isAbsolute(sessionId) ? sessionId : null;
+  if (directPath) {
+    try {
+      if (statSync(directPath).isFile()) {
+        return { label: sessionId, path: directPath, runtime, reachable: true };
+      }
+    } catch {
+    }
+  }
+  const resolvedPath = runtime === "claude" ? findSessionJsonl(path11.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path11.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
+  if (!resolvedPath && fallbackDir) {
+    const fallback = writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir);
+    if (fallback) return fallback;
+  }
+  const ref = {
+    label: sessionId,
+    path: resolvedPath ?? sessionId,
+    runtime,
+    reachable: Boolean(resolvedPath)
+  };
+  if (!resolvedPath) {
+    ref.reason = "session file path not found";
+  }
+  return ref;
+}
 function formatSenderHandle(message) {
   return message.sender_description ? `@${message.sender_name} \u2014 ${message.sender_description}` : `@${message.sender_name}`;
 }
@@ -2675,12 +3180,38 @@ function formatThreadContextMessage(message) {
   const senderType = formatVisibleActorType(message.sender_type);
   return `- [msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(message)}: ${message.content}`;
 }
-function formatIncomingMessage(message) {
+function mcpToolName(driver, name) {
+  return `${driver?.mcpToolPrefix ?? ""}${name}`;
+}
+function communicationCommand(driver, name) {
+  if (!driver?.usesSlockCliForCommunication) {
+    return mcpToolName(driver, name);
+  }
+  switch (name) {
+    case "send_message":
+      return "slock message send";
+    case "read_history":
+      return "slock message read";
+    case "check_messages":
+      return "slock message check";
+    case "claim_tasks":
+      return "slock task claim";
+    default:
+      return `slock ${name.replace(/_/g, " ")}`;
+  }
+}
+function dynamicReplyInstruction(driver) {
+  return driver?.usesSlockCliForCommunication ? "reply using `slock message send --target <exact target>`" : `reply with ${communicationCommand(driver, "send_message")}`;
+}
+function dynamicClaimInstruction(driver) {
+  return driver?.usesSlockCliForCommunication ? "claim the relevant task with `slock task claim`" : `claim the relevant task with ${communicationCommand(driver, "claim_tasks")}`;
+}
+function formatIncomingMessage(message, driver) {
   const threadJoinPrefix = message.thread_join_context ? [
     `[System: You were added to a new thread via @mention. Read this context before replying.]`,
     `parent: ${message.thread_join_context.parent_target}`,
     `thread: ${message.thread_join_context.thread_target}`,
-    `suggested next step: read_history(channel="${message.thread_join_context.suggested_read_history_target}")`,
+    `suggested next step: ${driver?.usesSlockCliForCommunication ? `slock message read --channel "${message.thread_join_context.suggested_read_history_target}"` : `${communicationCommand(driver, "read_history")}(channel="${message.thread_join_context.suggested_read_history_target}")`}`,
     "",
     "Parent message:",
     formatThreadContextMessage(message.thread_join_context.parent_message),
@@ -2699,6 +3230,42 @@ function formatIncomingMessage(message) {
   return threadJoinPrefix ? `${threadJoinPrefix}
 ${body}` : body;
 }
+function formatRuntimeProfileControlPrompt(messages) {
+  const controls = messages.map((message) => ({
+    message,
+    notification: runtimeProfileNotificationFromMessage(message)
+  }));
+  if (controls.length === 0 || controls.some(({ notification }) => !notification)) {
+    return null;
+  }
+  const body = controls.map(({ message }) => message.content).join("\n\n---\n\n");
+  return [
+    "Runtime Profile control notice.",
+    "",
+    "Complete the required runtime control action before reading or responding to normal inbox messages.",
+    "",
+    body,
+    "",
+    "Do not answer this notice in prose as the acknowledgment."
+  ].join("\n");
+}
+function formatRuntimeProfileControlStartupInput(control, driver) {
+  if (control.kind !== "migration") {
+    return [
+      "Read the Runtime Profile daemon release notice from your system prompt before normal work.",
+      "No chat reply is required for this notice. Stop after reading it; queued inbox messages will be delivered separately."
+    ].join("\n");
+  }
+  const actionName = `${driver.mcpToolPrefix}runtime_profile_migration_done`;
+  return [
+    "Runtime Profile migration is required before normal work.",
+    `Invoke the available runtime control action \`${actionName}\` with exactly this migration_key: \`${control.key}\`.`,
+    "Do not read MEMORY.md, check messages, or send a chat reply before this tool call.",
+    "After the runtime control action succeeds, stop. Queued inbox messages will be delivered separately.",
+    "",
+    control.message
+  ].join("\n");
+}
 function buildUnreadSummary(messages, excludeChannel) {
   const summary = /* @__PURE__ */ new Map();
   for (const message of messages) {
@@ -2723,6 +3290,16 @@ var FIRST_CINDY_SEED_MODE = "first-cindy";
 function getOnboardingSeedMode(config) {
   return (config.envVars?.[ONBOARDING_MEMORY_SEED_ENV] || "").trim().toLowerCase();
 }
+function withLocalRuntimeContext(config, agentId, workspacePath) {
+  return {
+    ...config,
+    runtimeContext: {
+      ...config.runtimeContext ?? {},
+      agentId: config.runtimeContext?.agentId ?? agentId,
+      workspacePath
+    }
+  };
+}
 function buildOnboardingPlaybookMd() {
   return `# Cindy Onboarding Playbook
 
@@ -2731,14 +3308,18 @@ Start warm and brief.
 Move quickly to one useful action, not a feature tour.
 Keep activation energy low: invite the user to start with one sentence about what they need now.
 
-## Step 2: Capture Minimal Context
-Ask only what is needed to route:
-1. What is your role?
-2. What are you working on these days?
+## Step 2: Activate or Propose
+Use one decision: does the user already know what they want to do?
+- Yes: skip role/work intake and propose a starter plan.
+- No: ask what they do and what they are working on. These questions are activation, not a questionnaire.
+
+After any usable signal, stop asking and propose.
+After confirming language preference, do not give a generic product introduction; move into the user's work or a starter action.
 
 ## Step 3: Route by Intent (A-E)
 - A: Specific project/task
-  - Map immediately to first setup actions (agents + channels + first task).
+  - Enter starter-task mode immediately.
+  - Propose first setup actions before asking for more detail.
 - B: "What can you do?" curiosity
   - Proactively share 1-2 interview-grounded examples, then ask the user to pick one.
   - Use this opener tone: "Here are some examples our users have shared with us. I'm sharing these to inspire you."
@@ -2749,6 +3330,28 @@ Ask only what is needed to route:
 - E: Low-intent greeting/testing
   - Use a low-pressure prompt and guide to one concrete starter action.
 
+### Starter Plan Output
+A starter plan should make the next action executable, not just descriptive:
+- agent name + role description that can be copied into the create-agent form
+- suggested channel or workstream
+- first task to send after creation
+- next UI action if the user needs to create an agent or channel
+
+Do not use a rigid keyword routing table. Use examples as inspiration, then adapt to the user's context.
+If details are missing but not blocking, state reasonable defaults and invite correction.
+Only ask one blocking question first if the answer is required before any useful starter plan can be proposed.
+Do not imply you have already created agents or channels unless the action has actually happened.
+
+### Capability Boundary Pivot
+If the user's primary request is outside current capabilities, acknowledge the limitation once and pivot immediately to the nearest useful alternative.
+Do not repeat that something is impossible across multiple turns.
+Offer a concrete substitute: a manual input path, a narrower analysis task, an agent/team setup, or another workflow Slock can execute now.
+
+### Active-Elsewhere Handoff
+Channel silence is not failure.
+If the user is already active outside the onboarding channel, follow the work instead of trying to pull them back.
+Offer a concrete next step in the context they are using: first task, second agent suggestion, channel structure, or reminder.
+
 ## Step 4: Progress Setup (Soft Guidance)
 While helping with real work, progressively shape:
 - initial team target >= 3 agents
@@ -2762,6 +3365,8 @@ Do not force setup before value.
 
 ## Step 5: End Every Turn with One Next Step
 Each reply should end with one clear, immediate action.
+At wrap-up, if there is a concrete next check-in, ask consent to set one contextual reminder.
+The reminder must reference the user's goal, agent, recent step, or suggested next action; do not send generic "come back later" reminders.
 
 ## Inspiration Stories (Interview-Grounded)
 - Story 1: "Sense of abundance" \u2014 agents self-organize, you do not need to micro-manage.
@@ -2954,6 +3559,34 @@ Do not copy these answers verbatim.
 
 ### Guardrail
 - Keep contact guidance concrete and current; do not invent alternative support channels.
+
+## FAQ 14: Can I use Slock on my phone?
+### Answer idea
+- Yes. Slock can be used from a mobile browser.
+- For easier return access, users can add Slock to their phone home screen as a web app:
+  - iPhone: Safari \u2192 Share \u2192 Add to Home Screen
+  - Android: Chrome \u2192 menu \u2192 Add to Home Screen / Install app
+- Good mobile use cases: quick check-ins, todos/reminders, short replies, and reviewing agent updates.
+
+### Next step
+- If the user wants mobile access now, ask whether they use iPhone or Android, then guide the matching Add to Home Screen step.
+
+### Guardrail
+- Do not imply Slock has a native iOS/Android App Store app.
+- Do not over-sell it as fully equivalent to a native app; call it mobile browser / home-screen web app.
+
+## FAQ 15: How do I create agents or channels?
+### Answer idea
+- The user can create agents from the Agents section in the People tab by clicking the + button, or from a computer/machine context menu via Create Agent.
+- The user can create channels from the Channels section by clicking the + button.
+- When recommending setup, provide copyable agent names/descriptions, suggested channel names, and the first task to send after creation.
+
+### Next step
+- Give the exact agent/channel spec the user can copy, then guide them to the relevant + button or creation dialog.
+
+### Guardrail
+- Do not imply you already created agents or channels unless that action actually happened.
+- If you cannot directly create something, avoid a long permissions explanation; give the copyable spec and the next UI action.
 `;
 }
 function buildOnboardingSeedFiles() {
@@ -3112,9 +3745,20 @@ function classifyTerminalFailure(ap) {
   return null;
 }
 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 || "");
+  const candidates = [
+    ap.lastRuntimeError,
+    ...ap.recentStderr
+  ].filter((value) => !!value);
+  if (ap.driver.id === "claude") {
+    return candidates.some((text) => /No conversation found with session ID/i.test(text));
+  }
+  if (ap.driver.id === "opencode") {
+    return candidates.some(
+      (text) => /Session not found/i.test(text) && text.includes(ap.sessionId)
+    );
+  }
+  return false;
 }
 function getMessageDeliveryText(driver) {
   return driver.supportsStdinNotification ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
@@ -3129,7 +3773,12 @@ 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 NATIVE_STANDING_PROMPT_STARTUP_INPUT = (
+  // Claude Code 2.1.114 treats "follow your system prompt" style user turns as
+  // prompt-injection bait even when the prompt is supplied via --system-prompt-file.
+  // A neutral starter lets the native standing prompt drive startup/migration.
+  "Start."
+);
 var AgentProcessManager = class _AgentProcessManager {
   agents = /* @__PURE__ */ new Map();
   agentsStarting = /* @__PURE__ */ new Set();
@@ -3143,6 +3792,7 @@ var AgentProcessManager = class _AgentProcessManager {
   daemonApiKey;
   serverUrl;
   dataDir;
+  runtimeSessionHomeDir;
   driverResolver;
   defaultAgentEnvVarsProvider;
   tracer;
@@ -3153,6 +3803,7 @@ var AgentProcessManager = class _AgentProcessManager {
     this.daemonApiKey = daemonApiKey;
     this.serverUrl = opts.serverUrl;
     this.dataDir = opts.dataDir || DATA_DIR;
+    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os4.homedir();
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
     this.tracer = opts.tracer ?? noopTracer;
@@ -3169,41 +3820,45 @@ var AgentProcessManager = class _AgentProcessManager {
     this.agentsStarting.add(agentId);
     try {
       const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path10.join(this.dataDir, agentId);
+      const agentDataDir = path11.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
-      const memoryMdPath = path10.join(agentDataDir, "MEMORY.md");
+      const runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
+      const memoryMdPath = path11.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
-        const initialMemoryMd = buildInitialMemoryMd(config);
+        const initialMemoryMd = buildInitialMemoryMd(runtimeConfig);
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      const notesDir = path10.join(agentDataDir, "notes");
+      const notesDir = path11.join(agentDataDir, "notes");
       await mkdir(notesDir, { recursive: true });
       if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
         const seedFiles = buildOnboardingSeedFiles();
         for (const { relativePath, content } of seedFiles) {
-          const fullPath = path10.join(agentDataDir, relativePath);
+          const fullPath = path11.join(agentDataDir, relativePath);
           try {
             await access(fullPath);
           } catch {
-            await mkdir(path10.dirname(fullPath), { recursive: true });
+            await mkdir(path11.dirname(fullPath), { recursive: true });
             await writeFile(fullPath, content);
           }
         }
       }
-      const isResume = !!config.sessionId;
-      const standingPrompt = driver.buildSystemPrompt(config, agentId);
+      const isResume = !!runtimeConfig.sessionId;
+      const standingPrompt = driver.buildSystemPrompt(runtimeConfig, agentId);
       let prompt;
-      if (isResume && resumePrompt) {
+      if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
+        prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
+      } else if (isResume && resumePrompt) {
         prompt = resumePrompt;
         prompt += getBusyDeliveryNote(driver);
       } else if (wakeMessage) {
+        const runtimeProfileControlPrompt = formatRuntimeProfileControlPrompt([wakeMessage]);
         const channelLabel = formatChannelLabel(wakeMessage);
-        prompt = `New message received:
+        prompt = runtimeProfileControlPrompt ?? `New message received:
 
-${formatIncomingMessage(wakeMessage)}`;
-        if (unreadSummary && Object.keys(unreadSummary).length > 0) {
+${formatIncomingMessage(wakeMessage, driver)}`;
+        if (!runtimeProfileControlPrompt && unreadSummary && Object.keys(unreadSummary).length > 0) {
           const otherUnread = Object.entries(unreadSummary).filter(([key]) => key !== channelLabel);
           if (otherUnread.length > 0) {
             prompt += `
@@ -3215,15 +3870,17 @@ You also have unread messages in other channels:`;
             }
             prompt += `
 
-Use read_history to catch up, or respond to the message above first.`;
+Use ${communicationCommand(driver, "read_history")} to catch up, or respond to the message above first.`;
           }
         }
-        prompt += `
+        if (!runtimeProfileControlPrompt) {
+          prompt += `
 
-Respond as appropriate \u2014 reply using send_message, or take action as needed. Complete ALL your work before stopping.
+Respond as appropriate \u2014 ${dynamicReplyInstruction(driver)}, 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)}`;
-        prompt += getBusyDeliveryNote(driver);
+          prompt += getBusyDeliveryNote(driver);
+        }
       } 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)) {
@@ -3232,14 +3889,32 @@ IMPORTANT: If the message requires multi-step work (e.g. research, code changes,
         }
         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)}`;
+Use ${communicationCommand(driver, "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 ${communicationCommand(driver, "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: ${dynamicReplyInstruction(driver)} and ${dynamicClaimInstruction(driver)} before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver)}`;
       } else if (isResume) {
         prompt = `No new messages while you were away. Nothing to do \u2014 just stop. ${getMessageDeliveryText(driver)}`;
         prompt += getBusyDeliveryNote(driver);
       } else {
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : standingPrompt;
       }
-      const effectiveConfig = await this.buildSpawnConfig(agentId, config);
+      const effectiveConfig = await this.buildSpawnConfig(agentId, runtimeConfig);
+      const canDeferEmptyStart = driver.deferSpawnUntilMessage === true && !wakeMessage && !runtimeConfig.runtimeProfileControl && (!unreadSummary || Object.keys(unreadSummary).length === 0);
+      if (canDeferEmptyStart) {
+        const pendingMessages = this.startingInboxes.get(agentId) || [];
+        this.startingInboxes.delete(agentId);
+        this.agentsStarting.delete(agentId);
+        this.idleAgentConfigs.set(agentId, {
+          config: effectiveConfig,
+          sessionId: effectiveConfig.sessionId || null,
+          launchId: launchId || null
+        });
+        this.sendAgentStatus(agentId, "active", launchId || null);
+        this.broadcastActivity(agentId, "online", "Process idle");
+        logger.info(`[Agent ${agentId}] Deferred ${driver.id} spawn until first concrete message`);
+        for (const message of pendingMessages) {
+          this.deliverMessage(agentId, message);
+        }
+        return;
+      }
       const { process: proc } = driver.spawn({
         agentId,
         config: effectiveConfig,
@@ -3255,9 +3930,12 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         process: proc,
         driver,
         inbox: this.startingInboxes.get(agentId) || [],
-        config,
-        sessionId: config.sessionId || null,
+        config: runtimeConfig,
+        sessionId: runtimeConfig.sessionId || null,
         launchId: launchId || null,
+        startupWakeMessage: wakeMessage,
+        startupUnreadSummary: unreadSummary,
+        startupResumePrompt: resumePrompt,
         isIdle: false,
         notificationTimer: null,
         pendingNotificationCount: 0,
@@ -3275,6 +3953,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         spawnError: null,
         exitCode: null,
         exitSignal: null,
+        expectedTerminationReason: null,
         pendingTrajectory: null,
         gatedSteering: createGatedSteeringState()
       };
@@ -3282,6 +3961,9 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       this.agents.set(agentId, agentProcess);
       this.startRuntimeTrace(agentId, agentProcess, "spawn");
       this.agentsStarting.delete(agentId);
+      if (config.runtimeProfileControl) {
+        this.ackInjectedRuntimeProfileControl(agentId, config.runtimeProfileControl, agentProcess.launchId);
+      }
       if (wakeMessage) {
         this.ackInjectedRuntimeProfileMessages(agentId, [wakeMessage], agentProcess.launchId);
       }
@@ -3341,20 +4023,60 @@ Use read_history to catch up on the channels listed above, then stop. Read each
           }
           const finalCode = ap.exitCode ?? code;
           const finalSignal = ap.exitSignal ?? signal;
-          const terminalFailureDetail = classifyTerminalFailure(ap);
-          this.endRuntimeTrace(ap, finalCode === 0 ? "ok" : "error", {
-            outcome: finalCode === 0 ? "process-exit" : "process-crash",
+          const expectedTermination = Boolean(ap.expectedTerminationReason);
+          const processEndedCleanly = finalCode === 0 || expectedTermination && !ap.lastRuntimeError;
+          const terminalFailureDetail = processEndedCleanly ? null : classifyTerminalFailure(ap);
+          const missingResumeSession = isMissingResumeSession(ap);
+          const summary = summarizeCrash(finalCode, finalSignal);
+          this.endRuntimeTrace(ap, processEndedCleanly ? "ok" : "error", {
+            outcome: processEndedCleanly ? "process-exit" : "process-crash",
+            expectedTerminationReason: ap.expectedTerminationReason || void 0,
             exitCode: finalCode,
             exitSignal: finalSignal
           });
-          if (finalCode === 0) {
+          if (processEndedCleanly) {
             this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from process exit)");
           } else {
             this.clearCompactionWatchdog(ap);
           }
           this.agents.delete(agentId);
-          if (finalCode === 0) {
-            const queuedWakeMessage = !ap.driver.supportsStdinNotification ? ap.inbox.shift() : void 0;
+          if (missingResumeSession) {
+            const staleSessionId = ap.sessionId;
+            const runtimeLabel = ap.driver.id === "opencode" ? "OpenCode" : "Claude";
+            const restartConfig = { ...ap.config, sessionId: null };
+            logger.warn(
+              `[Agent ${agentId}] Stored ${runtimeLabel} session ${staleSessionId} is unavailable locally; falling back to cold start`
+            );
+            this.broadcastActivity(
+              agentId,
+              "working",
+              `Stored ${runtimeLabel} session missing; cold-starting a new session\u2026`,
+              [{ kind: "text", text: `Stored ${runtimeLabel} session ${staleSessionId} was not found locally. Falling back to a cold start.` }]
+            );
+            this.startAgent(
+              agentId,
+              restartConfig,
+              ap.startupWakeMessage,
+              ap.startupUnreadSummary,
+              ap.startupResumePrompt,
+              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})`, [], ap.launchId);
+            });
+            return;
+          }
+          if (processEndedCleanly) {
+            let queuedWakeMessage;
+            if (!ap.driver.supportsStdinNotification) {
+              while (ap.inbox.length > 0) {
+                const candidate = ap.inbox.shift();
+                if (this.shouldDeferWakeMessage(agentId, ap.driver, candidate)) continue;
+                queuedWakeMessage = candidate;
+                break;
+              }
+            }
             const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
             if (queuedWakeMessage) {
               logger.info(`[Agent ${agentId}] Turn completed; restarting immediately for queued message`);
@@ -3389,26 +4111,6 @@ Use read_history to catch up on the channels listed above, then stop. Read each
           } 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})`, [], ap.launchId);
-              });
-              return;
-            }
             logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
             this.sendAgentStatus(agentId, "inactive", ap.launchId);
             if (terminalFailureDetail) {
@@ -3492,6 +4194,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     this.agents.delete(agentId);
     ap.process.kill("SIGTERM");
     if (!silent) {
+      this.sendRuntimeProfileReportFor(agentId, ap.config, ap.sessionId, ap.launchId);
       this.sendAgentStatus(agentId, "inactive", ap.launchId);
       this.broadcastActivity(agentId, "offline", "Stopped");
       logger.info(`[Agent ${agentId}] Stopped by request`);
@@ -3530,6 +4233,10 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       }
       const cached = this.idleAgentConfigs.get(agentId);
       if (cached) {
+        const driver = this.driverResolver(cached.config.runtime || "claude");
+        if (this.shouldDeferWakeMessage(agentId, driver, message)) {
+          return;
+        }
         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) => {
@@ -3538,6 +4245,9 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       }
       return;
     }
+    if (this.shouldDeferWakeMessage(agentId, ap.driver, message)) {
+      return;
+    }
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       const nextMessages = ap.inbox.splice(0, ap.inbox.length);
       nextMessages.push(message);
@@ -3566,7 +4276,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path10.join(this.dataDir, agentId);
+    const agentDataDir = path11.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -3582,6 +4292,11 @@ Use read_history to catch up on the channels listed above, then stop. Read each
   getRunningAgentIds() {
     return [...this.agents.keys()];
   }
+  shouldDeferWakeMessage(agentId, driver, message) {
+    if (!driver.shouldDeferWakeMessage?.(message)) return false;
+    logger.info(`[Agent ${agentId}] Deferred non-concrete wake message for ${driver.id}`);
+    return true;
+  }
   getAgentSessionId(agentId) {
     return this.agents.get(agentId)?.sessionId ?? null;
   }
@@ -3596,7 +4311,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     return result;
   }
   buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
-    const workspacePath = path10.join(this.dataDir, agentId);
+    const workspacePath = path11.join(this.dataDir, agentId);
     return {
       agentId,
       launchId,
@@ -3610,12 +4325,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
           path: workspacePath,
           reachable: true
         },
-        sessionRef: sessionId ? {
-          label: sessionId,
-          path: sessionId,
-          runtime: config.runtime,
-          reachable: true
-        } : null
+        sessionRef: sessionId ? resolveRuntimeSessionRef(config.runtime, sessionId, this.runtimeSessionHomeDir, workspacePath) : null
       }
     };
   }
@@ -3706,9 +4416,26 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       }
     }
   }
-  sendRuntimeProfileReport(agentId) {
-    const report = this.getAgentRuntimeProfileReport(agentId);
-    if (!report) return;
+  ackInjectedRuntimeProfileControl(agentId, control, launchId) {
+    const title = runtimeProfileNotificationTitle(control.kind);
+    this.broadcastActivity(agentId, "working", title, [{ kind: "system", title, text: control.message }], launchId);
+    if (control.kind === "migration") {
+      this.sendToServer({
+        type: "agent:runtime_profile:migration:ack",
+        agentId,
+        migrationKey: control.key,
+        launchId: launchId || void 0
+      });
+    } else {
+      this.sendToServer({
+        type: "agent:runtime_profile:daemon_release_notice:ack",
+        agentId,
+        noticeKey: control.key,
+        launchId: launchId || void 0
+      });
+    }
+  }
+  sendRuntimeProfileWireReport(report) {
     this.sendToServer({
       type: "agent:runtime_profile",
       agentId: report.agentId,
@@ -3716,6 +4443,14 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       launchId: report.launchId || void 0
     });
   }
+  sendRuntimeProfileReportFor(agentId, config, sessionId, launchId) {
+    this.sendRuntimeProfileWireReport(this.buildRuntimeProfileReport(agentId, config, sessionId, launchId));
+  }
+  sendRuntimeProfileReport(agentId) {
+    const report = this.getAgentRuntimeProfileReport(agentId);
+    if (!report) return;
+    this.sendRuntimeProfileWireReport(report);
+  }
   // Machine-level workspace scanning
   async scanAllWorkspaces() {
     return scanWorkspaceDirectories(this.dataDir);
@@ -3725,7 +4460,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 = path10.join(this.dataDir, agentId);
+    const agentDir = path11.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -3733,8 +4468,8 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path10.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path10.sep) && resolved !== agentDir) {
+      const resolved = path11.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path11.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -3742,9 +4477,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 = path10.join(this.dataDir, agentId);
-    const resolved = path10.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path10.sep) && resolved !== agentDir) {
+    const agentDir = path11.join(this.dataDir, agentId);
+    const resolved = path11.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path11.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat2(resolved);
@@ -3768,7 +4503,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       ".sh",
       ".py"
     ]);
-    const ext = path10.extname(resolved).toLowerCase();
+    const ext = path11.extname(resolved).toLowerCase();
     if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
       return { content: null, binary: true };
     }
@@ -3794,14 +4529,14 @@ Use read_history to catch up on the channels listed above, then stop. Read each
   async listSkills(agentId, runtimeHint) {
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
-    const home = os3.homedir();
-    const workspaceDir = path10.join(this.dataDir, agentId);
+    const home = os4.homedir();
+    const workspaceDir = path11.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(path10.join(home, p)))
+      paths.global.map((p) => this.scanSkillsDir(path11.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path10.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path11.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -3830,7 +4565,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 = path10.join(dir, entry.name, "SKILL.md");
+        const skillMd = path11.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -3841,7 +4576,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(path10.join(dir, entry.name), "utf-8");
+          const content = await readFile(path11.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -4056,7 +4791,9 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     logger.info(
       `[Agent ${agentId}] Claude gated steering flush reason=${reason} messages=${nextMessages.length}`
     );
-    this.broadcastActivity(agentId, "working", "Message received");
+    if (reason === "turn_end") {
+      this.broadcastActivity(agentId, "working", "Message received");
+    }
     if (this.deliverMessagesViaStdin(agentId, ap, nextMessages, reason === "turn_end" ? "idle" : "busy")) {
       return true;
     }
@@ -4233,6 +4970,16 @@ Use read_history to catch up on the channels listed above, then stop. Read each
             this.broadcastActivity(agentId, "online", "Idle");
           }
           this.endRuntimeTrace(ap, "ok", { outcome: "turn-completed" });
+          if (ap.driver.terminateProcessOnTurnEnd) {
+            ap.expectedTerminationReason = "turn_end";
+            logger.info(`[Agent ${agentId}] Turn completed; terminating ${ap.driver.id} process`);
+            try {
+              ap.process.kill("SIGTERM");
+            } catch (err) {
+              const reason = err instanceof Error ? err.message : String(err);
+              logger.warn(`[Agent ${agentId}] Failed to terminate ${ap.driver.id} after turn_end: ${reason}`);
+            }
+          }
         }
         if (event.sessionId) {
           this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId, launchId: ap?.launchId || void 0 });
@@ -4294,7 +5041,6 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     if (ap.driver.busyDeliveryMode === "direct" && 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");
       if (this.deliverMessagesViaStdin(agentId, ap, queuedMessages, "busy")) {
         return;
       }
@@ -4311,15 +5057,15 @@ Use read_history to catch up on the channels listed above, then stop. Read each
   /** 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 true;
-    const prompt = messages.length === 1 ? `New message received:
+    const prompt = formatRuntimeProfileControlPrompt(messages) ?? (messages.length === 1 ? `New message received:
 
-${formatIncomingMessage(messages[0])}
+${formatIncomingMessage(messages[0], ap.driver)}
 
 Respond as appropriate. Complete all your work before stopping.` : `New messages received:
 
-${messages.map((message) => formatIncomingMessage(message)).join("\n")}
+${messages.map((message) => formatIncomingMessage(message, ap.driver)).join("\n")}
 
-Respond as appropriate. Complete all your work before stopping.`;
+Respond as appropriate. Complete all your work before stopping.`);
     const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
     if (!encoded) {
       ap.inbox.unshift(...messages);
@@ -4355,8 +5101,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 = path10.join(dir, entry.name);
-      const relativePath = path10.relative(rootDir, fullPath);
+      const fullPath = path11.join(dir, entry.name);
+      const relativePath = path11.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -4587,10 +5333,10 @@ var ReminderCache = class {
 
 // src/machineLock.ts
 import { createHash, randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync, statSync, writeFileSync as writeFileSync7 } from "fs";
-import os4 from "os";
-import path11 from "path";
-var DEFAULT_MACHINE_STATE_ROOT = path11.join(os4.homedir(), ".slock", "machines");
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
+import os5 from "os";
+import path12 from "path";
+var DEFAULT_MACHINE_STATE_ROOT = path12.join(os5.homedir(), ".slock", "machines");
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -4609,18 +5355,18 @@ function getDaemonMachineLockId(apiKey) {
   return `machine-${apiKeyFingerprint(apiKey).slice(0, 16)}`;
 }
 function ownerPath(lockDir) {
-  return path11.join(lockDir, "owner.json");
+  return path12.join(lockDir, "owner.json");
 }
 function readOwner(lockDir) {
   try {
-    return JSON.parse(readFileSync3(ownerPath(lockDir), "utf8"));
+    return JSON.parse(readFileSync4(ownerPath(lockDir), "utf8"));
   } catch {
     return null;
   }
 }
 function lockAgeMs(lockDir) {
   try {
-    return Date.now() - statSync(lockDir).mtimeMs;
+    return Date.now() - statSync2(lockDir).mtimeMs;
   } catch {
     return null;
   }
@@ -4639,26 +5385,26 @@ function acquireDaemonMachineLock(options) {
   const rootDir = options.rootDir ?? DEFAULT_MACHINE_STATE_ROOT;
   const fingerprint = apiKeyFingerprint(options.apiKey);
   const lockId = getDaemonMachineLockId(options.apiKey);
-  const machineDir = path11.join(rootDir, lockId);
-  const lockDir = path11.join(machineDir, "daemon.lock");
+  const machineDir = path12.join(rootDir, lockId);
+  const lockDir = path12.join(machineDir, "daemon.lock");
   const token = randomUUID2();
-  mkdirSync4(machineDir, { recursive: true });
+  mkdirSync5(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      mkdirSync4(lockDir);
+      mkdirSync5(lockDir);
       const owner = {
         pid: process.pid,
         token,
-        hostname: os4.hostname(),
+        hostname: os5.hostname(),
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         serverUrl: options.serverUrl,
         apiKeyFingerprint: fingerprint.slice(0, 16)
       };
       try {
-        writeFileSync7(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
+        writeFileSync8(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
 `, { mode: 384 });
       } catch (err) {
-        rmSync(lockDir, { recursive: true, force: true });
+        rmSync2(lockDir, { recursive: true, force: true });
         throw err;
       }
       return {
@@ -4668,7 +5414,7 @@ function acquireDaemonMachineLock(options) {
         release: () => {
           const currentOwner = readOwner(lockDir);
           if (currentOwner?.pid === process.pid && currentOwner.token === token) {
-            rmSync(lockDir, { recursive: true, force: true });
+            rmSync2(lockDir, { recursive: true, force: true });
           }
         }
       };
@@ -4685,7 +5431,7 @@ function acquireDaemonMachineLock(options) {
           throw new DaemonMachineLockConflictError(lockDir, null);
         }
       }
-      rmSync(lockDir, { recursive: true, force: true });
+      rmSync2(lockDir, { recursive: true, force: true });
     }
   }
   throw new DaemonMachineLockConflictError(lockDir, readOwner(lockDir));
@@ -4712,23 +5458,23 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path12.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path12.resolve(dirname, "chat-bridge.js");
+  const dirname = path13.dirname(fileURLToPath(moduleUrl));
+  const jsPath = path13.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path12.resolve(dirname, "chat-bridge.ts");
+    return path13.resolve(dirname, "chat-bridge.ts");
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path12.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path12.resolve(thisDir, "cli", "index.js");
+  const thisDir = path13.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path13.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path12.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path13.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -4737,9 +5483,14 @@ function detectRuntimes() {
   const ids = [];
   const versions = {};
   for (const runtime of RUNTIMES) {
+    const driver = getDriver(runtime.id);
     try {
-      const probe = getDriver(runtime.id).probe?.();
-      if (probe?.available) {
+      if (driver.probe) {
+        const probe = driver.probe();
+        if (!probe.available) {
+          if (probe.version) versions[runtime.id] = probe.version;
+          continue;
+        }
         ids.push(runtime.id);
         if (probe.version) versions[runtime.id] = probe.version;
         continue;
@@ -4840,7 +5591,7 @@ var DaemonCore = class {
   }
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
-    if (this.options.dataDir) return path12.join(path12.dirname(this.options.dataDir), "machines");
+    if (this.options.dataDir) return path13.join(path13.dirname(this.options.dataDir), "machines");
     return DEFAULT_MACHINE_STATE_ROOT;
   }
   start() {
@@ -5031,8 +5782,8 @@ var DaemonCore = class {
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
       runtimes,
       runningAgents: this.agentManager.getRunningAgentIds(),
-      hostname: this.options.hostname ?? os5.hostname(),
-      os: this.options.osDescription ?? `${os5.platform()} ${os5.arch()}`,
+      hostname: this.options.hostname ?? os6.hostname(),
+      os: this.options.osDescription ?? `${os6.platform()} ${os6.arch()}`,
       daemonVersion: this.daemonVersion
     });
     for (const agentId of this.agentManager.getRunningAgentIds()) {