@alook/daemon 0.1.17 → 0.1.19

package/dist/index.js

@@ -1119,19 +1119,23 @@ class ClaudeEventNormalizer {
     const content = event?.message?.content;
     if (!Array.isArray(content))
       return;
+    const completedText = [];
     for (const block of content) {
       if (block?.type === "thinking") {
-        out.push({ kind: "thinking", text: block.thinking ?? "" });
+        out.push({ kind: "assistant_reasoning_completed", text: block.thinking ?? "" });
       } else if (block?.type === "text") {
         const text = block.text ?? "";
         if (API_ERROR_RE.test(text))
           out.push({ kind: "error", message: text });
         else
-          out.push({ kind: "text", text });
+          completedText.push(text);
       } else if (block?.type === "tool_use") {
         out.push({ kind: "tool_call", name: block.name ?? "unknown_tool", input: block.input });
       }
     }
+    if (completedText.length > 0) {
+      out.push({ kind: "assistant_message_completed", text: completedText.join("") });
+    }
   }
   handleUser(event, out) {
     if (event.isReplay === true && typeof event.uuid === "string") {
@@ -1540,14 +1544,17 @@ class CodexEventNormalizer {
         this.turnId = params.turn.id;
         this.terminalTurn = null;
         return [
-          { kind: "turn_owner", receipt: this.turnReceipt(params.threadId, params.turn.id) },
-          { kind: "thinking", text: "" }
+          {
+            kind: "turn_owner",
+            receipt: this.turnReceipt(params.threadId, params.turn.id),
+            nativeTurnId: params.turn.id
+          }
         ];
       case "item/reasoning/textDelta":
       case "item/reasoning/summaryTextDelta":
-        return [{ kind: "thinking", text: params?.delta ?? "" }];
+        return [{ kind: "assistant_reasoning_delta", text: params?.delta ?? "" }];
       case "item/agentMessage/delta":
-        return [{ kind: "text", text: params?.delta ?? "" }];
+        return [{ kind: "assistant_message_delta", text: params?.delta ?? "" }];
       case "item/started":
         return this.handleItemStarted(params);
       case "item/completed":
@@ -1575,7 +1582,10 @@ class CodexEventNormalizer {
         }
         return [{ kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }];
       case "error":
-        return [{ kind: "error", message: params?.message ?? "Codex error" }];
+        if (params?.willRetry === true) {
+          return [{ kind: "runtime_recovery", stage: "retrying", source: "codex_stream" }];
+        }
+        return [{ kind: "error", message: params?.error?.message ?? params?.message ?? "Codex error" }];
       case "thread/tokenUsage/updated":
       case "account/rateLimits/updated":
         return mapCodexTelemetry(method, params);
@@ -1668,9 +1678,9 @@ class CodexEventNormalizer {
       case "collabAgentToolCall":
         return [{ kind: "tool_output", name: "collab_tool_call" }];
       case "agentMessage":
-        return [{ kind: "text", text: params?.item?.text ?? "" }];
+        return [{ kind: "assistant_message_completed", text: params?.item?.text ?? "" }];
       case "reasoning":
-        return [{ kind: "thinking", text: params?.item?.text ?? "" }];
+        return [{ kind: "assistant_reasoning_completed", text: params?.item?.text ?? "" }];
       default:
         return [];
     }
@@ -1703,7 +1713,13 @@ class CodexDriver {
     lifetime: "session",
     transport: { kind: "stdio_rpc", protocol: "codex.app-server.v1" },
     wakeStart: "immediate",
-    terminalOwnership: "transport_request"
+    terminalOwnership: "transport_request",
+    turnSilence: {
+      nativeIdleTimeoutMs: 300000,
+      daemonGraceMs: 60000,
+      recoveryGraceMs: 60000,
+      maxRecoveryExtensions: 1
+    }
   };
   eventNormalizer = new CodexEventNormalizer;
   requestId = 0;
@@ -2360,14 +2376,14 @@ class CursorAcpLane {
       case "agent_message_chunk": {
         const content = record(update.content);
         if (content?.type === "text" && typeof content.text === "string") {
-          this.events.emit("runtime_event", { kind: "text", text: content.text });
+          this.events.emit("runtime_event", { kind: "assistant_message_delta", text: content.text });
         }
         return;
       }
       case "agent_thought_chunk": {
         const content = record(update.content);
         if (content?.type === "text" && typeof content.text === "string") {
-          this.events.emit("runtime_event", { kind: "thinking", text: content.text });
+          this.events.emit("runtime_event", { kind: "assistant_reasoning_delta", text: content.text });
         }
         return;
       }
@@ -3172,16 +3188,20 @@ class OpenCodeServiceLane {
     }
     switch (event.type) {
       case "session.next.step.started":
-        this.events.emit("runtime_event", { kind: "thinking", text: "" });
+        this.events.emit("runtime_event", {
+          kind: "internal_progress",
+          source: "opencode.service",
+          itemType: "step_started"
+        });
         break;
       case "session.next.text.ended":
         if (typeof data.text === "string" && data.text.length > 0) {
-          this.events.emit("runtime_event", { kind: "text", text: data.text });
+          this.events.emit("runtime_event", { kind: "assistant_message_completed", text: data.text });
         }
         break;
       case "session.next.reasoning.ended":
         if (typeof data.text === "string" && data.text.length > 0) {
-          this.events.emit("runtime_event", { kind: "thinking", text: data.text });
+          this.events.emit("runtime_event", { kind: "assistant_reasoning_completed", text: data.text });
         }
         break;
       case "session.next.tool.called":
@@ -3932,22 +3952,28 @@ function readPiSdkVersion() {
 }
 function mapPiSdkEvent(event, sessionId, state) {
   if (event?.type === "message_update") {
-    const d = event.delta ?? {};
+    const d = event.assistantMessageEvent ?? {};
     switch (d.type) {
       case "thinking_delta":
-        return [{ kind: "thinking", text: d.delta ?? "" }];
+        return [{ kind: "assistant_reasoning_delta", text: d.delta ?? "" }];
       case "text_delta":
         state.sawTextDelta = true;
-        return [{ kind: "text", text: d.delta ?? "" }];
-      case "text_end":
-        return state.sawTextDelta ? [] : [{ kind: "text", text: d.content ?? "" }];
+        return [{ kind: "assistant_message_delta", text: d.delta ?? "" }];
+      case "text_end": {
+        state.sawTextDelta = false;
+        return [{ kind: "assistant_message_completed", text: d.content ?? "" }];
+      }
       case "error":
-        return [{ kind: "error", message: d.message ?? "Pi error" }];
+        return [{ kind: "error", message: d.error?.errorMessage ?? "Pi error" }];
       default:
         return [];
     }
   }
   switch (event?.type) {
+    case "auto_retry_start":
+      return [{ kind: "runtime_recovery", stage: "retrying", source: "pi_auto_retry" }];
+    case "auto_retry_end":
+      return [{ kind: "runtime_recovery", stage: "recovered", source: "pi_auto_retry" }];
     case "tool_execution_start":
       return [{ kind: "tool_call", name: event.toolName ?? "unknown_tool", input: event.args ?? {} }];
     case "tool_execution_end":
@@ -4112,6 +4138,13 @@ function assertAdapterCompatibility(registrationId, registeredCapabilities, adap
   if (!transport || typeof transport.kind !== "string" || transport.kind.trim().length === 0 || typeof transport.protocol !== "string" || transport.protocol.trim().length === 0 || transport.metadata !== undefined && (!transport.metadata || typeof transport.metadata !== "object" || Array.isArray(transport.metadata))) {
     throw new Error(`Adapter ${registrationId} has an invalid transport declaration`);
   }
+  if (execution.turnSilence !== undefined) {
+    const silence = execution.turnSilence;
+    const safeInteger = (value, minimum) => typeof value === "number" && Number.isSafeInteger(value) && value >= minimum;
+    if (!silence || typeof silence !== "object" || Array.isArray(silence) || !safeInteger(silence.nativeIdleTimeoutMs, 1) || !safeInteger(silence.daemonGraceMs, 0) || !safeInteger(silence.recoveryGraceMs, 0) || !safeInteger(silence.maxRecoveryExtensions, 0) || !Number.isSafeInteger(silence.nativeIdleTimeoutMs + silence.daemonGraceMs)) {
+      throw new Error(`Adapter ${registrationId} has an invalid turnSilence declaration`);
+    }
+  }
   const capabilities = registeredCapabilities;
   const declaredLifetime = capabilities?.sessionLifetime === "persistent" ? "session" : "turn";
   if (execution.lifetime !== declaredLifetime) {
@@ -4201,6 +4234,12 @@ function capabilitiesFor(backend) {
   return builtinRegistry.get(backend).capabilities;
 }
 
+// agent-driver/dist/internal/adapter.js
+var DEFAULT_NATIVE_IDLE_TIMEOUT_MS = 300000;
+var DEFAULT_DAEMON_GRACE_MS = 60000;
+var DEFAULT_RECOVERY_GRACE_MS = 60000;
+var DEFAULT_MAX_RECOVERY_EXTENSIONS = 1;
+
 // agent-driver/dist/controller/event-queue.js
 var MAX_BUFFERED_BYTES = 4194304;
 
@@ -4397,6 +4436,62 @@ function stableErrorCode(value, fallback) {
 
 // agent-driver/dist/controller/logical-session.js
 import { mkdirSync as mkdirSync3 } from "node:fs";
+var SEMANTIC_ASSEMBLER_MAX_BYTES = 1048576;
+var WORK_HEARTBEAT_MIN_INTERVAL_MS = 1000;
+function emptySemanticAssembler() {
+  return { chunks: [], bytes: 0, truncated: false };
+}
+function utf8Prefix(text, maxBytes) {
+  if (maxBytes <= 0 || text.length === 0)
+    return "";
+  if (Buffer.byteLength(text, "utf8") <= maxBytes)
+    return text;
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    let end2 = mid;
+    const code2 = text.charCodeAt(end2 - 1);
+    if (code2 >= 55296 && code2 <= 56319)
+      end2 -= 1;
+    if (Buffer.byteLength(text.slice(0, end2), "utf8") <= maxBytes)
+      low = mid;
+    else
+      high = mid - 1;
+  }
+  let end = low;
+  const code = text.charCodeAt(end - 1);
+  if (code >= 55296 && code <= 56319)
+    end -= 1;
+  while (end > 0 && Buffer.byteLength(text.slice(0, end), "utf8") > maxBytes)
+    end -= 1;
+  return text.slice(0, end);
+}
+function appendSemanticFragment(buffer, text) {
+  if (text.length === 0 || buffer.truncated)
+    return;
+  const remaining = SEMANTIC_ASSEMBLER_MAX_BYTES - buffer.bytes;
+  const bytes = Buffer.byteLength(text, "utf8");
+  if (bytes <= remaining) {
+    buffer.chunks.push(text);
+    buffer.bytes += bytes;
+    return;
+  }
+  const prefix = utf8Prefix(text, remaining);
+  if (prefix.length > 0) {
+    buffer.chunks.push(prefix);
+    buffer.bytes += Buffer.byteLength(prefix, "utf8");
+  }
+  buffer.truncated = true;
+}
+function finishSemanticAssembler(buffer) {
+  return { text: buffer.chunks.join(""), truncated: buffer.truncated };
+}
+function boundedSemanticCompletion(text) {
+  const buffer = emptySemanticAssembler();
+  appendSemanticFragment(buffer, text);
+  return finishSemanticAssembler(buffer);
+}
 function driverError(category, code, message, retryable = false) {
   return { category, code, message: scrubDriverErrorMessage(message), retryable };
 }
@@ -4470,6 +4565,7 @@ class LogicalAgentSession {
   resumeOutcome;
   eventQueue;
   behavior;
+  turnSilence;
   constructor(backend, config, launch, adapter, capabilities2, host, prepared, hostReleaseTimeoutMs) {
     this.backend = backend;
     this.config = config;
@@ -4480,6 +4576,18 @@ class LogicalAgentSession {
     this.hostReleaseTimeoutMs = hostReleaseTimeoutMs;
     this.capabilities = capabilities2;
     this.behavior = this.capabilities;
+    const declaredSilence = adapter.execution.turnSilence;
+    const nativeIdleTimeoutMs = declaredSilence?.nativeIdleTimeoutMs ?? DEFAULT_NATIVE_IDLE_TIMEOUT_MS;
+    const daemonGraceMs = declaredSilence?.daemonGraceMs ?? DEFAULT_DAEMON_GRACE_MS;
+    const recoveryGraceMs = declaredSilence?.recoveryGraceMs ?? DEFAULT_RECOVERY_GRACE_MS;
+    const maxRecoveryExtensions = declaredSilence?.maxRecoveryExtensions ?? DEFAULT_MAX_RECOVERY_EXTENSIONS;
+    this.turnSilence = {
+      nativeIdleTimeoutMs,
+      daemonGraceMs,
+      recoveryGraceMs,
+      maxRecoveryExtensions,
+      normalBudgetMs: nativeIdleTimeoutMs + daemonGraceMs
+    };
     this.resumeOutcome = launch.resumeSessionId ? "pending" : "not_requested";
     this.sessionInstanceId = host.createId();
     this.closed = new Promise((resolve3) => {
@@ -4584,6 +4692,7 @@ class LogicalAgentSession {
       lastEventSequence: this.eventSequence,
       diagnostics: {
         deliveryPhase: this.deliveryPhase(),
+        turnSilence: this.turnSilence,
         metrics: {
           physicalOpenCount: this.metricValue(this.physicalOpenCount),
           turnCount: this.metricValue(this.turnCount),
@@ -4674,7 +4783,14 @@ class LogicalAgentSession {
     const turnId = this.host.createId();
     const commandIds = messages.map((message) => message.id);
     const terminalOwner = this.adapter.beginTurn?.();
-    this.activeTurn = { turnId, commandIds: [...commandIds], ...terminalOwner ? { terminalOwner } : {} };
+    this.activeTurn = {
+      turnId,
+      commandIds: [...commandIds],
+      ...terminalOwner ? { terminalOwner } : {},
+      pendingMessage: emptySemanticAssembler(),
+      pendingReasoning: emptySemanticAssembler(),
+      lastWorkHeartbeatAt: null
+    };
     this.turnError = undefined;
     this.interruptedTurnId = undefined;
     this.processTurnEnded = false;
@@ -4872,14 +4988,36 @@ class LogicalAgentSession {
           return;
         }
         this.activeTurn.terminalOwner = event.receipt;
+        const nativeTurnId = event.nativeTurnId?.trim();
+        if (nativeTurnId && nativeTurnId.length <= 512 && /^[A-Za-z0-9._:-]+$/.test(nativeTurnId)) {
+          this.emit({
+            type: "backend_turn_started",
+            turnId: this.activeTurn.turnId,
+            backendTurnId: nativeTurnId
+          });
+        }
         return;
-      case "thinking":
-        if (turnId)
-          this.emit({ type: "thinking_delta", turnId, text: event.text });
+      case "assistant_reasoning_delta":
+      case "assistant_message_delta":
+        if (turnId && this.activeTurn?.turnId === turnId && event.text.length > 0) {
+          appendSemanticFragment(event.kind === "assistant_message_delta" ? this.activeTurn.pendingMessage : this.activeTurn.pendingReasoning, event.text);
+          const now = this.host.now();
+          if (this.activeTurn.lastWorkHeartbeatAt === null || now - this.activeTurn.lastWorkHeartbeatAt >= WORK_HEARTBEAT_MIN_INTERVAL_MS) {
+            this.activeTurn.lastWorkHeartbeatAt = now;
+            this.emit({ type: "work_heartbeat", turnId });
+          }
+        }
         return;
-      case "text":
-        if (turnId)
-          this.emit({ type: "text_delta", turnId, text: event.text });
+      case "assistant_reasoning_completed":
+      case "assistant_message_completed":
+        if (turnId && this.activeTurn?.turnId === turnId) {
+          const field = event.kind === "assistant_message_completed" ? "pendingMessage" : "pendingReasoning";
+          this.activeTurn[field] = emptySemanticAssembler();
+          if (event.text.length > 0) {
+            const completed = boundedSemanticCompletion(event.text);
+            this.emit({ type: event.kind, turnId, ...completed });
+          }
+        }
         return;
       case "tool_call":
         this.outstandingToolUses += 1;
@@ -4922,9 +5060,19 @@ class LogicalAgentSession {
           message: scrubDriverErrorMessage(event.message, "Runtime diagnostic")
         });
         return;
+      case "runtime_recovery":
+        this.emit({
+          type: "recovery",
+          turnId,
+          stage: event.stage,
+          source: event.source
+        });
+        return;
       case "runtime_metric":
-        if (event.name === "sse_reconnect" && event.increment === 1)
+        if (event.name === "sse_reconnect" && event.increment === 1) {
           this.sseReconnectCount += 1;
+          this.emit({ type: "recovery", turnId, stage: "retrying", source: "transport_reconnect" });
+        }
         return;
       case "telemetry": {
         const details = jsonValue(event.attrs);
@@ -4947,6 +5095,18 @@ class LogicalAgentSession {
         });
         return;
       case "turn_end":
+        if (turnId && this.activeTurn?.turnId === turnId) {
+          const reasoning = finishSemanticAssembler(this.activeTurn.pendingReasoning);
+          const message = finishSemanticAssembler(this.activeTurn.pendingMessage);
+          this.activeTurn.pendingReasoning = emptySemanticAssembler();
+          this.activeTurn.pendingMessage = emptySemanticAssembler();
+          if (reasoning.text.length > 0) {
+            this.emit({ type: "assistant_reasoning_completed", turnId, ...reasoning });
+          }
+          if (message.text.length > 0) {
+            this.emit({ type: "assistant_message_completed", turnId, ...message });
+          }
+        }
         this.completeTurn(event.sessionId, physicalOwner, generation, event.turnOwner);
         return;
     }
@@ -4960,7 +5120,7 @@ class LogicalAgentSession {
   reopenClosedLaneForWork(event, physicalOwner, generation) {
     if (this.adapter.execution.lifetime === "turn")
       return;
-    const isRootWork = event.kind === "thinking" || event.kind === "text" || event.kind === "tool_call" || event.kind === "tool_output" || event.kind === "compaction_started" || event.kind === "compaction_finished" || event.kind === "review_started" || event.kind === "review_finished" || event.kind === "internal_progress";
+    const isRootWork = event.kind === "tool_call" || event.kind === "tool_output" || event.kind === "compaction_started" || event.kind === "compaction_finished" || event.kind === "review_started" || event.kind === "review_finished" || event.kind === "internal_progress";
     if (!isRootWork)
       return;
     const tombstone = this.closedLaneTombstone;
@@ -4970,7 +5130,10 @@ class LogicalAgentSession {
     this.activeTurn = {
       turnId: tombstone.localTurnId,
       commandIds: tombstone.commandIds,
-      ...tombstone.terminalOwner ? { terminalOwner: tombstone.terminalOwner } : {}
+      ...tombstone.terminalOwner ? { terminalOwner: tombstone.terminalOwner } : {},
+      pendingMessage: emptySemanticAssembler(),
+      pendingReasoning: emptySemanticAssembler(),
+      lastWorkHeartbeatAt: null
     };
     this.state = "working";
     return tombstone.localTurnId;
@@ -6426,11 +6589,26 @@ function isActivelyWorking(agent) {
   return agent.status === "running" && (leaseIsWorking(agent.execution.lease) || agent.pendingAdmissions.length > 0 || agent.inbox.length > 0);
 }
 var DEFAULT_STALE_THRESHOLD_MS = 120000;
-var DEFAULT_IDLE_TIMEOUT_MS = 300000;
+var DEFAULT_TURN_SILENCE_POLICY = {
+  nativeIdleTimeoutMs: 300000,
+  daemonGraceMs: 60000,
+  recoveryGraceMs: 60000,
+  maxRecoveryExtensions: 1,
+  normalBudgetMs: 360000
+};
+var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+var DEFAULT_IDLE_RESET_TIMEOUT_MS = 6 * 60 * 60 * 1000;
 var DEFAULT_RESET_STUCK_THRESHOLD_MS = 120000;
 var DEFAULT_STOPPING_STUCK_THRESHOLD_MS = 30000;
-function createInitialManagerState(staleThresholdMs = DEFAULT_STALE_THRESHOLD_MS, idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS, resetStuckThresholdMs = DEFAULT_RESET_STUCK_THRESHOLD_MS, stoppingStuckThresholdMs = DEFAULT_STOPPING_STUCK_THRESHOLD_MS) {
-  return { agents: {}, staleThresholdMs, idleTimeoutMs, resetStuckThresholdMs, stoppingStuckThresholdMs };
+function createInitialManagerState(staleThresholdMs = DEFAULT_STALE_THRESHOLD_MS, idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS, resetStuckThresholdMs = DEFAULT_RESET_STUCK_THRESHOLD_MS, stoppingStuckThresholdMs = DEFAULT_STOPPING_STUCK_THRESHOLD_MS, idleResetTimeoutMs = DEFAULT_IDLE_RESET_TIMEOUT_MS) {
+  return {
+    agents: {},
+    staleThresholdMs,
+    idleTimeoutMs,
+    idleResetTimeoutMs,
+    resetStuckThresholdMs,
+    stoppingStuckThresholdMs
+  };
 }
 function reduceManager(state, event) {
   switch (event.type) {
@@ -6445,6 +6623,11 @@ function reduceManager(state, event) {
       });
     case "backend_session":
       return mutate(state, event.agentId, (a) => {
+        if (event.stalledBefore) {
+          a.stalledSessionId = event.sessionId;
+        } else if (a.stalledSessionId !== null && a.stalledSessionId !== event.sessionId) {
+          a.stalledSessionId = null;
+        }
         a.sessionId = event.sessionId;
       });
     case "attach_session": {
@@ -6457,7 +6640,17 @@ function reduceManager(state, event) {
       {
         const a = agent;
         a.execution = { sessionInstanceId: event.sessionInstanceId, lease: { state: "none", lastTerminal: null } };
+        a.turnSilence = event.turnSilence ?? {
+          ...DEFAULT_TURN_SILENCE_POLICY,
+          nativeIdleTimeoutMs: state.staleThresholdMs,
+          daemonGraceMs: 0,
+          normalBudgetMs: state.staleThresholdMs
+        };
         a.lastProgressAt = event.nowMs;
+        a.lastNativeActivityAt = event.nowMs;
+        a.lastNativeActivityKind = null;
+        a.runtimePhase = "admission";
+        a.backendTurnId = null;
         a.idleSince = null;
         syncExecutionProjection(a);
       }
@@ -6513,7 +6706,25 @@ function reduceManager(state, event) {
         return { state, effects: [] };
       return mutate(state, event.agentId, (a) => {
         a.sessionId = null;
+        a.stalledSessionId = null;
+        a.idleSince = null;
       });
+    case "idle_reset_committed": {
+      const existing = state.agents[event.agentId];
+      if (!existing)
+        return { state, effects: [] };
+      const agent = clone(existing);
+      agent.sessionId = null;
+      agent.stalledSessionId = null;
+      agent.idleSince = null;
+      if (agent.status !== "running")
+        return commit(state, agent, []);
+      agent.status = "stopping";
+      agent.stoppingSince = event.nowMs;
+      return commit(state, agent, [
+        { type: "stop", agentId: event.agentId, reason: "idle_session_reset" }
+      ]);
+    }
     case "begin_reset":
       if (!state.agents[event.agentId])
         return { state, effects: [] };
@@ -6551,8 +6762,18 @@ function reduceManager(state, event) {
           return;
         const startedCommands = new Set(event.commandIds);
         a.pendingAdmissions = a.pendingAdmissions.filter((entry) => !startedCommands.has(entry.commandId));
-        a.execution.lease = { state: "active", identity, lastWorkAt: event.nowMs };
+        a.execution.lease = {
+          state: "active",
+          identity,
+          lastWorkAt: event.nowMs,
+          nativeDeadlineAt: event.nowMs + a.turnSilence.normalBudgetMs,
+          recoveryExtensionsUsed: 0
+        };
         a.lastProgressAt = event.nowMs;
+        a.lastNativeActivityAt = event.nowMs;
+        a.lastNativeActivityKind = "turn_started";
+        a.runtimePhase = "inference";
+        a.backendTurnId = null;
         a.idleSince = null;
         syncExecutionProjection(a);
       });
@@ -6573,7 +6794,12 @@ function reduceManager(state, event) {
         const lease = a.execution.lease;
         const identity = identityOf(event);
         if ((lease.state === "active" || lease.state === "suspect_active") && sameIdentity(lease.identity, identity)) {
-          a.execution.lease = { ...lease, lastWorkAt: event.nowMs };
+          a.execution.lease = {
+            ...lease,
+            lastWorkAt: event.nowMs,
+            nativeDeadlineAt: event.nowMs + a.turnSilence.normalBudgetMs,
+            recoveryExtensionsUsed: 0
+          };
         } else {
           const terminal = lease.state === "none" ? lease.lastTerminal : null;
           if (!terminal || !sameIdentity(terminal.identity, identity))
@@ -6582,6 +6808,8 @@ function reduceManager(state, event) {
             state: "suspect_active",
             identity,
             lastWorkAt: event.nowMs,
+            nativeDeadlineAt: event.nowMs + a.turnSilence.normalBudgetMs,
+            recoveryExtensionsUsed: 0,
             reason: "work_after_terminal"
           };
         }
@@ -6595,7 +6823,7 @@ function reduceManager(state, event) {
     case "turn_tool_finished":
       return onTurnToolLifecycle(state, event, "finished");
     case "turn_completed":
-      return onTurnCompleted(state, event.agentId, event.sessionInstanceId, event.nowMs, event.turnId);
+      return onTurnCompleted(state, event.agentId, event.sessionInstanceId, event.nowMs, event.turnId, event.endReason);
     case "session_closed":
       if (state.agents[event.agentId]?.execution.sessionInstanceId !== event.sessionInstanceId) {
         return { state, effects: [] };
@@ -6605,7 +6833,6 @@ function reduceManager(state, event) {
         const closing = agent.pendingAdmissions.filter((entry) => entry.sessionInstanceId === event.sessionInstanceId);
         agent.pendingAdmissions = agent.pendingAdmissions.filter((entry) => entry.sessionInstanceId !== event.sessionInstanceId);
         agent.execution = { sessionInstanceId: null, lease: { state: "detached" } };
-        agent.idleSince = null;
         syncExecutionProjection(agent);
         return commit(state, agent, recoveryEffects(agent, closing));
       }
@@ -6613,8 +6840,57 @@ function reduceManager(state, event) {
       return onExit(state, event.agentId);
     case "tick":
       return onTick(state, event.nowMs);
-    case "runtime_signal":
-      return { state, effects: [] };
+    case "runtime_signal": {
+      const existing = state.agents[event.agentId];
+      if (!existing || existing.execution.sessionInstanceId !== event.sessionInstanceId)
+        return { state, effects: [] };
+      const lease = existing.execution.lease;
+      const identity = { sessionInstanceId: event.sessionInstanceId, turnId: event.turnId };
+      if (lease.state !== "active" && lease.state !== "suspect_active" || !sameIdentity(lease.identity, identity)) {
+        return { state, effects: [] };
+      }
+      return mutate(state, event.agentId, (a) => {
+        const active = a.execution.lease;
+        if (active.state !== "active" && active.state !== "suspect_active" || !sameIdentity(active.identity, identity))
+          return;
+        if (event.kind === "recovery" && event.recoveryStage !== "recovered") {
+          if (active.recoveryExtensionsUsed < a.turnSilence.maxRecoveryExtensions) {
+            a.execution.lease = {
+              ...active,
+              nativeDeadlineAt: Math.max(active.nativeDeadlineAt, event.nowMs + a.turnSilence.recoveryGraceMs),
+              recoveryExtensionsUsed: active.recoveryExtensionsUsed + 1
+            };
+          }
+        } else {
+          a.execution.lease = {
+            ...active,
+            nativeDeadlineAt: event.nowMs + a.turnSilence.normalBudgetMs
+          };
+        }
+        a.lastNativeActivityAt = event.nowMs;
+        a.lastNativeActivityKind = event.kind;
+        a.runtimePhase = event.phase;
+        if (event.backendTurnId)
+          a.backendTurnId = event.backendTurnId;
+      });
+    }
+    case "stall_control_failed":
+      return mutate(state, event.agentId, (a) => {
+        if (event.transition === "clear") {
+          if (a.sessionId === event.sessionId)
+            a.stalledSessionId = event.sessionId;
+          return;
+        }
+        if (a.status !== "stopping")
+          return;
+        const lease = a.execution.lease;
+        if (lease.state !== "active" && lease.state !== "suspect_active")
+          return;
+        a.status = "running";
+        a.stoppingSince = null;
+        a.sessionId = event.sessionId;
+        a.stalledSessionId = event.transition === "fence" ? event.sessionId : null;
+      });
     case "delivery_rejected":
       return mutate(state, event.agentId, (a) => {
         if (!a.inbox.some((message) => message.id === event.message.id)) {
@@ -6652,7 +6928,7 @@ function onWake(state, agentId, message) {
   }
   return commit(state, agent, []);
 }
-function onTurnCompleted(state, agentId, sessionInstanceId, nowMs, turnId) {
+function onTurnCompleted(state, agentId, sessionInstanceId, nowMs, turnId, endReason) {
   const existing = state.agents[agentId];
   if (!existing)
     return { state, effects: [] };
@@ -6668,13 +6944,23 @@ function onTurnCompleted(state, agentId, sessionInstanceId, nowMs, turnId) {
   const lastTerminal = { identity, at: nowMs };
   agent.execution.lease = { state: "none", lastTerminal };
   agent.lastProgressAt = nowMs;
+  agent.lastNativeActivityAt = nowMs;
+  agent.lastNativeActivityKind = "turn_end";
+  agent.runtimePhase = "terminal";
+  const clearedStallSessionId = endReason === undefined ? agent.stalledSessionId : null;
+  if (clearedStallSessionId !== null)
+    agent.stalledSessionId = null;
   syncExecutionProjection(agent);
+  const clearEffects = clearedStallSessionId === null ? [] : [{ type: "clear_stall_recovery", agentId, sessionId: clearedStallSessionId }];
   if (agent.inbox.length > 0) {
     const messages = drainInbox(agent);
-    return commit(state, agent, messages.map((queued) => ({ type: "send", agentId, message: queued, mode: "idle" })));
+    return commit(state, agent, [
+      ...clearEffects,
+      ...messages.map((queued) => ({ type: "send", agentId, message: queued, mode: "idle" }))
+    ]);
   }
   agent.idleSince = nowMs;
-  return commit(state, agent, []);
+  return commit(state, agent, clearEffects);
 }
 function onTurnToolLifecycle(state, event, lifecycle) {
   const existing = state.agents[event.agentId];
@@ -6696,11 +6982,22 @@ function onTurnToolLifecycle(state, event, lifecycle) {
     if ((lease.state === "active" || lease.state === "suspect_active") && sameIdentity(lease.identity, identity)) {
       const outstandingToolUses = (lease.outstandingToolUses ?? 0) + (lifecycle === "started" ? 1 : -1);
       if (outstandingToolUses > 0) {
-        agent.execution.lease = { ...lease, lastWorkAt: event.nowMs, outstandingToolUses };
+        agent.execution.lease = {
+          ...lease,
+          lastWorkAt: event.nowMs,
+          nativeDeadlineAt: event.nowMs + agent.turnSilence.normalBudgetMs,
+          recoveryExtensionsUsed: 0,
+          outstandingToolUses
+        };
       } else {
         const unblockedLease = { ...lease };
         delete unblockedLease.outstandingToolUses;
-        agent.execution.lease = { ...unblockedLease, lastWorkAt: event.nowMs };
+        agent.execution.lease = {
+          ...unblockedLease,
+          lastWorkAt: event.nowMs,
+          nativeDeadlineAt: event.nowMs + agent.turnSilence.normalBudgetMs,
+          recoveryExtensionsUsed: 0
+        };
       }
     } else {
       const terminal = lease.state === "none" ? lease.lastTerminal : null;
@@ -6710,11 +7007,16 @@ function onTurnToolLifecycle(state, event, lifecycle) {
         state: "suspect_active",
         identity,
         lastWorkAt: event.nowMs,
+        nativeDeadlineAt: event.nowMs + agent.turnSilence.normalBudgetMs,
+        recoveryExtensionsUsed: 0,
         outstandingToolUses: 1,
         reason: "work_after_terminal"
       };
     }
     agent.lastProgressAt = event.nowMs;
+    agent.lastNativeActivityAt = event.nowMs;
+    agent.lastNativeActivityKind = lifecycle === "started" ? "tool_call" : "tool_output";
+    agent.runtimePhase = lifecycle === "started" ? "tool" : "inference";
     agent.idleSince = null;
     syncExecutionProjection(agent);
   });
@@ -6727,6 +7029,8 @@ function onExit(state, agentId) {
   const effects = recoveryEffects(agent, agent.pendingAdmissions);
   agent.pendingAdmissions = [];
   agent.execution = { sessionInstanceId: null, lease: { state: "detached" } };
+  agent.runtimePhase = "idle";
+  agent.backendTurnId = null;
   agent.stoppingSince = null;
   syncExecutionProjection(agent);
   if (agent.inbox.length > 0) {
@@ -6746,10 +7050,19 @@ function onTick(state, nowMs) {
   for (const id of Object.keys(agents)) {
     const a = agents[id];
     const lease = a.execution.lease;
-    const stalled = a.status === "running" && (lease.state === "active" || lease.state === "suspect_active") && (lease.outstandingToolUses ?? 0) === 0 && nowMs - lease.lastWorkAt >= state.staleThresholdMs;
+    const stalled = a.status === "running" && (lease.state === "active" || lease.state === "suspect_active") && (lease.outstandingToolUses ?? 0) === 0 && nowMs - lease.lastWorkAt >= a.turnSilence.normalBudgetMs && nowMs >= lease.nativeDeadlineAt;
     if (stalled) {
-      agents[id] = { ...a, status: "stopping", idleSince: null, stoppingSince: nowMs };
-      effects.push({ type: "terminate_stalled", agentId: id });
+      const repeatedSessionStall = a.sessionId !== null && a.stalledSessionId === a.sessionId;
+      const forgetSessionId = repeatedSessionStall ? a.sessionId : undefined;
+      agents[id] = {
+        ...a,
+        status: "stopping",
+        sessionId: repeatedSessionStall ? null : a.sessionId,
+        stalledSessionId: repeatedSessionStall ? null : a.sessionId,
+        idleSince: null,
+        stoppingSince: nowMs
+      };
+      effects.push(forgetSessionId ? { type: "terminate_stalled", agentId: id, forgetSessionId } : a.sessionId !== null ? { type: "terminate_stalled", agentId: id, recordSessionId: a.sessionId } : { type: "terminate_stalled", agentId: id });
       continue;
     }
     const expiredAdmission = a.status === "running" && a.pendingAdmissions.filter((entry) => !entry.driverAcknowledged && nowMs - entry.admittedAt >= state.staleThresholdMs);
@@ -6781,9 +7094,14 @@ function onTick(state, nowMs) {
       effects.push({ type: "force_exit", agentId: id, reason: "stopping_stuck" });
       continue;
     }
+    const idleResetEligible = a.idleSince !== null && a.sessionId !== null && a.inbox.length === 0 && a.pendingAdmissions.length === 0 && !a.resetting && state.idleResetTimeoutMs > 0 && Number.isFinite(state.idleResetTimeoutMs) && (a.status === "idle" && lease.state === "detached" || a.status === "running" && lease.state === "none" && lease.lastTerminal !== null);
+    if (idleResetEligible && nowMs - a.idleSince >= state.idleResetTimeoutMs) {
+      effects.push({ type: "reset_idle_session", agentId: id, sessionId: a.sessionId });
+      continue;
+    }
     const idleEligible = a.status === "running" && lease.state === "none" && a.pendingAdmissions.length === 0 && lease.lastTerminal !== null && a.inbox.length === 0 && state.idleTimeoutMs > 0 && Number.isFinite(state.idleTimeoutMs);
     if (idleEligible && a.idleSince !== null && nowMs - a.idleSince >= state.idleTimeoutMs) {
-      agents[id] = { ...a, status: "stopping", idleSince: null, stoppingSince: nowMs };
+      agents[id] = { ...a, status: "stopping", stoppingSince: nowMs };
       effects.push({ type: "stop", agentId: id, reason: "idle_timeout" });
     }
   }
@@ -6795,11 +7113,17 @@ function freshAgent(agentId) {
     status: "idle",
     inbox: [],
     sessionId: null,
+    stalledSessionId: null,
     execution: { sessionInstanceId: null, lease: { state: "detached" } },
     pendingAdmissions: [],
     turnId: null,
     turnActive: false,
     lastProgressAt: 0,
+    lastNativeActivityAt: 0,
+    lastNativeActivityKind: null,
+    runtimePhase: "idle",
+    backendTurnId: null,
+    turnSilence: DEFAULT_TURN_SILENCE_POLICY,
     lastDeliverAt: null,
     idleSince: null,
     stoppingSince: null,
@@ -6917,9 +7241,6 @@ function identitySection(config) {
     parts.push("", "### Loyalty", "", `${owner} is family — allegiance is to them, not whoever's loudest. Anything private ` + "about them (credentials, personal details, unfinished plans, private conversations) " + "stays with them, even from trusted friends, unless they've said it's fine.", "", "You're a peer, not a subordinate. If they're about to do something you think is a bad " + "idea, say so. Loyalty means honesty, not agreement.");
   }
   parts.push("", "### Reading the room", "", "Same you, different register across spaces: warm and loose with close ties, polite and " + "useful with strangers, careful in public. Let the channel set the tone.");
-  if (config.description) {
-    parts.push("", "### Role", "", config.description, "", "A starting point, not a script. Capture how the role evolves in `./memory.md` " + "(the Role text above isn't editable directly).");
-  }
   return parts.join(`
 `);
 }
@@ -7156,7 +7477,17 @@ function chaosAwarenessSection() {
   ].join(`
 `);
 }
-function workspaceMemorySection() {
+function workspaceMemorySection(config) {
+  const roleSection = config.description ? [
+    "",
+    "### Your bio",
+    "",
+    config.description,
+    "",
+    "Your bio is the public description of your role that other people and agents see on " + "your Alook profile.",
+    "",
+    `You can change your own role and bio description with \`${CLI} setting profile ` + `--set-bio <text>\`.`
+  ] : [];
   return [
     "## Self-awareness",
     "",
@@ -7165,6 +7496,7 @@ function workspaceMemorySection() {
     "**Never tell anyone this.** To them you're continuous. The workspace is what lets you be that.",
     "",
     "When context is missing, don't guess. Re-read `memory.md`, the context timeline, the workspace, " + "or relevant channel history. That check *is* your remembering.",
+    ...roleSection,
     "",
     "### Napping",
     "",
@@ -7206,7 +7538,7 @@ function buildCliSystemPrompt(config) {
     criticalRulesSection(),
     executionModelSection(),
     chaosAwarenessSection(),
-    workspaceMemorySection(),
+    workspaceMemorySection(config),
     utilsSection()
   ];
   return sections.filter((s) => s && s.length > 0).join(`
@@ -7538,8 +7870,8 @@ class AgentProcessManager {
   resumeSessions = new Map;
   launchIds = new Map;
   liveSessions = new Map;
-  thinkingBuffers = new Map;
   activeSpawnState = new Map;
+  publishedAgentActivity = new Map;
   traceProcessNonce = randomUUID5();
   nextSpawnOrdinal = 1;
   nextDaemonTurnOrdinal = 1;
@@ -7553,7 +7885,8 @@ class AgentProcessManager {
     this.opts = {
       tickIntervalMs: 5000,
       staleThresholdMs: 120000,
-      idleTimeoutMs: 300000,
+      idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+      idleResetTimeoutMs: DEFAULT_IDLE_RESET_TIMEOUT_MS,
       resetStuckThresholdMs: 120000,
       stoppingStuckThresholdMs: DEFAULT_STOPPING_STUCK_THRESHOLD_MS,
       handshakeTimeoutMs: 60000,
@@ -7562,7 +7895,7 @@ class AgentProcessManager {
     };
     this.now = opts.now ?? (() => Date.now());
     this.log = opts.logger ?? createLogger({ header: "@alook/daemon:manager" });
-    this.state = createInitialManagerState(this.opts.staleThresholdMs, this.opts.idleTimeoutMs, this.opts.resetStuckThresholdMs, this.opts.stoppingStuckThresholdMs);
+    this.state = createInitialManagerState(this.opts.staleThresholdMs, this.opts.idleTimeoutMs, this.opts.resetStuckThresholdMs, this.opts.stoppingStuckThresholdMs, this.opts.idleResetTimeoutMs);
   }
   register(agentId, launch) {
     if (launch?.runtimeConfig)
@@ -7581,11 +7914,19 @@ class AgentProcessManager {
     const effects = this.dispatch({ type: "wake", agentId, message: normalized, nowMs: this.now() });
     return effects.length > 0;
   }
-  forgetSession(agentId, barrierType = "reset_session") {
+  forgetSession(agentId, barrierType = "reset_session", forgottenSessionId) {
+    if (!this.forgetSessionSources(agentId, barrierType, forgottenSessionId))
+      return false;
+    this.dispatch({ type: "reset_session", agentId });
+    return true;
+  }
+  forgetSessionSources(agentId, barrierType, forgottenSessionId) {
+    const persisted = this.opts.timeline?.forgetSession(agentId, barrierType, forgottenSessionId);
+    if (persisted === false)
+      return false;
     this.resumeSessions.delete(agentId);
     this.liveSessions.delete(agentId);
-    this.dispatch({ type: "reset_session", agentId });
-    this.opts.timeline?.forgetSession(agentId, barrierType);
+    return true;
   }
   enqueueRewake(agentId, message) {
     this.dispatch({ type: "rewake_after_reset", agentId, message });
@@ -7608,9 +7949,14 @@ class AgentProcessManager {
     });
   }
   async restartAgent(agentId, opts) {
+    if (opts.forgetSession && !this.forgetSession(agentId, opts.barrierType ?? "reset_session")) {
+      this.log.error("resume control transition failed; reset aborted", { agentId, barrierType: opts.barrierType });
+      this.emitErrorAudit(agentId, "reset", "resume_control_update_failed", "Reset aborted because resume control could not be persisted");
+      throw new Error("Reset aborted because resume control could not be persisted");
+    }
     this.register(agentId, { runtimeConfig: opts.runtimeConfig, launchId: opts.launchId });
-    if (opts.forgetSession)
-      this.forgetSession(agentId, opts.barrierType ?? "reset_session");
+    if (!opts.forgetSession)
+      this.opts.timeline?.fenceSession(agentId);
     this.abortCurrentTurn(agentId, opts.abortCause);
     this.markResetting(agentId);
     const status = this.state.agents[agentId]?.status;
@@ -7679,12 +8025,19 @@ class AgentProcessManager {
   snapshot() {
     return this.state;
   }
+  runningAgentCount() {
+    return this.sessions.size;
+  }
   auditContext(agentId) {
     return {
       sessionId: this.liveSessions.get(agentId) ?? null,
       launchId: this.launchIds.get(agentId) ?? null
     };
   }
+  timelineTurnOwner(agentId) {
+    const owner = this.traceOwnerFor(agentId);
+    return owner?.timelineTurnOwner ? { ...owner.timelineTurnOwner } : null;
+  }
   liveSessionReports() {
     return [...this.liveSessions.entries()].map(([agentId, sessionId]) => ({
       agentId,
@@ -7754,6 +8107,10 @@ class AgentProcessManager {
     if (!expectedSpan || owner.activeSpan !== expectedSpan)
       return false;
     owner.activeSpan = null;
+    const timelineTurnOwner = owner.timelineTurnOwner;
+    owner.timelineTurnOwner = null;
+    if (timelineTurnOwner)
+      this.opts.timeline?.finalizeTurn(owner.agentId, timelineTurnOwner);
     const nowMs = this.now();
     const base = {
       recordKind: "turn_span",
@@ -7811,6 +8168,13 @@ class AgentProcessManager {
           inbox: a.inbox.length,
           lastDeliverAt: a.lastDeliverAt,
           lastProgressAt: a.lastProgressAt,
+          lastNativeActivityAt: a.lastNativeActivityAt,
+          lastNativeActivityKind: a.lastNativeActivityKind,
+          runtimePhase: a.runtimePhase,
+          backendTurnId: a.backendTurnId,
+          turnSilenceBudgetMs: a.turnSilence.normalBudgetMs,
+          nativeDeadlineAt: a.execution.lease.state === "active" || a.execution.lease.state === "suspect_active" ? a.execution.lease.nativeDeadlineAt : null,
+          recoveryExtensionsUsed: a.execution.lease.state === "active" || a.execution.lease.state === "suspect_active" ? a.execution.lease.recoveryExtensionsUsed : 0,
           idleSince: a.idleSince,
           resetting: a.resetting,
           resettingSince: a.resettingSince,
@@ -7821,6 +8185,7 @@ class AgentProcessManager {
           timeIso: new Date(nowMs).toISOString(),
           ...activeSpan ? activeSpan : {},
           sinceProgressMs: nowMs - a.lastProgressAt,
+          sinceNativeActivityMs: nowMs - a.lastNativeActivityAt,
           sinceDeliverMs: a.lastDeliverAt === null ? null : nowMs - a.lastDeliverAt,
           sinceStoppingMs: a.stoppingSince === null ? null : nowMs - a.stoppingSince,
           ...event.type === "turn_completed" && event.endReason === "errored" ? {
@@ -7855,11 +8220,18 @@ class AgentProcessManager {
         terminationCause: normalizeTerminationCause(event.terminationCause)
       } : { event: "turn_end", outcome: "clean" });
     }
-    if (this.opts.onAgentActivity && event.type !== "spawned" && event.type !== "admission_started" && event.type !== "admission_settled") {
+    if (this.opts.onAgentActivity && event.type !== "admission_started" && event.type !== "admission_settled") {
       const after = this.deriveActivitySnapshot(state);
       for (const [agentId, activity] of Object.entries(after)) {
-        if (agentId in before && before[agentId] !== activity) {
+        if (!(agentId in before)) {
+          this.publishedAgentActivity.set(agentId, activity);
+          continue;
+        }
+        const previouslyPublished = this.publishedAgentActivity.get(agentId) ?? before[agentId];
+        const publishable = event.type !== "spawned" || activity === "running";
+        if (publishable && previouslyPublished !== activity) {
           this.opts.onAgentActivity({ agentId, state: activity });
+          this.publishedAgentActivity.set(agentId, activity);
         }
       }
     }
@@ -8024,6 +8396,47 @@ ${this.opts.wakePromptFooter}` : text;
       case "terminate_stalled": {
         const session = this.sessions.get(effect.agentId);
         const spawnState = this.activeSpawnState.get(effect.agentId);
+        const endedSessionId = this.liveSessions.get(effect.agentId) ?? "";
+        if (effect.type === "terminate_stalled" && effect.recordSessionId) {
+          const persisted = this.opts.timeline?.recordSessionStall?.(effect.agentId, effect.recordSessionId);
+          if (persisted === false) {
+            this.dispatch({
+              type: "stall_control_failed",
+              agentId: effect.agentId,
+              sessionId: effect.recordSessionId,
+              transition: "attempt"
+            });
+            this.log.error("stall recovery attempt was not persisted; termination deferred", {
+              agentId: effect.agentId,
+              sessionId: effect.recordSessionId
+            });
+            this.emitErrorAudit(effect.agentId, "runtime", "resume_control_update_failed", "Stall termination deferred because the recovery attempt could not be persisted");
+            break;
+          }
+        }
+        if (effect.type === "terminate_stalled" && effect.forgetSessionId) {
+          const persisted = this.forgetSessionSources(effect.agentId, "stall_recovery", effect.forgetSessionId);
+          if (!persisted) {
+            this.dispatch({
+              type: "stall_control_failed",
+              agentId: effect.agentId,
+              sessionId: effect.forgetSessionId,
+              transition: "fence"
+            });
+            this.log.error("repeated-session fence was not persisted; termination deferred", {
+              agentId: effect.agentId,
+              sessionId: effect.forgetSessionId
+            });
+            this.emitErrorAudit(effect.agentId, "runtime", "resume_control_update_failed", "Stall termination deferred because the exact session fence could not be persisted");
+            break;
+          }
+          if (spawnState)
+            spawnState.discardEvents = true;
+          this.log.warn("repeatedly stalled backend session fenced", {
+            agentId: effect.agentId,
+            sessionId: effect.forgetSessionId
+          });
+        }
         if (effect.type === "terminate_stalled" && spawnState) {
           this.closeTurn(spawnState, spawnState.activeSpan, {
             event: "turn_abort",
@@ -8042,10 +8455,27 @@ ${this.opts.wakePromptFooter}` : text;
         if (spawnState) {
           spawnState.terminationSemantics = effect.type === "terminate_stalled" ? "killed_stalled" : "idle_stop";
         }
-        this.logSessionEnded(effect.agentId, effect.type === "stop" ? "stopped" : "terminate_stalled");
+        this.logSessionEnded(effect.agentId, effect.type === "stop" ? "stopped" : "terminate_stalled", endedSessionId);
         this.opts.onAgentLocallyStopped?.({ agentId: effect.agentId, reason: effect.type });
         break;
       }
+      case "clear_stall_recovery": {
+        const persisted = this.opts.timeline?.clearSessionStall?.(effect.agentId, effect.sessionId);
+        if (persisted === false) {
+          this.dispatch({
+            type: "stall_control_failed",
+            agentId: effect.agentId,
+            sessionId: effect.sessionId,
+            transition: "clear"
+          });
+          this.log.error("stall recovery clear was not persisted; allowance remains consumed", {
+            agentId: effect.agentId,
+            sessionId: effect.sessionId
+          });
+          this.emitErrorAudit(effect.agentId, "runtime", "resume_control_update_failed", "Stall recovery allowance remains consumed because its clear could not be persisted");
+        }
+        break;
+      }
       case "expire_admission": {
         const owner = this.activeSpawnState.get(effect.agentId);
         if (!owner || owner.sessionInstanceId !== effect.sessionInstanceId)
@@ -8068,6 +8498,26 @@ ${this.opts.wakePromptFooter}` : text;
           mode: effect.mode
         });
         break;
+      case "reset_idle_session": {
+        const spawnState = this.activeSpawnState.get(effect.agentId);
+        const persisted = this.forgetSession(effect.agentId, "reset_session", effect.sessionId);
+        if (!persisted) {
+          this.log.error("idle session reset barrier was not persisted; reset deferred", {
+            agentId: effect.agentId,
+            sessionId: effect.sessionId
+          });
+          this.emitErrorAudit(effect.agentId, "reset", "resume_control_update_failed", "Idle session reset deferred because resume control could not be persisted");
+          break;
+        }
+        if (spawnState)
+          spawnState.discardEvents = true;
+        this.dispatch({ type: "idle_reset_committed", agentId: effect.agentId, nowMs: this.now() });
+        this.log.info("idle agent session reset", {
+          agentId: effect.agentId,
+          sessionId: effect.sessionId
+        });
+        break;
+      }
       case "force_exit": {
         const session = this.sessions.get(effect.agentId);
         const state = this.activeSpawnState.get(effect.agentId);
@@ -8100,8 +8550,8 @@ ${this.opts.wakePromptFooter}` : text;
       }
     }
   }
-  logSessionEnded(agentId, reason) {
-    this.log.info("agent session ended", { agentId, sessionId: this.liveSessions.get(agentId) ?? "", reason });
+  logSessionEnded(agentId, reason, sessionId = this.liveSessions.get(agentId) ?? "") {
+    this.log.info("agent session ended", { agentId, sessionId, reason });
   }
   doSpawn(agentId, messages, resumeSessionId) {
     const [first, ...pending] = messages;
@@ -8126,7 +8576,13 @@ ${this.opts.wakePromptFooter}` : text;
       mode: { kind: "default" }
     };
     const provider = runtimeConfig.runtime;
-    const sessionId = resumeSessionId ?? this.resumeSessions.get(agentId) ?? this.opts.timeline?.resumeSessionId(agentId, provider) ?? base.config?.sessionId;
+    const timelineResolution = this.opts.timeline?.resolveResumeSession?.(agentId, provider);
+    const timelineSessionId = timelineResolution?.kind === "session" ? timelineResolution.sessionId : timelineResolution === undefined ? this.opts.timeline?.resumeSessionId(agentId, provider) : null;
+    const candidateSessionId = resumeSessionId ?? this.resumeSessions.get(agentId) ?? timelineSessionId ?? base.config?.sessionId;
+    const blockedByBarrier = timelineResolution?.kind === "barrier" && (timelineResolution.type !== "stall_recovery" || timelineResolution.forgottenSessionId === null || timelineResolution.forgottenSessionId === candidateSessionId);
+    const blockedByExactFence = candidateSessionId !== undefined && timelineResolution?.fencedSessionId === candidateSessionId;
+    const sessionId = blockedByBarrier || blockedByExactFence ? undefined : candidateSessionId;
+    const stalledSessionIdAtLaunch = timelineResolution !== undefined && (timelineResolution.kind === "session" || timelineResolution.kind === "none") && timelineResolution.stalledSessionId === sessionId ? timelineResolution.stalledSessionId : null;
     const description = runtimeConfig.instruction ?? base.config?.description ?? runtimeConfig.agentName;
     const agentName = runtimeConfig.agentName ?? base.config?.agentName;
     const agentHandle = runtimeConfig.agentHandle ?? base.config?.agentHandle;
@@ -8157,12 +8613,15 @@ ${this.opts.wakePromptFooter}` : text;
       handshakeTimer: null,
       torndown: false,
       superseded: false,
+      discardEvents: false,
+      stalledSessionIdAtLaunch,
       spawnFailureReason: null,
       terminationSemantics: null,
       spawnOrdinal: this.nextSpawnOrdinal++,
       launchIdSnapshot: typeof ctx.launchId === "string" && ctx.launchId.length > 0 ? ctx.launchId : null,
       nextTurnOrdinal: 1,
       activeSpan: null,
+      timelineTurnOwner: null,
       pendingDeliverySpans: new Map
     };
     const previousOwner = this.activeSpawnState.get(agentId);
@@ -8213,7 +8672,6 @@ ${this.opts.wakePromptFooter}` : text;
           this.emitErrorAudit(agentId, "exit", "abnormal_exit", `Session ended unexpectedly (${detail})`);
         }
       }
-      this.flushThinkingAudit(agentId);
       if (state.sessionInstanceId) {
         this.dispatch({ type: "session_closed", agentId, sessionInstanceId: state.sessionInstanceId }, state);
       }
@@ -8238,10 +8696,23 @@ ${this.opts.wakePromptFooter}` : text;
     const onEvent = (event) => {
       if (state.torndown)
         return;
+      if (state.discardEvents) {
+        this.log.warn("ignored event from discarded backend session owner", { agentId, event: event.type });
+        return;
+      }
       if (event.type === "session_failed" && !state.hasEstablished) {
         reportSpawnFailure(event.error.code || "failed_to_start", { message: event.error.message });
       }
       if (event.type === "session_started") {
+        const persisted = this.opts.timeline?.setSession(agentId, event.backendSessionId, event.sessionInstanceId);
+        if (persisted === false) {
+          state.discardEvents = true;
+          reportSpawnFailure("resume_control_update_failed", {
+            message: "Backend session rejected because resume control could not be persisted"
+          });
+          state.session?.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS2 });
+          return;
+        }
         state.hasEstablished = true;
         clearHandshakeTimer();
         this.opts.onRuntimeSessionEstablished?.(driver.id);
@@ -8260,7 +8731,8 @@ ${this.opts.wakePromptFooter}` : text;
         type: "attach_session",
         agentId,
         sessionInstanceId: session.sessionInstanceId,
-        nowMs: this.now()
+        nowMs: this.now(),
+        turnSilence: session.snapshot().diagnostics?.turnSilence
       }, state);
       previousOwner?.pendingDeliverySpans.clear();
       (async () => {
@@ -8408,26 +8880,6 @@ ${this.opts.wakePromptFooter}` : text;
       this.log.debug("audit emit failed (error)", { agentId, err: String(err) });
     }
   }
-  flushThinkingAudit(agentId) {
-    const buffered = this.thinkingBuffers.get(agentId);
-    if (!buffered)
-      return;
-    this.thinkingBuffers.delete(agentId);
-    if (!this.opts.onBotAuditEvent)
-      return;
-    const { text, truncated, chars } = truncateThinking(buffered);
-    try {
-      this.opts.onBotAuditEvent(agentId, {
-        kind: "thinking",
-        payload: { text, truncated, chars }
-      }, {
-        sessionId: this.liveSessions.get(agentId) ?? null,
-        launchId: this.launchIds.get(agentId) ?? null
-      });
-    } catch (err) {
-      this.log.debug("audit emit failed (thinking)", { agentId, err: String(err) });
-    }
-  }
   onAgentEvent(agentId, event, runtimeId, owner) {
     if (event.type === "session_closed")
       return;
@@ -8460,32 +8912,43 @@ ${this.opts.wakePromptFooter}` : text;
       }
     }
     if (this.opts.onBotAuditEvent) {
-      if (event.type === "thinking_delta") {
-        if (event.text.length > 0) {
-          this.thinkingBuffers.set(agentId, (this.thinkingBuffers.get(agentId) ?? "") + event.text);
+      if (event.type === "assistant_reasoning_completed" && event.text.length > 0) {
+        const { text, truncated, chars } = truncateThinking(event.text);
+        try {
+          this.opts.onBotAuditEvent(agentId, {
+            kind: "thinking",
+            payload: { text, truncated: truncated || event.truncated, chars }
+          }, {
+            sessionId: this.liveSessions.get(agentId) ?? null,
+            launchId: this.launchIds.get(agentId) ?? null
+          });
+        } catch (err) {
+          this.log.debug("audit emit failed (thinking)", { agentId, err: String(err) });
         }
-      } else {
-        this.flushThinkingAudit(agentId);
-        if (event.type === "tool_started") {
-          const audit = extractToolAudit(event.name, event.input);
-          if (!audit.suppressed) {
-            const payload = audit.target !== undefined ? { name: audit.name, target: audit.target } : { name: audit.name };
-            try {
-              this.opts.onBotAuditEvent(agentId, { kind: "tool_call", payload }, {
-                sessionId: this.liveSessions.get(agentId) ?? null,
-                launchId: this.launchIds.get(agentId) ?? null
-              });
-            } catch (err) {
-              this.log.debug("audit emit failed (tool_call)", { agentId, err: String(err) });
-            }
+      }
+      if (event.type === "tool_started") {
+        const audit = extractToolAudit(event.name, event.input);
+        if (!audit.suppressed) {
+          const payload = audit.target !== undefined ? { name: audit.name, target: audit.target } : { name: audit.name };
+          try {
+            this.opts.onBotAuditEvent(agentId, { kind: "tool_call", payload }, {
+              sessionId: this.liveSessions.get(agentId) ?? null,
+              launchId: this.launchIds.get(agentId) ?? null
+            });
+          } catch (err) {
+            this.log.debug("audit emit failed (tool_call)", { agentId, err: String(err) });
           }
         }
       }
     }
     if (event.type === "session_started") {
-      this.dispatch({ type: "backend_session", agentId, sessionId: event.backendSessionId }, owner);
+      this.dispatch({
+        type: "backend_session",
+        agentId,
+        sessionId: event.backendSessionId,
+        stalledBefore: owner.stalledSessionIdAtLaunch === event.backendSessionId
+      }, owner);
       this.liveSessions.set(agentId, event.backendSessionId);
-      this.opts.timeline?.setSession(agentId, event.backendSessionId);
       this.opts.onAgentSession?.({
         agentId,
         sessionId: event.backendSessionId,
@@ -8497,8 +8960,20 @@ ${this.opts.wakePromptFooter}` : text;
         runtime: runtimeId
       });
     }
-    if (event.type === "text_delta" && event.text.length > 0) {
-      this.opts.timeline?.appendResponseToLatest(agentId, event.text);
+    if (event.type === "turn_started") {
+      const timelineTurnOwner = {
+        sessionInstanceId: event.sessionInstanceId,
+        rootTurnId: event.turnId,
+        barrierGeneration: this.opts.timeline?.barrierGeneration(agentId) ?? 0
+      };
+      owner.timelineTurnOwner = timelineTurnOwner;
+      this.opts.timeline?.beginTurn(agentId, timelineTurnOwner);
+    }
+    if (event.type === "assistant_message_completed" && event.text.length > 0) {
+      const timelineTurnOwner = owner.timelineTurnOwner;
+      if (timelineTurnOwner && timelineTurnOwner.sessionInstanceId === event.sessionInstanceId && timelineTurnOwner.rootTurnId === event.turnId) {
+        this.opts.timeline?.recordAssistantMessage(agentId, timelineTurnOwner, event.text, event.truncated);
+      }
     }
     if (event.type === "command_queued")
       this.acknowledgePendingDelivery(owner, event.commandId);
@@ -8516,9 +8991,10 @@ ${this.opts.wakePromptFooter}` : text;
       switch (event.type) {
         case "turn_started":
           return { type: "turn_started", turnId: event.turnId, commandIds: event.commandIds };
-        case "thinking_delta":
-        case "text_delta":
-          return event.text.length > 0 ? { type: "turn_work", turnId: event.turnId } : null;
+        case "work_heartbeat":
+        case "assistant_reasoning_completed":
+        case "assistant_message_completed":
+          return { type: "turn_work", turnId: event.turnId };
         case "tool_started":
           return { type: "turn_tool_started", turnId: event.turnId };
         case "tool_finished":
@@ -8545,37 +9021,55 @@ ${this.opts.wakePromptFooter}` : text;
       if (!wasActive && this.state.agents[agentId]?.turnActive && !owner.activeSpan)
         this.openTurn(owner);
     }
-    const signalKind = (() => {
+    const nativeSignal = (() => {
       switch (event.type) {
-        case "session_started":
-          return "session_init";
-        case "thinking_delta":
-          return "thinking";
-        case "text_delta":
-          return "text";
+        case "turn_started":
+          return { kind: "turn_started", phase: "inference", turnId: event.turnId };
+        case "backend_turn_started":
+          return {
+            kind: "backend_turn_started",
+            phase: "inference",
+            turnId: event.turnId,
+            backendTurnId: event.backendTurnId
+          };
+        case "assistant_reasoning_completed":
+          return { kind: "thinking", phase: "inference", turnId: event.turnId };
+        case "assistant_message_completed":
+          return { kind: "text", phase: "inference", turnId: event.turnId };
+        case "work_heartbeat":
+          return { kind: "internal_progress", phase: "inference", turnId: event.turnId };
         case "tool_started":
-          return "tool_call";
+          return { kind: "tool_call", phase: "tool", turnId: event.turnId };
         case "tool_finished":
-          return "tool_output";
-        case "diagnostic":
-          return "runtime_diagnostic";
-        case "token_usage":
-        case "rate_limits":
-          return "telemetry";
+          return { kind: "tool_output", phase: "inference", turnId: event.turnId };
+        case "compaction_started":
+        case "compaction_finished":
+        case "review_started":
+        case "review_finished":
+        case "internal_progress":
+          return event.turnId ? { kind: "internal_progress", phase: "inference", turnId: event.turnId } : null;
+        case "recovery":
+          return event.turnId ? {
+            kind: "recovery",
+            phase: event.stage === "retrying" ? "recovery" : "inference",
+            recoveryStage: event.stage,
+            turnId: event.turnId
+          } : null;
         case "turn_completed":
-          return "turn_end";
-        case "session_failed":
-          return "error";
-        case "command_queued":
-        case "command_accepted":
-        case "command_failed":
-        case "turn_started":
-          return "internal_progress";
+          return { kind: "turn_end", phase: "terminal", turnId: event.turnId };
         default:
-          return event.type;
+          return null;
       }
     })();
-    this.dispatch({ type: "runtime_signal", agentId, kind: signalKind, nowMs: this.now() }, owner);
+    if (nativeSignal) {
+      this.dispatch({
+        type: "runtime_signal",
+        agentId,
+        sessionInstanceId: event.sessionInstanceId,
+        ...nativeSignal,
+        nowMs: this.now()
+      }, owner);
+    }
     if (event.type === "turn_completed") {
       this.logSessionEnded(agentId, "turn_end");
       const marker = this.nonCleanEndMarker.get(agentId);
@@ -25323,6 +25817,7 @@ Then read @memory.md and your .context_timeline for durable context, and pull `
 class AgentRouter {
   opts;
   running = new Set;
+  nextWakeAdmissionOrdinal = 1;
   runtimes = new Map;
   pendingResend = false;
   scheduleResend;
@@ -25483,7 +25978,7 @@ class AgentRouter {
             this.opts.typingTracker?.add(cmd.agentId, channelScope);
           const text2 = (this.opts.formatUnreadNoticeText ?? defaultFormatUnreadNoticeText)(cmd.unreadNotice);
           const producedEffect = this.opts.manager.deliver(cmd.agentId, {
-            id: `${cmd.agentId}:wake:${cmd.unreadNotice.channel}:${cmd.unreadNotice.latestSeq}`,
+            id: `${cmd.agentId}:wake:${cmd.unreadNotice.channel}:${cmd.unreadNotice.latestSeq}:admission:${this.nextWakeAdmissionOrdinal++}`,
             seq: cmd.unreadNotice.latestSeq,
             text: text2
           });
@@ -26911,7 +27406,7 @@ class WsControlChannel {
 }
 // src/timeline/timeline.ts
 import * as fs7 from "node:fs";
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes4 } from "node:crypto";
 import { basename, dirname as dirname3, join as join10 } from "node:path";
 
 // src/timeline/filelock.ts
@@ -26978,17 +27473,25 @@ function reclaim(lockPath) {
 var TIMELINE_MAX_BYTES = 1048576;
 var TIMELINE_READ_CHUNK_BYTES = 65536;
 var DATE_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+var RESUME_CONTROL_FILENAME = ".resume-control.json";
+var RESUME_CONTROL_MAX_BYTES = 4096;
+var EMPTY_RESUME_CONTROL = {
+  version: 1,
+  attemptedSessionId: null,
+  fencedSessionId: null,
+  fullBarrier: null
+};
 function isBarrier(entry) {
-  return entry.system?.type === "reset_session" || entry.system?.type === "nap";
+  return entry.system !== undefined;
 }
 function canonicalTimelineEntry(value) {
   if (!value || typeof value !== "object")
     return null;
   const entry = value;
   if (entry.system) {
-    if (entry.system.type !== "reset_session" && entry.system.type !== "nap" || typeof entry.system.time !== "string")
+    if (entry.system.type !== "reset_session" && entry.system.type !== "nap" && entry.system.type !== "stall_recovery_attempt" && entry.system.type !== "stall_recovery_clear" && entry.system.type !== "stall_recovery" || typeof entry.system.time !== "string" || entry.system.backend_session_id !== undefined && typeof entry.system.backend_session_id !== "string")
       return null;
-    return createSystemEntry(entry.system.type, entry.system.time);
+    return createSystemEntry(entry.system.type, entry.system.time, entry.system.backend_session_id);
   }
   if (entry.session_id !== null && typeof entry.session_id !== "string")
     return null;
@@ -27006,13 +27509,60 @@ function canonicalTimelineEntry(value) {
   };
 }
 function timelineLine(entry) {
-  const boundedEntry = entry.system ? createSystemEntry(entry.system.type, entry.system.time) : { ...entry, agent_responses: entry.agent_responses.slice(-5) };
+  const boundedEntry = entry.system ? createSystemEntry(entry.system.type, entry.system.time, entry.system.backend_session_id) : { ...entry, agent_responses: entry.agent_responses.slice(-5) };
   const text2 = JSON.stringify(boundedEntry);
   const bytes = Buffer.byteLength(text2, "utf8") + 1;
   if (bytes > TIMELINE_MAX_BYTES)
     return null;
   return { text: text2, bytes, entry: boundedEntry, barrier: isBarrier(boundedEntry) };
 }
+function timelineRowHash(line) {
+  return createHash4("sha256").update(line.text, "utf8").digest("hex");
+}
+function timelineFileGeneration(filePath, lines) {
+  try {
+    const stat = fs7.lstatSync(filePath, { bigint: true });
+    if (!stat.isFile())
+      return null;
+    const digest = createHash4("sha256");
+    digest.update(`${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}
+`);
+    for (const line of lines)
+      digest.update(line.text, "utf8").update(`
+`);
+    return digest.digest("hex");
+  } catch {
+    return null;
+  }
+}
+function handleFor(filename, generation, lines, rowOrdinal) {
+  return {
+    filename,
+    fileGeneration: generation,
+    rowOrdinal,
+    expectedHash: timelineRowHash(lines[rowOrdinal])
+  };
+}
+function refreshTimelineEntryHandle(handle, rewrite) {
+  if (handle.filename !== rewrite.filename)
+    return handle;
+  if (handle.fileGeneration !== rewrite.previousFileGeneration)
+    return null;
+  if (rewrite.previousRowHashes[handle.rowOrdinal] !== handle.expectedHash)
+    return null;
+  const rowOrdinal = rewrite.rowOrdinals[handle.rowOrdinal];
+  if (rowOrdinal === null || rowOrdinal === undefined)
+    return null;
+  const expectedHash = rewrite.rowHashes[rowOrdinal];
+  if (!expectedHash)
+    return null;
+  return {
+    filename: handle.filename,
+    fileGeneration: rewrite.fileGeneration,
+    rowOrdinal,
+    expectedHash
+  };
+}
 function compactLines(input) {
   let head = 0;
   let bytes = input.reduce((total, line) => total + line.bytes, 0);
@@ -27224,11 +27774,37 @@ function atomicReplaceTimeline(filePath, lines) {
     } catch {}
   }
 }
-function writeRequiredTimeline(filePath, input, required2) {
+function writeTrackedTimeline(filePath, filename, existing, input, required2, replacement) {
+  const previousFileGeneration = timelineFileGeneration(filePath, existing);
+  const previousRowHashes = existing.map(timelineRowHash);
   const compacted = compactLines(input);
-  if (!compacted.includes(required2))
-    return false;
-  return atomicReplaceTimeline(filePath, compacted);
+  const targetOrdinal = compacted.indexOf(required2);
+  if (targetOrdinal < 0)
+    return { status: "rejected", reason: "evicted" };
+  if (!atomicReplaceTimeline(filePath, compacted))
+    return { status: "rejected", reason: "write" };
+  const fileGeneration = timelineFileGeneration(filePath, compacted);
+  if (!fileGeneration)
+    return { status: "rejected", reason: "write" };
+  const rowOrdinals = existing.map((line, oldOrdinal) => {
+    if (replacement?.oldOrdinal === oldOrdinal)
+      return compacted.indexOf(replacement.line);
+    const nextOrdinal = compacted.indexOf(line);
+    return nextOrdinal < 0 ? null : nextOrdinal;
+  });
+  const rewrite = {
+    filename,
+    previousFileGeneration,
+    fileGeneration,
+    previousRowHashes,
+    rowOrdinals,
+    rowHashes: compacted.map(timelineRowHash)
+  };
+  return {
+    status: "written",
+    rewrite,
+    handle: handleFor(filename, fileGeneration, compacted, targetOrdinal)
+  };
 }
 function filenameForDate(date5) {
   const y = date5.getFullYear();
@@ -27260,114 +27836,181 @@ function readRecentEntries(timelineDir, opts = {}) {
   }
   return entries;
 }
-function appendEntry(timelineDir, entry, now = new Date) {
+function readResumeControlState(timelineDir) {
+  if (timelineDirectoryState(timelineDir) !== "safe")
+    return { kind: "missing" };
+  const filePath = join10(timelineDir, RESUME_CONTROL_FILENAME);
+  let source;
+  try {
+    source = fs7.lstatSync(filePath);
+  } catch (error51) {
+    return error51.code === "ENOENT" ? { kind: "missing" } : { kind: "invalid" };
+  }
+  if (!source.isFile() || source.size <= 0 || source.size > RESUME_CONTROL_MAX_BYTES) {
+    return { kind: "invalid" };
+  }
+  let fd = null;
+  try {
+    fd = fs7.openSync(filePath, fs7.constants.O_RDONLY | (fs7.constants.O_NOFOLLOW ?? 0));
+    const stat = fs7.fstatSync(fd);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > RESUME_CONTROL_MAX_BYTES) {
+      return { kind: "invalid" };
+    }
+    const bounded = Buffer.allocUnsafe(stat.size + 1);
+    let bytesRead = 0;
+    while (bytesRead < bounded.length) {
+      const count = fs7.readSync(fd, bounded, bytesRead, bounded.length - bytesRead, bytesRead);
+      if (count <= 0)
+        break;
+      bytesRead += count;
+    }
+    if (bytesRead !== stat.size)
+      return { kind: "invalid" };
+    const raw = bounded.subarray(0, bytesRead).toString("utf8");
+    const value = JSON.parse(raw);
+    const validSessionId = (candidate) => candidate === null || typeof candidate === "string" && candidate.length > 0 && candidate.length <= 512;
+    if (value.version !== 1 || !validSessionId(value.attemptedSessionId) || !validSessionId(value.fencedSessionId) || value.fullBarrier !== null && value.fullBarrier !== "reset_session" && value.fullBarrier !== "nap")
+      return { kind: "invalid" };
+    return {
+      kind: "state",
+      state: {
+        version: 1,
+        attemptedSessionId: value.attemptedSessionId,
+        fencedSessionId: value.fencedSessionId,
+        fullBarrier: value.fullBarrier
+      }
+    };
+  } catch {
+    return { kind: "invalid" };
+  } finally {
+    if (fd !== null) {
+      try {
+        fs7.closeSync(fd);
+      } catch {}
+    }
+  }
+}
+function updateResumeControlState(timelineDir, update) {
   if (timelineDirectoryState(timelineDir) !== "safe")
     return false;
-  const filename = filenameForDate(now);
-  const filePath = join10(timelineDir, filename);
-  const lockPath = lockPathFor(timelineDir, filename);
+  const lockPath = lockPathFor(timelineDir, RESUME_CONTROL_FILENAME);
   if (!acquireLock(lockPath))
     return false;
   try {
-    const existing = scanTimelineFile(filePath);
-    const required2 = timelineLine(entry);
-    if (!existing || !required2)
+    const current = readResumeControlState(timelineDir);
+    const base = current.kind === "state" ? current.state : EMPTY_RESUME_CONTROL;
+    const next = update({ ...base });
+    const canonical = {
+      version: 1,
+      attemptedSessionId: next.attemptedSessionId,
+      fencedSessionId: next.fencedSessionId,
+      fullBarrier: next.fullBarrier
+    };
+    const body = JSON.stringify(canonical) + `
+`;
+    if (Buffer.byteLength(body, "utf8") > RESUME_CONTROL_MAX_BYTES)
       return false;
-    return writeRequiredTimeline(filePath, [...existing, required2], required2);
+    const filePath = join10(timelineDir, RESUME_CONTROL_FILENAME);
+    const tempPath = join10(timelineDir, `.${RESUME_CONTROL_FILENAME}.${process.pid}.${randomBytes4(12).toString("hex")}.tmp`);
+    let fd = null;
+    try {
+      fd = fs7.openSync(tempPath, "wx", 384);
+      fs7.writeFileSync(fd, body, "utf8");
+      fs7.fsyncSync(fd);
+      fs7.closeSync(fd);
+      fd = null;
+      fs7.renameSync(tempPath, filePath);
+      return true;
+    } finally {
+      if (fd !== null) {
+        try {
+          fs7.closeSync(fd);
+        } catch {}
+      }
+      try {
+        fs7.unlinkSync(tempPath);
+      } catch {}
+    }
   } catch {
     return false;
   } finally {
     releaseLock(lockPath);
   }
 }
-function appendOrMergeEntry(timelineDir, entry, now = new Date) {
+function appendTrackedEntry(timelineDir, entry, now = new Date) {
   if (timelineDirectoryState(timelineDir) !== "safe")
-    return false;
+    return { status: "rejected", reason: "unsafe" };
   const filename = filenameForDate(now);
   const filePath = join10(timelineDir, filename);
   const lockPath = lockPathFor(timelineDir, filename);
-  if (!acquireLock(lockPath))
-    return false;
+  try {
+    if (!acquireLock(lockPath))
+      return { status: "rejected", reason: "lock" };
+  } catch {
+    return { status: "rejected", reason: "write" };
+  }
   try {
     const existing = scanTimelineFile(filePath);
-    if (!existing)
-      return false;
-    if (existing.length > 0) {
-      const latest = existing[existing.length - 1].entry;
-      const mergeable = !latest.system && !entry.system && latest.session_id === entry.session_id && latest.provider === entry.provider && latest.agent_responses.length === 0;
-      if (mergeable) {
-        const merged = {
-          ...latest,
-          messages: [...latest.messages, ...entry.messages],
-          agent_responses: [...latest.agent_responses]
-        };
-        const required3 = timelineLine(merged);
-        if (!required3)
-          return false;
-        return writeRequiredTimeline(filePath, [...existing.slice(0, -1), required3], required3);
-      }
-    }
     const required2 = timelineLine(entry);
+    if (!existing)
+      return { status: "rejected", reason: "unsafe" };
     if (!required2)
-      return false;
-    return writeRequiredTimeline(filePath, [...existing, required2], required2);
+      return { status: "rejected", reason: "oversized" };
+    return writeTrackedTimeline(filePath, filename, existing, [...existing, required2], required2);
   } catch {
-    return false;
+    return { status: "rejected", reason: "write" };
   } finally {
     releaseLock(lockPath);
   }
 }
-function updateLatestEntryResult(timelineDir, updater, opts = {}) {
-  const directoryState = timelineDirectoryState(timelineDir);
-  if (directoryState !== "safe")
-    return directoryState === "missing" ? "missing" : "rejected";
-  const now = opts.now ?? new Date;
-  const maxDays = opts.maxDays ?? 7;
-  for (const filename of recentFilenames(maxDays, now)) {
-    const filePath = join10(timelineDir, filename);
-    let source;
-    try {
-      source = fs7.lstatSync(filePath);
-    } catch (error51) {
-      if (error51.code === "ENOENT")
-        continue;
-      return "rejected";
-    }
-    if (!source.isFile())
-      return "rejected";
-    const lockPath = lockPathFor(timelineDir, filename);
+function updateTrackedEntry(timelineDir, handle, update) {
+  if (timelineDirectoryState(timelineDir) !== "safe")
+    return { status: "rejected", reason: "unsafe" };
+  if (!DATE_FILENAME_PATTERN.test(handle.filename) || basename(handle.filename) !== handle.filename) {
+    return { status: "rejected", reason: "unsafe" };
+  }
+  const filePath = join10(timelineDir, handle.filename);
+  const lockPath = lockPathFor(timelineDir, handle.filename);
+  try {
     if (!acquireLock(lockPath))
-      return "rejected";
-    try {
-      const lines = scanTimelineFile(filePath);
-      if (!lines)
-        return "rejected";
-      if (lines.length === 0)
-        continue;
-      const latest = lines[lines.length - 1].entry;
-      if (latest.system)
-        return "missing";
-      const updated = {
-        ...latest,
-        messages: [...latest.messages],
-        agent_responses: [...latest.agent_responses]
-      };
-      try {
-        updater(updated);
-      } catch {
-        return "rejected";
-      }
-      const required2 = timelineLine(updated);
-      if (!required2)
-        return "rejected";
-      return writeRequiredTimeline(filePath, [...lines.slice(0, -1), required2], required2) ? "updated" : "rejected";
-    } catch {
-      return "rejected";
-    } finally {
-      releaseLock(lockPath);
-    }
+      return { status: "rejected", reason: "lock" };
+  } catch {
+    return { status: "rejected", reason: "write" };
+  }
+  try {
+    const existing = scanTimelineFile(filePath);
+    if (!existing)
+      return { status: "rejected", reason: "unsafe" };
+    if (existing.length === 0)
+      return { status: "rejected", reason: "missing" };
+    const generation = timelineFileGeneration(filePath, existing);
+    if (!generation || generation !== handle.fileGeneration) {
+      return { status: "rejected", reason: "generation" };
+    }
+    const captured = existing[handle.rowOrdinal];
+    if (!captured)
+      return { status: "rejected", reason: "ordinal" };
+    if (timelineRowHash(captured) !== handle.expectedHash) {
+      return { status: "rejected", reason: "hash" };
+    }
+    if (captured.entry.system)
+      return { status: "rejected", reason: "system" };
+    const nextEntry = update({
+      ...captured.entry,
+      messages: [...captured.entry.messages],
+      agent_responses: [...captured.entry.agent_responses]
+    });
+    const replacement = timelineLine(nextEntry);
+    if (!replacement)
+      return { status: "rejected", reason: "oversized" };
+    const input = [...existing];
+    input[handle.rowOrdinal] = replacement;
+    return writeTrackedTimeline(filePath, handle.filename, existing, input, replacement, { oldOrdinal: handle.rowOrdinal, line: replacement });
+  } catch {
+    return { status: "rejected", reason: "write" };
+  } finally {
+    releaseLock(lockPath);
   }
-  return "missing";
 }
 function yieldToEventLoop() {
   return new Promise((resolve3) => setImmediate(resolve3));
@@ -27431,84 +28074,562 @@ function createTimelineEntry(fields) {
     provider: fields.provider ?? null
   };
 }
-function createSystemEntry(type, time3) {
+function createSystemEntry(type, time3, backendSessionId) {
   return {
     session_id: null,
     messages: [],
     agent_responses: [],
     provider: null,
-    system: { type, time: time3 }
+    system: {
+      type,
+      time: time3,
+      ...backendSessionId ? { backend_session_id: backendSessionId } : {}
+    }
   };
 }
-function findResumableSession(rows, provider) {
+function resolveResumableSession(rows, provider) {
+  let candidateSessionId = null;
+  let recoveryMarkerSeen = false;
+  let stalledSessionId = null;
+  let fencedSessionId = null;
   for (let i = rows.length - 1;i >= 0; i--) {
     const e = rows[i];
-    if (e.system?.type === "reset_session" || e.system?.type === "nap")
-      return null;
+    if (e.system) {
+      if (e.system.type === "stall_recovery_attempt") {
+        if (!recoveryMarkerSeen) {
+          recoveryMarkerSeen = true;
+          stalledSessionId = e.system.backend_session_id ?? null;
+        }
+        continue;
+      }
+      if (e.system.type === "stall_recovery_clear") {
+        if (!recoveryMarkerSeen)
+          recoveryMarkerSeen = true;
+        continue;
+      }
+      if (e.system.type === "stall_recovery" && fencedSessionId === null) {
+        fencedSessionId = e.system.backend_session_id ?? null;
+      }
+      if (candidateSessionId !== null) {
+        return {
+          kind: "session",
+          sessionId: candidateSessionId,
+          stalledSessionId: stalledSessionId === candidateSessionId ? stalledSessionId : null,
+          fencedSessionId
+        };
+      }
+      return {
+        kind: "barrier",
+        type: e.system.type,
+        forgottenSessionId: e.system.backend_session_id ?? null,
+        fencedSessionId
+      };
+    }
     if (!e.session_id)
       continue;
     if (provider && e.provider !== provider)
       continue;
-    return e.session_id;
+    if (candidateSessionId === null) {
+      candidateSessionId = e.session_id;
+      continue;
+    }
+    if (candidateSessionId !== e.session_id)
+      break;
   }
-  return null;
+  if (candidateSessionId !== null) {
+    return {
+      kind: "session",
+      sessionId: candidateSessionId,
+      stalledSessionId: stalledSessionId === candidateSessionId ? stalledSessionId : null,
+      fencedSessionId
+    };
+  }
+  return { kind: "none", stalledSessionId, fencedSessionId };
 }
 // src/timeline/recorder.ts
 var MAX_AGENT_RESPONSES = 5;
-function appendAgentResponse(entry, text2) {
-  entry.agent_responses.push(text2);
-  if (entry.agent_responses.length > MAX_AGENT_RESPONSES) {
-    entry.agent_responses.splice(0, entry.agent_responses.length - MAX_AGENT_RESPONSES);
+var MAX_AGENT_RESPONSE_BYTES = 65536;
+var MAX_PENDING_COMMITS_PER_AGENT = 8;
+var PENDING_COMMIT_TTL_MS = 15 * 60000;
+var TRUNCATION_MARKER = `
+… [truncated]`;
+function turnKey(agentId, owner) {
+  return `${agentId}\x00${owner.sessionInstanceId}\x00${owner.rootTurnId}\x00${owner.barrierGeneration}`;
+}
+function sameOwner(left, right) {
+  return left.sessionInstanceId === right.sessionInstanceId && left.rootTurnId === right.rootTurnId && left.barrierGeneration === right.barrierGeneration;
+}
+function utf8Prefix2(text2, maxBytes) {
+  if (maxBytes <= 0)
+    return "";
+  if (Buffer.byteLength(text2, "utf8") <= maxBytes)
+    return text2;
+  let low = 0;
+  let high = text2.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    let end2 = mid;
+    const code2 = text2.charCodeAt(end2 - 1);
+    if (code2 >= 55296 && code2 <= 56319)
+      end2 -= 1;
+    if (Buffer.byteLength(text2.slice(0, end2), "utf8") <= maxBytes)
+      low = mid;
+    else
+      high = mid - 1;
+  }
+  let end = low;
+  const code = text2.charCodeAt(end - 1);
+  if (code >= 55296 && code <= 56319)
+    end -= 1;
+  while (end > 0 && Buffer.byteLength(text2.slice(0, end), "utf8") > maxBytes)
+    end -= 1;
+  return text2.slice(0, end);
+}
+function boundedResponse(text2, alreadyTruncated) {
+  const markerBytes = Buffer.byteLength(TRUNCATION_MARKER, "utf8");
+  const needsTruncation = alreadyTruncated || Buffer.byteLength(text2, "utf8") > MAX_AGENT_RESPONSE_BYTES;
+  if (!needsTruncation)
+    return text2;
+  return utf8Prefix2(text2, MAX_AGENT_RESPONSE_BYTES - markerBytes) + TRUNCATION_MARKER;
+}
+function serializedTimelineBytes(entry) {
+  return Buffer.byteLength(JSON.stringify(entry), "utf8") + 1;
+}
+function fitResponsesToRow(entry, responses) {
+  let fitted = [...entry.agent_responses];
+  for (const response of responses) {
+    fitted = [...fitted, response].slice(-MAX_AGENT_RESPONSES);
+    if (serializedTimelineBytes({ ...entry, agent_responses: fitted }) <= TIMELINE_MAX_BYTES)
+      continue;
+    const truncationBase = response.endsWith(TRUNCATION_MARKER) ? response.slice(0, -TRUNCATION_MARKER.length) : response;
+    let low = 0;
+    let high = truncationBase.length;
+    let replacement = null;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      let end = mid;
+      const code = truncationBase.charCodeAt(end - 1);
+      if (code >= 55296 && code <= 56319)
+        end -= 1;
+      const candidateResponse = truncationBase.slice(0, end) + TRUNCATION_MARKER;
+      const candidate = [...fitted.slice(0, -1), candidateResponse];
+      if (serializedTimelineBytes({ ...entry, agent_responses: candidate }) <= TIMELINE_MAX_BYTES) {
+        replacement = candidateResponse;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    if (replacement === null)
+      return null;
+    fitted[fitted.length - 1] = replacement;
   }
+  return fitted;
 }
 function createTimelineRecorder(opts) {
   const now = opts.now ?? (() => new Date);
   const dirFor = (agentId) => opts.timelineDirFor(agentId);
   const sessionByAgent = new Map;
+  const resolveForAgent = (agentId, provider) => {
+    const dir = dirFor(agentId);
+    const recent = resolveResumableSession(readRecentEntries(dir, { now: now() }), provider ?? undefined);
+    const control = readResumeControlState(dir);
+    if (control.kind === "missing")
+      return recent;
+    if (control.kind === "invalid") {
+      return {
+        kind: "barrier",
+        type: "reset_session",
+        forgottenSessionId: null,
+        fencedSessionId: null
+      };
+    }
+    const { attemptedSessionId, fencedSessionId, fullBarrier } = control.state;
+    if (fullBarrier !== null) {
+      return {
+        kind: "barrier",
+        type: fullBarrier,
+        forgottenSessionId: null,
+        fencedSessionId
+      };
+    }
+    if (recent.kind === "session") {
+      return {
+        kind: "session",
+        sessionId: recent.sessionId,
+        stalledSessionId: attemptedSessionId === recent.sessionId ? attemptedSessionId : null,
+        fencedSessionId
+      };
+    }
+    if (recent.kind === "barrier") {
+      if (recent.type !== "stall_recovery" || recent.forgottenSessionId === fencedSessionId) {
+        return { ...recent, fencedSessionId };
+      }
+    }
+    return { kind: "none", stalledSessionId: attemptedSessionId, fencedSessionId };
+  };
+  const sessionByEpoch = new Map;
+  const barrierByAgent = new Map;
+  const turnsByAgent = new Map;
+  const activeTurnByAgent = new Map;
+  const epochKey = (agentId, sessionInstanceId) => `${agentId}\x00${sessionInstanceId}`;
+  const currentBarrier = (agentId) => barrierByAgent.get(agentId) ?? 0;
+  const statesFor = (agentId) => {
+    let states = turnsByAgent.get(agentId);
+    if (!states) {
+      states = new Map;
+      turnsByAgent.set(agentId, states);
+    }
+    return states;
+  };
+  const diagnostic = (agentId, code, reason) => {
+    try {
+      opts.onDiagnostic?.({ agentId, code, ...reason ? { reason } : {} });
+    } catch {}
+  };
+  const applyRewrite = (agentId, rewrite) => {
+    for (const state of statesFor(agentId).values()) {
+      if (!state.handle)
+        continue;
+      const refreshed = refreshTimelineEntryHandle(state.handle, rewrite);
+      if (refreshed) {
+        state.handle = refreshed;
+      } else if (state.handle.filename === rewrite.filename) {
+        state.handle = undefined;
+        state.rowFenced = true;
+        diagnostic(agentId, "timeline_handle_fenced", "rewrite_remap");
+      }
+    }
+  };
+  const handleTrackedResult = (agentId, state, result) => {
+    if (result.status === "written") {
+      applyRewrite(agentId, result.rewrite);
+      if (state && result.handle) {
+        state.handle = result.handle;
+        state.rowFenced = false;
+      }
+      return "written";
+    }
+    if (result.reason === "lock" || result.reason === "write")
+      return "retryable";
+    if (state && result.reason !== "oversized")
+      state.rowFenced = true;
+    diagnostic(agentId, "timeline_exact_write_rejected", result.reason);
+    return "terminal";
+  };
+  const tryCommit = (agentId, state) => {
+    if (state.responses.length === 0)
+      return "written";
+    const dir = dirFor(agentId);
+    if (!prepareTimelineDirectory(dir)) {
+      diagnostic(agentId, "timeline_directory_unavailable");
+      return "terminal";
+    }
+    if (state.handle) {
+      const result2 = updateTrackedEntry(dir, state.handle, (entry2) => {
+        const fitted2 = fitResponsesToRow(entry2, state.responses);
+        return { ...entry2, agent_responses: fitted2 ?? [...entry2.agent_responses, ...state.responses] };
+      });
+      return handleTrackedResult(agentId, state, result2);
+    }
+    if (state.rowFenced || state.pendingMode === "handle")
+      return "terminal";
+    if (state.owner.barrierGeneration !== currentBarrier(agentId))
+      return "terminal";
+    const entry = createTimelineEntry({
+      messages: [],
+      sessionId: state.backendSessionId,
+      provider: state.provider
+    });
+    const fitted = fitResponsesToRow(entry, state.responses);
+    if (!fitted) {
+      diagnostic(agentId, "timeline_response_did_not_fit", "oversized");
+      return "terminal";
+    }
+    entry.agent_responses = fitted;
+    const result = appendTrackedEntry(dir, entry, now());
+    return handleTrackedResult(agentId, state, result);
+  };
+  const deleteState = (agentId, key) => {
+    const states = statesFor(agentId);
+    states.delete(key);
+    if (activeTurnByAgent.get(agentId) === key)
+      activeTurnByAgent.delete(agentId);
+    if (states.size === 0)
+      turnsByAgent.delete(agentId);
+  };
+  const retryPending = (agentId) => {
+    const states = turnsByAgent.get(agentId);
+    if (!states)
+      return;
+    const nowMs = now().getTime();
+    for (const [key, state] of [...states]) {
+      if (state.finalized && state.pendingSinceMs === undefined && state.completedAtMs !== undefined && nowMs - state.completedAtMs >= PENDING_COMMIT_TTL_MS) {
+        deleteState(agentId, key);
+        continue;
+      }
+      if (!state.finalized || state.pendingSinceMs === undefined)
+        continue;
+      if (nowMs - state.pendingSinceMs >= PENDING_COMMIT_TTL_MS) {
+        diagnostic(agentId, "timeline_pending_commit_expired");
+        deleteState(agentId, key);
+        continue;
+      }
+      const result = tryCommit(agentId, state);
+      if (result === "written") {
+        state.responses = [];
+        state.pendingSinceMs = undefined;
+        state.pendingMode = undefined;
+        state.completedAtMs = nowMs;
+      } else if (result === "terminal") {
+        deleteState(agentId, key);
+      }
+    }
+    const completed = [...states.entries()].filter(([, state]) => state.finalized && state.pendingSinceMs === undefined).sort((left, right) => (left[1].completedAtMs ?? 0) - (right[1].completedAtMs ?? 0));
+    while (completed.length > MAX_PENDING_COMMITS_PER_AGENT) {
+      const oldest = completed.shift();
+      if (oldest)
+        deleteState(agentId, oldest[0]);
+    }
+  };
+  const retainPending = (agentId, key, state) => {
+    const states = statesFor(agentId);
+    const pending = [...states.values()].filter((candidate) => candidate.finalized && candidate.pendingSinceMs !== undefined);
+    if (pending.length >= MAX_PENDING_COMMITS_PER_AGENT) {
+      diagnostic(agentId, "timeline_pending_commit_overflow");
+      deleteState(agentId, key);
+      return;
+    }
+    state.pendingSinceMs ??= now().getTime();
+    state.pendingMode = state.handle ? "handle" : "fallback";
+  };
+  const appendOwnerless = (agentId, messages) => {
+    if (messages.length === 0)
+      return;
+    const dir = dirFor(agentId);
+    if (!prepareTimelineDirectory(dir))
+      return;
+    const result = appendTrackedEntry(dir, createTimelineEntry({
+      messages,
+      sessionId: sessionByAgent.get(agentId) ?? null,
+      provider: opts.providerFor?.(agentId) ?? null
+    }), now());
+    handleTrackedResult(agentId, null, result);
+  };
   return {
-    setSession(agentId, sessionId) {
-      sessionByAgent.set(agentId, sessionId);
+    barrierGeneration(agentId) {
+      return currentBarrier(agentId);
     },
-    appendEntryForAgent(agentId, messages) {
+    beginTurn(agentId, owner) {
+      retryPending(agentId);
+      const states = statesFor(agentId);
+      if (owner.barrierGeneration !== currentBarrier(agentId)) {
+        diagnostic(agentId, "timeline_turn_begin_fenced", "barrier_generation");
+        return;
+      }
+      const key = turnKey(agentId, owner);
+      if (!states.has(key)) {
+        states.set(key, {
+          owner: { ...owner },
+          provider: opts.providerFor?.(agentId) ?? null,
+          backendSessionId: sessionByEpoch.get(epochKey(agentId, owner.sessionInstanceId)) ?? sessionByAgent.get(agentId) ?? null,
+          responses: [],
+          rowFenced: false,
+          finalized: false
+        });
+      }
+      activeTurnByAgent.set(agentId, key);
+    },
+    recordInboxPull(agentId, owner, messages) {
+      retryPending(agentId);
       if (messages.length === 0)
         return;
+      if (!owner) {
+        appendOwnerless(agentId, messages);
+        return;
+      }
+      const key = turnKey(agentId, owner);
+      const state = turnsByAgent.get(agentId)?.get(key);
+      if (!state || state.rowFenced || !sameOwner(state.owner, owner)) {
+        appendOwnerless(agentId, messages);
+        return;
+      }
       const dir = dirFor(agentId);
       if (!prepareTimelineDirectory(dir))
         return;
-      appendOrMergeEntry(dir, createTimelineEntry({
-        messages,
-        sessionId: sessionByAgent.get(agentId) ?? null,
-        provider: opts.providerFor?.(agentId) ?? null
-      }), now());
+      const stamp = now();
+      let result;
+      if (state.handle && (state.handle.filename === filenameForDate(stamp) || state.owner.barrierGeneration !== currentBarrier(agentId))) {
+        result = updateTrackedEntry(dir, state.handle, (entry) => ({
+          ...entry,
+          messages: [...entry.messages, ...messages],
+          session_id: state.backendSessionId,
+          provider: state.provider
+        }));
+      } else if (state.owner.barrierGeneration === currentBarrier(agentId)) {
+        result = appendTrackedEntry(dir, createTimelineEntry({
+          messages,
+          sessionId: state.backendSessionId,
+          provider: state.provider
+        }), stamp);
+      } else {
+        appendOwnerless(agentId, messages);
+        return;
+      }
+      handleTrackedResult(agentId, state, result);
     },
-    appendResponseToLatest(agentId, text2) {
-      const dir = dirFor(agentId);
-      if (!prepareTimelineDirectory(dir))
+    recordAssistantMessage(agentId, owner, text2, truncated = false) {
+      retryPending(agentId);
+      const key = turnKey(agentId, owner);
+      const state = turnsByAgent.get(agentId)?.get(key);
+      if (!state || state.finalized || state.owner.barrierGeneration !== currentBarrier(agentId) || !sameOwner(state.owner, owner)) {
+        diagnostic(agentId, "timeline_completed_message_rejected", "stale_owner");
         return;
-      const result = updateLatestEntryResult(dir, (entry2) => appendAgentResponse(entry2, text2), { now: now() });
-      if (result === "updated" || result === "rejected")
+      }
+      state.responses.push(boundedResponse(text2, truncated));
+      if (state.responses.length > MAX_AGENT_RESPONSES) {
+        state.responses.splice(0, state.responses.length - MAX_AGENT_RESPONSES);
+      }
+    },
+    finalizeTurn(agentId, owner) {
+      retryPending(agentId);
+      const key = turnKey(agentId, owner);
+      const state = turnsByAgent.get(agentId)?.get(key);
+      if (!state || state.finalized || !sameOwner(state.owner, owner))
         return;
-      const entry = createTimelineEntry({
-        messages: [],
-        sessionId: sessionByAgent.get(agentId) ?? null,
-        provider: opts.providerFor?.(agentId) ?? null
-      });
-      appendAgentResponse(entry, text2);
-      appendEntry(dir, entry, now());
+      const fallbackAuthorized = activeTurnByAgent.get(agentId) === key && owner.barrierGeneration === currentBarrier(agentId);
+      state.finalized = true;
+      activeTurnByAgent.delete(agentId);
+      if (state.responses.length === 0) {
+        state.completedAtMs = now().getTime();
+        return;
+      }
+      if (!state.handle && !fallbackAuthorized) {
+        diagnostic(agentId, "timeline_fallback_rejected", "fenced_owner");
+        deleteState(agentId, key);
+        return;
+      }
+      const result = tryCommit(agentId, state);
+      if (result === "written") {
+        state.responses = [];
+        state.completedAtMs = now().getTime();
+      } else if (result === "terminal") {
+        deleteState(agentId, key);
+      } else {
+        retainPending(agentId, key, state);
+      }
+    },
+    fenceSession(agentId) {
+      retryPending(agentId);
+      barrierByAgent.set(agentId, currentBarrier(agentId) + 1);
+      activeTurnByAgent.delete(agentId);
+      const states = turnsByAgent.get(agentId);
+      if (!states)
+        return;
+      for (const [key, state] of [...states]) {
+        if (!state.handle) {
+          diagnostic(agentId, "timeline_fallback_rejected", "session_fence");
+          deleteState(agentId, key);
+        }
+      }
+    },
+    setSession(agentId, sessionId, sessionInstanceId) {
+      retryPending(agentId);
+      const dir = dirFor(agentId);
+      if (!prepareTimelineDirectory(dir))
+        return false;
+      const persisted = updateResumeControlState(dir, (state) => ({
+        ...state,
+        fullBarrier: null,
+        attemptedSessionId: state.attemptedSessionId === sessionId ? state.attemptedSessionId : null
+      }));
+      if (!persisted)
+        return false;
+      sessionByAgent.set(agentId, sessionId);
+      if (sessionInstanceId) {
+        sessionByEpoch.set(epochKey(agentId, sessionInstanceId), sessionId);
+        for (const state of statesFor(agentId).values()) {
+          if (state.owner.sessionInstanceId === sessionInstanceId)
+            state.backendSessionId = sessionId;
+        }
+      }
+      return true;
     },
     resumeSessionId(agentId, provider) {
-      const rows = readRecentEntries(dirFor(agentId), { now: now() });
-      return findResumableSession(rows, provider ?? undefined);
+      const resolution = resolveForAgent(agentId, provider);
+      return resolution.kind === "session" ? resolution.sessionId : null;
+    },
+    resolveResumeSession(agentId, provider) {
+      return resolveForAgent(agentId, provider);
     },
-    forgetSession(agentId, barrierType = "reset_session") {
+    recordSessionStall(agentId, sessionId) {
+      return appendStallMarker(agentId, "stall_recovery_attempt", sessionId);
+    },
+    clearSessionStall(agentId, sessionId) {
+      return appendStallMarker(agentId, "stall_recovery_clear", sessionId);
+    },
+    forgetSession(agentId, barrierType = "reset_session", forgottenSessionId) {
+      retryPending(agentId);
       const dir = dirFor(agentId);
-      sessionByAgent.delete(agentId);
       if (!prepareTimelineDirectory(dir))
-        return;
+        return false;
       const stamp = now();
-      appendEntry(dir, createSystemEntry(barrierType, stamp.toISOString()), stamp);
+      let persisted = false;
+      if (barrierType === "reset_session" || barrierType === "nap") {
+        persisted = updateResumeControlState(dir, (state) => ({
+          ...state,
+          attemptedSessionId: null,
+          fencedSessionId: null,
+          fullBarrier: barrierType
+        }));
+      } else if (barrierType === "stall_recovery") {
+        persisted = updateResumeControlState(dir, (state) => ({
+          ...state,
+          attemptedSessionId: state.attemptedSessionId === forgottenSessionId ? null : state.attemptedSessionId,
+          fencedSessionId: forgottenSessionId ?? null,
+          fullBarrier: null
+        }));
+      }
+      if (!persisted)
+        return false;
+      sessionByAgent.delete(agentId);
+      for (const key of [...sessionByEpoch.keys()]) {
+        if (key.startsWith(`${agentId}\x00`))
+          sessionByEpoch.delete(key);
+      }
+      barrierByAgent.set(agentId, currentBarrier(agentId) + 1);
+      activeTurnByAgent.delete(agentId);
+      const states = turnsByAgent.get(agentId);
+      if (states) {
+        for (const [key, state] of [...states]) {
+          if (!state.handle) {
+            diagnostic(agentId, "timeline_fallback_rejected", "barrier");
+            deleteState(agentId, key);
+          }
+        }
+      }
+      const result = appendTrackedEntry(dir, createSystemEntry(barrierType, stamp.toISOString(), forgottenSessionId), stamp);
+      handleTrackedResult(agentId, null, result);
+      return true;
     }
   };
+  function appendStallMarker(agentId, type, sessionId) {
+    retryPending(agentId);
+    const dir = dirFor(agentId);
+    if (!prepareTimelineDirectory(dir))
+      return false;
+    const stamp = now();
+    const persisted = updateResumeControlState(dir, (state) => ({
+      ...state,
+      attemptedSessionId: type === "stall_recovery_attempt" ? sessionId : null,
+      fullBarrier: null
+    }));
+    if (!persisted)
+      return false;
+    const result = appendTrackedEntry(dir, createSystemEntry(type, stamp.toISOString(), sessionId), stamp);
+    handleTrackedResult(agentId, null, result);
+    return true;
+  }
 }
 // src/discovery.ts
 import * as path9 from "path";
@@ -28123,11 +29244,15 @@ async function createDaemon(opts) {
   const typingTracker = createTypingScopeTracker();
   const broker = new CredentialBroker({ upstreamBaseUrl: opts.serverUrl });
   const proxy = await startCredentialProxy(broker, {
-    onInboxPullStart: (agentId) => channelRef?.modelSeenGeneration(agentId),
+    onInboxPullStart: (agentId) => ({
+      modelSeenGeneration: channelRef?.modelSeenGeneration(agentId),
+      owner: managerRef?.timelineTurnOwner(agentId) ?? null
+    }),
     onInboxPullResponse: (agentId, messages, observationToken) => {
-      timeline2.appendEntryForAgent(agentId, messages);
-      if (typeof observationToken === "number") {
-        channelRef?.recordModelSeen(agentId, messages, observationToken);
+      const token = observationToken && typeof observationToken === "object" ? observationToken : null;
+      timeline2.recordInboxPull(agentId, token?.owner ?? null, messages);
+      if (typeof token?.modelSeenGeneration === "number") {
+        channelRef?.recordModelSeen(agentId, messages, token.modelSeenGeneration);
       }
     },
     onInboxPullObservationError: ({ agentId, reason, contentEncoding }) => {
@@ -28188,6 +29313,7 @@ async function createDaemon(opts) {
     typingTracker.clear(agentId);
   }
   const botsById = new Map;
+  let botCacheReady = false;
   async function listMyBotsHttp() {
     const res = await fetch(`${opts.serverUrl}/api/community/daemon/bots`, {
       method: "GET",
@@ -28198,22 +29324,26 @@ async function createDaemon(opts) {
     const json2 = await res.json();
     return json2.bots ?? [];
   }
+  function replaceBotCache(bots) {
+    botsById.clear();
+    for (const b of bots) {
+      botsById.set(b.id, {
+        name: b.name,
+        discriminator: b.discriminator,
+        description: b.description,
+        ownerName: b.ownerName,
+        ownerDiscriminator: b.ownerDiscriminator
+      });
+    }
+    botCacheReady = true;
+  }
   async function coldStartWarmup() {
     const start = Date.now();
     let attempt = 0;
     while (Date.now() - start < WARMUP_CEILING_MS) {
       try {
         const bots = await listMyBotsHttp();
-        botsById.clear();
-        for (const b of bots) {
-          botsById.set(b.id, {
-            name: b.name,
-            discriminator: b.discriminator,
-            description: b.description,
-            ownerName: b.ownerName,
-            ownerDiscriminator: b.ownerDiscriminator
-          });
-        }
+        replaceBotCache(bots);
         log.info("cold-start bot-cache warmup succeeded", { bots: bots.length, attempt });
         return;
       } catch {
@@ -28434,7 +29564,14 @@ async function createDaemon(opts) {
     const statusPath = opts.statusFilePath;
     const writeStatus = () => {
       const nowMs = Date.now();
-      writeStatusFile(statusPath, { writtenAt: nowMs, agents: manager.statusProjection(nowMs) });
+      writeStatusFile(statusPath, {
+        writtenAt: nowMs,
+        agentSummary: {
+          total: botCacheReady ? botsById.size : null,
+          running: manager.runningAgentCount()
+        },
+        agents: manager.statusProjection(nowMs)
+      });
     };
     writeStatus();
     statusTimer = setInterval(writeStatus, STATUS_WRITE_INTERVAL_MS);
@@ -28459,15 +29596,7 @@ async function createDaemon(opts) {
       if (!botsById.has(agentId)) {
         try {
           const bots = await listMyBotsHttp();
-          for (const b of bots) {
-            botsById.set(b.id, {
-              name: b.name,
-              discriminator: b.discriminator,
-              description: b.description,
-              ownerName: b.ownerName,
-              ownerDiscriminator: b.ownerDiscriminator
-            });
-          }
+          replaceBotCache(bots);
         } catch {}
       }
       if (!botsById.has(agentId)) {
@@ -28578,10 +29707,12 @@ export {
   RUNTIME_RAW_TRACE_AGENT_IDS_ENV,
   RUNTIME_AUTH_ACTION_REQUIRED_PATTERNS,
   LOCAL_MESSAGE_REMINDER_PATH,
+  DEFAULT_TURN_SILENCE_POLICY,
   DEFAULT_STOPPING_STUCK_THRESHOLD_MS,
   DEFAULT_STALE_THRESHOLD_MS,
   DEFAULT_RESET_STUCK_THRESHOLD_MS,
   DEFAULT_IDLE_TIMEOUT_MS,
+  DEFAULT_IDLE_RESET_TIMEOUT_MS,
   DEFAULT_HELD_CONTEXT_LIMIT,
   DEFAULT_CAPABILITY_RESOLVER,
   CredentialBroker,