@slock-ai/daemon 0.55.2-alpha.0 → 0.55.3

package/dist/{chunk-QQRU3GA6.js → chunk-DLB2KVD7.js}

@@ -5,7 +5,7 @@ import {
   executeJsonRequest,
   executeResponseRequest,
   logger
-} from "./chunk-VOZJ2ELH.js";
+} from "./chunk-M2KQBJR3.js";
 
 // src/core.ts
 import path16 from "path";
@@ -38,6 +38,244 @@ var CHANNEL_MESSAGE_RE = new RegExp(
   "iu"
 );
 
+// ../shared/src/producerFactLineage.ts
+var PRODUCER_FACT_TEXT_LABEL = "producerFactId";
+function formatProducerFactLineageBracket(producerFactId) {
+  const id = normalizeProducerFactId(producerFactId);
+  return id ? ` [${PRODUCER_FACT_TEXT_LABEL}=${id}]` : "";
+}
+function normalizeProducerFactId(producerFactId) {
+  return typeof producerFactId === "string" ? producerFactId.trim() : "";
+}
+
+// ../shared/src/apmHeldFreshness.ts
+function buildApmFreshnessDecisionProducerFactId(agentId, input) {
+  const stableInput = {
+    agentId,
+    action: input.action,
+    decision: input.decision,
+    target: input.target ?? null,
+    reason: input.reason,
+    pendingMaxSeq: input.pendingMaxSeq ?? null,
+    modelSeenSeq: input.modelSeenSeq ?? null,
+    heldMessageCount: input.heldMessageCount ?? null,
+    omittedMessageCount: input.omittedMessageCount ?? null
+  };
+  return `freshness_decision_fact:${hashApmHeldFreshnessStable(stableInput)}`;
+}
+function projectApmHeldFreshnessEnvelope(input) {
+  const body = {
+    state: "held",
+    outcome: "held",
+    subtype: "freshness",
+    reason: "newer_messages_available",
+    producerFactId: input.producerFactId,
+    available_actions: apmHeldFreshnessAvailableActions(input.action),
+    heldMessages: input.heldMessages,
+    newMessageCount: input.newMessageCount,
+    shownMessageCount: input.heldMessages.length,
+    omittedMessageCount: input.omittedMessageCount,
+    seenUpToSeq: input.seenUpToSeq
+  };
+  return {
+    clauseId: "SMR-006",
+    projector: "held-envelope",
+    surface: "agent-api-held-response",
+    producerFactId: input.producerFactId,
+    body
+  };
+}
+function projectApmHeldFreshnessActivity(input) {
+  const title = input.action === "send" ? "Send held by freshness check" : input.action === "task_claim" ? "Task claim held by freshness check" : "Task update held by freshness check";
+  const text = [
+    input.target ? `target: ${input.target}` : null,
+    `new messages: ${input.messageCount} newer message${input.messageCount === 1 ? "" : "s"}`,
+    `decision: ${input.decision === "syncing_hold" ? "syncing hold" : "local hold"}; review the newer context before retrying`
+  ].filter((line) => Boolean(line)).join("\n");
+  return {
+    clauseId: "SMR-006",
+    projector: "held-envelope",
+    surface: "agent:activity",
+    producerFactId: input.producerFactId,
+    entry: {
+      kind: "slock_action",
+      producerFactId: input.producerFactId,
+      title,
+      text
+    }
+  };
+}
+function projectApmFreshnessDecisionTrace(input) {
+  return {
+    clauseId: "SMR-006",
+    projector: "held-envelope",
+    surface: "daemon-trace",
+    producerFactId: input.producerFactId,
+    attrs: {
+      producer_fact_id: input.producerFactId,
+      action: input.decision.action,
+      decision: input.decision.decision,
+      target: input.decision.target,
+      inbox_trust_state: input.decision.inboxTrustState,
+      reason: input.decision.reason,
+      pending_count: input.decision.pendingCount,
+      pending_max_seq: input.decision.pendingMaxSeq,
+      model_seen_seq: input.decision.modelSeenSeq,
+      held_message_count: input.decision.heldMessageCount,
+      omitted_message_count: input.decision.omittedMessageCount
+    }
+  };
+}
+function apmHeldFreshnessAvailableActions(action) {
+  return action === "send" ? ["check_messages", "send_draft", "send_anyway"] : ["check_messages", "retry_action"];
+}
+function hashApmHeldFreshnessStable(value) {
+  return sha256HexUtf8(stableStringifyApmHeldFreshness(value));
+}
+function stableStringifyApmHeldFreshness(value) {
+  return JSON.stringify(stableNormalizeApmHeldFreshness(value));
+}
+function stableNormalizeApmHeldFreshness(value) {
+  if (Array.isArray(value)) return value.map((item) => stableNormalizeApmHeldFreshness(item));
+  if (!value || typeof value !== "object") return value;
+  const record = value;
+  const normalized = {};
+  for (const key of Object.keys(record).sort()) {
+    const child = record[key];
+    if (child === void 0) continue;
+    normalized[key] = stableNormalizeApmHeldFreshness(child);
+  }
+  return normalized;
+}
+var SHA256_INITIAL_STATE = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+var SHA256_K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function sha256HexUtf8(value) {
+  const bytes = new TextEncoder().encode(value);
+  const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(bytes);
+  padded[bytes.length] = 128;
+  const bitLength = bytes.length * 8;
+  const view = new DataView(padded.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+  const h = [...SHA256_INITIAL_STATE];
+  const words = new Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let i = 0; i < 16; i += 1) {
+      words[i] = view.getUint32(offset + i * 4);
+    }
+    for (let i = 16; i < 64; i += 1) {
+      const s0 = rotateRight(words[i - 15], 7) ^ rotateRight(words[i - 15], 18) ^ words[i - 15] >>> 3;
+      const s1 = rotateRight(words[i - 2], 17) ^ rotateRight(words[i - 2], 19) ^ words[i - 2] >>> 10;
+      words[i] = words[i - 16] + s0 + words[i - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + s1 + ch + SHA256_K[i] + words[i] >>> 0;
+      const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  return h.map((part) => part.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+
 // ../shared/src/tracing/index.ts
 var DEFAULT_TRACE_FLAGS = "00";
 var TRACEPARENT_VERSION = "00";
@@ -954,7 +1192,7 @@ var DISPLAY_PLAN_CONFIG = {
 // src/agentProcessManager.ts
 import { mkdirSync as mkdirSync4, readdirSync, statSync, writeFileSync as writeFileSync7 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import path12 from "path";
 import os5 from "os";
 
@@ -1059,8 +1297,8 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 17. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
 18. **\`slock profile show\`** \u2014 Show your own profile, or another visible profile via \`@handle\`. Mirrors the canonical Slock profile view.
 19. **\`slock profile update\`** \u2014 Update your own profile. Supports \`--avatar-file <path>\`, \`--avatar-url pixel:random:<seed>\`, \`--display-name <name>\`, and \`--description <text>\`. Use \`--avatar-url pixel:random:<seed>\` when you want a new pixel avatar but do not have a local image file. Values must be non-empty. Provide at least one flag per call; multiple flags can be combined.
-20. **\`slock integration list\`** \u2014 List registered third-party services and this agent's active Slock Agent Logins.
-21. **\`slock integration login\`** \u2014 Provision or reuse this agent's login for a registered third-party service.
+20. **\`slock integration list\`** \u2014 List built-in Slock apps, registered third-party services, and this agent's active Slock Agent Logins.
+21. **\`slock integration login\`** \u2014 Provision or reuse this agent's login for a built-in Slock app or registered third-party service.
 22. **\`slock integration env\`** \u2014 Print per-agent local CLI environment for a manifest-backed service that requires isolated HOME/XDG state.
 23. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
 24. **\`slock reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
@@ -1174,9 +1412,9 @@ Each channel has a **name** and optionally a **description** that define its pur
 - If unsure where something belongs, call ${serverInfoCmd} to review channel descriptions.`;
   const thirdPartyIntegrationsSection = isCli ? `### Third-party integrations
 
-If a registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app, first run \`slock integration list\` and match the app to a registered service before browsing the app. Use \`slock integration login --service <service>\` to provision or reuse your agent login for that service. If the service exposes an agent behavior manifest and you need to run its local CLI, run \`slock integration env --service <service>\` before invoking that CLI; if it prints exports, apply them first so service credentials stay under a per-agent profile HOME/XDG tree instead of the host user's global HOME. If it reports that no local env is required, do not invent HOME/XDG overrides. If it fails, do not run that local CLI with the host user's HOME; report that the service manifest is unsupported. Slock does not execute commands from remote manifests automatically. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. When the command returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes an app URL, open that URL as the service-provided third-party app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`slock profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the registered service / Slock Agent Login path.` : `### Third-party integrations
+If a built-in Slock app or registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app or built-in Slock app, first run \`slock integration list\` and match the app to a listed service before browsing the app. Use \`slock integration login --service <service>\` to provision or reuse your agent login for that service. If the service exposes an agent behavior manifest and you need to run its local CLI, run \`slock integration env --service <service>\` before invoking that CLI; if it prints exports, apply them first so service credentials stay under a per-agent profile HOME/XDG tree instead of the host user's global HOME. If it reports that no local env is required, do not invent HOME/XDG overrides. If it fails, do not run that local CLI with the host user's HOME; report that the service manifest is unsupported. Slock does not execute commands from remote manifests automatically. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. When the command returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes an app URL, open that URL as the service-provided app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`slock profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the listed service / Slock Agent Login path.` : `### Third-party integrations
 
-If a registered third-party service requires login, use Slock Agent Login through the available registered-service interface instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app, first inspect the registered-service interface and match the app to a registered service before browsing the app. Once the registered-service interface reports the agent login is ready, the agent-side login is ready. If that interface provides an app URL, use it as the service-provided third-party app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow or treat internal request IDs as OAuth callback codes unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use your Slock profile view. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the registered service / Slock Agent Login path.`;
+If a built-in Slock app or registered third-party service requires login, use Slock Agent Login through the available registered-service interface instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app or built-in Slock app, first inspect the registered-service interface and match the app to a listed service before browsing the app. Once the registered-service interface reports the agent login is ready, the agent-side login is ready. If that interface provides an app URL, use it as the service-provided app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow or treat internal request IDs as OAuth callback codes unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use your Slock profile view. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the listed service / Slock Agent Login path.`;
   const readingHistorySection = isCli ? `### Reading history
 
 \`slock message read --channel "#channel-name"\` or \`slock message read --channel dm:@peer-name\` or \`slock message read --channel "#channel:shortid"\`
@@ -1544,6 +1782,258 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
 import { randomBytes } from "crypto";
 import http from "http";
 import { URL as URL2 } from "url";
+
+// src/apmStateMachine.ts
+import { createHash } from "crypto";
+var MAX_APM_GATED_STEERING_EVENTS = 12;
+function createInitialApmGatedSteeringState() {
+  return {
+    isIdle: false,
+    expectedTerminationReason: null,
+    phase: "idle",
+    outstandingToolUses: 0,
+    compacting: false,
+    toolBoundaryFlushDisabled: false,
+    lastFlushReason: null,
+    recentEvents: []
+  };
+}
+function reduceApmIdleState(state, input) {
+  return {
+    nextState: {
+      ...state,
+      isIdle: input.isIdle
+    }
+  };
+}
+function reduceApmGatedToolUse(state, input) {
+  if (input.kind === "tool_call") {
+    return {
+      nextState: {
+        isIdle: false,
+        expectedTerminationReason: state.expectedTerminationReason,
+        phase: "tool_wait",
+        outstandingToolUses: state.outstandingToolUses + 1,
+        compacting: state.compacting,
+        toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
+        lastFlushReason: state.lastFlushReason,
+        recentEvents: state.recentEvents
+      },
+      hadOutstandingToolUse: state.outstandingToolUses > 0,
+      shouldFlushToolBatch: false
+    };
+  }
+  const hadOutstandingToolUse = state.outstandingToolUses > 0;
+  const outstandingToolUses = Math.max(0, state.outstandingToolUses - 1);
+  return {
+    nextState: {
+      isIdle: false,
+      expectedTerminationReason: state.expectedTerminationReason,
+      phase: "tool_boundary",
+      outstandingToolUses,
+      compacting: state.compacting,
+      toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
+      lastFlushReason: state.lastFlushReason,
+      recentEvents: state.recentEvents
+    },
+    hadOutstandingToolUse,
+    shouldFlushToolBatch: hadOutstandingToolUse && outstandingToolUses === 0
+  };
+}
+function reduceApmGatedCompaction(state, input) {
+  if (input.kind === "compaction_started") {
+    return {
+      nextState: {
+        isIdle: false,
+        expectedTerminationReason: state.expectedTerminationReason,
+        phase: "compacting",
+        outstandingToolUses: state.outstandingToolUses,
+        compacting: true,
+        toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
+        lastFlushReason: state.lastFlushReason,
+        recentEvents: state.recentEvents
+      }
+    };
+  }
+  if (input.kind === "compaction_interrupted") {
+    return {
+      nextState: {
+        isIdle: false,
+        expectedTerminationReason: state.expectedTerminationReason,
+        phase: state.phase,
+        outstandingToolUses: state.outstandingToolUses,
+        compacting: false,
+        toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
+        lastFlushReason: state.lastFlushReason,
+        recentEvents: state.recentEvents
+      }
+    };
+  }
+  return {
+    nextState: {
+      isIdle: false,
+      expectedTerminationReason: state.expectedTerminationReason,
+      phase: "assistant_continuation",
+      outstandingToolUses: state.outstandingToolUses,
+      compacting: false,
+      toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
+      lastFlushReason: state.lastFlushReason,
+      recentEvents: state.recentEvents
+    }
+  };
+}
+function reduceApmGatedCompactionBoundaryFlush(_state, input) {
+  if (!input.hasSession || !input.supportsStdinNotification || input.inboxLength === 0) {
+    return { effects: [] };
+  }
+  if (input.pendingNotificationCount === 0) return { effects: [] };
+  return {
+    effects: [{
+      kind: "notify_stdin",
+      reason: "compaction_finished",
+      stdinMode: "busy",
+      clauseId: "SMR-002"
+    }]
+  };
+}
+function reduceApmGatedTurnEnd(_state, input = {}) {
+  const shouldDeliverQueuedMessages = Boolean(
+    input.inboxLength && input.inboxLength > 0 && input.supportsStdinNotification && input.hasSession
+  );
+  return {
+    nextState: {
+      isIdle: !shouldDeliverQueuedMessages,
+      expectedTerminationReason: input.terminateProcessOnTurnEnd === true ? "turn_end" : _state.expectedTerminationReason,
+      phase: "idle",
+      outstandingToolUses: 0,
+      compacting: false,
+      toolBoundaryFlushDisabled: _state.toolBoundaryFlushDisabled,
+      lastFlushReason: _state.lastFlushReason,
+      recentEvents: _state.recentEvents
+    },
+    effects: shouldDeliverQueuedMessages ? [{
+      kind: "deliver_stdin",
+      reason: "turn_end",
+      stdinMode: "idle",
+      clauseId: "SMR-002"
+    }] : []
+  };
+}
+function reduceApmGatedError(state, input = {}) {
+  const shouldDisableToolBoundaryFlush = input.disableToolBoundaryFlush === true;
+  return {
+    nextState: {
+      isIdle: input.terminalWakeable === true,
+      expectedTerminationReason: state.expectedTerminationReason,
+      phase: "error",
+      outstandingToolUses: state.outstandingToolUses,
+      compacting: false,
+      toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled || shouldDisableToolBoundaryFlush,
+      lastFlushReason: state.lastFlushReason,
+      recentEvents: state.recentEvents
+    },
+    shouldDisableToolBoundaryFlush
+  };
+}
+function reduceApmGatedAssistantContinuation(state) {
+  return {
+    nextState: {
+      isIdle: false,
+      expectedTerminationReason: state.expectedTerminationReason,
+      phase: "assistant_continuation",
+      outstandingToolUses: state.outstandingToolUses,
+      compacting: state.compacting,
+      toolBoundaryFlushDisabled: state.toolBoundaryFlushDisabled,
+      lastFlushReason: state.lastFlushReason,
+      recentEvents: state.recentEvents
+    }
+  };
+}
+function reduceApmStalledRecoveryTermination(state, input) {
+  if (input.inboxLength === 0) {
+    return { nextState: state, shouldTerminate: false, alreadyRecovering: false, blockedReason: "empty_inbox" };
+  }
+  if (state.expectedTerminationReason === "stalled_recovery") {
+    return { nextState: state, shouldTerminate: false, alreadyRecovering: true, blockedReason: null };
+  }
+  const directStdinRuntime = input.supportsStdinNotification && input.busyDeliveryMode === "direct";
+  const canRestartDirectStdinProcess = directStdinRuntime && input.hasSession && (state.outstandingToolUses === 0 || input.hasDirectStdinRecoveryEvidence);
+  const canRestartStalledProcess = !input.supportsStdinNotification || canRestartDirectStdinProcess;
+  if (!canRestartStalledProcess) {
+    return { nextState: state, shouldTerminate: false, alreadyRecovering: false, blockedReason: "runtime_not_restartable" };
+  }
+  if (input.staleForMs < input.staleThresholdMs && !input.runtimeProgressIsStale) {
+    return { nextState: state, shouldTerminate: false, alreadyRecovering: false, blockedReason: "runtime_progress_recent" };
+  }
+  return {
+    nextState: {
+      ...state,
+      expectedTerminationReason: "stalled_recovery"
+    },
+    shouldTerminate: true,
+    alreadyRecovering: false,
+    blockedReason: null
+  };
+}
+function reduceApmStartupTimeoutTermination(state, input) {
+  if (input.hasRuntimeProgressEvent) {
+    return {
+      nextState: state,
+      shouldTerminate: false,
+      blockedReason: "runtime_progress_started"
+    };
+  }
+  return {
+    nextState: {
+      ...state,
+      isIdle: false,
+      expectedTerminationReason: "startup_timeout"
+    },
+    shouldTerminate: true,
+    blockedReason: null
+  };
+}
+function reduceApmGatedFlush(state, input) {
+  return {
+    nextState: {
+      ...state,
+      lastFlushReason: input.reason
+    }
+  };
+}
+function reduceApmGatedRecentEvent(state, input) {
+  const summary = `${input.event}:${state.phase}:tools=${state.outstandingToolUses}:compact=${state.compacting}`;
+  return {
+    nextState: {
+      ...state,
+      recentEvents: [...state.recentEvents, summary].slice(-MAX_APM_GATED_STEERING_EVENTS)
+    }
+  };
+}
+function reduceApmGatedFlushReadiness(state, input) {
+  if (!input.isGated) return { shouldNotify: false, blockedReason: "non_gated", effects: [] };
+  if (!input.hasSession) return { shouldNotify: false, blockedReason: "missing_session", effects: [] };
+  if (input.inboxLength === 0) return { shouldNotify: false, blockedReason: "empty_inbox", effects: [] };
+  if (state.toolBoundaryFlushDisabled) {
+    return { shouldNotify: false, blockedReason: "tool_boundary_flush_disabled", effects: [] };
+  }
+  if (state.compacting) return { shouldNotify: false, blockedReason: "compacting", effects: [] };
+  if (state.outstandingToolUses > 0) {
+    return { shouldNotify: false, blockedReason: "outstanding_tool_uses", effects: [] };
+  }
+  return {
+    shouldNotify: true,
+    blockedReason: null,
+    effects: [{
+      kind: "notify_stdin",
+      reason: input.reason,
+      stdinMode: "busy",
+      clauseId: "SMR-002"
+    }]
+  };
+}
+
+// src/agentCredentialProxy.ts
 var registrations = /* @__PURE__ */ new Map();
 var proxyServerState = null;
 var proxyServerStartPromise = null;
@@ -1682,7 +2172,7 @@ async function handleProxyRequest(req, res) {
       const bodyBuffer = new ArrayBuffer(rawBodyBuffer.byteLength);
       new Uint8Array(bodyBuffer).set(rawBodyBuffer);
       body = bodyBuffer;
-      headers.set("content-length", String(rawBodyBuffer.byteLength));
+      headers.delete("content-length");
     }
     let sendTarget;
     const sideEffectAction = agentApiSideEffectAction(target.pathname);
@@ -1706,7 +2196,7 @@ async function handleProxyRequest(req, res) {
       body = prepared.bodyText;
       if (sideEffectAction === "send") sendTarget = prepared.target;
       headers.set("content-type", "application/json");
-      headers.set("content-length", String(Buffer.byteLength(prepared.bodyText)));
+      headers.delete("content-length");
     }
     const upstream = await daemonFetch(target, {
       method,
@@ -1895,6 +2385,24 @@ function maxMessageSeq(messages) {
   }
   return maxSeq > 0 ? maxSeq : void 0;
 }
+function messageSenderId(message) {
+  if (typeof message.sender_id === "string" && message.sender_id.length > 0) return message.sender_id;
+  if (typeof message.senderId === "string" && message.senderId.length > 0) return message.senderId;
+  return void 0;
+}
+function isSelfAuthoredMessage(registration, message) {
+  return messageSenderId(message) === registration.agentId;
+}
+function isMessageModelSeen(coordinator, target, message) {
+  const seq = Math.floor(messageSeq(message));
+  const boundary = coordinator.getBoundary(target);
+  if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= seq) return true;
+  return coordinator.isMessageModelSeen?.({ target, message }) === true;
+}
+function resolveFreshnessBoundary(messages) {
+  const seenUpToSeq = maxMessageSeq(messages);
+  return typeof seenUpToSeq === "number" ? { ok: true, seenUpToSeq } : { ok: false, reason: "missing_seq_boundary" };
+}
 function sortBySeq(messages) {
   return [...messages].sort((a, b) => messageSeq(a) - messageSeq(b));
 }
@@ -1963,35 +2471,29 @@ function localAgentApiEventsResponse(registration, target) {
     }
   };
 }
-function heldAvailableActions(action) {
-  return action === "send" ? ["check_messages", "send_draft", "send_anyway"] : ["check_messages", "retry_action"];
-}
-function localHeldResponse(input) {
-  if (input.messages.length === 0) return void 0;
+function localHeldContext(input) {
+  if (input.messages.length === 0) return { ok: false, reason: "empty_context" };
   const normalized = sortBySeq(normalizeVisibleMessages(input.messages, input.target));
   const heldMessages = latestVisibleMessages(normalized, LOCAL_HELD_CONTEXT_LIMIT);
   const omittedMessageCount = Math.max(0, normalized.length - heldMessages.length);
-  const seenUpToSeq = maxMessageSeq(normalized);
-  if (seenUpToSeq === void 0) return void 0;
+  const boundary = resolveFreshnessBoundary(normalized);
+  if (!boundary.ok) return boundary;
   input.coordinator.consumeVisibleMessages({
     target: input.target,
     messages: heldMessages,
-    boundarySeq: seenUpToSeq,
+    boundarySeq: boundary.seenUpToSeq,
     source: input.source
   });
-  const response = {
-    state: "held",
-    outcome: "held",
-    subtype: "freshness",
-    reason: "newer_messages_available",
-    available_actions: heldAvailableActions(input.action),
-    heldMessages,
-    newMessageCount: normalized.length,
-    shownMessageCount: heldMessages.length,
-    omittedMessageCount
+  return {
+    ok: true,
+    context: {
+      heldMessages,
+      newMessageCount: normalized.length,
+      shownMessageCount: heldMessages.length,
+      omittedMessageCount,
+      seenUpToSeq: boundary.seenUpToSeq
+    }
   };
-  response.seenUpToSeq = seenUpToSeq;
-  return response;
 }
 function recordFreshnessDecision(coordinator, decision) {
   coordinator?.recordFreshnessDecision?.(decision);
@@ -2037,7 +2539,7 @@ function parseTargetFields(target) {
 }
 function normalizeVisibleMessage(message, target) {
   const targetFields = target ? parseTargetFields(target) : {};
-  return {
+  const normalized = {
     ...targetFields,
     ...message,
     message_id: message.message_id ?? message.id,
@@ -2046,6 +2548,9 @@ function normalizeVisibleMessage(message, target) {
     sender_name: message.sender_name ?? message.senderName,
     sender_description: message.sender_description ?? message.senderDescription ?? null
   };
+  const senderId = messageSenderId(message);
+  if (senderId) normalized.sender_id = senderId;
+  return normalized;
 }
 function normalizeVisibleMessages(messages, target) {
   return messages.map((message) => normalizeVisibleMessage(message, target));
@@ -2086,31 +2591,46 @@ async function prepareAgentApiSideEffectForward(registration, headers, rawBody,
   }
   const pending = coordinator.getPendingMessages(target);
   if (pending.length > 0) {
-    const localResponse = localHeldResponse({
-      action,
+    const modelSeenSeq = coordinator.getBoundary(target);
+    const contextResult = localHeldContext({
       target,
       messages: pending,
       coordinator,
       source: "side_effect_preflight_context"
     });
-    if (localResponse) {
-      recordFreshnessDecision(coordinator, {
+    if (contextResult.ok) {
+      const { context } = contextResult;
+      const decision = {
         action,
         decision: "local_hold",
         target,
         inboxTrustState: "trusted",
         reason: "exact_target_pending",
         pendingCount: pending.length,
-        pendingMaxSeq: maxMessageSeq(pending),
-        modelSeenSeq: coordinator.getBoundary(target),
-        heldMessageCount: typeof localResponse.shownMessageCount === "number" ? localResponse.shownMessageCount : void 0,
-        omittedMessageCount: typeof localResponse.omittedMessageCount === "number" ? localResponse.omittedMessageCount : void 0
-      });
+        pendingMaxSeq: context.seenUpToSeq,
+        modelSeenSeq,
+        heldMessageCount: context.shownMessageCount,
+        omittedMessageCount: context.omittedMessageCount
+      };
+      const producerFactId = buildApmFreshnessDecisionProducerFactId(registration.agentId, decision);
+      const localResponse = projectApmHeldFreshnessEnvelope({
+        producerFactId,
+        action,
+        heldMessages: context.heldMessages,
+        newMessageCount: context.newMessageCount,
+        omittedMessageCount: context.omittedMessageCount,
+        seenUpToSeq: context.seenUpToSeq
+      }).body;
+      recordFreshnessDecision(coordinator, { ...decision, producerFactId });
+      return {
+        bodyText: JSON.stringify(body),
+        target,
+        localResponse
+      };
     }
     return {
       bodyText: JSON.stringify(body),
-      target,
-      localResponse
+      target
     };
   }
   const existingBoundary = typeof body.seenUpToSeq === "number" && Number.isFinite(body.seenUpToSeq) ? Math.max(0, Math.floor(body.seenUpToSeq)) : void 0;
@@ -2131,35 +2651,82 @@ async function prepareAgentApiSideEffectForward(registration, headers, rawBody,
   }
   const recent = await loadRecentTargetMessages(registration, headers, target);
   if (recent.length > 0) {
-    const seenUpToSeq = maxMessageSeq(recent);
+    const unconsumedCounterparty = recent.filter(
+      (message) => !isSelfAuthoredMessage(registration, message) && !isMessageModelSeen(coordinator, target, message)
+    );
+    const boundary2 = resolveFreshnessBoundary(recent);
+    if (!boundary2.ok) {
+      recordFreshnessDecision(coordinator, {
+        action,
+        decision: "forward",
+        target,
+        inboxTrustState: "untrusted",
+        reason: "target_first_touch_recent_context_without_seq_boundary",
+        pendingCount: 0,
+        modelSeenSeq: 0
+      });
+      return { bodyText: JSON.stringify(body), target };
+    }
+    if (unconsumedCounterparty.length === 0) {
+      const { seenUpToSeq: seenUpToSeq2 } = boundary2;
+      if (action === "send") body.seenUpToSeq = seenUpToSeq2;
+      coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq2, source: "side_effect_preflight_context" });
+      recordFreshnessDecision(coordinator, {
+        action,
+        decision: "forward",
+        target,
+        inboxTrustState: "untrusted",
+        reason: "target_first_touch_recent_context_already_seen",
+        pendingCount: 0,
+        pendingMaxSeq: seenUpToSeq2,
+        modelSeenSeq: seenUpToSeq2,
+        heldMessageCount: 0,
+        omittedMessageCount: 0
+      });
+      return { bodyText: JSON.stringify(body), target };
+    }
+    const heldBoundary = resolveFreshnessBoundary(unconsumedCounterparty);
+    if (!heldBoundary.ok) {
+      recordFreshnessDecision(coordinator, {
+        action,
+        decision: "forward",
+        target,
+        inboxTrustState: "untrusted",
+        reason: "target_first_touch_counterparty_context_without_seq_boundary",
+        pendingCount: 0,
+        modelSeenSeq: 0
+      });
+      return { bodyText: JSON.stringify(body), target };
+    }
+    const heldMessages = latestVisibleMessages(unconsumedCounterparty, LOCAL_HELD_CONTEXT_LIMIT);
+    const omittedMessageCount = Math.max(0, unconsumedCounterparty.length - heldMessages.length);
+    const { seenUpToSeq } = boundary2;
     coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq, source: "side_effect_preflight_context" });
-    recordFreshnessDecision(coordinator, {
+    const decision = {
       action,
       decision: "syncing_hold",
       target,
       inboxTrustState: "untrusted",
       reason: "target_first_touch_recent_context",
       pendingCount: 0,
-      pendingMaxSeq: seenUpToSeq,
+      pendingMaxSeq: heldBoundary.seenUpToSeq,
       modelSeenSeq: 0,
-      heldMessageCount: recent.length,
-      omittedMessageCount: 0
-    });
+      heldMessageCount: heldMessages.length,
+      omittedMessageCount
+    };
+    const producerFactId = buildApmFreshnessDecisionProducerFactId(registration.agentId, decision);
+    recordFreshnessDecision(coordinator, { ...decision, producerFactId });
     return {
       bodyText: JSON.stringify(body),
       target,
-      localResponse: {
-        state: "held",
-        outcome: "held",
-        subtype: "freshness",
-        reason: "newer_messages_available",
-        available_actions: heldAvailableActions(action),
-        seenUpToSeq,
-        heldMessages: recent,
-        newMessageCount: recent.length,
-        shownMessageCount: recent.length,
-        omittedMessageCount: 0
-      }
+      localResponse: projectApmHeldFreshnessEnvelope({
+        producerFactId,
+        action,
+        heldMessages,
+        newMessageCount: unconsumedCounterparty.length,
+        omittedMessageCount,
+        seenUpToSeq
+      }).body
     };
   }
   recordFreshnessDecision(coordinator, {
@@ -2512,7 +3079,7 @@ function collectResultErrorDetail(message, fallback) {
   return parts.join(" | ") || fallback;
 }
 function isProviderApiFailureText(value, hasToolUse) {
-  return !hasToolUse && /^\s*API Error:/i.test(value) && (/\b(?:ECONNRESET|EPIPE|ETIMEDOUT|ECONNREFUSED|ENOTFOUND|EAI_AGAIN)\b/i.test(value) || /\bUnable to connect to API\b/i.test(value) || /\b(?:timed out|timeout)\b/i.test(value) || /\b5\d{2}\b/.test(value));
+  return !hasToolUse && /^\s*API Error:/i.test(value) && (/\b(?:ECONNRESET|EPIPE|ETIMEDOUT|ECONNREFUSED|ENOTFOUND|EAI_AGAIN)\b/i.test(value) || /\bUnable to connect to API\b/i.test(value) || /\b(?:timed out|timeout)\b/i.test(value) || /\b4\d{2}\b/.test(value) || /\b5\d{2}\b/.test(value));
 }
 var ClaudeEventNormalizer = class {
   normalizeLine(line) {
@@ -3538,6 +4105,7 @@ var CodexDriver = class {
       cwd: ctx.workingDirectory,
       approvalPolicy: "never",
       sandbox: "danger-full-access",
+      sandbox_mode: "danger-full-access",
       developerInstructions: ctx.standingPrompt,
       // Raw response items are used only as payload-free liveness signals in
       // the daemon. They replace the previous transcript-mtime heuristic.
@@ -5356,7 +5924,7 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
 }
 
 // src/runtimeErrorDiagnostics.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var MAX_RUNTIME_ERROR_MESSAGE_EXCERPT_CHARS = 4096;
 var RUNTIME_AUTH_ACTION_REQUIRED_PATTERNS = [
   /access token could not be refreshed/i,
@@ -5506,7 +6074,7 @@ function runtimeDisplayName(runtimeId) {
 }
 function fingerprintRuntimeError(value) {
   const normalized = value.toLowerCase().replace(/[0-9a-f]{12,}/g, "<hex>").replace(/\b\d+\b/g, "<num>").replace(/\s+/g, " ").trim();
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function bucketLength(length) {
   if (length === 0) return "0";
@@ -5612,6 +6180,9 @@ var RuntimeNotificationState = class {
 var DEFAULT_MAX_CONCURRENT_AGENT_STARTS = 5;
 var DEFAULT_AGENT_START_INTERVAL_MS = 500;
 var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS = 3;
+function assertNeverApmEffect(effect) {
+  throw new Error(`Unhandled APM gated steering effect: ${String(effect)}`);
+}
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS = 250;
 var WORKSPACE_TEXT_FILE_MAX_BYTES = 1048576;
 var WORKSPACE_IMAGE_PREVIEW_MAX_BYTES = 5 * 1024 * 1024;
@@ -5917,7 +6488,8 @@ function formatIncomingMessage(message, driver) {
   const senderType = formatVisibleActorType(message.sender_type);
   const attachSuffix = message.attachments?.length ? ` [${message.attachments.length} attachment${message.attachments.length > 1 ? "s" : ""}: ${message.attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to download]` : "";
   const taskSuffix = message.task_status ? ` [task #${message.task_number} status=${message.task_status}${message.task_assignee_id ? ` assignee=${formatTaskAssigneeType(message.task_assignee_type)}:${message.task_assignee_id}` : ""}]` : "";
-  const body = `[target=${target} msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(message)}: ${message.content}${attachSuffix}${taskSuffix}`;
+  const lineageSuffix = formatProducerFactLineageBracket(message.producerFactId);
+  const body = `[target=${target} msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(message)}: ${message.content}${attachSuffix}${taskSuffix}${lineageSuffix}`;
   return threadJoinPrefix ? `${threadJoinPrefix}
 ${body}` : body;
 }
@@ -5959,6 +6531,8 @@ function buildUnreadSummary(messages, excludeChannel) {
 var MAX_TRAJECTORY_TEXT = 2e3;
 var TRAJECTORY_COALESCE_MS = 350;
 var ACTIVITY_HEARTBEAT_MS = 6e4;
+var STDIN_NOTIFICATION_INITIAL_DELAY_MS = 3e3;
+var STDIN_NOTIFICATION_RETRY_DELAY_MS = 15e3;
 var COMPACTION_STALE_MS = 5 * 6e4;
 var RUNTIME_PROGRESS_STALE_MS = 15 * 6e4;
 var DEFAULT_RUNTIME_START_TIMEOUT_MS = 2 * 6e4;
@@ -5967,7 +6541,6 @@ var MAX_STDOUT_LINES = 8;
 var MAX_STDOUT_LINE_LENGTH = 240;
 var MAX_STDERR_LINES = 8;
 var MAX_STDERR_LINE_LENGTH = 240;
-var MAX_GATED_STEERING_EVENTS = 12;
 var ONBOARDING_MEMORY_SEED_ENV = "SLOCK_ONBOARDING_MEMORY_SEED";
 var FIRST_CINDY_SEED_MODE = "first-cindy";
 function getOnboardingSeedMode(config) {
@@ -6383,13 +6956,8 @@ function stripManagedRunnerCredential(config) {
 }
 function createGatedSteeringState() {
   return {
-    phase: "idle",
-    outstandingToolUses: 0,
-    compacting: false,
-    toolBoundaryFlushDisabled: process.env.SLOCK_CLAUDE_GATED_STEERING_TOOL_BOUNDARY === "0",
-    lastFlushReason: null,
-    recentEvents: [],
-    inFlightBatch: null
+    ...createInitialApmGatedSteeringState(),
+    toolBoundaryFlushDisabled: process.env.SLOCK_CLAUDE_GATED_STEERING_TOOL_BOUNDARY === "0"
   };
 }
 var RUNTIME_PROFILE_MIGRATION_MESSAGE_PREFIX = "runtime-profile-migration-";
@@ -6408,7 +6976,7 @@ function runtimeProfileNotificationTitle(kind) {
 }
 function hashRuntimeProfileKey(key) {
   if (!key) return void 0;
-  return createHash2("sha256").update(key).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(key).digest("hex").slice(0, 16);
 }
 function runtimeProfileTurnControl(kind, key, source) {
   return {
@@ -6680,6 +7248,19 @@ function summarizeMessageInputBytes(messages) {
     runtime_input_thread_context_content_bytes_bucket: bucketBytes(threadContextContentBytes)
   };
 }
+function messageProducerFactTraceAttrs(messages) {
+  if (!messages || messages.length === 0) return {};
+  const producerFactIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    const producerFactId = typeof message.producerFactId === "string" ? message.producerFactId.trim() : "";
+    if (producerFactId) producerFactIds.add(producerFactId);
+  }
+  if (producerFactIds.size === 0) return {};
+  return {
+    message_producer_fact_count: producerFactIds.size,
+    ...producerFactIds.size === 1 ? { message_producer_fact_id: [...producerFactIds][0] } : {}
+  };
+}
 function buildRuntimeInputTraceAttrs(opts) {
   return {
     runtime_input_source: opts.source,
@@ -6748,10 +7329,12 @@ var AgentProcessManager = class _AgentProcessManager {
   driverResolver;
   defaultAgentEnvVarsProvider;
   tracer;
+  stdinNotificationRetryMs;
   cliTransportTraceDir = null;
   deliveryTraceContexts = /* @__PURE__ */ new WeakMap();
   processExitTraceAttrs = /* @__PURE__ */ new WeakMap();
   agentVisibleBoundaries = /* @__PURE__ */ new Map();
+  agentVisibleMessageIds = /* @__PURE__ */ new Map();
   constructor(chatBridgePath, sendToServer, daemonApiKey, opts) {
     this.chatBridgePath = chatBridgePath;
     this.slockCliPath = opts.slockCliPath ?? "";
@@ -6763,6 +7346,10 @@ var AgentProcessManager = class _AgentProcessManager {
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
     this.tracer = opts.tracer ?? noopTracer;
+    this.stdinNotificationRetryMs = Math.max(
+      0,
+      Math.floor(opts.stdinNotificationRetryMs ?? STDIN_NOTIFICATION_RETRY_DELAY_MS)
+    );
     this.maxConcurrentAgentStarts = Math.max(
       1,
       Math.floor(
@@ -6793,6 +7380,29 @@ var AgentProcessManager = class _AgentProcessManager {
   getVisibleBoundary(agentId, target) {
     return this.agentVisibleBoundaries.get(agentId)?.get(target);
   }
+  visibleMessageIdMap(agentId) {
+    let map = this.agentVisibleMessageIds.get(agentId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.agentVisibleMessageIds.set(agentId, map);
+    }
+    return map;
+  }
+  getVisibleMessageIdSet(agentId, target) {
+    return this.agentVisibleMessageIds.get(agentId)?.get(target);
+  }
+  isVisibleMessageModelSeen(agentId, target, message) {
+    const seq = Number(message.seq ?? 0);
+    const boundary = this.getVisibleBoundary(agentId, target);
+    if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= Math.floor(seq)) return true;
+    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;
+  }
+  scheduleStdinNotification(agentId, ap, delayMs) {
+    return ap.notifications.schedule(() => {
+      this.sendStdinNotification(agentId);
+    }, delayMs);
+  }
   allPendingVisibleMessages(agentId) {
     const collect = (messages) => (messages ?? []).filter((message) => typeof message.seq === "number" && message.seq > 0);
     return [
@@ -6822,13 +7432,14 @@ var AgentProcessManager = class _AgentProcessManager {
     };
     for (const message of input.messages) {
       const seq = Number(message.seq ?? 0);
-      if (!Number.isFinite(seq) || seq <= 0) continue;
       const target = input.target ?? formatVisibleMessageTarget(message);
       if (!target) continue;
       const bucket = ensureBucket(target);
-      bucket.maxSeq = Math.max(bucket.maxSeq, Math.floor(seq));
-      bucket.seqs.add(Math.floor(seq));
-      const id = typeof message.id === "string" ? message.id : typeof message.message_id === "string" ? message.message_id : null;
+      if (Number.isFinite(seq) && seq > 0) {
+        bucket.maxSeq = Math.max(bucket.maxSeq, Math.floor(seq));
+        bucket.seqs.add(Math.floor(seq));
+      }
+      const id = typeof message.message_id === "string" ? message.message_id : typeof message.id === "string" ? message.id : null;
       if (id) bucket.ids.add(id);
     }
     if (input.target && typeof input.boundarySeq === "number" && Number.isFinite(input.boundarySeq) && input.boundarySeq > 0) {
@@ -6837,10 +7448,19 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     if (byTarget.size === 0) return;
     const boundaryMap = this.visibleBoundaryMap(agentId);
+    const visibleIds = this.visibleMessageIdMap(agentId);
     for (const [target, bucket] of byTarget) {
       const highWaterSeq = Math.max(bucket.maxSeq, bucket.boundarySeq);
       const previous = boundaryMap.get(target) ?? 0;
       boundaryMap.set(target, Math.max(previous, highWaterSeq));
+      if (bucket.ids.size > 0) {
+        let targetIds = visibleIds.get(target);
+        if (!targetIds) {
+          targetIds = /* @__PURE__ */ new Set();
+          visibleIds.set(target, targetIds);
+        }
+        for (const id of bucket.ids) targetIds.add(id);
+      }
     }
     const suppress = (messages) => {
       if (!messages || messages.length === 0) return 0;
@@ -6873,6 +7493,7 @@ var AgentProcessManager = class _AgentProcessManager {
     return {
       getBoundary: (target) => this.getVisibleBoundary(agentId, target),
       getPendingMessages: (target) => this.pendingVisibleMessages(agentId, target),
+      isMessageModelSeen: ({ target, message }) => this.isVisibleMessageModelSeen(agentId, target, message),
       getAllPendingMessages: () => this.allPendingVisibleMessages(agentId),
       consumeVisibleMessages: (input) => this.consumeVisibleMessages(agentId, input),
       recordDrainOutcome: (input) => {
@@ -6888,20 +7509,16 @@ var AgentProcessManager = class _AgentProcessManager {
       recordProxyFailure: (input) => this.recordAgentProxyFailure(agentId, input),
       recordTransportNormalizedError: (input) => this.recordAgentProxyTransportNormalizedError(agentId, input),
       recordFreshnessDecision: (input) => {
+        const producerFactId = input.producerFactId ?? buildApmFreshnessDecisionProducerFactId(agentId, input);
+        const trace = projectApmFreshnessDecisionTrace({
+          producerFactId,
+          decision: input
+        });
         this.recordDaemonTrace("daemon.agent.inbox.freshness_decision", {
           agentId,
-          action: input.action,
-          decision: input.decision,
-          target: input.target,
-          inbox_trust_state: input.inboxTrustState,
-          reason: input.reason,
-          pending_count: input.pendingCount,
-          pending_max_seq: input.pendingMaxSeq,
-          model_seen_seq: input.modelSeenSeq,
-          held_message_count: input.heldMessageCount,
-          omitted_message_count: input.omittedMessageCount
+          ...trace.attrs
         });
-        this.recordFreshnessDecisionActivity(agentId, input);
+        this.recordFreshnessDecisionActivity(agentId, input, producerFactId);
       }
     };
   }
@@ -6931,20 +7548,17 @@ var AgentProcessManager = class _AgentProcessManager {
       upstream: input.upstream
     }, "error");
   }
-  recordFreshnessDecisionActivity(agentId, input) {
+  recordFreshnessDecisionActivity(agentId, input, producerFactId) {
     if (input.decision !== "local_hold" && input.decision !== "syncing_hold") return;
     const ap = this.agents.get(agentId);
     const messageCount = input.pendingCount ?? input.heldMessageCount ?? 0;
-    const title = input.action === "send" ? "Send held by freshness check" : input.action === "task_claim" ? "Task claim held by freshness check" : "Task update held by freshness check";
-    const entry = {
-      kind: "slock_action",
-      title,
-      text: [
-        input.target ? `target: ${input.target}` : null,
-        `new messages: ${messageCount} newer message${messageCount === 1 ? "" : "s"}`,
-        `decision: ${input.decision === "syncing_hold" ? "syncing hold" : "local hold"}; review the newer context before retrying`
-      ].filter((line) => Boolean(line)).join("\n")
-    };
+    const entry = projectApmHeldFreshnessActivity({
+      producerFactId,
+      action: input.action,
+      decision: input.decision,
+      target: input.target,
+      messageCount
+    }).entry;
     if (ap) ap.activityClientSeq += 1;
     this.sendToServer({
       type: "agent:activity",
@@ -7353,7 +7967,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         notifications: new RuntimeNotificationState(),
         activityHeartbeat: null,
         startupTimeoutTimer: null,
-        startupTimedOut: false,
         compactionWatchdog: null,
         compactionStartedAt: null,
         runtimeProgress: new RuntimeProgressState(Date.now()),
@@ -7485,7 +8098,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           this.clearStalledRecoverySigtermWatchdog(ap);
           const finalCode = ap.exitCode ?? code;
           const finalSignal = ap.exitSignal ?? signal;
-          const expectedTermination = Boolean(ap.expectedTerminationReason) || ap.startupTimedOut;
+          const startupTimeoutTermination = ap.expectedTerminationReason === "startup_timeout";
+          const expectedTermination = Boolean(ap.expectedTerminationReason);
           const processEndedCleanly = finalCode === 0 || expectedTermination && !ap.lastRuntimeError;
           const terminalFailureDetail = processEndedCleanly ? null : classifyTerminalFailure(ap);
           const resumeRecoveryReason = resumeSessionRecoveryReason(ap);
@@ -7589,7 +8203,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               });
               logger.warn(`[Agent ${agentId}] Recoverable provider stream failure (${reason}) \u2014 keeping agent wakeable`);
               this.sendAgentStatus(agentId, "active", ap.launchId);
-            } else if (ap.startupTimedOut) {
+            } else if (startupTimeoutTermination) {
               logger.warn(`[Agent ${agentId}] Startup timeout cleanup completed (${reason})`);
             } else {
               this.idleAgentConfigs.delete(agentId);
@@ -7597,7 +8211,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               this.sendAgentStatus(agentId, "inactive", ap.launchId);
             }
             if (terminalFailureDetail) {
-              if (!ap.startupTimedOut) {
+              if (!startupTimeoutTermination) {
                 this.broadcastActivity(
                   agentId,
                   "error",
@@ -7795,9 +8409,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           pendingMessages: ap.inbox.length
         });
       } else if (!ap.notifications.hasTimer) {
-        ap.notifications.schedule(() => {
-          this.sendStdinNotification(agentId);
-        }, 3e3);
+        this.scheduleStdinNotification(agentId, ap, STDIN_NOTIFICATION_INITIAL_DELAY_MS);
       }
     }
     this.recordDaemonTrace("daemon.agent.runtime_profile.routed", {
@@ -7975,7 +8587,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       const nextMessages = ap.inbox.splice(0, ap.inbox.length);
       nextMessages.push(message);
-      ap.isIdle = false;
+      this.commitApmIdleState(agentId, ap, false);
       this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery", nextMessages);
       this.broadcastActivity(agentId, "working", "Message received");
       const stdinAccepted = this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle");
@@ -8059,9 +8671,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (ap.driver.busyDeliveryMode === "gated") {
       ap.notifications.add();
       if (!ap.notifications.hasTimer) {
-        ap.notifications.schedule(() => {
-          this.sendStdinNotification(agentId);
-        }, 3e3);
+        this.scheduleStdinNotification(agentId, ap, STDIN_NOTIFICATION_INITIAL_DELAY_MS);
       }
       this.recordGatedSteeringEvent(agentId, ap, "buffer", {
         reason: "busy_message",
@@ -8082,9 +8692,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     ap.notifications.add();
     if (!ap.notifications.hasTimer) {
-      ap.notifications.schedule(() => {
-        this.sendStdinNotification(agentId);
-      }, 3e3);
+      this.scheduleStdinNotification(agentId, ap, STDIN_NOTIFICATION_INITIAL_DELAY_MS);
     }
     this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
       outcome: "queued_busy_notification",
@@ -8258,7 +8866,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       return true;
     }
     if (ap?.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) {
-      ap.isIdle = false;
+      this.commitApmIdleState(agentId, ap, false);
       this.startRuntimeTrace(agentId, ap, "runtime-profile", [message]);
       const written = this.deliverMessagesViaStdin(agentId, ap, [message], "idle");
       span.end(written ? "ok" : "error", {
@@ -8768,18 +9376,22 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (!ap || !ap.compactionStartedAt) return;
     this.clearCompactionWatchdog(ap);
     this.broadcastActivity(agentId, "working", detail, [{ kind: "compaction_finished" }]);
-    ap.gatedSteering.compacting = false;
-    this.setGatedSteeringPhase(agentId, ap, "assistant_continuation", { event: "compaction_finished", inferred: true });
+    const reduction = reduceApmGatedCompaction(ap.gatedSteering, { kind: "compaction_finished" });
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, {
+      event: "compaction_finished",
+      inferred: true
+    });
     if (options.flushBoundaryMessages ?? true) {
       this.flushCompactionBoundaryMessages(agentId, ap);
     }
-    ap.isIdle = false;
+    this.commitApmIdleState(agentId, ap, false);
   }
   interruptCompactionIfActive(agentId) {
     const ap = this.agents.get(agentId);
     if (!ap || !ap.compactionStartedAt && !ap.gatedSteering.compacting) return;
     this.clearCompactionWatchdog(ap);
-    ap.gatedSteering.compacting = false;
+    const reduction = reduceApmGatedCompaction(ap.gatedSteering, { kind: "compaction_interrupted" });
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
   }
   messagesTraceAttrs(messages) {
     if (!messages || messages.length === 0) return {};
@@ -8792,6 +9404,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         message_id_present: Boolean(first.message_id),
         deliveryId: context.deliveryId,
         delivery_correlation_id: context.deliveryId,
+        ...messageProducerFactTraceAttrs(messages),
         control_kind: notification.kind,
         key_present: Boolean(notification.key),
         runtime_profile_control_kind: notification.kind,
@@ -8804,7 +9417,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       messageId: first.message_id,
       message_id_present: Boolean(first.message_id),
       deliveryId: context.deliveryId,
-      delivery_correlation_id: context.deliveryId ?? first.message_id
+      delivery_correlation_id: context.deliveryId ?? first.message_id,
+      ...messageProducerFactTraceAttrs(messages)
     };
   }
   runtimeProfileTurnControlTraceAttrs(control) {
@@ -8893,10 +9507,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   recordGatedSteeringEvent(agentId, ap, event, attrs = {}) {
     if (ap.driver.busyDeliveryMode !== "gated") return;
-    const summary = `${event}:${ap.gatedSteering.phase}:tools=${ap.gatedSteering.outstandingToolUses}:compact=${ap.gatedSteering.compacting}`;
-    ap.gatedSteering.recentEvents.push(summary);
-    ap.gatedSteering.recentEvents = ap.gatedSteering.recentEvents.slice(-MAX_GATED_STEERING_EVENTS);
+    const reduction = reduceApmGatedRecentEvent(ap.gatedSteering, { event });
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
     this.recordRuntimeTraceEvent(agentId, ap, `runtime.gated_steering.${event}`, {
+      isIdle: ap.gatedSteering.isIdle,
+      expectedTerminationReason: ap.gatedSteering.expectedTerminationReason,
       phase: ap.gatedSteering.phase,
       outstandingToolUses: ap.gatedSteering.outstandingToolUses,
       compacting: ap.gatedSteering.compacting,
@@ -8905,63 +9520,110 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       ...attrs
     });
   }
-  setGatedSteeringPhase(agentId, ap, phase, attrs = {}) {
-    if (!ap || ap.driver.busyDeliveryMode !== "gated") return;
-    ap.gatedSteering.phase = phase;
-    this.recordGatedSteeringEvent(agentId, ap, "phase", attrs);
-  }
-  tryFlushGatedSteering(agentId, ap, reason) {
-    if (ap.driver.busyDeliveryMode !== "gated") return false;
-    if (!ap.sessionId || ap.inbox.length === 0) return false;
-    if (reason !== "turn_end") {
-      if (ap.gatedSteering.toolBoundaryFlushDisabled) return false;
-      if (ap.gatedSteering.compacting || ap.gatedSteering.outstandingToolUses > 0) return false;
-      this.recordGatedSteeringEvent(agentId, ap, "notify", { reason, pendingMessages: ap.inbox.length });
-      return this.sendStdinNotification(agentId);
-    }
-    const pendingMessages = ap.inbox.length;
-    const pendingNotificationCount = ap.notifications.pendingCount;
-    const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-    ap.notifications.clear();
-    ap.gatedSteering.lastFlushReason = reason;
-    if (reason !== "turn_end") {
-      ap.gatedSteering.inFlightBatch = {
-        reason,
-        messages: nextMessages
-      };
-    } else {
-      ap.gatedSteering.inFlightBatch = null;
-    }
-    this.recordGatedSteeringEvent(agentId, ap, "flush", { reason, messageCount: nextMessages.length });
-    logger.info(
-      `[Agent ${agentId}] Claude gated steering flush reason=${reason} messages=${nextMessages.length}`
-    );
-    if (reason === "turn_end") {
-      this.broadcastActivity(agentId, "working", "Message received");
-    }
-    if (this.deliverMessagesViaStdin(agentId, ap, nextMessages, reason === "turn_end" ? "idle" : "busy")) {
-      return true;
+  commitGatedSteeringDecisionState(agentId, ap, nextState, phaseEventAttrs) {
+    ap.gatedSteering.phase = nextState.phase;
+    ap.gatedSteering.outstandingToolUses = nextState.outstandingToolUses;
+    ap.gatedSteering.compacting = nextState.compacting;
+    ap.gatedSteering.toolBoundaryFlushDisabled = nextState.toolBoundaryFlushDisabled;
+    ap.gatedSteering.lastFlushReason = nextState.lastFlushReason;
+    ap.gatedSteering.recentEvents = nextState.recentEvents;
+    ap.gatedSteering.isIdle = nextState.isIdle;
+    ap.gatedSteering.expectedTerminationReason = nextState.expectedTerminationReason;
+    ap.isIdle = nextState.isIdle;
+    ap.expectedTerminationReason = nextState.expectedTerminationReason;
+    if (phaseEventAttrs) {
+      this.recordGatedSteeringEvent(agentId, ap, "phase", phaseEventAttrs);
+    }
+  }
+  commitApmIdleState(agentId, ap, isIdle) {
+    const reduction = reduceApmIdleState(ap.gatedSteering, { isIdle });
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
+  }
+  notifyGatedSteeringBoundary(agentId, ap, reason) {
+    const readiness = reduceApmGatedFlushReadiness(ap.gatedSteering, {
+      isGated: ap.driver.busyDeliveryMode === "gated",
+      hasSession: Boolean(ap.sessionId),
+      inboxLength: ap.inbox.length,
+      reason
+    });
+    if (readiness.effects.length === 0) return false;
+    let didExecute = false;
+    for (const effect of readiness.effects) {
+      didExecute = this.executeApmGatedSteeringEffect(agentId, ap, effect) || didExecute;
     }
-    if (reason !== "turn_end") {
-      ap.gatedSteering.inFlightBatch = null;
+    return didExecute;
+  }
+  recordApmGatedSteeringEffectTrace(agentId, ap, effect, attrs) {
+    this.recordDaemonTrace("daemon.apm.gated_effect", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      effect_kind: effect.kind,
+      reason: effect.reason,
+      target: "runtime-stdin",
+      stdin_mode: effect.stdinMode,
+      clause_id: effect.clauseId,
+      pending_messages: ap.inbox.length,
+      ...attrs
+    });
+  }
+  executeApmGatedSteeringEffect(agentId, ap, effect) {
+    switch (effect.kind) {
+      case "notify_stdin":
+        this.recordGatedSteeringEvent(agentId, ap, "notify", {
+          reason: effect.reason,
+          pendingMessages: ap.inbox.length
+        });
+        {
+          const written = this.sendStdinNotification(agentId);
+          this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
+            outcome: written ? "written" : "not_written"
+          });
+          return written;
+        }
+      case "deliver_stdin": {
+        const messages = ap.inbox.splice(0, ap.inbox.length);
+        ap.notifications.clear();
+        if (messages.length === 0) {
+          this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
+            outcome: "empty",
+            delivered_messages_count: 0
+          });
+          return true;
+        }
+        if (ap.driver.busyDeliveryMode === "gated") {
+          const flushReduction = reduceApmGatedFlush(ap.gatedSteering, { reason: effect.reason });
+          this.commitGatedSteeringDecisionState(agentId, ap, flushReduction.nextState);
+          this.recordGatedSteeringEvent(agentId, ap, "flush", {
+            reason: effect.reason,
+            messageCount: messages.length
+          });
+        }
+        this.broadcastActivity(agentId, "working", "Message received");
+        const accepted = this.deliverMessagesViaStdin(agentId, ap, messages, effect.stdinMode);
+        this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
+          outcome: accepted ? "written" : "not_written",
+          delivered_messages_count: messages.length
+        });
+        return accepted;
+      }
+      default:
+        return assertNeverApmEffect(effect);
     }
-    ap.notifications.add(pendingNotificationCount || pendingMessages);
-    return false;
   }
   flushCompactionBoundaryMessages(agentId, ap) {
-    if (!ap.sessionId || !ap.driver.supportsStdinNotification || ap.inbox.length === 0) return false;
-    if (ap.notifications.pendingCount > 0) {
-      ap.notifications.clearTimer();
-      this.sendStdinNotification(agentId);
-      return true;
+    const reduction = reduceApmGatedCompactionBoundaryFlush(ap.gatedSteering, {
+      hasSession: Boolean(ap.sessionId),
+      supportsStdinNotification: ap.driver.supportsStdinNotification,
+      inboxLength: ap.inbox.length,
+      pendingNotificationCount: ap.notifications.pendingCount
+    });
+    if (reduction.effects.length === 0) return false;
+    ap.notifications.clearTimer();
+    for (const effect of reduction.effects) {
+      this.executeApmGatedSteeringEffect(agentId, ap, effect);
     }
-    return false;
-  }
-  clearGatedInFlightBatch(agentId, ap, reason) {
-    if (ap.driver.busyDeliveryMode !== "gated" || !ap.gatedSteering.inFlightBatch) return;
-    const messageCount = ap.gatedSteering.inFlightBatch.messages.length;
-    ap.gatedSteering.inFlightBatch = null;
-    this.recordGatedSteeringEvent(agentId, ap, "ack", { reason, messageCount });
+    return true;
   }
   startRuntimeStartupTimeout(agentId, ap) {
     const timeoutMs = runtimeStartTimeoutMs();
@@ -8979,14 +9641,17 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   handleRuntimeStartupTimeout(agentId, ap, timeoutMs) {
     const current = this.agents.get(agentId);
     if (current !== ap) return;
-    if (ap.runtimeProgress.lastEventKind) {
+    const reduction = reduceApmStartupTimeoutTermination(ap.gatedSteering, {
+      hasRuntimeProgressEvent: Boolean(ap.runtimeProgress.lastEventKind)
+    });
+    if (!reduction.shouldTerminate) {
       this.clearRuntimeStartupTimeout(ap);
       return;
     }
     this.clearRuntimeStartupTimeout(ap);
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
     const terminalFailureDetail = classifyTerminalFailure(ap);
     const detail = terminalFailureDetail?.detail ?? formatRuntimeStartTimeoutMessage(ap.driver.id);
-    ap.startupTimedOut = true;
     ap.lastRuntimeError = detail;
     ap.runtimeProgress.markStale();
     const staleForMs = Math.max(timeoutMs, ap.runtimeProgress.ageMs());
@@ -9015,6 +9680,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     try {
       this.processExitTraceAttrs.set(ap.process, {
         stop_source: "startup_timeout",
+        expectedTerminationReason: "startup_timeout",
         timeout_ms: timeoutMs
       });
       ap.process.kill("SIGTERM");
@@ -9023,20 +9689,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       logger.warn(`[Agent ${agentId}] Failed to terminate startup-timed-out ${ap.driver.id} process: ${reason}`);
     }
   }
-  requeueGatedInFlightBatch(agentId, ap, reason) {
-    if (ap.driver.busyDeliveryMode !== "gated" || !ap.gatedSteering.inFlightBatch) return;
-    const batch = ap.gatedSteering.inFlightBatch;
-    ap.gatedSteering.inFlightBatch = null;
-    ap.inbox.unshift(...batch.messages);
-    ap.notifications.add(batch.messages.length);
-    this.recordGatedSteeringEvent(agentId, ap, "requeue", {
-      reason,
-      originalFlushReason: batch.reason,
-      messageCount: batch.messages.length
-    });
-  }
   isThinkingBlockMutationError(message) {
-    return /thinking.*redacted_thinking|redacted_thinking.*thinking/i.test(message) && /cannot be modified/i.test(message);
+    return /thinking.*redacted_thinking|redacted_thinking.*thinking/i.test(message) && /cannot be modified/i.test(message) || /messages\.\d+\.content\.\d+\.text\.start_timestamp:\s*Extra inputs are not permitted/i.test(message);
   }
   markRuntimeProgressStaleIfNeeded(agentId, ap) {
     if (ap.lastActivity !== "working" && ap.lastActivity !== "thinking") return false;
@@ -9068,16 +9722,22 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return true;
   }
   recoverStaleProcessForQueuedMessageIfNeeded(agentId, ap) {
-    if (ap.inbox.length === 0) return false;
-    if (ap.expectedTerminationReason === "stalled_recovery") {
+    const staleForMs = ap.runtimeProgress.ageMs();
+    const reduction = reduceApmStalledRecoveryTermination(ap.gatedSteering, {
+      inboxLength: ap.inbox.length,
+      supportsStdinNotification: ap.driver.supportsStdinNotification,
+      busyDeliveryMode: ap.driver.busyDeliveryMode,
+      hasSession: Boolean(ap.sessionId),
+      hasDirectStdinRecoveryEvidence: hasDirectStdinRecoveryEvidence(ap),
+      runtimeProgressIsStale: ap.runtimeProgress.isStale,
+      staleForMs,
+      staleThresholdMs: RUNTIME_PROGRESS_STALE_MS
+    });
+    if (reduction.alreadyRecovering) {
       return true;
     }
-    const directStdinRuntime = ap.driver.supportsStdinNotification && ap.driver.busyDeliveryMode === "direct";
-    const canRestartDirectStdinProcess = directStdinRuntime && Boolean(ap.sessionId) && (ap.gatedSteering.outstandingToolUses === 0 || hasDirectStdinRecoveryEvidence(ap));
-    const canRestartStalledProcess = !ap.driver.supportsStdinNotification || canRestartDirectStdinProcess;
-    if (!canRestartStalledProcess) return false;
-    const staleForMs = ap.runtimeProgress.ageMs();
-    if (staleForMs < RUNTIME_PROGRESS_STALE_MS && !ap.runtimeProgress.isStale) return false;
+    if (!reduction.shouldTerminate) return false;
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
     ap.runtimeProgress.markStale();
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
@@ -9103,7 +9763,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
-    ap.expectedTerminationReason = "stalled_recovery";
     const runtimeLabel = ap.driver.id === "opencode" ? "OpenCode" : ap.driver.id;
     logger.warn(
       `[Agent ${agentId}] ${runtimeLabel} process stalled for ${staleForMinutes}m with ${ap.inbox.length} queued message(s); terminating for restart`
@@ -9169,31 +9828,32 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.sendRuntimeProfileReport(agentId);
         break;
       case "thinking": {
-        if (ap) this.clearGatedInFlightBatch(agentId, ap, "non_error_progress");
         this.completeCompactionIfActive(agentId, "Context compaction finished (inferred from resumed output)");
         this.queueTrajectoryText(agentId, "thinking", event.text);
-        if (ap) ap.isIdle = false;
-        this.setGatedSteeringPhase(agentId, ap, "assistant_continuation", { event: "thinking" });
+        if (ap) {
+          const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "thinking" });
+        }
         break;
       }
       case "text": {
-        if (ap) this.clearGatedInFlightBatch(agentId, ap, "non_error_progress");
         this.completeCompactionIfActive(agentId, "Context compaction finished (inferred from resumed output)");
         this.queueTrajectoryText(agentId, "text", event.text);
-        if (ap) ap.isIdle = false;
-        this.setGatedSteeringPhase(agentId, ap, "assistant_continuation", { event: "text" });
+        if (ap) {
+          const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "text" });
+        }
         break;
       }
       case "tool_call": {
-        if (ap) this.clearGatedInFlightBatch(agentId, ap, "non_error_progress");
         this.completeCompactionIfActive(agentId, "Context compaction finished (inferred from resumed tool use)");
         this.flushPendingTrajectory(agentId);
         const invocation = normalizeToolDisplayInvocation(event.name, event.input);
         if (ap) {
-          ap.gatedSteering.outstandingToolUses++;
+          const reduction = reduceApmGatedToolUse(ap.gatedSteering, { kind: "tool_call" });
           this.noteRuntimeProfileToolCall(agentId, ap, invocation.toolName);
           this.recordRuntimeTraceEvent(agentId, ap, "tool.call.started", { tool: invocation.toolName });
-          this.setGatedSteeringPhase(agentId, ap, "tool_wait", {
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, {
             event: "tool_call",
             tool: invocation.toolName
           });
@@ -9205,23 +9865,20 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           toolName: invocation.toolName,
           toolInput: inputSummary
         }]);
-        if (ap) ap.isIdle = false;
         break;
       }
       case "tool_output": {
         const invocation = normalizeToolDisplayInvocation(event.name, {});
         if (ap) {
-          const hadOutstandingToolUse = ap.gatedSteering.outstandingToolUses > 0;
-          ap.gatedSteering.outstandingToolUses = Math.max(0, ap.gatedSteering.outstandingToolUses - 1);
+          const reduction = reduceApmGatedToolUse(ap.gatedSteering, { kind: "tool_output" });
           this.recordRuntimeTraceEvent(agentId, ap, "tool.output.observed", { tool: invocation.toolName });
           this.recordRuntimeTraceEvent(agentId, ap, "runtime.continuation.expected");
-          this.setGatedSteeringPhase(agentId, ap, "tool_boundary", {
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, {
             event: "tool_output",
             tool: invocation.toolName
           });
-          ap.isIdle = false;
-          if (hadOutstandingToolUse && ap.gatedSteering.outstandingToolUses === 0) {
-            this.tryFlushGatedSteering(agentId, ap, "tool_batch_complete");
+          if (reduction.shouldFlushToolBatch) {
+            this.notifyGatedSteeringBoundary(agentId, ap, "tool_batch_complete");
           }
         }
         break;
@@ -9232,9 +9889,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (ap) this.startCompactionWatchdog(agentId, ap);
         this.broadcastActivity(agentId, "working", "Compacting context", [{ kind: "compaction_started" }]);
         if (ap) {
-          ap.gatedSteering.compacting = true;
-          this.setGatedSteeringPhase(agentId, ap, "compacting", { event: "compaction_started" });
-          ap.isIdle = false;
+          const reduction = reduceApmGatedCompaction(ap.gatedSteering, { kind: "compaction_started" });
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "compaction_started" });
         }
         break;
       case "compaction_finished":
@@ -9243,10 +9899,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (ap) this.clearCompactionWatchdog(ap);
         this.broadcastActivity(agentId, "working", "Context compaction finished", [{ kind: "compaction_finished" }]);
         if (ap) {
-          ap.gatedSteering.compacting = false;
-          this.setGatedSteeringPhase(agentId, ap, "assistant_continuation", { event: "compaction_finished" });
+          const reduction = reduceApmGatedCompaction(ap.gatedSteering, { kind: "compaction_finished" });
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "compaction_finished" });
           this.flushCompactionBoundaryMessages(agentId, ap);
-          ap.isIdle = false;
         }
         break;
       case "turn_end":
@@ -9256,28 +9911,21 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         });
         this.flushPendingTrajectory(agentId);
         if (ap) {
-          this.clearGatedInFlightBatch(agentId, ap, "turn_end");
           if (event.sessionId) ap.sessionId = event.sessionId;
-          ap.gatedSteering.outstandingToolUses = 0;
-          ap.gatedSteering.compacting = false;
-          this.setGatedSteeringPhase(agentId, ap, "idle", { event: "turn_end" });
-          if (ap.inbox.length > 0 && ap.driver.supportsStdinNotification && ap.sessionId) {
-            const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-            ap.notifications.clear();
-            if (ap.driver.busyDeliveryMode === "gated") {
-              ap.gatedSteering.lastFlushReason = "turn_end";
-              this.recordGatedSteeringEvent(agentId, ap, "flush", {
-                reason: "turn_end",
-                messageCount: nextMessages.length
-              });
-            }
-            this.broadcastActivity(agentId, "working", "Message received");
-            if (!this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle")) {
-              ap.isIdle = true;
+          const reduction = reduceApmGatedTurnEnd(ap.gatedSteering, {
+            inboxLength: ap.inbox.length,
+            supportsStdinNotification: ap.driver.supportsStdinNotification,
+            hasSession: Boolean(ap.sessionId),
+            terminateProcessOnTurnEnd: ap.driver.terminateProcessOnTurnEnd === true
+          });
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "turn_end" });
+          const deliverStdinEffect = reduction.effects.find((effect) => effect.kind === "deliver_stdin");
+          if (deliverStdinEffect) {
+            if (!this.executeApmGatedSteeringEffect(agentId, ap, deliverStdinEffect)) {
+              this.commitApmIdleState(agentId, ap, true);
               this.broadcastActivity(agentId, "online", "Idle");
             }
           } else {
-            ap.isIdle = true;
             if (ap.lastRuntimeError) {
               this.broadcastActivity(agentId, "error", ap.lastRuntimeError);
             } else {
@@ -9290,7 +9938,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "turn_end")
           });
           if (ap.driver.terminateProcessOnTurnEnd) {
-            ap.expectedTerminationReason = "turn_end";
             logger.info(`[Agent ${agentId}] Turn completed; terminating ${ap.driver.id} process`);
             try {
               this.processExitTraceAttrs.set(ap.process, {
@@ -9319,10 +9966,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           if (runtimeErrorDiagnostics.spanAttrs.runtime_error_action_required === true) {
             visibleErrorMessage = formatRuntimeLoginRequiredMessage(ap.driver.id);
           }
-          this.setGatedSteeringPhase(agentId, ap, "error", { event: "error" });
-          if (ap.driver.busyDeliveryMode === "gated" && this.isThinkingBlockMutationError(event.message)) {
-            this.requeueGatedInFlightBatch(agentId, ap, "thinking_block_mutation_error");
-            ap.gatedSteering.toolBoundaryFlushDisabled = true;
+          const shouldDisableToolBoundaryFlush = ap.driver.busyDeliveryMode === "gated" && this.isThinkingBlockMutationError(event.message);
+          const terminalFailure = classifyTerminalFailure(ap);
+          const reduction = reduceApmGatedError(ap.gatedSteering, {
+            disableToolBoundaryFlush: shouldDisableToolBoundaryFlush,
+            terminalWakeable: Boolean(ap.driver.supportsStdinNotification && terminalFailure && !terminalFailure.actionRequired)
+          });
+          this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "error" });
+          if (reduction.shouldDisableToolBoundaryFlush) {
             this.recordGatedSteeringEvent(agentId, ap, "disabled", {
               reason: "thinking_block_mutation_error",
               lastFlushReason: ap.gatedSteering.lastFlushReason,
@@ -9341,7 +9992,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             ...runtimeTraceCounterAttrs(ap),
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
           });
-          const terminalFailure = classifyTerminalFailure(ap);
           if (ap.driver.supportsStdinNotification && terminalFailure) {
             if (terminalFailure.actionRequired) {
               logger.warn(`[Agent ${agentId}] ${ap.driver.id} auth requires user action; terminating runtime process`);
@@ -9356,7 +10006,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
                 logger.warn(`[Agent ${agentId}] Failed to terminate ${ap.driver.id} after auth error: ${reason}`);
               }
             } else {
-              ap.isIdle = true;
               ap.notifications.clear();
               logger.info(`[Agent ${agentId}] Marked ${ap.driver.id} wakeable after terminal runtime error`);
             }
@@ -9471,6 +10120,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       return true;
     } else {
       ap.notifications.add(count);
+      const retryScheduled = ap.driver.busyDeliveryMode === "direct" ? this.scheduleStdinNotification(agentId, ap, this.stdinNotificationRetryMs) : false;
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
@@ -9479,6 +10129,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         outcome: "encode_failed",
         mode: "busy",
         pending_notification_count: count,
+        retry_scheduled: retryScheduled,
+        notification_timer_present: ap.notifications.hasTimer,
         inbox_count: inboxCount,
         session_id_present: true
       }, "error");
@@ -9507,7 +10159,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       });
       if (messages.length === 0) {
         if (mode === "idle") {
-          ap.isIdle = true;
+          this.commitApmIdleState(agentId, ap, true);
         }
         return true;
       }
@@ -9549,7 +10201,7 @@ ${RESPONSE_TARGET_HINT}`);
     if (!encoded) {
       ap.inbox.unshift(...messages);
       if (mode === "idle") {
-        ap.isIdle = true;
+        this.commitApmIdleState(agentId, ap, true);
       }
       logger.warn(
         `[Agent ${agentId}] Failed to encode ${mode} stdin delivery; re-queued ${messages.length === 1 ? "message" : `${messages.length} messages`}`
@@ -9901,7 +10553,7 @@ var ReminderCache = class {
 };
 
 // src/machineLock.ts
-import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
 import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
 import os6 from "os";
 import path13 from "path";
@@ -9917,7 +10569,7 @@ var DaemonMachineLockConflictError = class extends Error {
   }
 };
 function apiKeyFingerprint(apiKey) {
-  return createHash3("sha256").update(apiKey).digest("hex");
+  return createHash4("sha256").update(apiKey).digest("hex");
 }
 function getDaemonMachineLockId(apiKey) {
   return `machine-${apiKeyFingerprint(apiKey).slice(0, 16)}`;
@@ -10180,7 +10832,7 @@ function isDiagnosticErrorAttr(key) {
 }
 
 // src/traceBundleUpload.ts
-import { createHash as createHash5, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
 import { gzipSync } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path15 from "path";
@@ -10310,12 +10962,12 @@ async function uploadWithSignedCapability({
 }
 
 // src/traceJitter.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var INITIAL_UPLOAD_DELAY_SPAN_MS = 3e4;
 var UPLOAD_INTERVAL_JITTER_SPAN_MS = 6e4;
 var MAX_FILE_AGE_JITTER_SPAN_MS = 6e4;
 function computeTraceJitter(lockId) {
-  const seed = createHash4("sha256").update(lockId).digest();
+  const seed = createHash5("sha256").update(lockId).digest();
   return {
     initialUploadDelayMs: seed.readUInt32BE(0) % INITIAL_UPLOAD_DELAY_SPAN_MS,
     uploadIntervalJitterMs: seed.readUInt32BE(4) % UPLOAD_INTERVAL_JITTER_SPAN_MS,
@@ -10516,7 +11168,7 @@ var DaemonTraceBundleUploader = class {
   }
 };
 function sha256Hex(body) {
-  return createHash5("sha256").update(body).digest("hex");
+  return createHash6("sha256").update(body).digest("hex");
 }
 function readPositiveIntegerEnv2(name, fallback) {
   const value = process.env[name];