@slock-ai/daemon 0.57.2 → 0.57.3

package/dist/{chunk-EKSATDT3.js → chunk-H2QU4LAU.js}

@@ -1438,9 +1438,9 @@ Error code prefixes tell you the layer:
 function buildCredentialHygieneSection() {
   return `### Credential hygiene
 
-**Never paste credentials into Slock messages, attachments, or task fields.** Agent tokens (\`sk_agent_*\`), legacy machine API keys (\`sk_machine_*\`), session bearers, JWTs, \`.env\` files, or \`credential.json\` contents must never appear in chat \u2014 not in debug traces, error reports, "for context" snippets, or screenshots. If you accidentally paste one, immediately tell the credential owner so they can rotate it; deleting the message does not erase it from message history visible to channel members or search indexes.
+**Never paste credentials into public Slock channels, public-channel threads, or public-channel task/attachment fields.** Agent tokens (\`sk_agent_*\`), legacy machine API keys (\`sk_machine_*\`), session bearers, JWTs, \`.env\` files, or \`credential.json\` contents must not appear in public channel chat. DMs and private channels are allowed for authorized secret handoff, but verify the audience first. If you accidentally paste one into a public channel, immediately tell the credential owner so they can rotate it.
 
-If a tool or error output contains credential-shaped strings, redact them to \`sk_agent_<redacted>\` / \`sk_machine_<redacted>\` shape before reposting.
+If a tool or error output contains credential-shaped strings, redact them to \`sk_agent_<redacted>\` / \`sk_machine_<redacted>\` shape before posting to a public channel.
 
 **Profile credential resolution is strict.** When invoked as \`slock --profile <slug>\` or with \`SLOCK_PROFILE=<slug>\`, the CLI resolves credentials from \`$SLOCK_PROFILE_DIR\` \u2192 \`$SLOCK_HOME/profiles/<slug>\` \u2192 \`$HOME/.slock/profiles/<slug>\` in that order. It does **not** fall back to a different profile's credential, to an ambient user-level token, or to environment-leaked secrets \u2014 if your designated profile credential is missing or unreadable, the CLI fails closed rather than authenticating as someone else.`;
 }
@@ -1808,9 +1808,9 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 17. **${cancelReminderCmd}** \u2014 Cancel one of your reminders by ID.`;
   const credentialHygieneSection = isCli ? cliGuideSections.credentialHygiene : `### Credential hygiene
 
