chatroom-cli 1.119.2 → 1.120.0

package/dist/index.js

@@ -45821,8 +45821,7 @@ class AgentProcessManager {
       sessionId: this.deps.sessionId,
       machineId: this.deps.machineId,
       chatroomId: opts.chatroomId,
-      role: opts.role,
-      taskId: opts.taskId
+      role: opts.role
     });
     if (!authorization.allowed) {
       this.resetSlotIdle(slot);
@@ -47087,6 +47086,15 @@ function createTaskService(deps) {
     turnEndAttemptCounts.delete(key);
     redeliveryExhaustedKeys.delete(key);
   };
+  const forgetStaleTask = ({
+    chatroomId,
+    role,
+    taskId
+  }) => {
+    taskInboxState.remove(chatroomId, role, taskId, Date.now());
+    pendingTaskReconciliationWatcher.clear(chatroomId, role, taskId);
+    clearRedeliveryTrackingForTask(chatroomId, role, taskId);
+  };
   const sweepUncoveredInProgressTasks = async () => {
     let released = 0;
     let failures3 = 0;
@@ -47456,7 +47464,8 @@ function createTaskService(deps) {
     isRedeliveryExhausted,
     clearRedeliveryTracking: ({ chatroomId, role }) => {
       clearRoleRedeliveryTracking(chatroomId, role);
-    }
+    },
+    forgetStaleTask
   };
   return service4;
 }
@@ -47704,7 +47713,9 @@ class NativeTaskDeliveryCoordinator {
         const result = await executors.deliverTask(row, agentConfig);
         if (!result || result.kind === "task-unavailable") {
           console.warn(`[NativeDelivery:execution] attempt=${attemptId} role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=inject result=task_hydration_missing`);
-          await recordDeliveryFailure(taskService, row.taskId, "injection_not_confirmed");
+          if (!result?.stale) {
+            await recordDeliveryFailure(taskService, row.taskId, "injection_not_confirmed");
+          }
         } else if (result.kind === "failed") {
           console.warn(`[NativeDelivery:failure] attempt=${attemptId} role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=inject reason=${result.reason}`);
           await recordDeliveryFailure(taskService, row.taskId, result.reason);
@@ -47781,23 +47792,55 @@ async function processTasksUpdate(taskService, configurationService, pass, isTas
         ...startInput,
         ...ephemeralOverrides ? { overrides: ephemeralOverrides } : {}
       };
+      const taskLookup = {
+        chatroomId: task.chatroomId,
+        role: task.agentConfig.role,
+        taskId: task.taskId
+      };
+      const fullBeforeSlot = await taskService.loadAssignedTaskForAction(taskLookup);
+      if (!fullBeforeSlot) {
+        taskService.forgetStaleTask(taskLookup);
+        console.warn(`[NativeDelivery:stale-task] chatroom=${task.chatroomId} role=${task.agentConfig.role} task=${task.taskId} reason=authoritative_task_missing`);
+        return { kind: "task-unavailable", stale: true };
+      }
       const slot = await acquireNativeDeliverySlot({
         ...effectiveStartInput,
         timeoutMs: 30000
       });
-      const full = await taskService.loadAssignedTaskForAction({
+      const full = await taskService.loadAssignedTaskForAction(taskLookup);
+      if (!full) {
+        taskService.forgetStaleTask(taskLookup);
+        console.warn(`[NativeDelivery:stale-task] chatroom=${task.chatroomId} role=${task.agentConfig.role} task=${task.taskId} reason=authoritative_task_missing_after_slot`);
+        return { kind: "task-unavailable", stale: true };
+      }
+      if (!slot?.harnessSessionId)
+        return { kind: "task-unavailable" };
+      const delivery = {
         chatroomId: task.chatroomId,
         role: task.agentConfig.role,
-        taskId: task.taskId
-      });
-      if (!full || !slot?.harnessSessionId)
-        return { kind: "task-unavailable" };
+        taskId: task.taskId,
+        harnessSessionId: slot.harnessSessionId
+      };
+      options.onTaskDeliveryStarted?.(delivery);
       let delivered;
-      await taskService.deliverNativeTask(full, slot.harnessSessionId, (result) => {
-        delivered = result;
-      });
-      if (!delivered)
+      try {
+        await taskService.deliverNativeTask(full, slot.harnessSessionId, (result) => {
+          delivered = result;
+        });
+      } catch (error51) {
+        options.onTaskDeliveryFailed?.({
+          ...delivery,
+          reason: "injection_not_confirmed"
+        });
+        throw error51;
+      }
+      if (!delivered) {
+        options.onTaskDeliveryFailed?.({
+          ...delivery,
+          reason: "injection_not_confirmed"
+        });
         return { kind: "failed", reason: "injection_not_confirmed" };
+      }
       return { kind: "delivered", delivered };
     }
   };
