@slock-ai/daemon 0.57.1 → 0.57.2-play.20260608142014

package/dist/{chunk-6RZCYFJP.js → chunk-JVPMCKSF.js}

@@ -351,40 +351,127 @@ var NoopActiveSpan = class {
   }
 };
 var noopTracer = new NoopTracer();
-function createScopedTracer(tracer, scopeAttrs) {
+function projectTraceScopeAttrs(scope) {
+  const attrs = {};
+  addOptionalStringAttr(attrs, "daemon_version", scope.resource?.daemonVersion);
+  addPresenceAttr(attrs, "daemon_version_present", scope.resource?.daemonVersion);
+  addOptionalStringAttr(attrs, "computer_version", scope.resource?.computerVersion);
+  addPresenceAttr(attrs, "computer_version_present", scope.resource?.computerVersion);
+  addOptionalStringAttr(attrs, "deployment_environment", scope.resource?.deploymentEnvironment);
+  addOptionalStringAttr(attrs, "service_revision", scope.resource?.serviceRevision);
+  addOptionalStringAttr(attrs, "request_id", scope.request?.requestId);
+  addPresenceAttr(attrs, "request_id_present", scope.request?.requestId);
+  addOptionalStringAttr(attrs, "route_pattern", scope.request?.routePattern);
+  addOptionalStringAttr(attrs, "method", scope.request?.method);
+  addOptionalStringAttr(attrs, "caller_kind", scope.request?.callerKind);
+  if (typeof scope.request?.userIdPresent === "boolean") {
+    attrs.user_id_present = scope.request.userIdPresent;
+  }
+  addOptionalStringAttr(attrs, "server_id", scope.actor?.serverId);
+  addPresenceAttr(attrs, "server_id_present", scope.actor?.serverId, scope.actor?.serverIdPresent);
+  addOptionalStringAttr(attrs, "machine_id", scope.actor?.machineId);
+  addPresenceAttr(attrs, "machine_id_present", scope.actor?.machineId, scope.actor?.machineIdPresent);
+  addOptionalStringAttr(attrs, "agent_id", scope.actor?.agentId);
+  addPresenceAttr(attrs, "agent_id_present", scope.actor?.agentId, scope.actor?.agentIdPresent);
+  addOptionalStringAttr(attrs, "launch_id", scope.actor?.launchId);
+  addPresenceAttr(attrs, "launch_id_present", scope.actor?.launchId, scope.actor?.launchIdPresent);
+  addOptionalStringAttr(attrs, "session_id", scope.actor?.sessionId);
+  addPresenceAttr(attrs, "session_id_present", scope.actor?.sessionId, scope.actor?.sessionIdPresent);
+  return attrs;
+}
+function createTraceScopeTracer(tracer, scope, options = {}) {
+  const scopedTracer = createScopedTracer(tracer, projectTraceScopeAttrs(scope), {
+    attrPrecedence: options.scopeAttrPrecedence
+  });
+  return options.spanAttrContracts ? createSpanAttrContractTracer(scopedTracer, options.spanAttrContracts) : scopedTracer;
+}
+function createScopedTracer(tracer, scopeAttrs, options = {}) {
   if (!Object.keys(scopeAttrs).length) return tracer;
-  return new ScopedTracer(tracer, scopeAttrs);
+  return new ScopedTracer(tracer, scopeAttrs, options.attrPrecedence ?? "scope");
 }
 var ScopedTracer = class {
-  constructor(tracer, scopeAttrs) {
+  constructor(tracer, scopeAttrs, attrPrecedence) {
     this.tracer = tracer;
     this.scopeAttrs = scopeAttrs;
+    this.attrPrecedence = attrPrecedence;
   }
   startSpan(name, options) {
     const span = this.tracer.startSpan(name, {
       ...options,
-      attrs: mergeAttrs(options.attrs, this.scopeAttrs)
+      attrs: this.mergeScopeAttrs(options.attrs)
     });
-    return new ScopedActiveSpan(span, this.scopeAttrs);
+    return new ScopedActiveSpan(span, this.scopeAttrs, this.attrPrecedence);
+  }
+  mergeScopeAttrs(attrs) {
+    return this.attrPrecedence === "caller" ? mergeAttrs(this.scopeAttrs, attrs) : mergeAttrs(attrs, this.scopeAttrs);
   }
 };
 var ScopedActiveSpan = class {
-  constructor(span, scopeAttrs) {
+  constructor(span, scopeAttrs, attrPrecedence) {
     this.span = span;
     this.scopeAttrs = scopeAttrs;
+    this.attrPrecedence = attrPrecedence;
     this.context = span.context;
   }
   context;
   addEvent(name, attrs) {
-    this.span.addEvent(name, mergeAttrs(attrs, this.scopeAttrs));
+    this.span.addEvent(name, this.mergeScopeAttrs(attrs));
   }
   end(status, options) {
     this.span.end(status, options ? {
       ...options,
-      attrs: mergeAttrs(options.attrs, this.scopeAttrs)
+      attrs: this.mergeScopeAttrs(options.attrs)
     } : void 0);
   }
+  mergeScopeAttrs(attrs) {
+    return this.attrPrecedence === "caller" ? mergeAttrs(this.scopeAttrs, attrs) : mergeAttrs(attrs, this.scopeAttrs);
+  }
+};
+function createSpanAttrContractTracer(tracer, contracts) {
+  if (!Object.keys(contracts).length) return tracer;
+  return new SpanAttrContractTracer(tracer, contracts);
+}
+var SpanAttrContractTracer = class {
+  constructor(tracer, contracts) {
+    this.tracer = tracer;
+    this.contracts = contracts;
+  }
+  startSpan(name, options) {
+    const contract = this.contracts[name];
+    if (!contract) return this.tracer.startSpan(name, options);
+    const span = this.tracer.startSpan(name, {
+      ...options,
+      attrs: filterTraceAttrs(options.attrs, contract.spanAttrs)
+    });
+    return new SpanAttrContractActiveSpan(span, contract);
+  }
 };
+var SpanAttrContractActiveSpan = class {
+  constructor(span, contract) {
+    this.span = span;
+    this.contract = contract;
+    this.context = span.context;
+  }
+  context;
+  addEvent(name, attrs) {
+    this.span.addEvent(name, filterTraceAttrs(attrs, this.contract.eventAttrs?.[name]));
+  }
+  end(status, options) {
+    this.span.end(status, options ? {
+      ...options,
+      attrs: filterTraceAttrs(options.attrs, this.contract.endAttrs)
+    } : void 0);
+  }
+};
+function filterTraceAttrs(attrs, allowedKeys) {
+  if (!attrs || !allowedKeys) return attrs;
+  const allowed = new Set(allowedKeys);
+  const filtered = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (allowed.has(key)) filtered[key] = value;
+  }
+  return Object.keys(filtered).length ? filtered : void 0;
+}
 var BasicTracer = class {
   sink;
   clock;
@@ -482,6 +569,14 @@ function mergeAttrs(base, extra) {
   if (!extra) return base;
   return { ...base, ...extra };
 }
+function addOptionalStringAttr(attrs, key, value) {
+  const normalized = value?.trim();
+  if (!normalized) return;
+  attrs[key] = normalized;
+}
+function addPresenceAttr(attrs, key, value, explicitPresent) {
+  attrs[key] = typeof explicitPresent === "boolean" ? explicitPresent : Boolean(value?.trim());
+}
 function generateTraceId() {
   return randomNonZeroHex(TRACE_ID_HEX_LENGTH);
 }
@@ -1046,6 +1141,9 @@ var SERVER_CAPABILITY_MATRIX = {
 
 // ../shared/src/index.ts
 var RUNTIME_CONFIG_VERSION = 1;
+var EXTERNAL_AGENT_RUNTIME_ID = "external";
+var EXTERNAL_AGENT_RUNTIME_MODEL = "external";
+var EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
@@ -1058,6 +1156,9 @@ var RUNTIMES = [
   { id: "pi", displayName: "Pi", binary: "pi", supported: true }
 ];
 var RUNTIME_MODELS = {
+  [EXTERNAL_AGENT_RUNTIME_ID]: [
+    { id: EXTERNAL_AGENT_RUNTIME_MODEL, label: EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME }
+  ],
   claude: [
     { id: "opus", label: "Claude Opus" },
     { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
@@ -1980,6 +2081,19 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
+// src/authEnv.ts
+var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
+var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
+function scrubDaemonAuthEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  return env;
+}
+function scrubDaemonChildEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  delete env[SLOCK_AGENT_TOKEN_ENV];
+  return env;
+}
+
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -3466,7 +3580,9 @@ var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_CREDENTIAL_KEY"
+  "SLOCK_AGENT_TOKEN",
+  "SLOCK_AGENT_CREDENTIAL_KEY",
+  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
 ];
 var cachedOpencliBinPath;
 function resolveOpencliBinPath() {
@@ -3681,7 +3797,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(opencliBinPath)} "
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  delete spawnEnv.SLOCK_AGENT_TOKEN;
+  scrubDaemonChildEnv(spawnEnv);
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -4110,7 +4226,7 @@ function resolveCommandOnWindows(command, env, execFileSyncFn, existsSyncFn) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync2;
   if (platform === "win32") {
@@ -4136,7 +4252,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -5490,11 +5606,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return withWindowsUserEnvironment({
+  return scrubDaemonChildEnv(withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps);
+  }, deps));
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -5550,7 +5666,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync4;
-  const env = deps.env ?? process.env;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const winPath = path6.win32;
   let geminiEntry = null;
   try {
@@ -5690,12 +5806,15 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync, existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import os3 from "os";
 import path7 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_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 {
@@ -5704,6 +5823,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 : path7.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 scrubDaemonChildEnv(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 = path7.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync3(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
+  };
+}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -5727,7 +5913,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 = "";
@@ -5753,21 +5957,23 @@ var KimiDriver = class {
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
       "--agent-file",
       agentFilePath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const launch = resolveKimiSpawn(args);
-    const proc = spawn7(launch.command, launch.args, {
+    const spawnTarget = resolveKimiSpawn(args);
+    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -5775,7 +5981,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: launch.shell
+      shell: spawnTarget.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -5889,14 +6095,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os3.homedir()) {
-  const configPath = path7.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;
@@ -6136,7 +6337,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
+    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -7381,16 +7582,19 @@ var RuntimeProgressState = class {
 };
 
 // src/runtimeNotificationState.ts
+function inboxNoticeMessageIdentity(message) {
+  const seq = typeof message.seq === "number" && Number.isFinite(message.seq) && message.seq > 0 ? Math.floor(message.seq) : null;
+  if (seq !== null) {
+    return `s:${seq}`;
+  }
+  const id = typeof message.message_id === "string" && message.message_id.length > 0 ? message.message_id : typeof message.id === "string" && message.id.length > 0 ? message.id : "";
+  return id.length > 0 ? `m:${id}` : "";
+}
 function computeInboxNoticeFingerprint(messages) {
   const keys = [];
   for (const m of messages) {
-    const seq = typeof m.seq === "number" && Number.isFinite(m.seq) && m.seq > 0 ? Math.floor(m.seq) : null;
-    if (seq !== null) {
-      keys.push(`s:${seq}`);
-      continue;
-    }
-    const id = typeof m.message_id === "string" && m.message_id.length > 0 ? m.message_id : typeof m.id === "string" && m.id.length > 0 ? m.id : "";
-    if (id.length > 0) keys.push(`m:${id}`);
+    const key = inboxNoticeMessageIdentity(m);
+    if (key.length > 0) keys.push(key);
   }
   if (keys.length === 0) return "";
   keys.sort();
@@ -7401,6 +7605,10 @@ var RuntimeNotificationState = class {
   pendingCountValue = 0;
   lastNoticeFingerprint = null;
   lastNoticeSessionId = null;
+  lastEncodeFailedFingerprint = null;
+  lastEncodeFailedSessionId = null;
+  contributedSessionId = null;
+  contributedIdentities = /* @__PURE__ */ new Set();
   get pendingCount() {
     return this.pendingCountValue;
   }
@@ -7443,13 +7651,63 @@ var RuntimeNotificationState = class {
     return this.lastNoticeFingerprint === fingerprint && this.lastNoticeSessionId === sessionId;
   }
   /** Register a fingerprint as written — call ONLY after a successful stdin write. */
-  recordNoticeWritten(fingerprint, sessionId) {
+  recordNoticeWritten(fingerprint, sessionId, messages = []) {
     this.lastNoticeFingerprint = fingerprint;
     this.lastNoticeSessionId = sessionId;
+    this.lastEncodeFailedFingerprint = null;
+    this.lastEncodeFailedSessionId = null;
+    this.ensureContributionSession(sessionId);
+    for (const message of messages) {
+      const identity = inboxNoticeMessageIdentity(message);
+      if (identity.length > 0) {
+        this.contributedIdentities.add(identity);
+      }
+    }
+  }
+  hasContributedMessage(message, sessionId) {
+    if (this.contributedSessionId !== sessionId) return false;
+    const identity = inboxNoticeMessageIdentity(message);
+    return identity.length > 0 && this.contributedIdentities.has(identity);
+  }
+  filterUncontributedMessages(messages, sessionId) {
+    if (this.contributedSessionId !== sessionId || this.contributedIdentities.size === 0) {
+      return [...messages];
+    }
+    return messages.filter((message) => {
+      const identity = inboxNoticeMessageIdentity(message);
+      return identity.length === 0 || !this.contributedIdentities.has(identity);
+    });
+  }
+  pruneContributedToPending(messages, sessionId) {
+    this.ensureContributionSession(sessionId);
+    if (this.contributedIdentities.size === 0) return;
+    const pending = /* @__PURE__ */ new Set();
+    for (const message of messages) {
+      const identity = inboxNoticeMessageIdentity(message);
+      if (identity.length > 0) pending.add(identity);
+    }
+    for (const identity of this.contributedIdentities) {
+      if (!pending.has(identity)) {
+        this.contributedIdentities.delete(identity);
+      }
+    }
+  }
+  isDuplicateEncodeFailedNotice(fingerprint, sessionId) {
+    if (fingerprint.length === 0) return false;
+    return this.lastEncodeFailedFingerprint === fingerprint && this.lastEncodeFailedSessionId === sessionId;
+  }
+  recordNoticeEncodeFailed(fingerprint, sessionId) {
+    if (fingerprint.length === 0) return;
+    this.lastEncodeFailedFingerprint = fingerprint;
+    this.lastEncodeFailedSessionId = sessionId;
   }
   clearNoticeFingerprint() {
     this.lastNoticeFingerprint = null;
     this.lastNoticeSessionId = null;
+    this.lastEncodeFailedFingerprint = null;
+    this.lastEncodeFailedSessionId = null;
+    this.contributedSessionId = null;
+    this.contributedIdentities.clear();
   }
   schedule(callback, delayMs) {
     if (this.timerValue) return false;
@@ -7462,6 +7720,11 @@ var RuntimeNotificationState = class {
     this.clearTimer();
     return count;
   }
+  ensureContributionSession(sessionId) {
+    if (this.contributedSessionId === sessionId) return;
+    this.contributedSessionId = sessionId;
+    this.contributedIdentities.clear();
+  }
 };
 
 // src/agentProcessManager.ts
@@ -8605,6 +8868,7 @@ var RUNTIME_TELEMETRY_RESERVED_ATTR_KEYS = /* @__PURE__ */ new Set([
   "sessionId",
   "turnId",
   "runtimeResultId",
+  "runtimeResultIdSource",
   "daemonVersion",
   "daemon_version",
   "daemon_version_present",
@@ -8780,13 +9044,33 @@ var AgentProcessManager = class _AgentProcessManager {
       this.sendStdinNotification(agentId);
     }, delayMs);
   }
+  flushPendingDirectStdinNotificationOnRuntimeProgress(agentId, ap, source) {
+    if (ap.notifications.pendingCount === 0) return false;
+    if (ap.isIdle) return false;
+    if (!ap.sessionId) return false;
+    if (!ap.driver.supportsStdinNotification) return false;
+    if (ap.runtime.descriptor.busyDelivery !== "direct") return false;
+    if (ap.gatedSteering.compacting) return false;
+    this.recordDaemonTrace("daemon.agent.stdin_notification.retry_signal", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      source,
+      mode: "busy",
+      pending_notification_count: ap.notifications.pendingCount,
+      inbox_count: ap.inbox.length,
+      session_id_present: true
+    });
+    return this.sendStdinNotification(agentId, { forceUnsupportedRetry: true });
+  }
   clearRuntimeErrorDeliveryBackoff(ap) {
     if (ap.runtimeErrorDeliveryBackoff.timer) {
       clearTimeout(ap.runtimeErrorDeliveryBackoff.timer);
     }
     ap.runtimeErrorDeliveryBackoff = createRuntimeErrorDeliveryBackoffState();
   }
-  clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, eventKind) {
+  clearRuntimeErrorDeliveryBackoffWithTrace(agentId, ap, resetSource) {
     if (ap.runtimeErrorDeliveryBackoff.attempts === 0 && ap.runtimeErrorDeliveryBackoff.untilMs === 0) return;
     const attempts = ap.runtimeErrorDeliveryBackoff.attempts;
     const reason = ap.runtimeErrorDeliveryBackoff.reason;
@@ -8798,9 +9082,12 @@ var AgentProcessManager = class _AgentProcessManager {
       launchId: ap.launchId || void 0,
       reason: reason || void 0,
       attempts,
-      reset_source: eventKind
+      reset_source: resetSource
     });
   }
+  clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, eventKind) {
+    this.clearRuntimeErrorDeliveryBackoffWithTrace(agentId, ap, eventKind);
+  }
   runtimeErrorDeliveryBackoffRemainingMs(ap) {
     return Math.max(0, ap.runtimeErrorDeliveryBackoff.untilMs - Date.now());
   }
@@ -8828,8 +9115,10 @@ var AgentProcessManager = class _AgentProcessManager {
         return "provider_connection_error";
       case "ProviderStreamError":
         return "provider_stream_error";
-      default:
+      case "TimeoutError":
         return null;
+      default:
+        return "runtime_error";
     }
   }
   noteRuntimeErrorDeliveryBackoff(agentId, ap, message, terminalFailure, stickyTerminalFailure, reasonOverride) {
@@ -8900,9 +9189,24 @@ var AgentProcessManager = class _AgentProcessManager {
     if (ap.inbox.length === 0) return false;
     const reason = ap.runtimeErrorDeliveryBackoff.reason || "runtime_error_backoff";
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
-      const messages = [...ap.inbox];
+      ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+      const messages = ap.notifications.filterUncontributedMessages(ap.inbox, ap.sessionId);
       ap.notifications.clearPending();
       ap.notifications.clearTimer();
+      if (messages.length === 0) {
+        this.recordDaemonTrace("daemon.agent.runtime_error_delivery_backoff.flush", {
+          agentId,
+          runtime: ap.config.runtime,
+          model: ap.config.model,
+          launchId: ap.launchId || void 0,
+          reason,
+          mode: "idle",
+          outcome: "suppressed_already_contributed",
+          inbox_count: ap.inbox.length,
+          messages_count: 0
+        });
+        return false;
+      }
       this.commitApmIdleState(agentId, ap, false);
       this.startRuntimeTrace(agentId, ap, "runtime-error-backoff-idle-delivery", messages);
       this.broadcastActivity(agentId, "working", "Message received");
@@ -9583,6 +9887,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         runtimeProgress: new RuntimeProgressState(Date.now()),
         runtimeTraceSpan: null,
         runtimeTraceCounters: createRuntimeTraceCounters(),
+        runtimeTelemetryResultSeq: 0,
         lastActivity: "",
         lastActivityDetail: "",
         recentStdout: [],
@@ -10135,6 +10440,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     this.agents.delete(agentId);
     if (!silent) {
       this.activityClientSeqByAgent.delete(agentId);
+      this.agentVisibleBoundaries.delete(agentId);
+      this.agentVisibleMessageIds.delete(agentId);
     }
     this.runtimeExitTraceAttrs.set(ap.runtime, {
       stop_source: silent ? "daemon_internal" : "explicit_request",
@@ -10358,6 +10665,25 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         }));
         return true;
       }
+      ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+      const noticeFingerprint = computeInboxNoticeFingerprint([message]);
+      const messageAlreadyPending = noticeFingerprint.length > 0 && ap.inbox.some((pending) => computeInboxNoticeFingerprint([pending]) === noticeFingerprint);
+      const messageAlreadyContributed = ap.notifications.hasContributedMessage(message, ap.sessionId);
+      if (messageAlreadyPending && (messageAlreadyContributed || ap.notifications.isDuplicateNotice(noticeFingerprint, ap.sessionId))) {
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "suppressed_duplicate_stdin_idle_delivery",
+          accepted: true,
+          process_present: true,
+          runtime: ap.config.runtime,
+          session_id_present: true,
+          launchId: ap.launchId || void 0,
+          is_idle: ap.isIdle,
+          inbox_count: ap.inbox.length,
+          pending_notification_count: ap.notifications.pendingCount
+        }));
+        logger.info(`[Agent ${agentId}] Suppressing duplicate idle stdin inbox update (unread-set unchanged since last write); pending=${ap.inbox.length}`);
+        return true;
+      }
       ap.inbox.push(message);
       const nextMessages = [...ap.inbox];
       this.commitApmIdleState(agentId, ap, false);
@@ -11226,6 +11552,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       if (row.flags.includes("task")) taskTargetCount += 1;
     }
     return {
+      target_count: rows.length,
+      changed_target_count: rows.length,
       inbox_target_count: rows.length,
       pending_message_count: pendingMessageCount,
       max_pending_per_target: maxPendingCount,
@@ -11399,7 +11727,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           return false;
         }
         const messages = [...ap.inbox];
-        ap.notifications.clear();
+        ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+        ap.notifications.clearPending();
+        ap.notifications.clearTimer();
         if (messages.length === 0) {
           this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
             outcome: "empty",
@@ -11415,12 +11745,23 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             messageCount: messages.length
           });
         }
-        this.broadcastActivity(agentId, "working", "Message received");
         const runtimeProfileMessages = messages.filter((message) => runtimeProfileNotificationFromMessage(message));
-        const ordinaryMessages = messages.filter((message) => !runtimeProfileNotificationFromMessage(message));
+        const ordinaryMessageCandidates = messages.filter((message) => !runtimeProfileNotificationFromMessage(message));
+        const ordinaryMessages = ap.notifications.filterUncontributedMessages(
+          ordinaryMessageCandidates,
+          ap.sessionId
+        );
+        if (runtimeProfileMessages.length === 0 && ordinaryMessages.length === 0) {
+          this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
+            outcome: "suppressed_already_contributed",
+            delivered_messages_count: 0
+          });
+          return false;
+        }
+        this.broadcastActivity(agentId, "working", "Message received");
         let accepted = true;
         if (runtimeProfileMessages.length > 0) {
-          ap.inbox.splice(0, ap.inbox.length, ...ordinaryMessages);
+          ap.inbox.splice(0, ap.inbox.length, ...ordinaryMessageCandidates);
           accepted = this.deliverMessagesViaStdin(agentId, ap, runtimeProfileMessages, effect.stdinMode);
         }
         if (ordinaryMessages.length > 0) {
@@ -11434,7 +11775,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         }
         this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
           outcome: accepted ? "written" : "not_written",