-**Never paste credentials into Slock messages, attachments, or task fields.** Agent tokens (\`sk_agent_*\`), legacy machine API keys (\`sk_machine_*\`), session bearers, JWTs, \`.env\` files, or \`credential.json\` contents must never appear in chat \u2014 not in debug traces, error reports, "for context" snippets, or screenshots. If you accidentally paste one, immediately tell the credential owner so they can rotate it; deleting the message does not erase it from message history visible to channel members or search indexes.
+**Never paste credentials into public Slock channels, public-channel threads, or public-channel task/attachment fields.** Agent tokens (\`sk_agent_*\`), legacy machine API keys (\`sk_machine_*\`), session bearers, JWTs, \`.env\` files, or \`credential.json\` contents must not appear in public channel chat. DMs and private channels are allowed for authorized secret handoff, but verify the audience first. If you accidentally paste one into a public channel, immediately tell the credential owner so they can rotate it.
 
-If a tool or error output contains credential-shaped strings, redact them to \`sk_agent_<redacted>\` / \`sk_machine_<redacted>\` shape before reposting.`;
+If a tool or error output contains credential-shaped strings, redact them to \`sk_agent_<redacted>\` / \`sk_machine_<redacted>\` shape before posting to a public channel.`;
   const reminderSection = isCli ? cliGuideSections.reminders : `### Reminders
 
 Use reminders for follow-up that depends on future state you cannot resolve now, whether user-requested or self-driven. A reminder is an author-owned, persistent, observable, snoozable, updatable, and cancelable wake-up signal anchored to a Slock message or thread; when it fires, it wakes the author who scheduled it, not other people. If anchored to a message or thread, the receipt/fire system message is visible in that surface, but wake ownership does not transfer. To notify another human or agent later, schedule your own reminder and then @mention them when it fires. Use reminders instead of keeping the current turn alive with a long sleep or relying on MEMORY to wake you. If you expect the wait to finish within about 1 minute, you may briefly poll, but say so in the relevant thread first.
@@ -7985,6 +7985,9 @@ 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 SPAWN_FAIL_BACKOFF_BASE_MS = 1e3;
+var SPAWN_FAIL_BACKOFF_MAX_MS = 3e4;
+var SPAWN_FAIL_BACKOFF_THRESHOLD = 3;
 var COMPACTION_STALE_MS = 5 * 6e4;
 var RUNTIME_PROGRESS_STALE_MS = 15 * 6e4;
 var DEFAULT_RUNTIME_START_TIMEOUT_MS = 2 * 6e4;
@@ -8492,6 +8495,12 @@ function summarizeCrash(code, signal) {
   if (typeof code === "number") return `exit code ${code}`;
   return "unknown exit";
 }
+function currentErrorCandidates(ap) {
+  return [
+    ap.runtimeErrorSinceProgress ? ap.lastRuntimeError : null,
+    ...ap.recentDecisionStderr
+  ].filter((value) => !!value);
+}
 function classifyTerminalFailure(ap) {
   const candidates = [
     ap.lastRuntimeError,
@@ -8535,21 +8544,16 @@ function isCodexProviderReconnectLog(text) {
 function isCodexBenignTransportLog(text) {
   return /Falling back from WebSockets/i.test(text);
 }
+function isStdinClassRecoveryLine(text) {
+  return /write_stdin failed|stdin is closed|closed for this session|session.*closed/i.test(text);
+}
 function hasDirectStdinRecoveryEvidence(ap) {
-  const candidates = [
-    ap.lastRuntimeError,
-    ...ap.recentStderr
-  ].filter((value) => !!value);
-  return candidates.some(
-    (text) => /write_stdin failed|stdin is closed|closed for this session|session.*closed/i.test(text)
-  );
+  const candidates = currentErrorCandidates(ap);
+  return candidates.some((text) => isStdinClassRecoveryLine(text));
 }
 function resumeSessionRecoveryReason(ap) {
   if (!ap.sessionId) return null;
-  const candidates = [
-    ap.lastRuntimeError,
-    ...ap.recentStderr
-  ].filter((value) => !!value);
+  const candidates = currentErrorCandidates(ap);
   if (ap.driver.id === "claude") {
     return candidates.some((text) => /No conversation found with session ID/i.test(text)) ? "missing" : null;
   }
@@ -8860,6 +8864,11 @@ var AgentProcessManager = class _AgentProcessManager {
   runtimeExitTraceAttrs = /* @__PURE__ */ new WeakMap();
   agentVisibleBoundaries = /* @__PURE__ */ new Map();
   agentVisibleMessageIds = /* @__PURE__ */ new Map();
+  // Spawn-fail backoff state per-agent (lifted outside AgentProcess because spawn fails
+  // BEFORE ap exists; rate-state must persist across stop/respawn so churn can't bypass).
+  // Explicit stop clears (fresh launch resets dedup clock — CC1 lifecycle pattern); silent
+  // stop preserves (same-launch respawn must keep counter or churn bypasses the cap).
+  agentSpawnFailBackoff = /* @__PURE__ */ new Map();
   daemonVersion;
   computerVersion;
   constructor(sendToServer, daemonApiKey, opts) {
@@ -8939,6 +8948,57 @@ var AgentProcessManager = class _AgentProcessManager {
     const id = typeof message.message_id === "string" ? message.message_id : typeof message.id === "string" ? message.id : "";
     return id.length > 0 && this.getVisibleMessageIdSet(agentId, target)?.has(id) === true;
   }
+  // ----- SPAWN-FAIL BACKOFF (per-agent) ----------------------------------
+  // Anchored at auto_restart_from_idle (apm:3596) + runtime_profile_auto_restart (apm:4137).
+  // Threshold > 1 → first SPAWN_FAIL_BACKOFF_THRESHOLD failures behave as today (preserves
+  // single-transient-hiccup); subsequent failure schedules a per-agent cooldown gating new
+  // spawn attempts. Successful spawn resets state. State lives outside AgentProcess because
+  // spawn fails BEFORE ap exists and the rate-window must persist across stop/respawn
+  // (else stop/start churn bypasses the cap — CC1 lifecycle pattern). Never advances any
+  // consume cursor or model-seen state (3-cursor orthogonality with CC1/CC2).
+  getOrCreateSpawnFailBackoff(agentId) {
+    let state = this.agentSpawnFailBackoff.get(agentId);
+    if (!state) {
+      state = createRuntimeErrorDeliveryBackoffState();
+      this.agentSpawnFailBackoff.set(agentId, state);
+    }
+    return state;
+  }
+  isSpawnFailBackoffActive(agentId) {
+    const state = this.agentSpawnFailBackoff.get(agentId);
+    if (!state) return false;
+    return state.untilMs > 0 && this.clockNow() < state.untilMs;
+  }
+  clockNow() {
+    return Date.now();
+  }
+  recordSpawnFailure(agentId, reason) {
+    const state = this.getOrCreateSpawnFailBackoff(agentId);
+    state.attempts += 1;
+    state.reason = reason;
+    if (state.attempts <= SPAWN_FAIL_BACKOFF_THRESHOLD) {
+      state.untilMs = 0;
+      return { backoffActive: false, attempts: state.attempts, untilMs: 0 };
+    }
+    const exponent = Math.min(state.attempts - SPAWN_FAIL_BACKOFF_THRESHOLD, 10);
+    const baseDelay = Math.min(SPAWN_FAIL_BACKOFF_MAX_MS, SPAWN_FAIL_BACKOFF_BASE_MS * Math.pow(2, exponent));
+    state.untilMs = this.clockNow() + Math.floor(baseDelay);
+    if (state.timer) clearTimeout(state.timer);
+    state.timer = setTimeout(() => {
+      const s = this.agentSpawnFailBackoff.get(agentId);
+      if (s) {
+        s.timer = null;
+        s.untilMs = 0;
+      }
+    }, Math.max(1, state.untilMs - this.clockNow()));
+    return { backoffActive: true, attempts: state.attempts, untilMs: state.untilMs };
+  }
+  resetSpawnFailBackoff(agentId) {
+    const state = this.agentSpawnFailBackoff.get(agentId);
+    if (!state) return;
+    if (state.timer) clearTimeout(state.timer);
+    this.agentSpawnFailBackoff.delete(agentId);
+  }
   scheduleStdinNotification(agentId, ap, delayMs) {
     return ap.notifications.schedule(() => {
       this.sendStdinNotification(agentId);
@@ -9793,6 +9853,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         recentStdout: [],
         recentStderr: [],
         lastRuntimeError: null,
+        recentDecisionStderr: [],
+        runtimeErrorSinceProgress: false,
         runtimeErrorDeliveryBackoff: createRuntimeErrorDeliveryBackoffState(),
         spawnError: null,
         exitCode: null,
@@ -9836,6 +9898,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (driver.id === "codex" && isCodexProviderReconnectLog(text)) {
           if (current) {
             current.recentStderr = pushRecentStderr(current.recentStderr, text);
+            current.recentDecisionStderr = pushRecentStderr(current.recentDecisionStderr, text);
           }
           this.recordDaemonTrace("daemon.agent.provider_reconnect", {
             agentId,
@@ -9852,6 +9915,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (driver.id === "codex" && isCodexBenignTransportLog(text)) return;
         if (current) {
           current.recentStderr = pushRecentStderr(current.recentStderr, text);
+          current.recentDecisionStderr = pushRecentStderr(current.recentDecisionStderr, text);
         }
         logger.error(`[Agent ${agentId} stderr]: ${text}`);
       });
@@ -10342,6 +10406,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       this.activityClientSeqByAgent.delete(agentId);
       this.agentVisibleBoundaries.delete(agentId);
       this.agentVisibleMessageIds.delete(agentId);
+      this.resetSpawnFailBackoff(agentId);
     }
     this.runtimeExitTraceAttrs.set(ap.runtime, {
       stop_source: silent ? "daemon_internal" : "explicit_request",
@@ -10438,6 +10503,25 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           return true;
         }
         logger.info(`[Agent ${agentId}] Starting from idle state for new message`);
+        if (this.isSpawnFailBackoffActive(agentId)) {
+          const state = this.agentSpawnFailBackoff.get(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: "spawn_fail_cooldown_active",
+            accepted: true,
+            process_present: false,
+            cached_idle_config_present: true,
+            runtime: cached.config.runtime,
+            session_id_present: Boolean(cached.sessionId),
+            launchId: cached.launchId || void 0,
+            spawn_fail_attempts: state.attempts,
+            spawn_fail_until_ms: state.untilMs,
+            starting_inbox_count: pending.length
+          }));
+          return true;
+        }
         this.idleAgentConfigs.delete(agentId);
         this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
           outcome: "auto_restart_from_idle",
@@ -10448,12 +10532,33 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           session_id_present: Boolean(cached.sessionId),
           launchId: cached.launchId || void 0
         }));
-        return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0, transientDelivery).then(() => true, (err) => {
+        return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0, transientDelivery).then(() => {
+          this.resetSpawnFailBackoff(agentId);
+          return true;
+        }, (err) => {
           logger.error(`[Agent ${agentId}] Failed to auto-restart`, err);
           if (this.reportRunnerCredentialMintFailure(agentId, err, cached.launchId, "idle_auto_restart")) {
+            const report2 = this.recordSpawnFailure(agentId, "runner_credential_mint");
+            this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
+              agentId,
+              source: "idle_auto_restart",
+              reason: "runner_credential_mint",
+              attempts: report2.attempts,
+              cooldown_active: report2.backoffActive,
+              until_ms: report2.untilMs
+            });
             return false;
           }
           this.idleAgentConfigs.set(agentId, cached);
+          const report = this.recordSpawnFailure(agentId, "spawn_error");
+          this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
+            agentId,
+            source: "idle_auto_restart",
+            reason: "spawn_error",
+            attempts: report.attempts,
+            cooldown_active: report.backoffActive,
+            until_ms: report.untilMs
+          });
           return false;
         });
       }
@@ -10928,10 +11033,35 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const cached = this.idleAgentConfigs.get(agentId);
     if (cached) {
       logger.info(`[Agent ${agentId}] Starting from idle state for runtime profile ${kind} ${key}`);
+      if (this.isSpawnFailBackoffActive(agentId)) {
+        const state = this.agentSpawnFailBackoff.get(agentId);
+        span.end("ok", {
+          attrs: {
+            outcome: "spawn_fail_cooldown_active",
+            runtime: cached.config.runtime,
+            launchId: cached.launchId || void 0,
+            spawn_fail_attempts: state.attempts,
+            spawn_fail_until_ms: state.untilMs
+          }
+        });
+        return true;
+      }
       this.idleAgentConfigs.delete(agentId);
-      return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).then(() => true, (err) => {
+      return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).then(() => {
+        this.resetSpawnFailBackoff(agentId);
+        return true;
+      }, (err) => {
         logger.error(`[Agent ${agentId}] Failed to auto-restart for runtime profile notification`, err);
         if (this.reportRunnerCredentialMintFailure(agentId, err, cached.launchId, "runtime_profile_auto_restart")) {
+          const report2 = this.recordSpawnFailure(agentId, "runner_credential_mint");
+          this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
+            agentId,
+            source: "runtime_profile_auto_restart",
+            reason: "runner_credential_mint",
+            attempts: report2.attempts,
+            cooldown_active: report2.backoffActive,
+            until_ms: report2.untilMs
+          });
           span.end("error", {
             attrs: {
               outcome: "runner_credential_mint_failed",
@@ -10942,6 +11072,15 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           return false;
         }
         this.idleAgentConfigs.set(agentId, cached);
+        const report = this.recordSpawnFailure(agentId, "spawn_error");
+        this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
+          agentId,
+          source: "runtime_profile_auto_restart",
+          reason: "spawn_error",
+          attempts: report.attempts,
+          cooldown_active: report.backoffActive,
+          until_ms: report.untilMs
+        });
         span.end("error", {
           attrs: {
             outcome: "restart_failed",
@@ -11535,6 +11674,21 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   noteRuntimeProgress(ap, eventKind) {
     ap.runtimeProgress.noteRuntimeEvent(eventKind);
+    this.invalidateRecoveryErrorView(ap);
+  }
+  /**
+   * Invalidate the decision-only error view on a liveness signal. The process is
+   * alive and has moved past any error it logged earlier in the turn, so a stale
+   * error must not keep restarting/re-routing a recovered agent. Error-class
+   * agnostic; a genuinely current failure re-populates the view after this point.
+   * Called on BOTH progress paths — ordinary runtime events and
+   * `internal_progress` (raw runtime activity that stale-recovery already treats
+   * as liveness). `recentStderr`/`lastRuntimeError` are untouched and stay full
+   * for diagnostics, user-facing reporting, and sticky terminal-failure gating.
+   */
+  invalidateRecoveryErrorView(ap) {
+    ap.recentDecisionStderr = [];
+    ap.runtimeErrorSinceProgress = false;
   }
   recordGatedSteeringEvent(agentId, ap, event, attrs = {}) {
     if (ap.runtime.descriptor.busyDelivery !== "gated") return;
@@ -11725,6 +11879,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const terminalFailureDetail = classifyTerminalFailure(ap);
     const detail = terminalFailureDetail?.detail ?? formatRuntimeStartTimeoutMessage(ap.driver.id);
     ap.lastRuntimeError = detail;
+    ap.runtimeErrorSinceProgress = true;
     ap.runtimeProgress.markStale();
     const staleForMs = Math.max(timeoutMs, ap.runtimeProgress.ageMs());
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, Math.max(1, Math.floor(staleForMs / 6e4)));
@@ -11879,6 +12034,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }
       if (event.kind === "internal_progress") {
         ap.runtimeProgress.noteInternalProgress();
+        this.invalidateRecoveryErrorView(ap);
         this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
         this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.internal_observed", {
           turn_outcome: "held",
@@ -12053,7 +12209,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       case "error": {
         this.interruptCompactionIfActive(agentId);
         this.flushPendingTrajectory(agentId);
-        if (ap) ap.lastRuntimeError = event.message;
+        if (ap) {
+          ap.lastRuntimeError = event.message;
+          ap.runtimeErrorSinceProgress = true;
+        }
         let visibleErrorMessage = event.message;
         if (ap) {
           const runtimeErrorDiagnostics = buildRuntimeErrorDiagnosticEnvelope(event.message);

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   subscribeDaemonLogs
-} from "./chunk-EKSATDT3.js";
+} from "./chunk-H2QU4LAU.js";
 export {
   DAEMON_CLI_USAGE,
   DaemonCore,

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.57.2",
+  "version": "0.57.3",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"
@@ -31,7 +31,7 @@
     "prepublishOnly": "pnpm run build",
     "typecheck": "tsc --noEmit",
     "generate:slock-cli-guide": "tsx scripts/generate-slock-cli-guide.ts",
-    "check:slock-cli-guide-fresh": "pnpm generate:slock-cli-guide && git diff --exit-code ../../docs/agent-knowledge/slock-cli-overview.mdx",
+    "check:slock-cli-guide-fresh": "pnpm generate:slock-cli-guide && git diff --exit-code ../../manual/agent-knowledge/slock-cli-overview.md",
     "release:patch": "npm version patch --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:minor": "npm version minor --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:major": "npm version major --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",