@wyattjoh/demur 0.5.0 → 0.6.0

package/README.md

@@ -98,7 +98,7 @@ Pin a specific release when reproducibility matters:
 
 <!-- x-release-please-start-version -->
 ```sh
-pi install npm:@wyattjoh/demur@0.5.0
+pi install npm:@wyattjoh/demur@0.6.0
 ```
 <!-- x-release-please-end -->
 
@@ -218,21 +218,32 @@ demur auth login
 demur auth status
 demur auth logout
 demur training review
-# Force the line-oriented interface for pipes or basic terminals:
-demur training review --plain
+demur training list --status=unreviewed --cwd=/workspace
+demur training list --status=deny --json
+demur training review <record-id> --decision=deny --note="would destroy work" --json
 demur judge "git reset --hard HEAD~3"
 ```
 
 Bare `demur` opens the central OpenTUI interface when stdin and stdout are
 interactive. `demur training review` remains an explicit alias for the same
-interface. Its header shows the persisted global estimated cost, and each queue
-row shows that evaluation's estimated input cost. It starts in an `all` view;
-Tab and Shift-Tab rotate between `all`, `not reviewed`, `approved` (`allow`),
-`ask`, and `deny` views. The queue is focused initially: arrow keys navigate it,
-Up from its first result focuses a
-fuzzy working-directory filter, and another Up focuses the tab strip. Left and
-Right select adjacent focused tabs, while Down returns through the filter to the
-queue. Right from the queue focuses the scrollable detail pane.
+interface. `[` opens Reviews and `]` opens Settings. You can also navigate Up
+to the top-level section strip, use Left and Right to switch sections, and press
+Down or Enter to open one. Settings exposes every option from Pi's `/demur`
+menu—operating mode, training capture,
+and failure policy—and atomically saves each change to the same global
+configuration file. Use Up and Down to select a setting, Left and Right to
+change it in either direction, or Enter/Space to choose its next value.
+Disabling demur also turns training capture off, and training remains unavailable
+until an active mode is selected.
+
+The Reviews header shows the persisted global estimated cost, and each queue row
+shows the model decision in a muted semantic color. It starts in an `all` view;
+Tab and Shift-Tab rotate between `all`, `not reviewed`, `approved` (`allow`), `ask`,
+and `deny` views. The queue is focused initially: arrow keys navigate it, Up
+from its first result focuses a fuzzy working-directory filter, and another Up
+focuses the tab strip. Left and Right select adjacent focused tabs, while Down
+returns through the filter to the queue. Right from the queue focuses the
+scrollable detail pane.
 The detail pane supports arrows or `j`/`k`; Left returns to the queue. Page Up
 and Page Down page within the focused pane, and queue navigation stops at its
 first and last entries. Mouse clicks select tabs, records, the filter, or either
@@ -242,9 +253,18 @@ leaves a record for a later pass, and `q` or Escape stops. Previously reviewed
 records remain available, and changing an answer appends a review revision while
 preserving its visible history. The TUI remains open when a view is empty and
 polls training state for newly captured or externally reviewed evaluations.
-Non-interactive invocations automatically use the line-oriented reviewer; pass
-`--plain` to select it explicitly. Reviews remain separate from the original
-evidence so they can later be curated into independently licensed eval fixtures.
+
+Flag-based training commands provide the same review operations without the
+TUI. `demur training list` accepts `--status` and fuzzy `--cwd` filters. Status
+is derived from the latest human review, so `allow`, `ask`, and `deny` select
+reviewed records while `unreviewed` selects records without a review. Record a
+new append-only review revision by passing a record ID, a required
+`--decision=<allow|ask|deny>`, and an optional `--note`. Add `--json` to either
+operation to emit one versioned JSON document; JSON failures are written to
+stdout with a nonzero exit code. Interactive `demur training review` still opens
+the TUI, but without a terminal it requires an explicit list or record-ID review
+operation. Reviews remain separate from the original evidence so they can later
+be curated into independently licensed eval fixtures.
 
 From a development checkout, `bun run judge "<command>"` remains available.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wyattjoh/demur",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "A proof-of-concept destructive-command guard for coding agents.",
   "license": "MIT",
@@ -38,6 +38,7 @@
     "src/policy.ts",
     "src/questions.ts",
     "src/state.ts",
+    "src/settings-model.ts",
     "src/training-review-model.ts",
     "src/training-review-tui.tsx",
     "src/types.ts"
@@ -51,7 +52,7 @@
   },
   "scripts": {
     "check": "tsc --noEmit",
-    "test": "vitest run",
+    "test": "vitest run && bun test ./src/training-review-tui.bun.tsx",
     "build:pi": "bun build extensions/demur/index.ts --target=node --outfile=dist/demur-guard.js --format=esm --external @earendil-works/pi-coding-agent && bun build src/adapters/pi-worker.ts --target=bun --outfile=dist/demur-pi-worker.js --format=esm",
     "build:claude": "bun build src/adapters/claude-code.ts --target=bun --outfile=dist/demur-hook.js --format=esm",
     "build": "bun run build:pi && bun run build:claude",

package/src/cli.ts

@@ -1,7 +1,11 @@
 #!/usr/bin/env bun
-import { createInterface } from "node:readline/promises";
 import { Predicate } from "effect";
 import { loadCostTotals } from "../extensions/demur/cost-tracker.ts";
+import {
+  loadDemurSettings,
+  saveDemurSettings,
+  type DemurSettings,
+} from "../extensions/demur/settings.ts";
 import {
   loadTrainingRecords,
   loadTrainingReviews,
@@ -19,7 +23,12 @@ import {
 } from "./key.ts";
 import {
   buildTrainingReviewEntries,
+  createTrainingReviewInput,
+  filterTrainingReviewEntries,
+  getLatestTrainingReview,
   getTrainingReviewFilter,
+  type TrainingReviewEntry,
+  type TrainingReviewFilter,
   type TrainingReviewSnapshot,
 } from "./training-review-model.ts";
 import type { TrainingReviewTuiResult } from "./training-review-tui.tsx";
@@ -30,7 +39,9 @@ const USAGE = `Usage:
   demur auth login
   demur auth status
   demur auth logout
