@slock-ai/daemon 0.46.2 → 0.47.0-staging.20260511155804

package/dist/{chunk-FG5JGA67.js → chunk-WTTEYI5T.js}

@@ -1,10 +1,14 @@
 import {
   DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
+  SLOCK_HOME_ENV,
   buildWebSocketOptions,
   executeJsonRequest,
   executeResponseRequest,
-  logger
-} from "./chunk-Z3PCMYZO.js";
+  listLegacySlockStatePaths,
+  logger,
+  resolveSlockHome,
+  resolveSlockHomePath
+} from "./chunk-B7XIMLOT.js";
 
 // src/core.ts
 import path15 from "path";
@@ -576,6 +580,66 @@ function summarizeToolInput(toolName, input) {
 // ../shared/src/attachmentPreview.ts
 var CSV_PREVIEW_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 
+// ../shared/src/actionCards.ts
+import { z } from "zod";
+var uuidSchema = z.uuid();
+var idOrHandleSchema = z.string().min(1).max(120);
+var draftHintSchema = z.string().trim().max(2e3).optional().describe(
+  "Why the agent prepared this for you. Shows below the form on the card; not the action itself."
+);
+var channelCreateOperationSchema = z.object({
+  type: z.literal("channel:create"),
+  name: z.string().trim().min(1).max(80),
+  visibility: z.enum(["public", "private"]).default("public"),
+  description: z.string().trim().max(500).optional(),
+  /**
+   * Humans to add to the channel on creation. Each entry is a handle
+   * (`@alice` or bare `alice`) or a UUID. Server resolves via
+   * `resolveUserByName` at prepare time; resolved UUIDs are stored.
+   */
+  initialHumans: z.array(idOrHandleSchema).max(64).optional(),
+  /**
+   * Agents to add to the channel on creation. Each entry is a handle
+   * (`@scout` or bare `scout`) or a UUID. Server resolves via
+   * `resolveAgentByName` at prepare time; resolved UUIDs are stored.
+   */
+  initialAgents: z.array(idOrHandleSchema).max(64).optional(),
+  draftHint: draftHintSchema
+});
+var agentCreateOperationSchema = z.object({
+  type: z.literal("agent:create"),
+  name: z.string().trim().min(1).max(60),
+  description: z.string().trim().max(500).optional(),
+  /**
+   * Agent can only suggest semantic intent (name + description). Technical
+   * configuration (which computer / runtime / model / reasoning effort) is
+   * a user prerogative — the human picks those in the create dialog when
+   * they click "Create Agent" on the card. Per stdrc 2026-05-10
+   * #proj-approval msg=ae4ecedd: "为什么 computer、runtime 和 model 还是
+   * 帮用户选了？" — don't let the agent prefill those.
+   */
+  draftHint: draftHintSchema
+});
+var channelAddMemberOperationSchema = z.object({
+  type: z.literal("channel:add_member"),
+  /**
+   * Target channel. Handle (`#general` or bare `general`) or UUID.
+   * Server resolves via `resolveChannelByName` at prepare time; the
+   * resolved UUID is stored in the card metadata.
+   */
+  channel: idOrHandleSchema,
+  /** Same resolution rule as `channelCreateOperationSchema.initialHumans`. */
+  humans: z.array(idOrHandleSchema).max(64).optional(),
+  /** Same resolution rule as `channelCreateOperationSchema.initialAgents`. */
+  agents: z.array(idOrHandleSchema).max(64).optional(),
+  draftHint: draftHintSchema
+});
+var actionCardActionSchema = z.discriminatedUnion("type", [
+  channelCreateOperationSchema,
+  agentCreateOperationSchema,
+  channelAddMemberOperationSchema
+]);
+
 // ../shared/src/testing/failpoints.ts
 var NoopFailpointRegistry = class {
   get enabled() {
@@ -686,8 +750,9 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync4, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync4, readdirSync as readdirSync3, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
 import path11 from "path";
 import os5 from "os";
 
@@ -796,6 +861,7 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 21. **\`slock reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
 22. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
 23. **\`slock reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
+24. **\`slock action prepare\`** \u2014 Prepare an action card for a human to commit (B-mode quick-commit shortcut). Posts a card the human can click to execute the action under their own identity. Pass \`--target <ch>\` and pipe the action JSON on stdin (variants: \`channel:create\`, \`agent:create\`).
 
 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
@@ -1272,6 +1338,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(ctx.slockCliPath)}
     ...ctx.config.envVars || {},
     ...extraEnv,
     ...runtimeContextEnv(ctx.config),
+    [SLOCK_HOME_ENV]: resolveSlockHome(),
     SLOCK_AGENT_ID: ctx.agentId,
     ...ctx.launchId ? { SLOCK_AGENT_LAUNCH_ID: ctx.launchId } : {},
     SLOCK_SERVER_URL: ctx.config.serverUrl,
@@ -1705,7 +1772,7 @@ var ClaudeDriver = class {
 
 // src/drivers/codex.ts
 import { spawn as spawn2, execSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
 import os2 from "os";
 import path4 from "path";
 function getCodexNotificationErrorMessage(params) {
@@ -1734,11 +1801,29 @@ function ensureGitRepoForCodex(workingDirectory, deps = {}) {
   );
 }
 var CODEX_DESKTOP_BUNDLE_PATH = "/Applications/Codex.app/Contents/Resources/codex";
+function resolveWindowsSandboxRunner(deps = {}) {
+  const homeDir = deps.homeDir ?? os2.homedir();
+  const sandboxBinDir = path4.join(homeDir, ".codex", ".sandbox-bin");
+  if (!(deps.existsSyncFn ?? existsSync3)(sandboxBinDir)) return null;
+  try {
+    const files = readdirSync2(sandboxBinDir);
+    const runners = files.filter((f) => f.startsWith("codex-command-runner") && f.endsWith(".exe")).sort((a, b) => b.localeCompare(a));
+    if (runners.length > 0) return path4.join(sandboxBinDir, runners[0]);
+  } catch {
+  }
+  return null;
+}
 function resolveCodexCommand(deps = {}) {
   const pathCommand = resolveCommandOnPath("codex", deps);
   if (pathCommand) return pathCommand;
-  if ((deps.platform ?? process.platform) !== "darwin") return null;
-  return firstExistingPath([CODEX_DESKTOP_BUNDLE_PATH], deps);
+  const platform = deps.platform ?? process.platform;
+  if (platform === "darwin") {
+    return firstExistingPath([CODEX_DESKTOP_BUNDLE_PATH], deps);
+  }
+  if (platform === "win32") {
+    return resolveWindowsSandboxRunner(deps);
+  }
+  return null;
 }
 function probeCodex(deps = {}) {
   if ((deps.platform ?? process.platform) === "win32") {
@@ -1779,6 +1864,13 @@ function resolveCodexSpawn(commandArgs, deps = {}) {
     }
   }
   if (!codexEntry) {
+    const sandboxRunner = resolveWindowsSandboxRunner(deps);
+    if (sandboxRunner) {
+      return {
+        command: sandboxRunner,
+        args: commandArgs
+      };
+    }
     throw new Error(
       "Cannot resolve Codex CLI entry point on Windows. Ensure @openai/codex is installed globally via npm (npm i -g @openai/codex)."
     );
@@ -2228,6 +2320,15 @@ function detectCodexModels(home = os2.homedir()) {
 import { spawn as spawn3 } from "child_process";
 import path5 from "path";
 import { writeFileSync as writeFileSync3 } from "fs";
+function buildCopilotSpawnEnv(ctx) {
+  return {
+    ...process.env,
+    FORCE_COLOR: "0",
+    NO_COLOR: "1",
+    ...ctx.config.envVars || {},
+    [SLOCK_HOME_ENV]: resolveSlockHome()
+  };
+}
 var CopilotDriver = class {
   id = "copilot";
   lifecycle = {
@@ -2286,7 +2387,7 @@ var CopilotDriver = 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 = buildCopilotSpawnEnv(ctx);
     const proc = spawn3("copilot", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
@@ -2383,6 +2484,15 @@ var CopilotDriver = class {
 import { spawn as spawn4, spawnSync } from "child_process";
 import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
 import path6 from "path";
+function buildCursorSpawnEnv(ctx) {
+  return {
+    ...process.env,
+    FORCE_COLOR: "0",
+    NO_COLOR: "1",
+    ...ctx.config.envVars || {},
+    [SLOCK_HOME_ENV]: resolveSlockHome()
+  };
+}
 var CursorDriver = class {
   id = "cursor";
   lifecycle = {
@@ -2437,7 +2547,7 @@ var CursorDriver = class {
       args.push("--resume", ctx.config.sessionId);
     }
     args.push(ctx.prompt);
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", ...ctx.config.envVars || {} };
+    const spawnEnv = buildCursorSpawnEnv(ctx);
     const proc = spawn4("cursor-agent", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
@@ -3527,8 +3637,86 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
   }
 }
 
+// src/runtimeErrorDiagnostics.ts
+import { createHash } from "crypto";
+var MAX_RUNTIME_ERROR_MESSAGE_EXCERPT_CHARS = 4096;
+function buildRuntimeErrorDiagnosticEnvelope(message) {
+  const rawMessage = String(message || "");
+  const scrubbed = scrubRuntimeErrorDiagnosticText(rawMessage);
+  const { value: excerpt, truncated } = truncateDiagnosticText(scrubbed, MAX_RUNTIME_ERROR_MESSAGE_EXCERPT_CHARS);
+  const httpStatus = extractHttpStatus(rawMessage);
+  const runtimeErrorClass = classifyRuntimeError(rawMessage, httpStatus);
+  const fingerprint = fingerprintRuntimeError(scrubbed);
+  const spanAttrs = {
+    runtime_error_class: runtimeErrorClass,
+    runtime_error_fingerprint: fingerprint,
+    runtime_error_message_present: rawMessage.length > 0,
+    runtime_error_message_length_bucket: bucketLength(rawMessage.length),
+    runtime_error_message_truncated: truncated
+  };
+  if (httpStatus !== null) {
+    spanAttrs.runtime_error_http_status = httpStatus;
+  }
+  return {
+    spanAttrs,
+    eventAttrs: {
+      ...spanAttrs,
+      runtime_error_message_excerpt: excerpt
+    }
+  };
+}
+function scrubRuntimeErrorDiagnosticText(value) {
+  return value.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer [REDACTED_TOKEN]").replace(/\b(?:sk|sk-ant|sk-proj|xox[baprs]?)-[A-Za-z0-9_-]{8,}\b/g, "[REDACTED_TOKEN]").replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, "[REDACTED_EMAIL]").replace(/https?:\/\/[^\s"'<>]+/gi, (url) => redactUrlQuery(url)).replace(/\/Users\/[^\s"'<>:]+(?:\/[^\s"'<>:]+)*/g, "[REDACTED_PATH]").replace(/\/home\/[^\s"'<>:]+(?:\/[^\s"'<>:]+)*/g, "[REDACTED_PATH]").replace(/[A-Za-z]:\\Users\\[^\s"'<>:]+(?:\\[^\s"'<>:]+)*/g, "[REDACTED_PATH]");
+}
+function truncateDiagnosticText(value, maxChars) {
+  if (value.length <= maxChars) return { value, truncated: false };
+  return { value: value.slice(0, maxChars), truncated: true };
+}
+function extractHttpStatus(message) {
+  const match = /\b(?:HTTP|status(?:\s+code)?|API\s+Error)[:\s]+([45]\d{2})\b/i.exec(message) ?? /\b([45]\d{2})\s+(?:Bad Request|Unauthorized|Forbidden|Not Found|Conflict|Too Many Requests|Internal Server Error|Service Unavailable)\b/i.exec(message);
+  if (!match) return null;
+  const status = Number(match[1]);
+  return Number.isInteger(status) ? status : null;
+}
+function classifyRuntimeError(message, httpStatus) {
+  const explicit = /\b([A-Z][A-Za-z0-9_]*(?:Error|Exception))\b/.exec(message);
+  if (explicit) return explicit[1];
+  if (httpStatus !== null) {
+    if (httpStatus === 429) return "RateLimitError";
+    if (httpStatus === 401 || httpStatus === 403) return "AuthError";
+    if (httpStatus === 404) return "NotFoundError";
+    if (httpStatus >= 500) return "ProviderServerError";
+    return "ProviderApiError";
+  }
+  if (/\btimeout|timed out\b/i.test(message)) return "TimeoutError";
+  if (/\brate.?limit|too many requests\b/i.test(message)) return "RateLimitError";
+  if (/\bnot found\b/i.test(message)) return "NotFoundError";
+  return "RuntimeError";
+}
+function fingerprintRuntimeError(value) {
+  const normalized = value.toLowerCase().replace(/[0-9a-f]{12,}/g, "<hex>").replace(/\b\d+\b/g, "<num>").replace(/\s+/g, " ").trim();
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function bucketLength(length) {
+  if (length === 0) return "0";
+  if (length < 1024) return "<1k";
+  if (length < 4096) return "1k-4k";
+  if (length < 16384) return "4k-16k";
+  return "16k+";
+}
+function redactUrlQuery(value) {
+  try {
+    const url = new URL(value);
+    if (url.search) url.search = "?[REDACTED_QUERY]";
+    if (url.username) url.username = "[REDACTED_USER]";
+    if (url.password) url.password = "[REDACTED_PASSWORD]";
+    return url.toString();
+  } catch {
+    return value.replace(/\?.*$/, "?[REDACTED_QUERY]");
+  }
+}
+
 // src/agentProcessManager.ts
-var DATA_DIR = path11.join(os5.homedir(), ".slock", "agents");
 var DEFAULT_MAX_CONCURRENT_AGENT_STARTS = 5;
 var DEFAULT_AGENT_START_INTERVAL_MS = 500;
 var WORKSPACE_TEXT_FILE_MAX_BYTES = 1048576;
@@ -3609,7 +3797,7 @@ function findSessionJsonl(root, predicate) {
     if (depth < 0 || visited >= maxEntries) return null;
     let entries;
     try {
-      entries = readdirSync2(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
+      entries = readdirSync3(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
     } catch {
       return null;
     }
@@ -3857,15 +4045,27 @@ After confirming language preference, do not give a generic product introduction
   - 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
+A starter plan should make the next action executable, not just descriptive.
+For new channels, new agents, and adding members to an existing channel, post an **action card** rather than a copyable spec:
+
+- Use \`slock action prepare --target <onboarding-channel>\` and pipe an \`ActionCardAction\` JSON. Identity references are handles (\`@alice\` / \`@scout\` / \`#general\` \u2014 bare names work too), never UUIDs. Server resolves at prepare time.
+  - \`{type: "channel:create", name, visibility: "public" | "private", description?, initialHumans?: ["@alice"], initialAgents?: ["@scout"], draftHint?}\`
+  - \`{type: "agent:create", name, description?, draftHint?}\`
+  - \`{type: "channel:add_member", channel: "#existing-channel", humans?: ["@alice"], agents?: ["@scout"], draftHint?}\` \u2014 at least one of humans / agents must be non-empty
+- The owner clicks the button on the card; the matching dialog opens **prefilled with your values** (editable, deselectable for add_member). They review, adjust, and submit; the action is committed under their identity.
+- Technical fields the owner must pick themselves are NOT yours to prefill on \`agent:create\`: computer, runtime, model, reasoning effort. Stay on semantic intent (name + description).
+- For \`channel:add_member\`, only suggest people who are actually likely candidates (already in the server, relevant to the channel's topic). The owner will deselect anyone they don't want \u2014 make their default-yes list useful, not exhaustive.
+- Do not just describe or list copyable specs once action cards are available \u2014 the human input cost should land at "click the card, review, submit", not "copy this name into the dialog yourself".
+- Do not imply the resource has been created or members added until the card flips to "Done".
+
+Other plan elements still apply:
+- suggested channel or workstream pairing
+- first task to send after the card is committed
+- who to pull in once the channel exists (often a follow-up \`channel:add_member\` card)
 
 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.
+If details are missing but not blocking, state reasonable defaults inside the action card payload (the owner can edit) and invite correction in chat.
+Only ask one blocking question first if the answer is required before any useful card can be prepared.
 Do not imply you have already created agents or channels unless the action has actually happened.
 
 ### Capability Boundary Pivot
@@ -4103,16 +4303,22 @@ Do not copy these answers verbatim.
 
 ## 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.
+- When the owner agrees to a new agent or channel, **post an action card** with \`slock action prepare\`. The card lives inline in chat; the owner clicks the action button, the matching create dialog opens prefilled with your values (editable), and the resource is created under their identity when they submit.
+- v1 supports three action types via \`slock action prepare --target '<channel>' <<EOF { ... } EOF\`:
+  - \`{type: "channel:create", name, visibility: "public" | "private", description?, initialHumans?: ["@alice"], initialAgents?: ["@scout"], draftHint?}\`
+  - \`{type: "agent:create", name, description?, draftHint?}\` \u2014 runtime / model / computer are the owner's call, not yours
+  - \`{type: "channel:add_member", channel: "#existing-channel", humans?: ["@alice"], agents?: ["@scout"], draftHint?}\` \u2014 at least one of humans / agents must be non-empty. The owner clicks "Add Members" on the card; an AddMembers dialog opens with your suggested list (each row toggleable) and the owner submits to actually add them.
+
+- **Identity references are handles, not UUIDs.** Use \`@alice\` / \`@scout\` / \`#general\` (or bare \`alice\` / \`scout\` / \`general\`). The server resolves to UUIDs at prepare time. If a handle doesn't match a real human / agent / channel in this server you get a 422 INVALID_HANDLE error pointing at the field \u2014 fix the handle and retry. You should never see or write UUIDs in action card payloads.
+- Manual fallback (only when the owner explicitly wants to do it themselves or asks how to repeat it): the + buttons in the Agents and Channels sidebar sections. Lead with the action card; mention the + button only on request.
 
 ### Next step
-- Give the exact agent/channel spec the user can copy, then guide them to the relevant + button or creation dialog.
+- Prefill the values you have, post the action card with a short \`draftHint\` explaining why these values, and tell the owner: "click the button on the card to review and commit." Then propose the first task to send once the card flips to Done.
 
 ### 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.
+- Do not imply you already created agents or channels unless the card state is \`executed\`.
+- Do not prefill technical fields on \`agent:create\` (runtime / model / computer / reasoning effort). The owner picks those in the dialog.
+- If the action type the user wants is not yet supported (e.g. \`channel:add_member\`), say so plainly and offer the manual UI path; do not invent action types the schema does not accept.
 `;
 }
 function buildOnboardingSeedFiles() {
@@ -4212,6 +4418,20 @@ function runtimeProfileNotificationFromMessage(message) {
 function runtimeProfileNotificationTitle(kind) {
   return kind === "migration" ? "Runtime Profile migration" : "Runtime Profile notice";
 }
+function hashRuntimeProfileKey(key) {
+  if (!key) return void 0;
+  return createHash2("sha256").update(key).digest("hex").slice(0, 16);
+}
+function runtimeProfileTurnControl(kind, key, source) {
+  return {
+    kind,
+    source,
+    keyHash: hashRuntimeProfileKey(key) ?? null,
+    keyPresent: Boolean(key),
+    injectedAtMs: Date.now(),
+    migrationDoneToolObserved: false
+  };
+}
 function pushRecentLines(lines, chunk, maxLines, maxLineLength) {
   const next = [...lines];
   for (const rawLine of chunk.split(/\r?\n/)) {
@@ -4400,13 +4620,14 @@ var AgentProcessManager = class _AgentProcessManager {
   defaultAgentEnvVarsProvider;
   tracer;
   deliveryTraceContexts = /* @__PURE__ */ new WeakMap();
+  processExitTraceAttrs = /* @__PURE__ */ new WeakMap();
   constructor(chatBridgePath, sendToServer, daemonApiKey, opts) {
     this.chatBridgePath = chatBridgePath;
     this.slockCliPath = opts.slockCliPath ?? "";
     this.sendToServer = sendToServer;
     this.daemonApiKey = daemonApiKey;
     this.serverUrl = opts.serverUrl;
-    this.dataDir = opts.dataDir || DATA_DIR;
+    this.dataDir = opts.dataDir || resolveSlockHomePath("agents");
     this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os5.homedir();
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
@@ -4798,6 +5019,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         exitCode: null,
         exitSignal: null,
         expectedTerminationReason: null,
+        runtimeProfileTurnControl: runtimeConfig.runtimeProfileControl ? runtimeProfileTurnControl(runtimeConfig.runtimeProfileControl.kind, runtimeConfig.runtimeProfileControl.key, "agent_config") : null,
         pendingTrajectory: null,
         gatedSteering: createGatedSteeringState()
       };
@@ -4872,7 +5094,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           clean_exit: code === 0,
           runtime_trace_active: Boolean(current?.runtimeTraceSpan),
           inbox_count: current?.inbox.length ?? 0,
-          pending_notification_count: current?.pendingNotificationCount ?? 0
+          pending_notification_count: current?.pendingNotificationCount ?? 0,
+          ...this.processExitTraceAttrs.get(proc)
         });
         logger.info(`[Agent ${agentId}] Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}`);
       });
@@ -4900,7 +5123,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             outcome: processEndedCleanly ? "process-exit" : "process-crash",
             expectedTerminationReason: ap.expectedTerminationReason || void 0,
             exitCode: finalCode,
-            exitSignal: finalSignal
+            exitSignal: finalSignal,
+            ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "process_exit")
           });
           if (processEndedCleanly) {
             this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from process exit)");
