@alook/daemon 0.1.17 → 0.1.18

package/dist/cli/index.js

@@ -20288,19 +20288,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 text2 = block.text ?? "";
         if (API_ERROR_RE.test(text2))
           out.push({ kind: "error", message: text2 });
         else
-          out.push({ kind: "text", text: text2 });
+          completedText.push(text2);
       } 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") {
@@ -20709,14 +20713,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":
@@ -20744,7 +20751,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);
@@ -20837,9 +20847,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 [];
     }
@@ -20872,7 +20882,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;
@@ -21529,14 +21545,14 @@ class CursorAcpLane {
       case "agent_message_chunk": {
         const content = record2(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 = record2(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;
       }
@@ -22341,16 +22357,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":
@@ -23101,22 +23121,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":
@@ -23281,6 +23307,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) {
@@ -23370,6 +23403,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;
 
@@ -23566,6 +23605,62 @@ function stableErrorCode(value, fallback) {
 
 // agent-driver/dist/controller/logical-session.js
 import { mkdirSync as mkdirSync4 } 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(text2, maxBytes) {
+  if (maxBytes <= 0 || text2.length === 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 appendSemanticFragment(buffer, text2) {
+  if (text2.length === 0 || buffer.truncated)
+    return;
+  const remaining = SEMANTIC_ASSEMBLER_MAX_BYTES - buffer.bytes;
+  const bytes = Buffer.byteLength(text2, "utf8");
+  if (bytes <= remaining) {
+    buffer.chunks.push(text2);
+    buffer.bytes += bytes;
+    return;
+  }
+  const prefix = utf8Prefix(text2, 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(text2) {
+  const buffer = emptySemanticAssembler();
+  appendSemanticFragment(buffer, text2);
+  return finishSemanticAssembler(buffer);
+}
 function driverError(category, code, message2, retryable = false) {
   return { category, code, message: scrubDriverErrorMessage(message2), retryable };
 }
@@ -23639,6 +23734,7 @@ class LogicalAgentSession {
   resumeOutcome;
   eventQueue;
   behavior;
+  turnSilence;
   constructor(backend, config2, launch, adapter, capabilities2, host, prepared, hostReleaseTimeoutMs) {
     this.backend = backend;
     this.config = config2;
@@ -23649,6 +23745,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) => {
@@ -23753,6 +23861,7 @@ class LogicalAgentSession {
       lastEventSequence: this.eventSequence,
       diagnostics: {
         deliveryPhase: this.deliveryPhase(),
+        turnSilence: this.turnSilence,
         metrics: {
           physicalOpenCount: this.metricValue(this.physicalOpenCount),
           turnCount: this.metricValue(this.turnCount),
@@ -23843,7 +23952,14 @@ class LogicalAgentSession {
     const turnId = this.host.createId();
     const commandIds = messages.map((message2) => message2.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;
@@ -24041,14 +24157,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;
@@ -24091,9 +24229,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);
@@ -24116,6 +24264,18 @@ class LogicalAgentSession {
         });
         return;
       case "turn_end":
+        if (turnId && this.activeTurn?.turnId === turnId) {
+          const reasoning = finishSemanticAssembler(this.activeTurn.pendingReasoning);
+          const message2 = 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 (message2.text.length > 0) {
+            this.emit({ type: "assistant_message_completed", turnId, ...message2 });
+          }
+        }
         this.completeTurn(event.sessionId, physicalOwner, generation, event.turnOwner);
         return;
     }
@@ -24129,7 +24289,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;
@@ -24139,7 +24299,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;
@@ -26242,11 +26405,26 @@ function isActivelyWorking(agent2) {
   return agent2.status === "running" && (leaseIsWorking(agent2.execution.lease) || agent2.pendingAdmissions.length > 0 || agent2.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) {
@@ -26261,6 +26439,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": {
@@ -26273,7 +26456,17 @@ function reduceManager(state, event) {
       {
         const a = agent2;
         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);
       }
@@ -26329,7 +26522,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 agent2 = clone2(existing);
+      agent2.sessionId = null;
+      agent2.stalledSessionId = null;
+      agent2.idleSince = null;
+      if (agent2.status !== "running")
+        return commit(state, agent2, []);
+      agent2.status = "stopping";
+      agent2.stoppingSince = event.nowMs;
+      return commit(state, agent2, [
+        { type: "stop", agentId: event.agentId, reason: "idle_session_reset" }
+      ]);
+    }
     case "begin_reset":
       if (!state.agents[event.agentId])
         return { state, effects: [] };
@@ -26367,8 +26578,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);
       });
@@ -26389,7 +26610,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))
@@ -26398,6 +26624,8 @@ function reduceManager(state, event) {
             state: "suspect_active",
             identity,
             lastWorkAt: event.nowMs,
+            nativeDeadlineAt: event.nowMs + a.turnSilence.normalBudgetMs,
+            recoveryExtensionsUsed: 0,
             reason: "work_after_terminal"
           };
         }
@@ -26411,7 +26639,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: [] };
@@ -26421,7 +26649,6 @@ function reduceManager(state, event) {
         const closing = agent2.pendingAdmissions.filter((entry) => entry.sessionInstanceId === event.sessionInstanceId);
         agent2.pendingAdmissions = agent2.pendingAdmissions.filter((entry) => entry.sessionInstanceId !== event.sessionInstanceId);
         agent2.execution = { sessionInstanceId: null, lease: { state: "detached" } };
-        agent2.idleSince = null;
         syncExecutionProjection(agent2);
         return commit(state, agent2, recoveryEffects(agent2, closing));
       }
@@ -26429,8 +26656,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((message2) => message2.id === event.message.id)) {
@@ -26468,7 +26744,7 @@ function onWake(state, agentId, message2) {
   }
   return commit(state, agent2, []);
 }
-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: [] };
@@ -26484,13 +26760,23 @@ function onTurnCompleted(state, agentId, sessionInstanceId, nowMs, turnId) {
   const lastTerminal = { identity, at: nowMs };
   agent2.execution.lease = { state: "none", lastTerminal };
   agent2.lastProgressAt = nowMs;
+  agent2.lastNativeActivityAt = nowMs;
+  agent2.lastNativeActivityKind = "turn_end";
+  agent2.runtimePhase = "terminal";
+  const clearedStallSessionId = endReason === undefined ? agent2.stalledSessionId : null;
+  if (clearedStallSessionId !== null)
+    agent2.stalledSessionId = null;
   syncExecutionProjection(agent2);
+  const clearEffects = clearedStallSessionId === null ? [] : [{ type: "clear_stall_recovery", agentId, sessionId: clearedStallSessionId }];
   if (agent2.inbox.length > 0) {
     const messages = drainInbox(agent2);
-    return commit(state, agent2, messages.map((queued) => ({ type: "send", agentId, message: queued, mode: "idle" })));
+    return commit(state, agent2, [
+      ...clearEffects,
+      ...messages.map((queued) => ({ type: "send", agentId, message: queued, mode: "idle" }))
+    ]);
   }
   agent2.idleSince = nowMs;
-  return commit(state, agent2, []);
+  return commit(state, agent2, clearEffects);
 }
 function onTurnToolLifecycle(state, event, lifecycle) {
   const existing = state.agents[event.agentId];
@@ -26512,11 +26798,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) {
-        agent2.execution.lease = { ...lease, lastWorkAt: event.nowMs, outstandingToolUses };
+        agent2.execution.lease = {
+          ...lease,
+          lastWorkAt: event.nowMs,
+          nativeDeadlineAt: event.nowMs + agent2.turnSilence.normalBudgetMs,
+          recoveryExtensionsUsed: 0,
+          outstandingToolUses
+        };
       } else {
         const unblockedLease = { ...lease };
         delete unblockedLease.outstandingToolUses;
-        agent2.execution.lease = { ...unblockedLease, lastWorkAt: event.nowMs };
+        agent2.execution.lease = {
+          ...unblockedLease,
+          lastWorkAt: event.nowMs,
+          nativeDeadlineAt: event.nowMs + agent2.turnSilence.normalBudgetMs,
+          recoveryExtensionsUsed: 0
+        };
       }
     } else {
       const terminal = lease.state === "none" ? lease.lastTerminal : null;
@@ -26526,11 +26823,16 @@ function onTurnToolLifecycle(state, event, lifecycle) {
         state: "suspect_active",
         identity,
         lastWorkAt: event.nowMs,
+        nativeDeadlineAt: event.nowMs + agent2.turnSilence.normalBudgetMs,
+        recoveryExtensionsUsed: 0,
         outstandingToolUses: 1,
         reason: "work_after_terminal"
       };
     }
     agent2.lastProgressAt = event.nowMs;
+    agent2.lastNativeActivityAt = event.nowMs;
+    agent2.lastNativeActivityKind = lifecycle === "started" ? "tool_call" : "tool_output";
+    agent2.runtimePhase = lifecycle === "started" ? "tool" : "inference";
     agent2.idleSince = null;
     syncExecutionProjection(agent2);
   });
@@ -26543,6 +26845,8 @@ function onExit(state, agentId) {
   const effects = recoveryEffects(agent2, agent2.pendingAdmissions);
   agent2.pendingAdmissions = [];
   agent2.execution = { sessionInstanceId: null, lease: { state: "detached" } };
+  agent2.runtimePhase = "idle";
+  agent2.backendTurnId = null;
   agent2.stoppingSince = null;
   syncExecutionProjection(agent2);
   if (agent2.inbox.length > 0) {
@@ -26562,10 +26866,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);
@@ -26597,9 +26910,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" });
     }
   }
