@wrongstack/cli 1.0.19 → 1.0.24

package/dist/subcommands/handlers/typesafe-topic-replay.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `wstack typesafe replay-topic-shift` — calibrate the topic-shift front on
+ * this project's own sessions.
+ *
+ * Session journals record every user prompt (`user_input`) and every message
+ * appended to the conversation, so the history the advisor saw at each prompt
+ * can be rebuilt. Each prompt is replayed through the real `TopicShiftAdvisor`
+ * twice — once with only the TypeSafe judge, once with only the configured
+ * provider (the path it has always had, with its production request) — and only
+ * prompts that pass the advisor's own local gate are counted, because the
+ * rest never reach a classifier in production either.
+ *
+ * Reported: how often each classifier answers at all, what it answers, and
+ * how the two agree where Jev is decisive. `--json` includes the prompt and
+ * the previous user prompt for hand-labelling. Nothing is written.
+ */
+import type { SubcommandDeps } from '../contracts.js';
+export declare function replayTopicShift(deps: SubcommandDeps, write: (line: string) => void): Promise<number>;
+//# sourceMappingURL=typesafe-topic-replay.d.ts.map

package/dist/subcommands/handlers/typesafe-triage-replay.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `wstack typesafe replay-memory-triage` — calibrate the triage front on this
+ * project's own memories.
+ *
+ * Opens the project's SAGE database READ-ONLY, runs the deterministic Phases
+ * 1–2 exactly as `/memory triage` does to find the gray zone, samples it, and
+ * asks both Jev (`probeMemoryValue`, raw distribution) and the configured LLM
+ * (the same prompt and parser `/memory triage` uses) for a 1–5 rating.
+ *
+ * The report compares them on the rating and — what actually matters — on the
+ * triage ACTION each rating would cause (keep / stale / propose archive),
+ * overall and for the subset the front would settle at each confidence
+ * threshold. The LLM is the reference, not ground truth; `--no-llm` skips it
+ * and reports Jev's distribution alone. Nothing is written anywhere.
+ */
+import type { SubcommandDeps } from '../contracts.js';
+export declare function replayMemoryTriage(deps: SubcommandDeps, write: (line: string) => void): Promise<number>;
+//# sourceMappingURL=typesafe-triage-replay.d.ts.map

package/dist/subcommands/handlers/typesafe.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `wstack typesafe` — the account surface for the System One features.
+ *
+ * TypeSafe is not a provider and deliberately does not appear in `wstack auth`:
+ * it answers typed questions rather than generating text, so putting it in the
+ * provider list would leak `jev-latest` into the model picker, the subagent
+ * lanes and the fallback chain, where selecting it would simply break a turn.
+ * But "not a provider" is not "not an account" — it has a credential, a host
+ * and a bill, and until this command existed the only way to configure any of
+ * that was to hand-edit a config file. Nothing in any UI mentioned it.
+ *
+ *   wstack typesafe                  what is configured (no network request)
+ *   wstack typesafe login            store a key (and pick a route)
+ *   wstack typesafe test             spend one cheap question proving it works
+ *
+ * `test` is the point of the whole command. Both consumers degrade silently by
+ * design, so a wrong or revoked key produces no error anywhere — it produces
+ * slightly worse routing and no skill suggestions, forever. This is the only
+ * place that asks the host directly and reports what it said.
+ */
+import type { SubcommandHandler } from '../contracts.js';
+export declare const typesafeCmd: SubcommandHandler;
+//# sourceMappingURL=typesafe.d.ts.map

package/dist/{subcommands-XSLXMIDP.js → subcommands-ZTSIN7LG.js}

@@ -1,9 +1,9 @@
 import {
   subcommandNames,
   subcommands
-} from "./chunk-2CZEORLV.js";
+} from "./chunk-424ORSE7.js";
 export {
   subcommandNames,
   subcommands
 };
-//# sourceMappingURL=subcommands-XSLXMIDP.js.map
+//# sourceMappingURL=subcommands-ZTSIN7LG.js.map

package/dist/typesafe-HVEVPA6R.js

