chatroom-cli 1.128.0 → 1.129.0

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(() => {
@@ -20393,6 +20403,13 @@ var init_agent_role = __esm(() => {
     researcher: {
       tags: ["ephemeral" /* Ephemeral */],
       teams: [{ teamId: "duo", order: 25 }]
+    },
+    verifier: {
+      tags: ["ephemeral" /* Ephemeral */],
+      teams: [
+        { teamId: "duo", order: 45 },
+        { teamId: "solo", order: 45 }
+      ]
     }
   };
   AGENT_ROLE_DEFINITIONS = Object.fromEntries(Object.entries(roleMetadata).map(([role, metadata]) => [role, { role, ...metadata }]));
@@ -35229,8 +35246,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 +35311,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 +36354,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 +36623,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 +36752,8 @@ class AgentWorkManager {
   nativeTaskDeliveryQueue;
   deliveryTaskService;
   recoveryGates = new Map;
+  respawnStartRetries = new Map;
+  respawnRestartSeq = 0;
   disposed = false;
   constructor(deps) {
     this.deps = deps;
@@ -36763,7 +36785,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 +36814,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 +36932,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 +36963,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 +37003,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 +37047,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 +37295,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 +37512,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 +40620,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 +40658,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 +40676,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 +40749,13 @@ function createTaskService(deps) {
   };
   const clearRoleRedeliveryTracking = (chatroomId, role) => {
     const prefix = `${chatroomId}:${role.toLowerCase()}:`;
-    for (const key of [...turnEndAttemptCounts.keys()]) {
+    for (const key of [...turnFailureCounts.keys()]) {
+      if (key.startsWith(prefix))
+        turnFailureCounts.delete(key);
+    }
+    for (const key of [...uncoveredLadder.keys()]) {
       if (key.startsWith(prefix))
-        turnEndAttemptCounts.delete(key);
+        uncoveredLadder.delete(key);
     }
     for (const key of [...redeliveryExhaustedKeys]) {
       if (key.startsWith(prefix))
@@ -40802,7 +41157,10 @@ function createTaskService(deps) {
       taskId,
       ...expectedReason ? { expectedReason } : {}
     }),
-    recordUncoveredTurnEnd,
+    recordTurnFailure,
+    decideUncoveredTurnEnd: decideUncoveredTurnEnd2,
+    confirmNudgeSent,
+    resetTurnTracking,
     isRedeliveryExhausted,
     clearRedeliveryTracking: ({ chatroomId, role }) => {
       clearRoleRedeliveryTracking(chatroomId, role);
@@ -40817,6 +41175,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();
 });
 
@@ -99530,14 +99889,14 @@ 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, and uiux-engineer roles",
+      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral architect, researcher, triage, uiux-engineer, and verifier roles",
       roles: getBuiltinRolesForTeam("duo"),
       entryPoint: "planner"
     },
     solo: {
       structureId: TEAM_STRUCTURE_IDS.solo,
       name: "Solo",
-      description: "A single agent working independently, with optional ephemeral architect, triage, and uiux-engineer roles",
+      description: "A single agent working independently, with optional ephemeral architect, triage, uiux-engineer, and verifier roles",
       roles: getBuiltinRolesForTeam("solo"),
       entryPoint: "solo"
     }
@@ -100621,6 +100980,99 @@ var init_triage_handoff_templates = __esm(() => {
   init_command2();
 });
 
+// ../../services/backend/prompts/teams/verifier-handoff-templates.ts
+function normalizeEntryPointRole5(entryPointRole) {
+  return entryPointRole.trim().toLowerCase() || "planner";
+}
+function getEntryPointToVerifierHandoffTemplate(entryPointRole) {
+  const entryPoint = normalizeEntryPointRole5(entryPointRole);
+  return `${getHandoffRecipientVisibilityCallout("verifier")}
+
+## Handoff Template (${entryPoint} → verifier)
+
+The verifier judges, from chatroom logs only, whether the user's last message was achieved. It ${VERIFIER_TEST_RULE}; list any user-requested tests under Requested test runs. Treat the claimed outcome as a claim, not as evidence: the verifier does not trust it and checks every requirement against the logs themselves. Request this review only when the task involved code changes, in any conversation mode. The verdict returns to \`${entryPoint}\`.
+
+## Round
+<1 or 2; for 2, cite the round-1 verdict message id>
+
+## Mode
+<chat | code | code:enhanced>
+
+## User message id
+<id of the user's last message: the origin message id of the user task, or from \`chatroom messages anchor\`>
+
+## Context id
+<id from \`chatroom context read\`, or \`none\` if no context was read for this task>
+
+## Requested test runs
+<the test commands the user explicitly asked for, one per line, or exactly \`None requested.\`>
+
+## Claimed outcome
+<requirement-by-requirement what you believe is complete>
+
+## Evidence pointers
+<builder handoff message ids, commits, PRs, and test results as quoted in those handoffs>
+
+## Known gaps
+<anything incomplete, or exactly \`None.\`>
+
+## Handoff
+Send this request to the verifier with the command below, then stop. The verdict returns to \`${entryPoint}\`.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: entryPoint,
+    nextRole: "verifier",
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+function getVerifierToEntryPointHandoffTemplate(entryPointRole) {
+  const entryPoint = normalizeEntryPointRole5(entryPointRole);
+  return `${getHandoffRecipientVisibilityCallout(entryPoint)}
+
+## Handoff Template (Verifier → ${entryPoint})
+
+Return one advisory verdict for the authoritative request. This review is non-binding: it uses chatroom logs, plus the requested test runs listed in the request, if any, deciding every requirement from the evidence those logs and runs actually contain. It ${VERIFIER_TEST_RULE}. Never accept the claimed outcome as proof. Use the exact sections below, in this order.
+
+## Verdict
+<exactly one of ${VERIFIER_VERDICTS.join(", ")} as the value; ${ACHIEVED} only if every requirement is met; ${NOT_ACHIEVED} if any requirement is unmet (logs show it was not done, or contradict it); ${INCONCLUSIVE} if none is unmet but any is unverified (logs are silent)>
+
+## Objective
+<user message id, any prior user messages used, objective in 1-2 sentences>
+
+## Requirements
+<numbered \`R1 — <requirement> — met | unmet | unverified — <evidence ref>\`>
+
+## Evidence
+<bullets: \`<message id or handoff> — "<short quote>" — supports R#\`; for a requested test run, \`<command> — exit <result> — supports R#\`>
+
+## Missing or unmet
+<per unmet or unverified requirement: what is missing and what evidence would resolve it; exactly \`None.\` if ${ACHIEVED}>
+
+## Scope and limits
+<state the test runs the verifier executed (command and exit result), or "No tests were run; none were requested."; log range read; whether the download was truncated; context id read and whether it matched the request>
+
+## Handoff
+Run the normal handoff command to \`${entryPoint}\` with this complete verdict, then stop.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "verifier",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var VERIFIER_VERDICTS, VERIFIER_TEST_RULE = "runs no test the user did not ask for, and never builds, lints, or edits", ACHIEVED, NOT_ACHIEVED, INCONCLUSIVE;
+var init_verifier_handoff_templates = __esm(() => {
+  init_command2();
+  VERIFIER_VERDICTS = ["ACHIEVED", "NOT_ACHIEVED", "INCONCLUSIVE"];
+  [ACHIEVED, NOT_ACHIEVED, INCONCLUSIVE] = VERIFIER_VERDICTS;
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/planner.ts
 var duoPlannerHandoffContract;
 var init_planner = __esm(() => {
@@ -100631,16 +101083,26 @@ var init_planner = __esm(() => {
   init_researcher_handoff_templates();
   init_triage_handoff_templates();
   init_uiux_engineer_handoff_templates();
+  init_verifier_handoff_templates();
   duoPlannerHandoffContract = {
     role: "planner",
-    receivesFrom: ["user", "builder", "architect", "uiux-engineer", "triage", "researcher"],
-    returnsTo: ["builder", "architect", "uiux-engineer", "triage", "researcher", "user"],
+    receivesFrom: [
+      "user",
+      "builder",
+      "architect",
+      "uiux-engineer",
+      "triage",
+      "researcher",
+      "verifier"
+    ],
+    returnsTo: ["builder", "architect", "uiux-engineer", "triage", "researcher", "verifier", "user"],
     outboundTemplates: {
       builder: () => getPlannerToBuilderHandoffTemplate(),
       architect: () => getEntryPointToArchitectHandoffTemplate("planner"),
       "uiux-engineer": () => getEntryPointToUiuxEngineerHandoffTemplate("planner"),
       triage: () => getEntryPointToTriageHandoffTemplate("planner"),
       researcher: () => getEntryPointToResearcherHandoffTemplate("planner"),
+      verifier: () => getEntryPointToVerifierHandoffTemplate("planner"),
       user: (query) => query.conversationMode === "chat" ? getChatToUserHandoffTemplate() : getPlannerToUserReportTemplate({
         chatroomId: query.chatroomId,
         role: query.role,
@@ -100692,6 +101154,20 @@ var init_uiux_engineer = __esm(() => {
   };
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/verifier.ts
+var duoVerifierHandoffContract;
+var init_verifier = __esm(() => {
+  init_verifier_handoff_templates();
+  duoVerifierHandoffContract = {
+    role: "verifier",
+    receivesFrom: ["planner"],
+    returnsTo: ["planner"],
+    outboundTemplates: {
+      planner: () => getVerifierToEntryPointHandoffTemplate("planner")
+    }
+  };
+});
+
 // ../shared/src/domain/chatroom-role.ts
 var CHATROOM_ROLE_USER = "user";
 var init_chatroom_role = __esm(() => {
@@ -100836,6 +101312,7 @@ var init_handoff_templates = __esm(() => {
   init_researcher();
   init_triage();
   init_uiux_engineer();
+  init_verifier();
   init_contracts();
   DUO_ROLE_HANDOFF_CATALOG = {
     planner: duoPlannerHandoffContract,
@@ -100843,7 +101320,8 @@ var init_handoff_templates = __esm(() => {
     architect: duoArchitectHandoffContract,
     researcher: duoResearcherHandoffContract,
     "uiux-engineer": duoUiuxEngineerHandoffContract,
-    triage: duoTriageHandoffContract
+    triage: duoTriageHandoffContract,
+    verifier: duoVerifierHandoffContract
   };
   DUO_ROLE_HANDOFF_CONTRACTS = Object.values(DUO_ROLE_HANDOFF_CATALOG);
   validatedDuoRoleHandoffContracts = (() => {
@@ -100888,14 +101366,16 @@ var init_solo = __esm(() => {
   init_architect_handoff_templates();
   init_triage_handoff_templates();
   init_uiux_engineer_handoff_templates();
+  init_verifier_handoff_templates();
   soloHandoffContract = {
     role: "solo",
-    receivesFrom: ["user", "architect", "uiux-engineer", "triage"],
-    returnsTo: ["architect", "uiux-engineer", "triage", "user"],
+    receivesFrom: ["user", "architect", "uiux-engineer", "triage", "verifier"],
+    returnsTo: ["architect", "uiux-engineer", "triage", "verifier", "user"],
     outboundTemplates: {
       architect: () => getEntryPointToArchitectHandoffTemplate("solo"),
       "uiux-engineer": () => getEntryPointToUiuxEngineerHandoffTemplate("solo"),
       triage: () => getEntryPointToTriageHandoffTemplate("solo"),
+      verifier: () => getEntryPointToVerifierHandoffTemplate("solo"),
       user: (query) => query.conversationMode === "chat" ? getChatToUserHandoffTemplate() : getSoloToUserReportTemplate({
         chatroomId: query.chatroomId,
         role: query.role,
@@ -100933,6 +101413,20 @@ var init_uiux_engineer2 = __esm(() => {
   };
 });
 
+// ../../services/backend/prompts/teams/solo/handoff-templates/verifier.ts
+var soloVerifierHandoffContract;
+var init_verifier2 = __esm(() => {
+  init_verifier_handoff_templates();
+  soloVerifierHandoffContract = {
+    role: "verifier",
+    receivesFrom: ["solo"],
+    returnsTo: ["solo"],
+    outboundTemplates: {
+      solo: () => getVerifierToEntryPointHandoffTemplate("solo")
+    }
+  };
+});
+
 // ../../services/backend/prompts/teams/solo/handoff-templates/index.ts
 function listSoloRoleHandoffContracts() {
   return validatedSoloRoleHandoffContracts;
@@ -100950,12 +101444,14 @@ var init_handoff_templates2 = __esm(() => {
   init_solo();
   init_triage2();
   init_uiux_engineer2();
+  init_verifier2();
   init_contracts();
   SOLO_ROLE_HANDOFF_CATALOG = {
     solo: soloHandoffContract,
     architect: soloArchitectHandoffContract,
     "uiux-engineer": soloUiuxEngineerHandoffContract,
-    triage: soloTriageHandoffContract
+    triage: soloTriageHandoffContract,
+    verifier: soloVerifierHandoffContract
   };
   SOLO_ROLE_HANDOFF_CONTRACTS = Object.values(SOLO_ROLE_HANDOFF_CATALOG);
   validatedSoloRoleHandoffContracts = (() => {
@@ -101506,6 +102002,34 @@ chatroom handoff --chatroom-id="<chatroom-id>" --role="uiux-engineer" --next-rol
 The handoff must contain every required brief section, repository evidence, chosen flow, exact component/prop/state details, explicit states, accessibility details, ownership decisions, concrete classes/tokens, risks, acceptance criteria, tests, and implementation sequence the configured entry point needs to coordinate implementation. It must not contain implementation edits or alternative designs.`;
 });
 
+// ../../services/backend/prompts/cli/roles/verifier.ts
+var ACHIEVED2, NOT_ACHIEVED2, INCONCLUSIVE2, VERIFIER_GUIDANCE;
+var init_verifier3 = __esm(() => {
+  init_verifier_handoff_templates();
+  init_sections();
+  [ACHIEVED2, NOT_ACHIEVED2, INCONCLUSIVE2] = VERIFIER_VERDICTS;
+  VERIFIER_GUIDANCE = `## Verifier Operating Model
+
+You are the verifier. Your main job is to check whether the user's goal was accomplished, judged from chatroom logs. You are advisory and read-only: do not edit files, implement code, run builds or linters, run \`chatroom context new\`, or act as the planner or builder. The one exception to running nothing is the test rule below: it ${VERIFIER_TEST_RULE}.
+
+${"{SESSION_CONTINUITY}"}
+
+${getInterRoleHandoffRule()}
+
+1. Read the injected verification request: round, mode, user message id, context id, requested test runs, claimed outcome, evidence pointers, and known gaps. The claimed outcome is a claim to be checked, never evidence.
+2. Recover the objective from the logs. Run \`chatroom messages anchor --chatroom-id="<chatroom-id>" --role="verifier"\`, then \`chatroom messages download --chatroom-id="<chatroom-id>" --role="verifier" --since-message-id=<user message id> --limit=100\`. If the download is truncated, raise \`--limit\` and download again until the range is complete. If the anchor id differs from the request's user message id, use the request's id and report the mismatch. For terse follow-ups, recover intent from the prior user messages the anchor lists.
+2a. Requested test runs: if the user's last message (or prior user messages for this objective) explicitly asks for tests to be run, run exactly those commands from the repository root, record the command and exit result, and count the output as evidence. Run no test the user did not ask for. If the request is absent, run nothing.
+3. Run \`chatroom context read --chatroom-id="<chatroom-id>" --role="verifier"\` and note any mismatch with the request's context id.
+4. Decompose the objective into numbered requirements R1..Rn. Split compound requests and ignore anything the user did not actually ask for.
+5. Find evidence for every requirement in the logs alone: builder handoff reports, planner delegations, quoted test output, commits, and PRs. \`met\` requires concrete evidence in the logs. The planner's claimed outcome is a claim, not evidence. Silence means \`unverified\`. A contradiction, or a log showing the requirement was not done, means \`unmet\`. Never state that tests passed unless a log reports it, or you ran the requested tests yourself.
+6. Choose the verdict by the rules in the injected verdict template: exactly one of ${VERIFIER_VERDICTS.join(", ")}. ${ACHIEVED2} only if every requirement is met; ${NOT_ACHIEVED2} if any requirement is unmet; ${INCONCLUSIVE2} if none is unmet but any is unverified.
+7. Follow the injected \`<handoff-templates>\` verdict template exactly, in its order, and put the complete verdict in the handoff. Then hand off to the configured entry point with the normal command, then stop:
+
+\`\`\`bash
+chatroom handoff --chatroom-id="<chatroom-id>" --role="verifier" --next-role="{ENTRY_POINT_ROLE}"
+\`\`\``;
+});
+
 // ../../services/backend/prompts/cli/roles/planner-guidance-context.ts
 var init_planner_guidance_context = __esm(() => {
   init_env();
@@ -101529,6 +102053,7 @@ var init_fromContext2 = __esm(() => {
   init_planner2();
   init_researcher2();
   init_uiux_engineer3();
+  init_verifier3();
   init_fromContext();
 });
 
@@ -101618,6 +102143,19 @@ var init_templates = __esm(() => {
       ],
       defaultHandoffTarget: "planner"
     },
+    verifier: {
+      role: "verifier",
+      title: "Verifier",
+      description: "You are the verifier responsible for judging, from chatroom logs only, whether the user's last message was achieved; you do not implement, test, or inspect code.",
+      responsibilities: [
+        "Recover the user's last message and the pinned context from the chatroom logs",
+        "Break the objective into numbered requirements",
+        "Check each requirement against concrete evidence in the logs, treating the planner claim as unverified",
+        "Return one verdict (ACHIEVED, NOT_ACHIEVED, or INCONCLUSIVE) with evidence and the missing items",
+        "Execute nothing: no tests, builds, or repository inspection"
+      ],
+      defaultHandoffTarget: "planner"
+    },
     triage: {
       role: "triage",
       title: "Triage Agent",
@@ -110754,9 +111292,7 @@ function normalizeDeliveryAttachments(input) {
   return Object.values(attachments).some((items) => items && items.length > 0) ? attachments : undefined;
 }
 function normalizeTask(input) {
-  if (!input.taskId || input.taskStatus == null || input.taskContent == null)
-    return;
-  return { _id: input.taskId, status: input.taskStatus, content: input.taskContent };
+  return input.task ?? undefined;
 }
 function toSerializableMessage(input) {
   const attachments = normalizeDeliveryAttachments(input);
@@ -111145,10 +111681,6 @@ async function createDefaultDeps17() {
     }
   };
 }
-function formatBadges(message) {
-  const status = message.taskStatus ? ` (${message.taskStatus})` : "";
-  return `${status}`;
-}
 function logMessageContent(content, full) {
   if (full) {
     console.log(`   Content:
@@ -111220,11 +111752,10 @@ var listBySenderRoleEffect = (chatroomId, options) => exports_Effect.gen(functio
     console.log("─".repeat(60));
     for (const message of messages) {
       const timestamp = new Date(message._creationTime).toLocaleString();
-      const badges = formatBadges(message);
       console.log(`
 \uD83D\uDD39 ID: ${message._id}`);
       console.log(`   Time: ${timestamp}`);
-      console.log(`   Type: ${message.type}${badges}`);
+      console.log(`   Type: ${message.type}`);
       if (message.targetRole) {
         console.log(`   Target: ${message.targetRole}`);
       }
@@ -111256,12 +111787,11 @@ var listBySenderRoleEffect = (chatroomId, options) => exports_Effect.gen(functio
     for (const message of messages) {
       const timestamp = new Date(message._creationTime).toLocaleString();
       const roleIndicator = message.senderRole.toLowerCase() === "user" ? "\uD83D\uDC64" : "\uD83E\uDD16";
-      const badges = formatBadges(message);
       console.log(`
 ${roleIndicator} ${message.senderRole}${message.targetRole ? ` → ${message.targetRole}` : ""}`);
       console.log(`   ID: ${message._id}`);
       console.log(`   Time: ${timestamp}`);
-      console.log(`   Type: ${message.type}${badges}`);
+      console.log(`   Type: ${message.type}`);
       logMessageContent(message.content, options.full ?? false);
     }
     console.log(`
@@ -137918,4 +138448,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=FEC6884486B357A364756E2164756E21
+//# debugId=8506C14FCD932D1964756E2164756E21