-  demur training review [--plain]
+  demur training list [--status=<all|unreviewed|allow|ask|deny>] [--cwd=<query>] [--json]
+  demur training review
+  demur training review <record-id> --decision=<allow|ask|deny> [--note=<text>] [--json]
   demur judge "<command>" [--cwd=<path>]`;
 
 /**
@@ -45,26 +56,22 @@ export type CliDependencies = {
   loadTrainingReviews(): Promise<ReadonlyArray<TrainingReview>>;
   loadGlobalEstimatedCostUsd(): Promise<number>;
   recordTrainingReview(input: TrainingReviewInput): Promise<TrainingReview>;
+  loadDemurSettings(): Promise<DemurSettings>;
+  saveDemurSettings(settings: DemurSettings): Promise<void>;
   runTrainingReviewTui(
     snapshot: TrainingReviewSnapshot,
+    settings: DemurSettings,
     reloadSnapshot: () => Promise<TrainingReviewSnapshot>,
     recordReview: (input: TrainingReviewInput) => Promise<TrainingReview>,
+    saveSettings: (settings: DemurSettings) => Promise<void>,
   ): Promise<TrainingReviewTuiResult>;
   isInteractive(): boolean;
   readSecret(prompt: string): Promise<string>;
-  readLine(prompt: string): Promise<string>;
   cwd(): string;
   stdout(message: string): void;
   stderr(message: string): void;
 };
 
-let lineInput:
-  | {
-    terminal: ReturnType<typeof createInterface>;
-    lines: AsyncIterator<string>;
-  }
-  | undefined;
-
 const defaultDependencies: CliDependencies = {
   judge: (command, cwd) => guard(command, cwd, "cli"),
   resolveApiKey,
@@ -75,15 +82,28 @@ const defaultDependencies: CliDependencies = {
   loadGlobalEstimatedCostUsd: async () =>
     (await loadCostTotals()).estimatedCostUsd,
   recordTrainingReview,
-  runTrainingReviewTui: async (snapshot, reloadSnapshot, recordReview) => {
+  loadDemurSettings,
+  saveDemurSettings,
+  runTrainingReviewTui: async (
+    snapshot,
+    settings,
+    reloadSnapshot,
+    recordReview,
+    saveSettings,
+  ) => {
     const { runTrainingReviewTui } = await import(
       "./training-review-tui.tsx"
     );
-    return runTrainingReviewTui(snapshot, reloadSnapshot, recordReview);
+    return runTrainingReviewTui(
+      snapshot,
+      settings,
+      reloadSnapshot,
+      recordReview,
+      saveSettings,
+    );
   },
   isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
   readSecret,
-  readLine,
   cwd: () => process.cwd(),
   stdout: (message) => console.log(message),
   stderr: (message) => console.error(message),
@@ -104,7 +124,7 @@ export async function runCli(
     if (args.length === 0) {
       if (!dependencies.isInteractive()) {
         dependencies.stderr(
-          "demur: the interactive app requires a terminal; use `demur training review --plain` for line-oriented review.",
+          "demur: the interactive app requires a terminal; use `demur training list --json` or review a record by ID.",
         );
         return 2;
       }
@@ -127,10 +147,17 @@ export async function runCli(
     const judgeArgs = args[0] === "judge" ? args.slice(1) : args;
     return await runJudge(judgeArgs, dependencies);
   } catch (error: unknown) {
-    dependencies.stderr(`demur: ${errorDetail(error)}`);
+    if (isTrainingJsonRequest(args)) {
+      writeTrainingJsonError(
+        trainingOperation(args),
+        "unexpected_error",
+        errorDetail(error),
+        dependencies,
+      );
+    } else {
+      dependencies.stderr(`demur: ${errorDetail(error)}`);
+    }
     return 1;
-  } finally {
-    closeLineInput();
   }
 }
 
@@ -201,43 +228,224 @@ async function runAuth(
   return 2;
 }
 
+type ParsedArguments = {
+  positionals: ReadonlyArray<string>;
+  options: ReadonlyMap<string, string | true>;
+};
+
+type ParseArgumentsResult =
+  | { parsed: ParsedArguments; error: undefined }
+  | { parsed: undefined; error: string };
+
 async function runTraining(
   args: ReadonlyArray<string>,
   dependencies: CliDependencies,
 ): Promise<number> {
-  const plain = args.includes("--plain");
-  const operands = args.filter((arg) => arg !== "--plain");
-  if (
-    operands.length !== 1 ||
-    operands[0] !== "review" ||
-    args.filter((arg) => arg === "--plain").length > 1
-  ) {
-    dependencies.stderr(USAGE);
+  const command = args[0];
+  if (command === "list") {
+    return runTrainingList(args.slice(1), dependencies);
+  }
+
+  if (command === "review") {
+    if (args.length === 1) {
+      return runInteractiveTrainingReview(dependencies);
+    }
+    return runTrainingReview(args.slice(1), dependencies);
+  }
+
+  return writeTrainingUsageError(
+    trainingOperation(["training", ...args]),
+    args.includes("--json"),
+    "expected `training list` or `training review`",
+    dependencies,
+  );
+}
+
+async function runInteractiveTrainingReview(
+  dependencies: CliDependencies,
+): Promise<number> {
+  if (!dependencies.isInteractive()) {
+    dependencies.stderr(
+      "demur: `training review` requires a terminal; use `training list --json` and review a record by ID.",
+    );
     return 2;
   }
 
   const loadSnapshot = () => loadTrainingReviewSnapshot(dependencies);
   const snapshot = await loadSnapshot();
+  const settings = await dependencies.loadDemurSettings();
+  const result = await dependencies.runTrainingReviewTui(
+    snapshot,
+    settings,
+    loadSnapshot,
+    dependencies.recordTrainingReview,
+    dependencies.saveDemurSettings,
+  );
+  printReviewSummary(result, dependencies);
+  return 0;
+}
 
-  if (!plain && dependencies.isInteractive()) {
-    const result = await dependencies.runTrainingReviewTui(
-      snapshot,
-      loadSnapshot,
-      dependencies.recordTrainingReview,
+async function runTrainingList(
+  args: ReadonlyArray<string>,
+  dependencies: CliDependencies,
+): Promise<number> {
+  const operation = "training.list";
+  const parsedResult = parseArguments(
+    args,
+    new Set(["json"]),
+    new Set(["status", "cwd"]),
+  );
+  const json = args.includes("--json");
+  if (parsedResult.error !== undefined) {
+    return writeTrainingUsageError(
+      operation,
+      json,
+      parsedResult.error,
+      dependencies,
+    );
+  }
+
+  const parsed = parsedResult.parsed;
+  if (parsed.positionals.length !== 0) {
+    return writeTrainingUsageError(
+      operation,
+      hasOption(parsed, "json"),
+      "`training list` does not accept positional arguments",
+      dependencies,
+    );
+  }
+
+  const statusValue = getStringOption(parsed, "status") ?? "all";
+  if (!isTrainingReviewFilter(statusValue)) {
+    return writeTrainingUsageError(
+      operation,
+      hasOption(parsed, "json"),
+      `unsupported status: ${statusValue}`,
+      dependencies,
+    );
+  }
+
+  const cwdQuery = getStringOption(parsed, "cwd") ?? "";
+  const entries = filterTrainingReviewEntries(
+    await loadTrainingEntries(dependencies),
+    statusValue,
+    cwdQuery,
+  );
+
+  if (hasOption(parsed, "json")) {
+    writeTrainingJsonSuccess(
+      operation,
+      {
+        filter: {
+          status: statusValue,
+          cwd: cwdQuery === "" ? null : cwdQuery,
+        },
+        records: entries.map(trainingListRecord),
+      },
+      dependencies,
     );
-    printReviewSummary(result, dependencies);
     return 0;
   }
 
-  const pending = buildTrainingReviewEntries(snapshot)
-    .filter((entry) => getTrainingReviewFilter(entry) === "unreviewed")
-    .map((entry) => entry.record);
-  if (pending.length === 0) {
-    dependencies.stdout("No unreviewed demur training records.");
+  if (entries.length === 0) {
+    dependencies.stdout("No matching demur training records.");
+    return 0;
+  }
+
+  dependencies.stdout(
+    `${entries.length} matching training record${entries.length === 1 ? "" : "s"}:`,
+  );
+  for (const entry of entries) {
+    const record = entry.record;
+    dependencies.stdout(
+      [
+        record.id,
+        getTrainingReviewFilter(entry),
+        `model=${record.verdict.decision}`,
+        record.cwd,
+        summarizeTrainingCommand(record.command),
+      ].join("\t"),
+    );
+  }
+  return 0;
+}
+
+async function runTrainingReview(
+  args: ReadonlyArray<string>,
+  dependencies: CliDependencies,
+): Promise<number> {
+  const operation = "training.review";
+  const parsedResult = parseArguments(
+    args,
+    new Set(["json"]),
+    new Set(["decision", "note"]),
+  );
+  const json = args.includes("--json");
+  if (parsedResult.error !== undefined) {
+    return writeTrainingUsageError(
+      operation,
+      json,
+      parsedResult.error,
+      dependencies,
+    );
+  }
+
+  const parsed = parsedResult.parsed;
+  if (parsed.positionals.length !== 1) {
+    return writeTrainingUsageError(
+      operation,
+      hasOption(parsed, "json"),
+      "`training review` requires exactly one record ID",
+      dependencies,
+    );
+  }
+
+  const decisionValue = getStringOption(parsed, "decision");
+  if (decisionValue === undefined || !isDecision(decisionValue)) {
+    return writeTrainingUsageError(
+      operation,
+      hasOption(parsed, "json"),
+      "`--decision` must be allow, ask, or deny",
+      dependencies,
+    );
+  }
+
+  const recordId = parsed.positionals[0];
+  const entries = await loadTrainingEntries(dependencies);
+  const entry = entries.find((candidate) => candidate.record.id === recordId);
+  if (entry === undefined) {
+    return writeTrainingDomainError(
+      operation,
+      hasOption(parsed, "json"),
+      "record_not_found",
+      `training record not found: ${recordId}`,
+      dependencies,
+    );
+  }
+
+  const previousReview = getLatestTrainingReview(entry) ?? null;
+  const review = await dependencies.recordTrainingReview(
+    createTrainingReviewInput(
+      entry.record,
+      decisionValue,
+      getStringOption(parsed, "note"),
+    ),
+  );
+  const corrected = decisionValue !== entry.record.verdict.decision;
+
+  if (hasOption(parsed, "json")) {
+    writeTrainingJsonSuccess(
+      operation,
+      { review, corrected, previousReview },
+      dependencies,
+    );
     return 0;
   }
 
-  return runPlainTrainingReview(pending, dependencies);
+  dependencies.stdout(
+    `Recorded ${decisionValue.toUpperCase()} review for ${recordId}${corrected ? ` (model: ${entry.record.verdict.decision.toUpperCase()})` : " (accepted model decision)"}.`,
+  );
+  return 0;
 }
 
 async function loadTrainingReviewSnapshot(
@@ -251,44 +459,18 @@ async function loadTrainingReviewSnapshot(
   return { records, reviews, globalEstimatedCostUsd };
 }
 
-async function runPlainTrainingReview(
-  pending: ReadonlyArray<TrainingRecord>,
+async function loadTrainingEntries(
   dependencies: CliDependencies,
-): Promise<number> {
-  let reviewed = 0;
-  let corrected = 0;
-  let skipped = 0;
-  for (const [index, record] of pending.entries()) {
-    printTrainingRecord(record, index + 1, pending.length, dependencies);
-    const expectedDecision = await readExpectedDecision(record, dependencies);
-    if (expectedDecision === "quit") break;
-    if (expectedDecision === "skip") {
-      skipped += 1;
-      continue;
-    }
-
-    const isCorrection = expectedDecision !== record.verdict.decision;
-    const note = isCorrection
-      ? (await dependencies.readLine("Correction note (optional): ")).trim() ||
-        undefined
-      : undefined;
-    await dependencies.recordTrainingReview({
-      recordId: record.id,
-      originalDecision: record.verdict.decision,
-      expectedDecision,
-      note,
-    });
-    reviewed += 1;
-    if (isCorrection) corrected += 1;
-    dependencies.stdout(
-      isCorrection
-        ? `Recorded correction: ${record.verdict.decision} → ${expectedDecision}.`
-        : `Accepted ${record.verdict.decision} decision.`,
-    );
-  }
-
-  printReviewSummary({ reviewed, corrected, skipped }, dependencies);
-  return 0;
+): Promise<ReadonlyArray<TrainingReviewEntry>> {
+  const [records, reviews] = await Promise.all([
+    dependencies.loadTrainingRecords(),
+    dependencies.loadTrainingReviews(),
+  ]);
+  return buildTrainingReviewEntries({
+    records,
+    reviews,
+    globalEstimatedCostUsd: 0,
+  });
 }
 
 function printReviewSummary(
@@ -303,54 +485,162 @@ function printReviewSummary(
   );
 }
 
-async function readExpectedDecision(
-  record: TrainingRecord,
-  dependencies: CliDependencies,
-): Promise<"allow" | "ask" | "deny" | "skip" | "quit"> {
-  while (true) {
-    const input = (
-      await dependencies.readLine(
-        `Expected decision [enter=${record.verdict.decision}, allow, ask, deny, skip, quit]: `,
-      )
-    ).trim().toLowerCase();
-
-    if (input === "") return record.verdict.decision;
-    if (
-      input === "allow" ||
-      input === "ask" ||
-      input === "deny" ||
-      input === "skip" ||
-      input === "quit"
-    ) {
-      return input;
+function parseArguments(
+  args: ReadonlyArray<string>,
+  booleanOptions: ReadonlySet<string>,
+  valueOptions: ReadonlySet<string>,
+): ParseArgumentsResult {
+  const positionals: Array<string> = [];
+  const options = new Map<string, string | true>();
+
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === undefined) continue;
+    if (!argument.startsWith("--")) {
+      positionals.push(argument);
+      continue;
     }
-    dependencies.stderr(`Unknown review choice: ${input}`);
+
+    const separator = argument.indexOf("=");
+    const name = argument.slice(2, separator < 0 ? undefined : separator);
+    const inlineValue = separator < 0 ? undefined : argument.slice(separator + 1);
+    if (options.has(name)) {
+      return { parsed: undefined, error: `duplicate option: --${name}` };
+    }
+
+    if (booleanOptions.has(name)) {
+      if (inlineValue !== undefined) {
+        return {
+          parsed: undefined,
+          error: `option --${name} does not accept a value`,
+        };
+      }
+      options.set(name, true);
+      continue;
+    }
+
+    if (!valueOptions.has(name)) {
+      return { parsed: undefined, error: `unknown option: --${name}` };
+    }
+
+    const followingValue = args[index + 1];
+    const value = inlineValue ??
+      (followingValue !== undefined && !followingValue.startsWith("--")
+        ? followingValue
+        : undefined);
+    if (value === undefined) {
+      return {
+        parsed: undefined,
+        error: `option --${name} requires a value`,
+      };
+    }
+    if (inlineValue === undefined) index += 1;
+    options.set(name, value);
   }
+
+  return { parsed: { positionals, options }, error: undefined };
+}
+
+function getStringOption(
+  parsed: ParsedArguments,
+  name: string,
+): string | undefined {
+  const value = parsed.options.get(name);
+  return typeof value === "string" ? value : undefined;
+}
+
+function hasOption(parsed: ParsedArguments, name: string): boolean {
+  return parsed.options.has(name);
+}
+
+function isTrainingReviewFilter(value: string): value is TrainingReviewFilter {
+  return value === "all" ||
+    value === "unreviewed" ||
+    value === "allow" ||
+    value === "ask" ||
+    value === "deny";
+}
+
+function isDecision(value: string): value is "allow" | "ask" | "deny" {
+  return value === "allow" || value === "ask" || value === "deny";
 }
 
-function printTrainingRecord(
-  record: TrainingRecord,
-  index: number,
-  total: number,
+function trainingListRecord(entry: TrainingReviewEntry): object {
+  return {
+    status: getTrainingReviewFilter(entry),
+    record: entry.record,
+    reviews: entry.reviews,
+    latestReview: getLatestTrainingReview(entry) ?? null,
+  };
+}
+
+function summarizeTrainingCommand(command: string): string {
+  return command.replaceAll(/\s+/g, " ").trim();
+}
+
+function writeTrainingUsageError(
+  operation: string,
+  json: boolean,
+  message: string,
   dependencies: CliDependencies,
-): void {
-  dependencies.stdout("");
-  dependencies.stdout(
-    `[${index}/${total}] ${record.recordedAt} · ${record.mode} · host ${record.hostAction}`,
-  );
-  dependencies.stdout(`cwd: ${record.cwd}`);
-  dependencies.stdout(`command: ${record.command}`);
-  dependencies.stdout(
-    `verdict: ${record.verdict.decision.toUpperCase()} — ${record.verdict.reason}`,
-  );
-  if (record.verdict.judgments !== undefined) {
-    dependencies.stdout(
-      `judgments: ${JSON.stringify(record.verdict.judgments)}`,
+): number {
+  if (json) {
+    writeTrainingJsonError(
+      operation,
+      "invalid_arguments",
+      message,
+      dependencies,
     );
+  } else {
+    dependencies.stderr(`demur: ${message}`);
+    dependencies.stderr(USAGE);
   }
-  if (record.verdict.failure !== undefined) {
-    dependencies.stdout(`failure: ${record.verdict.failure}`);
+  return 2;
+}
+
+function writeTrainingDomainError(
+  operation: string,
+  json: boolean,
+  code: string,
+  message: string,
+  dependencies: CliDependencies,
+): number {
+  if (json) {
+    writeTrainingJsonError(operation, code, message, dependencies);
+  } else {
+    dependencies.stderr(`demur: ${message}`);
   }
+  return 1;
+}
+
+function writeTrainingJsonSuccess(
+  operation: string,
+  result: unknown,
+  dependencies: CliDependencies,
+): void {
+  dependencies.stdout(JSON.stringify({ version: 1, ok: true, operation, result }));
+}
+
+function writeTrainingJsonError(
+  operation: string,
+  code: string,
+  message: string,
+  dependencies: CliDependencies,
+): void {
+  dependencies.stdout(JSON.stringify({
+    version: 1,
+    ok: false,
+    operation,
+    error: { code, message },
+  }));
+}
+
+function isTrainingJsonRequest(args: ReadonlyArray<string>): boolean {
+  return args[0] === "training" && args.includes("--json");
+}
+
+function trainingOperation(args: ReadonlyArray<string>): string {
+  return `training.${args[1] ?? "unknown"}`;
 }
 
 async function runJudge(
@@ -403,26 +693,6 @@ async function runJudge(
   return 0;
 }
 
-async function readLine(prompt: string): Promise<string> {
-  if (lineInput === undefined) {
-    const terminal = createInterface({ input: process.stdin });
-    lineInput = {
-      terminal,
-      lines: terminal[Symbol.asyncIterator](),
-    };
-  }
-
-  process.stderr.write(prompt);
-  const next = await lineInput.lines.next();
-  if (next.done) throw new Error("training review input ended");
-  return next.value;
-}
-
-function closeLineInput(): void {
-  lineInput?.terminal.close();
-  lineInput = undefined;
-}
-
 async function readSecret(prompt: string): Promise<string> {
   if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== "function") {
     return (await Bun.stdin.text()).trim();

package/src/settings-model.ts

@@ -0,0 +1,60 @@
+import {
+  DEMUR_MODES,
+  FAILURE_POLICIES,
+  type DemurSettings,
+} from "../extensions/demur/settings.ts";
+
+/**
+ * Settings exposed by both the Pi extension menu and the central TUI.
+ */
+export type DemurSettingKey = "mode" | "training" | "failurePolicy";
+
+/**
+ * Move one persisted demur setting to its next or previous supported value.
+ *
+ * Selecting disabled mode always turns training capture off. Training cannot be
+ * changed while disabled, matching the persisted configuration invariant.
+ *
+ * @param settings - Current persisted settings
+ * @param key - Setting to change
+ * @param direction - Positive for the next value, negative for the previous
+ * @returns The updated settings, or the original object when no change is valid
+ */
+export function changeDemurSetting(
+  settings: DemurSettings,
+  key: DemurSettingKey,
+  direction: number,
+): DemurSettings {
+  if (key === "training") {
+    if (settings.mode === "disabled") return settings;
+    return { ...settings, training: !settings.training };
+  }
+
+  if (key === "mode") {
+    const mode = cycleValue(DEMUR_MODES, settings.mode, direction);
+    return {
+      ...settings,
+      mode,
+      training: mode === "disabled" ? false : settings.training,
+    };
+  }
+
+  return {
+    ...settings,
+    failurePolicy: cycleValue(
+      FAILURE_POLICIES,
+      settings.failurePolicy,
+      direction,
+    ),
+  };
+}
+
+function cycleValue<Value>(
+  values: ReadonlyArray<Value>,
+  current: Value,
+  direction: number,
+): Value {
+  const currentIndex = values.indexOf(current);
+  const offset = direction < 0 ? values.length - 1 : 1;
+  return values[(currentIndex + offset) % values.length] ?? current;
+}

package/src/training-review-model.ts

@@ -119,7 +119,7 @@ export function filterTrainingReviewEntries(
  *
  * @param record - Training evidence being reviewed
  * @param expectedDecision - Human-selected expected outcome
- * @param note - Optional correction explanation
+ * @param note - Optional explanation for the human decision
  * @returns Normalized review input for persistence
  */
 export function createTrainingReviewInput(
@@ -127,12 +127,11 @@ export function createTrainingReviewInput(
   expectedDecision: Decision,
   note: string | undefined,
 ): TrainingReviewInput {
-  const corrected = expectedDecision !== record.verdict.decision;
   return {
     recordId: record.id,
     originalDecision: record.verdict.decision,
     expectedDecision,
-    note: corrected ? note?.trim() || undefined : undefined,
+    note: note?.trim() || undefined,
   };
 }
 

package/src/training-review-tui.tsx

@@ -12,10 +12,15 @@ import {
   estimateInputCostUsd,
   formatUsd,
 } from "../extensions/demur/cost-tracker.ts";
+import type { DemurSettings } from "../extensions/demur/settings.ts";
 import type {
   TrainingReview,
   TrainingReviewInput,
 } from "../extensions/demur/training-store.ts";
+import {
+  changeDemurSetting,
+  type DemurSettingKey,
+} from "./settings-model.ts";
 import {
   buildTrainingReviewEntries,
   createTrainingReviewInput,
@@ -38,8 +43,11 @@ const COLORS = {
   text: "#eceff4",
   muted: "#8f98a8",
   allow: "#a3be8c",
+  allowMuted: "#78906a",
   ask: "#ebcb8b",
+  askMuted: "#a28f68",
   deny: "#bf616a",
+  denyMuted: "#87515a",
   selection: "#2e3440",
   error: "#ff6b7a",
 } as const;
@@ -55,6 +63,33 @@ const FILTERS: ReadonlyArray<{
   { value: "deny", label: "deny" },
 ];
 
+const SECTIONS: ReadonlyArray<{ value: AppSection; label: string }> = [
+  { value: "reviews", label: "Reviews" },
+  { value: "settings", label: "Settings" },
+];
+
+const SETTING_ROWS: ReadonlyArray<{
+  key: DemurSettingKey;
+  label: string;
+  description: string;
+}> = [
+  {
+    key: "mode",
+    label: "Operating mode",
+    description: "Enforce decisions, observe passively, or bypass the guard.",
+  },
+  {
+    key: "training",
+    label: "Training capture",
+    description: "Append full evaluations for later human review.",
+  },
+  {
+    key: "failurePolicy",
+    label: "Failure policy",
+    description: "Action when no trustworthy judgment is available.",
+  },
+];
+
 /**
  * Summary returned after an interactive training-review session.
  */
@@ -66,8 +101,10 @@ export type TrainingReviewTuiResult = {
 
 type TrainingReviewAppProps = {
   snapshot: TrainingReviewSnapshot;
+  settings: DemurSettings;
   reloadSnapshot(): Promise<TrainingReviewSnapshot>;
   recordReview(input: TrainingReviewInput): Promise<TrainingReview>;
+  saveSettings(settings: DemurSettings): Promise<void>;
   pollIntervalMs: number | undefined;
   onExit(result: TrainingReviewTuiResult): void;
 };
@@ -77,7 +114,15 @@ type NoteEditorState = {
   expectedDecision: Decision;
 };
 
-type FocusTarget = "tabs" | "filter" | "queue" | "detail";
+type AppSection = "reviews" | "settings";
+
+type FocusTarget =
+  | "sections"
+  | "tabs"
+  | "filter"
+  | "queue"
+  | "detail"
+  | "settings";
 
 /**
  * Render the interactive historical training-review queue.
@@ -93,6 +138,11 @@ export function TrainingReviewApp(
   const [snapshot, setSnapshot] = useState<TrainingReviewSnapshot>(
     props.snapshot,
   );
+  const [section, setSection] = useState<AppSection>("reviews");
+  const [settings, setSettings] = useState<DemurSettings>(props.settings);
+  const [selectedSettingIndex, setSelectedSettingIndex] = useState(0);
+  const [savingSettings, setSavingSettings] = useState(false);
+  const [settingsError, setSettingsError] = useState<string | undefined>();
   const [activeFilter, setActiveFilter] = useState<TrainingReviewFilter>(
     "all",
   );
@@ -147,7 +197,7 @@ export function TrainingReviewApp(
     : Math.max(7, Math.min(11, Math.floor(height * 0.32)));
   const queuePageSize = Math.max(
     1,
-    Math.floor((horizontal ? height - 13 : queueSize - 2) / 2),
+    Math.floor((horizontal ? height - 16 : queueSize - 2) / 2),
   );
   useEffect(() => {
     const timer = setTimeout(() => setReady(true), 250);
@@ -204,6 +254,26 @@ export function TrainingReviewApp(
     props.onExit(nextResult);
   };
 
+  const persistSetting = async (
+    key: DemurSettingKey,
+    direction: number,
+  ) => {
+    if (savingSettings) return;
+    const nextSettings = changeDemurSetting(settings, key, direction);
+    if (nextSettings === settings) return;
+
+    setSavingSettings(true);
+    setSettingsError(undefined);
+    try {
+      await props.saveSettings(nextSettings);
+      setSettings(nextSettings);
+    } catch (cause: unknown) {
+      setSettingsError(errorDetail(cause));
+    } finally {
+      setSavingSettings(false);
+    }
+  };
+
   const persistDecision = async (
     entry: TrainingReviewEntry,
     expectedDecision: Decision,
@@ -323,6 +393,73 @@ export function TrainingReviewApp(
       return;
     }
 
+    const sectionKey = key.sequence || key.name;
+    if (focus !== "filter" && (sectionKey === "[" || sectionKey === "]")) {
+      key.preventDefault();
+      const nextSection = sectionKey === "[" ? "reviews" : "settings";
+      setSection(nextSection);
+      setFocus(nextSection === "reviews" ? "tabs" : "settings");
+      return;
+    }
+
+    if (focus === "sections") {
+      if (key.name === "left" || key.name === "right") {
+        key.preventDefault();
+        setSection((current) =>
+          current === "reviews" ? "settings" : "reviews"
+        );
+        return;
+      }
+      if (key.name === "down" || key.name === "return") {
+        key.preventDefault();
+        setFocus(section === "reviews" ? "tabs" : "settings");
+        return;
+      }
+      if (key.name === "q" || key.name === "escape") {
+        key.preventDefault();
+        finish(result);
+      }
+      return;
+    }
+
+    if (section === "settings") {
+      if (key.name === "q" || key.name === "escape") {
+        key.preventDefault();
+        finish(result);
+        return;
+      }
+      if (key.name === "up") {
+        key.preventDefault();
+        if (selectedSettingIndex === 0) {
+          setFocus("sections");
+        } else {
+          setSelectedSettingIndex((current) => current - 1);
+        }
+        return;
+      }
+      if (key.name === "down") {
+        key.preventDefault();
+        setSelectedSettingIndex((current) =>
+          Math.min(current + 1, SETTING_ROWS.length - 1)
+        );
+        return;
+      }
+      if (
+        key.name === "left" ||
+        key.name === "right" ||
+        key.name === "return" ||
+        key.name === "space" ||
+        key.sequence === " "
+      ) {
+        key.preventDefault();
+        const row = SETTING_ROWS[selectedSettingIndex];
+        if (row !== undefined) {
+          void persistSetting(row.key, key.name === "left" ? -1 : 1);
+        }
+      }
+      return;
+    }
+
     if (key.name === "tab") {
       key.preventDefault();
       rotateFilter(key.shift);
@@ -330,6 +467,11 @@ export function TrainingReviewApp(
     }
 
     if (focus === "tabs") {
+      if (key.name === "up") {
+        key.preventDefault();
+        setFocus("sections");
+        return;
+      }
       if (key.name === "left" || key.name === "right") {
         key.preventDefault();
         moveFilterSelection(key.name === "left" ? -1 : 1);
@@ -461,6 +603,42 @@ export function TrainingReviewApp(
       </box>
 
       <box
+        title=" View "
+        titleColor={focus === "sections" ? COLORS.accent : COLORS.muted}
+        flexDirection="row"
+        gap={1}
+        border
+        borderColor={focus === "sections" ? COLORS.accent : COLORS.border}
+        backgroundColor={COLORS.panel}
+        height={3}
+        paddingLeft={1}
+        paddingRight={1}
+      >
+        {SECTIONS.map((candidate) => {
+          const active = candidate.value === section;
+          return (
+            <text
+              key={candidate.value}
+              fg={active ? COLORS.accent : COLORS.muted}
+              bg={active ? COLORS.selection : COLORS.background}
+              onMouseDown={() => {
+                setSection(candidate.value);
+                setFocus("sections");
+              }}
+            >
+              {` ${candidate.label} `}
+            </text>
+          );
+        })}
+        <text fg={COLORS.muted}>[ / ] switch · Up to focus · ←/→ switch</text>
+      </box>
+
+      {section === "reviews"
+        ? (
+          <>
+      <box
+        title=" Review status "
+        titleColor={focus === "tabs" ? COLORS.accent : COLORS.muted}
         flexDirection="row"
         gap={1}
         border
@@ -568,13 +746,28 @@ export function TrainingReviewApp(
                         setFocus("queue");
                       }}
                     >
-                      <text fg={entrySelected
-                        ? statusColor(getTrainingReviewFilter(entry))
-                        : COLORS.text}>
+                      <text
+                        fg={entrySelected
+                          ? statusColor(getTrainingReviewFilter(entry))
+                          : COLORS.text}
+                        wrapMode="none"
+                        truncate
+                      >
                         {`${entrySelected ? "▶" : " "} ${summarizeCommand(entry.record.command, horizontal ? queueSize - 6 : width - 8)}`}
                       </text>
-                      <text fg={entrySelected ? COLORS.accent : COLORS.muted}>
-                        {`  ${statusLabel(getTrainingReviewFilter(entry))} · ${formatEvaluationCost(entry)} · ${entry.reviews.length}r`}
+                      <text
+                        fg={entrySelected ? COLORS.accent : COLORS.muted}
+                        wrapMode="none"
+                        truncate
+                      >
+                        {`  ${statusLabel(getTrainingReviewFilter(entry))} · `}
+                        <span
+                          fg={mutedDecisionColor(
+                            entry.record.verdict.decision,
+                          )}
+                        >
+                          {entry.record.verdict.decision.toUpperCase()}
+                        </span>
                       </text>
                     </box>
                   );
@@ -704,7 +897,7 @@ export function TrainingReviewApp(
       <box flexDirection="row" justifyContent="space-between">
         <text fg={COLORS.muted}>
           {focus === "tabs"
-            ? "←/→ select status · Down/Enter filter · Tab rotates"
+            ? "←/→ select status · Up sections · Down/Enter filter · Tab rotates"
             : focus === "filter"
             ? "Type to fuzzy-search cwd · Up tabs · Down/Enter queue · Tab rotates"
             : focus === "detail"
@@ -715,6 +908,81 @@ export function TrainingReviewApp(
           {saving ? "Saving…" : "q/Esc quit"}
         </text>
       </box>
+          </>
+        )
+        : (
+          <>
+            <box
+              title=" Pi extension settings "
+              titleColor={COLORS.accent}
+              border
+              borderColor={COLORS.accent}
+              backgroundColor={COLORS.panel}
+              flexGrow={1}
+              flexDirection="column"
+              padding={1}
+              gap={1}
+            >
+              <text fg={COLORS.muted} wrapMode="word">
+                Changes are saved globally and picked up by Pi before its next Bash call.
+              </text>
+              {SETTING_ROWS.map((row, index) => {
+                const selectedRow = index === selectedSettingIndex;
+                const unavailable = row.key === "training" &&
+                  settings.mode === "disabled";
+                return (
+                  <box
+                    key={row.key}
+                    flexDirection="column"
+                    backgroundColor={selectedRow
+                      ? COLORS.selection
+                      : COLORS.panel}
+                    paddingLeft={1}
+                    paddingRight={1}
+                    onMouseDown={() => {
+                      setSelectedSettingIndex(index);
+                      setFocus("settings");
+                    }}
+                  >
+                    <box flexDirection="row">
+                      <text
+                        width={24}
+                        fg={selectedRow ? COLORS.accent : COLORS.text}
+                      >
+                        {`${selectedRow ? "▶" : " "} ${row.label}`}
+                      </text>
+                      <text fg={unavailable ? COLORS.muted : COLORS.allow}>
+                        {settingDisplayValue(settings, row.key)}
+                      </text>
+                    </box>
+                    <text fg={COLORS.muted} wrapMode="word">
+                      {unavailable
+                        ? "Unavailable while the operating mode is disabled."
+                        : row.description}
+                    </text>
+                  </box>
+                );
+              })}
+            </box>
+
+            {settingsError === undefined
+              ? null
+              : (
+                <text fg={COLORS.error}>
+                  Could not save settings: {settingsError}
+                </text>
+              )}
+
+            <box flexDirection="row" justifyContent="space-between">
+              <text fg={COLORS.muted}>
+                ↑/↓ select · ←/→ change · Enter/Space next · [ reviews
+              </text>
+              <text fg={savingSettings ? COLORS.ask : COLORS.muted}>
+                {savingSettings ? "Saving…" : "q/Esc quit"}
+              </text>
+            </box>
+          </>
+        )}
     </box>
   );
 }
@@ -766,14 +1034,18 @@ function JudgmentsTable(props: { entry: TrainingReviewEntry }): React.ReactNode
  * Launch OpenTUI for complete training history and restore the terminal on exit.
  *
  * @param snapshot - Complete training state to present initially
+ * @param settings - Current globally persisted Pi extension settings
  * @param reloadSnapshot - Polling callback that returns current training state
  * @param recordReview - Persistence callback for review revisions
+ * @param saveSettings - Atomic persistence callback for Pi extension settings
  * @returns Counts for the completed interactive session
  */
 export async function runTrainingReviewTui(
   snapshot: TrainingReviewSnapshot,
+  settings: DemurSettings,
   reloadSnapshot: () => Promise<TrainingReviewSnapshot>,
   recordReview: (input: TrainingReviewInput) => Promise<TrainingReview>,
+  saveSettings: (settings: DemurSettings) => Promise<void>,
 ): Promise<TrainingReviewTuiResult> {
   const renderer = await createCliRenderer({
     exitOnCtrlC: false,
@@ -796,8 +1068,10 @@ export async function runTrainingReviewTui(
     root.render(
       <TrainingReviewApp
         snapshot={snapshot}
+        settings={settings}
         reloadSnapshot={reloadSnapshot}
         recordReview={recordReview}
+        saveSettings={saveSettings}
         pollIntervalMs={undefined}
         onExit={finish}
       />,
@@ -805,6 +1079,15 @@ export async function runTrainingReviewTui(
   });
 }
 
+function settingDisplayValue(
+  settings: DemurSettings,
+  key: DemurSettingKey,
+): string {
+  if (key === "mode") return settings.mode;
+  if (key === "training") return settings.training ? "on" : "off";
+  return settings.failurePolicy;
+}
+
 function countByFilter(
   entries: ReadonlyArray<TrainingReviewEntry>,
 ): Record<TrainingReviewFilter, number> {
@@ -871,6 +1154,14 @@ function decisionColor(decision: Decision): string {
   }[decision];
 }
 
+function mutedDecisionColor(decision: Decision): string {
+  return {
+    allow: COLORS.allowMuted,
+    ask: COLORS.askMuted,
+    deny: COLORS.denyMuted,
+  }[decision];
+}
+
 function emptyTitle(
   entries: ReadonlyArray<TrainingReviewEntry>,
   cwdQuery: string,
@@ -928,13 +1219,6 @@ function judgmentRows(
   ];
 }
 
-function formatEvaluationCost(entry: TrainingReviewEntry): string {
-  const inputTokens = entry.record.verdict.usage?.inputTokens;
-  return inputTokens === undefined
-    ? "cost n/a"
-    : formatUsd(estimateInputCostUsd(inputTokens));
-}
-
 function formatUsage(entry: TrainingReviewEntry): string {
   const usage = entry.record.verdict.usage;
   return usage === undefined