@wrongstack/cli 1.0.19 → 1.0.26

package/dist/typesafe-brain-replay-C5276FVR.js

@@ -0,0 +1,222 @@
+
+// src/subcommands/handlers/typesafe-brain-replay.ts
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+import {
+  probeSystemOneBrain,
+  systemOneBrainSettles
+} from "@wrongstack/core/execution";
+import { resolveTypeSafeAccount } from "@wrongstack/core/typesafe";
+import { color } from "@wrongstack/core/utils";
+var MONITOR_OPTIONS = [
+  {
+    id: "steer",
+    label: "Steer the agent with corrective guidance",
+    consequence: "A steer message is injected before its next step."
+  },
+  { id: "continue", label: "Let the agent continue unaided" }
+];
+function monitorKind(question) {
+  if (/has been edited \d+ times within/.test(question)) return "file_churn";
+  if (/has failed \d+ times in a row/.test(question)) return "tool_failure";
+  if (/no observable progress/.test(question)) return "stall";
+  if (/errors occurred within/.test(question)) return "error_storm";
+  return void 0;
+}
+function monitorContext(kind, question) {
+  if (kind === "file_churn") {
+    const m = /file "([^"]+)" has been edited (\d+) times within (\d+) minutes/.exec(question);
+    if (m) return `File: ${m[1]}
+Edits in window: ${m[2]}
+Window: ${Number(m[3]) * 60}s`;
+  }
+  if (kind === "tool_failure") {
+    const m = /tool "([^"]+)" has failed (\d+) times/.exec(question);
+    if (m) return `Tool: ${m[1]}
+Consecutive failures: ${m[2]}`;
+  }
+  return question;
+}
+function parseFlag(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+async function replayBrainLedger(deps, write) {
+  const flags = deps.flags ?? {};
+  const account = resolveTypeSafeAccount({ config: deps.config, restGate: null });
+  if (account.status !== "ready") {
+    write(`${color.red("\u2717")} ${account.reason}. Run \`wstack typesafe login\`.`);
+    return 2;
+  }
+  const ledgerPath = typeof flags["ledger"] === "string" ? path.resolve(flags["ledger"]) : path.join(deps.paths.projectDir, "brain-ledger.jsonl");
+  const perKind = parseFlag(flags["limit"], 40);
+  const onlyKind = typeof flags["kind"] === "string" ? flags["kind"] : void 0;
+  let raw;
+  try {
+    raw = await readFile(ledgerPath, "utf8");
+  } catch (err) {
+    write(`${color.red("\u2717")} cannot read ${ledgerPath}: ${err.message}`);
+    return 2;
+  }
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  const outcomes = /* @__PURE__ */ new Map();
+  for (const r of rows) if (r.kind === "outcome" && r.outcome) outcomes.set(r.requestId, r.outcome);
+  const byKind = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of rows) {
+    if (r.kind !== "answered" || !r.question || !r.optionId) continue;
+    if (r.optionId !== "steer" && r.optionId !== "continue") continue;
+    const kind = monitorKind(r.question);
+    if (!kind || onlyKind && kind !== onlyKind || seen.has(r.question)) continue;
+    seen.add(r.question);
+    const list = byKind.get(kind) ?? [];
+    list.push({
+      kind,
+      question: r.question,
+      recorded: r.optionId,
+      recordedBy: r.detail?.startsWith("Council") ? "council" : "other",
+      outcome: outcomes.get(r.requestId)
+    });
+    byKind.set(kind, list);
+  }
+  const cases = [];
+  for (const list of byKind.values()) {
+    const step = Math.max(1, list.length / perKind);
+    for (let i = 0; i < list.length && cases.length < 1e4; i += step) {
+      const picked = list[Math.floor(i)];
+      if (picked) cases.push(picked);
+      if (cases.filter((c) => c.kind === picked?.kind).length >= perKind) break;
+    }
+  }
+  if (cases.length === 0) {
+    write("No replayable BrainMonitor decisions in the ledger.");
+    return 0;
+  }
+  if (flags["json"] !== true) {
+    write(color.dim(`Replaying ${cases.length} decision(s) from ${ledgerPath}\u2026`));
+  }
+  const judge = { client: account.client, model: account.model, feature: "brain" };
+  const CONCURRENCY = 8;
+  for (let i = 0; i < cases.length; i += CONCURRENCY) {
+    await Promise.all(
+      cases.slice(i, i + CONCURRENCY).map(async (c) => {
+        const request = {
+          id: `replay-${i}`,
+          source: "system",
+          question: c.question,
+          context: monitorContext(c.kind, c.question),
+          risk: "medium",
+          fallback: "ask_human",
+          options: MONITOR_OPTIONS
+        };
+        try {
+          c.probe = await probeSystemOneBrain(judge, request, { timeoutMs: 15e3 });
+          if (!c.probe) c.error = "malformed answer";
+        } catch (err) {
+          c.error = err instanceof Error ? err.message : String(err);
+        }
+      })
+    );
+  }
+  const report = summarize(cases);
+  if (flags["json"] === true) {
+    write(JSON.stringify({ ledger: ledgerPath, ...report }, null, 2));
+    return 0;
+  }
+  const pct = (a, b) => b === 0 ? "\u2014" : `${Math.round(a / b * 100)}%`;
+  for (const k of report.kinds) {
+    write(color.bold(`${k.kind}`) + color.dim(`  n=${k.n} (council ${k.council})`));
+    write(
+      `  recorded   steer ${k.recordedSteer} / continue ${k.n - k.recordedSteer}   Jev steer ${k.jevSteer} / continue ${k.judged - k.jevSteer}`
+    );
+    write(`  agreement  ${pct(k.agree, k.judged)} of ${k.judged} judged`);
+    write(
+      `  settles    ${pct(k.settled, k.judged)} at current thresholds, agreeing ${pct(k.settledAgree, k.settled)}`
+    );
+    if (k.futileSteers > 0) {
+      write(
+        `  futile steers (signal re-fired): ${k.futileSteers}, Jev said continue on ${k.futileSteersJevContinue}`
+      );
+    }
+  }
+  write("");
+  write(color.bold("Sweep (decidable threshold; confidence/probability at defaults)"));
+  for (const s of report.sweep) {
+    write(
+      `  decidable \u2265 ${s.threshold.toFixed(2)}  settles ${pct(s.settled, report.judged)}  agreeing ${pct(s.agree, s.settled)}`
+    );
+  }
+  if (report.errors > 0) write(color.amber(`${report.errors} case(s) not judged (host error).`));
+  write(color.dim(`model ${report.model ?? account.model}`));
+  write(
+    color.dim(
+      "Replayed contexts lack the tool output the live monitor attaches, so tool_failure reads as signal-only here."
+    )
+  );
+  return 0;
+}
+function summarize(cases) {
+  const kinds = [...new Set(cases.map((c) => c.kind))].map((kind) => {
+    const list = cases.filter((c) => c.kind === kind);
+    const judged2 = list.filter((c) => c.probe);
+    const settled = judged2.filter((c) => systemOneBrainSettles(c.probe));
+    const futile = list.filter((c) => c.recorded === "steer" && c.outcome === "failure");
+    return {
+      kind,
+      n: list.length,
+      council: list.filter((c) => c.recordedBy === "council").length,
+      recordedSteer: list.filter((c) => c.recorded === "steer").length,
+      judged: judged2.length,
+      jevSteer: judged2.filter((c) => c.probe.optionId === "steer").length,
+      agree: judged2.filter((c) => c.probe.optionId === c.recorded).length,
+      settled: settled.length,
+      settledAgree: settled.filter((c) => c.probe.optionId === c.recorded).length,
+      futileSteers: futile.length,
+      futileSteersJevContinue: futile.filter((c) => c.probe?.optionId === "continue").length
+    };
+  });
+  const judged = cases.filter((c) => c.probe);
+  const sweep = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6].map((threshold) => {
+    const settled = judged.filter(
+      (c) => c.probe.decidable >= threshold && systemOneBrainSettles(c.probe, { minDecidable: 0 })
+    );
+    return {
+      threshold,
+      settled: settled.length,
+      agree: settled.filter((c) => c.probe.optionId === c.recorded).length
+    };
+  });
+  return {
+    kinds,
+    sweep,
+    judged: judged.length,
+    errors: cases.filter((c) => c.error).length,
+    model: judged[0]?.probe?.model,
+    cases: judged.map((c) => ({
+      kind: c.kind,
+      recorded: c.recorded,
+      jev: c.probe.optionId,
+      p: Number(c.probe.probability.toFixed(3)),
+      decidable: Number(c.probe.decidable.toFixed(3))
+    })),
+    disagreements: judged.filter((c) => c.probe.optionId !== c.recorded).slice(0, 20).map((c) => ({
+      kind: c.kind,
+      question: c.question.slice(0, 200),
+      recorded: c.recorded,
+      jev: c.probe.optionId,
+      p: Number(c.probe.probability.toFixed(3)),
+      decidable: Number(c.probe.decidable.toFixed(3))
+    }))
+  };
+}
+export {
+  replayBrainLedger
+};
+//# sourceMappingURL=typesafe-brain-replay-C5276FVR.js.map