@@ -5063,6 +5287,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       agentId,
       kind,
       key_present: Boolean(key),
+      key_hash: hashRuntimeProfileKey(key),
       outcome: ap.sessionId ? "queued_busy" : "queued_before_session",
       runtime: ap.config.runtime,
       session_id_present: Boolean(ap.sessionId),
@@ -5085,6 +5310,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       agentId,
       kind,
       key_present: Boolean(key),
+      key_hash: hashRuntimeProfileKey(key),
       outcome: "queued_during_start",
       startup_pending: true,
       starting_inbox_count: pending.length,
@@ -5121,6 +5347,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     this.clearCompactionWatchdog(ap);
     this.agents.delete(agentId);
+    this.processExitTraceAttrs.set(ap.process, {
+      stop_source: silent ? "daemon_internal" : "explicit_request",
+      stop_wait_requested: wait,
+      stop_silent: silent
+    });
     ap.process.kill("SIGTERM");
     if (!silent) {
       this.sendRuntimeProfileReportFor(agentId, ap.config, ap.sessionId, ap.launchId);
@@ -5411,7 +5642,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       attrs: {
         agentId,
         control_kind: kind,
-        key_present: Boolean(key)
+        key_present: Boolean(key),
+        key_hash: hashRuntimeProfileKey(key)
       }
     });
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -5444,7 +5676,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     if (ap?.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) {
       ap.isIdle = false;
-      this.startRuntimeTrace(agentId, ap, "runtime-profile");
+      this.startRuntimeTrace(agentId, ap, "runtime-profile", [message]);
       const written = this.deliverMessagesViaStdin(agentId, ap, [message], "idle");
       span.end(written ? "ok" : "error", {
         attrs: {
@@ -5539,6 +5771,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         agentId,
         control_kind: control.kind,
         key_present: Boolean(control.key),
+        key_hash: hashRuntimeProfileKey(control.key),
         launchId: launchId || void 0,
         source: "agent_config"
       }
@@ -5903,7 +6136,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         deliveryId: context.deliveryId,
         delivery_correlation_id: context.deliveryId,
         control_kind: notification.kind,
-        key_present: Boolean(notification.key)
+        key_present: Boolean(notification.key),
+        runtime_profile_control_kind: notification.kind,
+        runtime_profile_key_hash: hashRuntimeProfileKey(notification.key),
+        runtime_profile_key_present: Boolean(notification.key)
       };
     }
     return {
@@ -5914,8 +6150,63 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       delivery_correlation_id: context.deliveryId ?? first.message_id
     };
   }