-          delivered_messages_count: messages.length
+          delivered_messages_count: runtimeProfileMessages.length + ordinaryMessages.length
         });
         return accepted;
       }
@@ -11666,6 +12007,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "thinking" });
+          this.flushPendingDirectStdinNotificationOnRuntimeProgress(agentId, ap, event.kind);
         }
         break;
       }
@@ -11676,6 +12018,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "text" });
+          this.flushPendingDirectStdinNotificationOnRuntimeProgress(agentId, ap, event.kind);
         }
         break;
       }
@@ -11748,6 +12091,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (ap) {
           if (event.sessionId) ap.sessionId = event.sessionId;
           const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
+          if (!stickyTerminalFailure && ap.runtimeErrorDeliveryBackoff.reason === "runtime_error") {
+            this.clearRuntimeErrorDeliveryBackoffWithTrace(agentId, ap, "turn_end_unclassified_runtime_error");
+          }
           const reduction = reduceApmGatedTurnEnd(ap.gatedSteering, {
             inboxLength: stickyTerminalFailure ? 0 : ap.inbox.length,
             supportsStdinNotification: ap.driver.supportsStdinNotification,
@@ -11879,7 +12225,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   recordRuntimeTelemetry(agentId, ap, event) {
-    const sessionId = ap.driver.currentSessionId ?? event.sessionId;
+    const sessionId = ap.driver.currentSessionId ?? event.sessionId ?? ap.sessionId ?? ap.config.sessionId;
+    const resultIdentity = this.runtimeTelemetryResultIdentity(agentId, ap, event);
     const payloadAttrs = sanitizeRuntimeTelemetryPayloadAttrs(event.attrs);
     const versionAttrs = this.runtimeTelemetryVersionAttrs();
     const telemetryAttrs = {
@@ -11889,7 +12236,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       ...event.usageKind ? { usageKind: event.usageKind } : {},
       ...sessionId ? { sessionId } : {},
       ...event.turnId ? { turnId: event.turnId } : {},
-      ...event.runtimeResultId ? { runtimeResultId: event.runtimeResultId } : {}
+      ...resultIdentity
     };
     const attrs = {
       agentId,
@@ -11902,6 +12249,16 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     ap.runtimeTraceSpan?.addEvent(`runtime.telemetry.${event.name}`, telemetryAttrs);
     this.recordDaemonTrace(`daemon.runtime.telemetry.${event.name}`, attrs);
   }
+  runtimeTelemetryResultIdentity(agentId, ap, event) {
+    if (event.runtimeResultId) return { runtimeResultId: event.runtimeResultId };
+    if (event.name !== "token_usage" || event.source !== "claude_result_usage") return {};
+    const sequence = ++ap.runtimeTelemetryResultSeq;
+    const scope = ap.launchId || agentId;
+    return {
+      runtimeResultId: `${scope}:claude_result_usage:${sequence}`,
+      runtimeResultIdSource: "daemon_sequence"
+    };
+  }
   runtimeTelemetryVersionAttrs() {
     return {
       ...this.daemonVersion ? {
@@ -11970,7 +12327,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   /** Send a batched notification to the agent via stdin about pending messages */
-  sendStdinNotification(agentId) {
+  sendStdinNotification(agentId, options = {}) {
     const ap = this.agents.get(agentId);
     if (!ap) return false;
     const count = ap.notifications.takePendingAndClearTimer();
@@ -12012,7 +12369,24 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const inboxCount = ap.inbox.length;
     if (inboxCount === 0) return false;
-    const changedMessages = ap.inbox.slice(Math.max(0, ap.inbox.length - count));
+    ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+    const changedMessageCandidates = ap.inbox.slice(Math.max(0, ap.inbox.length - count));
+    const changedMessages = ap.notifications.filterUncontributedMessages(changedMessageCandidates, ap.sessionId);
+    if (changedMessages.length === 0) {
+      this.recordDaemonTrace("daemon.agent.stdin_notification", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        outcome: "suppressed_already_contributed",
+        mode: "busy",
+        pending_notification_count: count,
+        inbox_count: ap.inbox.length,
+        session_id_present: true
+      });
+      logger.info(`[Agent ${agentId}] Suppressing stdin inbox notice because all candidate messages already contributed; pending=${ap.inbox.length}`);
+      return false;
+    }
     const noticeFingerprint = computeInboxNoticeFingerprint(changedMessages);
     if (ap.notifications.isDuplicateNotice(noticeFingerprint, ap.sessionId)) {
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
@@ -12029,6 +12403,22 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       logger.info(`[Agent ${agentId}] Suppressing duplicate stdin inbox notice (unread-set unchanged since last write); pending=${ap.inbox.length}`);
       return false;
     }
+    if (!options.forceUnsupportedRetry && ap.notifications.isDuplicateEncodeFailedNotice(noticeFingerprint, ap.sessionId)) {
+      ap.notifications.add(count);
+      this.recordDaemonTrace("daemon.agent.stdin_notification", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        outcome: "suppressed_duplicate_encode_failed",
+        mode: "busy",
+        pending_notification_count: count,
+        inbox_count: ap.inbox.length,
+        session_id_present: true
+      });
+      logger.info(`[Agent ${agentId}] Suppressing duplicate unsupported stdin inbox notice (unread-set unchanged since last encode failure); pending=${ap.inbox.length}`);
+      return false;
+    }
     const inboxRows = projectAgentInboxSnapshot(changedMessages);
     const notification = `[Slock inbox notice:
 ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
@@ -12051,6 +12441,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
         model: ap.config.model,
         launchId: ap.launchId || void 0,
         mode: "busy",
+        source: "busy_stdin_notification",
         notification_byte_count: notificationByteCount,
         ...projectionAttrs
       });
@@ -12066,12 +12457,15 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
         inbox_target_count: inboxRows.length,
         session_id_present: true
       });
-      ap.notifications.recordNoticeWritten(noticeFingerprint, ap.sessionId);
+      ap.notifications.recordNoticeWritten(noticeFingerprint, ap.sessionId, changedMessages);
       return true;
     } else {
       ap.notifications.add(count);
-      const retryScheduled = ap.runtime.descriptor.busyDelivery === "direct" ? this.scheduleStdinNotification(agentId, ap, this.stdinNotificationRetryMs) : false;
+      const retryScheduled = ap.runtime.descriptor.busyDelivery === "direct" && sendResult.reason !== "unsupported" ? this.scheduleStdinNotification(agentId, ap, this.stdinNotificationRetryMs) : false;
       const outcome = runtimeSendFailureOutcome(sendResult);
+      if (outcome === "encode_failed") {
+        ap.notifications.recordNoticeEncodeFailed(noticeFingerprint, ap.sessionId);
+      }
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
@@ -12113,6 +12507,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       model: ap.config.model,
       launchId: ap.launchId || void 0,
       mode,
+      source,
       notification_byte_count: Buffer.byteLength(renderedInput, "utf8"),
       cursors_advanced: "none",
       ...projectionAttrs
@@ -12191,6 +12586,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       stdin_write_attempted: true,
       cursors_advanced: "none"
     });
+    ap.notifications.recordNoticeWritten(computeInboxNoticeFingerprint(messages), ap.sessionId, messages);
     return true;
   }
   /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
@@ -12407,7 +12803,7 @@ var DaemonConnection = class {
       logger.warn(`[Daemon] Dropping outbound message while disconnected: ${msg.type}`);
     }
     this.trace("daemon.connection.outbound_dropped", {
-      message_type: msg.type,
+      outbound_message_kind: msg.type,
       ws_ready_state: this.ws?.readyState ?? null
     });
   }
@@ -12456,7 +12852,7 @@ var DaemonConnection = class {
         this.resetWatchdog();
         if (messageKind !== "ping") {
           this.trace("daemon.connection.inbound_received", {
-            message_type: messageKind,
+            inbound_message_kind: messageKind,
             last_inbound_age_ms_bucket: "0"
           });
         }
@@ -12547,7 +12943,7 @@ var DaemonConnection = class {
     if (msg.launchId && latestLaunchId && msg.launchId !== latestLaunchId) {
       this.trace("daemon.connection.pending_activity_invalidated", {
         reason: "launch_changed",
-        message_type: msg.type,
+        outbound_message_kind: msg.type,
         agentId: msg.agentId,
         stale_launch_id_present: true,
         next_launch_id_present: true
@@ -12567,7 +12963,7 @@ var DaemonConnection = class {
     this.pendingActivityByAgent.delete(identity.agentId);
     this.trace("daemon.connection.pending_activity_invalidated", {
       reason: "launch_changed",
-      message_type: msg.type,
+      outbound_message_kind: msg.type,
       agentId: identity.agentId,
       stale_launch_id_present: Boolean(pending.launchId),
       next_launch_id_present: true
@@ -12596,7 +12992,7 @@ var DaemonConnection = class {
       ws.send(JSON.stringify(msg));
     }
     this.trace("daemon.connection.outbound_replayed", {
-      message_type: "agent:activity",
+      outbound_message_kind: "agent:activity",
       message_count: pending.length
     });
   }
@@ -13422,7 +13818,52 @@ var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"];
 var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS2 = 3;
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2 = 250;
-var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
+var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
+  "daemon.lifecycle.start": {
+    spanAttrs: ["machine_dir_present", "local_trace_enabled"],
+    eventAttrs: {
+      "daemon.machine_lock.acquired": ["machine_dir_present"]
+    }
+  },
+  "daemon.lifecycle.stop": {
+    spanAttrs: ["machine_lock_present"]
+  },
+  "daemon.runner_credential_mint.retry": {
+    spanAttrs: ["agentId", "runtime", "attempt", "max_attempts", "status", "code", "reason", "retryable"]
+  },
+  "daemon.runner_credential_mint.failed": {
+    spanAttrs: ["agentId", "runtime", "status", "code", "reason", "retryable", "max_attempts"]
+  },
+  "daemon.agent.spawn.failed": {
+    spanAttrs: ["agentId", "launchId", "runtime", "model", "failure_reason", "failure_detail", "session_id_present"]
+  },
+  "daemon.agent.delivery": {
+    spanAttrs: ["agentId", "deliveryId", "delivery_correlation_id", "messageId", "message_id_present", "seq"],
+    eventAttrs: {
+      "daemon.receive": ["seq", "deliveryId"],
+      "daemon.deliver_to_agent_manager": ["accepted"],
+      "daemon.ack.sent": ["seq"]
+    },
+    endAttrs: ["outcome", "ackSeq", "deliveryId", "error_class"]
+  },
+  "daemon.runtime_profile.control.received": {
+    spanAttrs: ["agentId", "control_kind", "key_present", "launchId"],
+    endAttrs: ["outcome", "error_class"]
+  },
+  "daemon.computer_control.received": {
+    spanAttrs: ["action", "handled"]
+  },
+  "daemon.ready.sent": {
+    spanAttrs: ["runtimes_count", "running_agents_count", "idle_agents_count", "runtime_profile_reports_count"]
+  },
+  "daemon.runtime_profile.report.sent": {
+    spanAttrs: ["agentId", "launchId", "runtime", "report_source", "model_present", "session_ref_present", "workspace_ref_present"]
+  },
+  "daemon.connection.local_disconnect_observed": {
+    spanAttrs: ["running_agents_count", "idle_agents_count"]
+  }
+};
+var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -13458,9 +13899,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args) {
+function parseDaemonCliArgs(args, env = {}) {
   let serverUrl = "";
-  let apiKey = "";
+  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -13629,6 +14070,8 @@ var DaemonCore = class {
   tracer;
   injectedTracer;
   machineLock = null;
+  observedServerId = null;
+  observedMachineId = null;
   localTraceSink = null;
   traceBundleUploader = null;
   constructor(options) {
@@ -13679,6 +14122,7 @@ var DaemonCore = class {
     return process.env.SLOCK_DAEMON_LOCAL_TRACE !== "0";
   }
   resolveTraceJitter() {
+    if (process.env.SLOCK_DAEMON_TRACE_JITTER_DISABLED === "1") return NO_JITTER;
     const lockId = this.machineLock?.lockId;
     return lockId ? computeTraceJitter(lockId) : NO_JITTER;
   }
@@ -13710,7 +14154,7 @@ var DaemonCore = class {
       workerUrl,
       tracer: this.tracer,
       currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null,
-      lockId: this.machineLock?.lockId
+      jitter: this.resolveTraceJitter()
     });
     this.traceBundleUploader.start();
   }
@@ -13789,22 +14233,29 @@ var DaemonCore = class {
     span.end(status);
   }
   withDaemonTraceScope(tracer) {
-    return createScopedTracer(tracer, this.daemonTraceScopeAttrs());
+    return {
+      startSpan: (name, options) => createTraceScopeTracer(tracer, this.daemonTraceScope(), {
+        spanAttrContracts: DAEMON_CORE_TRACE_ATTR_CONTRACTS
+      }).startSpan(name, options)
+    };
   }
-  daemonTraceScopeAttrs() {
+  daemonTraceScope() {
     return {
-      daemonVersion: this.daemonVersion,
-      daemon_version: this.daemonVersion,
-      daemon_version_present: Boolean(this.daemonVersion),
-      ...this.computerVersion ? {
-        computerVersion: this.computerVersion,
-        computer_version: this.computerVersion,
-        computer_version_present: true
-      } : {
-        computer_version_present: false
+      resource: {
+        daemonVersion: this.daemonVersion,
+        computerVersion: this.computerVersion
+      },
+      actor: {
+        serverId: this.observedServerId,
+        machineId: this.observedMachineId
       }
     };
   }
+  observeRuntimeContext(config) {
+    const ctx = config.runtimeContext;
+    if (ctx?.serverId) this.observedServerId = ctx.serverId;
+    if (ctx?.machineId) this.observedMachineId = ctx.machineId;
+  }
   async requestRunnerCredentialOnce(agentId, config) {
     const url = new URL(`/internal/computer/runners/${encodeURIComponent(agentId)}/credentials`, this.options.serverUrl);
     const res = await daemonFetch(url, {
@@ -13896,6 +14347,7 @@ var DaemonCore = class {
     );
   }
   async startAgentFromMessage(msg) {
+    this.observeRuntimeContext(msg.config);
     const agentCredential = await this.mintRunnerCredential(msg.agentId, msg.config);
     const config = { ...msg.config, agentCredentialKey: agentCredential.apiKey, agentCredentialId: agentCredential.credentialId };
     await this.agentManager.startAgent(
@@ -13913,6 +14365,7 @@ var DaemonCore = class {
     logger.info(`[Daemon] Received ${msg.type}${summary ? ` ${summary}` : ""}`);
     switch (msg.type) {
       case "agent:start":
+        this.observeRuntimeContext(msg.config);
         logger.info(`[Agent ${msg.agentId}] Start requested (runtime=${msg.config.runtime}, model=${msg.config.model}, session=${msg.config.sessionId || "new"}${msg.wakeMessage ? ", wake=true" : ""})`);
         this.startAgentFromMessage(msg).catch((err) => {
           const classification = classifySpawnFailure(err);
@@ -14229,6 +14682,8 @@ var DaemonCore = class {
 };
 
 export {
+  DAEMON_API_KEY_ENV,
+  scrubDaemonAuthEnv,
   subscribeDaemonLogs,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,

package/dist/cli/index.js

@@ -860,11 +860,17 @@ async function runDeviceCodeLogin(options) {
   const pollIntervalMs = options.pollIntervalOverrideMs ?? serverIntervalMs;
   const deadlineMs = Date.now() + Math.max(1, authorizeBody.expiresIn ?? 600) * 1e3;
   while (Date.now() < deadlineMs) {
-    const tokenRes = await httpFetch(`${base}/api/auth/device/token`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ deviceCode: authorizeBody.deviceCode })
-    });
+    let tokenRes;
+    try {
+      tokenRes = await httpFetch(`${base}/api/auth/device/token`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ deviceCode: authorizeBody.deviceCode })
+      });
+    } catch {
+      await delay(pollIntervalMs);
+      continue;
+    }
     if (tokenRes.ok) {
       const tokenBody = await tokenRes.json();
       if (!tokenBody.accessToken || !tokenBody.refreshToken || !tokenBody.userId) {
@@ -15249,6 +15255,12 @@ var SERVER_CAPABILITY_MATRIX = {
 };
 
 // ../shared/src/index.ts
+var EXTERNAL_AGENT_RUNTIME_ID = "external";
+var EXTERNAL_AGENT_RUNTIME_MODEL = "external";
+var EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
+function isExternalAgentRuntime(runtime) {
+  return runtime === EXTERNAL_AGENT_RUNTIME_ID;
+}
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
@@ -15261,8 +15273,71 @@ var RUNTIMES = [
   { id: "pi", displayName: "Pi", binary: "pi", supported: true }
 ];
 function getRuntimeDisplayName(id) {
+  if (isExternalAgentRuntime(id)) return EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME;
   return RUNTIMES.find((r) => r.id === id)?.displayName ?? id;
 }
+var RUNTIME_MODELS = {
+  [EXTERNAL_AGENT_RUNTIME_ID]: [
+    { id: EXTERNAL_AGENT_RUNTIME_MODEL, label: EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME }
+  ],
+  claude: [
+    { id: "opus", label: "Claude Opus" },
+    { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
+    { id: "claude-opus-4-7", label: "Claude Opus 4.7" },
+    { id: "claude-opus-4-6", label: "Claude Opus 4.6" },
+    { id: "sonnet", label: "Claude Sonnet" },
+    { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+    { id: "haiku", label: "Claude Haiku" },
+    { id: "claude-haiku-4-5", label: "Claude Haiku 4.5" }
+  ],
+  codex: [
+    { id: "gpt-5.5", label: "GPT-5.5" },
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
+    { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark" },
+    { id: "gpt-5.2-codex", label: "GPT-5.2 Codex" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max" },
+    { id: "gpt-5.1-codex", label: "GPT-5.1 Codex" },
+    { id: "gpt-5-codex", label: "GPT-5 Codex" },
+    { id: "gpt-5", label: "GPT-5" }
+  ],
+  antigravity: [
+    { id: "default", label: "AGY configured default", verified: "suggestion_only" }
+  ],
+  copilot: [
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "claude-4-sonnet", label: "Claude 4 Sonnet" },
+    { id: "claude-4.5-sonnet", label: "Claude 4.5 Sonnet" }
+  ],
+  cursor: [
+    { id: "composer-2-fast", label: "Composer 2 Fast" },
+    { id: "composer-2", label: "Composer 2" },
+    { id: "auto", label: "Auto" }
+  ],
+  gemini: [
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" },
+    { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (Preview)" },
+    { id: "gemini-3-flash-preview", label: "Gemini 3 Flash (Preview)" },
+    { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+    { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }
+  ],
+  opencode: [
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" },
+    { id: "deepseek/deepseek-v4-pro", label: "DeepSeek V4 Pro (OpenCode)", verified: "suggestion_only" },
+    { id: "openrouter/anthropic/claude-opus-4.5", label: "Claude Opus 4.5 via OpenRouter", verified: "suggestion_only" },
+    { id: "fusecode/opus[1m]", label: "Opus 1M via FuseCode", verified: "suggestion_only" }
+  ],
+  pi: [
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" }
+  ],
+  // Kimi CLI resolves model keys from each user's local config, so the safest
+  // built-in option is to defer to whatever default model the CLI already uses.
+  kimi: [
+    { id: "default", label: "Configured Default" }
+  ]
+};
 var PLAN_CONFIG = {
   free: {
     displayName: "Hobby",

package/dist/core.js

@@ -1,4 +1,5 @@
 import {
+  DAEMON_API_KEY_ENV,
   DAEMON_CLI_USAGE,
   DaemonCore,
   deleteWorkspaceDirectory,
@@ -8,9 +9,11 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
+  scrubDaemonAuthEnv,
   subscribeDaemonLogs
-} from "./chunk-6RZCYFJP.js";
+} from "./chunk-JVPMCKSF.js";
 export {
+  DAEMON_API_KEY_ENV,
   DAEMON_CLI_USAGE,
   DaemonCore,
   deleteWorkspaceDirectory,
@@ -20,5 +23,6 @@ export {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
+  scrubDaemonAuthEnv,
   subscribeDaemonLogs
 };

package/dist/drivers/piSdkRunner.js

@@ -0,0 +1,96 @@
+// src/drivers/piSdkRunner.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import {
+  AuthStorage,
+  createAgentSessionFromServices,
+  createAgentSessionServices,
+  SessionManager
+} from "@earendil-works/pi-coding-agent";
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+function parseArgs(argv) {
+  const index = argv.indexOf("--config");
+  const configPath = index >= 0 ? argv[index + 1] : void 0;
+  if (!configPath) throw new Error("Missing --config <path>");
+  return { configPath };
+}
+function resolveConfiguredModel(modelId, modelRegistry) {
+  if (!modelId) return void 0;
+  const [provider, ...rest] = modelId.split("/");
+  const providerScopedId = rest.join("/");
+  if (provider && providerScopedId) {
+    const exact = modelRegistry.find(provider, providerScopedId);
+    if (exact) return exact;
+  }
+  return modelRegistry.getAll().find(
+    (model) => model.id === modelId || `${model.provider}/${model.id}` === modelId || (providerScopedId ? model.id === providerScopedId : false)
+  );
+}
+async function createSessionManager(config) {
+  if (!config.sessionId) return SessionManager.create(config.cwd, config.sessionDir);
+  const localSessions = await SessionManager.list(config.cwd, config.sessionDir);
+  const match = localSessions.find((session) => session.id.startsWith(config.sessionId));
+  if (match) return SessionManager.open(match.path, config.sessionDir);
+  return SessionManager.create(config.cwd, config.sessionDir);
+}
+async function run() {
+  const { configPath } = parseArgs(process.argv.slice(2));
+  const config = JSON.parse(await readFile(configPath, "utf8"));
+  const authStorage = AuthStorage.create(path.join(config.agentDir, "auth.json"));
+  const services = await createAgentSessionServices({
+    cwd: config.cwd,
+    agentDir: config.agentDir,
+    authStorage,
+    resourceLoaderOptions: {
+      appendSystemPrompt: [config.standingPrompt],
+      noContextFiles: true,
+      noExtensions: true,
+      noPromptTemplates: true,
+      noSkills: true,
+      noThemes: true
+    }
+  });
+  for (const diagnostic of services.diagnostics) {
+    const line = `[Pi SDK] ${diagnostic.type}: ${diagnostic.message}`;
+    if (diagnostic.type === "error") throw new Error(line);
+    process.stderr.write(`${line}
+`);
+  }
+  const sessionManager = await createSessionManager(config);
+  const model = resolveConfiguredModel(config.model, services.modelRegistry);
+  if (config.model && !model) {
+    throw new Error(`Configured Pi model '${config.model}' was not found in Pi model registry.`);
+  }
+  const { session } = await createAgentSessionFromServices({
+    services,
+    sessionManager,
+    model
+  });
+  const header = session.sessionManager.getHeader();
+  if (header) writeJson(header);
+  const unsubscribe = session.subscribe((event) => writeJson(event));
+  try {
+    await session.prompt(config.prompt);
+  } finally {
+    unsubscribe();
+    session.dispose();
+    await services.settingsManager.flush();
+  }
+}
+run().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  writeJson({
+    type: "message_end",
+    message: {
+      role: "assistant",
+      content: [],
+      stopReason: "error",
+      errorMessage: message
+    }
+  });
+  writeJson({ type: "turn_end" });
+  process.exitCode = 1;
+});

package/dist/index.js

@@ -2,11 +2,13 @@
 import {
   DAEMON_CLI_USAGE,
   DaemonCore,
-  parseDaemonCliArgs
-} from "./chunk-6RZCYFJP.js";
+  parseDaemonCliArgs,
+  scrubDaemonAuthEnv
+} from "./chunk-JVPMCKSF.js";
 
 // src/index.ts
-var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));
+var parsedArgs = parseDaemonCliArgs(process.argv.slice(2), process.env);
+scrubDaemonAuthEnv(process.env);
 if (!parsedArgs) {
   console.error(DAEMON_CLI_USAGE);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.57.1",
+  "version": "0.57.2-play.20260608142014",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"