chatroom-cli 1.127.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))
-        turnEndAttemptCounts.delete(key);
+        turnFailureCounts.delete(key);
+    }
+    for (const key of [...uncoveredLadder.keys()]) {
+      if (key.startsWith(prefix))
+        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();
 });
 
@@ -48728,6 +49080,14 @@ var init_pi_sdk_package = __esm(() => {
   };
 });
 
+// src/daemon/infrastructure/local/harness/services/pi-sdk/assistant-error.ts
+function assistantErrorOf(event) {
+  if (event.message.role !== "assistant" || event.message.stopReason !== "error")
+    return;
+  return event.message.errorMessage ?? UNKNOWN_PROVIDER_ERROR;
+}
+var UNKNOWN_PROVIDER_ERROR = "unknown provider error";
+
 // src/daemon/infrastructure/local/harness/services/pi-sdk/pi-sdk-stream-adapter.ts
 var PiSdkStreamAdapter;
 var init_pi_sdk_stream_adapter = __esm(() => {
@@ -48735,6 +49095,7 @@ var init_pi_sdk_stream_adapter = __esm(() => {
   PiSdkStreamAdapter = class PiSdkStreamAdapter extends NativeStreamAdapterBase {
     textBuffer = "";
     thinkingBuffer = "";
+    lastAssistantError;
     constructor(logPrefix, emitLogLine, activityEmitter) {
       super(logPrefix, emitLogLine, activityEmitter);
     }
@@ -48774,17 +49135,43 @@ var init_pi_sdk_stream_adapter = __esm(() => {
           this.writeLine(formatAgentLogLine(this.logPrefix, "tool_result", `${event.toolName} result: ${resultStr}`));
           break;
         }
+        case "message_end":
+          this.recordAssistantOutcome(event);
+          break;
         case "agent_end":
-          this.completeTurn({ status: "completed", source: "pi-sdk.agent_end" });
+          if (event.willRetry)
+            break;
+          this.settleRun("pi-sdk.agent_end");
           break;
         default:
           break;
       }
     }
+    recordAssistantOutcome(event) {
+      const message = event.message;
+      if (message.role !== "assistant")
+        return;
+      this.lastAssistantError = assistantErrorOf(event);
+      if (this.lastAssistantError === undefined)
+        return;
+      this.writeLine(formatAgentLogLine(this.logPrefix, "run-error", `assistant error: ${this.lastAssistantError}`));
+    }
+    settleResolvedPrompt() {
+      this.settleRun("pi-sdk.prompt.resolved");
+    }
     finish() {
       this.flushText();
       this.flushThinking();
     }
+    settleRun(source) {
+      if (this.lastAssistantError !== undefined) {
+        const error51 = this.lastAssistantError;
+        if (this.completeTurn({ status: "failed", source, error: error51 }))
+          this.notifyFailure(source);
+      } else {
+        this.completeTurn({ status: "completed", source });
+      }
+    }
     appendText(delta) {
       this.flushThinking();
       this.textBuffer += delta;
@@ -48876,9 +49263,13 @@ function waitForResumeOrAbort4(session2) {
     })
   ]);
 }
-function resolveRequiredModel(modelRegistry, model) {
+async function createModelRuntime() {
+  const sdk = await loadSdk4();
+  return sdk.ModelRuntime.create();
+}
+function resolveRequiredModel(modelRuntime, model) {
   const slash = model.indexOf("/");
-  const resolved = slash === -1 ? modelRegistry.getAll().find((entry) => entry.id === model) : modelRegistry.find(model.slice(0, slash), model.slice(slash + 1));
+  const resolved = slash === -1 ? modelRuntime.getModels().find((entry) => entry.id === model) : modelRuntime.getModel(model.slice(0, slash), model.slice(slash + 1));
   if (!resolved) {
     throw new Error(`Pi model not found: ${model}`);
   }
@@ -48912,10 +49303,8 @@ var init_pi_sdk_agent_service = __esm(() => {
     }
     async isInstalled() {
       try {
-        const { ModelRegistry, AuthStorage } = await loadSdk4();
-        const authStorage = AuthStorage.create();
-        const modelRegistry = ModelRegistry.create(authStorage);
-        return modelRegistry.getAvailable().length > 0;
+        const modelRuntime = await createModelRuntime();
+        return (await modelRuntime.getAvailable()).length > 0;
       } catch (err) {
         console.warn(`[pi-sdk] unavailable: ${formatPiSdkLoadError(err)}`);
         return false;
@@ -48938,26 +49327,16 @@ var init_pi_sdk_agent_service = __esm(() => {
     }
     async listModels() {
       try {
-        const { ModelRegistry, AuthStorage } = await loadSdk4();
-        const authStorage = AuthStorage.create();
-        const modelRegistry = ModelRegistry.create(authStorage);
-        return modelRegistry.getAvailable().map((entry) => `${entry.provider}/${entry.id}`);
+        const modelRuntime = await createModelRuntime();
+        return (await modelRuntime.getAvailable()).map((entry) => `${entry.provider}/${entry.id}`);
       } catch (err) {
         console.warn(`[pi-sdk] listModels failed:`, err instanceof Error ? err.message : err);
         return [];
       }
     }
     async openResumedSession(args2) {
-      const {
-        AuthStorage,
-        createAgentSession,
-        DefaultResourceLoader,
-        getAgentDir,
-        ModelRegistry,
-        SessionManager
-      } = await loadSdk4();
-      const authStorage = AuthStorage.create();
-      const modelRegistry = ModelRegistry.create(authStorage);
+      const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk4();
+      const modelRuntime = await createModelRuntime();
       const sessions = await SessionManager.list(args2.workingDir, getPiSessionDir(args2.workingDir));
       const match5 = sessions.find((s) => s.id === args2.harnessSessionId);
       if (!match5) {
@@ -48972,8 +49351,7 @@ var init_pi_sdk_agent_service = __esm(() => {
       const { session: session2 } = await withTimeout(createAgentSession({
         cwd: args2.workingDir,
         sessionManager: SessionManager.open(match5.path, getPiSessionDir(args2.workingDir)),
-        authStorage,
-        modelRegistry,
+        modelRuntime,
         resourceLoader
       }), SESSION_CREATE_TIMEOUT_MS2, "createAgentSession");
       return session2;
@@ -49027,19 +49405,11 @@ var init_pi_sdk_agent_service = __esm(() => {
       return keeper;
     }
     async createSession(args2) {
-      const {
-        AuthStorage,
-        createAgentSession,
-        DefaultResourceLoader,
-        getAgentDir,
-        ModelRegistry,
-        SessionManager
-      } = await loadSdk4();
-      const authStorage = AuthStorage.create();
-      const modelRegistry = ModelRegistry.create(authStorage);
+      const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk4();
+      const modelRuntime = await createModelRuntime();
       const model = requireHarnessModel(args2.model, "pi-sdk spawn");
       const parsed = parsePiSpawnModel(model);
-      const resolvedModel = resolveRequiredModel(modelRegistry, parsed.model ?? model);
+      const resolvedModel = resolveRequiredModel(modelRuntime, parsed.model ?? model);
       const thinkingLevel = resolvePiThinkingLevel(parsed?.thinking);
       const agentDir = getAgentDir();
       const resourceLoader = new DefaultResourceLoader({
@@ -49053,8 +49423,7 @@ var init_pi_sdk_agent_service = __esm(() => {
         model: resolvedModel,
         ...thinkingLevel ? { thinkingLevel } : {},
         sessionManager: SessionManager.create(getPiSessionDir(args2.workingDir)),
-        authStorage,
-        modelRegistry,
+        modelRuntime,
         resourceLoader
       }), SESSION_CREATE_TIMEOUT_MS2, "createAgentSession");
       return session2;
@@ -49201,9 +49570,7 @@ ${deferredResume}` : deferredResume;
                 exitSignal = "SIGTERM";
                 break;
               }
-              if (!adapter.turnCompletion.isComplete) {
-                adapter.completeTurn({ status: "completed", source: "pi-sdk.prompt.resolved" });
-              }
+              adapter.settleResolvedPrompt();
               adapter.finish();
               nextPrompt = null;
             } catch (turnErr) {
@@ -122973,6 +123340,7 @@ class PiSdkSession {
   listeners = new Set;
   closed = false;
   unsubscribe;
+  lastAssistantError;
   constructor(options) {
     this.session = options.session;
     this.opencodeSessionId = options.opencodeSessionId;
@@ -122988,14 +123356,21 @@ class PiSdkSession {
     const text = input.parts.map((p) => p.text).join(`
 `);
     const messageId = randomUUID14();
+    this.lastAssistantError = undefined;
     const onSessionEvent = (event) => {
       if (this.closed)
         return;
+      if (event.type === "message_end" && event.message.role === "assistant") {
+        this.lastAssistantError = assistantErrorOf(event);
+      }
       this.emitFromPiEvent(event, messageId);
     };
     this.unsubscribe?.();
     this.unsubscribe = this.session.subscribe(onSessionEvent);
     await withTimeout(this.session.prompt(text), PROMPT_TIMEOUT_MS3, "session.prompt");
+    if (this.lastAssistantError !== undefined) {
+      throw new Error(this.lastAssistantError);
+    }
     this.emit({ type: "session.idle", payload: {}, timestamp: Date.now() });
   }
   onEvent(listener) {
@@ -123060,9 +123435,9 @@ async function loadSdk7() {
     throw err;
   }
 }
-function resolveRequiredModel2(modelRegistry, model) {
+function resolveRequiredModel2(modelRuntime, model) {
   const slash = model.indexOf("/");
-  const resolved = slash === -1 ? modelRegistry.getAll().find((entry) => entry.id === model) : modelRegistry.find(model.slice(0, slash), model.slice(slash + 1));
+  const resolved = slash === -1 ? modelRuntime.getModels().find((entry) => entry.id === model) : modelRuntime.getModel(model.slice(0, slash), model.slice(slash + 1));
   if (!resolved) {
     throw new Error(`Pi model not found: ${model}`);
   }
@@ -123075,15 +123450,13 @@ class PiSdkHarness {
   cwd;
   closed = false;
   sessions = new Map;
-  modelRegistry;
-  authStorage;
-  constructor(cwd, modelRegistry, authStorage) {
+  modelRuntime;
+  constructor(cwd, modelRuntime) {
     this.cwd = cwd;
-    this.modelRegistry = modelRegistry;
-    this.authStorage = authStorage;
+    this.modelRuntime = modelRuntime;
   }
   async models() {
-    return this.modelRegistry.getAvailable().map((entry) => ({
+    return (await this.modelRuntime.getAvailable()).map((entry) => ({
       id: `${entry.provider}/${entry.id}`,
       name: entry.id,
       provider: entry.provider
@@ -123094,7 +123467,7 @@ class PiSdkHarness {
   }
   async listProviders() {
     const byProvider = new Map;
-    for (const entry of this.modelRegistry.getAvailable()) {
+    for (const entry of await this.modelRuntime.getAvailable()) {
       const models = byProvider.get(entry.provider) ?? [];
       models.push({ modelID: entry.id, name: entry.id });
       byProvider.set(entry.provider, models);
@@ -123170,7 +123543,7 @@ class PiSdkHarness {
     const { createAgentSession, DefaultResourceLoader, getAgentDir } = await loadSdk7();
     const parsed = args2.model ? parsePiSpawnModel(args2.model) : undefined;
     const modelSlug = parsed?.model ?? args2.model;
-    const resolvedModel = args2.requireModel ? resolveRequiredModel2(this.modelRegistry, requireHarnessModel(modelSlug, "pi-sdk openAgentSession")) : modelSlug ? resolveRequiredModel2(this.modelRegistry, modelSlug) : undefined;
+    const resolvedModel = args2.requireModel ? resolveRequiredModel2(this.modelRuntime, requireHarnessModel(modelSlug, "pi-sdk openAgentSession")) : modelSlug ? resolveRequiredModel2(this.modelRuntime, modelSlug) : undefined;
     const thinkingLevel = resolvePiThinkingLevel(parsed?.thinking);
     if (args2.requireModel && !resolvedModel) {
       throw new Error("No Pi model available — configure provider credentials in ~/.pi/agent/auth.json");
@@ -123184,8 +123557,7 @@ class PiSdkHarness {
     const { session: session2 } = await withTimeout(createAgentSession({
       cwd: this.cwd,
       sessionManager: args2.sessionManager,
-      authStorage: this.authStorage,
-      modelRegistry: this.modelRegistry,
+      modelRuntime: this.modelRuntime,
       resourceLoader,
       ...resolvedModel ? { model: resolvedModel } : {},
       ...thinkingLevel ? { thinkingLevel } : {}
@@ -123195,13 +123567,12 @@ class PiSdkHarness {
 }
 var SESSION_CREATE_TIMEOUT_MS3 = 60000, _sdkCache7, _sdkLoadError7, startPiSdkHarness = async (config4) => {
   try {
-    const { AuthStorage, ModelRegistry } = await loadSdk7();
-    const authStorage = AuthStorage.create();
-    const modelRegistry = ModelRegistry.create(authStorage);
-    if (modelRegistry.getAvailable().length === 0) {
+    const sdk = await loadSdk7();
+    const modelRuntime = await sdk.ModelRuntime.create();
+    if ((await modelRuntime.getAvailable()).length === 0) {
       throw new Error("No Pi models available");
     }
-    return new PiSdkHarness(config4.workingDir, modelRegistry, authStorage);
+    return new PiSdkHarness(config4.workingDir, modelRuntime);
   } catch (err) {
     throw new Error(`pi-sdk unavailable: ${formatPiSdkLoadError(err)}`);
   }
@@ -137899,4 +138270,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=E3A1D1E6D6D8AB0C64756E2164756E21
+//# debugId=7C84BEF97B16C1D064756E2164756E21