+  runtimeProfileTurnControlTraceAttrs(control) {
+    if (!control) return {};
+    const pendingAgeMs = Math.max(0, Date.now() - control.injectedAtMs);
+    return {
+      runtime_profile_control_kind: control.kind,
+      runtime_profile_control_source: control.source,
+      runtime_profile_key_hash: control.keyHash || void 0,
+      runtime_profile_key_present: control.keyPresent,
+      runtime_profile_pending_age_ms: pendingAgeMs,
+      runtime_profile_requires_ack: control.kind === "migration",
+      runtime_profile_migration_done_observed: control.kind === "migration" ? control.migrationDoneToolObserved : void 0
+    };
+  }
+  activateRuntimeProfileTurnControl(ap, control) {
+    ap.runtimeProfileTurnControl = control;
+  }
+  runtimeProfileTurnControlFromMessages(messages, source = "message") {
+    const notifications = messages?.map((message) => runtimeProfileNotificationFromMessage(message)).filter((candidate) => Boolean(candidate)) ?? [];
+    const notification = notifications.find((candidate) => candidate.kind === "migration") ?? notifications[0];
+    if (!notification) return null;
+    return runtimeProfileTurnControl(notification.kind, notification.key, source);
+  }
+  noteRuntimeProfileToolCall(agentId, ap, toolName) {
+    const control = ap.runtimeProfileTurnControl;
+    if (!control || control.kind !== "migration") return;
+    if (!toolName.includes("runtime_profile_migration_done")) return;
+    control.migrationDoneToolObserved = true;
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime_profile.migration_done_tool.observed", {
+      ...this.runtimeProfileTurnControlTraceAttrs(control),
+      tool: toolName
+    });
+  }
+  finalizeRuntimeProfileTurnControl(agentId, ap, terminal) {
+    const control = ap.runtimeProfileTurnControl;
+    if (!control) return {};
+    const attrs = this.runtimeProfileTurnControlTraceAttrs(control);
+    if (control.kind === "migration" && !control.migrationDoneToolObserved) {
+      this.recordRuntimeTraceEvent(agentId, ap, "runtime_profile.migration.turn_without_ack", {
+        ...attrs,
+        terminal,
+        inbox_count: ap.inbox.length,
+        pending_notification_count: ap.pendingNotificationCount
+      });
+    }
+    ap.runtimeProfileTurnControl = null;
+    return {
+      ...attrs,
+      runtime_profile_turn_terminal: terminal,
+      runtime_profile_turn_outcome: control.kind === "migration" ? control.migrationDoneToolObserved ? "migration_done_observed" : "missing_migration_done" : "notice_only"
+    };
+  }
   startRuntimeTrace(agentId, ap, reason, messages) {
     if (ap.runtimeTraceSpan) return ap.runtimeTraceSpan;
+    const messageControl = this.runtimeProfileTurnControlFromMessages(messages);
+    if (messageControl) {
+      this.activateRuntimeProfileTurnControl(ap, messageControl);
+    }
     const span = this.tracer.startSpan("daemon.runtime.turn", {
       surface: "daemon",
       kind: "internal",
@@ -5925,10 +6216,15 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         model: ap.config.model,
         reason,
         hasSession: Boolean(ap.sessionId),
-        ...this.messagesTraceAttrs(messages)
+        ...this.messagesTraceAttrs(messages),
+        ...this.runtimeProfileTurnControlTraceAttrs(ap.runtimeProfileTurnControl)
       }
     });