@@ -26611,11 +26929,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,
@@ -26737,9 +27061,6 @@ function identitySection(config2) {
     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 (config2.description) {
-    parts.push("", "### Role", "", config2.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(`
 `);
 }
@@ -26976,7 +27297,17 @@ function chaosAwarenessSection() {
   ].join(`
 `);
 }
-function workspaceMemorySection() {
+function workspaceMemorySection(config2) {
+  const roleSection = config2.description ? [
+    "",
+    "### Your bio",
+    "",
+    config2.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",
     "",
@@ -26985,6 +27316,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",
     "",
@@ -27026,7 +27358,7 @@ function buildCliSystemPrompt(config2) {
     criticalRulesSection(),
     executionModelSection(),
     chaosAwarenessSection(),
-    workspaceMemorySection(),
+    workspaceMemorySection(config2),
     utilsSection()
   ];
   return sections.filter((s) => s && s.length > 0).join(`
@@ -27294,8 +27626,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;
@@ -27309,7 +27641,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,
@@ -27318,7 +27651,7 @@ class AgentProcessManager {
     };
     this.now = opts.now ?? (() => Date.now());
     this.log = opts.logger ?? createLogger2({ 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)
@@ -27337,11 +27670,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, message2) {
     this.dispatch({ type: "rewake_after_reset", agentId, message: message2 });
@@ -27364,9 +27705,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;
@@ -27441,6 +27787,10 @@ class AgentProcessManager {
       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,
@@ -27510,6 +27860,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",
@@ -27567,6 +27921,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,
@@ -27577,6 +27938,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" ? {
@@ -27611,11 +27973,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);
         }
       }
     }
@@ -27780,6 +28149,47 @@ ${this.opts.wakePromptFooter}` : text2;
       case "terminate_stalled": {
         const session2 = 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",
@@ -27798,10 +28208,27 @@ ${this.opts.wakePromptFooter}` : text2;
         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)
@@ -27824,6 +28251,26 @@ ${this.opts.wakePromptFooter}` : text2;
           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 session2 = this.sessions.get(effect.agentId);
         const state = this.activeSpawnState.get(effect.agentId);
@@ -27856,8 +28303,8 @@ ${this.opts.wakePromptFooter}` : text2;
       }
     }
   }
-  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;
@@ -27882,7 +28329,13 @@ ${this.opts.wakePromptFooter}` : text2;
       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;
@@ -27913,12 +28366,15 @@ ${this.opts.wakePromptFooter}` : text2;
       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);
@@ -27969,7 +28425,6 @@ ${this.opts.wakePromptFooter}` : text2;
           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);
       }
@@ -27994,10 +28449,23 @@ ${this.opts.wakePromptFooter}` : text2;
     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);
@@ -28016,7 +28484,8 @@ ${this.opts.wakePromptFooter}` : text2;
         type: "attach_session",
         agentId,
         sessionInstanceId: session2.sessionInstanceId,
-        nowMs: this.now()
+        nowMs: this.now(),
+        turnSilence: session2.snapshot().diagnostics?.turnSilence
       }, state);
       previousOwner?.pendingDeliverySpans.clear();
       (async () => {
@@ -28164,26 +28633,6 @@ ${this.opts.wakePromptFooter}` : text2;
       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: text2, truncated, chars } = truncateThinking(buffered);
-    try {
-      this.opts.onBotAuditEvent(agentId, {
-        kind: "thinking",
-        payload: { text: text2, 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;
@@ -28216,32 +28665,43 @@ ${this.opts.wakePromptFooter}` : text2;
       }
     }
     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: text2, truncated, chars } = truncateThinking(event.text);
+        try {
+          this.opts.onBotAuditEvent(agentId, {
+            kind: "thinking",
+            payload: { text: text2, 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,
@@ -28253,8 +28713,20 @@ ${this.opts.wakePromptFooter}` : text2;
         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);
@@ -28272,9 +28744,10 @@ ${this.opts.wakePromptFooter}` : text2;
       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":
@@ -28301,37 +28774,55 @@ ${this.opts.wakePromptFooter}` : text2;
       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);
@@ -28726,7 +29217,7 @@ function createTypingScopeTracker() {
 }
 // src/timeline/timeline.ts
 import * as fs9 from "node:fs";
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { createHash as createHash2, randomBytes as randomBytes4 } from "node:crypto";
 import { basename as basename3, dirname as dirname5, join as join11 } from "node:path";
 
 // src/timeline/filelock.ts
@@ -28793,17 +29284,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;
@@ -28821,13 +29320,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 createHash2("sha256").update(line.text, "utf8").digest("hex");
+}
+function timelineFileGeneration(filePath, lines) {
+  try {
+    const stat = fs9.lstatSync(filePath, { bigint: true });
+    if (!stat.isFile())
+      return null;
+    const digest = createHash2("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);
@@ -29039,11 +29585,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();
@@ -29075,114 +29647,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 = join11(timelineDir, RESUME_CONTROL_FILENAME);
+  let source;
+  try {
+    source = fs9.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 = fs9.openSync(filePath, fs9.constants.O_RDONLY | (fs9.constants.O_NOFOLLOW ?? 0));
+    const stat = fs9.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 = fs9.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 {
+        fs9.closeSync(fd);
+      } catch {}
+    }
+  }
+}
+function updateResumeControlState(timelineDir, update) {
   if (timelineDirectoryState(timelineDir) !== "safe")
     return false;
-  const filename = filenameForDate(now);
-  const filePath = join11(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 = join11(timelineDir, RESUME_CONTROL_FILENAME);
+    const tempPath = join11(timelineDir, `.${RESUME_CONTROL_FILENAME}.${process.pid}.${randomBytes4(12).toString("hex")}.tmp`);
+    let fd = null;
+    try {
+      fd = fs9.openSync(tempPath, "wx", 384);
+      fs9.writeFileSync(fd, body, "utf8");
+      fs9.fsyncSync(fd);
+      fs9.closeSync(fd);
+      fd = null;
+      fs9.renameSync(tempPath, filePath);
+      return true;
+    } finally {
+      if (fd !== null) {
+        try {
+          fs9.closeSync(fd);
+        } catch {}
+      }
+      try {
+        fs9.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 = join11(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 = join11(timelineDir, filename);
-    let source;
-    try {
-      source = fs9.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) || basename3(handle.filename) !== handle.filename) {
+    return { status: "rejected", reason: "unsafe" };
+  }
+  const filePath = join11(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((resolve4) => setImmediate(resolve4));
@@ -29246,84 +29885,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);
+    },
+    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;
+      }
+      state.responses.push(boundedResponse(text2, truncated));
+      if (state.responses.length > MAX_AGENT_RESPONSES) {
+        state.responses.splice(0, state.responses.length - MAX_AGENT_RESPONSES);
+      }
     },
-    appendResponseToLatest(agentId, text2) {
-      const dir = dirFor(agentId);
-      if (!prepareTimelineDirectory(dir))
+    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 result = updateLatestEntryResult(dir, (entry2) => appendAgentResponse(entry2, text2), { now: now() });
-      if (result === "updated" || result === "rejected")
+      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;
-      const entry = createTimelineEntry({
-        messages: [],
-        sessionId: sessionByAgent.get(agentId) ?? null,
-        provider: opts.providerFor?.(agentId) ?? null
-      });
-      appendAgentResponse(entry, text2);
-      appendEntry(dir, entry, now());
+      }
+      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);
+    },
+    recordSessionStall(agentId, sessionId) {
+      return appendStallMarker(agentId, "stall_recovery_attempt", sessionId);
     },
-    forgetSession(agentId, barrierType = "reset_session") {
+    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/daemon/diagnosticsCommand.ts
 function reportUnavailable(options, reportId) {
@@ -29868,11 +30985,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 }) => {
@@ -30634,8 +31755,8 @@ function projectDaemonLogRow(value, targetAgentId) {
     fields: projectedFields
   };
 }
-var MANAGER_EVENTS = ["register", "wake", "spawned", "session", "root_work", "turn_end", "exit", "tick", "reset_session", "begin_reset", "rewake_after_reset", "runtime_signal", "admission_started", "admission_settled"];
-var MANAGER_EFFECTS = ["spawn", "send", "stop", "terminate_stalled", "force_exit", "gated_hold"];
+var MANAGER_EVENTS = ["register", "wake", "spawned", "session", "root_work", "turn_end", "exit", "tick", "reset_session", "begin_reset", "rewake_after_reset", "runtime_signal", "stall_control_failed", "admission_started", "admission_settled"];
+var MANAGER_EFFECTS = ["spawn", "send", "stop", "terminate_stalled", "clear_stall_recovery", "force_exit", "gated_hold"];
 var AGENT_STATUSES = ["idle", "starting", "running", "stopping"];
 var DELIVERY_PHASES = ["idle", "admission_wait", "steering", "next_turn_queued", "compacting", "reviewing", "tool_wait", "working"];
 var RESUME_OUTCOMES = ["not_requested", "pending", "resumed", "reset_required", "failed"];
@@ -30644,6 +31765,8 @@ var TERMINATION_CAUSES = ["runtime_error", "killed_stalled", "other"];
 var SPAWN_FAILURE_REASONS = ["ENOENT", "handshake_timeout", "pre_handshake_exit", "spawn_threw", "other"];
 var TERMINATION_SEMANTICS = ["killed_stalled", "idle_stop", "force_exit", "other"];
 var ABORT_CAUSES = ["start_threw", "start_rejected", "send_threw", "spawn_failure", "handshake_timeout", "reset", "nap", "model_switch", "requested_stop", "shutdown", "physical_exit", "terminate_stalled", "force_exit", "other"];
+var NATIVE_ACTIVITY_KINDS = ["turn_started", "backend_turn_started", "thinking", "text", "tool_call", "tool_output", "internal_progress", "recovery", "turn_end"];
+var RUNTIME_PHASES = ["idle", "admission", "inference", "tool", "recovery", "terminal"];
 var EXIT_SIGNALS = new Set(["SIGABRT", "SIGALRM", "SIGBREAK", "SIGBUS", "SIGCHLD", "SIGCONT", "SIGFPE", "SIGHUP", "SIGILL", "SIGINFO", "SIGINT", "SIGIO", "SIGIOT", "SIGKILL", "SIGLOST", "SIGPIPE", "SIGPOLL", "SIGPROF", "SIGPWR", "SIGQUIT", "SIGSEGV", "SIGSTKFLT", "SIGSTOP", "SIGSYS", "SIGTERM", "SIGTRAP", "SIGTSTP", "SIGTTIN", "SIGTTOU", "SIGURG", "SIGUSR1", "SIGUSR2", "SIGVTALRM", "SIGWINCH", "SIGXCPU", "SIGXFSZ", "other"]);
 function enumValue(value, values, bucket = false, maxChars = 64) {
   if (!boundedString(value, maxChars))
@@ -30681,6 +31804,13 @@ function copyString(row, output, key, maxChars, optional2 = false, nullable2 = f
   output[key] = row[key];
   return true;
 }
+function copyScrubbedString(row, output, key, maxChars, optional2 = false, nullable2 = false) {
+  if (!copyString(row, output, key, maxChars, optional2, nullable2))
+    return false;
+  if (typeof output[key] === "string")
+    output[key] = scrubDiagnosticText(output[key]);
+  return true;
+}
 function projectTraceBase(row, targetAgentId) {
   if (row.agentId !== targetAgentId || !boundedString(row.agentId, 128) || !canonicalTime(row.timeIso))
     return null;
@@ -30707,11 +31837,29 @@ function projectFsm(row, targetAgentId) {
   Object.assign(output, { event, status, turnActive: row.turnActive });
   if (!copyInteger(row, output, "inbox") || !copyInteger(row, output, "lastDeliverAt", { nullable: true }) || !copyInteger(row, output, "lastProgressAt") || !copyInteger(row, output, "idleSince", { nullable: true }))
     return null;
+  if (!copyInteger(row, output, "lastNativeActivityAt", { optional: true }) || !copyScrubbedString(row, output, "backendTurnId", 512, true, true) || !copyInteger(row, output, "turnSilenceBudgetMs", { optional: true }) || !copyInteger(row, output, "nativeDeadlineAt", { optional: true, nullable: true }) || !copyInteger(row, output, "recoveryExtensionsUsed", { optional: true }))
+    return null;
+  if ("lastNativeActivityKind" in row && row.lastNativeActivityKind !== undefined) {
+    if (row.lastNativeActivityKind === null)
+      output.lastNativeActivityKind = null;
+    else {
+      const kind = enumValue(row.lastNativeActivityKind, NATIVE_ACTIVITY_KINDS);
+      if (!kind)
+        return null;
+      output.lastNativeActivityKind = kind;
+    }
+  }
+  if ("runtimePhase" in row && row.runtimePhase !== undefined) {
+    const phase = enumValue(row.runtimePhase, RUNTIME_PHASES);
+    if (!phase)
+      return null;
+    output.runtimePhase = phase;
+  }
   output.resetting = row.resetting;
   if (!copyInteger(row, output, "resettingSince", { nullable: true }) || !copyInteger(row, output, "stoppingSince", { nullable: true }))
     return null;
   output.deliveryPhase = deliveryPhase;
-  if (!copyInteger(row, output, "sinceProgressMs") || !copyInteger(row, output, "sinceDeliverMs", { nullable: true }) || !copyInteger(row, output, "sinceStoppingMs", { nullable: true }) || !projectOptionalSpanMetadata(row, output))
+  if (!copyInteger(row, output, "sinceProgressMs") || !copyInteger(row, output, "sinceNativeActivityMs", { optional: true }) || !copyInteger(row, output, "sinceDeliverMs", { nullable: true }) || !copyInteger(row, output, "sinceStoppingMs", { nullable: true }) || !projectOptionalSpanMetadata(row, output))
     return null;
   const metricKeys = [
     "physicalOpenCount",
@@ -30842,7 +31990,7 @@ function projectStatusRow(value, targetAgentId) {
   return output;
 }
 // src/diagnostics/bundle.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { createWriteStream, unlinkSync as unlinkSync5 } from "node:fs";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -30992,7 +32140,7 @@ async function buildDiagnosticBundle(args) {
   const { footer, total } = envelope();
   if (total > maxUncompressed)
     throw new BundleTooLargeError;
-  const hash2 = createHash2("sha256");
+  const hash2 = createHash3("sha256");
   let compressedBytes = 0;
   const meter = new Transform({
     transform(chunk2, _encoding, callback) {
@@ -31033,7 +32181,7 @@ async function buildDiagnosticBundle(args) {
   };
 }
 // src/diagnostics/coordinator.ts
-import { createHash as createHash3, randomBytes as randomBytes5 } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes5 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
   closeSync as closeSync4,
@@ -31189,7 +32337,7 @@ function createDiagnosticReportCoordinator(args) {
       if (!stat.isFile() || stat.isSymbolicLink())
         return null;
       const bytes = readFileSync6(path11);
-      return { sizeBytes: bytes.byteLength, sha256: createHash3("sha256").update(bytes).digest("hex") };
+      return { sizeBytes: bytes.byteLength, sha256: createHash4("sha256").update(bytes).digest("hex") };
     } catch {
       return null;
     }