@slock-ai/daemon 0.46.1 → 0.46.2-play.20260510065637

package/dist/chat-bridge.js

@@ -4,8 +4,9 @@ import {
   buildFetchDispatcher,
   executeJsonRequest,
   executeResponseRequest,
-  logger
-} from "./chunk-Z3PCMYZO.js";
+  logger,
+  resolveSlockHomePath
+} from "./chunk-B7XIMLOT.js";
 
 // src/chat-bridge.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -722,8 +723,7 @@ Use this ID in send_message's attachment_ids parameter to include it in a messag
       try {
         const fs = await import("fs");
         const path = await import("path");
-        const os = await import("os");
-        const cacheDir = path.join(os.homedir(), ".slock", "attachments");
+        const cacheDir = resolveSlockHomePath("attachments");
         fs.mkdirSync(cacheDir, { recursive: true });
         const existing = fs.readdirSync(cacheDir).find((f) => f.startsWith(attachment_id));
         if (existing) {

package/dist/{chunk-XW57NR6Y.js → chunk-7EZVMA2D.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";
@@ -688,6 +692,7 @@ var DISPLAY_PLAN_CONFIG = {
 // src/agentProcessManager.ts
 import { mkdirSync as mkdirSync4, readdirSync as readdirSync2, 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";
 
@@ -1093,6 +1098,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 +1288,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,
@@ -2228,6 +2245,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 +2312,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 +2409,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 +2472,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 +2807,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 +2825,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 +2908,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 +2978,7 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -2863,16 +2987,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 +3110,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;
@@ -3527,8 +3643,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;
@@ -4212,6 +4406,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 +4608,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 +5007,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 +5082,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 +5111,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 +5275,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 +5298,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 +5335,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 +5630,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 +5664,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 +5759,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 +6124,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 +6138,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 +6204,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 +6318,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 +6350,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 +6360,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 +6413,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 +6503,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 +6532,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 +6546,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 +7025,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 +7041,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 +7077,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);
@@ -6830,6 +7136,7 @@ function acquireDaemonMachineLock(options) {
 import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync3, 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;
 var DEFAULT_MAX_FILES = 8;
 var DIAGNOSTIC_ID_ATTRS = /* @__PURE__ */ new Set([
   "serverId",
@@ -6843,17 +7150,37 @@ 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;
+  maxFileAgeMs;
   maxFiles;
+  nowMsProvider;
   currentFile = null;
+  currentFileOpenedAtMs = null;
   currentSize = 0;
   sequence = 0;
   constructor(options) {
     this.traceDir = path13.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));
+    this.maxFileAgeMs = baseAgeMs + ageJitterMs;
     this.maxFiles = Math.max(1, Math.floor(options.maxFiles ?? DEFAULT_MAX_FILES));
+    this.nowMsProvider = options.nowMsProvider ?? Date.now;
+  }
+  /** Exposed for observability — the effective rotation age after jitter. */
+  getMaxFileAgeMs() {
+    return this.maxFileAgeMs;
   }
   record(span) {
     try {
@@ -6870,13 +7197,16 @@ var LocalRotatingTraceSink = class {
   }
   ensureFile(nextBytes) {
     mkdirSync6(this.traceDir, { recursive: true, mode: 448 });
-    if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes) {
+    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.traceDir,
-        `daemon-trace-${safeTimestamp(Date.now())}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
+        `daemon-trace-${safeTimestamp(nowMs)}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
       );
       writeFileSync9(this.currentFile, "", { flag: "a", mode: 384 });
       this.currentSize = statSync4(this.currentFile).size;
+      this.currentFileOpenedAtMs = nowMs;
       this.pruneOldFiles();
     }
   }
@@ -6926,6 +7256,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);
   }
@@ -6959,9 +7294,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 createHash2, 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";
@@ -7090,6 +7428,35 @@ async function uploadWithSignedCapability({
   return { capability, session, uploadResponse };
 }
 
+// src/traceJitter.ts
+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 = createHash4("sha256").update(lockId).digest();
+  return {
+    initialUploadDelayMs: seed.readUInt32BE(0) % INITIAL_UPLOAD_DELAY_SPAN_MS,
+    uploadIntervalJitterMs: seed.readUInt32BE(4) % UPLOAD_INTERVAL_JITTER_SPAN_MS,
+    maxFileAgeJitterMs: seed.readUInt32BE(8) % MAX_FILE_AGE_JITTER_SPAN_MS
+  };
+}
+var NO_JITTER = {
+  initialUploadDelayMs: 0,
+  uploadIntervalJitterMs: 0,
+  maxFileAgeJitterMs: 0
+};
+function bucketDelayMs(delayMs) {
+  if (delayMs < 1e3) return "0-1s";
+  if (delayMs < 5e3) return "1-5s";
+  if (delayMs < 15e3) return "5-15s";
+  if (delayMs < 3e4) return "15-30s";
+  if (delayMs < 6e4) return "30-60s";
+  if (delayMs < 3e5) return "60s-5m";
+  if (delayMs < 6e5) return "5-10m";
+  return "10m+";
+}
+
 // src/traceBundleUpload.ts
 var TRACE_UPLOAD_SCOPE = "daemon-trace-bundle:create";
 var DEFAULT_UPLOAD_INTERVAL_MS = 5 * 60 * 1e3;
@@ -7097,30 +7464,66 @@ var DEFAULT_MIN_FILE_AGE_MS = 60 * 1e3;
 var DEFAULT_MAX_FILES_PER_RUN = 4;
 var DaemonTraceBundleUploader = class {
   options;
-  timer = null;
+  jitter;
+  timers;
+  initialDelayTimer = null;
+  intervalTimer = null;
+  stopped = false;
   constructor(options) {
     this.options = options;
+    this.jitter = options.jitter ?? (options.lockId ? computeTraceJitter(options.lockId) : NO_JITTER);
+    this.timers = options.timers ?? {
+      setTimeout: globalThis.setTimeout.bind(globalThis),
+      setInterval: globalThis.setInterval.bind(globalThis),
+      clearTimeout: globalThis.clearTimeout.bind(globalThis),
+      clearInterval: globalThis.clearInterval.bind(globalThis)
+    };
   }
   start() {
-    if (this.timer) return;
-    void this.uploadOnce();
-    this.timer = setInterval(() => {
-      void this.uploadOnce();
-    }, this.options.intervalMs ?? readPositiveIntegerEnv2("SLOCK_DAEMON_TRACE_UPLOAD_INTERVAL_MS", DEFAULT_UPLOAD_INTERVAL_MS));
+    if (this.stopped) return;
+    if (this.initialDelayTimer || this.intervalTimer) return;
+    const initialDelayMs = this.jitter.initialUploadDelayMs;
+    this.initialDelayTimer = this.timers.setTimeout(() => {
+      this.initialDelayTimer = null;
+      if (this.stopped) return;
+      void this.uploadOnce("initial");
+      this.scheduleNextTick();
+    }, initialDelayMs);
   }
   stop() {
-    if (!this.timer) return;
-    clearInterval(this.timer);
-    this.timer = null;
+    this.stopped = true;
+    if (this.initialDelayTimer) {
+      this.timers.clearTimeout(this.initialDelayTimer);
+      this.initialDelayTimer = null;
+    }
+    if (this.intervalTimer) {
+      this.timers.clearTimeout(this.intervalTimer);
+      this.intervalTimer = null;
+    }
   }
-  async uploadOnce() {
+  /**
+   * Drive a single upload pass. `trigger` is surfaced as a span attribute so
+   * we can distinguish startup drain vs steady-state ticks in ScopeDB.
+   */
+  async uploadOnce(trigger = "manual") {
     const files = await this.findUploadCandidates();
     let uploaded = 0;
     for (const file of files.slice(0, this.options.maxFilesPerRun ?? DEFAULT_MAX_FILES_PER_RUN)) {
-      if (await this.uploadFile(file)) uploaded += 1;
+      if (await this.uploadFile(file, trigger)) uploaded += 1;
     }
     return { attempted: files.length, uploaded };
   }
+  scheduleNextTick() {
+    if (this.stopped) return;
+    const baseIntervalMs = this.options.intervalMs ?? readPositiveIntegerEnv2("SLOCK_DAEMON_TRACE_UPLOAD_INTERVAL_MS", DEFAULT_UPLOAD_INTERVAL_MS);
+    const nextMs = baseIntervalMs + this.jitter.uploadIntervalJitterMs;
+    this.intervalTimer = this.timers.setTimeout(() => {
+      this.intervalTimer = null;
+      if (this.stopped) return;
+      void this.uploadOnce("interval");
+      this.scheduleNextTick();
+    }, nextMs);
+  }
   async findUploadCandidates() {
     const traceDir = path14.join(this.options.machineDir, "traces");
     let names;
@@ -7147,13 +7550,16 @@ var DaemonTraceBundleUploader = class {
     }
     return candidates;
   }
-  async uploadFile(file) {
+  async uploadFile(file, trigger) {
     const span = this.options.tracer?.startSpan("daemon.bundle.upload", {
       surface: "daemon",
       kind: "producer",
       attrs: {
         file_present: true,
-        worker_url_present: Boolean(this.options.workerUrl)
+        worker_url_present: Boolean(this.options.workerUrl),
+        upload_trigger: trigger,
+        initial_delay_ms_bucket: bucketDelayMs(this.jitter.initialUploadDelayMs),
+        interval_jitter_ms_bucket: bucketDelayMs(this.jitter.uploadIntervalJitterMs)
       }
     });
     try {
@@ -7229,7 +7635,7 @@ var DaemonTraceBundleUploader = class {
   }
 };
 function sha256Hex(body) {
-  return createHash2("sha256").update(body).digest("hex");
+  return createHash5("sha256").update(body).digest("hex");
 }
 function readPositiveIntegerEnv2(name, fallback) {
   const value = process.env[name];
@@ -7239,6 +7645,7 @@ function readPositiveIntegerEnv2(name, fallback) {
 }
 
 // src/core.ts
+var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 function parseDaemonCliArgs(args) {
   let serverUrl = "";
@@ -7407,6 +7814,7 @@ var DaemonCore = class {
   daemonVersion;
   chatBridgePath;
   slockCliPath;
+  slockHome;
   runtimeDetector;
   agentManager;
   connection;
@@ -7421,6 +7829,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));
@@ -7430,7 +7840,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,
@@ -7452,18 +7862,25 @@ 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;
     if (!this.options.localTrace) return false;
     return process.env.SLOCK_DAEMON_LOCAL_TRACE !== "0";
   }
+  resolveTraceJitter() {
+    const lockId = this.machineLock?.lockId;
+    return lockId ? computeTraceJitter(lockId) : NO_JITTER;
+  }
   installLocalTraceSink(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
+    const jitter = this.resolveTraceJitter();
     this.localTraceSink = new LocalRotatingTraceSink({
       machineDir,
       maxFileBytes: this.options.localTraceMaxFileBytes ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILE_BYTES", 5 * 1024 * 1024),
+      maxFileAgeMs: this.options.localTraceMaxFileAgeMs ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILE_AGE_MS", 5 * 60 * 1e3),
+      maxFileAgeJitterMs: jitter.maxFileAgeJitterMs,
       maxFiles: this.options.localTraceMaxFiles ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILES", 8)
     });
     this.tracer = new BasicTracer({
@@ -7474,20 +7891,27 @@ var DaemonCore = class {
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
     if (this.traceBundleUploader) return;
-    const workerUrl = process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL;
-    if (!workerUrl) return;
+    if (process.env.SLOCK_DAEMON_TRACE_UPLOAD_DISABLED === "1") return;
+    const workerUrl = process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL || DEFAULT_TRACE_UPLOAD_URL;
     this.traceBundleUploader = new DaemonTraceBundleUploader({
       machineDir,
       serverUrl: this.options.serverUrl,
       apiKey: this.options.apiKey,
       workerUrl,
       tracer: this.tracer,
-      currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null
+      currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null,
+      lockId: this.machineLock?.lockId
     });
     this.traceBundleUploader.start();
   }
   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,

package/dist/{chunk-Z3PCMYZO.js → chunk-B7XIMLOT.js}

@@ -207,6 +207,45 @@ async function executeResponseRequest(url, init, {
   }
 }
 
+// src/slockHome.ts
+import os from "os";
+import path from "path";
+import { existsSync } from "fs";
+var SLOCK_HOME_ENV = "SLOCK_HOME";
+function resolveDefaultSlockHome(homeDir = os.homedir()) {
+  return path.resolve(path.join(homeDir, ".slock"));
+}
+function resolveSlockHome(env = process.env, homeDir = os.homedir()) {
+  const raw = env[SLOCK_HOME_ENV]?.trim();
+  const root = raw && raw.length > 0 ? raw : resolveDefaultSlockHome(homeDir);
+  return path.resolve(root);
+}
+function resolveSlockHomePath(childPath, slockHome = resolveSlockHome()) {
+  return path.join(slockHome, childPath);
+}
+function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.homedir()) {
+  const defaultHome = resolveDefaultSlockHome(homeDir);
+  if (path.resolve(slockHome) === defaultHome) return [];
+  const candidates = [
+    {
+      path: path.join(defaultHome, "agents"),
+      destination: path.join(slockHome, "agents"),
+      description: "agent workspaces and per-agent runtime wrapper state"
+    },
+    {
+      path: path.join(defaultHome, "machines"),
+      destination: path.join(slockHome, "machines"),
+      description: "daemon machine locks, local traces, and machine-scoped state"
+    },
+    {
+      path: path.join(defaultHome, "attachments"),
+      destination: path.join(slockHome, "attachments"),
+      description: "chat bridge attachment download cache"
+    }
+  ];
+  return candidates.filter((candidate) => existsSync(candidate.path));
+}
+
 export {
   subscribeDaemonLogs,
   logger,
@@ -214,5 +253,9 @@ export {
   buildFetchDispatcher,
   DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
   executeJsonRequest,
-  executeResponseRequest
+  executeResponseRequest,
+  SLOCK_HOME_ENV,
+  resolveSlockHome,
+  resolveSlockHomePath,
+  listLegacySlockStatePaths
 };

package/dist/core.js

@@ -9,10 +9,10 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-XW57NR6Y.js";
+} from "./chunk-7EZVMA2D.js";
 import {
   subscribeDaemonLogs
-} from "./chunk-Z3PCMYZO.js";
+} from "./chunk-B7XIMLOT.js";
 export {
   DAEMON_CLI_USAGE,
   DaemonCore,

package/dist/index.js

@@ -3,8 +3,8 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-XW57NR6Y.js";
-import "./chunk-Z3PCMYZO.js";
+} from "./chunk-7EZVMA2D.js";
+import "./chunk-B7XIMLOT.js";
 
 // src/index.ts
 var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.46.1",
+  "version": "0.46.2-play.20260510065637",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"