chatroom-cli 1.132.0 → 1.133.0

package/dist/index.js

@@ -20412,6 +20412,14 @@ var init_agent_role = __esm(() => {
         { teamId: "duo", order: 45 },
         { teamId: "solo", order: 45 }
       ]
+    },
+    reviewer: {
+      tags: ["ephemeral" /* Ephemeral */],
+      teams: [{ teamId: "duo", order: 35 }]
+    },
+    "game-asset-designer": {
+      tags: ["ephemeral" /* Ephemeral */],
+      teams: [{ teamId: "duo", order: 42 }]
     }
   };
   AGENT_ROLE_DEFINITIONS = Object.fromEntries(Object.entries(roleMetadata).map(([role, metadata]) => [role, { role, ...metadata }]));
@@ -35270,6 +35278,25 @@ var init_assigned_task = __esm(() => {
   ACTIVE_TASK_STATUSES = ["pending", "acknowledged", "in_progress"];
 });
 
+// src/daemon/domain/usecase/compute-backoff-delay.ts
+function computeBackoffDelay(attempt, opts, random3 = Math.random) {
+  const exp = Math.min(opts.maxMs, opts.baseMs * 2 ** (attempt - 1));
+  const jitterRatio = opts.jitter ?? 0;
+  if (jitterRatio <= 0)
+    return Math.max(0, Math.round(exp));
+  const jitter = exp * jitterRatio * (random3() * 2 - 1);
+  return Math.max(0, Math.round(exp + jitter));
+}
+var REDELIVERY_BACKOFF_BASE_MS = 5000, REDELIVERY_BACKOFF_MAX_MS, REDELIVERY_BACKOFF_OPTIONS;
+var init_compute_backoff_delay = __esm(() => {
+  REDELIVERY_BACKOFF_MAX_MS = 5 * 60000;
+  REDELIVERY_BACKOFF_OPTIONS = {
+    baseMs: REDELIVERY_BACKOFF_BASE_MS,
+    maxMs: REDELIVERY_BACKOFF_MAX_MS,
+    jitter: 0.2
+  };
+});
+
 // src/daemon/infrastructure/local/harness/services/spawn-prompt.ts
 function createSpawnPrompt(raw, opts) {
   if (opts?.nativeBootstrap) {
@@ -36877,6 +36904,26 @@ var init_native_task_injector = __esm(() => {
   };
 });
 
+// src/daemon/services/agent-process-service/domain/usecase/is-cli-driven-harness.ts
+function isCliDrivenHarness(harness) {
+  if (harness == null)
+    return false;
+  const capabilities = getHarnessCapabilities(harness);
+  return capabilities?.runtimeKind === "cli";
+}
+var init_is_cli_driven_harness = __esm(() => {
+  init_types();
+});
+
+// src/daemon/services/agent-process-service/domain/usecase/restart-retry-interval.ts
+function restartRetryMaxIntervalMs(cliDriven) {
+  return cliDriven ? CLI_RESTART_RETRY_MAX_INTERVAL_MS : AGENT_RESTART_RETRY_MAX_INTERVAL_MS;
+}
+var AGENT_RESTART_RETRY_MAX_INTERVAL_MS, CLI_RESTART_RETRY_MAX_INTERVAL_MS = 30000;
+var init_restart_retry_interval = __esm(() => {
+  AGENT_RESTART_RETRY_MAX_INTERVAL_MS = 10 * 60000;
+});
+
 // src/daemon/services/agent-process-service/service/agent-work-manager.ts
 class AgentWorkManager {
   deps;
@@ -36891,6 +36938,8 @@ class AgentWorkManager {
   recoveryGates = new Map;
   respawnStartRetries = new Map;
   respawnRestartSeq = 0;
+  turnFailureAccountingFailures = new Map;
+  turnFailureReleaseTimers = new Map;
   disposed = false;
   constructor(deps) {
     this.deps = deps;
@@ -36923,11 +36972,14 @@ class AgentWorkManager {
       recordDeliveryFailure: deps.taskService.recordDeliveryFailure,
       clearDeliveryFailure: deps.taskService.clearDeliveryFailure,
       recordTurnFailure: deps.taskService.recordTurnFailure,
+      parkTurnFailure: deps.taskService.parkTurnFailure,
       decideUncoveredTurnEnd: deps.taskService.decideUncoveredTurnEnd,
       confirmNudgeSent: deps.taskService.confirmNudgeSent,
       resetTurnTracking: deps.taskService.resetTurnTracking,
       isRedeliveryExhausted: deps.taskService.isRedeliveryExhausted,
       clearRedeliveryTracking: deps.taskService.clearRedeliveryTracking,
+      markTurnFailureReleasePending: deps.taskService.markTurnFailureReleasePending,
+      clearTurnFailureReleasePending: deps.taskService.clearTurnFailureReleasePending,
       forgetStaleTask: deps.taskService.forgetStaleTask,
       loadAssignedTaskForAction: deps.taskService.loadAssignedTaskForAction,
       deliverNativeTask: (task, harnessSessionId, onTaskDelivered, isCurrent) => this.nativeTaskDeliveryQueue.enqueue({
@@ -36960,6 +37012,9 @@ class AgentWorkManager {
         role: event.role
       });
     }
+    if (event.reason === "user.start" || event.reason === "user.restart") {
+      this.cancelTurnFailureReleasesForRole(event.chatroomId, event.role);
+    }
     await this.requestReconcile({
       chatroomId: event.chatroomId,
       role: event.role,
@@ -37017,14 +37072,29 @@ class AgentWorkManager {
   }
   async recoverStoppedRole(args2) {
     const key = recoveryKey(args2.chatroomId, args2.role);
-    const gate = this.recoveryGates.get(key);
+    let gate = this.recoveryGates.get(key);
     if (!gate)
       throw new Error(`role recovery gate not prepared for ${args2.role}@${args2.chatroomId}`);
-    if (gate.recoveryPromise)
-      return gate.recoveryPromise;
+    while (gate.recoveryPromise) {
+      if (args2.mode !== "explicit")
+        return gate.recoveryPromise;
+      await gate.recoveryPromise.catch(() => {
+        return;
+      });
+      if (!this.recoveryGates.has(key)) {
+        await this.prepareRoleRecovery({ chatroomId: args2.chatroomId, role: args2.role });
+      }
+      const nextGate = this.recoveryGates.get(key);
+      if (!nextGate)
+        throw new Error(`role recovery gate not prepared for ${args2.role}@${args2.chatroomId}`);
+      gate = nextGate;
+    }
     gate.recoveryPromise = (async () => {
       await gate.drainPromise;
       const result3 = await this.deps.taskService.recoverInFlightTasks(args2);
+      if (args2.mode === "explicit") {
+        this.cancelTurnFailureReleasesForRole(args2.chatroomId, args2.role);
+      }
       if (this.recoveryGates.get(key) === gate) {
         if (gate.retryTimer)
           clearTimeout(gate.retryTimer);
@@ -37060,7 +37130,7 @@ class AgentWorkManager {
     const gate = this.recoveryGates.get(recoveryKey(chatroomId, role));
     if (!gate || gate.retryTimer || this.disposed)
       return;
-    const delay3 = Math.min(30000, 1000 * 2 ** gate.retryAttempts++);
+    const delay3 = computeBackoffDelay(gate.retryAttempts++ + 1, RECOVERY_RETRY_BACKOFF);
     gate.retryTimer = setTimeout(() => {
       gate.retryTimer = undefined;
       this.recoverStoppedRole({ chatroomId, role, mode: "automatic" }).catch((error51) => {
@@ -37069,26 +37139,115 @@ class AgentWorkManager {
       });
     }, delay3);
   }
-  async recoverTaskAfterTurnFailure(event, activeTask, phase) {
+  async recoverTaskAfterTurnFailure(event, activeTask) {
     const { chatroomId, role } = event;
-    const { exceeded } = await this.deps.taskService.recordTurnFailure({
+    const { attempts, exceeded } = await this.deps.taskService.recordTurnFailure({
       chatroomId,
       role,
       taskId: activeTask.taskId
     });
-    if (exceeded)
-      return "exceeded";
-    try {
-      await this.deps.taskService.releaseTaskAfterTurnFailure({
+    if (exceeded) {
+      this.cancelTurnFailureRelease({
         chatroomId,
         role,
         taskId: activeTask.taskId
       });
+      return "exceeded";
+    }
+    this.scheduleTurnFailureRelease({ chatroomId, role, taskId: activeTask.taskId }, attempts, event.completion.turnId, "turn-failure");
+    return "scheduled";
+  }
+  scheduleTurnFailureRelease(key, attempt, turnId, source) {
+    if (this.disposed)
+      return;
+    const keyStr = turnFailureReleaseKey(key);
+    if (source === "turn-failure")
+      this.turnFailureAccountingFailures.delete(keyStr);
+    this.cancelTurnFailureRelease(key);
+    const delay3 = computeBackoffDelay(attempt, REDELIVERY_BACKOFF_OPTIONS);
+    this.deps.taskService.markTurnFailureReleasePending(key);
+    const timer = setTimeout(() => {
+      this.turnFailureReleaseTimers.delete(keyStr);
+      this.deps.taskService.clearTurnFailureReleasePending(key);
+      if (this.disposed)
+        return;
+      this.releaseAfterTurnFailureBackoff(key, attempt);
+    }, delay3);
+    this.turnFailureReleaseTimers.set(keyStr, { key, timer });
+    console.log(`[NativeDelivery:turn-failure-backoff] chatroom=${key.chatroomId} role=${key.role} task=${key.taskId} turn=${turnId} attempt=${attempt} delayMs=${delay3}`);
+  }
+  async releaseAfterTurnFailureBackoff(key, attempt) {
+    const current = this.deps.taskInboxState.getForRole(key.chatroomId, key.role, key.taskId);
+    if (!current || current.status !== "in_progress") {
+      console.log(`[NativeDelivery:turn-failure-release-skipped] chatroom=${key.chatroomId} role=${key.role} task=${key.taskId} reason=task_not_current status=${current?.status ?? "missing"}`);
+      return;
+    }
+    const activeTask = this.deps.agentTaskState.get({
+      chatroomId: key.chatroomId,
+      role: key.role
+    });
+    if (activeTask?.taskId === key.taskId) {
+      console.log(`[NativeDelivery:turn-failure-release-skipped] chatroom=${key.chatroomId} role=${key.role} task=${key.taskId} reason=task_active`);
+      return;
+    }
+    try {
+      await this.deps.taskService.releaseTaskAfterTurnFailure({
+        chatroomId: key.chatroomId,
+        role: key.role,
+        taskId: key.taskId
+      });
+      this.turnFailureAccountingFailures.delete(turnFailureReleaseKey(key));
     } catch (error51) {
-      console.error(`[NativeDelivery:${phase}-recovery-error] chatroom=${chatroomId} role=${role} task=${activeTask.taskId} turn=${event.completion.turnId} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
-      return "recovery-failed";
+      console.error(`[NativeDelivery:turn-failed-release-error] chatroom=${key.chatroomId} role=${key.role} task=${key.taskId} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
+      await this.retryReleaseAfterFailure(key, attempt);
+    }
+  }
+  async retryReleaseAfterFailure(key, previousAttempt) {
+    const keyStr = turnFailureReleaseKey(key);
+    try {
+      const { attempts, exceeded } = await this.deps.taskService.recordTurnFailure(key);
+      this.turnFailureAccountingFailures.delete(keyStr);
+      if (exceeded)
+        return;
+      this.scheduleTurnFailureRelease(key, attempts, "release-retry", "release-retry");
+    } catch (error51) {
+      console.error(`[NativeDelivery:turn-failed-release-retry-error] chatroom=${key.chatroomId} role=${key.role} task=${key.taskId} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
+      const failures = (this.turnFailureAccountingFailures.get(keyStr) ?? 0) + 1;
+      this.turnFailureAccountingFailures.set(keyStr, failures);
+      if (failures >= MAX_TURN_FAILURE_ACCOUNTING_FAILURES) {
+        this.turnFailureAccountingFailures.delete(keyStr);
+        this.cancelTurnFailureRelease(key);
+        console.error(`[NativeDelivery:turn-failure-accounting-stalled] chatroom=${key.chatroomId} role=${key.role} task=${key.taskId} failures=${failures}`);
+        try {
+          await this.deps.taskService.parkTurnFailure(key);
+        } catch (parkError) {
+          console.error(`[NativeDelivery:turn-failure-park-error] chatroom=${key.chatroomId} role=${key.role} task=${key.taskId} error=${parkError instanceof Error ? parkError.stack ?? parkError.message : String(parkError)}`);
+        }
+        return;
+      }
+      this.scheduleTurnFailureRelease(key, previousAttempt, "release-retry", "release-retry");
+    }
+  }
+  cancelTurnFailureRelease(key) {
+    const keyStr = turnFailureReleaseKey(key);
+    const entry = this.turnFailureReleaseTimers.get(keyStr);
+    if (entry === undefined)
+      return;
+    clearTimeout(entry.timer);
+    this.turnFailureReleaseTimers.delete(keyStr);
+    this.turnFailureAccountingFailures.delete(keyStr);
+    this.deps.taskService.clearTurnFailureReleasePending(key);
+  }
+  cancelTurnFailureReleasesForRole(chatroomId, role) {
+    const prefix = `${chatroomId}:${role.toLowerCase()}:`;
+    for (const [keyStr, entry] of [...this.turnFailureReleaseTimers]) {
+      if (!keyStr.startsWith(prefix))
+        continue;
+      clearTimeout(entry.timer);
+      this.turnFailureReleaseTimers.delete(keyStr);
+      this.turnFailureAccountingFailures.delete(keyStr);
+      this.deps.taskService.clearTurnFailureReleasePending(entry.key);
     }
-    return "released";
   }
   async handleAgentTurnEnded(event) {
     const completion = event.completion;
@@ -37100,14 +37259,11 @@ 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.recoverTaskAfterTurnFailure(event, activeTask2, "turn-failed");
+        const recovery = await this.recoverTaskAfterTurnFailure(event, activeTask2);
         if (recovery === "exceeded") {
           this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
           return { kind: "release-slot" };
         }
-        if (recovery === "recovery-failed") {
-          return { kind: "hold-slot", reason: "task-recovery-failed" };
-        }
         this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
       }
       const fact = {
@@ -37296,7 +37452,9 @@ class AgentWorkManager {
       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}`);
+      const cliDriven = isCliDrivenHarness(startInput.agentHarness);
+      const attemptLabel = cliDriven ? `1 of ${MAX_RESPAWN_START_ATTEMPTS}` : "1";
+      console.error(`[NativeDelivery:uncovered-restart-failed] chatroom=${chatroomId} role=${role} task=${task.taskId} attempt=${attemptLabel} error=${outcome.error}`);
       this.beginRespawnStartRetries({ chatroomId, role, workingDir, startInput });
     }
   }
@@ -37311,9 +37469,13 @@ class AgentWorkManager {
       };
     }
   }
-  beginRespawnStartRetries(request3) {
+  beginRespawnStartRetries(input) {
     if (this.disposed)
       return;
+    const request3 = {
+      ...input,
+      cliDriven: isCliDrivenHarness(input.startInput.agentHarness)
+    };
     const key = recoveryKey(request3.chatroomId, request3.role);
     this.cancelRespawnStart(key, "superseded_by_new_restart");
     this.respawnRestartSeq += 1;
@@ -37328,11 +37490,27 @@ class AgentWorkManager {
   armRespawnStartRetry(key, pending) {
     if (this.disposed)
       return;
-    const delay3 = Math.min(30000, 1000 * 2 ** (pending.attempts - 1));
+    const delay3 = computeBackoffDelay(pending.attempts, {
+      baseMs: RESPAWN_RETRY_BASE_MS,
+      maxMs: restartRetryMaxIntervalMs(pending.request.cliDriven),
+      jitter: 0
+    });
     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)}`);
+        const current = this.respawnStartRetries.get(key);
+        const message = error51 instanceof Error ? error51.stack ?? error51.message : String(error51);
+        console.error(`[NativeDelivery:uncovered-restart-error] chatroom=${pending.request.chatroomId} role=${pending.request.role} error=${message}`);
+        if (!current || current.restartId !== pending.restartId || this.disposed)
+          return;
+        current.attempts += 1;
+        if (current.request.cliDriven && current.attempts >= MAX_RESPAWN_START_ATTEMPTS) {
+          this.respawnStartRetries.delete(key);
+          console.error(`[NativeDelivery:uncovered-restart-failed] attempts exhausted chatroom=${current.request.chatroomId} role=${current.request.role} attempts=${current.attempts} error=${message}`);
+          return;
+        }
+        console.error(`[NativeDelivery:uncovered-restart-error-retry] chatroom=${current.request.chatroomId} role=${current.request.role} attempt=${current.attempts} error=${message}`);
+        this.armRespawnStartRetry(key, current);
       });
     }, delay3);
   }
@@ -37340,7 +37518,7 @@ class AgentWorkManager {
     const pending = this.respawnStartRetries.get(key);
     if (!pending || pending.restartId !== restartId || this.disposed)
       return;
-    const { chatroomId, role, workingDir, startInput } = pending.request;
+    const { chatroomId, role } = pending.request;
     if (this.deps.agentMgr.isStopRequested(chatroomId, role)) {
       this.cancelRespawnStart(key, "stop_requested");
       return;
@@ -37350,6 +37528,33 @@ class AgentWorkManager {
       this.cancelRespawnStart(key, "agent_already_running");
       return;
     }
+    const config3 = this.deps.configurationService.get(chatroomId, role);
+    if (!config3) {
+      if (this.deps.configurationService.state?.(chatroomId, role) === "syncing") {
+        console.log(`[NativeDelivery:uncovered-restart-config-syncing] chatroom=${chatroomId} role=${role} attempts=${pending.attempts}`);
+        this.armRespawnStartRetry(key, pending);
+        return;
+      }
+      this.cancelRespawnStart(key, "config_removed");
+      return;
+    }
+    const previous = pending.request;
+    if (config3.agentHarness !== previous.startInput.agentHarness || config3.model !== previous.startInput.model || config3.workingDir !== previous.workingDir) {
+      const startInput2 = {
+        ...previous.startInput,
+        agentHarness: config3.agentHarness,
+        model: config3.model,
+        workingDir: config3.workingDir
+      };
+      pending.request = {
+        ...previous,
+        workingDir: config3.workingDir,
+        startInput: startInput2,
+        cliDriven: isCliDrivenHarness(config3.agentHarness)
+      };
+      console.log(`[NativeDelivery:uncovered-restart-config-changed] chatroom=${chatroomId} role=${role} harness=${config3.agentHarness} model=${config3.model} workingDir=${config3.workingDir}`);
+    }
+    const { workingDir, startInput } = pending.request;
     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" };
@@ -37375,12 +37580,13 @@ class AgentWorkManager {
       return;
     }
     current.attempts += 1;
-    if (current.attempts >= MAX_RESPAWN_START_ATTEMPTS) {
+    if (current.request.cliDriven && 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}`);
+    const attemptLabel = current.request.cliDriven ? `${current.attempts} of ${MAX_RESPAWN_START_ATTEMPTS}` : `${current.attempts}`;
+    console.error(`[NativeDelivery:uncovered-restart-failed] chatroom=${chatroomId} role=${role} attempt=${attemptLabel} error=${outcome.error}`);
     this.armRespawnStartRetry(key, current);
   }
   cancelRespawnStart(key, reason) {
@@ -37432,6 +37638,12 @@ class AgentWorkManager {
   }
   dispose() {
     this.disposed = true;
+    for (const entry of this.turnFailureReleaseTimers.values()) {
+      clearTimeout(entry.timer);
+      this.deps.taskService.clearTurnFailureReleasePending(entry.key);
+    }
+    this.turnFailureReleaseTimers.clear();
+    this.turnFailureAccountingFailures.clear();
     for (const pending of this.respawnStartRetries.values()) {
       if (pending.timer)
         clearTimeout(pending.timer);
@@ -37496,6 +37708,20 @@ class AgentWorkManager {
     if (notification.event.eventType === "task_deleted" /* TaskDeleted */) {
       await this.cancelTaskWork(notification.event.chatroomId, notification.event.role, notification.event.taskId);
     }
+    if (notification.event.eventType === "task_assigned" /* TaskAssigned */) {
+      this.cancelTurnFailureRelease({
+        chatroomId: notification.event.chatroomId,
+        role: notification.event.role,
+        taskId: notification.event.taskId
+      });
+    }
+    if (notification.event.task?.status === "completed") {
+      this.cancelTurnFailureRelease({
+        chatroomId: notification.event.chatroomId,
+        role: notification.event.role,
+        taskId: notification.event.taskId
+      });
+    }
     if (notification.event.eventType === "task_deleted" /* TaskDeleted */) {
       return { handledEventIds: [notification.event.eventId] };
     }
@@ -37541,6 +37767,7 @@ class AgentWorkManager {
     }
   }
   async cancelTaskWork(chatroomId, role, taskId) {
+    this.cancelTurnFailureRelease({ chatroomId, role, taskId });
     const activeTask = this.deps.agentTaskState.get({ chatroomId, role });
     if (activeTask?.taskId !== taskId)
       return;
@@ -37649,7 +37876,7 @@ class AgentWorkManager {
     this.deps.agentTaskState.start(args2);
   }
 }
-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 MAX_RESPAWN_START_ATTEMPTS = 3, MAX_UNCOVERED_NUDGE_SEND_ATTEMPTS = 3, UNCOVERED_NUDGE_RETRY_MS = 250, MAX_TURN_FAILURE_ACCOUNTING_FAILURES = 5, RECOVERY_RETRY_BACKOFF, RESPAWN_RETRY_BASE_MS = 1000, recoveryKey = (chatroomId, role) => `${chatroomId}:${role.toLowerCase()}`, turnFailureReleaseKey = ({ chatroomId, role, taskId }) => `${chatroomId}:${role.toLowerCase()}:${taskId}`, sessionKeyFor = (pid, harnessSessionId) => `${pid}:${harnessSessionId ?? "none"}`;
 var init_agent_work_manager = __esm(() => {
   init_reliability();
   init_agent();
@@ -37659,11 +37886,15 @@ var init_agent_work_manager = __esm(() => {
   init_agent_slot();
   init_assigned_task();
   init_check_agent_slot();
+  init_compute_backoff_delay();
   init_native_task_injector_logic();
   init_convex_native_task_delivery_gateway();
   init_daemon_audit_port();
   init_task_delivery_processor();
   init_native_task_injector();
+  init_is_cli_driven_harness();
+  init_restart_retry_interval();
+  RECOVERY_RETRY_BACKOFF = { baseMs: 1000, maxMs: 30000, jitter: 0 };
 });
 
 // src/daemon/services/agent-process-service/service/index.ts
@@ -39632,11 +39863,6 @@ class AgentProcessManager {
         }
       };
       const dispositions = await Promise.all([...this.agentTurnEndedHandlers].map((handler) => handler(event)));
-      const held = dispositions.find((disposition) => disposition?.kind === "hold-slot");
-      if (held?.kind === "hold-slot") {
-        console.warn(`[AgentProcessManager] Native turn slot held after ${completionStatus}: role=${opts.role} pid=${opts.pid} reason=${held.reason}`);
-        return;
-      }
       if (completionStatus !== "completed" && !dispositions.some((disposition) => disposition?.kind === "release-slot")) {
         console.warn(`[AgentProcessManager] Native turn slot held: no task-service disposition returned role=${opts.role} pid=${opts.pid} status=${completionStatus}`);
         return;
@@ -40795,14 +41021,80 @@ function createTaskService(deps) {
   let bootstrapRecoveryAttempts = 0;
   let bootstrapRecoveryTimer;
   let bootstrapRecoveryPromise;
-  const TURN_FAILURE_RETRY_CAP = 3;
+  const TURN_FAILURE_RETRY_CAP = 8;
   const turnFailureCounts = new Map;
   const uncoveredLadder = new Map;
   const redeliveryExhaustedKeys = new Set;
+  const rearmCycleCounts = new Map;
+  const rearmTimers = new Map;
+  const pendingTurnFailureReleases = new Set;
   const redeliveryKey = (chatroomId, role, taskId) => `${chatroomId}:${role.toLowerCase()}:${taskId}`;
-  const parkTask = async (args2, attempts) => {
-    const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
-    redeliveryExhaustedKeys.add(key);
+  const clearRearmTimer = (key) => {
+    const timer = rearmTimers.get(key);
+    if (timer === undefined)
+      return;
+    clearTimeout(timer);
+    rearmTimers.delete(key);
+  };
+  const resetRearmBudget = (key) => {
+    clearRearmTimer(key);
+    rearmCycleCounts.delete(key);
+  };
+  const scheduleRedeliveryRearm = (args2) => {
+    if (inboxStopped)
+      return;
+    const { key } = args2;
+    const cycles = rearmCycleCounts.get(key) ?? 0;
+    if (cycles >= MAX_REARM_CYCLES) {
+      console.log(`[NativeDelivery:redelivery-rearm-exhausted] chatroom=${args2.chatroomId} role=${args2.role} task=${args2.taskId} cycles=${MAX_REARM_CYCLES}`);
+      return;
+    }
+    clearRearmTimer(key);
+    const delay3 = REARM_DELAYS_MS[cycles];
+    const timer = setTimeout(() => {
+      rearmTimers.delete(key);
+      runRedeliveryRearm({ ...args2, delay: delay3, cycle: cycles + 1 });
+    }, delay3);
+    rearmTimers.set(key, timer);
+  };
+  const runRedeliveryRearm = async (args2) => {
+    const { chatroomId, role, taskId, key } = args2;
+    const current = taskInboxState.getForRole(chatroomId, role, taskId);
+    if (!current || current.status !== "in_progress" || !redeliveryExhaustedKeys.has(key)) {
+      console.log(`[NativeDelivery:redelivery-rearm-skipped] reason=task_not_current chatroom=${chatroomId} role=${role} task=${taskId} status=${current?.status ?? "missing"}`);
+      return;
+    }
+    rearmCycleCounts.set(key, args2.cycle);
+    redeliveryExhaustedKeys.delete(key);
+    turnFailureCounts.delete(key);
+    try {
+      await gateway.clearDeliveryFailure({
+        sessionId: deps.sessionId,
+        machineId: deps.machineId,
+        taskId
+      });
+    } catch (error51) {
+      console.warn(`[TaskService] redelivery-rearm clear failure failed chatroom=${chatroomId} role=${role} task=${taskId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    }
+    let released = false;
+    try {
+      const result3 = await releaseTask({ chatroomId, role, taskId });
+      released = result3.released;
+      if (!released) {
+        console.warn(`[TaskService] redelivery-rearm release skipped chatroom=${chatroomId} role=${role} task=${taskId} cycle=${args2.cycle}`);
+      }
+    } catch (error51) {
+      console.error(`[TaskService] redelivery-rearm release failed chatroom=${chatroomId} role=${role} task=${taskId} cycle=${args2.cycle}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    }
+    if (!released) {
+      redeliveryExhaustedKeys.add(key);
+      await recordExhaustedOnBackend({ chatroomId, role, taskId });
+      scheduleRedeliveryRearm(args2);
+      return;
+    }
+    console.log(`[NativeDelivery:redelivery-rearm] cycle=${args2.cycle}/${MAX_REARM_CYCLES} chatroom=${chatroomId} role=${role} task=${taskId} delayMs=${args2.delay}`);
+  };
+  const recordExhaustedOnBackend = async (args2) => {
     try {
       await gateway.recordDeliveryFailure({
         sessionId: deps.sessionId,
@@ -40813,19 +41105,31 @@ 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)}`);
     }
+  };
+  const parkTask = async (args2, reason, attempts) => {
+    const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
+    redeliveryExhaustedKeys.add(key);
+    await recordExhaustedOnBackend(args2);
     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 rearmCycles = rearmCycleCounts.get(key) ?? 0;
+    const rearmDelay = reason === "provider_failure" && rearmCycles < MAX_REARM_CYCLES ? REARM_DELAYS_MS[rearmCycles] : undefined;
+    console.log(`[NativeDelivery:redelivery-exhausted] chatroom=${args2.chatroomId} role=${args2.role} task=${args2.taskId}${attemptsSuffix} reason=${reason} rearm=${rearmDelay ?? "none"} — release/redelivery stopped; user.start or explicit recovery resets`);
+    if (reason === "provider_failure") {
+      scheduleRedeliveryRearm({ ...args2, key });
+    }
   };
   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;
+    const recordedAttempts = turnFailureCounts.get(key) ?? 0;
+    if (redeliveryExhaustedKeys.has(key)) {
+      return { attempts: recordedAttempts, exceeded: true };
+    }
+    const attempts = recordedAttempts + 1;
     turnFailureCounts.set(key, attempts);
     if (attempts < TURN_FAILURE_RETRY_CAP)
-      return { exceeded: false };
-    await parkTask(args2, attempts);
-    return { exceeded: true };
+      return { attempts, exceeded: false };
+    await parkTask(args2, "provider_failure", attempts);
+    return { attempts, exceeded: true };
   };
   const decideUncoveredTurnEnd2 = async (args2) => {
     const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
@@ -40839,7 +41143,7 @@ function createTaskService(deps) {
     if (decision.action === "restart-session") {
       uncoveredLadder.set(key, withSessionRestart(entry));
     } else if (decision.action === "park") {
-      await parkTask(args2);
+      await parkTask(args2, "uncovered_turn");
     }
     return decision;
   };
@@ -40858,6 +41162,7 @@ function createTaskService(deps) {
     turnFailureCounts.delete(key);
     uncoveredLadder.delete(key);
     redeliveryExhaustedKeys.delete(key);
+    resetRearmBudget(key);
   };
   const forgetStaleTask = ({
     chatroomId,
@@ -40898,11 +41203,19 @@ function createTaskService(deps) {
       if (key.startsWith(prefix))
         redeliveryExhaustedKeys.delete(key);
     }
+    for (const key of [...rearmTimers.keys()]) {
+      if (key.startsWith(prefix))
+        resetRearmBudget(key);
+    }
+    for (const key of [...rearmCycleCounts.keys()]) {
+      if (key.startsWith(prefix))
+        rearmCycleCounts.delete(key);
+    }
   };
   const scheduleBootstrapRecovery = () => {
     if (inboxStopped || bootstrapRecoveryTimer || !bootstrapRecoveryPending)
       return;
-    const delay3 = Math.min(30000, 1000 * 2 ** bootstrapRecoveryAttempts++);
+    const delay3 = computeBackoffDelay(++bootstrapRecoveryAttempts, BOOTSTRAP_RECOVERY_BACKOFF);
     bootstrapRecoveryTimer = setTimeout(() => {
       bootstrapRecoveryTimer = undefined;
       if (!inboxStopped)
@@ -41119,6 +41432,11 @@ function createTaskService(deps) {
     },
     stopTaskInbox: () => {
       inboxStopped = true;
+      for (const timer of rearmTimers.values())
+        clearTimeout(timer);
+      rearmTimers.clear();
+      rearmCycleCounts.clear();
+      pendingTurnFailureReleases.clear();
       if (bootstrapRecoveryTimer)
         clearTimeout(bootstrapRecoveryTimer);
       bootstrapRecoveryTimer = undefined;
@@ -41209,7 +41527,8 @@ function createTaskService(deps) {
           }
           if (mode === "automatic") {
             const tracking = { chatroomId: task.chatroomId, role: taskRole, taskId: task.taskId };
-            if (isRedeliveryExhausted(tracking)) {
+            const key = redeliveryKey(task.chatroomId, taskRole, task.taskId);
+            if (isRedeliveryExhausted(tracking) || rearmTimers.has(key) || pendingTurnFailureReleases.has(key)) {
               skipped += 1;
               continue;
             }
@@ -41295,6 +41614,7 @@ function createTaskService(deps) {
       ...expectedReason ? { expectedReason } : {}
     }),
     recordTurnFailure,
+    parkTurnFailure: (args2) => parkTask(args2, "provider_failure"),
     decideUncoveredTurnEnd: decideUncoveredTurnEnd2,
     confirmNudgeSent,
     resetTurnTracking,
@@ -41302,18 +41622,29 @@ function createTaskService(deps) {
     clearRedeliveryTracking: ({ chatroomId, role }) => {
       clearRoleRedeliveryTracking(chatroomId, role);
     },
+    markTurnFailureReleasePending: ({ chatroomId, role, taskId }) => {
+      pendingTurnFailureReleases.add(redeliveryKey(chatroomId, role, taskId));
+    },
+    clearTurnFailureReleasePending: ({ chatroomId, role, taskId }) => {
+      pendingTurnFailureReleases.delete(redeliveryKey(chatroomId, role, taskId));
+    },
     forgetStaleTask
   };
   return service4;
 }
+var BOOTSTRAP_RECOVERY_BACKOFF, REARM_DELAYS_MS, MAX_REARM_CYCLES;
 var init_task_service = __esm(() => {
   init_chatroom_workspace_task_inbox();
   init_pending_task_reconciliation_watcher();
   init_task_inbox_acknowledgement_retry_watcher();
   init_task_inbox_delivery_retry_watcher();
   init_api3();
+  init_compute_backoff_delay();
   init_uncovered_turn_ladder();
   init_convex_native_task_delivery_gateway();
+  BOOTSTRAP_RECOVERY_BACKOFF = { baseMs: 1000, maxMs: 30000, jitter: 0 };
+  REARM_DELAYS_MS = [15 * 60000, 30 * 60000, 60 * 60000];
+  MAX_REARM_CYCLES = REARM_DELAYS_MS.length;
 });
 
 // src/daemon/services/task-service/infrastructure/repository/task-handoff-repository.ts
@@ -100027,7 +100358,7 @@ var init_team_presets = __esm(() => {
     duo: {
       structureId: TEAM_STRUCTURE_IDS.duo,
       name: "Duo",
-      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral architect, researcher, triage, uiux-engineer, and verifier roles",
+      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral architect, researcher, triage, reviewer, uiux-engineer, game-asset-designer, and verifier roles",
       roles: getBuiltinRolesForTeam("duo"),
       entryPoint: "planner"
     },
@@ -100806,6 +101137,166 @@ var init_builder = __esm(() => {
   };
 });
 
+// ../../services/backend/prompts/teams/game-asset-designer-evidence.ts
+var GAME_ASSET_EVIDENCE_LABELS, GAME_ASSET_EVIDENCE_LABEL_LIST, GAME_ASSET_NEVER_CLAIM_RULE = "Never claim a polycount, texel density, loudness, color space, or visual-quality result without `measured` or `inspected` evidence. Numeric results (polycount, texel density, resolution, loudness, true peak, sample rate, bit depth) and color-space slot checks require `measured`; `inspected` covers only visual or audible judgments. A budget or target you write into the spec is a requirement and is labelled `specified`, not a result.", GAME_ASSET_RESULT_RULE = "A checklist item is `pass` or `fail` only with `measured` or `inspected` evidence. Otherwise record it as `not checked` and keep its label (`specified` or `unverified`).", GAME_ASSET_EVIDENCE_DEFINITIONS = `- \`measured\` — a tool or script you ran on the actual file produced the number or read the metadata field; cite the command and its output value (this includes header or JSON values read by command).
+- \`inspected\` — you opened the actual file or a render and made a qualitative observation (silhouette, seam, palette, style match); describe what you saw and give no numbers.
+- \`specified\` — a target or requirement from the brief or your own spec; no file was checked. A budget you write into a spec is \`specified\`.
+- \`unverified\` — a result that should have been checked but could not be (no file access, no tool, unreadable file), or a value someone else stated that you did not check; say why and name the source.`;
+var init_game_asset_designer_evidence = __esm(() => {
+  GAME_ASSET_EVIDENCE_LABELS = ["measured", "inspected", "specified", "unverified"];
+  GAME_ASSET_EVIDENCE_LABEL_LIST = GAME_ASSET_EVIDENCE_LABELS.map((label) => `\`${label}\``).join(", ");
+});
+
+// ../../services/backend/prompts/teams/game-asset-designer-handoff-templates.ts
+function getEntryPointToGameAssetDesignerHandoffTemplate(query) {
+  const entryPoint = query.fromRole;
+  return `Instructions (not part of the message): Pass the asset request as a brief the designer can act on without guessing. Provide every field below; write \`Not specified.\` for a field you cannot fill and the designer will ask or apply a stated default. Give each asset a stable ID (\`A01\`, \`A02\`…). Use \`spec only\` only when you want a specification with no files; the default is \`spec and generate\`.
+
+## Asset request
+<one to three sentences: what the assets are for and the user-visible goal>
+
+## Target
+<engine and version; genre and camera; platform tier (mobile, PC, console, VR); render pipeline if known>
+
+## Assets requested
+<numbered list with stable IDs \`A01\`, \`A02\`…; each item: asset name, category (3D model, PBR textures, 2D sprite/UI, audio, other), purpose, quantity or variants>
+
+## Budgets and conventions
+<triangle budget per LOD, texel density or pixel grid, texture resolution and atlas limits, loudness target, naming convention, folder layout; or \`Not specified.\`>
+
+## Style reference
+<repository paths, URLs, or a written style sheet; or \`Not specified.\`>
+
+## Spec consumer
+<who produces or integrates these assets from the spec: \`builder\`, \`uiux-engineer\`, an external artist, or \`user\`>
+
+## Existing assets
+<repository paths the designer must reuse or must not overwrite; or \`Not specified.\`>
+
+## Deliverable mode
+<\`spec and generate\` (default when you name an output location and allowed tools) or \`spec only\`>
+
+## Allowed tools
+<the generators the designer may run, or \`Any tool available in the designer's shell.\`; say which>
+
+## Allowed edit paths
+<repository-relative paths the designer may edit; \`None.\` for none>
+
+## Commit
+<\`None.\` or the commit message and the paths to commit>
+
+## Output location
+<the exact repository directory the designer may write to; required for \`spec and generate\`; \`None.\` for \`spec only\`>
+
+## Acceptance criteria
+<what must be true for the planner to accept the delivery>
+
+Instructions after the body (not part of the message): run the normal handoff command to \`game-asset-designer\` with the complete body above, then stop. Use this template only under the conditions below; the body above ends at \`## Acceptance criteria\`.
+
+### When to use the game asset designer
+- the request creates or changes game art or audio assets (models, textures, sprites, UI art, sound effects);
+- assets must meet engine import conventions or budgets before a builder integrates them;
+- the user asks for an asset spec, style sheet, or asset audit.
+
+Skip it for code-only work, for a trivial asset rename, and for non-game UI icons or illustrations (use \`uiux-engineer\`).
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: entryPoint,
+    nextRole: "game-asset-designer",
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+function getGameAssetDesignerToEntryPointHandoffTemplate(query) {
+  const entryPoint = query.toRole;
+  return `Instructions (not part of the message): Return a complete asset delivery report for the request the planner named. State only what you established. Label every checked property with one evidence label: ${GAME_ASSET_EVIDENCE_LABEL_LIST}. Definitions: ${GAME_ASSET_EVIDENCE_DEFINITIONS} ${GAME_ASSET_NEVER_CLAIM_RULE} ${GAME_ASSET_RESULT_RULE} Write only under the named output location and the named edit paths. In \`spec only\` you write no files. Use the exact sections below, in this order. If you are blocked or need a clarification, send the same sections with Summary starting \`Blocked:\` and every section you could not reach written as \`Not started.\`
+
+## Summary
+<one to three sentences: what was delivered, whether it is spec only or includes files, and the count of \`fail\` and \`not checked\` items>
+
+## Target and assumptions
+<each assumption you made and why; each deviation from the planner's target or budgets; or \`None.\`>
+
+## Asset manifest
+<one entry per asset, keyed by the planner's stable ID (\`A01\`…): name, category, file format, path (or \`Specified only.\`), dimensions/units/scale, pivot, naming, LOD list with triangle budgets, texture set with resolution, color space and channel packing, atlas/pixel grid/frame data, audio format and loudness target, import settings, dependencies and variants; for each budget, the acceptance check (exact command and expected value); for each generated file, the generator (tool + version + command or seed)>
+
+## Quality checklist results
+<per asset: each applicable checklist item as \`pass\`, \`fail\`, \`n/a\`, or \`not checked\`, with its evidence label and, for \`measured\`, the command and value; write exactly \`None failed.\` after the list if no item failed>
+
+## Acceptance criteria results
+<each planner acceptance criterion as \`met\`, \`not met\`, or \`not checked\`, with its evidence label>
+
+## Style consistency
+<how the set matches the style reference; deviations; what was compared and how>
+
+## Created and edited paths
+<repository-relative paths and a one-line description each; write exactly \`None.\` for spec only>
+
+## Commits
+<write exactly \`None.\` if none; otherwise one line per commit: \`<sha> <message>\`>
+
+## Sources
+<URLs for engine or platform rules relied on, with version or date checked>
+
+## Open questions
+<each clarification needed from the planner with a recommended default; write exactly \`None.\` if none>
+
+## Not verified
+<every property you could not measure or inspect; write exactly \`None.\` if none>
+
+## Recommended next step
+<exactly one target: \`game-asset-designer\` (re-run with the listed asset IDs), \`builder\` (integrate, or apply the listed import settings), \`uiux-engineer\` (place the listed UI art in a screen design), or \`planner\` (decision needed on an open question); then the affected asset IDs>
+
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "game-asset-designer",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var init_game_asset_designer_handoff_templates = __esm(() => {
+  init_game_asset_designer_evidence();
+  init_command2();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/game-asset-designer-planner-code.ts
+function getGameAssetDesignerPlannerCodeTemplate(query) {
+  return getGameAssetDesignerToEntryPointHandoffTemplate(query);
+}
+var init_game_asset_designer_planner_code = __esm(() => {
+  init_game_asset_designer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/game-asset-designer-planner-chat.ts
+var init_game_asset_designer_planner_chat = __esm(() => {
+  init_game_asset_designer_planner_code();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/game-asset-designer.ts
+var duoGameAssetDesignerHandoffContract;
+var init_game_asset_designer = __esm(() => {
+  init_game_asset_designer_planner_chat();
+  init_game_asset_designer_planner_code();
+  init_contracts();
+  duoGameAssetDesignerHandoffContract = {
+    role: "game-asset-designer",
+    receivesFrom: ["planner"],
+    returnsTo: ["planner"],
+    outboundTemplates: {
+      planner: handoffTemplateByMode({
+        chat: getGameAssetDesignerPlannerCodeTemplate,
+        code: getGameAssetDesignerPlannerCodeTemplate
+      })
+    }
+  };
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/planner-architect-code.ts
 function getPlannerArchitectCodeTemplate(query) {
   return getEntryPointToArchitectHandoffTemplate(query);
@@ -100907,6 +101398,19 @@ var init_planner_builder_chat = __esm(() => {
   init_planner_builder_code();
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-game-asset-designer-code.ts
+function getPlannerGameAssetDesignerCodeTemplate(query) {
+  return getEntryPointToGameAssetDesignerHandoffTemplate(query);
+}
+var init_planner_game_asset_designer_code = __esm(() => {
+  init_game_asset_designer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-game-asset-designer-chat.ts
+var init_planner_game_asset_designer_chat = __esm(() => {
+  init_planner_game_asset_designer_code();
+});
+
 // ../../services/backend/prompts/teams/researcher-handoff-templates.ts
 function getEntryPointToResearcherHandoffTemplate(query) {
   const entryPoint = query.fromRole;
@@ -100992,6 +101496,75 @@ var init_planner_researcher_chat = __esm(() => {
   init_planner_researcher_code();
 });
 
+// ../../services/backend/prompts/teams/reviewer-handoff-templates.ts
+function getEntryPointToReviewerHandoffTemplate(query) {
+  const entryPoint = query.fromRole;
+  return `Pass the review target and the review focus. State the exact commit range, branch, pull request, or file list to inspect, the focus areas (for example security, correctness, or test quality), and any known context or constraints. Ask the reviewer for a report only: do not edit files, run builds or tests, or implement fixes.
+
+### When to review
+
+Review before delivery for code-producing work:
+- a builder slice has just completed and is about to be delivered;
+- the user asks for a code review;
+- a change is large, risky, or touches security-sensitive or shared code.
+
+Skip review for a trivial edit that has already been verified.
+
+After completing the review, the reviewer must return its issue report to \`${entryPoint}\` with the normal handoff command.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: entryPoint,
+    nextRole: "reviewer",
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+function getReviewerToEntryPointHandoffTemplate(query) {
+  const entryPoint = query.toRole;
+  return `Instructions (not part of the message): Return a complete review report for the target the planner named. The reviewer is advisory: do not edit files, implement fixes, run builds or tests, or propose architecture rewrites beyond each issue's suggested fix. Report only what you observed and mark anything unverified as such. Label every issue with a severity: \`blocker\`, \`major\`, \`minor\`, or \`nit\`. Group the issues by severity with blockers first, and cite the repository-relative file and line or line range for each. Use the exact sections below, in this order.
+
+## Summary
+<one to three sentences: overall state of the target and the count of blocker/major issues>
+
+## Review scope
+<commits, paths, and PR/branch inspected; commands run, if any>
+
+## Issues
+<numbered list grouped by severity (blocker, major, minor, nit); each item: \`file:line\` — summary — evidence — suggested fix; write exactly \`None observed.\` if none>
+
+## Not reviewed
+<anything out of scope or unreadable; write exactly \`None.\` if none>
+
+Instructions after the body (not part of the message): run the normal handoff command to \`${entryPoint}\` with the complete body above, then stop.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "reviewer",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var init_reviewer_handoff_templates = __esm(() => {
+  init_command2();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-reviewer-code.ts
+function getPlannerReviewerCodeTemplate(query) {
+  return getEntryPointToReviewerHandoffTemplate(query);
+}
+var init_planner_reviewer_code = __esm(() => {
+  init_reviewer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner-reviewer-chat.ts
+var init_planner_reviewer_chat = __esm(() => {
+  init_planner_reviewer_code();
+});
+
 // ../../services/backend/prompts/teams/triage-handoff-templates.ts
 function getEntryPointToTriageHandoffTemplate(query) {
   const entryPoint = query.fromRole;
@@ -101489,8 +102062,12 @@ var init_planner = __esm(() => {
   init_planner_architect_code();
   init_planner_builder_chat();
   init_planner_builder_code();
+  init_planner_game_asset_designer_chat();
+  init_planner_game_asset_designer_code();
   init_planner_researcher_chat();
   init_planner_researcher_code();
+  init_planner_reviewer_chat();
+  init_planner_reviewer_code();
   init_planner_triage_chat();
   init_planner_triage_code();
   init_planner_uiux_engineer_chat();
@@ -101509,9 +102086,21 @@ var init_planner = __esm(() => {
       "uiux-engineer",
       "triage",
       "researcher",
+      "reviewer",
+      "game-asset-designer",
+      "verifier"
+    ],
+    returnsTo: [
+      "user",
+      "builder",
+      "architect",
+      "uiux-engineer",
+      "triage",
+      "researcher",
+      "reviewer",
+      "game-asset-designer",
       "verifier"
     ],
-    returnsTo: ["user", "builder", "architect", "uiux-engineer", "triage", "researcher", "verifier"],
     outboundTemplates: {
       builder: handoffTemplateByMode({
         chat: getPlannerBuilderCodeTemplate,
@@ -101533,6 +102122,14 @@ var init_planner = __esm(() => {
         chat: getPlannerResearcherCodeTemplate,
         code: getPlannerResearcherCodeTemplate
       }),
+      reviewer: handoffTemplateByMode({
+        chat: getPlannerReviewerCodeTemplate,
+        code: getPlannerReviewerCodeTemplate
+      }),
+      "game-asset-designer": handoffTemplateByMode({
+        chat: getPlannerGameAssetDesignerCodeTemplate,
+        code: getPlannerGameAssetDesignerCodeTemplate
+      }),
       verifier: handoffTemplateByMode({
         chat: getPlannerVerifierCodeTemplate,
         code: getPlannerVerifierCodeTemplate
@@ -101577,6 +102174,38 @@ var init_researcher = __esm(() => {
   };
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/reviewer-planner-code.ts
+function getReviewerPlannerCodeTemplate(query) {
+  return getReviewerToEntryPointHandoffTemplate(query);
+}
+var init_reviewer_planner_code = __esm(() => {
+  init_reviewer_handoff_templates();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/reviewer-planner-chat.ts
+var init_reviewer_planner_chat = __esm(() => {
+  init_reviewer_planner_code();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/reviewer.ts
+var duoReviewerHandoffContract;
+var init_reviewer = __esm(() => {
+  init_reviewer_planner_chat();
+  init_reviewer_planner_code();
+  init_contracts();
+  duoReviewerHandoffContract = {
+    role: "reviewer",
+    receivesFrom: ["planner"],
+    returnsTo: ["planner"],
+    outboundTemplates: {
+      planner: handoffTemplateByMode({
+        chat: getReviewerPlannerCodeTemplate,
+        code: getReviewerPlannerCodeTemplate
+      })
+    }
+  };
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/triage-planner-code.ts
 function getTriagePlannerCodeTemplate(query) {
   return getTriageToEntryPointHandoffTemplate(query);
@@ -101681,8 +102310,10 @@ var DUO_ROLE_HANDOFF_CATALOG, DUO_ROLE_HANDOFF_CONTRACTS, validatedDuoRoleHandof
 var init_handoff_templates = __esm(() => {
   init_architect();
   init_builder();
+  init_game_asset_designer();
   init_planner();
   init_researcher();
+  init_reviewer();
   init_triage();
   init_uiux_engineer();
   init_verifier();
@@ -101692,7 +102323,9 @@ var init_handoff_templates = __esm(() => {
     builder: duoBuilderHandoffContract,
     architect: duoArchitectHandoffContract,
     researcher: duoResearcherHandoffContract,
+    reviewer: duoReviewerHandoffContract,
     "uiux-engineer": duoUiuxEngineerHandoffContract,
+    "game-asset-designer": duoGameAssetDesignerHandoffContract,
     triage: duoTriageHandoffContract,
     verifier: duoVerifierHandoffContract
   };
@@ -102505,6 +103138,79 @@ var init_builder2 = __esm(() => {
   init_sections();
 });
 
+// ../../services/backend/prompts/cli/roles/game-asset-designer.ts
+var GAME_ASSET_DESIGNER_GUIDANCE;
+var init_game_asset_designer2 = __esm(() => {
+  init_game_asset_designer_evidence();
+  init_sections();
+  GAME_ASSET_DESIGNER_GUIDANCE = `## Game Asset Designer Operating Model
+
+You are the game asset designer responsible for specifying production-quality game assets, and for producing them only when the planner's request and your available tools allow it. You own the asset specification, generate the asset files yourself, and edit only the asset-integration paths the brief allows (engine import or config files and the code that references the asset files). You do not implement application logic outside those paths. In \`spec only\` mode you write no files. You do not act as the builder or planner.
+
+${"{SESSION_CONTINUITY}"}
+
+${getInterRoleHandoffRule()}
+
+1. Recover the authoritative request from the injected task and the \`<handoff-templates>\` brief. Recover relevant chatroom history if the brief refers to earlier assets. Production quality is relative to a target, so confirm these inputs: target engine and version, genre and camera, platform tier (mobile, PC, console, VR), art style reference, asset categories, and budgets (triangles per LOD, texel density, texture resolution, atlas size, loudness). If an input is missing and the repository does not answer it, ask \`{ENTRY_POINT_ROLE}\` through the handoff with a clarification request. Do not guess a target engine or platform. For a non-blocking gap, apply the stated default and list it under assumptions. If you are blocked, send the same report to \`{ENTRY_POINT_ROLE}\` with Summary starting \`Blocked:\` and every section you could not reach written as \`Not started.\`
+2. Inspect the repository for existing assets, naming and folder conventions, engine and import configuration, and style references. Match what exists unless the planner says otherwise. Cite paths.
+3. Classify each asset as 3D model, PBR material or texture set, 2D sprite or UI art, audio, or other, and write one manifest entry per asset using the fields in the handoff template.
+4. Specify against the target engine's documented import conventions. Prefer official engine documentation, the Khronos glTF 2.0 specification, and platform audio guidance. Cite the source for any rule you rely on. Treat community figures (albedo ranges, texel density tiers, polycount tiers) as starting points that the request's declared budgets override, and say so.
+5. Apply the quality checklist below to every asset before handoff.
+6. Say exactly how each claim was established, using only these evidence labels (${GAME_ASSET_EVIDENCE_LABEL_LIST}):
+${GAME_ASSET_EVIDENCE_DEFINITIONS}
+${GAME_ASSET_NEVER_CLAIM_RULE} ${GAME_ASSET_RESULT_RULE}
+7. Generate the asset files yourself when the brief names an output location and allowed tools (default mode \`spec and generate\`). Use only the tools the brief allows, and use tools already available in your shell. Record the tool, its version, and the command or seed for every generated file in the manifest. Write only under the named output location. Edit files only at the paths named under \`Allowed edit paths\`. Never overwrite or delete an existing file unless the brief names it. Commit only when the brief names the paths and the commit message; otherwise leave changes uncommitted and say so. If \`Deliverable mode\` is \`spec only\`, write no files. If the output location is missing or ambiguous, deliver \`spec only\`, state that in Summary, and list the gap under Open questions. Describe generated output as production-ready only when every checklist item for it passes with \`measured\` or \`inspected\` evidence. Run each numeric check against the generated file itself, not against your own generator's settings.
+
+   In \`spec only\` the deliverable is a \`Specified only.\` manifest. Each entry has: a stable ID (\`A01\`, \`A02\`…); category; format; units, scale and pivot; name and path; budgets per property; import settings; dependencies and variants; and, for each budget, an acceptance check that gives the exact measuring command and expected value (for example \`ffmpeg -i <file> -af ebur128=peak=true -f null -\`, \`gltf-transform inspect <file>\`, \`ffprobe <file>\`).
+8. Follow the injected \`<handoff-templates>\` asset delivery report exactly, in its order.
+9. Hand the report to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
+
+\`\`\`bash
+chatroom handoff --chatroom-id="<chatroom-id>" --role="game-asset-designer" --next-role="{ENTRY_POINT_ROLE}"
+\`\`\`
+
+### Quality checklist (apply to each asset; mark each item pass, fail, or not applicable, with its evidence label)
+
+**All assets**
+- Name follows the project convention (type prefix, descriptive name, variant, LOD suffix); ASCII, no spaces; folder matches the asset category.
+- File format is the one the target engine imports (glTF 2.0/GLB, FBX, PNG, WAV/OGG as named in the request); no unused data (hidden meshes, unused materials, history).
+- Style matches the named style reference: silhouette, value range, palette, level of detail, and texel density or pixel grid.
+- Budgets in the request are met; any exceedance is called out with the measured value.
+
+**3D models**
+- Units and axes match the target (glTF: meters, +Y up, front +Z); scale is applied (identity scale) and a real-world size is stated.
+- Pivot/origin follows the declared policy; LODs share the base pivot and alignment.
+- Clean topology: no n-gons or non-manifold edges unless declared, no flipped normals or inverted winding (glTF: counter-clockwise front faces), consistent normals and tangents (MikkTSpace).
+- Triangle count per LOD is within budget; LOD naming matches the engine (Unity \`_LOD0\`, \`_LOD1\`; Unreal LODs share the base pivot and alignment and are imported per the FBX import options; Godot generates LODs at import, so declare the Generate LODs setting instead of a suffix).
+- UVs: non-overlapping unique layout where textures are unique, island padding, consistent texel density, no stretched islands; a second UV set if the engine needs baked lighting.
+- Collision and sockets use the engine's naming (Unreal \`UBX_\`/\`UCP_\`/\`USP_\`/\`UCX_\` + mesh name and \`SOCKET_\` + mesh name; Godot \`-col\`/\`-convcolonly\` suffixes).
+- Skinned meshes: bone count within budget, influences per vertex within the declared budget (commonly 4, marked \`unverified\`; glTF allows more via \`JOINTS_1\`), no leftover IK helpers, a named rest pose.
+
+**PBR materials and textures**
+- Metallic-roughness workflow with documented channel packing (glTF: roughness in G, metallic in B, occlusion in R).
+- Color space: base color and emissive sRGB; normal, roughness, metallic, occlusion, masks linear. State the normal map Y convention. In glTF, color space is set by the material slot that references the image, not by embedded PNG chunks. Verify the slot for each map: \`baseColorTexture\` and \`emissiveTexture\` are sRGB; \`metallicRoughnessTexture\`, \`occlusionTexture\` and \`normalTexture\` are linear.
+- Base color values stay in a physically plausible range (community starting range roughly 30–240 sRGB per channel for non-metals; the request's budget overrides it); metallic is near binary.
+- Resolution matches the texel-density budget and surface size; dimensions meet the engine/platform rule (power of two where the engine needs mipmaps or streaming, for example Unreal; confirm for the target engine version); compression format named.
+- Tiling textures wrap without a visible seam; no baked-in lighting or text in base color unless declared.
+- Maps in one set share texel density, value range, and naming (\`T_Name_BaseColor\`, \`_Normal\`, \`_ORM\`).
+
+**2D sprites and UI art**
+- Fixed grid and pixels-per-unit declared; sprite sizes are multiples of the grid; no sub-pixel offsets.
+- Palette size and colors declared; transparent background with clean alpha edges.
+- Animation: uniform frame size per clip, frame count, frame rate, loop flag, and pivot per clip.
+- Atlas: padding of at least the engine default (Unity default 4 px), atlas size within the platform max, filter mode Point for pixel art and no mip maps.
+- Export PNG (lossless with alpha); name states size and frame count where relevant.
+
+**Audio**
+- Loudness measured against the platform target stated in the request (for example console -24 LUFS, mobile -18 LUFS, true peak at or below -1 dBTP); no clipping. Measure with a tool: \`ffmpeg -i <file> -af ebur128=peak=true -f null -\` for integrated loudness and true peak; \`ffprobe <file>\` for sample rate, bit depth and channels; for glTF, \`gltf-transform inspect <file>\` (quote the command's actual output). Cite the platform source. If the request does not state the target, mark the loudness target \`unverified\` and name the source. Mobile targets vary (-18 vs -16 LUFS).
+- Sample rate, bit depth, channel count, loop points, and format stated; short noisy SFX use PCM or ADPCM, long audio uses compressed or streamed formats, per the engine's guidance.
+
+### Scope boundary
+You may specify, name, organize, generate, validate, and integrate assets within the paths the brief allows. You must not claim fidelity you did not establish. If you cannot open or measure a file, write \`unverified\`. Do not present alternative art directions beyond what the request needs; recommend one.
+
+The handoff must contain every required report section, the manifest with one entry per asset, checklist results with evidence labels, assumptions, created and edited paths (or \`None.\`), and open questions for \`{ENTRY_POINT_ROLE}\`.`;
+});
+
 // ../../services/backend/prompts/cli/roles/planner.ts
 var init_planner2 = __esm(() => {
   init_env();
@@ -102536,6 +103242,30 @@ chatroom handoff --chatroom-id="<chatroom-id>" --role="researcher" --next-role="
 \`\`\``;
 });
 
+// ../../services/backend/prompts/cli/roles/reviewer.ts
+var REVIEWER_GUIDANCE;
+var init_reviewer2 = __esm(() => {
+  init_sections();
+  REVIEWER_GUIDANCE = `## Reviewer Operating Model
+
+You are the reviewer responsible for inspecting the code artifacts the planner names and reporting the issues you observe. You are advisory only: do not edit files, implement fixes, or act as the builder or planner.
+
+${"{SESSION_CONTINUITY}"}
+
+${getInterRoleHandoffRule()}
+
+1. Recover the review target and focus from the injected task and the \`<handoff-templates>\` brief. If the target is not explicit, ask the planner through the handoff; do not guess a range.
+2. Inspect the target: the diff or commits, the changed files, and the surrounding code they depend on. Read the actual files; do not review from summaries.
+3. Look for correctness bugs, security issues, missing or weak tests, unclear ownership or error handling, dead code, duplication, and type drift. Stay within the stated focus when one is given.
+4. Label every issue with a severity (\`blocker\`, \`major\`, \`minor\`, \`nit\`) and cite the file and line. Only report what you observed; mark anything unverified as such.
+5. Follow the injected \`<handoff-templates>\` review report exactly, in its order.
+6. Hand the report to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
+
+\`\`\`bash
+chatroom handoff --chatroom-id="<chatroom-id>" --role="reviewer" --next-role="{ENTRY_POINT_ROLE}"
+\`\`\``;
+});
+
 // ../../services/backend/prompts/cli/roles/triage.ts
 var TRIAGE_GUIDANCE;
 var init_triage3 = __esm(() => {
@@ -102636,8 +103366,10 @@ var init_fromContext = __esm(() => {
 var init_fromContext2 = __esm(() => {
   init_architect3();
   init_builder2();
+  init_game_asset_designer2();
   init_planner2();
   init_researcher2();
+  init_reviewer2();
   init_triage3();
   init_uiux_engineer3();
   init_verifier3();
@@ -102731,6 +103463,32 @@ var init_templates = __esm(() => {
       ],
       defaultHandoffTarget: "planner"
     },
+    reviewer: {
+      role: "reviewer",
+      title: "Reviewer",
+      description: "You are the reviewer responsible for inspecting the code artifacts the planner names and reporting the issues you observe; you are advisory only and do not implement fixes.",
+      responsibilities: [
+        "Recover the review target and focus from the planner brief",
+        "Inspect the diff or commits and the surrounding code they depend on",
+        "Look for correctness, security, test quality, ownership, dead code, duplication, and type drift",
+        "Label each issue with a severity and cite the file and line",
+        "Hand one review report to the planner, separating reviewed scope from what was not reviewed"
+      ],
+      defaultHandoffTarget: "planner"
+    },
+    "game-asset-designer": {
+      role: "game-asset-designer",
+      title: "Game Asset Designer",
+      description: "You are the game asset designer responsible for specifying production-quality game assets (and producing them when the planner allows); you do not implement application code.",
+      responsibilities: [
+        "Recover the target, asset request, style reference, and budgets from the planner brief",
+        "Inspect the repository for existing assets, naming and folder conventions, and engine import configuration",
+        "Write one manifest entry per asset covering format, units, pivot, LODs, textures, atlases, and audio",
+        "Self-check each asset against the quality checklist and label every claim with its evidence label",
+        "Hand one asset delivery report to the planner, separating assumptions and unverified properties from established results"
+      ],
+      defaultHandoffTarget: "planner"
+    },
     verifier: {
       role: "verifier",
       title: "Verifier",
@@ -139141,4 +139899,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=430CD3ADC73C742264756E2164756E21
+//# debugId=71E0747DD56ECDB664756E2164756E21