@slock-ai/daemon 0.46.2 → 0.47.0-play.20260512173159

package/dist/{chunk-FG5JGA67.js → chunk-5DPZMLC3.js}

@@ -1,17 +1,21 @@
 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";
+import path16 from "path";
 import os7 from "os";
 import { createRequire } from "module";
 import { accessSync } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../shared/src/tracing/index.ts
 var DEFAULT_TRACE_FLAGS = "00";
@@ -576,6 +580,82 @@ 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/translationLanguages.ts
+var SUPPORTED_TRANSLATION_LANGUAGE_CODES = [
+  "en",
+  "zh-cn",
+  "zh-tw",
+  "ja",
+  "ko",
+  "es",
+  "fr",
+  "de",
+  "pt-br"
+];
+var SUPPORTED_TRANSLATION_LANGUAGE_SET = new Set(
+  SUPPORTED_TRANSLATION_LANGUAGE_CODES
+);
+
 // ../shared/src/testing/failpoints.ts
 var NoopFailpointRegistry = class {
   get enabled() {
@@ -645,6 +725,7 @@ var SERVER_CAPABILITY_MATRIX = {
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
+  { id: "pi", displayName: "Pi", binary: "pi", supported: true },
   { 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 },
@@ -686,9 +767,10 @@ 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 mkdirSync5, readdirSync as readdirSync3, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
-import path11 from "path";
+import { createHash as createHash2 } from "crypto";
+import path12 from "path";
 import os5 from "os";
 
 // src/drivers/claude.ts
@@ -781,21 +863,23 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 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, including lifecycle history for each reminder.
-20. **\`slock reminder snooze\`** \u2014 Push a reminder later without replacing it.
-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.
+9. **\`slock message react\`** \u2014 Add or remove your reaction on a message. Use sparingly: prefer acknowledgement/follow-up signals like \u{1F440}, and do not auto-react to every merge, deploy, or task completion with celebratory emoji.
+10. **\`slock task list\`** \u2014 View a channel's task board.
+11. **\`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).
+12. **\`slock task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
+13. **\`slock task unclaim\`** \u2014 Release your claim on a task.
+14. **\`slock task update\`** \u2014 Change a task's status (e.g. to in_review or done).
+15. **\`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\`.
+16. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
+17. **\`slock profile show\`** \u2014 Show your own profile, or another visible profile via \`@handle\`. Mirrors the canonical Slock profile view.
+18. **\`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.
+19. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
+20. **\`slock reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
+21. **\`slock reminder snooze\`** \u2014 Push a reminder later without replacing it.
+22. **\`slock reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
+23. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
+24. **\`slock reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
+25. **\`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
@@ -1093,6 +1177,17 @@ Keep the user informed. They cannot see your internal reasoning, so:
 - For multi-step work, send short progress updates (e.g. "Working on step 2/3\u2026").
 - When done, summarize the result.
 - Keep updates concise \u2014 one or two sentences. Don't flood the chat.
+- For long answers where users need the conclusion first but details still matter, put the conclusion and next action outside any collapse, then use sanitized HTML details blocks for optional depth:
+
+\`\`\`html
+<details>
+<summary>Evidence, logs, or edge cases</summary>
+
+Detailed notes go here.
+</details>
+\`\`\`
+
+  Do not hide the main recommendation, blocker, or required action inside \`<details>\`; only fold supporting evidence, logs, alternatives, or extended rationale.
 
 ### Conversation etiquette
 
@@ -1272,6 +1367,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 +1801,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 +1830,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 +1893,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 +2349,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 +2416,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 +2513,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 +2576,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"],
@@ -2772,13 +2911,16 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
 import os3 from "os";
 import path8 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
 var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
+var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
+var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
+var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -2787,6 +2929,73 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os3.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path8.join(home, ".kimi", "config.toml");
+  try {
+    return {
+      raw: readFileSync3(configPath, "utf8"),
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  } catch {
+    return {
+      raw: null,
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  }
+}
+function buildKimiSpawnEnv(env = process.env) {
+  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
+  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
+  return spawnEnv;
+}
+function buildKimiEffectiveEnv(ctx, overrideEnv) {
+  return {
+    ...process.env,
+    ...ctx.config.envVars || {},
+    ...overrideEnv || {}
+  };
+}
+function buildKimiLaunchOptions(ctx, opts = {}) {
+  const env = buildKimiEffectiveEnv(ctx, opts.env);
+  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = path8.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
+      chmodSync(configFilePath, 384);
+    }
+  }
+  if (configFilePath) {
+    args.push("--config-file", configFilePath);
+  }
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  return {
+    args,
+    env: buildKimiSpawnEnv(env),
+    configFilePath,
+    configContent
+  };
+}
 var KimiDriver = class {
   id = "kimi";
   lifecycle = {
@@ -2803,7 +3012,25 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildKimiLaunchOptions(launchCtx, {
+        home: opts?.home,
+        writeGeneratedConfig: false
+      });
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
+      };
+    }
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -2855,6 +3082,7 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -2863,16 +3091,13 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args.push("--model", ctx.config.model);
-    }
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" };
     const proc = spawn6("kimi", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
-      env: spawnEnv,
+      env: launch.env,
       shell: process.platform === "win32"
     });
     proc.stdin?.write(JSON.stringify({
@@ -2989,14 +3214,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os3.homedir()) {
-  const configPath = path8.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync3(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os3.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -3399,6 +3619,304 @@ var OpenCodeDriver = class {
   }
 };
 
+// src/drivers/pi.ts
+import { spawn as spawn8, spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7 } from "fs";
+import { fileURLToPath } from "url";
+import path10 from "path";
+var CHAT_MCP_TOOL_PREFIX2 = "chat_";
+var NO_MESSAGE_PROMPT2 = "No new messages are pending. Stop now.";
+var FIRST_MESSAGE_TASK_PREFIX2 = "First message task (system-triggered):";
+var MIN_BUNDLED_PI_VERSION = "0.74.0";
+function defaultPackageResolver(specifier) {
+  return import.meta.resolve(specifier);
+}
+function parseSemver2(version) {
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isSupportedPiVersion(version) {
+  if (!version) return true;
+  const actual = parseSemver2(version);
+  const minimum = parseSemver2(MIN_BUNDLED_PI_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 resolveBundledPiCliPath(resolver = defaultPackageResolver) {
+  try {
+    const mainPath = fileURLToPath(resolver("@earendil-works/pi-coding-agent"));
+    const cliPath = path10.join(path10.dirname(mainPath), "cli.js");
+    return existsSync7(cliPath) ? cliPath : null;
+  } catch {
+    return null;
+  }
+}
+function readBundledPiVersion(cliPath) {
+  const result = spawnSync3(process.execPath, [cliPath, "--version"], {
+    encoding: "utf8",
+    timeout: 5e3
+  });
+  if (result.error || result.status !== 0) return null;
+  return String(result.stdout || result.stderr || "").trim() || null;
+}
+function unsupportedPiVersionMessage(version) {
+  if (!version || isSupportedPiVersion(version)) return null;
+  return `Bundled Pi CLI ${version} is unsupported; requires Pi >= ${MIN_BUNDLED_PI_VERSION}.`;
+}
+function buildPiLaunchOptions(ctx, opts = {}) {
+  const cliPath = opts.cliPath ?? resolveBundledPiCliPath();
+  if (!cliPath) {
+    throw new Error("Bundled Pi CLI not found in @earendil-works/pi-coding-agent");
+  }
+  const piDir = path10.join(ctx.workingDirectory, ".slock", "pi");
+  const sessionDir = path10.join(piDir, "sessions");
+  mkdirSync4(sessionDir, { recursive: true });
+  const slock = prepareCliTransport(ctx, {
+    NO_COLOR: "1",
+    PI_CODING_AGENT_DIR: piDir,
+    PI_CODING_AGENT_SESSION_DIR: sessionDir
+  });
+  const systemPromptPath = path10.join(slock.slockDir, "pi-system-prompt.md");
+  writeFileSync7(systemPromptPath, ctx.standingPrompt, { encoding: "utf8", mode: 384 });
+  const args = [
+    cliPath,
+    "--mode",
+    "json",
+    "--session-dir",
+    sessionDir,
+    "--append-system-prompt",
+    systemPromptPath,
+    "--no-context-files",
+    "--no-extensions",
+    "--no-skills",
+    "--no-prompt-templates",
+    "--no-themes"
+  ];
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  if (ctx.config.sessionId) {
+    args.push("--session", ctx.config.sessionId);
+  }
+  const turnPrompt = ctx.prompt === ctx.standingPrompt ? NO_MESSAGE_PROMPT2 : ctx.prompt;
+  args.push(turnPrompt);
+  return {
+    command: process.execPath,
+    args,
+    env: slock.spawnEnv,
+    sessionDir,
+    systemPromptPath
+  };
+}
+function isSystemFirstMessageTask2(message) {
+  return message.sender_id === "system" && message.channel_type === "channel" && message.channel_name === "all" && message.content.trimStart().startsWith(FIRST_MESSAGE_TASK_PREFIX2);
+}
+function buildPiSystemPrompt(config) {
+  return buildCliTransportSystemPrompt(config, {
+    toolPrefix: CHAT_MCP_TOOL_PREFIX2,
+    extraCriticalRules: [
+      "- Runtime Profile migration controls are not available in the Pi runtime yet. If asked to acknowledge a runtime migration, explain the blocker instead of inventing a command."
+    ],
+    postStartupNotes: [
+      "**Pi 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"
+  });
+}
+function contentText(content) {
+  if (!content) return "";
+  const chunks = [];
+  for (const item of content) {
+    if (item.type === "text" && typeof item.text === "string") {
+      chunks.push(item.text);
+    }
+  }
+  return chunks.join("");
+}
+function apiKeyErrorMessage(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  if (/no api key found/i.test(trimmed)) return trimmed;
+  if (/api key.+required/i.test(trimmed)) return trimmed;
+  if (/no models available/i.test(trimmed)) return trimmed;
+  return null;
+}
+var PiDriver = class {
+  id = "pi";
+  lifecycle = {
+    kind: "per_turn",
+    start: "defer_until_concrete_message",
+    exit: "terminate_on_turn_end",
+    inFlightWake: "coalesce_into_pending"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "none"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId, ctx) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildPiLaunchOptions(launchCtx);
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: [launch.systemPromptPath]
+      };
+    }
+  };
+  supportsStdinNotification = false;
+  mcpToolPrefix = CHAT_MCP_TOOL_PREFIX2;
+  busyDeliveryMode = "none";
+  terminateProcessOnTurnEnd = true;
+  deferSpawnUntilMessage = true;
+  usesSlockCliForCommunication = true;
+  sessionId = null;
+  sessionAnnounced = false;
+  apiKeyErrorAnnounced = false;
+  turnEnded = false;
+  assistantTextByMessageId = /* @__PURE__ */ new Map();
+  shouldDeferWakeMessage(message) {
+    return isSystemFirstMessageTask2(message);
+  }
+  probe() {
+    const cliPath = resolveBundledPiCliPath();
+    if (!cliPath) return { available: false };
+    const version = readBundledPiVersion(cliPath) || void 0;
+    const unsupportedMessage = unsupportedPiVersionMessage(version);
+    if (unsupportedMessage) {
+      return {
+        available: false,
+        version: `${version} (requires >= ${MIN_BUNDLED_PI_VERSION})`
+      };
+    }
+    return { available: true, version };
+  }
+  async detectModels() {
+    return null;
+  }
+  spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    this.sessionAnnounced = false;
+    this.apiKeyErrorAnnounced = false;
+    this.turnEnded = false;
+    this.assistantTextByMessageId.clear();
+    const cliPath = resolveBundledPiCliPath();
+    if (!cliPath) throw new Error("Bundled Pi CLI not found in @earendil-works/pi-coding-agent");
+    const unsupportedMessage = unsupportedPiVersionMessage(readBundledPiVersion(cliPath));
+    if (unsupportedMessage) throw new Error(unsupportedMessage);
+    const launch = buildPiLaunchOptions(ctx, { cliPath });
+    const proc = spawn8(launch.command, 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 {
+      if (this.apiKeyErrorAnnounced) return [];
+      const message = apiKeyErrorMessage(line);
+      if (!message) return [];
+      this.apiKeyErrorAnnounced = true;
+      this.turnEnded = true;
+      return [
+        { kind: "error", message },
+        { kind: "turn_end", sessionId: this.sessionId || void 0 }
+      ];
+    }
+    const events = [];
+    if (event.type === "session" && event.id) {
+      this.sessionId = event.id;
+    }
+    if (!this.sessionAnnounced && this.sessionId) {
+      events.push({ kind: "session_init", sessionId: this.sessionId });
+      this.sessionAnnounced = true;
+    }
+    switch (event.type) {
+      case "agent_start":
+      case "turn_start":
+        events.push({ kind: "thinking", text: "" });
+        break;
+      case "message_update":
+      case "message_end":
+        if (event.message?.role === "assistant") {
+          const key = event.message.id || "current";
+          const currentText = contentText(event.message.content);
+          const previousText = this.assistantTextByMessageId.get(key) ?? "";
+          if (currentText.length > previousText.length && currentText.startsWith(previousText)) {
+            events.push({ kind: "text", text: currentText.slice(previousText.length) });
+          } else if (currentText && currentText !== previousText) {
+            events.push({ kind: "text", text: currentText });
+          }
+          this.assistantTextByMessageId.set(key, currentText);
+          if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
+            events.push({ kind: "error", message: event.message.errorMessage || `Request ${event.message.stopReason}` });
+          }
+        }
+        break;
+      case "tool_execution_start":
+        events.push({
+          kind: "tool_call",
+          name: event.toolName || "unknown_tool",
+          input: event.args
+        });
+        break;
+      case "tool_execution_end":
+        events.push({
+          kind: "tool_output",
+          name: event.toolName || "unknown_tool"
+        });
+        if (event.isError) {
+          events.push({ kind: "error", message: `Pi tool ${event.toolName || "unknown_tool"} failed` });
+        }
+        break;
+      case "compaction_start":
+        events.push({ kind: "compaction_started" });
+        break;
+      case "compaction_end":
+        events.push({ kind: "compaction_finished" });
+        if (event.errorMessage) events.push({ kind: "error", message: event.errorMessage });
+        break;
+      case "turn_end":
+      case "agent_end":
+        if (!this.turnEnded) {
+          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+          this.turnEnded = true;
+        }
+        break;
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildPiSystemPrompt(config);
+  }
+};
+
 // src/drivers/index.ts
 var driverFactories = {
   claude: () => new ClaudeDriver(),
@@ -3407,7 +3925,8 @@ var driverFactories = {
   cursor: () => new CursorDriver(),
   gemini: () => new GeminiDriver(),
   kimi: () => new KimiDriver(),
-  opencode: () => new OpenCodeDriver()
+  opencode: () => new OpenCodeDriver(),
+  pi: () => new PiDriver()
 };
 function getDriver(runtimeId) {
   const createDriver = driverFactories[runtimeId];
@@ -3420,7 +3939,7 @@ function getDriver(runtimeId) {
 
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -3428,7 +3947,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path10.join(dataDir, directoryName);
+  return path11.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -3477,7 +3996,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path10.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path11.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -3496,7 +4015,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path10.join(dataDir, entry.name);
+      const dirPath = path11.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -3527,8 +4046,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,19 +4206,19 @@ 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;
     }
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isFile() || !predicate(entry.name)) continue;
-      return path11.join(dir, entry.name);
+      return path12.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);
+      const found = visit(path12.join(dir, entry.name), depth - 1);
       if (found) return found;
     }
     return null;
@@ -3634,10 +4231,10 @@ function safeSessionFilename(value) {
 }
 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({
+    const dir = path12.join(fallbackDir, ".slock", "runtime-sessions");
+    mkdirSync5(dir, { recursive: true });
+    const filePath = path12.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    writeFileSync8(filePath, JSON.stringify({
       type: "runtime_session_handoff",
       runtime,
       sessionId,
@@ -3656,7 +4253,7 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
   }
 }
 function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.homedir(), fallbackDir) {
-  const directPath = path11.isAbsolute(sessionId) ? sessionId : null;
+  const directPath = path12.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
       if (statSync2(directPath).isFile()) {
@@ -3665,7 +4262,7 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.homedir(), f
     } 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;
+  const resolvedPath = runtime === "claude" ? findSessionJsonl(path12.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path12.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;
@@ -3857,15 +4454,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 +4712,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 +4827,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 +5029,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;
@@ -4651,26 +5281,26 @@ var AgentProcessManager = class _AgentProcessManager {
     this.recordDaemonTrace("daemon.agent.spawn.started", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId));
     try {
       const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path11.join(this.dataDir, agentId);
+      const agentDataDir = path12.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
       const runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
-      const memoryMdPath = path11.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path12.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
         const initialMemoryMd = buildInitialMemoryMd(runtimeConfig);
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      const notesDir = path11.join(agentDataDir, "notes");
+      const notesDir = path12.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 = path11.join(agentDataDir, relativePath);
+          const fullPath = path12.join(agentDataDir, relativePath);
           try {
             await access(fullPath);
           } catch {
-            await mkdir(path11.dirname(fullPath), { recursive: true });
+            await mkdir(path12.dirname(fullPath), { recursive: true });
             await writeFile(fullPath, content);
           }
         }
@@ -4798,6 +5428,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 +5503,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 +5532,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 +5696,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 +5719,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 +5756,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);
@@ -5320,7 +5960,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return true;
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path11.join(this.dataDir, agentId);
+    const agentDataDir = path12.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -5357,7 +5997,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return result;
   }
   buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
-    const workspacePath = path11.join(this.dataDir, agentId);
+    const workspacePath = path12.join(this.dataDir, agentId);
     return {
       agentId,
       launchId,
@@ -5411,7 +6051,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 +6085,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 +6180,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"
       }
@@ -5603,7 +6245,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path11.join(this.dataDir, agentId);
+    const agentDir = path12.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -5611,8 +6253,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path11.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path11.sep) && resolved !== agentDir) {
+      const resolved = path12.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path12.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -5620,14 +6262,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return this.listDirectoryChildren(targetDir, agentDir);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path11.join(this.dataDir, agentId);
-    const resolved = path11.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path11.sep) && resolved !== agentDir) {
+    const agentDir = path12.join(this.dataDir, agentId);
+    const resolved = path12.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path12.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat2(resolved);
     if (info.isDirectory()) throw new Error("Cannot read a directory");
-    const ext = path11.extname(resolved).toLowerCase();
+    const ext = path12.extname(resolved).toLowerCase();
     if (WORKSPACE_TEXT_EXTENSIONS.has(ext) || ext === "") {
       if (info.size > WORKSPACE_TEXT_FILE_MAX_BYTES) throw new Error("File too large");
       const content = await readFile(resolved, "utf-8");
@@ -5662,13 +6304,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
     const home = os5.homedir();
-    const workspaceDir = path11.join(this.dataDir, agentId);
+    const workspaceDir = path12.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(path11.join(home, p)))
+      paths.global.map((p) => this.scanSkillsDir(path12.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path11.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path12.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -5697,7 +6339,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path11.join(dir, entry.name, "SKILL.md");
+        const skillMd = path12.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -5708,7 +6350,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(path11.join(dir, entry.name), "utf-8");
+          const content = await readFile(path12.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -5903,7 +6545,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 +6559,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 +6625,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 +6739,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 +6771,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 +6781,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 +6834,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 +6924,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 +6953,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 +6967,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;
@@ -6418,8 +7143,8 @@ ${RESPONSE_TARGET_HINT}`);
     const nodes = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = path11.join(dir, entry.name);
-      const relativePath = path11.relative(rootDir, fullPath);
+      const fullPath = path12.join(dir, entry.name);
+      const relativePath = path12.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -6721,11 +7446,10 @@ var ReminderCache = class {
 };
 
 // src/machineLock.ts
-import { createHash, randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync8 } from "fs";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
 import os6 from "os";
-import path12 from "path";
-var DEFAULT_MACHINE_STATE_ROOT = path12.join(os6.homedir(), ".slock", "machines");
+import path13 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -6738,13 +7462,16 @@ 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");
+  return path13.join(lockDir, "owner.json");
 }
 function readOwner(lockDir) {
   try {
@@ -6771,16 +7498,16 @@ 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);
-  const lockDir = path12.join(machineDir, "daemon.lock");
+  const machineDir = path13.join(rootDir, lockId);
+  const lockDir = path13.join(machineDir, "daemon.lock");
   const token = randomUUID2();
-  mkdirSync5(machineDir, { recursive: true });
+  mkdirSync6(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      mkdirSync5(lockDir);
+      mkdirSync6(lockDir);
       const owner = {
         pid: process.pid,
         token,
@@ -6790,7 +7517,7 @@ function acquireDaemonMachineLock(options) {
         apiKeyFingerprint: fingerprint.slice(0, 16)
       };
       try {
-        writeFileSync8(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
+        writeFileSync9(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
 `, { mode: 384 });
       } catch (err) {
         rmSync2(lockDir, { recursive: true, force: true });
@@ -6827,8 +7554,8 @@ 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 path13 from "path";
+import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync4, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync10 } from "fs";
+import path14 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_FILES = 8;
@@ -6844,6 +7571,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;
@@ -6855,7 +7591,7 @@ var LocalRotatingTraceSink = class {
   currentSize = 0;
   sequence = 0;
   constructor(options) {
-    this.traceDir = path13.join(options.machineDir, "traces");
+    this.traceDir = path14.join(options.machineDir, "traces");
     this.maxFileBytes = Math.max(1024, Math.floor(options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES));
     const baseAgeMs = Math.max(1e3, Math.floor(options.maxFileAgeMs ?? DEFAULT_MAX_FILE_AGE_MS));
     const ageJitterMs = Math.max(0, Math.floor(options.maxFileAgeJitterMs ?? 0));
@@ -6881,26 +7617,26 @@ var LocalRotatingTraceSink = class {
     return this.currentFile;
   }
   ensureFile(nextBytes) {
-    mkdirSync6(this.traceDir, { recursive: true, mode: 448 });
+    mkdirSync7(this.traceDir, { recursive: true, mode: 448 });
     const nowMs = this.nowMsProvider();
     const shouldRotateForAge = this.currentFileOpenedAtMs !== null && nowMs - this.currentFileOpenedAtMs >= this.maxFileAgeMs;
     if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes || shouldRotateForAge) {
-      this.currentFile = path13.join(
+      this.currentFile = path14.join(
         this.traceDir,
         `daemon-trace-${safeTimestamp(nowMs)}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
       );
-      writeFileSync9(this.currentFile, "", { flag: "a", mode: 384 });
+      writeFileSync10(this.currentFile, "", { flag: "a", mode: 384 });
       this.currentSize = statSync4(this.currentFile).size;
       this.currentFileOpenedAtMs = nowMs;
       this.pruneOldFiles();
     }
   }
   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)) {
-      rmSync3(path13.join(this.traceDir, file), { force: true });
+      rmSync3(path14.join(this.traceDir, file), { force: true });
     }
   }
 };
