chatroom-cli 1.128.0 → 1.128.1

package/dist/index.js

@@ -20251,6 +20251,16 @@ var init_agent_process_manager_service = __esm(() => {
   init_check_agent_slot();
 });
 
+// ../../services/backend/config/reliability.ts
+var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, NATIVE_DELIVERY_RECONCILE_MS = 1e4, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, MACHINE_COMMAND_LEASE_RENEWAL_INTERVAL_MS = 20000, MACHINE_COMMAND_DAEMON_ROUTINE_TTL_MS, SCOPE_TARGET_STOP_TIMEOUT_MS = 1e4, AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS = 120000, CONNECTION_CLOSE_REQUEST_TTL_MS, ENHANCER_TERMINAL_JOB_RETENTION_MS;
+var init_reliability = __esm(() => {
+  DAEMON_HEARTBEAT_INTERVAL_MS = 5 * 60000;
+  DAEMON_HEARTBEAT_TTL_MS = 6 * DAEMON_HEARTBEAT_INTERVAL_MS;
+  MACHINE_COMMAND_DAEMON_ROUTINE_TTL_MS = 5 * 60000;
+  CONNECTION_CLOSE_REQUEST_TTL_MS = 10 * 60000;
+  ENHANCER_TERMINAL_JOB_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+});
+
 // ../shared/src/domain/team-kind.ts
 var TEAM_PRESET_IDS;
 var init_team_kind = __esm(() => {
@@ -35229,8 +35239,10 @@ var init_agent_lifecycle_fact = __esm(() => {
 function isDeliverableTaskStatus(status) {
   return status === "pending" || status === "acknowledged";
 }
+var ACTIVE_TASK_STATUSES;
 var init_assigned_task = __esm(() => {
   init_agent_role();
+  ACTIVE_TASK_STATUSES = ["pending", "acknowledged", "in_progress"];
 });
 
 // src/daemon/infrastructure/local/harness/services/spawn-prompt.ts
@@ -35292,6 +35304,17 @@ var init_native_task_injector_logic = __esm(() => {
   };
 });
 
+// src/daemon/services/task-service/domain/usecase/uncovered-turn-nudge.ts
+function buildUncoveredTurnNudgePrompt(args2) {
+  return [
+    `Your previous turn ended, but task ${args2.taskId} has no handoff recorded.`,
+    "If the work is complete, run `chatroom handoff` for this task now, as instructed in the task.",
+    "If you are waiting on something (for example a background command or CI), do not end your turn: wait for it in the foreground, then run `chatroom handoff`.",
+    "If you cannot do either, reply with one line saying what you are waiting on."
+  ].join(`
+`);
+}
+
 // ../../services/backend/src/domain/entities/participant.ts
 var NATIVE_WAITING_ACTION = "native:waiting", NATIVE_TASK_INJECTED_ACTION = "native:task-injected", GET_NEXT_TASK_STARTED_ACTION = "get-next-task:started";
 
@@ -36324,16 +36347,6 @@ var init_parse_session_augmentation = __esm(() => {
   init_team_agent_settings();
 });
 
-// ../../services/backend/config/reliability.ts
-var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, NATIVE_DELIVERY_RECONCILE_MS = 1e4, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, MACHINE_COMMAND_LEASE_RENEWAL_INTERVAL_MS = 20000, MACHINE_COMMAND_DAEMON_ROUTINE_TTL_MS, SCOPE_TARGET_STOP_TIMEOUT_MS = 1e4, AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS = 120000, CONNECTION_CLOSE_REQUEST_TTL_MS, ENHANCER_TERMINAL_JOB_RETENTION_MS;
-var init_reliability = __esm(() => {
-  DAEMON_HEARTBEAT_INTERVAL_MS = 5 * 60000;
-  DAEMON_HEARTBEAT_TTL_MS = 6 * DAEMON_HEARTBEAT_INTERVAL_MS;
-  MACHINE_COMMAND_DAEMON_ROUTINE_TTL_MS = 5 * 60000;
-  CONNECTION_CLOSE_REQUEST_TTL_MS = 10 * 60000;
-  ENHANCER_TERMINAL_JOB_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
-});
-
 // src/daemon/services/task-service/service/native-cold-session-before-inject.ts
 function sleep3(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -36603,7 +36616,7 @@ function resumeHarnessWithPrompt(task, deps, prompt, harnessSessionId) {
         taskId,
         error: error51
       });
-      return;
+      return yield* exports_Effect.fail(resumeResult.failure);
     }
     yield* exports_Effect.tryPromise({
       try: () => deps.audit.emit({
@@ -36732,6 +36745,8 @@ class AgentWorkManager {
   nativeTaskDeliveryQueue;
   deliveryTaskService;
   recoveryGates = new Map;
+  respawnStartRetries = new Map;
+  respawnRestartSeq = 0;
   disposed = false;
   constructor(deps) {
     this.deps = deps;
@@ -36763,7 +36778,10 @@ class AgentWorkManager {
       releaseTaskAfterTurnFailure: deps.taskService.releaseTaskAfterTurnFailure,
       recordDeliveryFailure: deps.taskService.recordDeliveryFailure,
       clearDeliveryFailure: deps.taskService.clearDeliveryFailure,
-      recordUncoveredTurnEnd: deps.taskService.recordUncoveredTurnEnd,
+      recordTurnFailure: deps.taskService.recordTurnFailure,
+      decideUncoveredTurnEnd: deps.taskService.decideUncoveredTurnEnd,
+      confirmNudgeSent: deps.taskService.confirmNudgeSent,
+      resetTurnTracking: deps.taskService.resetTurnTracking,
       isRedeliveryExhausted: deps.taskService.isRedeliveryExhausted,
       clearRedeliveryTracking: deps.taskService.clearRedeliveryTracking,
       forgetStaleTask: deps.taskService.forgetStaleTask,
@@ -36789,6 +36807,7 @@ class AgentWorkManager {
     this.unsubscribeTaskService = deps.taskService.subscribe((notification) => this.handleTaskServiceNotification(notification));
   }
   async handleAgentStarted(event) {
+    this.cancelRespawnStart(recoveryKey(event.chatroomId, event.role), `agent_started:${event.reason ?? "unknown"}`);
     await this.waitForRoleRecovery(event.chatroomId, event.role);
     this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
     if (event.reason === "user.start") {
@@ -36906,9 +36925,9 @@ class AgentWorkManager {
       });
     }, delay3);
   }
-  async recoverTaskAfterUncoveredTurnEnd(event, activeTask, phase) {
+  async recoverTaskAfterTurnFailure(event, activeTask, phase) {
     const { chatroomId, role } = event;
-    const { exceeded } = await this.deps.taskService.recordUncoveredTurnEnd({
+    const { exceeded } = await this.deps.taskService.recordTurnFailure({
       chatroomId,
       role,
       taskId: activeTask.taskId
@@ -36937,7 +36956,7 @@ class AgentWorkManager {
       const errorDetail = completion.error;
       console.error(`[NativeDelivery:turn-failed] chatroom=${event.chatroomId} role=${event.role} task=${activeTask2?.taskId ?? "none"} turn=${completion.turnId} status=${completion.status} source=${completion.source} error=${errorDetail ?? "none"}`);
       if (activeTask2) {
-        const recovery = await this.recoverTaskAfterUncoveredTurnEnd(event, activeTask2, "turn-failed");
+        const recovery = await this.recoverTaskAfterTurnFailure(event, activeTask2, "turn-failed");
         if (recovery === "exceeded") {
           this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
           return { kind: "release-slot" };
@@ -36977,14 +36996,41 @@ class AgentWorkManager {
     });
     if (activeTask) {
       const handoff = await this.deps.taskService.getLatestHandoff(event.chatroomId, event.role);
-      if (!handoff?.taskIds.includes(activeTask.taskId)) {
-        const recovery = await this.recoverTaskAfterUncoveredTurnEnd(event, activeTask, "turn-ended");
-        if (recovery === "recovery-failed") {
-          return { kind: "hold-slot", reason: "task-recovery-failed" };
+      const covered = handoff?.taskIds.includes(activeTask.taskId) ?? false;
+      if (covered) {
+        this.deps.taskService.resetTurnTracking({
+          chatroomId: event.chatroomId,
+          role: event.role,
+          taskId: activeTask.taskId
+        });
+      } else {
+        const decision = await this.deps.taskService.decideUncoveredTurnEnd({
+          chatroomId: event.chatroomId,
+          role: event.role,
+          taskId: activeTask.taskId,
+          sessionKey: sessionKeyFor(event.pid, event.slot.harnessSessionId)
+        });
+        if (decision.action === "nudge") {
+          await this.enqueueTurnEndedWaitingFact(event);
+          this.scheduleUncoveredAction(event, activeTask, "nudge");
+          return { kind: "release-slot" };
+        }
+        if (decision.action === "restart-session") {
+          await this.enqueueTurnEndedWaitingFact(event);
+          this.scheduleUncoveredAction(event, activeTask, "restart-session");
+          return { kind: "release-slot" };
         }
+        await this.enqueueTurnEndedWaitingFact(event);
+        this.applyParkAction(event);
+        return { kind: "release-slot" };
       }
     }
     this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
+    await this.enqueueTurnEndedWaitingFact(event);
+    this.scheduleRoleDelivery(event.chatroomId, event.role);
+    return { kind: "release-slot" };
+  }
+  async enqueueTurnEndedWaitingFact(event) {
     try {
       await this.deps.lifecycleOutbox.enqueue(buildAgentStatusFact({
         chatroomId: event.chatroomId,
@@ -36994,8 +37040,244 @@ class AgentWorkManager {
     } catch (error51) {
       console.error(`[NativeDelivery:turn-ended-outbox-error] chatroom=${event.chatroomId} role=${event.role} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
     }
+  }
+  scheduleUncoveredAction(event, task, action, attempt = 0, delayMs = 0) {
+    setTimeout(() => {
+      if (this.disposed)
+        return;
+      const run = action === "nudge" ? this.sendUncoveredNudge(event, task, attempt) : this.restartSessionForUncoveredTask(event, task);
+      run.catch((error51) => {
+        console.error(`[NativeDelivery:uncovered-action-error] action=${action} chatroom=${event.chatroomId} role=${event.role} task=${task.taskId} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
+      });
+    }, delayMs);
+  }
+  async sendUncoveredNudge(event, task, attempt = 0) {
+    const { chatroomId, role } = event;
+    const sessionKey = sessionKeyFor(event.pid, event.slot.harnessSessionId);
+    const deliveryState = getRoleDeliveryState();
+    if (!deliveryState.tryAcquireDelivery(chatroomId, role)) {
+      console.log(`[NativeDelivery:uncovered-nudge-skipped] chatroom=${chatroomId} role=${role} task=${task.taskId} reason=delivery_busy`);
+      if (attempt + 1 < MAX_UNCOVERED_NUDGE_SEND_ATTEMPTS) {
+        this.scheduleUncoveredAction(event, task, "nudge", attempt + 1, UNCOVERED_NUDGE_RETRY_MS);
+        return;
+      }
+      await this.escalateUndeliverableNudge(event, task, sessionKey);
+      return;
+    }
+    const generation = deliveryState.getGeneration(chatroomId, role);
+    try {
+      const skipReason = this.uncoveredNudgeSkipReason(event, task);
+      if (skipReason) {
+        console.log(`[NativeDelivery:uncovered-nudge-skipped] chatroom=${chatroomId} role=${role} task=${task.taskId} reason=${skipReason}`);
+        return;
+      }
+      try {
+        await exports_Effect.runPromise(this.deps.agentMgr.resumeTurnForSlot({
+          chatroomId,
+          role,
+          prompt: buildUncoveredTurnNudgePrompt({ taskId: task.taskId })
+        }));
+      } catch (error51) {
+        console.error(`[NativeDelivery:uncovered-nudge] chatroom=${chatroomId} role=${role} task=${task.taskId} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
+        await this.escalateUndeliverableNudge(event, task, sessionKey);
+        return;
+      }
+      this.deps.taskService.confirmNudgeSent({ chatroomId, role, taskId: task.taskId, sessionKey });
+    } finally {
+      deliveryState.releaseDelivery(chatroomId, role, generation);
+    }
+  }
+  async escalateUndeliverableNudge(event, task, sessionKey) {
+    const decision = await this.deps.taskService.decideUncoveredTurnEnd({
+      chatroomId: event.chatroomId,
+      role: event.role,
+      taskId: task.taskId,
+      sessionKey,
+      nudgeUnavailable: true
+    });
+    if (decision.action === "restart-session") {
+      this.scheduleUncoveredAction(event, task, "restart-session");
+    } else {
+      this.applyParkAction(event);
+    }
+  }
+  async restartSessionForUncoveredTask(event, task) {
+    const { chatroomId, role, pid } = event;
+    const config3 = this.deps.configurationService.get(chatroomId, role);
+    const slot = this.deps.agentMgr.getSlot(chatroomId, role);
+    const harness = config3?.agentHarness ?? slot?.harness;
+    const model = config3?.model ?? slot?.model;
+    const workingDir = config3?.workingDir ?? slot?.workingDir;
+    if (!harness || !model || !workingDir) {
+      console.error(`[NativeDelivery:uncovered-restart-failed] chatroom=${chatroomId} role=${role} task=${task.taskId} error=missing_agent_config`);
+      const sessionKey = sessionKeyFor(event.pid, event.slot.harnessSessionId);
+      await this.deps.taskService.decideUncoveredTurnEnd({
+        chatroomId,
+        role,
+        taskId: task.taskId,
+        sessionKey,
+        nudgeUnavailable: true
+      });
+      this.applyParkAction(event);
+      return;
+    }
+    const startInput = {
+      chatroomId,
+      role,
+      agentHarness: harness,
+      model,
+      workingDir,
+      reason: DaemonStartReasonCode.RESPAWN,
+      wantResume: false
+    };
+    let outcome;
+    try {
+      outcome = await this.deps.runSerializedForAgent({ chatroomId, role, workingDir }, { timeoutMs: AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS }, async (ops, context3) => {
+        const current = this.deps.agentMgr.getSlot(chatroomId, role);
+        if (this.deps.agentMgr.isStopRequested(chatroomId, role) || current?.pid !== pid || current?.harnessSessionId !== event.slot.harnessSessionId) {
+          console.log(`[NativeDelivery:uncovered-restart-stale] chatroom=${chatroomId} role=${role} task=${task.taskId}`);
+          return { kind: "skipped", reason: "stale_slot" };
+        }
+        await this.prepareRoleRecovery({ chatroomId, role });
+        await ops.stopAgent({ chatroomId, role, reason: AgentStopReasonEnum["daemon.respawn"], pid, workingDir }, context3.signal);
+        await this.recoverStoppedRole({ chatroomId, role, mode: "automatic" });
+        return this.attemptRespawnStart(ops, startInput, context3.signal);
+      });
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      console.error(`[NativeDelivery:uncovered-restart-failed] chatroom=${chatroomId} role=${role} task=${task.taskId} error=${message}`);
+      if (this.recoveryGates.has(recoveryKey(chatroomId, role))) {
+        this.scheduleRecoveryRetry(chatroomId, role);
+      }
+      return;
+    }
+    if (outcome.kind === "start-failed") {
+      console.error(`[NativeDelivery:uncovered-restart-failed] chatroom=${chatroomId} role=${role} task=${task.taskId} attempt=1 of ${MAX_RESPAWN_START_ATTEMPTS} error=${outcome.error}`);
+      this.beginRespawnStartRetries({ chatroomId, role, workingDir, startInput });
+    }
+  }
+  async attemptRespawnStart(ops, startInput, signal) {
+    try {
+      const started = await ops.startAgent(startInput, signal);
+      return started.success ? { kind: "started" } : { kind: "start-failed", error: started.error ?? "start_rejected" };
+    } catch (error51) {
+      return {
+        kind: "start-failed",
+        error: error51 instanceof Error ? error51.message : String(error51)
+      };
+    }
+  }
+  beginRespawnStartRetries(request3) {
+    if (this.disposed)
+      return;
+    const key = recoveryKey(request3.chatroomId, request3.role);
+    this.cancelRespawnStart(key, "superseded_by_new_restart");
+    this.respawnRestartSeq += 1;
+    const pending = {
+      restartId: this.respawnRestartSeq,
+      request: request3,
+      attempts: 1
+    };
+    this.respawnStartRetries.set(key, pending);
+    this.armRespawnStartRetry(key, pending);
+  }
+  armRespawnStartRetry(key, pending) {
+    if (this.disposed)
+      return;
+    const delay3 = Math.min(30000, 1000 * 2 ** (pending.attempts - 1));
+    pending.timer = setTimeout(() => {
+      pending.timer = undefined;
+      this.retryRespawnStart(key, pending.restartId).catch((error51) => {
+        console.error(`[NativeDelivery:uncovered-restart-error] chatroom=${pending.request.chatroomId} role=${pending.request.role} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
+      });
+    }, delay3);
+  }
+  async retryRespawnStart(key, restartId) {
+    const pending = this.respawnStartRetries.get(key);
+    if (!pending || pending.restartId !== restartId || this.disposed)
+      return;
+    const { chatroomId, role, workingDir, startInput } = pending.request;
+    if (this.deps.agentMgr.isStopRequested(chatroomId, role)) {
+      this.cancelRespawnStart(key, "stop_requested");
+      return;
+    }
+    const slot = this.deps.agentMgr.getSlot(chatroomId, role);
+    if (slot && isSlotRunning(slot.state)) {
+      this.cancelRespawnStart(key, "agent_already_running");
+      return;
+    }
+    const outcome = await this.deps.runSerializedForAgent({ chatroomId, role, workingDir }, { timeoutMs: AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS }, async (ops, context3) => {
+      if (this.respawnStartRetries.get(key)?.restartId !== restartId) {
+        return { kind: "skipped", reason: "superseded" };
+      }
+      if (this.deps.agentMgr.isStopRequested(chatroomId, role)) {
+        return { kind: "skipped", reason: "stop_requested" };
+      }
+      const current2 = this.deps.agentMgr.getSlot(chatroomId, role);
+      if (current2 && isSlotRunning(current2.state)) {
+        return { kind: "skipped", reason: "agent_already_running" };
+      }
+      return this.attemptRespawnStart(ops, startInput, context3.signal);
+    });
+    if (outcome.kind === "skipped") {
+      this.cancelRespawnStart(key, outcome.reason);
+      return;
+    }
+    const current = this.respawnStartRetries.get(key);
+    if (current?.restartId !== restartId)
+      return;
+    if (outcome.kind === "started") {
+      this.cancelRespawnStart(key, "started");
+      return;
+    }
+    current.attempts += 1;
+    if (current.attempts >= MAX_RESPAWN_START_ATTEMPTS) {
+      this.respawnStartRetries.delete(key);
+      console.error(`[NativeDelivery:uncovered-restart-failed] attempts exhausted chatroom=${chatroomId} role=${role} attempts=${current.attempts} error=${outcome.error}`);
+      return;
+    }
+    console.error(`[NativeDelivery:uncovered-restart-failed] chatroom=${chatroomId} role=${role} attempt=${current.attempts} of ${MAX_RESPAWN_START_ATTEMPTS} error=${outcome.error}`);
+    this.armRespawnStartRetry(key, current);
+  }
+  cancelRespawnStart(key, reason) {
+    const pending = this.respawnStartRetries.get(key);
+    if (!pending)
+      return;
+    if (pending.timer)
+      clearTimeout(pending.timer);
+    pending.timer = undefined;
+    this.respawnStartRetries.delete(key);
+    if (reason === "started")
+      return;
+    console.log(`[NativeDelivery:uncovered-restart-cancelled] chatroom=${pending.request.chatroomId} role=${pending.request.role} attempts=${pending.attempts} reason=${reason}`);
+  }
+  uncoveredNudgeSkipReason(event, task) {
+    const { chatroomId, role } = event;
+    const slot = this.deps.agentMgr.getSlot(chatroomId, role);
+    if (!slot || !isSlotRunning(slot.state))
+      return "slot_not_running";
+    if (slot.pid !== event.pid)
+      return "pid_changed";
+    if (slot.harnessSessionId !== event.slot.harnessSessionId)
+      return "session_changed";
+    if (!isTurnPhaseIdle(slot.nativeTurnPhase ?? "idle"))
+      return "turn_not_idle";
+    if (this.deps.agentMgr.isStopRequested(chatroomId, role))
+      return "stop_requested";
+    if (this.recoveryGates.has(recoveryKey(chatroomId, role)))
+      return "recovery_in_progress";
+    if (this.deps.agentTaskState.get({ chatroomId, role })?.taskId !== task.taskId) {
+      return "task_not_active";
+    }
+    const current = this.deps.taskInboxState.getForRole(chatroomId, role, task.taskId);
+    if (!current || !ACTIVE_TASK_STATUSES.includes(current.status)) {
+      return "task_not_in_inbox";
+    }
+    return;
+  }
+  applyParkAction(event) {
+    this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
     this.scheduleRoleDelivery(event.chatroomId, event.role);
-    return { kind: "release-slot" };
   }
   scheduleRoleDelivery(chatroomId, role) {
     setTimeout(() => {
@@ -37006,6 +37288,12 @@ class AgentWorkManager {
   }
   dispose() {
     this.disposed = true;
+    for (const pending of this.respawnStartRetries.values()) {
+      if (pending.timer)
+        clearTimeout(pending.timer);
+      pending.timer = undefined;
+    }
+    this.respawnStartRetries.clear();
     for (const gate of this.recoveryGates.values()) {
       if (gate.retryTimer)
         clearTimeout(gate.retryTimer);
@@ -37217,13 +37505,16 @@ class AgentWorkManager {
     this.deps.agentTaskState.start(args2);
   }
 }
-var recoveryKey = (chatroomId, role) => `${chatroomId}:${role.toLowerCase()}`;
+var MAX_RESPAWN_START_ATTEMPTS = 3, MAX_UNCOVERED_NUDGE_SEND_ATTEMPTS = 3, UNCOVERED_NUDGE_RETRY_MS = 250, recoveryKey = (chatroomId, role) => `${chatroomId}:${role.toLowerCase()}`, sessionKeyFor = (pid, harnessSessionId) => `${pid}:${harnessSessionId ?? "none"}`;
 var init_agent_work_manager = __esm(() => {
+  init_reliability();
   init_agent();
   init_chatroom_workspace_task_inbox();
   init_dist();
   init_agent_lifecycle_fact();
   init_agent_slot();
+  init_assigned_task();
+  init_check_agent_slot();
   init_native_task_injector_logic();
   init_convex_native_task_delivery_gateway();
   init_daemon_audit_port();
@@ -40322,6 +40613,27 @@ class TaskInboxState {
   }
 }
 
+// src/daemon/services/task-service/domain/usecase/uncovered-turn-ladder.ts
+function decideUncoveredTurnEnd(entry, sessionKey, opts = {}) {
+  const current = entry ?? FRESH_ENTRY;
+  if (isNudgeDue(current, sessionKey, opts))
+    return { action: "nudge" };
+  return current.sessionRestarts < MAX_SESSION_RESTARTS_PER_TASK ? { action: "restart-session" } : { action: "park" };
+}
+function isNudgeDue(entry, sessionKey, opts) {
+  return !opts.nudgeUnavailable && entry.nudgedSessionKey !== sessionKey;
+}
+function withNudgeSent(entry, sessionKey) {
+  return { nudgedSessionKey: sessionKey, sessionRestarts: entry?.sessionRestarts ?? 0 };
+}
+function withSessionRestart(entry) {
+  return { nudgedSessionKey: undefined, sessionRestarts: (entry?.sessionRestarts ?? 0) + 1 };
+}
+var MAX_SESSION_RESTARTS_PER_TASK = 1, FRESH_ENTRY;
+var init_uncovered_turn_ladder = __esm(() => {
+  FRESH_ENTRY = { sessionRestarts: 0 };
+});
+
 // src/daemon/services/task-service/service/task-service.ts
 function createTaskService(deps) {
   const gateway = createConvexNativeTaskDeliveryGateway(deps.backend);
@@ -40339,18 +40651,13 @@ function createTaskService(deps) {
   let bootstrapRecoveryAttempts = 0;
   let bootstrapRecoveryTimer;
   let bootstrapRecoveryPromise;
-  const REDIVERY_ATTEMPT_CAP = 3;
-  const turnEndAttemptCounts = new Map;
+  const TURN_FAILURE_RETRY_CAP = 3;
+  const turnFailureCounts = new Map;
+  const uncoveredLadder = new Map;
   const redeliveryExhaustedKeys = new Set;
   const redeliveryKey = (chatroomId, role, taskId) => `${chatroomId}:${role.toLowerCase()}:${taskId}`;
-  const recordUncoveredTurnEnd = async (args2) => {
+  const parkTask = async (args2, attempts) => {
     const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
-    if (redeliveryExhaustedKeys.has(key))
-      return { exceeded: true };
-    const attempts = (turnEndAttemptCounts.get(key) ?? 0) + 1;
-    turnEndAttemptCounts.set(key, attempts);
-    if (attempts < REDIVERY_ATTEMPT_CAP)
-      return { exceeded: false };
     redeliveryExhaustedKeys.add(key);
     try {
       await gateway.recordDeliveryFailure({
@@ -40362,13 +40669,50 @@ function createTaskService(deps) {
     } catch (error51) {
       console.warn(`[TaskService] redelivery-exhausted failure record failed chatroom=${args2.chatroomId} role=${args2.role} task=${args2.taskId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
     }
-    console.log(`[NativeDelivery:redelivery-exhausted] chatroom=${args2.chatroomId} role=${args2.role} task=${args2.taskId} attempts=${attempts} — release/redelivery stopped; agent restart (user.start) resets`);
+    const attemptsSuffix = attempts === undefined ? "" : ` attempts=${attempts}`;
+    console.log(`[NativeDelivery:redelivery-exhausted] chatroom=${args2.chatroomId} role=${args2.role} task=${args2.taskId}${attemptsSuffix} — release/redelivery stopped; agent restart (user.start) resets`);
+  };
+  const recordTurnFailure = async (args2) => {
+    const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
+    if (redeliveryExhaustedKeys.has(key))
+      return { exceeded: true };
+    const attempts = (turnFailureCounts.get(key) ?? 0) + 1;
+    turnFailureCounts.set(key, attempts);
+    if (attempts < TURN_FAILURE_RETRY_CAP)
+      return { exceeded: false };
+    await parkTask(args2, attempts);
     return { exceeded: true };
   };
+  const decideUncoveredTurnEnd2 = async (args2) => {
+    const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
+    if (redeliveryExhaustedKeys.has(key))
+      return { action: "park" };
+    turnFailureCounts.delete(key);
+    const entry = uncoveredLadder.get(key);
+    const decision = decideUncoveredTurnEnd(entry, args2.sessionKey, {
+      nudgeUnavailable: args2.nudgeUnavailable ?? false
+    });
+    if (decision.action === "restart-session") {
+      uncoveredLadder.set(key, withSessionRestart(entry));
+    } else if (decision.action === "park") {
+      await parkTask(args2);
+    }
+    return decision;
+  };
+  const confirmNudgeSent = (args2) => {
+    const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
+    uncoveredLadder.set(key, withNudgeSent(uncoveredLadder.get(key), args2.sessionKey));
+  };
+  const resetTurnTracking = (args2) => {
+    const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
+    turnFailureCounts.delete(key);
+    uncoveredLadder.delete(key);
+  };
   const isRedeliveryExhausted = (args2) => redeliveryExhaustedKeys.has(redeliveryKey(args2.chatroomId, args2.role, args2.taskId));
   const clearRedeliveryTrackingForTask = (chatroomId, role, taskId) => {
     const key = redeliveryKey(chatroomId, role, taskId);
-    turnEndAttemptCounts.delete(key);
+    turnFailureCounts.delete(key);
+    uncoveredLadder.delete(key);
     redeliveryExhaustedKeys.delete(key);
   };
   const forgetStaleTask = ({
@@ -40398,9 +40742,13 @@ function createTaskService(deps) {
   };
   const clearRoleRedeliveryTracking = (chatroomId, role) => {
     const prefix = `${chatroomId}:${role.toLowerCase()}:`;
-    for (const key of [...turnEndAttemptCounts.keys()]) {
+    for (const key of [...turnFailureCounts.keys()]) {
+      if (key.startsWith(prefix))
+        turnFailureCounts.delete(key);
+    }
+    for (const key of [...uncoveredLadder.keys()]) {
       if (key.startsWith(prefix))
-        turnEndAttemptCounts.delete(key);
+        uncoveredLadder.delete(key);
     }
     for (const key of [...redeliveryExhaustedKeys]) {
       if (key.startsWith(prefix))
@@ -40802,7 +41150,10 @@ function createTaskService(deps) {
       taskId,
       ...expectedReason ? { expectedReason } : {}
     }),
-    recordUncoveredTurnEnd,
+    recordTurnFailure,
+    decideUncoveredTurnEnd: decideUncoveredTurnEnd2,
+    confirmNudgeSent,
+    resetTurnTracking,
     isRedeliveryExhausted,
     clearRedeliveryTracking: ({ chatroomId, role }) => {
       clearRoleRedeliveryTracking(chatroomId, role);
@@ -40817,6 +41168,7 @@ var init_task_service = __esm(() => {
   init_task_inbox_acknowledgement_retry_watcher();
   init_task_inbox_delivery_retry_watcher();
   init_api3();
+  init_uncovered_turn_ladder();
   init_convex_native_task_delivery_gateway();
 });
 
@@ -137918,4 +138270,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=FEC6884486B357A364756E2164756E21
+//# debugId=7C84BEF97B16C1D064756E2164756E21