package/dist/typesafe-judgment-check-GGYYV5UF.js

@@ -0,0 +1,29 @@
+
+// src/subcommands/handlers/typesafe-judgment-check.ts
+import { checkJevJudgments } from "@wrongstack/runtime/jev-checks";
+async function checkJudgments(deps, write) {
+  try {
+    const report = await checkJevJudgments(deps.config);
+    let feature = "";
+    for (const result of report.cases) {
+      if (feature !== result.feature) {
+        feature = result.feature;
+        write(feature);
+      }
+      write(
+        `${result.ok ? "\u2713" : "\u2717"} ${result.name} (${result.ms}ms) \u2014 expected ${result.expected}, got ${result.actual}${result.note ? ` [${result.note}]` : ""}`
+      );
+    }
+    write(
+      `${report.passed}/${report.total} as expected \u2014 ${report.route} route, model ${report.model}`
+    );
+    return report.passed === report.total ? 0 : 1;
+  } catch {
+    write("Jev checks unavailable. Configure an account with wstack typesafe login.");
+    return 2;
+  }
+}
+export {
+  checkJudgments
+};
+//# sourceMappingURL=typesafe-judgment-check-GGYYV5UF.js.map

package/dist/typesafe-topic-replay-ZILIU3WS.js

@@ -0,0 +1,234 @@
+import {
+  resolveRuntimeMaxContext
+} from "./chunk-CZTXF6HY.js";
+import {
+  createProviderForId
+} from "./chunk-BBHWW6LR.js";
+
+// src/subcommands/handlers/typesafe-topic-replay.ts
+import { readdir, readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { gunzip } from "node:zlib";
+import { TopicShiftAdvisor } from "@wrongstack/core/execution";
+import { resolveTypeSafeAccount } from "@wrongstack/core/typesafe";
+import { color } from "@wrongstack/core/utils";
+var gunzipAsync = promisify(gunzip);
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((b) => b?.type === "text").map((b) => b.text).join("\n");
+}
+async function sessionFiles(root) {
+  const out = [];
+  let days;
+  try {
+    days = await readdir(root);
+  } catch {
+    return out;
+  }
+  for (const day of days.sort()) {
+    let entries;
+    try {
+      entries = await readdir(path.join(root, day));
+    } catch {
+      continue;
+    }
+    for (const name of entries.sort()) {
+      if (/^sess_[^.]+\.jsonl(\.gz)?$/.test(name)) out.push(path.join(root, day, name));
+    }
+  }
+  return out;
+}
+async function promptPoints(file) {
+  const buf = await readFile(file);
+  const raw = file.endsWith(".gz") ? (await gunzipAsync(buf)).toString("utf8") : buf.toString("utf8");
+  const messages = [];
+  const points = [];
+  let contextTokens;
+  let previousPrompt = "";
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e["type"] === "llm_request" && typeof e["estimatedInputTokens"] === "number") {
+      contextTokens = e["estimatedInputTokens"];
+    } else if (e["type"] === "user_input") {
+      const prompt = textOf(e["content"]).trim();
+      if (prompt) {
+        points.push({
+          session: path.basename(file).replace(/\.jsonl(\.gz)?$/, ""),
+          prompt,
+          previousPrompt,
+          messages: [...messages],
+          contextTokens
+        });
+        previousPrompt = prompt;
+      }
+    } else if (e["type"] === "message_appended") {
+      const m = e["message"];
+      if (m && (m.role === "user" || m.role === "assistant")) {
+        const text = textOf(m.content).trim();
+        if (text) messages.push({ role: m.role, content: text });
+      }
+    }
+  }
+  return points;
+}
+async function replayTopicShift(deps, write) {
+  const flags = deps.flags ?? {};
+  const json = flags["json"] === true;
+  const account = resolveTypeSafeAccount({ config: deps.config, restGate: null });
+  if (account.status !== "ready") {
+    write(`${color.red("\u2717")} ${account.reason}. Run \`wstack typesafe login\`.`);
+    return 2;
+  }
+  const limit = Math.max(1, Number(flags["limit"]) || 40);
+  const sessionsRoot = typeof flags["sessions"] === "string" ? path.resolve(flags["sessions"]) : path.join(deps.paths.projectDir, "sessions");
+  const providerId = typeof flags["provider"] === "string" ? flags["provider"] : deps.config.provider;
+  const model = typeof flags["model"] === "string" ? flags["model"] : deps.config.model;
+  const flagMaxContext = Number(flags["max-context"]);
+  const maxContext = Number.isFinite(flagMaxContext) && flagMaxContext > 0 ? Math.floor(flagMaxContext) : await resolveRuntimeMaxContext({
+    modelsRegistry: deps.modelsRegistry,
+    config: deps.config,
+    provider: { capabilities: { maxContext: 0 } },
+    providerId,
+    modelId: model
+  }).catch(() => 0);
+  if (maxContext <= 0) {
+    write(
+      `${color.red("\u2717")} Context window of ${providerId}/${model} is unknown. Pass --max-context <tokens>.`
+    );
+    return 2;
+  }
+  const provider = flags["no-llm"] === true ? void 0 : createProviderForId(providerId, deps.config);
+  const judge = { client: account.client, model: account.model, feature: "topicShift" };
+  const reached = [];
+  let scanned = 0;
+  const files = await sessionFiles(sessionsRoot);
+  for (const file of files.reverse()) {
+    if (reached.length >= limit) break;
+    let points;
+    try {
+      points = await promptPoints(file);
+    } catch {
+      continue;
+    }
+    for (const point of points) {
+      if (reached.length >= limit) break;
+      scanned++;
+      let gate = false;
+      let jevNoul;
+      let jevError;
+      const jevAdvisor = new TopicShiftAdvisor({
+        getJudge: () => judge,
+        onDiagnostic: (d) => {
+          if (d.stage === "gate") gate = true;
+          if (d.stage === "system-one") {
+            jevNoul = d.noul;
+            jevError = d.error;
+          }
+        }
+      });
+      await jevAdvisor.advise({
+        prompt: point.prompt,
+        messages: point.messages,
+        contextTokens: point.contextTokens,
+        maxContext
+      });
+      if (!gate) continue;
+      const c = { ...point, jevNoul, jevError };
+      if (provider?.complete) {
+        let failure;
+        const llmAdvisor = new TopicShiftAdvisor({
+          onDiagnostic: (d) => {
+            if (d.stage === "model" && !d.parsed) {
+              failure = d.error ?? (d.text?.trim() ? "unparseable reply" : "empty reply");
+            }
+          }
+        });
+        const advice = await llmAdvisor.advise({
+          prompt: point.prompt,
+          messages: point.messages,
+          provider,
+          model,
+          contextTokens: point.contextTokens,
+          maxContext
+        });
+        if (advice.source === "model") {
+          c.llm = advice.suggestNewContext ? "new" : "same";
+          c.llmConfidence = advice.confidence;
+        } else {
+          c.llmFailure = failure ?? `no model answer (${advice.source})`;
+        }
+      }
+      reached.push(c);
+    }
+  }
+  const bucket = (n) => n === void 0 ? "none" : n >= 0.8 ? "new" : n <= 0.3 ? "same" : "unsure";
+  if (json) {
+    write(
+      JSON.stringify(
+        {
+          sessionsRoot,
+          scanned,
+          llm: provider ? `${providerId}/${model}` : null,
+          cases: reached.map((c) => ({
+            session: c.session,
+            previousPrompt: c.previousPrompt.slice(0, 200),
+            prompt: c.prompt.slice(0, 300),
+            jev: c.jevNoul === void 0 ? null : Number(c.jevNoul.toFixed(3)),
+            jevBucket: bucket(c.jevNoul),
+            jevError: c.jevError,
+            llm: c.llm ?? null,
+            llmConfidence: c.llmConfidence,
+            llmFailure: c.llmFailure
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  const pct = (a, b) => b === 0 ? "\u2014" : `${Math.round(a / b * 100)}%`;
+  const count = (b) => reached.filter((c) => bucket(c.jevNoul) === b).length;
+  write(
+    color.dim(
+      `${scanned} prompt(s) scanned in ${files.length} session file(s); ${reached.length} passed the local gate and reached a classifier`
+    )
+  );
+  write(color.bold("Jev"));
+  write(
+    `  new ${count("new")}  same ${count("same")}  unsure\u2192provider ${count("unsure")}  no answer ${count("none")}`
+  );
+  if (provider) {
+    const answered = reached.filter((c) => c.llm);
+    write(color.bold(`Provider classifier (${providerId}/${model}, production request shape)`));
+    write(
+      `  answered ${answered.length}/${reached.length}  new ${answered.filter((c) => c.llm === "new").length}  same ${answered.filter((c) => c.llm === "same").length}`
+    );
+    const failures = /* @__PURE__ */ new Map();
+    for (const c of reached) {
+      if (c.llmFailure) failures.set(c.llmFailure, (failures.get(c.llmFailure) ?? 0) + 1);
+    }
+    for (const [reason, n] of failures) write(color.amber(`  ${n}\xD7 ${reason.slice(0, 100)}`));
+    const both = reached.filter((c) => c.llm && ["new", "same"].includes(bucket(c.jevNoul)));
+    write(
+      `  agreement where Jev is decisive: ${pct(
+        both.filter((c) => bucket(c.jevNoul) === c.llm).length,
+        both.length
+      )} of ${both.length}`
+    );
+  }
+  write(color.dim(`model ${account.model}`));
+  return 0;
+}
+export {
+  replayTopicShift
+};
+//# sourceMappingURL=typesafe-topic-replay-ZILIU3WS.js.map

package/dist/typesafe-triage-replay-FGAW7QM7.js

@@ -0,0 +1,215 @@
+import {
+  createProviderForId
+} from "./chunk-BBHWW6LR.js";
+
+// src/subcommands/handlers/typesafe-triage-replay.ts
+import * as path from "node:path";
+import { resolveTypeSafeAccount } from "@wrongstack/core/typesafe";
+import { color } from "@wrongstack/core/utils";
+import { loadRuntimeDatabaseSync } from "@wrongstack/persistence";
+import {
+  computeValueScore,
+  evaluateMemory,
+  preFilterBatch,
+  probeMemoryValue
+} from "@wrongstack/sage";
+var SYSTEM_ONE_MIN_CONFIDENCE = 0.55;
+var SYSTEM_ONE_MIN_PROBABILITY = 0.5;
+async function loadMemories(dbPath) {
+  const Database = loadRuntimeDatabaseSync();
+  const db = new Database(dbPath, { readOnly: true });
+  try {
+    const rows = db.prepare("SELECT data FROM memories WHERE status IN ('active', 'stale')").all();
+    const out = [];
+    for (const row of rows) {
+      try {
+        out.push(JSON.parse(row.data));
+      } catch {
+      }
+    }
+    return out;
+  } finally {
+    db.close();
+  }
+}
+async function actionFor(memory, score) {
+  const vs = computeValueScore(memory);
+  const result = await evaluateMemory(memory, vs, async () => `${score} | calibration`);
+  return result.action === "keep_llm_override" ? "keep" : result.action;
+}
+async function replayMemoryTriage(deps, write) {
+  const flags = deps.flags ?? {};
+  const account = resolveTypeSafeAccount({ config: deps.config, restGate: null });
+  if (account.status !== "ready") {
+    write(`${color.red("\u2717")} ${account.reason}. Run \`wstack typesafe login\`.`);
+    return 2;
+  }
+  const limit = Math.max(1, Number(flags["limit"]) || 40);
+  const useLlm = flags["no-llm"] !== true;
+  const storageDir = deps.config.Sage?.storage?.directory;
+  const dbPath = path.resolve(
+    deps.projectRoot,
+    storageDir && typeof storageDir === "string" ? storageDir : path.join(".wrongstack", "memories"),
+    "sage.db"
+  );
+  let memories;
+  try {
+    memories = await loadMemories(dbPath);
+  } catch (err) {
+    write(`${color.red("\u2717")} cannot open ${dbPath}: ${err.message}`);
+    return 2;
+  }
+  const { uncertain } = preFilterBatch(memories);
+  const gray = uncertain.map((memory) => ({ memory, vs: computeValueScore(memory) })).filter((x) => x.vs.band === "gray");
+  const step = Math.max(1, gray.length / limit);
+  const cases = [];
+  for (let i = 0; i < gray.length && cases.length < limit; i += step) {
+    const pick = gray[Math.floor(i)];
+    if (pick) cases.push({ memory: pick.memory, vsTotal: pick.vs.total });
+  }
+  if (flags["json"] !== true)
+    write(
+      color.dim(
+        `${memories.length} memories, ${gray.length} in the gray zone; replaying ${cases.length}` + (useLlm ? " with the LLM reference" : " (Jev only)")
+      )
+    );
+  if (cases.length === 0) return 0;
+  let callLlm;
+  let llmLabel = "";
+  if (useLlm) {
+    const providerId = typeof flags["provider"] === "string" ? flags["provider"] : deps.config.provider;
+    const model = typeof flags["model"] === "string" ? flags["model"] : deps.config.model;
+    const provider = createProviderForId(
+      providerId,
+      deps.config
+    );
+    if (!provider?.complete) {
+      write(
+        color.amber(
+          `! cannot build provider "${providerId}" here; use --provider/--model or --no-llm.`
+        )
+      );
+      return 2;
+    }
+    llmLabel = `${providerId}/${model}`;
+    callLlm = async (system, user) => {
+      const response = await provider.complete(
+        {
+          model,
+          system: [{ type: "text", text: system }],
+          messages: [{ role: "user", content: user }],
+          // 60 is what `/memory triage` sends; --llm-max-tokens shows whether
+          // a reasoning model needs more room to produce any answer at all.
+          maxTokens: Math.max(16, Number(flags["llm-max-tokens"]) || 60),
+          temperature: 0.1
+        },
+        { signal: AbortSignal.timeout(6e4) }
+      );
+      return response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+    };
+  }
+  const judge = { client: account.client, model: account.model, feature: "memoryTriage" };
+  const CONCURRENCY = 6;
+  for (let i = 0; i < cases.length; i += CONCURRENCY) {
+    await Promise.all(
+      cases.slice(i, i + CONCURRENCY).map(async (c) => {
+        try {
+          c.jev = await probeMemoryValue(judge, c.memory);
+          if (c.jev) c.jevAction = await actionFor(c.memory, c.jev.score);
+        } catch (err) {
+          c.error = `jev: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        if (!callLlm) return;
+        try {
+          const r = await evaluateMemory(c.memory, computeValueScore(c.memory), callLlm);
+          if (r.evaluation.ok) {
+            c.llmScore = r.evaluation.score;
+            c.llmAction = r.action === "keep_llm_override" ? "keep" : r.action;
+          } else {
+            c.error = `llm: ${r.evaluation.error ?? "no score"}`;
+          }
+        } catch (err) {
+          c.error = `llm: ${err instanceof Error ? err.message : String(err)}`;
+        }
+      })
+    );
+  }
+  const judged = cases.filter((c) => c.jev);
+  const both = judged.filter((c) => c.llmScore !== void 0);
+  const settles = (c, minConfidence) => !!c.jev && c.jev.confidence >= minConfidence && c.jev.probability >= SYSTEM_ONE_MIN_PROBABILITY;
+  const pct = (a, b) => b === 0 ? "\u2014" : `${Math.round(a / b * 100)}%`;
+  if (flags["json"] === true) {
+    write(
+      JSON.stringify(
+        {
+          db: dbPath,
+          llm: llmLabel || null,
+          model: judged[0]?.jev?.model,
+          cases: cases.map((c) => ({
+            id: c.memory.id,
+            text: c.memory.text.slice(0, 160),
+            phase2: c.vsTotal,
+            jev: c.jev ? {
+              score: c.jev.score,
+              p: Number(c.jev.probability.toFixed(3)),
+              confidence: Number(c.jev.confidence.toFixed(3)),
+              action: c.jevAction
+            } : null,
+            llm: c.llmScore !== void 0 ? { score: c.llmScore, action: c.llmAction } : null,
+            error: c.error
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  write("");
+  write(color.bold("Jev rating distribution"));
+  const dist = [1, 2, 3, 4, 5].map((s) => judged.filter((c) => c.jev.score === s).length);
+  write(`  1:${dist[0]}  2:${dist[1]}  3:${dist[2]}  4:${dist[3]}  5:${dist[4]}`);
+  if (both.length > 0) {
+    write(color.bold(`Jev vs LLM (${llmLabel}), n=${both.length}`));
+    write(
+      `  rating exact   ${pct(both.filter((c) => c.jev.score === c.llmScore).length, both.length)}`
+    );
+    write(
+      `  rating \xB11      ${pct(both.filter((c) => Math.abs(c.jev.score - c.llmScore) <= 1).length, both.length)}`
+    );
+    write(
+      `  same action    ${pct(both.filter((c) => c.jevAction === c.llmAction).length, both.length)}`
+    );
+    write("  matrix (rows Jev 1-5, cols LLM 1-5)");
+    for (let j = 1; j <= 5; j++) {
+      const row = [1, 2, 3, 4, 5].map(
+        (l) => both.filter((c) => c.jev.score === j && c.llmScore === l).length
+      );
+      write(`    ${j}: ${row.map((n) => String(n).padStart(3)).join("")}`);
+    }
+    write("");
+    write(color.bold("Sweep (confidence threshold, p \u2265 0.5): settles / same action"));
+    for (const t of [0.3, 0.4, 0.5, 0.55, 0.6, 0.7, 0.8]) {
+      const s = both.filter((c) => settles(c, t));
+      write(
+        `  conf \u2265 ${t.toFixed(2)}${t === SYSTEM_ONE_MIN_CONFIDENCE ? " (current)" : "          "}  ${pct(s.length, both.length).padStart(4)}  ${pct(
+          s.filter((c) => c.jevAction === c.llmAction).length,
+          s.length
+        )}`
+      );
+    }
+  } else {
+    const s = judged.filter((c) => settles(c, SYSTEM_ONE_MIN_CONFIDENCE));
+    write(`  settles at current thresholds: ${pct(s.length, judged.length)}`);
+  }
+  const errors = cases.filter((c) => c.error);
+  if (errors.length > 0) {
+    write(color.amber(`${errors.length} case(s) with errors, e.g. ${errors[0]?.error}`));
+  }
+  write(color.dim(`model ${judged[0]?.jev?.model ?? account.model}`));
+  return 0;
+}
+export {
+  replayMemoryTriage
+};
+//# sourceMappingURL=typesafe-triage-replay-FGAW7QM7.js.map