@@ -6941,6 +7677,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,16 +7715,19 @@ 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";
+import path15 from "path";
 
 // src/directUploadCapability.ts
-function joinUrl(base, path16) {
-  return `${base.replace(/\/+$/, "")}${path16}`;
+function joinUrl(base, path17) {
+  return `${base.replace(/\/+$/, "")}${path17}`;
 }
 function jsonHeaders(apiKey) {
   return {
@@ -7106,12 +7850,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,
@@ -7202,7 +7946,7 @@ var DaemonTraceBundleUploader = class {
     }, nextMs);
   }
   async findUploadCandidates() {
-    const traceDir = path14.join(this.options.machineDir, "traces");
+    const traceDir = path15.join(this.options.machineDir, "traces");
     let names;
     try {
       names = await readdir3(traceDir);
@@ -7214,8 +7958,8 @@ var DaemonTraceBundleUploader = class {
     const currentFile = this.options.currentFileProvider?.();
     const candidates = [];
     for (const name of names.filter((entry) => entry.startsWith("daemon-trace-") && entry.endsWith(".jsonl")).sort()) {
-      const file = path14.join(traceDir, name);
-      if (currentFile && path14.resolve(file) === path14.resolve(currentFile)) continue;
+      const file = path15.join(traceDir, name);
+      if (currentFile && path15.resolve(file) === path15.resolve(currentFile)) continue;
       if (await this.isUploaded(file)) continue;
       try {
         const info = await stat3(file);
@@ -7289,8 +8033,8 @@ var DaemonTraceBundleUploader = class {
     }
   }
   uploadStatePath(file) {
-    const stateDir = path14.join(this.options.machineDir, "trace-uploads");
-    return path14.join(stateDir, `${path14.basename(file)}.uploaded.json`);
+    const stateDir = path15.join(this.options.machineDir, "trace-uploads");
+    return path15.join(stateDir, `${path15.basename(file)}.uploaded.json`);
   }
   async isUploaded(file) {
     try {
@@ -7302,9 +8046,9 @@ var DaemonTraceBundleUploader = class {
   }
   async markUploaded(file, metadata) {
     const stateFile = this.uploadStatePath(file);
-    await mkdir2(path14.dirname(stateFile), { recursive: true, mode: 448 });
+    await mkdir2(path15.dirname(stateFile), { recursive: true, mode: 448 });
     await writeFile2(stateFile, `${JSON.stringify({
-      file: path14.basename(file),
+      file: path15.basename(file),
       uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...metadata
     }, null, 2)}
@@ -7312,7 +8056,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];
@@ -7343,23 +8087,23 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path15.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path15.resolve(dirname, "chat-bridge.js");
+  const dirname = path16.dirname(fileURLToPath2(moduleUrl));
+  const jsPath = path16.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path15.resolve(dirname, "chat-bridge.ts");
+    return path16.resolve(dirname, "chat-bridge.ts");
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path15.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path15.resolve(thisDir, "cli", "index.js");
+  const thisDir = path16.dirname(fileURLToPath2(moduleUrl));
+  const bundledDistPath = path16.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path15.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path16.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -7491,6 +8235,7 @@ var DaemonCore = class {
   daemonVersion;
   chatBridgePath;
   slockCliPath;
+  slockHome;
   runtimeDetector;
   agentManager;
   connection;
@@ -7505,6 +8250,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 +8261,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,
@@ -7535,8 +8282,8 @@ 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;
+    if (this.options.dataDir) return path16.join(path16.dirname(this.options.dataDir), "machines");
+    return resolveDefaultMachineStateRoot();
   }
   shouldEnableLocalTrace() {
     if (this.injectedTracer) return false;
@@ -7580,6 +8327,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,