@@ -0,0 +1,316 @@
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
+import {
+  maskedKey,
+  mutateConfigProviders
+} from "./chunk-LUMETJFO.js";
+
+// src/subcommands/handlers/typesafe.ts
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+import {
+  BUILT_IN_ROUTES,
+  BUILT_IN_SEMANTIC_LINT_RULES,
+  estimateTypeSafeCostUsd,
+  findSemanticLintCandidates,
+  isTypeSafeJudgmentEnabled,
+  isTypeSafeRoute,
+  judgeSemanticLintCandidates,
+  parseSemanticLintRules,
+  resolveTypeSafeAccount,
+  resolveTypeSafeJudge,
+  resolveTypeSafeRoute,
+  TYPESAFE_JUDGMENT_FEATURES,
+  TYPESAFE_ROUTES
+} from "@wrongstack/core/typesafe";
+import { buildChildEnv, color } from "@wrongstack/core/utils";
+var USAGE = [
+  "Usage:",
+  "  wstack typesafe [status]                 show account and feature configuration",
+  "  wstack typesafe login [--route <id>]     store an API key in the active profile",
+  "      [--endpoint <url>] [--model <id>]    configure a proxy or pin a model",
+  "  wstack typesafe test                     send one question and report the answer",
+  "  wstack typesafe lint-conventions         judge convention-rule hits in the diff",
+  "      [--staged | --base <ref>] [--threshold <0..1>] [--json]",
+  "      rules: built-in + .wrongstack/semantic-lint.json; exit 1 on findings",
+  "  wstack typesafe check-judgments          run every judgment on known cases (live)",
+  "  wstack typesafe replay-brain-ledger      compare Jev with past Brain decisions",
+  "      [--ledger <path>] [--limit <per kind>] [--kind <signal>] [--json]",
+  "  wstack typesafe replay-topic-shift       compare Jev with the provider on past session prompts",
+  "      [--sessions <dir>] [--limit <n>] [--max-context <n>] [--no-llm] [--json]",
+  "  wstack typesafe replay-memory-triage     compare Jev with the LLM on SAGE gray-zone memories",
+  "      [--limit <n>] [--provider <id>] [--model <id>] [--llm-max-tokens <n>]",
+  "      [--no-llm] [--json]",
+  "",
+  `Routes: ${BUILT_IN_ROUTES.map((r) => `${r} (${TYPESAFE_ROUTES[r].env})`).join(", ")}, custom (typesafe.endpoint)`,
+  "",
+  "TypeSafe is not a chat provider and is not listed by `wstack auth`."
+].join("\n");
+var typesafeCmd = async (args, deps) => {
+  const write = (line) => deps.renderer.write(`${line}
+`);
+  const flags = deps.flags ?? {};
+  if (flags["help"] === true || flags["h"] === true) {
+    write(USAGE);
+    return 0;
+  }
+  const sub = (args[0] ?? "status").toLowerCase();
+  switch (sub) {
+    case "status":
+      return showStatus(deps, write);
+    case "login":
+      return await login(deps, write);
+    case "test":
+      return await test(deps, write);
+    case "lint-conventions":
+      return await lintConventions(deps, write);
+    case "replay-topic-shift":
+      return await (await import("./typesafe-topic-replay-4W73BOLV.js")).replayTopicShift(deps, write);
+    case "replay-memory-triage":
+      return await (await import("./typesafe-triage-replay-FGAW7QM7.js")).replayMemoryTriage(deps, write);
+    case "replay-brain-ledger":
+      return await (await import("./typesafe-brain-replay-C5276FVR.js")).replayBrainLedger(deps, write);
+    case "check-judgments":
+      return await (await import("./typesafe-judgment-check-GGYYV5UF.js")).checkJudgments(deps, write);
+    default:
+      write(`Unknown subcommand: ${sub}
+`);
+      write(USAGE);
+      return 1;
+  }
+};
+function requestedFeatures(deps) {
+  const requested = [];
+  if (deps.config.skills?.suggest?.enabled === true) requested.push("skills.suggest");
+  if (deps.config.fleet?.dispatch?.typesafeClassifier === true) {
+    requested.push("fleet.dispatch.typesafeClassifier");
+  }
+  return requested;
+}
+function showStatus(deps, write) {
+  const account = resolveTypeSafeAccount({ config: deps.config });
+  const route = resolveTypeSafeRoute(deps.config, process.env);
+  const features = requestedFeatures(deps);
+  write(color.bold("TypeSafe account"));
+  write(`  route      ${route}${route === "custom" ? color.dim(" (from typesafe.endpoint)") : ""}`);
+  if (account.status === "ready") {
+    write(`  endpoint   ${account.endpoint}`);
+    write(`  model      ${account.model}`);
+    write(
+      `  key        ${account.keySource === "config" ? `${maskedKey(deps.config.typesafe?.apiKey ?? "")} ${color.dim("(typesafe.apiKey)")}` : color.dim(`from $${account.keyEnv}`)}`
+    );
+    write("  connection not tested \u2014 run `wstack typesafe test` to verify");
+  } else {
+    write(`  key        ${color.dim("\u2014")}`);
+    write(`  ${color.amber("!")} ${account.reason}`);
+  }
+  write("");
+  write(
+    color.bold("Judgments") + color.dim("  (on with an account; typesafe.judgments.<id>: false turns one off)")
+  );
+  for (const feature of TYPESAFE_JUDGMENT_FEATURES) {
+    const on = isTypeSafeJudgmentEnabled(deps.config, feature);
+    write(
+      `  ${!on ? color.dim("off") : account.status === "ready" ? color.green("on ") : color.dim("idle")}  ${feature}`
+    );
+  }
+  write("");
+  write(color.bold("Features"));
+  if (features.length === 0) {
+    write(`  ${color.dim("none enabled")} \u2014 see docs/skills-suggestion.md`);
+  } else {
+    for (const feature of features) {
+      write(
+        account.status === "ready" ? `  ${color.green("on")}  ${feature}` : `  ${color.amber("on, but not running")}  ${feature}`
+      );
+    }
+  }
+  if (account.status !== "ready" && features.length > 0) {
+    write("");
+    write(`  ${color.amber("Run `wstack typesafe login` \u2014 these switches do nothing today.")}`);
+    return 1;
+  }
+  return 0;
+}
+async function login(deps, write) {
+  const flags = deps.flags ?? {};
+  for (const name of ["route", "endpoint", "model", "key"]) {
+    if (flags[name] !== void 0 && (typeof flags[name] !== "string" || !String(flags[name]).trim())) {
+      write(`--${name} requires a value.`);
+      return 1;
+    }
+  }
+  const requested = flags["route"];
+  let route;
+  if (typeof requested === "string") {
+    if (!isTypeSafeRoute(requested)) {
+      write(`Unknown route: ${requested}`);
+      write(USAGE);
+      return 1;
+    }
+    route = requested;
+  }
+  const endpoint = typeof flags["endpoint"] === "string" ? flags["endpoint"].trim() : void 0;
+  const model = typeof flags["model"] === "string" ? flags["model"].trim() : void 0;
+  if (endpoint && !route) route = "custom";
+  const update = (existing) => {
+    const next = { ...existing };
+    if (route && route !== resolveTypeSafeRoute({ typesafe: existing }, {})) {
+      delete next.endpoint;
+      delete next.model;
+    }
+    if (route) next.route = route;
+    if (endpoint) next.endpoint = endpoint;
+    if (model) next.model = model;
+    return next;
+  };
+  const settings = update(deps.config.typesafe ?? {});
+  const preview = resolveTypeSafeAccount({ config: { typesafe: settings }, env: {} });
+  if (preview.status === "unusable") {
+    write(`${preview.reason}. For a custom route, pass --endpoint <url>.`);
+    return 1;
+  }
+  const effectiveRoute = resolveTypeSafeRoute({ typesafe: settings }, {});
+  const label = effectiveRoute !== "custom" ? TYPESAFE_ROUTES[effectiveRoute].label : "TypeSafe (custom)";
+  const fromFlag = typeof flags["key"] === "string" ? flags["key"].trim() : "";
+  const key = fromFlag || await deps.reader.readSecret(`  ${color.amber("?")} ${label} API key: `);
+  if (!key.trim()) {
+    write("No key entered; nothing written.");
+    return 1;
+  }
+  const configPath = activeProfileConfigPath(deps.paths, deps.config);
+  await mutateConfigProviders(configPath, deps.vault, (_providers, config) => {
+    const existing = typeof config["typesafe"] === "object" && config["typesafe"] !== null ? config["typesafe"] : {};
+    config["typesafe"] = { ...update(existing), apiKey: key.trim() };
+  });
+  write(`${color.green("\u2713")} Key stored in ${configPath}`);
+  if (route) write(`  route set to ${route}`);
+  write(`  Verify it with ${color.bold("wstack typesafe test")}.`);
+  return 0;
+}
+async function test(deps, write) {
+  const account = resolveTypeSafeAccount({ config: deps.config, restGate: null });
+  if (account.status !== "ready") {
+    write(`${color.red("\u2717")} ${account.reason}`);
+    write("  Run `wstack typesafe login`.");
+    return 1;
+  }
+  write(`Asking ${account.endpoint} (${account.model})\u2026`);
+  const started = Date.now();
+  try {
+    const result = await account.client.systemOne({
+      state: { text: "The service returned this request successfully." },
+      questions: {
+        reachable: {
+          type: "noul",
+          instructions: "Is the text in the state written in English?"
+        }
+      }
+    });
+    const answer = result.answers["reachable"];
+    const elapsed = Date.now() - started;
+    if (answer?.type !== "noul") {
+      write(`${color.red("\u2717")} Reached the host but the answer was missing or malformed.`);
+      return 1;
+    }
+    write(`${color.green("\u2713")} ${account.route} route works \u2014 answered in ${elapsed}ms`);
+    write(`  model reported  ${result.model ?? color.dim("(none in response)")}`);
+    write(
+      `  cost            ${result.usage.inputTokens} input tokens ` + color.dim(`(~$${estimateTypeSafeCostUsd(result.usage.inputTokens).toFixed(6)})`)
+    );
+    if (result.model && deps.config.typesafe?.model && result.model !== deps.config.typesafe.model) {
+      write(
+        color.dim(`  note: asked for ${deps.config.typesafe.model}, answered by ${result.model}`)
+      );
+    }
+    return 0;
+  } catch (err) {
+    const status = err.status;
+    write(`${color.red("\u2717")} ${err instanceof Error ? err.message : String(err)}`);
+    if (status === 401 || status === 403) {
+      write("  The host rejected the key. Re-run `wstack typesafe login`.");
+    } else if (status === 429 || status === 529) {
+      write("  Rate limited or overloaded \u2014 the key is probably fine; try again shortly.");
+    } else if (status === 422) {
+      write("  The host rejected the request shape, not the key. This is a bug; please report it.");
+    }
+    return 1;
+  }
+}
+function runGit(cwd, args) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      args,
+      {
+        cwd,
+        env: buildChildEnv(),
+        encoding: "utf8",
+        timeout: 3e4,
+        windowsHide: true,
+        maxBuffer: 32 * 1024 * 1024
+      },
+      (err, stdout) => err ? reject(err) : resolve(stdout)
+    );
+  });
+}
+async function lintConventions(deps, write) {
+  const flags = deps.flags ?? {};
+  const judge = resolveTypeSafeJudge({ config: deps.config, feature: "semanticLint" });
+  if (!judge) {
+    const account = resolveTypeSafeAccount({ config: deps.config });
+    write(
+      `${color.red("\u2717")} ${account.status === "ready" ? "typesafe.judgments.semanticLint is false." : `${account.reason}. Run \`wstack typesafe login\`.`}`
+    );
+    return 2;
+  }
+  const rules = [...BUILT_IN_SEMANTIC_LINT_RULES];
+  const rulesPath = path.join(deps.projectRoot, ".wrongstack", "semantic-lint.json");
+  try {
+    const parsed = parseSemanticLintRules(JSON.parse(await readFile(rulesPath, "utf8")));
+    for (const error of parsed.errors) write(color.amber(`! ${rulesPath}: ${error}`));
+    rules.push(...parsed.rules);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      write(color.amber(`! ${rulesPath}: ${err instanceof Error ? err.message : String(err)}`));
+    }
+  }
+  const base = typeof flags["base"] === "string" ? flags["base"] : void 0;
+  const diffArgs = ["diff", "--no-color", "--no-ext-diff", "-U24"];
+  if (flags["staged"] === true) diffArgs.push("--cached");
+  else if (base) diffArgs.push(`${base}...HEAD`);
+  let diff;
+  try {
+    diff = await runGit(deps.projectRoot, diffArgs);
+  } catch (err) {
+    write(`${color.red("\u2717")} git diff failed: ${err instanceof Error ? err.message : String(err)}`);
+    return 2;
+  }
+  const candidates = findSemanticLintCandidates(diff, rules);
+  const thresholdFlag = Number(flags["threshold"]);
+  const threshold = Number.isFinite(thresholdFlag) && thresholdFlag > 0 && thresholdFlag <= 1 ? thresholdFlag : 0.7;
+  const result = candidates.length === 0 ? { findings: [], cleared: 0, unjudged: 0 } : await judgeSemanticLintCandidates(judge, rules, candidates, { threshold });
+  if (flags["json"] === true) {
+    write(JSON.stringify({ candidates: candidates.length, ...result }, null, 2));
+  } else {
+    for (const f of result.findings) {
+      write(
+        `${color.amber(`${f.file}:${f.line}`)}  ${color.bold(f.ruleId)}  ` + color.dim(`p=${f.probability.toFixed(2)}`)
+      );
+      write(`    ${f.text.slice(0, 160)}`);
+    }
+    write(
+      color.dim(
+        `${candidates.length} candidate(s) across ${rules.length} rule(s): ${result.findings.length} finding(s), ${result.cleared} cleared` + (result.unjudged ? `, ${result.unjudged} not judged (host unavailable)` : "")
+      )
+    );
+  }
+  if (result.findings.length > 0) return 1;
+  return result.unjudged > 0 ? 2 : 0;
+}
+export {
+  typesafeCmd
+};
+//# sourceMappingURL=typesafe-HVEVPA6R.js.map

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