@botiverse/raft-daemon 0.63.5-play.20260623160336 → 0.63.6

package/dist/{chunk-A2AHKVS2.js → chunk-DUWRNQQE.js}

@@ -2683,19 +2683,6 @@ 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";
@@ -3535,6 +3522,7 @@ function latestVisibleMessages(messages, limit) {
   return sorted.slice(Math.max(0, sorted.length - limit));
 }
 function isMessageModelSeen(input, message) {
+  if (messageSenderId(message) === input.agentId) return true;
   const seq = Math.floor(messageSeq(message));
   if (Number.isFinite(seq) && seq > 0 && typeof input.modelSeenSeq === "number" && input.modelSeenSeq >= seq) return true;
   return input.isMessageModelSeen?.({ target: input.target, message }) === true;
@@ -4262,9 +4250,7 @@ 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_TOKEN",
-  "SLOCK_AGENT_CREDENTIAL_KEY",
-  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
+  "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
 var WORKSPACE_CLI_TRANSPORT_FILENAMES = [
   "agent-token",
@@ -4616,7 +4602,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     SLOCK_SERVER_URL: ctx.config.serverUrl,
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  scrubDaemonChildEnv(spawnEnv);
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -5138,7 +5124,7 @@ function requiresWindowsShell(command, platform = process.platform) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   if (platform === "win32") {
@@ -5164,7 +5150,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -7244,11 +7230,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return scrubDaemonChildEnv(withWindowsUserEnvironment({
+  return withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps));
+  }, deps);
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -7304,7 +7290,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
+  const env = deps.env ?? process.env;
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -7441,15 +7427,12 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import os4 from "os";
 import path9 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 {
@@ -7458,73 +7441,6 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
-function readKimiConfigSource(home = os4.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 : path9.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 ?? os4.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 = path9.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",
@@ -7548,25 +7464,7 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    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
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
@@ -7590,23 +7488,21 @@ 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,
-      ...launch.args
+      this.sessionId
     ];
     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 spawnTarget = resolveKimiSpawn(args);
-    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
+    const launch = resolveKimiSpawn(args);
+    const proc = spawn7(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -7614,7 +7510,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: spawnTarget.shell
+      shell: launch.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -7727,9 +7623,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os4.homedir()) {
+  const configPath = path9.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -8395,7 +8296,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -10440,6 +10341,7 @@ var STDIN_NOTIFICATION_INITIAL_DELAY_MS = 3e3;
 var STDIN_NOTIFICATION_RETRY_DELAY_MS = 15e3;
 var RUNTIME_ERROR_DELIVERY_BACKOFF_BASE_MS = 1e4;
 var RUNTIME_ERROR_DELIVERY_BACKOFF_MAX_MS = 5 * 6e4;
+var RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD = 3;
 var SPAWN_FAIL_BACKOFF_BASE_MS = 1e3;
 var SPAWN_FAIL_BACKOFF_MAX_MS = 3e4;
 var SPAWN_FAIL_BACKOFF_THRESHOLD = 3;
@@ -11349,6 +11251,7 @@ var AgentProcessManager = class _AgentProcessManager {
   agentStartIntervalMs;
   startingInboxes = /* @__PURE__ */ new Map();
   terminalRuntimeFailures = /* @__PURE__ */ new Map();
+  runtimeErrorFingerprintFences = /* @__PURE__ */ new Map();
   pendingStartRebinds = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
@@ -11515,6 +11418,94 @@ var AgentProcessManager = class _AgentProcessManager {
     if (state.timer) clearTimeout(state.timer);
     this.agentSpawnFailBackoff.delete(agentId);
   }
+  // ----- RUNTIME-ERROR FINGERPRINT FENCE (per-agent) ---------------------
+  // The delivery backoff above is scoped to AgentProcess and is cleared when a
+  // runtime process exits. Recoverable terminal errors intentionally keep an
+  // idle restart cache so the next message can wake the agent, but that also
+  // means a deterministic same-fingerprint runtime error can close/restart
+  // forever. Keep this counter outside AgentProcess and reset only on real turn
+  // progress or explicit stop.
+  runtimeErrorFingerprintFenceResetEvent(eventKind) {
+    switch (eventKind) {
+      case "thinking":
+      case "text":
+      case "tool_call":
+      case "tool_output":
+      case "compaction_finished":
+      case "review_finished":
+      case "turn_end":
+        return true;
+      default:
+        return false;
+    }
+  }
+  resetRuntimeErrorFingerprintFence(agentId, resetSource, ap) {
+    const state = this.runtimeErrorFingerprintFences.get(agentId);
+    if (!state) return;
+    this.runtimeErrorFingerprintFences.delete(agentId);
+    this.recordDaemonTrace("daemon.agent.runtime_error_fingerprint_fence.reset", {
+      agentId,
+      runtime: ap?.config.runtime,
+      model: ap?.config.model,
+      launchId: ap?.launchId || state.launchId || void 0,
+      fingerprint: state.fingerprint,
+      attempts: state.attempts,
+      reset_source: resetSource
+    });
+  }
+  formatRuntimeErrorFingerprintFenceDetail(state) {
+    return [
+      `Runtime stopped after ${state.attempts} repeated runtime errors with the same fingerprint (${state.fingerprint}).`,
+      `Last error: ${state.lastRuntimeError}`,
+      "Restart after the runtime/tooling issue is fixed."
+    ].join(" ");
+  }
+  noteRuntimeErrorFingerprintFence(agentId, ap, message, fingerprint, terminalFailure, stickyTerminalFailure) {
+    if (!fingerprint) return null;
+    if (stickyTerminalFailure || terminalFailure?.actionRequired) return null;
+    let state = this.runtimeErrorFingerprintFences.get(agentId);
+    if (!state || state.fingerprint !== fingerprint) {
+      state = {
+        fingerprint,
+        attempts: 0,
+        lastRuntimeError: message,
+        detail: "",
+        launchId: ap.launchId
+      };
+      this.runtimeErrorFingerprintFences.set(agentId, state);
+    }
+    state.attempts += 1;
+    state.lastRuntimeError = message;
+    state.launchId = ap.launchId;
+    state.detail = this.formatRuntimeErrorFingerprintFenceDetail(state);
+    const fenced = state.attempts >= RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD;
+    this.recordDaemonTrace("daemon.agent.runtime_error_fingerprint_fence", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      fingerprint,
+      attempts: state.attempts,
+      threshold: RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD,
+      fenced,
+      runtime_error_class: buildRuntimeErrorDiagnosticEnvelope(message).spanAttrs.runtime_error_class
+    }, fenced ? "error" : "ok");
+    return fenced ? state : null;
+  }
+  applyRuntimeErrorFingerprintFence(agentId, ap, state) {
+    this.recordDaemonTrace("daemon.agent.runtime_error_fingerprint_fence.tripped", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      fingerprint: state.fingerprint,
+      attempts: state.attempts,
+      threshold: RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD
+    }, "error");
+    this.idleAgentConfigs.delete(agentId);
+    this.sendAgentStatus(agentId, "inactive", ap.launchId);
+    this.cleanupTerminalRuntimeFailure(agentId, ap, state.detail);
+  }
   scheduleStdinNotification(agentId, ap, delayMs) {
     return ap.notifications.schedule(() => {
       this.sendStdinNotification(agentId);
@@ -12498,6 +12489,7 @@ var AgentProcessManager = class _AgentProcessManager {
       let prompt;
       let promptSource;
       let wakeMessageDeliveredAsInboxUpdate = false;
+      let startingInboxDeliveredAsInput = false;
       const startingInboxMessages = this.startingInboxes.get(agentId) || [];
       if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
@@ -12538,6 +12530,10 @@ You also have unread messages in other channels:`;
 Use the inbox/read commands at a natural breakpoint if you choose to inspect those targets.`;
           }
         }
+      } else if (startingInboxMessages.length > 0) {
+        startingInboxDeliveredAsInput = true;
+        prompt = this.formatInboxUpdateRuntimeInput(startingInboxMessages, driver);
+        promptSource = "starting_inbox_update";
       } else if (isResume && unreadSummary && Object.keys(unreadSummary).length > 0) {
         prompt = `You have unread messages from while you were offline:`;
         for (const [ch, count] of Object.entries(unreadSummary)) {
@@ -12670,6 +12666,10 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       }
       if (wakeMessageDeliveredAsInboxUpdate) {
         this.recordInboxUpdateProjection(agentId, agentProcess, agentProcess.inbox, "spawn_wake_inbox_update", "wake", prompt);
+      } else if (startingInboxDeliveredAsInput) {
+        this.recordInboxUpdateProjection(agentId, agentProcess, startingInboxMessages, "spawn_starting_inbox_update", "wake", prompt);
+        this.consumeVisibleMessages(agentId, { messages: startingInboxMessages, source: "spawn_starting_inbox_update" });
+        this.ackInjectedRuntimeProfileMessages(agentId, startingInboxMessages, agentProcess.launchId);
       } else if (wakeMessage && !wakeMessageTransient) {
         this.consumeVisibleMessages(agentId, { messages: [wakeMessage], source: "spawn_wake_message" });
         this.ackInjectedRuntimeProfileMessages(agentId, [wakeMessage], agentProcess.launchId);
@@ -13311,6 +13311,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       this.agentVisibleBoundaries.delete(agentId);
       this.agentVisibleMessageIds.delete(agentId);
       this.resetSpawnFailBackoff(agentId);
+      this.resetRuntimeErrorFingerprintFence(agentId, "explicit_stop", ap);
     }
     this.runtimeExitTraceAttrs.set(ap.runtime, {
       stop_source: silent ? "daemon_internal" : "explicit_request",
@@ -13495,6 +13496,19 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           return false;
         });
       }
+      if (!transientDelivery && (this.queuedAgentStarts.has(agentId) || this.agentsStarting.has(agentId))) {
+        const pending = this.startingInboxes.get(agentId) || [];
+        pending.push(message);
+        this.startingInboxes.set(agentId, pending);
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: this.agentsStarting.has(agentId) ? "queued_for_starting_process" : "queued_for_queued_start",
+          accepted: true,
+          process_present: false,
+          cached_idle_config_present: false,
+          starting_inbox_count: pending.length
+        }));
+        return true;
+      }
       logger.warn(`[Agent ${agentId}] Delivery received but no running process or cached idle config exists`);
       if (transientDelivery) {
         this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
@@ -15426,6 +15440,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         return;
       }
       this.noteRuntimeProgress(ap, event.kind);
+      if (this.runtimeErrorFingerprintFenceResetEvent(event.kind)) {
+        this.resetRuntimeErrorFingerprintFence(agentId, `runtime_progress:${event.kind}`, ap);
+      }
       recordProgressObservedAfterStall();
     } else if (event.kind !== "internal_progress") {
       this.recordDaemonTrace("daemon.agent.event.received_without_process", {
@@ -15618,6 +15635,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         let visibleErrorMessage = event.message;
         if (ap) {
           const runtimeErrorDiagnostics = buildRuntimeErrorDiagnosticEnvelope(event.message);
+          const runtimeErrorFingerprint = typeof runtimeErrorDiagnostics.spanAttrs.runtime_error_fingerprint === "string" ? runtimeErrorDiagnostics.spanAttrs.runtime_error_fingerprint : null;
           if (runtimeErrorDiagnostics.spanAttrs.runtime_error_action_required === true) {
             visibleErrorMessage = formatRuntimeLoginRequiredMessage(ap.driver.id);
           }
@@ -15634,6 +15652,17 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             terminalWakeable: Boolean(ap.driver.supportsStdinNotification && terminalFailure && !terminalFailure.actionRequired)
           });
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "error" });
+          const fingerprintFence = this.noteRuntimeErrorFingerprintFence(
+            agentId,
+            ap,
+            event.message,
+            runtimeErrorFingerprint,
+            terminalFailure,
+            stickyTerminalFailure
+          );
+          if (fingerprintFence) {
+            visibleErrorMessage = fingerprintFence.detail;
+          }
           this.noteRuntimeErrorDeliveryBackoff(agentId, ap, event.message, terminalFailure, stickyTerminalFailure, backoffReasonOverride);
           if (reduction.shouldDisableToolBoundaryFlush) {
             this.recordGatedSteeringEvent(agentId, ap, "disabled", {
@@ -15654,7 +15683,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             ...runtimeTraceCounterAttrs(ap),
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
           });
-          if (ap.driver.supportsStdinNotification && terminalFailure) {
+          if (fingerprintFence) {
+            this.applyRuntimeErrorFingerprintFence(agentId, ap, fingerprintFence);
+          } else if (ap.driver.supportsStdinNotification && terminalFailure) {
             if (terminalFailure.actionRequired) {
               logger.warn(`[Agent ${agentId}] ${ap.driver.id} auth requires user action; terminating runtime process`);
               try {
@@ -17174,9 +17205,10 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     eventAttrs: {
       "daemon.receive": ["seq", "deliveryId"],
       "daemon.deliver_to_agent_manager": ["accepted"],
+      "daemon.delivery.buffered_for_start": ["pending_count"],
       "daemon.ack.sent": ["seq"]
     },
-    endAttrs: ["outcome", "ackSeq", "deliveryId", "error_class"]
+    endAttrs: ["outcome", "ackSeq", "deliveryId", "error_class", "pending_count"]
   },
   "daemon.runtime_profile.control.received": {
     spanAttrs: ["agentId", "control_kind", "key_present", "launchId"],
@@ -17222,7 +17254,7 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     spanAttrs: ["agentId", "event_kind", "runtime"]
   }
 };
-var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
+var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -17258,9 +17290,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args, env = {}) {
+function parseDaemonCliArgs(args) {
   let serverUrl = "";
-  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
+  let apiKey = "";
   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];
@@ -17460,6 +17492,8 @@ var DaemonCore = class {
   observedMachineId = null;
   localTraceSink = null;
   traceBundleUploader = null;
+  coreStartingAgentIds = /* @__PURE__ */ new Set();
+  coreStartPendingDeliveries = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = options;
     this.daemonVersion = options.daemonVersion ?? readDaemonVersion();
@@ -17737,19 +17771,63 @@ var DaemonCore = class {
       }
     );
   }
+  sendDeliveryAck(msg, traceparent) {
+    const ackSeq = msg.seq > 0 ? msg.seq : msg.message.seq ?? 0;
+    const ack = {
+      type: "agent:deliver:ack",
+      agentId: msg.agentId,
+      seq: ackSeq,
+      deliveryId: msg.deliveryId,
+      ...traceparent ? { traceparent } : {}
+    };
+    this.connection.send(ack);
+  }
   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(
-      msg.agentId,
-      config,
-      msg.wakeMessage,
-      msg.unreadSummary,
-      msg.resumePrompt,
-      msg.launchId,
-      msg.wakeMessageTransient ?? false
-    );
+    this.coreStartingAgentIds.add(msg.agentId);
+    let wakeDeliveryAck = null;
+    let replayDeliveries = [];
+    try {
+      this.observeRuntimeContext(msg.config);
+      const agentCredential = await this.mintRunnerCredential(msg.agentId, msg.config);
+      const config = { ...msg.config, agentCredentialKey: agentCredential.apiKey, agentCredentialId: agentCredential.credentialId };
+      const pendingDeliveries = this.coreStartPendingDeliveries.get(msg.agentId) || [];
+      this.coreStartPendingDeliveries.delete(msg.agentId);
+      let wakeMessage = msg.wakeMessage;
+      let wakeMessageTransient = msg.wakeMessageTransient ?? false;
+      replayDeliveries = [...pendingDeliveries];
+      if (!wakeMessage) {
+        const wakeIndex = replayDeliveries.findIndex((delivery) => delivery.transient !== true);
+        if (wakeIndex >= 0) {
+          const [wakeDelivery] = replayDeliveries.splice(wakeIndex, 1);
+          if (wakeDelivery) {
+            wakeDeliveryAck = wakeDelivery;
+            wakeMessage = wakeDelivery.message;
+            wakeMessageTransient = wakeDelivery.transient ?? false;
+          }
+        }
+      }
+      await this.agentManager.startAgent(
+        msg.agentId,
+        config,
+        wakeMessage,
+        msg.unreadSummary,
+        msg.resumePrompt,
+        msg.launchId,
+        wakeMessageTransient
+      );
+      this.coreStartingAgentIds.delete(msg.agentId);
+      if (wakeDeliveryAck) {
+        this.sendDeliveryAck(wakeDeliveryAck);
+      }
+      for (const delivery of replayDeliveries) {
+        this.handleMessage(delivery);
+      }
+    } catch (err) {
+      this.coreStartPendingDeliveries.delete(msg.agentId);
+      throw err;
+    } finally {
+      this.coreStartingAgentIds.delete(msg.agentId);
+    }
   }
   handleMessage(msg) {
     const summary = summarizeIncomingMessage(msg);
@@ -17804,6 +17882,14 @@ var DaemonCore = class {
         logger.info(`[Agent ${msg.agentId}] Delivery received (seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`);
         try {
           span.addEvent("daemon.receive", { seq: msg.seq, deliveryId: msg.deliveryId });
+          if (this.coreStartingAgentIds.has(msg.agentId)) {
+            const pending = this.coreStartPendingDeliveries.get(msg.agentId) || [];
+            pending.push(msg);
+            this.coreStartPendingDeliveries.set(msg.agentId, pending);
+            span.addEvent("daemon.delivery.buffered_for_start", { pending_count: pending.length });
+            span.end("ok", { attrs: { outcome: "buffered-for-start", pending_count: pending.length } });
+            break;
+          }
           const acceptedOrPromise = this.agentManager.deliverMessage(msg.agentId, msg.message, {
             deliveryId: msg.deliveryId,
             transient: msg.transient ?? false
@@ -17816,13 +17902,7 @@ var DaemonCore = class {
             }
             const ackSeq = msg.seq > 0 ? msg.seq : msg.message.seq ?? 0;
             span.addEvent("daemon.ack.sent", { seq: ackSeq });
-            this.connection.send({
-              type: "agent:deliver:ack",
-              agentId: msg.agentId,
-              seq: ackSeq,
-              traceparent: formatTraceparent(span.context),
-              deliveryId: msg.deliveryId
-            });
+            this.sendDeliveryAck(msg, formatTraceparent(span.context));
             span.end("ok", { attrs: { outcome: "ack-sent", ackSeq, deliveryId: msg.deliveryId } });
           }, (err) => {
             logger.error(`[Agent ${msg.agentId}] Delivery handling failed`, err);
@@ -18186,8 +18266,6 @@ var DaemonCore = class {
 
 export {
   subscribeDaemonLogs,
-  DAEMON_API_KEY_ENV,
-  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,

package/dist/core.js

@@ -1,5 +1,4 @@
 import {
-  DAEMON_API_KEY_ENV,
   DAEMON_CLI_USAGE,
   DaemonCore,
   deleteWorkspaceDirectory,
@@ -11,11 +10,9 @@ import {
   resolveWorkspaceDirectoryPath,
   runBundledSlockCli,
   scanWorkspaceDirectories,
-  scrubDaemonAuthEnv,
   subscribeDaemonLogs
-} from "./chunk-A2AHKVS2.js";
+} from "./chunk-DUWRNQQE.js";
 export {
-  DAEMON_API_KEY_ENV,
   DAEMON_CLI_USAGE,
   DaemonCore,
   deleteWorkspaceDirectory,
@@ -27,6 +24,5 @@ export {
   resolveWorkspaceDirectoryPath,
   runBundledSlockCli,
   scanWorkspaceDirectories,
-  scrubDaemonAuthEnv,
   subscribeDaemonLogs
 };

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botiverse/raft-daemon",
-  "version": "0.63.5-play.20260623160336",
+  "version": "0.63.6",
   "type": "module",
   "bin": {
     "raft-daemon": "dist/raft-daemon.js",
@@ -62,6 +62,7 @@
     "@slock-ai/trace-client": "workspace:*",
     "@types/node": "^25.5.0",
     "@types/ws": "^8.18.1",
+    "fast-check": "^4.8.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }