@tritard/waterbrother 0.16.97 → 0.16.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.16.97",
+  "version": "0.16.99",
   "description": "Waterbrother: bring-your-own-model coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/gateway.js

@@ -9,7 +9,7 @@ import { DEFAULT_PENDING_PAIRING_TTL_MINUTES, loadGatewayBridge, loadGatewayStat
 import { getGatewayStatus, getChannelSpec } from "./channels.js";
 import { getConfigPath, loadConfigLayers, saveConfig } from "./config.js";
 import { canonicalizeLoosePath } from "./path-utils.js";
-import { acceptSharedInvite, addSharedRoomNote, addSharedTask, approveSharedInvite, assignSharedTask, claimSharedOperator, claimSharedTask, commentSharedTask, createSharedInvite, enableSharedProject, getSharedTaskHistory, listSharedEvents, listSharedInvites, listSharedTasks, loadSharedProject, moveSharedTask, rejectSharedInvite, releaseSharedOperator, setSharedRoom, setSharedRoomMode, setSharedRuntimeProfile, removeSharedMember, upsertSharedAgent, upsertSharedMember } from "./shared-project.js";
+import { acceptSharedInvite, addSharedRoomNote, addSharedTask, addVerificationResult, approveSharedInvite, assignSharedTask, claimSharedOperator, claimSharedTask, commentSharedTask, createSharedInvite, enableSharedProject, getLatestVerificationResult, getSharedTaskHistory, listSharedEvents, listSharedInvites, listSharedTasks, loadSharedProject, moveSharedTask, rejectSharedInvite, releaseSharedOperator, removeSharedMember, setSharedRoom, setSharedRoomMode, setSharedRuntimeProfile, setSharedVerificationMode, upsertSharedAgent, upsertSharedMember } from "./shared-project.js";
 import { buildSelfAwarenessManifest, formatAboutWaterbrother, formatSelfState, resolveLocalConceptQuestion } from "./self-awareness.js";
 
 const execFileAsync = promisify(execFile);
@@ -296,6 +296,7 @@ function buildTelegramRoomOnboardingMarkup({ project = null, actorName = "", exe
   const participants = listProjectParticipants(project);
   const agents = listProjectAgents(project);
   const reviewer = chooseReviewerAgent(project);
+  const verifier = chooseVerifierAgent(project);
   const blockingReview = getLatestBlockingReviewPolicy(project);
   return [
     "<b>Roundtable room</b>",
@@ -305,6 +306,7 @@ function buildTelegramRoomOnboardingMarkup({ project = null, actorName = "", exe
     `agents: <code>${escapeTelegramHtml(String(agents.length || 0))}</code>`,
     executor?.provider && executor?.model ? `active runtime: <code>${escapeTelegramHtml(`${executor.provider}/${executor.model}`)}</code>` : "",
     reviewer ? `reviewer: <code>${escapeTelegramHtml(reviewer.ownerName || reviewer.label || reviewer.ownerId || reviewer.id || "unknown")}</code>` : "",
+    verifier ? `verifier: <code>${escapeTelegramHtml(verifier.ownerName || verifier.label || verifier.ownerId || verifier.id || "unknown")}</code>` : "",
     `blocking review: <code>${escapeTelegramHtml(blockingReview ? "yes" : "no")}</code>`,
     "",
     "<b>What you can do here</b>",
@@ -312,6 +314,7 @@ function buildTelegramRoomOnboardingMarkup({ project = null, actorName = "", exe
     "• ask <code>who is in the room?</code>",
     "• say <code>add Austin as editor</code>",
     "• ask <code>which terminals are live?</code>",
+    "• say <code>run verification</code>",
     "• in execute mode, address Waterbrother directly to build or change code",
     "",
     "Use <code>/help</code> for the full command list."
@@ -336,7 +339,9 @@ function buildTelegramRoomGuidanceMarkup({ project = null, member = null, execut
     "• <code>what project is this chat bound to?</code>",
     "• <code>who is in the room?</code>",
     "• <code>who are the bots?</code>",
-    role === "owner" ? "• <code>add Austin as editor</code>" : "• <code>what mode are we in?</code>"
+    role === "owner" ? "• <code>add Austin as editor</code>" : "• <code>what mode are we in?</code>",
+    "• <code>who is the verifier?</code>",
+    "• <code>run verification</code>"
   ].filter(Boolean).join("\n");
 }
 
@@ -353,6 +358,8 @@ function buildTelegramAgentAnnouncementMarkup(event = {}) {
     ? "This terminal is the selected executor and can take room work when it is live."
     : role === "reviewer"
       ? "This terminal is the room reviewer and can be asked for a second opinion or blocking review."
+      : role === "verifier"
+        ? "This terminal is the verifier and can run tests, checks, and build verification for the room."
       : "This terminal is on standby until the room assigns it a more active role.";
   return [
     `<b>${escapeTelegramHtml(title)}</b>`,
@@ -363,7 +370,7 @@ function buildTelegramAgentAnnouncementMarkup(event = {}) {
     runtime ? `runtime: <code>${escapeTelegramHtml(runtime)}</code>` : "",
     meta.runtimeProfile ? `runtime profile: <code>${escapeTelegramHtml(String(meta.runtimeProfile || ""))}</code>` : "",
     roleGuidance,
-    "Examples: <code>which terminals are live?</code>, <code>make this terminal the reviewer</code>, <code>make this terminal the executor</code>"
+    "Examples: <code>which terminals are live?</code>, <code>make this terminal the reviewer</code>, <code>make this terminal the verifier</code>, <code>make this terminal the executor</code>"
   ].filter(Boolean).join("\n");
 }
 
@@ -502,6 +509,32 @@ function summarizeRuntimeConflict(project, fallbackExecutor = {}) {
   };
 }
 
+function cleanAgentDisplayValue(value = "") {
+  const cleaned = String(value || "").replace(/\bundefined\b/ig, "").trim();
+  if (!cleaned) return "";
+  if (/^terminal$/i.test(cleaned)) return "";
+  return cleaned;
+}
+
+function getAgentOwnerDisplay(agent = {}, fallback = "") {
+  const ownerName = cleanAgentDisplayValue(agent?.ownerName);
+  const ownerId = cleanAgentDisplayValue(agent?.ownerId);
+  const label = cleanAgentDisplayValue(agent?.label);
+  const fallbackValue = cleanAgentDisplayValue(fallback);
+  return ownerName || ownerId || fallbackValue || label || "unknown";
+}
+
+function getAgentTerminalDisplay(agent = {}, fallback = "") {
+  const label = cleanAgentDisplayValue(agent?.label);
+  const fallbackValue = cleanAgentDisplayValue(fallback);
+  if (label) return label;
+  if (fallbackValue) return fallbackValue;
+  const ownerName = cleanAgentDisplayValue(agent?.ownerName);
+  if (ownerName) return ownerName + " terminal";
+  const ownerId = cleanAgentDisplayValue(agent?.ownerId);
+  if (ownerId) return ownerId + " terminal";
+  return "current terminal";
+}
 function formatBridgeHostLabel(host = {}) {
   const owner = String(host?.ownerName || host?.ownerId || "").trim();
   const label = String(host?.label || "").trim();
@@ -526,6 +559,11 @@ function chooseReviewerAgent(project) {
   return agents.find((agent) => String(agent?.role || "").trim() === "reviewer") || null;
 }
 
+function chooseVerifierAgent(project) {
+  const agents = listProjectAgents(project);
+  return agents.find((agent) => String(agent?.role || "").trim() === "verifier") || null;
+}
+
 function summarizeExecutorReviewerArbitration(project, fallbackExecutor = {}) {
   const executorAgent = chooseExecutorAgent(project, fallbackExecutor);
   const reviewerAgent = chooseReviewerAgent(project);
@@ -541,6 +579,29 @@ function summarizeExecutorReviewerArbitration(project, fallbackExecutor = {}) {
   };
 }
 
+function formatVerificationResultMarkup(result = {}, verifier = null) {
+  const lines = [
+    "<b>Verification result</b>",
+    `outcome: <code>${escapeTelegramHtml(String(result.outcome || "failed"))}</code>`
+  ];
+  if (verifier) {
+    lines.splice(1, 0, `verifier: <code>${escapeTelegramHtml(verifier.ownerName || verifier.label || verifier.ownerId || verifier.id || "unknown")}</code>`);
+  }
+  if (Array.isArray(result.commands) && result.commands.length) {
+    lines.push("commands:");
+    for (const command of result.commands) {
+      lines.push(`• <code>${escapeTelegramHtml(command)}</code>`);
+    }
+  }
+  if (result.summary) {
+    lines.push("", "<b>Summary</b>", escapeTelegramHtml(result.summary));
+  }
+  if (Array.isArray(result.logs) && result.logs.length) {
+    lines.push("", "<b>Top errors</b>", ...result.logs.slice(0, 6).map((line) => `• ${escapeTelegramHtml(line)}`));
+  }
+  return lines.filter(Boolean).join("\n");
+}
+
 function parseReviewerOutcome(text = "") {
   const value = String(text || "").trim();
   const lower = value.toLowerCase();
@@ -660,7 +721,11 @@ function formatTelegramProjectMarkup({ cwd, project, chatId = "", title = "" })
 }
 
 function normalizeTelegramProjectIntentText(text = "") {
-  return String(text || "").trim().replace(/\s+/g, " ");
+  return String(text || "")
+    .replace(/[‘’′]/g, "'")
+    .replace(/[“”]/g, '"')
+    .trim()
+    .replace(/\s+/g, " ");
 }
 
 function parseTelegramProjectIntent(text = "") {
@@ -783,15 +848,15 @@ function parseTelegramAgentIntent(text = "") {
     }
   }
 
-  const roleMatch = lowered.match(/\b(executor|reviewer|standby)\b/);
+  const roleMatch = lowered.match(/\b(executor|reviewer|verifier|standby)\b/);
   const role = roleMatch?.[1] || "";
   if (!role) return null;
 
   const patterns = [
-    /^(?:have|make|set)\s+(.+?)['’]s\s+(?:bot|terminal)\s+(?:be|as|to)?\s*(?:the\s+)?(executor|reviewer|standby)\s*$/i,
-    /^(?:have|make|set)\s+(.+?)\s+(?:bot|terminal)\s+(?:be|as|to)?\s*(?:the\s+)?(executor|reviewer|standby)\s*$/i,
-    /^(.+?)['’]s\s+(?:bot|terminal)\s+should\s+(?:be\s+)?(?:the\s+)?(executor|reviewer|standby)\s*$/i,
-    /^(.+?)\s+(?:bot|terminal)\s+should\s+(?:be\s+)?(?:the\s+)?(executor|reviewer|standby)\s*$/i
+    /^(?:have|make|set)\s+(.+?)['’]s\s+(?:bot|terminal)\s+(?:be|as|to)?\s*(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i,
+    /^(?:have|make|set)\s+(.+?)\s+(?:bot|terminal)\s+(?:be|as|to)?\s*(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i,
+    /^(.+?)['’]s\s+(?:bot|terminal)\s+should\s+(?:be\s+)?(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i,
+    /^(.+?)\s+(?:bot|terminal)\s+should\s+(?:be\s+)?(?:the\s+)?(executor|reviewer|verifier|standby)\s*$/i
   ];
   for (const pattern of patterns) {
     const match = value.match(pattern);
@@ -834,9 +899,28 @@ function parseTelegramStateIntent(text = "") {
   if (/\bwhat can i do here\b/.test(lower) || /\bhow do i use this room\b/.test(lower) || /\bhow do i use this chat\b/.test(lower) || /\bwhat do i do here\b/.test(lower)) {
     return { action: "room-guidance" };
   }
+  if (/\bwho(?:'s| is)? the verifier\b/.test(lower) || /\bwhat is the verifier\b/.test(lower) || /\bwho should verify this\b/.test(lower)) {
+    return { action: "verifier-status" };
+  }
   if (/\bwho are the (?:bots|boys)\b/.test(lower) || /\bwho are the agents\b/.test(lower) || /\bwhat (?:bots|boys) are here\b/.test(lower) || /\bwhat agents are here\b/.test(lower)) {
     return { action: "agent-list" };
   }
+  if (/^(?:run|start|do)\s+verification\b/.test(lower) || /^(?:verify)\b/.test(lower) || /\bshow latest verification result\b/.test(lower) || /\bdid verification pass\b/.test(lower)) {
+    return { action: /\bshow latest verification result\b/.test(lower) || /\bdid verification pass\b/.test(lower) ? "verification-status" : "run-verification" };
+  }
+  if (/\bverification mode\b/.test(lower)) {
+    const modeMatch = lower.match(/\b(off|manual|auto|blocking)\b/);
+    return modeMatch?.[1] ? { action: "verification-mode-set", mode: modeMatch[1] } : { action: "verification-mode-status" };
+  }
+  if (/\balways verify after execution\b/.test(lower)) {
+    return { action: "verification-mode-set", mode: "auto" };
+  }
+  if (/\bturn off verification\b/.test(lower)) {
+    return { action: "verification-mode-set", mode: "off" };
+  }
+  if (/\bverification should be blocking\b/.test(lower)) {
+    return { action: "verification-mode-set", mode: "blocking" };
+  }
   if (/\bwhich terminals are live\b/.test(lower) || /\bwhich bots are live\b/.test(lower) || /\bwho is live\b/.test(lower) || /\bwhat terminals are live\b/.test(lower)) {
     return { action: "live-hosts" };
   }
@@ -980,11 +1064,14 @@ function formatTelegramRoomMarkup(project, options = {}) {
   const liveHosts = Array.isArray(options.liveHosts) ? options.liveHosts : [];
   const selectedExecutor = chooseExecutorAgent(project, executor);
   const selectedReviewer = chooseReviewerAgent(project);
+  const selectedVerifier = chooseVerifierAgent(project);
   const blockingReview = getLatestBlockingReviewPolicy(project);
   const latestReviewResult = getLatestReviewResult(project);
   const latestReviewMeta = latestReviewResult?.meta && typeof latestReviewResult.meta === "object" ? latestReviewResult.meta : {};
+  const latestVerificationResult = getLatestVerificationResult(project);
   const selectedExecutorLiveHost = selectedExecutor ? findLiveHostForAgent(liveHosts, selectedExecutor) : null;
   const selectedReviewerLiveHost = selectedReviewer ? findLiveHostForAgent(liveHosts, selectedReviewer) : null;
+  const selectedVerifierLiveHost = selectedVerifier ? findLiveHostForAgent(liveHosts, selectedVerifier) : null;
   const executorBits = [
     `surface: <code>${escapeTelegramHtml(executor.surface || "telegram")}</code>`,
     `provider: <code>${escapeTelegramHtml(executor.provider || "unknown")}</code>`,
@@ -1012,8 +1099,12 @@ function formatTelegramRoomMarkup(project, options = {}) {
     `executor live: <code>${escapeTelegramHtml(selectedExecutorLiveHost ? "yes" : "no")}</code>`,
     `reviewer: <code>${escapeTelegramHtml(selectedReviewer ? (selectedReviewer.ownerName || selectedReviewer.label || selectedReviewer.ownerId || selectedReviewer.id || "none") : "none")}</code>`,
     `reviewer live: <code>${escapeTelegramHtml(selectedReviewerLiveHost ? "yes" : "no")}</code>`,
+    `verifier: <code>${escapeTelegramHtml(selectedVerifier ? (selectedVerifier.ownerName || selectedVerifier.label || selectedVerifier.ownerId || selectedVerifier.id || "none") : "none")}</code>`,
+    `verifier live: <code>${escapeTelegramHtml(selectedVerifierLiveHost ? "yes" : "no")}</code>`,
     `blocking review: <code>${escapeTelegramHtml(blockingReview ? "yes" : "no")}</code>`,
     `latest reviewer outcome: <code>${escapeTelegramHtml(String(latestReviewMeta.outcome || "").trim() || "none")}</code>`,
+    `verification mode: <code>${escapeTelegramHtml(String(project.verificationMode || "manual"))}</code>`,
+    `latest verification outcome: <code>${escapeTelegramHtml(String(latestVerificationResult?.outcome || "").trim() || "none")}</code>`,
     "<b>Executor</b>",
     ...executorBits,
     "<b>Runtime Split</b>",
@@ -1946,7 +2037,31 @@ class TelegramGateway {
       throw new Error("Only a shared-project owner can change terminal roles.");
     }
     const actor = this.describeTelegramUser(message?.from || {});
-    const targetAgent = resolveProjectAgent(project, intent.target);
+    const normalizedTarget = String(intent.target || "").trim().toLowerCase();
+    let targetAgent = resolveProjectAgent(project, intent.target);
+    if (!targetAgent && /^(?:this|my)(?:\s+(?:bot|terminal))?$/.test(normalizedTarget)) {
+      const host = await this.getLiveBridgeHost();
+      if (host) {
+        targetAgent = listProjectAgents(project).find((agent) => (
+          String(agent?.sessionId || "").trim() && String(agent.sessionId || "").trim() === String(host.sessionId || "").trim()
+        ) || (
+          String(agent?.ownerId || "").trim() && String(agent.ownerId || "").trim() === String(host.ownerId || "").trim()
+        )) || {
+          id: `agent:telegram-bridge:${String(host.sessionId || host.pid || "current").trim()}`,
+          ownerId: String(host.ownerId || actor.userId || "").trim(),
+          ownerName: getAgentOwnerDisplay(host, actor.displayName || actor.userId || "current operator"),
+          label: getAgentTerminalDisplay(host, actor.displayName ? actor.displayName + " terminal" : (actor.userId ? actor.userId + " terminal" : "current terminal")),
+          surface: String(host.surface || "live-tui").trim(),
+          role: "standby",
+          provider: String(host.provider || "").trim(),
+          model: String(host.model || "").trim(),
+          runtimeProfile: String(host.runtimeProfile || "").trim(),
+          sessionId: String(host.sessionId || "").trim(),
+          cwd: String(session.cwd || this.cwd).trim(),
+          chatId: String(message?.chat?.id || "").trim()
+        };
+      }
+    }
     if (!targetAgent) {
       throw new Error(`No terminal found for ${intent.target}. Ask them to connect their Waterbrother bot/terminal first.`);
     }
@@ -1958,26 +2073,30 @@ class TelegramGateway {
       actorName: actor.displayName || actorId
     });
     const runtimeLabel = targetAgent.provider && targetAgent.model ? `${targetAgent.provider}/${targetAgent.model}` : "unknown";
-    const actionTitle = intent.action === "agent-review"
+    const actionTitle = intent.action === "agent-review" || intent.role === "reviewer"
       ? "Roundtable reviewer assigned"
-      : intent.action === "agent-execute"
+      : intent.action === "agent-execute" || intent.role === "executor"
         ? "Roundtable executor assigned"
-        : "Roundtable terminal updated";
-    const note = intent.action === "agent-review"
+        : intent.role === "verifier"
+          ? "Roundtable verifier assigned"
+          : "Roundtable terminal updated";
+    const note = intent.action === "agent-review" || intent.role === "reviewer"
       ? "This sets the room reviewer role. It does not automatically run a review pass yet."
-      : intent.action === "agent-execute"
+      : intent.action === "agent-execute" || intent.role === "executor"
         ? "This sets the room executor role. Claim/mode rules still control actual execution."
-        : "";
-    const followUp = intent.action === "agent-review"
-      ? `Should ${targetAgent.ownerName || targetAgent.label || "that terminal"} review be advisory or blocking?`
+        : intent.role === "verifier"
+          ? "This sets the room verifier role. Use run verification when you want Waterbrother to run tests or build checks."
+          : "";
+    const followUp = intent.action === "agent-review" || intent.role === "reviewer"
+      ? `Should ${getAgentOwnerDisplay(targetAgent, actor.displayName || actor.userId || "that terminal")} review be advisory or blocking?`
       : "";
     return {
       kind: "agent",
       project: nextProject,
       markup: [
         `<b>${escapeTelegramHtml(actionTitle)}</b>`,
-        `owner: <code>${escapeTelegramHtml(targetAgent.ownerName || targetAgent.ownerId || targetAgent.label || targetAgent.id || "-")}</code>`,
-        `terminal: <code>${escapeTelegramHtml(targetAgent.label || targetAgent.id || "-")}</code>`,
+        `owner: <code>${escapeTelegramHtml(getAgentOwnerDisplay(targetAgent, actor.displayName || actor.userId || "current operator"))}</code>`,
+        `terminal: <code>${escapeTelegramHtml(getAgentTerminalDisplay(targetAgent, actor.displayName ? actor.displayName + " terminal" : "current terminal"))}</code>`,
         `role: <code>${escapeTelegramHtml(intent.role)}</code>`,
         `runtime: <code>${escapeTelegramHtml(runtimeLabel)}</code>`,
         `project: <code>${escapeTelegramHtml(nextProject.projectName || path.basename(session.cwd || this.cwd))}</code>`,
@@ -2245,6 +2364,7 @@ class TelegramGateway {
       runtimeProfile: host?.runtimeProfile || project?.runtimeProfile || this.channel.defaultRuntimeProfile || this.gateway.defaultRuntimeProfile || "",
       hostSessionId: host?.sessionId || ""
     };
+    const verifier = chooseVerifierAgent(project);
 
     if (intent.action === "bot-status") {
       const lines = [
@@ -2272,6 +2392,68 @@ class TelegramGateway {
       ].join("\n");
     }
 
+    if (intent.action === "verifier-status") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      if (!verifier) {
+        return [
+          "<b>Verifier</b>",
+          "No verifier is assigned yet.",
+          "Try: <code>make this terminal the verifier</code>"
+        ].join("\n");
+      }
+      return [
+        "<b>Verifier</b>",
+        `verifier: <code>${escapeTelegramHtml(getAgentOwnerDisplay(verifier))}</code>`,
+        `role: <code>${escapeTelegramHtml(verifier.role || "verifier")}</code>`,
+        `runtime: <code>${escapeTelegramHtml(verifier.provider && verifier.model ? `${verifier.provider}/${verifier.model}` : "unknown")}</code>`,
+        `verification mode: <code>${escapeTelegramHtml(String(project.verificationMode || "manual"))}</code>`
+      ].join("\n");
+    }
+
+    if (intent.action === "verification-mode-status") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      return [
+        "<b>Verification mode</b>",
+        `mode: <code>${escapeTelegramHtml(String(project.verificationMode || "manual"))}</code>`
+      ].join("\n");
+    }
+
+    if (intent.action === "verification-mode-set") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      const next = await setSharedVerificationMode(cwd, intent.mode, { actorId, actorName });
+      return [
+        "<b>Verification mode</b>",
+        `mode: <code>${escapeTelegramHtml(String(next.verificationMode || intent.mode || "manual"))}</code>`
+      ].join("\n");
+    }
+
+    if (intent.action === "verification-status") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      const result = getLatestVerificationResult(project);
+      if (!result) {
+        return "<b>Verification result</b>\nNo verification result is on record yet.";
+      }
+      return formatVerificationResultMarkup(result, verifier);
+    }
+
+    if (intent.action === "run-verification") {
+      if (!project?.enabled) {
+        return "This project is not shared.";
+      }
+      const result = await this.runLocalVerification(cwd, verifier);
+      const nextProject = await addVerificationResult(cwd, result, { actorId, actorName });
+      const latest = getLatestVerificationResult(nextProject) || result;
+      return formatVerificationResultMarkup(latest, verifier);
+    }
+
     if (intent.action === "accept-reviewer-concerns") {
       if (!project?.enabled) {
         return "This project is not shared.";
@@ -3146,6 +3328,75 @@ class TelegramGateway {
     return JSON.parse(stdout);
   }
 
+  async planVerificationCommands(cwd) {
+    const packageJsonPath = path.join(cwd, "package.json");
+    let scripts = {};
+    try {
+      const raw = await fs.readFile(packageJsonPath, "utf8");
+      const parsed = JSON.parse(raw);
+      scripts = parsed?.scripts && typeof parsed.scripts === "object" ? parsed.scripts : {};
+    } catch {}
+    const commands = [];
+    if (scripts.check) commands.push(["npm", ["run", "check"], "npm run check"]);
+    if (scripts.test) commands.push(["npm", ["test"], "npm test"]);
+    if (scripts.build) commands.push(["npm", ["run", "build"], "npm run build"]);
+    if (!commands.length) {
+      throw new Error("No verification commands are available here. Expected package.json scripts like check, test, or build.");
+    }
+    return commands;
+  }
+
+  async runLocalVerification(cwd, verifier = null) {
+    const planned = await this.planVerificationCommands(cwd);
+    const commands = [];
+    const startedAt = new Date().toISOString();
+    const logs = [];
+    let passedCount = 0;
+    for (const [bin, args, label] of planned) {
+      commands.push(label);
+      try {
+        await execFileAsync(bin, args, {
+          cwd,
+          env: { ...process.env },
+          maxBuffer: 8 * 1024 * 1024,
+          timeout: 10 * 60 * 1000
+        });
+        passedCount += 1;
+      } catch (error) {
+        const combined = `${String(error?.stderr || "")}\n${String(error?.stdout || "")}`.trim();
+        const extracted = combined
+          .split("\n")
+          .map((line) => String(line || "").trim())
+          .filter(Boolean)
+          .slice(0, 6);
+        logs.push(...extracted);
+        const outcome = error?.killed || error?.signal === "SIGTERM" ? "timeout" : (passedCount > 0 ? "partial" : "failed");
+        return {
+          id: "",
+          workItemId: "",
+          verifierAgentId: String(verifier?.id || "").trim(),
+          outcome,
+          summary: `${label} failed${passedCount > 0 ? ` after ${passedCount} passing check${passedCount === 1 ? "" : "s"}` : ""}.`,
+          commands,
+          startedAt,
+          completedAt: new Date().toISOString(),
+          logs
+        };
+      }
+    }
+    return {
+      id: "",
+      workItemId: "",
+      verifierAgentId: String(verifier?.id || "").trim(),
+      outcome: "passed",
+      summary: `${commands.length} verification command${commands.length === 1 ? "" : "s"} passed.`,
+      commands,
+      startedAt,
+      completedAt: new Date().toISOString(),
+      logs: []
+    };
+  }
+
   async startTypingLoop(chatId) {
     let stopped = false;
     const tick = async () => {

package/src/shared-project.js

@@ -8,7 +8,9 @@ const ROUNDTABLE_FILE = "ROUNDTABLE.md";
 const TASK_STATES = ["open", "active", "blocked", "done"];
 const RECENT_EVENT_LIMIT = 24;
 const PARTICIPANT_ROLES = ["owner", "editor", "observer"];
-const AGENT_ROLES = ["executor", "reviewer", "standby", "coordinator"];
+const AGENT_ROLES = ["executor", "reviewer", "verifier", "standby", "coordinator"];
+const VERIFICATION_MODES = ["off", "manual", "auto", "blocking"];
+const VERIFICATION_RESULT_LIMIT = 50;
 
 function makeId(prefix = "id") {
   return `${prefix}_${crypto.randomBytes(3).toString("hex")}`;
@@ -73,6 +75,37 @@ function normalizeAgent(agent = {}) {
   };
 }
 
+function normalizeVerificationResult(result = {}) {
+  const commands = Array.isArray(result.commands)
+    ? result.commands.map((item) => String(item || "").trim()).filter(Boolean)
+    : [];
+  const logs = Array.isArray(result.logs)
+    ? result.logs.map((item) => String(item || "").trim()).filter(Boolean)
+    : [];
+  const artifacts = Array.isArray(result.artifacts)
+    ? result.artifacts
+        .map((artifact) => ({
+          label: String(artifact?.label || "").trim(),
+          path: String(artifact?.path || "").trim(),
+          url: String(artifact?.url || "").trim()
+        }))
+        .filter((artifact) => artifact.label || artifact.path || artifact.url)
+    : [];
+  const outcome = String(result.outcome || "").trim().toLowerCase();
+  return {
+    id: String(result.id || makeId("vr")).trim(),
+    workItemId: String(result.workItemId || "").trim(),
+    verifierAgentId: String(result.verifierAgentId || "").trim(),
+    outcome: ["passed", "failed", "partial", "timeout"].includes(outcome) ? outcome : "failed",
+    summary: String(result.summary || "").trim(),
+    commands,
+    startedAt: String(result.startedAt || new Date().toISOString()).trim(),
+    completedAt: String(result.completedAt || result.startedAt || new Date().toISOString()).trim(),
+    logs,
+    artifacts
+  };
+}
+
 function isBrokenAgent(agent = {}) {
   const ownerId = String(agent.ownerId || "").trim();
   const ownerName = String(agent.ownerName || "").trim();
@@ -217,6 +250,12 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
     : null;
   const participants = buildProjectParticipants({ ...project, members });
   const agents = buildProjectAgents({ ...project, members, activeOperator });
+  const verificationResults = Array.isArray(project.verificationResults)
+    ? project.verificationResults
+        .map((item) => normalizeVerificationResult(item))
+        .filter((item) => item.id)
+        .slice(-VERIFICATION_RESULT_LIMIT)
+    : [];
 
   return {
     version: 1,
@@ -233,10 +272,15 @@ function normalizeSharedProject(project = {}, cwd = process.cwd()) {
     roomMode: ["chat", "plan", "execute"].includes(String(project.roomMode || "").trim())
       ? String(project.roomMode).trim()
       : "chat",
+    verificationMode: VERIFICATION_MODES.includes(String(project.verificationMode || "").trim())
+      ? String(project.verificationMode).trim()
+      : "manual",
     runtimeProfile: String(project.runtimeProfile || "").trim(),
     members,
     participants,
     agents,
+    verificationResults,
+    latestVerificationResultId: String(project.latestVerificationResultId || "").trim(),
     tasks,
     pendingInvites,
     recentEvents,
@@ -576,6 +620,25 @@ export async function setSharedRuntimeProfile(cwd, runtimeProfile = "", options
   })).project;
 }
 
+export async function setSharedVerificationMode(cwd, verificationMode = "manual", options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireOwner(existing, options.actorId);
+  const normalized = String(verificationMode || "").trim().toLowerCase();
+  if (!VERIFICATION_MODES.includes(normalized)) {
+    throw new Error(`Invalid verification mode. Expected one of ${VERIFICATION_MODES.join(", ")}.`);
+  }
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    verificationMode: normalized
+  });
+  return (await recordSharedProjectEvent(cwd, next, `verification mode set to ${normalized}`, {
+    type: "verification-mode",
+    actorId: String(options.actorId || "").trim(),
+    actorName: String(options.actorName || "").trim(),
+    meta: { verificationMode: normalized }
+  })).project;
+}
+
 export function getSharedMember(project, memberId = "") {
   const normalizedId = String(memberId || "").trim();
   if (!normalizedId || !project?.members?.length) return null;
@@ -702,6 +765,46 @@ export async function upsertSharedAgent(cwd, agent = {}, options = {}) {
   })).project;
 }
 
+export function getLatestVerificationResult(project) {
+  const latestId = String(project?.latestVerificationResultId || "").trim();
+  const results = Array.isArray(project?.verificationResults) ? project.verificationResults : [];
+  if (latestId) {
+    const exact = results.find((result) => String(result?.id || "").trim() === latestId);
+    if (exact) return exact;
+  }
+  return [...results].sort((a, b) => String(b.completedAt || "").localeCompare(String(a.completedAt || "")))[0] || null;
+}
+
+export async function addVerificationResult(cwd, result = {}, options = {}) {
+  const existing = await loadSharedProject(cwd);
+  requireSharedProject(existing);
+  if (options.actorId) {
+    requireMember(existing, options.actorId);
+  }
+  const verificationResult = normalizeVerificationResult(result);
+  const verificationResults = [...(existing.verificationResults || []), verificationResult].slice(-VERIFICATION_RESULT_LIMIT);
+  const next = await saveSharedProject(cwd, {
+    ...existing,
+    verificationResults,
+    latestVerificationResultId: verificationResult.id
+  });
+  return (await recordSharedProjectEvent(
+    cwd,
+    next,
+    `verification ${verificationResult.outcome} [${verificationResult.id}] ${verificationResult.summary || "result recorded"}`.trim(),
+    {
+      type: "verification-result",
+      actorId: String(options.actorId || "").trim(),
+      actorName: String(options.actorName || "").trim(),
+      meta: {
+        verificationResultId: verificationResult.id,
+        verifierAgentId: verificationResult.verifierAgentId,
+        outcome: verificationResult.outcome
+      }
+    }
+  )).project;
+}
+
 export async function addSharedRoomNote(cwd, text = "", options = {}) {
   const existing = await loadSharedProject(cwd);
   requireSharedProject(existing);
@@ -1123,12 +1226,15 @@ export function formatSharedProjectStatus(project) {
     room: project.room,
     mode: project.mode,
     roomMode: project.roomMode,
+    verificationMode: project.verificationMode,
     runtimeProfile: project.runtimeProfile,
     approvalPolicy: project.approvalPolicy,
     activeOperator: project.activeOperator,
     members: project.members,
     participants: project.participants,
     agents: project.agents,
+    verificationResults: project.verificationResults,
+    latestVerificationResultId: project.latestVerificationResultId,
     pendingInvites: project.pendingInvites,
     tasks: project.tasks,
     recentEvents: project.recentEvents