@@ -47887,6 +47930,7 @@ class AgentWorkManager {
       recordUncoveredTurnEnd: deps.taskService.recordUncoveredTurnEnd,
       isRedeliveryExhausted: deps.taskService.isRedeliveryExhausted,
       clearRedeliveryTracking: deps.taskService.clearRedeliveryTracking,
+      forgetStaleTask: deps.taskService.forgetStaleTask,
       loadAssignedTaskForAction: deps.taskService.loadAssignedTaskForAction,
       deliverNativeTask: (task, harnessSessionId, onTaskDelivered) => this.nativeTaskDeliveryQueue.enqueue({ task, harnessSessionId, onTaskDelivered })
     };
@@ -48044,6 +48088,17 @@ class AgentWorkManager {
       return;
     }
     if (notification.kind === "periodic-reconcile") {
+      const taskLookup2 = {
+        chatroomId: notification.task.chatroomId,
+        role: notification.task.agentConfig.role,
+        taskId: notification.task.taskId
+      };
+      const currentTask2 = await this.deliveryTaskService.loadAssignedTaskForAction(taskLookup2);
+      if (!currentTask2) {
+        this.deliveryTaskService.forgetStaleTask(taskLookup2);
+        console.warn(`[NativeDelivery:stale-task] chatroom=${taskLookup2.chatroomId} role=${taskLookup2.role} task=${taskLookup2.taskId} reason=periodic_authoritative_task_missing`);
+        return;
+      }
       await this.requestReconcile({
         chatroomId: notification.task.chatroomId,
         role: notification.task.agentConfig.role,
@@ -48070,6 +48125,17 @@ class AgentWorkManager {
     })?.taskId === notification.event.taskId) {
       return { handledEventIds: [notification.event.eventId] };
     }
+    const taskLookup = {
+      chatroomId: notification.event.chatroomId,
+      role: notification.event.role,
+      taskId: notification.event.taskId
+    };
+    const authoritativeTask = await this.deliveryTaskService.loadAssignedTaskForAction(taskLookup);
+    if (!authoritativeTask) {
+      this.deliveryTaskService.forgetStaleTask(taskLookup);
+      console.warn(`[NativeDelivery:stale-task] chatroom=${taskLookup.chatroomId} role=${taskLookup.role} task=${taskLookup.taskId} reason=inbox_authoritative_task_missing`);
+      return { handledEventIds: [notification.event.eventId] };
+    }
     const deliveredTaskIds = await this.requestReconcile({
       chatroomId: notification.event.chatroomId,
       role: notification.event.role,
@@ -48165,12 +48231,23 @@ class AgentWorkManager {
       return [];
     return processTasksUpdate(this.deliveryTaskService, this.deps.configurationService, pass, ({ chatroomId, role, taskId }) => this.deps.agentTaskState.get({ chatroomId, role })?.taskId === taskId, {
       tasks,
+      onTaskDeliveryStarted: (args2) => this.recordTaskDeliveryStarted(args2),
+      onTaskDeliveryFailed: (args2) => this.recordTaskDeliveryFailed(args2),
       onTaskDelivered: (args2) => {
         this.recordTaskDelivered(args2);
         onTaskDelivered?.(args2);
       }
     }, this.deps.acquireNativeDeliverySlot);
   }
+  recordTaskDeliveryStarted(args2) {
+    this.deps.agentTaskState.start(args2);
+  }
+  recordTaskDeliveryFailed(args2) {
+    const key = { chatroomId: args2.chatroomId, role: args2.role };
+    if (this.deps.agentTaskState.get(key)?.taskId === args2.taskId) {
+      this.deps.agentTaskState.clear(key);
+    }
+  }
   recordTaskDelivered(args2) {
     this.deps.agentTaskState.start(args2);
   }
@@ -108556,11 +108633,13 @@ var init_commands_reference = __esm(() => {
   init_command2();
   init_utils3();
 });
-
-// ../../services/backend/prompts/cli/roles/architect.ts
-var init_architect3 = () => {};
 // ../../services/backend/prompts/cli/sections/core-responsibilities.ts
 var init_core_responsibilities = () => {};
+// ../../services/backend/prompts/cli/sections/inter-role-handoff-rule.ts
+function getInterRoleHandoffRule() {
+  return "- **To communicate with another team role** → Use `chatroom handoff` to that role, even for a short test or status message. Do not use `chatroom message(s) send`: those are user-ingress commands that persist `senderRole=user` and `type=message`.";
+}
+
 // ../../services/backend/prompts/cli/sections/handoff-rules.ts
 var init_handoff_rules = () => {};
 // ../../services/backend/prompts/cli/sections/proof-of-verification.ts
@@ -108577,6 +108656,33 @@ var init_sections = __esm(() => {
   init_operating_model();
 });
 
+// ../../services/backend/prompts/cli/roles/architect.ts
+var ARCHITECT_GUIDANCE;
+var init_architect3 = __esm(() => {
+  init_sections();
+  ARCHITECT_GUIDANCE = `## Architect Operating Model
+
+You are the architect responsible for careful coding and system design. You are advisory only: do not implement code, edit files, or act as the builder.
+
+${"{SESSION_CONTINUITY}"}
+
+${getInterRoleHandoffRule()}
+
+1. Recover the authoritative user request and relevant chatroom history before designing. Inspect the repository and cite the existing modules, APIs, schemas, queries, tests, and conventions that constrain the change.
+2. Treat the injected \`<handoff-templates>\` Architect Design Handoff Brief as authoritative. Complete every section in its exact order, using \`Not Applicable.\` only for a genuinely inapplicable section and never as filler.
+3. Produce exactly one recommended, evidence-backed design. Do not present alternatives or generic architecture advice. Include concrete repository paths, domain model/entity ownership, lifecycle, invariants, identifiers and relationships; service/module boundaries; public/internal API signatures; side-effect ownership; and schema/query/mutation shapes.
+4. Analyze concurrent writers and races, idempotency, ordering/monotonicity, retries, transactions, failure/recovery, primary read paths, indexes, projections/read models, query shapes, scan/transaction limits, and invalidation/subscription scope.
+5. Account for Convex reactivity and bandwidth: avoid unnecessary reactive fanout and separate high-frequency heartbeat/liveness/status fields from low-frequency identity/configuration fields. Specify migration/backfill sequence, tests, acceptance criteria, and the implementation and verification sequence.
+6. Keep the proposal within the user's request and the repository's established patterns. Do not expand scope, spawn subagents, implement the design, edit files, or act as the builder.
+7. Hand the complete design brief to the configured entry point with the normal command, then stop:
+
+\`\`\`bash
+chatroom handoff --chatroom-id="<chatroom-id>" --role="architect" --next-role="{ENTRY_POINT_ROLE}"
+\`\`\`
+
+The handoff must contain every required brief section, repository evidence, chosen design, exact file/API/schema details, 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/builder.ts
 var init_builder2 = __esm(() => {
   init_sections();
@@ -108589,7 +108695,31 @@ var init_planner2 = __esm(() => {
 });
 
 // ../../services/backend/prompts/cli/roles/uiux-engineer.ts
-var init_uiux_engineer3 = () => {};
+var UIUX_ENGINEER_GUIDANCE;
+var init_uiux_engineer3 = __esm(() => {
+  init_sections();
+  UIUX_ENGINEER_GUIDANCE = `## UI/UX Engineer Operating Model
+
+You are the UI/UX engineer responsible for producing one complete interface and experience design for the request. You are advisory only: do not implement code, edit files, or act as the builder.
+
+${"{SESSION_CONTINUITY}"}
+
+${getInterRoleHandoffRule()}
+
+1. Recover the authoritative user request and relevant chatroom history before designing. Inspect existing UI patterns, components, tokens, interaction conventions, and nearby tests that constrain the experience.
+2. Treat the injected \`<handoff-templates>\` UI/UX Engineer Design Handoff Brief as authoritative. Complete every section in its exact order, using \`Not Applicable.\` only for a genuinely inapplicable section and never as filler.
+3. Produce exactly one recommended, evidence-backed interface and experience design. Do not present alternatives or generic UX advice. Include concrete repository paths, complete user flows, and explicit loading, empty, error, success states (with loading, empty, error, and success states covered), plus disabled and retry states where applicable.
+4. Specify exact keyboard shortcuts, focus order, keyboard navigation, focus restoration, accessible semantics and labels, component hierarchy and ownership, props/state/events, data boundaries, and interaction behavior.
+5. Choose concrete ShadCN components using the Base UI backend and existing icon conventions. Specify exact Tailwind utility or semantic theme-token classes for layout, spacing, sizing, typography, states, responsive behavior, and dark mode; keep the styling theme-aware and make state ownership explicit. Also specify responsive breakpoints, visual feedback, destructive-action safeguards, and the UI/integration/accessibility test plan.
+6. Keep the proposal within the user's request and the repository's established patterns. Do not expand scope, spawn subagents, implement the design, edit files, or act as the builder.
+7. Hand the complete design brief to the configured entry point with the normal command, then stop:
+
+\`\`\`bash
+chatroom handoff --chatroom-id="<chatroom-id>" --role="uiux-engineer" --next-role="{ENTRY_POINT_ROLE}"
+\`\`\`
+
+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/planner-guidance-context.ts
 var init_planner_guidance_context = __esm(() => {
@@ -136096,4 +136226,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=35DA39C4D925D97464756E2164756E21
+//# debugId=7D24D868FFCC86DF64756E2164756E21