chatroom-cli 1.128.1 → 1.129.1

package/dist/index.js

@@ -20403,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 }]));
@@ -99882,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"
     }
@@ -100973,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(() => {
@@ -100983,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,
@@ -101044,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(() => {
@@ -101188,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,
@@ -101195,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 = (() => {
@@ -101240,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,
@@ -101285,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;
@@ -101302,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 = (() => {
@@ -101858,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();
@@ -101881,6 +102053,7 @@ var init_fromContext2 = __esm(() => {
   init_planner2();
   init_researcher2();
   init_uiux_engineer3();
+  init_verifier3();
   init_fromContext();
 });
 
@@ -101970,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",
@@ -111106,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);
@@ -111497,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:
@@ -111572,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}`);
       }
@@ -111608,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(`
@@ -138270,4 +138448,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=7C84BEF97B16C1D064756E2164756E21
+//# debugId=8506C14FCD932D1964756E2164756E21