@wrongstack/cli 0.305.1 → 0.306.2

package/dist/{execution-QYFWDD3Y.js → execution-4IG5XKOL.js}

@@ -5,9 +5,10 @@ import {
   normalizeTuiThinkingWord,
   resolveActualTarget,
   resolvePersistPath,
+  runGit,
   setAutoSuggestions,
   setSuggestions
-} from "./chunk-V3XH6XBJ.js";
+} from "./chunk-T6YAVFXA.js";
 import {
   startCliHqConnection
 } from "./chunk-FKWHSFX4.js";
@@ -37,23 +38,24 @@ import {
   writeWebuiSessionChildReady
 } from "./chunk-3JPTNADJ.js";
 import {
-  resolveActiveApiKey
-} from "./chunk-SZ42FYPT.js";
-import {
-  activeProfileConfigPath
-} from "./chunk-YMXXOOFN.js";
+  CLI_VERSION
+} from "./chunk-XJXDOF63.js";
 import {
   terminalLink,
   terminalText
 } from "./chunk-KE7E7DPX.js";
 import {
-  CLI_VERSION
-} from "./chunk-XJXDOF63.js";
+  resolveActiveApiKey
+} from "./chunk-SZ42FYPT.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
 import "./chunk-7OCVIDC7.js";
 
 // src/execution.ts
 import * as path13 from "node:path";
 import { effectiveFallbackChain as effectiveFallbackChain2, setQueuedMessagesSnapshot as setQueuedMessagesSnapshot2 } from "@wrongstack/core/agent";
+import { updateReviewReportEvidence } from "@wrongstack/core/plugin";
 import { attachTodosCheckpoint as attachTodosCheckpoint2 } from "@wrongstack/core/storage";
 import { normalizeTokenSavingTier as normalizeTokenSavingTier2 } from "@wrongstack/core/types";
 import { mergeCustomModelDefs } from "@wrongstack/core/utils";
@@ -2746,6 +2748,128 @@ import * as fsp from "node:fs/promises";
 import * as path10 from "node:path";
 import { emitReviewIfChanged } from "@wrongstack/core/plugin";
 