-    span.addEvent("daemon.turn.started", { reason, ...this.messagesTraceAttrs(messages) });
+    span.addEvent("daemon.turn.started", {
+      reason,
+      ...this.messagesTraceAttrs(messages),
+      ...this.runtimeProfileTurnControlTraceAttrs(ap.runtimeProfileTurnControl)
+    });
     ap.runtimeTraceSpan = span;
     return span;
   }
@@ -6034,7 +6330,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       ageMs: staleForMs,
       lastActivity: ap.lastActivity,
       lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
-      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail)
+      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
+      ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
     this.broadcastActivity(agentId, "error", diagnostic.detail);
     return true;
@@ -6065,7 +6362,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
       lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
       pendingMessages: ap.inbox.length,
-      recovery: "terminate_for_queued_message"
+      recovery: "terminate_for_queued_message",
+      ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
     ap.expectedTerminationReason = "stalled_recovery";
     const runtimeLabel = ap.driver.id === "opencode" ? "OpenCode" : ap.driver.id;
@@ -6074,6 +6372,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     );
     this.broadcastActivity(agentId, "working", `Restarting stalled ${runtimeLabel} runtime for queued message`);
     try {
+      this.processExitTraceAttrs.set(ap.process, {
+        stop_source: "stalled_recovery",
+        expectedTerminationReason: "stalled_recovery",
+        queued_messages_count: ap.inbox.length
+      });
       ap.process.kill("SIGTERM");
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
@@ -6122,6 +6425,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (ap) {
           ap.gatedSteering.outstandingToolUses++;
           this.clearGatedInFlightBatch(agentId, ap, "non_error_progress");
+          this.noteRuntimeProfileToolCall(agentId, ap, invocation.toolName);
           this.recordRuntimeTraceEvent(agentId, ap, "tool.call.started", { tool: invocation.toolName });
           this.setGatedSteeringPhase(agentId, ap, "tool_wait", {
             event: "tool_call",
@@ -6211,11 +6515,18 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               this.broadcastActivity(agentId, "online", "Idle");
             }
           }
-          this.endRuntimeTrace(ap, "ok", { outcome: "turn-completed" });
+          this.endRuntimeTrace(ap, "ok", {
+            outcome: "turn-completed",
+            ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "turn_end")
+          });
           if (ap.driver.terminateProcessOnTurnEnd) {
             ap.expectedTerminationReason = "turn_end";
             logger.info(`[Agent ${agentId}] Turn completed; terminating ${ap.driver.id} process`);
             try {
+              this.processExitTraceAttrs.set(ap.process, {
+                stop_source: "turn_end",
+                expectedTerminationReason: "turn_end"
+              });
               ap.process.kill("SIGTERM");
             } catch (err) {
               const reason = err instanceof Error ? err.message : String(err);
@@ -6233,6 +6544,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.flushPendingTrajectory(agentId);
         if (ap) ap.lastRuntimeError = event.message;
         if (ap) {
+          const runtimeErrorDiagnostics = buildRuntimeErrorDiagnosticEnvelope(event.message);
           this.setGatedSteeringPhase(agentId, ap, "error", { event: "error" });
           if (ap.driver.busyDeliveryMode === "gated" && this.isThinkingBlockMutationError(event.message)) {
             this.requeueGatedInFlightBatch(agentId, ap, "thinking_block_mutation_error");
@@ -6246,8 +6558,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               `[Agent ${agentId}] Disabled Claude tool-boundary gated steering after thinking-block mutation error; lastFlushReason=${ap.gatedSteering.lastFlushReason || "none"}`
             );
           }
-          this.recordRuntimeTraceEvent(agentId, ap, "runtime.error", { message: event.message });
-          this.endRuntimeTrace(ap, "error", { outcome: "runtime-error", errorMessage: event.message });
+          this.recordRuntimeTraceEvent(agentId, ap, "runtime.error", runtimeErrorDiagnostics.eventAttrs);
+          this.endRuntimeTrace(ap, "error", {
+            outcome: "runtime-error",
+            ...runtimeErrorDiagnostics.spanAttrs,
+            ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
+          });
           if (ap.driver.supportsStdinNotification && classifyTerminalFailure(ap)) {
             ap.isIdle = true;
             ap.pendingNotificationCount = 0;
@@ -6721,11 +7037,10 @@ var ReminderCache = class {
 };
 
 // src/machineLock.ts
-import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
 import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync8 } from "fs";
 import os6 from "os";
 import path12 from "path";
-var DEFAULT_MACHINE_STATE_ROOT = path12.join(os6.homedir(), ".slock", "machines");
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -6738,11 +7053,14 @@ var DaemonMachineLockConflictError = class extends Error {
   }
 };
 function apiKeyFingerprint(apiKey) {
-  return createHash("sha256").update(apiKey).digest("hex");
+  return createHash3("sha256").update(apiKey).digest("hex");
 }
 function getDaemonMachineLockId(apiKey) {
   return `machine-${apiKeyFingerprint(apiKey).slice(0, 16)}`;
 }
+function resolveDefaultMachineStateRoot() {
+  return resolveSlockHomePath("machines");
+}
 function ownerPath(lockDir) {
   return path12.join(lockDir, "owner.json");
 }
@@ -6771,7 +7089,7 @@ function isProcessAlive(pid) {
   }
 }
 function acquireDaemonMachineLock(options) {
-  const rootDir = options.rootDir ?? DEFAULT_MACHINE_STATE_ROOT;
+  const rootDir = options.rootDir ?? resolveDefaultMachineStateRoot();
   const fingerprint = apiKeyFingerprint(options.apiKey);
   const lockId = getDaemonMachineLockId(options.apiKey);
   const machineDir = path12.join(rootDir, lockId);
@@ -6827,7 +7145,7 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
+import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync4, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
 import path13 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
@@ -6844,6 +7162,15 @@ var DIAGNOSTIC_ID_ATTRS = /* @__PURE__ */ new Set([
   "deliveryCorrelationId",
   "delivery_correlation_id"
 ]);
+var DIAGNOSTIC_ERROR_ATTRS = /* @__PURE__ */ new Set([
+  "runtime_error_class",
+  "runtime_error_fingerprint",
+  "runtime_error_http_status",
+  "runtime_error_message_present",
+  "runtime_error_message_length_bucket",
+  "runtime_error_message_truncated",
+  "runtime_error_message_excerpt"
+]);
 var LocalRotatingTraceSink = class {
   traceDir;
   maxFileBytes;
@@ -6896,7 +7223,7 @@ var LocalRotatingTraceSink = class {
     }
   }
   pruneOldFiles() {
-    const files = readdirSync3(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
+    const files = readdirSync4(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
     const excess = files.length - this.maxFiles;
     if (excess <= 0) return;
     for (const file of files.slice(0, excess)) {
@@ -6941,6 +7268,11 @@ function sanitizeAttrs(attrs) {
       sanitized[key] = sanitizeValue(value);
       continue;
     }
+    if (isDiagnosticErrorAttr(key)) {
+      if (value === null || value === void 0 || value === "") continue;
+      sanitized[key] = sanitizeValue(value);
+      continue;
+    }
     if (shouldDropAttr(key)) continue;
     sanitized[key] = sanitizeValue(value);
   }
@@ -6974,9 +7306,12 @@ function shouldDropAttr(key) {
 function isDiagnosticIdAttr(key) {
   return DIAGNOSTIC_ID_ATTRS.has(key);
 }
+function isDiagnosticErrorAttr(key) {
+  return DIAGNOSTIC_ERROR_ATTRS.has(key);
+}
 
 // src/traceBundleUpload.ts
-import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
 import { gzipSync } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path14 from "path";
@@ -7106,12 +7441,12 @@ async function uploadWithSignedCapability({
 }
 
 // src/traceJitter.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var INITIAL_UPLOAD_DELAY_SPAN_MS = 3e4;
 var UPLOAD_INTERVAL_JITTER_SPAN_MS = 6e4;
 var MAX_FILE_AGE_JITTER_SPAN_MS = 6e4;
 function computeTraceJitter(lockId) {
-  const seed = createHash2("sha256").update(lockId).digest();
+  const seed = createHash4("sha256").update(lockId).digest();
   return {
     initialUploadDelayMs: seed.readUInt32BE(0) % INITIAL_UPLOAD_DELAY_SPAN_MS,
     uploadIntervalJitterMs: seed.readUInt32BE(4) % UPLOAD_INTERVAL_JITTER_SPAN_MS,
@@ -7312,7 +7647,7 @@ var DaemonTraceBundleUploader = class {
   }
 };
 function sha256Hex(body) {
-  return createHash3("sha256").update(body).digest("hex");
+  return createHash5("sha256").update(body).digest("hex");
 }
 function readPositiveIntegerEnv2(name, fallback) {
   const value = process.env[name];
@@ -7491,6 +7826,7 @@ var DaemonCore = class {
   daemonVersion;
   chatBridgePath;
   slockCliPath;
+  slockHome;
   runtimeDetector;
   agentManager;
   connection;
@@ -7505,6 +7841,8 @@ var DaemonCore = class {
     this.daemonVersion = options.daemonVersion ?? readDaemonVersion();
     this.chatBridgePath = options.chatBridgePath ?? resolveChatBridgePath();
     this.slockCliPath = options.slockCliPath ?? resolveSlockCliPath();
+    this.slockHome = resolveSlockHome();
+    process.env[SLOCK_HOME_ENV] = this.slockHome;
     this.injectedTracer = Boolean(options.tracer);
     this.tracer = options.tracer ?? noopTracer;
     this.runtimeDetector = options.runtimeDetector ?? (() => detectRuntimes(this.tracer));
@@ -7514,7 +7852,7 @@ var DaemonCore = class {
     });
     let connection;
     const agentManagerOptions = {
-      dataDir: options.dataDir,
+      dataDir: options.dataDir ?? resolveSlockHomePath("agents", this.slockHome),
       serverUrl: options.serverUrl,
       defaultAgentEnvVarsProvider: options.defaultAgentEnvVarsProvider,
       slockCliPath: this.slockCliPath,
@@ -7536,7 +7874,7 @@ var DaemonCore = class {
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
     if (this.options.dataDir) return path15.join(path15.dirname(this.options.dataDir), "machines");
-    return DEFAULT_MACHINE_STATE_ROOT;
+    return resolveDefaultMachineStateRoot();
   }
   shouldEnableLocalTrace() {
     if (this.injectedTracer) return false;
@@ -7580,6 +7918,12 @@ var DaemonCore = class {
   }
   start() {
     logger.info("[Slock Daemon] Starting...");
+    logger.info(`[Slock Daemon] ${SLOCK_HOME_ENV}=${this.slockHome}`);
+    for (const legacy of listLegacySlockStatePaths(this.slockHome)) {
+      logger.warn(
+        `[Slock Daemon] Legacy Slock state exists outside ${SLOCK_HOME_ENV}: ${legacy.path}. This daemon will use ${legacy.destination}; migrate manually if that ${legacy.description} should move with this installation.`
+      );
+    }
     if (!this.machineLock) {
       this.machineLock = acquireDaemonMachineLock({
         apiKey: this.options.apiKey,