+// src/chimera-cascade-evidence.ts
+import { spawn as spawn2 } from "node:child_process";
+var JSON_BLOCK_RE = /```json\s*([\s\S]*?)```/gi;
+function extractCascadeEvidence(text) {
+  if (!text) return null;
+  for (const match of text.matchAll(JSON_BLOCK_RE)) {
+    const body = match[1]?.trim();
+    if (!body) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      continue;
+    }
+    const evidence = parseEvidenceObject(parsed);
+    if (evidence) return evidence;
+  }
+  return null;
+}
+function parseEvidenceObject(parsed) {
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const root = parsed;
+  const raw = root.verification_evidence;
+  if (typeof raw !== "object" || raw === null) return null;
+  const checks = raw;
+  const out = {};
+  let found = false;
+  for (const key of ["typecheck", "lint", "tests"]) {
+    const check = parseSingleCheck(checks[key]);
+    if (check) {
+      out[key] = check;
+      found = true;
+    }
+  }
+  return found ? out : null;
+}
+function parseSingleCheck(raw) {
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const check = raw;
+  const command = check.command;
+  const exitCode = check.exitCode;
+  if (typeof command !== "string" || command.trim().length === 0) return void 0;
+  if (typeof exitCode !== "number" || !Number.isInteger(exitCode) || exitCode < 0 || exitCode > 255) {
+    return void 0;
+  }
+  const output = typeof check.output === "string" ? truncateOutput(check.output) : void 0;
+  return { command: command.trim(), exitCode, output };
+}
+var MAX_EVIDENCE_OUTPUT_CHARS = 2e3;
+function truncateOutput(output) {
+  return output.length > MAX_EVIDENCE_OUTPUT_CHARS ? `${output.slice(0, MAX_EVIDENCE_OUTPUT_CHARS)}
+\u2026 (truncated)` : output;
+}
+var SAFE_EXECUTABLES = /* @__PURE__ */ new Set([
+  "pnpm",
+  "npm",
+  "yarn",
+  "npx",
+  "bun",
+  "node",
+  "tsc",
+  "biome",
+  "eslint",
+  "vitest",
+  "jest"
+]);
+var CASCADE_EVIDENCE_COMMAND_TIMEOUT_MS = 12e4;
+var CASCADE_EVIDENCE_UNSAFE_EXIT = 126;
+var CASCADE_EVIDENCE_RUN_ERROR_EXIT = 127;
+function isSafeCascadeCommand(command) {
+  if (!command || command.length > 500) return false;
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0) return false;
+  if (!SAFE_EXECUTABLES.has(tokens[0])) return false;
+  return tokens.every((token) => /^[A-Za-z0-9@/._:=~+*?\[\]-]+$/.test(token));
+}
+var runCascadeVerificationCommand = (command, cwd, timeoutMs) => {
+  if (!isSafeCascadeCommand(command)) {
+    return Promise.resolve({ exitCode: CASCADE_EVIDENCE_UNSAFE_EXIT });
+  }
+  const tokens = command.trim().split(/\s+/);
+  const executable = tokens[0];
+  const args = tokens.slice(1);
+  return new Promise((resolve3) => {
+    let child;
+    try {
+      child = spawn2(executable, args, {
+        cwd,
+        stdio: "ignore",
+        windowsHide: true,
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch {
+      resolve3({ exitCode: CASCADE_EVIDENCE_RUN_ERROR_EXIT });
+      return;
+    }
+    child.on("error", () => resolve3({ exitCode: CASCADE_EVIDENCE_RUN_ERROR_EXIT }));
+    child.on("close", (code) => resolve3({ exitCode: code ?? CASCADE_EVIDENCE_RUN_ERROR_EXIT }));
+  });
+};
+async function verifyCascadeEvidence(evidence, cwd, runCommand = runCascadeVerificationCommand, timeoutMs = CASCADE_EVIDENCE_COMMAND_TIMEOUT_MS) {
+  if (!evidence) return { status: "missing", checks: [] };
+  if (!evidence.typecheck) return { status: "failed", checks: [] };
+  const checks = [];
+  for (const name of ["typecheck", "lint", "tests"]) {
+    const claimed = evidence[name];
+    if (!claimed) continue;
+    const actual = await runCommand(claimed.command, cwd, timeoutMs);
+    const ok = claimed.exitCode === 0 && actual.exitCode === claimed.exitCode;
+    checks.push({
+      name,
+      command: claimed.command,
+      claimedExitCode: claimed.exitCode,
+      actualExitCode: actual.exitCode,
+      ok
+    });
+  }
+  if (checks.length === 0) return { status: "missing", checks };
+  const status = checks.every((c) => c.ok) ? "verified" : "failed";
+  return { status, checks };
+}
+
 // src/chimera-review-task.ts
 import { parseReviewSeverity } from "@wrongstack/core/plugin";
 function truncateAtCodePointBoundary(text, maxCodeUnits) {
@@ -2846,6 +2970,34 @@ function buildChimeraReviewTaskDescription(p) {
   lines.push("structured review report.");
   return lines.join("\n");
 }
+var CASCADE_EVIDENCE_INSTRUCTIONS = [
+  `After fixing, run the project's REAL verification commands on the code you changed`,
+  `(typecheck, lint, and the tests covering the fixed code) and return a machine-evidence`,
+  `block as the LAST section of your response. The block MUST be a fenced JSON block`,
+  `(exactly \`\`\`json ... \`\`\`) with this shape:`,
+  ``,
+  "```json",
+  "{",
+  '  "verification_evidence": {',
+  '    "typecheck": { "command": "pnpm typecheck", "exitCode": 0 },',
+  '    "lint":      { "command": "pnpm lint", "exitCode": 0 },',
+  '    "tests":     { "command": "pnpm test --filter affected", "exitCode": 0 }',
+  "  }",
+  "}",
+  "```",
+  ``,
+  `Rules:`,
+  `- \`command\` must be the EXACT command you ran (plain executable + args, no shell`,
+  `  chaining like \`&&\`/\`;\`/\`|\`, no redirection, no shell expansion). These commands are`,
+  `  re-run verbatim by the orchestrator to verify your work.`,
+  `- \`exitCode\` is the real process exit code you observed: 0 = passed, non-zero = failed.`,
+  `  Never invent or omit an exit code. If a command cannot be run, omit that key entirely`,
+  `  and explain why in your report text \u2014 an omitted key is honest, a fabricated 0 is not.`,
+  `- If your fix does not pass a command, report the true non-zero exit code; the`,
+  `  orchestrator will treat the fix as unverified and keep the finding open.`,
+  `- At least \`typecheck\` must be present; include \`lint\` and \`tests\` when the project`,
+  `  has them.`
+].join("\n");
 function buildChimeraCascadeTaskDescription(agentKind, p) {
   const fileList = p.bundle.files.map((f) => `- ${f.path}`).join("\n");
   const reportSlice = truncateAtCodePointBoundary(p.reviewText, 12e3);
@@ -2866,8 +3018,9 @@ function buildChimeraCascadeTaskDescription(agentKind, p) {
       `Investigate the security findings above. Read the flagged files, confirm or refute`,
       `each finding, and **apply fixes** for confirmed vulnerabilities using the edit tool.`,
       `Use severity (Critical/High/Medium), file:line citations, and remediation steps.`,
-      `After fixing, run the project's typecheck and linter to verify. If a finding is a`,
-      `false positive, say so and do not modify the file.`
+      `If a finding is a false positive, say so and do not modify the file.`,
+      ``,
+      CASCADE_EVIDENCE_INSTRUCTIONS
     ].join("\n");
   }
   return [
@@ -2884,9 +3037,10 @@ function buildChimeraCascadeTaskDescription(agentKind, p) {
     ``,
     `Hunt for the bugs flagged above. Read the affected files, trace each finding to its`,
     `root cause, and **apply minimal fixes** for confirmed bugs using the edit tool.`,
-    `Use severity (Critical/High/Medium), file:line citations. After fixing, run the`,
-    `project's typecheck and linter to verify. If a finding is a false positive, say so`,
-    `and do not modify the file.`
+    `Use severity (Critical/High/Medium), file:line citations. If a finding is a false`,
+    `positive, say so and do not modify the file.`,
+    ``,
+    CASCADE_EVIDENCE_INSTRUCTIONS
   ].join("\n");
 }
 
@@ -3003,7 +3157,9 @@ function installChimeraCascadeHandler({
   session,
   getPendingWork,
   trackWork,
-  buildLadder
+  buildLadder,
+  verifyEvidence = verifyCascadeEvidence,
+  persistEvidence
 }) {
   events.onPattern("chimera.cascade_needed", (_event, payload) => {
     const p = payload;
@@ -3016,6 +3172,7 @@ function installChimeraCascadeHandler({
         await previousWork;
       } catch {
       }
+      const agentEvidence = [];
       for (const agentKind of p.agents) {
         try {
           const taskDesc = buildChimeraCascadeTaskDescription(agentKind, p);
@@ -3059,6 +3216,10 @@ function installChimeraCascadeHandler({
           const result = outcome.result;
           if (result?.status === "success") {
             const resultText = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
+            const claimed = extractCascadeEvidence(resultText);
+            if (claimed) {
+              agentEvidence.push({ agentKind, evidence: claimed });
+            }
             await session.append({
               type: "llm_response",
               ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3089,7 +3250,21 @@ function installChimeraCascadeHandler({
           });
         }
       }
-      await maybeReReviewCascade({ events, session, bundle: p.bundle });
+      const accumulatedEvidence = {};
+      for (const { evidence } of agentEvidence) {
+        for (const name of ["typecheck", "lint", "tests"]) {
+          if (evidence[name]) accumulatedEvidence[name] = evidence[name];
+        }
+      }
+      await maybeReReviewCascade({
+        events,
+        session,
+        bundle: p.bundle,
+        reportId: p.reportId,
+        claimedEvidence: accumulatedEvidence,
+        verifyEvidence,
+        persistEvidence
+      });
     })();
     trackWork(pendingWork);
   });
@@ -3097,16 +3272,71 @@ function installChimeraCascadeHandler({
 async function maybeReReviewCascade({
   events,
   session,
-  bundle
+  bundle,
+  reportId,
+  claimedEvidence,
+  verifyEvidence,
+  persistEvidence
 }) {
   const maxDepth = bundle.maxCascadeDepth ?? 0;
   const currentDepth = bundle.cascadeDepth ?? 0;
+  const hasClaimedEvidence = Object.keys(claimedEvidence).length > 0;
+  const verification = hasClaimedEvidence ? await verifyEvidence(
+    claimedEvidence,
+    bundle.cwd,
+    void 0,
+    CASCADE_EVIDENCE_COMMAND_TIMEOUT_MS
+  ) : { status: "missing", checks: [] };
+  const evidenceBundle = {
+    ...bundle,
+    evidenceStatus: verification.status,
+    evidenceChecks: verification.checks
+  };
+  if (reportId && persistEvidence) {
+    try {
+      await persistEvidence(reportId, verification.status, verification.checks);
+    } catch (error) {
+      await session.append({
+        type: "error",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        message: `Chimera cascade evidence persistence failed: ${errorText2(error)}`,
+        phase: "agent"
+      });
+    }
+  }
+  await session.append({
+    type: "llm_response",
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    content: [
+      {
+        type: "text",
+        text: renderEvidenceSummary(verification.status, verification.checks)
+      }
+    ],
+    stopReason: "end_turn",
+    usage: { input: 0, output: 0 }
+  });
+  if (verification.status !== "verified") {
+    await session.append({
+      type: "llm_response",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      content: [
+        {
+          type: "text",
+          text: `\u{1F982} Chimera cascade evidence ${verification.status} \u2014 fix not confirmed, skipping re-review. Findings remain open.`
+        }
+      ],
+      stopReason: "end_turn",
+      usage: { input: 0, output: 0 }
+    });
+    return;
+  }
   if (maxDepth > 0 && currentDepth < maxDepth) {
     try {
       const reReadFiles = [];
-      for (const f of bundle.files) {
+      for (const f of evidenceBundle.files) {
         try {
-          const absPath = path10.join(bundle.cwd, f.path);
+          const absPath = path10.join(evidenceBundle.cwd, f.path);
           const content = await fsp.readFile(absPath, "utf8");
           reReadFiles.push({ path: f.path, status: "modified", content });
         } catch {
@@ -3114,7 +3344,7 @@ async function maybeReReviewCascade({
       }
       if (reReadFiles.length > 0) {
         const reReviewBundle = {
-          ...bundle,
+          ...evidenceBundle,
           files: reReadFiles,
           cascadeDepth: currentDepth + 1
         };
@@ -3172,18 +3402,28 @@ async function maybeReReviewCascade({
     });
   }
 }
+function renderEvidenceSummary(status, checks) {
+  if (status === "missing") return "no machine evidence supplied";
+  const summary = checks.map((check) => `${check.name}:${check.ok ? "pass" : "fail"}(${check.actualExitCode})`).join(", ");
+  return `${status}${summary ? ` \u2014 ${summary}` : ""}`;
+}
+function errorText2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/execution-chimera-review.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import path11 from "node:path";
-import { effectiveFallbackChain } from "@wrongstack/core/agent";
+import { effectiveFallbackChain, fallbackProfileChain as fallbackProfileChain2 } from "@wrongstack/core/agent";
 import {
   CHIMERA_REVIEW_PROMPT,
+  classifyChimeraReviewSource,
   integrateFindings,
   maybeCompactReviewStores,
   parseChimeraReviewReport,
   persistReviewReport,
-  recordCompletedReview
+  recordCompletedReview,
+  verifyFindingsAgainstDisk
 } from "@wrongstack/core/plugin";
 function normalizeFileKeyForCitation(raw, cwd) {
   const forward = raw.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -3267,7 +3507,13 @@ function installChimeraReviewHandler({
           const rawModel = p.reviewFallbackModels ? p.config.model?.trim() || void 0 : tModel;
           const baseProvider = rawProvider || tProvider || config.provider;
           const baseModel = rawModel || tModel || config.model;
-          const baseFallbacks = p.reviewFallbackModels ? [...p.reviewFallbackModels] : resolveReviewerFallbackModels(void 0);
+          const configFallbacks = [...p.config.fallbackModels ?? []];
+          if (p.config.fallbackProfile) {
+            configFallbacks.push(...fallbackProfileChain2(config, p.config.fallbackProfile));
+          }
+          const baseFallbacks = p.reviewFallbackModels ? [...p.reviewFallbackModels] : resolveReviewerFallbackModels(
+            configFallbacks.length > 0 ? configFallbacks : void 0
+          );
           const assigned = assignReviewerModels(
             baseProvider,
             baseModel,
@@ -3368,18 +3614,34 @@ function installChimeraReviewHandler({
           }
           const reviewText = typeof result.result === "string" ? result.result.trim() : JSON.stringify(result.result);
           const reportId = randomUUID3();
+          const reviewSource = classifyChimeraReviewSource(p);
+          const winningAttempt = outcome.wonAt ? ladder[outcome.wonAt - 1] : void 0;
+          const parsedReport = parseChimeraReviewReport(reviewText, {
+            sessionId: reviewSessionId,
+            agentId: p.fileProvenance?.find((entry) => entry.agentId)?.agentId ?? "chimera-review",
+            reviewerModel: winningAttempt ? attemptLabel(winningAttempt) : void 0,
+            reviewType: reviewSource,
+            reportId
+          });
+          const verifiedFindings = await verifyFindingsAgainstDisk(parsedReport.findings, {
+            cwd: p.cwd
+          });
+          const verifiedParsedReport = {
+            ...parsedReport,
+            findings: verifiedFindings
+          };
           await persistAndEmitCompletion({
             bundle: p,
             reviewText,
             status: "success",
             cwd: p.cwd,
             sessionId: reviewSessionId,
-            reportId
+            reportId,
+            parsedReport: verifiedParsedReport
           });
           if (reviewText) {
             const reviewHasFindings = !isChimeraAllClearReview(reviewText);
-            const parsedReview = parseChimeraReviewReport(reviewText);
-            const citedFindings = parsedReview.findings.filter((finding) => finding.location);
+            const citedFindings = verifiedFindings.filter((finding) => finding.location);
             const citedPaths = new Set(
               p.files.map((file) => normalizeFileKeyForCitation(file.path, p.cwd))
             );
@@ -3391,14 +3653,28 @@ function installChimeraReviewHandler({
               if (bucket) bucket.push(normalized);
               else changedBasenameIndex.set(basename7, [normalized]);
             }
-            const droppedCitations = citedFindings.filter((finding) => {
+            const inScopeCited = citedFindings.filter((finding) => {
               const citedKey = normalizeFileKeyForCitation(finding.location.file, p.cwd);
-              if (citedPaths.has(citedKey)) return false;
+              if (citedPaths.has(citedKey)) return true;
               const basename7 = path11.basename(finding.location.file).toLowerCase();
               const bucket = changedBasenameIndex.get(basename7);
-              return !(bucket && bucket.length === 1);
+              return !!(bucket && bucket.length === 1);
             });
-            const effectiveHasFindings = reviewHasFindings && (parsedReview.findings.length === 0 || parsedReview.findings.length > droppedCitations.length);
+            const droppedCitations = citedFindings.filter(
+              (finding) => !inScopeCited.includes(finding)
+            );
+            const actionableFindings = inScopeCited.filter(
+              (finding) => finding.verification?.status === "verified"
+            );
+            const unverifiedInScope = inScopeCited.filter(
+              (finding) => finding.verification?.status === "unverified"
+            );
+            const failedVerificationCount = inScopeCited.filter(
+              (finding) => finding.verification?.status === "failed"
+            ).length;
+            const effectiveHasFindings = reviewHasFindings && actionableFindings.length > 0;
+            const verifiedCount = actionableFindings.length;
+            const unverifiedCount = unverifiedInScope.length;
             const hallucinationNote = droppedCitations.length > 0 ? `
 
 \u26A0\uFE0F Citation validation: ${droppedCitations.length} finding(s) cite files outside the changed-file set and should be verified before acting.` : "";
@@ -3441,7 +3717,7 @@ ${reviewBody}`;
                 reviewLength: reviewText.length,
                 messageId: reviewMailMessageId
               });
-              if (!effectiveHasFindings) {
+              if (!reviewHasFindings) {
                 try {
                   await mailbox.ack({
                     messageId: reviewMailMessageId,
@@ -3485,11 +3761,8 @@ ${reviewBody}`;
                 phase: "agent"
               });
             }
-            const findingCount = Math.max(
-              0,
-              parsedReview.findings.length - droppedCitations.length
-            );
-            const message = effectiveHasFindings ? `\u{1F982} Chimera report ready \u2014 ${findingCount || "unparsed"} potential finding(s) across ${p.files.length} file(s). No follow-up started; open the mailbox and explicitly ask the leader to act if wanted.` : `\u{1F982} Chimera report ready \u2014 ${p.files.length} file(s) checked, no actionable findings. No follow-up started.`;
+            const findingCount = actionableFindings.length;
+            const message = effectiveHasFindings ? `\u{1F982} Chimera report ready \u2014 ${findingCount || "unparsed"} potential finding(s) (${verifiedCount} verified against disk, ${unverifiedCount} unverified, ${failedVerificationCount} failed) across ${p.files.length} file(s). No follow-up started; open the mailbox and explicitly ask the leader to act if wanted.` : `\u{1F982} Chimera report ready \u2014 ${p.files.length} file(s) checked, no actionable findings. No follow-up started.`;
             events.emitCustom("chimera.report_available", {
               reportId,
               sessionId: reviewSessionId,
@@ -3711,7 +3984,7 @@ function parseSuggestionsFromOutput(finalText, todos) {
     setAutoSuggestions([]);
     return null;
   }
-  const { texts, autoTexts } = parseNextSteps(finalText, false);
+  const { texts, autoTexts } = parseNextSteps(finalText);
   if (autoTexts.length > 0) {
     setAutoSuggestions(autoTexts);
   }
@@ -4752,6 +5025,373 @@ function createTuiNextStepCallbacks(input) {
   };
 }
 
+// src/tui-resource-menus.ts
+import { readdir } from "node:fs/promises";
+import { readJsonObjectFile } from "@wrongstack/core/utils";
+function createTuiResourceMenuGetter(ctx) {
+  return async (id) => {
+    switch (id) {
+      case "fallback":
+        return fallbackMenu(ctx.configStore);
+      case "profile":
+        return profileMenu(ctx.configStore, ctx.paths);
+      case "provider-status":
+        return providerStatusMenu(ctx.statusTracker);
+      case "memory":
+        return memoryMenu(ctx.memoryStore);
+      case "worktree":
+        return worktreeMenu(ctx.projectRoot);
+      case "git":
+        return gitMenu(ctx.projectRoot);
+    }
+  };
+}
+function fallbackMenu(store) {
+  const config = store.get();
+  const chain = config.fallbackModels ?? [];
+  const profiles = config.fallbackProfiles ?? {};
+  const favorites = config.favoriteModels ?? [];
+  const auto = config.fallbackAuto !== false;
+  const items = [
+    {
+      id: "leader",
+      label: "Leader",
+      status: "good",
+      summary: `${config.provider}/${config.model}`,
+      details: [
+        { label: "provider", value: config.provider },
+        { label: "model", value: config.model },
+        { label: "bridge", value: config.fallbackBridge || "disabled" }
+      ],
+      body: "The active session model. The bridge, when configured, is tried before the ordered fallback chain."
+    },
+    {
+      id: "auto",
+      label: "Smart fallback",
+      status: auto ? "good" : "muted",
+      summary: auto ? "enabled" : "disabled",
+      details: [
+        { label: "mode", value: auto ? "auto-derived when chain is empty" : "explicit chain only" },
+        { label: "favorites only", value: config.favoriteModelsOnly ? "yes" : "no" },
+        { label: "favorites", value: String(favorites.length) }
+      ],
+      actions: [
+        {
+          key: "t",
+          label: auto ? "turn off" : "turn on",
+          command: `/fallback auto ${auto ? "off" : "on"}`
+        }
+      ]
+    },
+    ...chain.map((ref, index) => ({
+      id: `chain:${index}`,
+      label: `${index + 1}. ${ref}`,
+      status: "warn",
+      summary: "explicit fallback",
+      details: [
+        { label: "position", value: String(index + 1) },
+        { label: "model ref", value: ref },
+        { label: "after", value: index === 0 ? "leader/bridge" : chain[index - 1] ?? "leader" }
+      ],
+      actions: [
+        { key: "x", label: "remove", command: `/fallback remove ${index + 1}`, confirm: true }
+      ]
+    })),
+    ...Object.entries(profiles).sort(([a], [b]) => a.localeCompare(b)).map(([name, refs]) => ({
+      id: `profile:${name}`,
+      label: `Profile: ${name}`,
+      status: refs.length > 0 ? "good" : "muted",
+      summary: `${refs.length} model${refs.length === 1 ? "" : "s"}`,
+      details: [
+        { label: "name", value: name },
+        { label: "length", value: String(refs.length) }
+      ],
+      body: refs.join(" \u2192 ") || "(empty profile)",
+      actions: [
+        { key: "u", label: "use", command: `/fallback profile use ${name}`, confirm: true },
+        { key: "x", label: "delete", command: `/fallback profile remove ${name}`, confirm: true }
+      ]
+    })),
+    ...favorites.map((ref, index) => ({
+      id: `favorite:${index}`,
+      label: `\u2605 ${ref}`,
+      status: "good",
+      summary: "favorite model",
+      details: [{ label: "model ref", value: ref }],
+      actions: [
+        {
+          key: "x",
+          label: "unfavorite",
+          command: `/fallback fav remove ${index + 1}`,
+          confirm: true
+        }
+      ]
+    }))
+  ];
+  return {
+    id: "fallback",
+    title: "Fallback routing",
+    subtitle: `${chain.length} explicit \xB7 ${Object.keys(profiles).length} profiles \xB7 ${favorites.length} favorites`,
+    items
+  };
+}
+async function profileMenu(store, paths) {
+  const active = store.get().activeProfile ?? paths.profileName ?? "default";
+  let names = [];
+  try {
+    names = (await readdir(paths.profilesDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+  }
+  const items = await Promise.all(
+    names.map(async (name) => {
+      const path14 = paths.profileConfig(name);
+      const data = await readJsonObjectFile(path14);
+      const provider = typeof data["provider"] === "string" ? data["provider"] : "unset";
+      const model = typeof data["model"] === "string" ? data["model"] : "unset";
+      const fallbackCount = Array.isArray(data["fallbackModels"]) ? data["fallbackModels"].length : 0;
+      const profileCount = isRecord(data["fallbackProfiles"]) ? Object.keys(data["fallbackProfiles"]).length : 0;
+      const isActive = name === active;
+      return {
+        id: name,
+        label: name,
+        status: isActive ? "good" : "muted",
+        summary: isActive ? "active" : `${provider}/${model}`,
+        details: [
+          { label: "active", value: isActive ? "yes" : "no" },
+          { label: "provider", value: provider },
+          { label: "model", value: model },
+          {
+            label: "theme",
+            value: typeof data["themePreset"] === "string" ? data["themePreset"] : "default"
+          },
+          { label: "fallbacks", value: String(fallbackCount) },
+          { label: "fallback profiles", value: String(profileCount) },
+          { label: "config", value: path14 }
+        ],
+        body: isActive ? "This profile owns the current session configuration." : "Switching profiles closes this session so every service restarts with the selected configuration.",
+        actions: isActive ? [] : [{ key: "s", label: "switch", command: `/profile switch ${name}`, confirm: true }]
+      };
+    })
+  );
+  return {
+    id: "profile",
+    title: "Profiles",
+    subtitle: `active: ${active}`,
+    emptyText: "No profiles found.",
+    items
+  };
+}
+function providerStatusMenu(tracker) {
+  const snapshot = tracker?.getSnapshot();
+  const items = snapshot?.statuses.map((status) => ({
+    id: `${status.providerId}/${status.model}`,
+    label: `${status.providerId}/${status.model}`,
+    status: status.state === "healthy" ? "good" : status.state === "degraded" ? "warn" : "bad",
+    summary: status.state,
+    details: [
+      { label: "state", value: status.state },
+      { label: "successes", value: String(status.totalSuccesses) },
+      { label: "failures", value: String(status.totalFailures) },
+      { label: "rate limits", value: String(status.rateLimitHits) },
+      { label: "consecutive failures", value: String(status.consecutiveFailures) },
+      {
+        label: "cooldown",
+        value: status.stateExpiresAt ? new Date(status.stateExpiresAt).toLocaleString() : "none"
+      },
+      { label: "last error kind", value: status.lastErrorKind ?? "none" }
+    ],
+    body: status.lastErrorMessage ?? "No recorded error.",
+    actions: [
+      ...status.state !== "healthy" ? [
+        {
+          key: "r",
+          label: "retry now",
+          command: `/provider-status retry ${status.providerId} ${status.model}`
+        }
+      ] : [],
+      {
+        key: "x",
+        label: "clear history",
+        command: `/provider-status clear ${status.providerId} ${status.model}`,
+        confirm: true
+      }
+    ]
+  })) ?? [];
+  return {
+    id: "provider-status",
+    title: "Provider health",
+    subtitle: snapshot ? `${snapshot.healthy} healthy \xB7 ${snapshot.degraded} degraded \xB7 ${snapshot.blocked} blocked` : "tracker unavailable",
+    emptyText: "No provider/model activity has been recorded.",
+    items
+  };
+}
+async function memoryMenu(store) {
+  if (!store)
+    return {
+      id: "memory",
+      title: "Memory",
+      emptyText: "Memory is disabled in this host.",
+      items: []
+    };
+  const [health, entries] = await Promise.all([store.health(), store.list(void 0, 100)]);
+  return {
+    id: "memory",
+    title: "Memory",
+    subtitle: `${health.status} \xB7 ${health.backend} \xB7 newest 100`,
+    emptyText: "No memories found.",
+    items: entries.map((entry, index) => ({
+      id: `${entry.ts}:${index}`,
+      label: truncate(entry.text.replace(/\s+/g, " "), 52),
+      status: entry.priority === "critical" || entry.priority === "high" ? "warn" : "muted",
+      summary: `${entry.scope} \xB7 ${entry.type ?? "fact"}`,
+      details: [
+        { label: "scope", value: entry.scope },
+        { label: "type", value: entry.type ?? "fact" },
+        { label: "priority", value: entry.priority ?? "medium" },
+        {
+          label: "confidence",
+          value: entry.confidence === void 0 ? "unspecified" : entry.confidence.toFixed(2)
+        },
+        { label: "created", value: entry.ts },
+        { label: "last accessed", value: entry.lastAccessed ?? "never" },
+        { label: "tags", value: entry.tags?.join(", ") || "none" },
+        { label: "source", value: entry.source ?? "unknown" }
+      ],
+      body: entry.text,
+      actions: entry.scope === "project-memory" ? [
+        {
+          key: "x",
+          label: "forget matching text",
+          command: `/memory forget ${entry.text.replace(/\s+/g, " ").trim()} --exact`,
+          confirm: true
+        }
+      ] : []
+    }))
+  };
+}
+async function gitMenu(projectRoot) {
+  const [branch, head, status] = await Promise.all([
+    runGit(["branch", "--show-current"], projectRoot),
+    runGit(["rev-parse", "--short", "HEAD"], projectRoot),
+    runGit(["status", "--porcelain=v1"], projectRoot)
+  ]);
+  if (status.code !== 0)
+    return { id: "git", title: "Git", emptyText: "Not a git repository.", items: [] };
+  const lines = status.stdout.split(/\r?\n/).filter(Boolean);
+  const items = [
+    {
+      id: "repo",
+      label: branch.stdout.trim() || "(detached)",
+      status: lines.length === 0 ? "good" : "warn",
+      summary: `${head.stdout.trim() || "no HEAD"} \xB7 ${lines.length === 0 ? "clean" : `${lines.length} changes`}`,
+      details: [
+        { label: "branch", value: branch.stdout.trim() || "(detached)" },
+        { label: "HEAD", value: head.stdout.trim() || "(unborn)" },
+        {
+          label: "working tree",
+          value: lines.length === 0 ? "clean" : `${lines.length} changed paths`
+        }
+      ],
+      actions: [{ key: "c", label: "commit workflow", command: "/commit", confirm: true }]
+    },
+    ...lines.map((line, index) => {
+      const code = line.slice(0, 2);
+      const path14 = line.slice(3);
+      const staged = code[0] !== " " && code[0] !== "?";
+      const unstaged = code[1] !== " " || code === "??";
+      return {
+        id: `change:${index}:${path14}`,
+        label: path14,
+        status: staged ? "good" : "warn",
+        summary: `${code} \xB7 ${staged ? "staged" : "not staged"}${unstaged ? " \xB7 working tree" : ""}`,
+        details: [
+          { label: "status", value: code },
+          { label: "staged", value: staged ? "yes" : "no" },
+          { label: "unstaged", value: unstaged ? "yes" : "no" },
+          { label: "path", value: path14 }
+        ],
+        actions: [
+          { key: "d", label: "diff summary", command: staged ? "/git diff --staged" : "/git diff" }
+        ]
+      };
+    })
+  ];
+  return { id: "git", title: "Git", subtitle: projectRoot, items };
+}
+async function worktreeMenu(projectRoot) {
+  const result = await runGit(["worktree", "list", "--porcelain"], projectRoot);
+  if (result.code !== 0) {
+    return {
+      id: "worktree",
+      title: "Worktrees",
+      emptyText: result.stderr || "Not a git repository.",
+      items: []
+    };
+  }
+  const records = result.stdout.trim().split(/\r?\n\r?\n/).map((block) => block.split(/\r?\n/).filter(Boolean)).filter((lines) => lines.length > 0);
+  const rows = await Promise.all(
+    records.map(async (lines, index) => {
+      const fields = Object.fromEntries(
+        lines.map((line) => {
+          const split = line.indexOf(" ");
+          return split < 0 ? [line, "yes"] : [line.slice(0, split), line.slice(split + 1)];
+        })
+      );
+      const path14 = fields["worktree"] ?? "(unknown path)";
+      const branchRef = fields["branch"];
+      const branch = branchRef?.replace(/^refs\/heads\//, "") ?? (fields["detached"] ? "(detached)" : "(bare)");
+      const status = path14 === "(unknown path)" || fields["prunable"] ? null : await runGit(["status", "--porcelain=v1"], path14);
+      const changes = status?.code === 0 ? status.stdout.split(/\r?\n/).filter(Boolean) : [];
+      const dirty = changes.length > 0;
+      const isMain = index === 0;
+      return {
+        id: path14,
+        label: branch,
+        status: fields["prunable"] ? "bad" : dirty ? "warn" : "good",
+        summary: `${isMain ? "main" : "linked"} \xB7 ${dirty ? `${changes.length} changes` : "clean"}`,
+        details: [
+          { label: "path", value: path14 },
+          { label: "branch", value: branch },
+          { label: "HEAD", value: fields["HEAD"]?.slice(0, 12) ?? "unknown" },
+          { label: "working tree", value: dirty ? `${changes.length} changed paths` : "clean" },
+          { label: "locked", value: fields["locked"] ?? "no" },
+          { label: "prunable", value: fields["prunable"] ?? "no" }
+        ],
+        body: changes.slice(0, 30).join("\n") || (isMain ? "Primary checkout." : "Linked checkout."),
+        actions: isMain ? [
+          { key: "p", label: "prune stale metadata", command: "/worktree prune" },
+          {
+            key: "x",
+            label: "clean managed worktrees",
+            command: "/worktree clean --yes",
+            confirm: true
+          }
+        ] : branchRef ? [
+          {
+            key: "m",
+            label: "squash merge",
+            command: `/worktree merge ${branch} --yes`,
+            confirm: true
+          }
+        ] : []
+      };
+    })
+  );
+  return {
+    id: "worktree",
+    title: "Worktrees",
+    subtitle: `${rows.length} checkout${rows.length === 1 ? "" : "s"}`,
+    emptyText: "No worktrees found.",
+    items: rows
+  };
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function truncate(value, max) {
+  return value.length <= max ? value : `${value.slice(0, max - 1)}\u2026`;
+}
+
 // src/execution.ts
 async function execute(deps) {
   const {
@@ -4909,6 +5549,9 @@ async function execute(deps) {
       session: { provider: config.provider, model: config.model }
     }),
     getPendingWork: () => chimeraWork.pending(),
+    persistEvidence: async (reportId, status, checks) => {
+      await updateReviewReportEvidence(reportId, wpaths.projectDir, status, checks);
+    },
     trackWork: (work) => {
       chimeraWork.track(work);
     }
@@ -5031,6 +5674,14 @@ async function execute(deps) {
           agent,
           events,
           slashRegistry,
+          skillLoader,
+          getResourceMenu: createTuiResourceMenuGetter({
+            configStore,
+            paths: wpaths,
+            memoryStore,
+            statusTracker,
+            projectRoot
+          }),
           secretInputController,
           attachments,
           tokenCounter,
@@ -5347,4 +5998,4 @@ export {
   execute,
   resolveReviewerFallbackModels
 };
-//# sourceMappingURL=execution-QYFWDD3Y.js.map
+//# sourceMappingURL=execution-4IG5XKOL.js.map