tldr-experts 0.4.0 → 0.6.0

package/README.md

@@ -1,8 +1,8 @@
 # tldr-experts
 
-[![npm](https://img.shields.io/npm/v/tldr-experts?label=npm%20tldr-experts)](https://www.npmjs.com/package/tldr-experts) [![ci](https://github.com/ederwii/tldr-experts/actions/workflows/ci.yml/badge.svg)](https://github.com/ederwii/tldr-experts/actions/workflows/ci.yml) ![status](https://img.shields.io/badge/status-alpha-orange)
+[![npm](https://img.shields.io/npm/v/tldr-experts?label=npm%20tldr-experts)](https://www.npmjs.com/package/tldr-experts) [![ci](https://github.com/ederwii/tldr-experts/actions/workflows/ci.yml/badge.svg)](https://github.com/ederwii/tldr-experts/actions/workflows/ci.yml) ![status](https://img.shields.io/badge/status-beta-blue)
 
-**A lightweight, file-based AI development workflow.** Open source, tool-agnostic in design, piloted on Claude Code. **Alpha:** every command is implemented and verified by running it; interfaces may change without notice, and `tldrx --help` is the authoritative surface.
+**An evidence-first, file-based AI development framework: five stages, a gate on every one, and every claim cited or refused.** Open source. The workflow and the persisted state format are provider-independent; the automated runner currently supports Claude Code. **Beta:** every command is implemented and verified by running it, the `version: 1` file formats only grow from here, and `tldrx --help` is the authoritative command surface.
 
 One loop — *Investigate → Handoff → Interview → Gate* — five phases, **what · how · plan · build ·
 watch**, one stage per command, each stopping at a gate you own; the files ARE the state, the
@@ -21,6 +21,11 @@ tldrx init                # detect repos, map the code, write .tldrx/, ask only
 tldrx install --claude    # write the skill, hooks and status line into ./.claude/
 ```
 
+Later: **`tldrx update`** pulls the newest published version and prints the CHANGELOG between the
+one you had and the one you now have. Any command will tell you, in one line, when there is a newer
+one — off the hot path, cached for a day, silent when it cannot reach the registry, and never in
+`--json` output or during a hook. Turn it off with `TLDRX_UPDATE_CHECK=off`.
+
 **Never used it before?** `tldrx learn` teaches the loop by running it: eight chapters, ~15 minutes,
 in a throwaway sandbox with a toy repo and a stand-in agent. Every command in it is the real one —
 `init`, `run new`, `next`, `approve`, a Build that cuts a branch and runs a real DoD — so nothing it
@@ -36,8 +41,10 @@ tldrx run new payments --scope feature --seed docs/payments/ --budget 25
 tldrx run auto            # `next`, over and over, until something actually needs you
 ```
 
-**Runtime: Node ≥ 20 or Bun** — the published package is a pre-built bundle with zero runtime
-dependencies, so an installed `tldrx` needs only Node; Bun builds it. Full walkthrough:
+**To run it: Node ≥ 20, and nothing else** — the published package is a pre-built bundle with
+zero runtime dependencies, and `dist/` is a Node bundle (Bun runs it too, if you have it).
+**To build or contribute: Bun ≥ 1.3**, which compiles that bundle and runs the test suite.
+`tldrx doctor` is the authority on the rest. Full walkthrough:
 [`docs/guide/01-quick-start.md`](docs/guide/01-quick-start.md).
 
 ## Trying it: three ways to run
@@ -63,7 +70,21 @@ and names the `--prepare` command instead.
 
 ### Overnight, with the checking kept
 
-Two commands and a prompt. There is no keyword for this: the mandate is prose you write.
+Two commands and a prompt — and the prompt now ships with the package:
+
+```bash
+tldrx drive --unattended        # print the mandate; paste it into the session that drives the run
+tldrx drive --attended          # the same disciplines, but every gate stays yours to sign
+```
+
+`tldrx drive` needs no workspace, opens no run and writes nothing: it prints the discipline the
+first real runs were driven by — the three-role protocol (developer → a **fresh** adversarial
+reviewer, never the author → the host verifying both in the code, not in their reports), evidence
+labelled `measured` / `inferred` / `assumed`, product questions parked rather than decided, the
+reviewer calibrated to the story's stakes, and the cost declared once. The two modes differ in
+exactly two places: who drives the turns, and who may close a gate.
+
+The rest of this section is what that mandate says, in the shape you would type it by hand.
 
 ```bash
 tldrx run new payments --scope feature --budget 25 \
@@ -138,7 +159,11 @@ Those are the shipped defaults, and every scope keeps at least one human gate. O
 signs something it should not have, `tldrx reject --stage <phase>/<stage> --note "…"` revokes it, moves
 the cursor back and marks the later stages `stale`. When it is one BUILD STORY you disagree with — a
 story two reviewers refused, which is terminal for the rest of the run —
-`tldrx story reopen <id> --note "…"` gives that one story another run of attempts and nothing else.
+`tldrx story reopen <id> --note "…"` gives that one story another run of attempts and nothing else;
+for one named defect in a story already `done`, `--for-fix` opens a fix round instead — no attempt
+consumed, the same DoD and the same reviewer, one open round at a time.
+To move who may close a gate after `run new` froze it, `tldrx run gates set <stage>:<policy> --note "…"`
+is the only sanctioned way, and it records the old→new value with your reason.
 When you fix `.tldrx/workspace.yml` mid-run and the approved stories still cite the old command strings,
 `tldrx plan sync-dod` rewrites just their dod lines — renames followed, removed commands dropped, and
 anything with no ancestor in the file's history flagged rather than guessed at.
@@ -190,7 +215,7 @@ context 83.7 KB of 160.0 KB (~23.8k tok, 12% of sonnet's ~200.0k window)
 ```
 
 Over `prompt_max_bytes` the stage is **refused** (exit 2) before anything spawns; `max_reads` stops
-the sub-agent at a read ceiling; `--effort` changes what a turn costs. What `--max-budget-usd` does is
+the sub-agent at a read ceiling; `--effort` changes what a turn costs. What `--max-usd` does is
 end a run *after* the turn it is already in — measured, one turn spent **$5.15** against a **$1.50**
 ceiling — so size the prompt for the money you are willing to lose. Afterwards `tldrx cost [--all]` adds up what was actually charged, per attempt, per stage, per
 run, read off `agent.result` events and nothing else. Retries are never merged — a retry is
@@ -200,24 +225,49 @@ Details: [`docs/guide/06-budgets-and-cost.md`](docs/guide/06-budgets-and-cost.md
 
 ## Several runs
 
-With several runs open and no id, every run-targeting command **refuses rather than guessing**,
-exits `2`, and lists them — `tldrx next: 3 runs are open — pass one:`. That means "you left off
-the id", not "it broke". Pass a positional `<run>` on `next`, `run status`, `cost`, `replay` and
-`retro`; `--run <id>` on the rest. `tldrx run status` with several open lists them all, exit `0`.
+With several runs open and no id, a run-targeting command **refuses rather than guessing** and
+lists them — `tldrx next: 3 runs are open — pass one:`. That means "you left off the id", not "it
+broke". Two of them refuse differently and it is worth knowing which: `tldrx run status` is not a
+refusal at all — it lists every open run and exits `0`, and it is the screen you read to find the
+id the others want — and `tldrx cost` refuses at exit `1`, not `2`.
+
+Most run-targeting commands take the id either way, a positional `<run>` or `--run <id>`: `next`,
+`cost`, `note`, `gate template`, `questions`, `budget show`, `ship`, `tickets`, and `run attend` ·
+`status` · `estimate` · `auto` · `unlock` · `cancel`. `replay` and `retro` take the positional only
+— `--run` there is an unknown flag. `approve`, `reject`, `answer`, `interview`, `plan`,
+`story reopen`, `watch` and `run gates set` take `--run <id>` only.
+
+`tldrx retro --all` goes the other way: it reads **every** run in the workspace and prints one
+table of what keeps catching you — finding class × count × how many runs × one example with its
+citation — mined from the review logs, the fix lists, `retro.md` and the `story.reopened` reasons.
+Strictly read-only: it writes nothing, anywhere.
 
 ## What to commit
 
 **Both `.tldrx/` and `tldrx-work/`.** The files are the state — the map, the facts, the questions and
 their answers, `run.yml`, `budget.yml`, `events.jsonl`, the handoffs, the plan — so a teammate who clones
-the repo gets the run. The block `tldrx init` appends to `.gitignore` excludes five paths and nothing
-else, because those five are machine-local or regenerated: `.tldrx/graphify-out/`, `.tldrx/cache/`,
-`.tldrx/worktrees/`, `tldrx-work/*/.lock`, `tldrx-work/*/.agent/`.
+the repo gets the run. The block `tldrx init` appends to `.gitignore` excludes eight paths and nothing
+else, because those eight are machine-local, regenerated, or a backup git already holds the history
+of: `.tldrx/graphify-out/`, `.tldrx/cache/`, `.tldrx/worktrees/`, `tldrx-work/*/.lock`,
+`tldrx-work/*/.agent/`, `tldrx-work/**/*.bak`, `.tldrx/**/*.bak` and
+`.claude/settings.json.bak-tldrx-*`.
+
+**You do not have to commit them by hand.** Closing a run — `tldrx approve` on the last gate,
+`tldrx next`, or `tldrx run cancel` — commits `tldrx-work/<run>/` and `.tldrx/memory/` in the
+workspace checkout, on the branch that checkout is on, and prints one line saying where they went.
+Only those paths: anything else you had staged is still staged afterwards. It is deliberately never
+the epic branch — an epic under review carries feature code, and run state on it collides with the
+same live files in your working tree the moment the PR merges, which is why `tldrx ship` refuses an
+epic that carries any (#102).
 
 ## Documentation
 
 **[The documentation site](https://ederwii.github.io/tldr-experts/)** is the place to start if you have
 never used this: a landing page, a Quickstart and one short page per concept, written for a reader
-rather than for an agent. Source in [`docs-site/`](docs-site/).
+rather than for an agent. Source in [`docs-site/`](docs-site/). It carries a
+**[live demo of `tldrx dashboard`](https://ederwii.github.io/tldr-experts/demo)** — a real export,
+rendered from the test suite's synthetic fixtures on every deploy, so you can see what the tool
+draws before installing anything.
 
 The reference guide, in `docs/guide/`: [1 Quick start](docs/guide/01-quick-start.md) ·
 [2 The loop](docs/guide/02-the-loop.md) (the four steps, what a stage file controls, the two execution modes) ·
@@ -233,6 +283,12 @@ Design docs: [`docs/concept.md`](docs/concept.md) (why) · [`docs/spec.md`](docs
 open decisions) · [`docs/ROADMAP.md`](docs/ROADMAP.md) (next) · [`CHANGELOG.md`](CHANGELOG.md) (shipped) ·
 [`docs/dashboard-model.md`](docs/dashboard-model.md).
 
+Contributing: **[`CONTRIBUTING.md`](CONTRIBUTING.md)** — the loop a change goes through, the four gates
+and what CI actually runs, the red-first test rules, and
+[how to contribute a model-provider config](CONTRIBUTING.md#contributing-a-model-provider-config)
+(the `TLDRX_CLAUDE_BIN` seam, the `stream-json` transcript contract, and what a generic provider
+would have to supply).
+
 ## Releases and status tags
 
 Install name is **`tldr-experts`**; it installs two commands, **`tldrx`** (short) and `tldr-experts` (same binary).
@@ -242,6 +298,8 @@ back on the registry is 0.3.0.
 
 | Version | Date | Status | Contains |
 |---|---|---|---|
+| 0.6.0 | 2026-09-02 | `beta` | the dashboard suite — a "Now" hero strip, `--serve` live refresh, stage durations and gate notes on page and CLI, and a public demo generated from fixtures; honest dual-economy spend (metered + host, lower-bound named); gate provenance — `executed_by` + `authority` so a delegated signature never reads as a personal one, machine-signed reporting fixed; ONE `absent:` semantic shared by claim-sources and the auto gate; superseded stamps when an owner answer flips an earlier phase doc; run close commits its state and `ship` refuses a state-carrying epic; merge-wave gates `docs:build`, survives interruption and self-rewrite; a public-surface drift guard; env.yml validation (unique ids, tool cap) |
+| 0.5.0 | 2026-09-02 | `beta` | `tldrx drive` and its own preflight, `watch check` / `watch arm`, `questions cards`, `plan schema`, `retro --all` (with its findings fed back into every reviewer prompt) and `story reopen --for-fix`; `tldrx update` plus a cached newer-version notice; the dashboard reads `budget.yml` and `events.jsonl` — operator notes, reopens and retries, the per-phase budget panel, and a host-attended run metered in tokens against `ceiling_host_tokens`; a rejected review envelope no longer burns a story attempt; `ship` opens one PR per repo; merge-wave lock + ref guard; five golden-transcript evals, one per stage; `CONTRIBUTING.md` and a model-provider contract |
 | 0.4.0 | 2026-09-01 | `beta` | FIRST BETA — 40-issue hardening burn (DoD pre-flight + `plan sync-dod`, merge-wave lock + gated-HEAD, load-aware tests, claim-sources across all outputs), `tldrx learn` 8-chapter sandbox tutorial (cold-player QA), `tldrx ship` / `tldrx note` / `run gates set`, budget policies + dual-economy wiring, single integration branch for chained epics, epic worktrees live to run close, bilingual docs site |
 | 0.3.1 | 2026-08-31 | `alpha` | Unattended mode (gates_policy agent, review handshake, fixlist, decision cards, dual economy), 6 contact fixes from the first feature-scope runs, colored init, training repair round |
 | 0.3.0 | 2026-08-30 | `alpha` | expert training with provenance, auto gates with an undo, `tldrx status`, seed triage, the token economy (context ledger, `max_reads`, `cost`, `estimate`), `install --claude`, `interview`, the ticket mirror, `--help` with flags and exit codes |
@@ -256,6 +314,10 @@ path documented; `stable` = 1.0, semver from here on. The badge above shows the
 
 ## Releasing
 
-**One command: `scripts/release.sh X.Y.Z --tag alpha`.** It is the only sanctioned path — a Claude Code hook denies hand-made `git tag` / `npm publish`, and `publish.yml` re-runs the same checks. Checklist and judgement calls: `docs/RELEASING.md`.
+**One command: `scripts/release.sh X.Y.Z --tag beta`.** The tag is not optional in practice: omit
+`--tag` and the script writes `alpha`, which is no longer this project's status. It is the only
+sanctioned path — a Claude Code hook denies hand-made `git tag` / `npm publish`, and `publish.yml`
+runs `release-check.sh --ci` (the file checks only) plus its own typecheck, tests and build.
+Checklist and judgement calls: `docs/RELEASING.md`.
 
 MIT, © 2026 Alan Martinez — a placeholder made while scaffolding; change it freely before anything ships.

package/dist/hooks/answer-capture.js

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import {
   FactsStore
-} from "./chunk-t1ywrfr4.js";
+} from "./chunk-17gv74sr.js";
 import {
   parseHookInput,
   readStdin
-} from "./chunk-b8kxzna2.js";
+} from "./chunk-vrhczzxs.js";
 import {
-  EventLog
-} from "./chunk-rz541e2b.js";
-import"./chunk-c6t5nx0r.js";
+  EventLog,
+  PHASE_ID_RE
+} from "./chunk-h7151g8w.js";
+import"./chunk-g4db8rbs.js";
+import"./chunk-v4ay50nq.js";
 import {
   MAX_FACT_CHARS,
   detectAnswered,
@@ -17,16 +19,15 @@ import {
   recordAnswer,
   replaceBlock,
   serializeQuestions
-} from "./chunk-rpcxsqh3.js";
-import"./chunk-m3mewgnw.js";
+} from "./chunk-97ncnegd.js";
 import"./chunk-39zh2e44.js";
 import {
   PROJECT_WORK_DIR,
   factsPath
-} from "./chunk-sq44k6g2.js";
+} from "./chunk-9w64mxdh.js";
 
 // src/hooks/answer-capture.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 
 // src/hooks/lib/decide.ts
 function allow() {
@@ -98,7 +99,95 @@ function nowRfc3339() {
 }
 
 // src/core/answers/captureAnswers.ts
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+
+// src/core/answers/stampSuperseded.ts
+import { appendFileSync, existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join2, relative } from "node:path";
+var STAMP_MARKER = "tldrx:superseded";
+var AFFECTS_KEY = "affects";
+function isStamped(text, fact) {
+  return text.includes(`${STAMP_MARKER} ${fact} `);
+}
+function stampText(fact, q, questionsRel, at) {
+  return `<!-- ${STAMP_MARKER} ${fact} | q: ${q} | at: ${at} | see: ${questionsRel} -->
+` + `> **Superseded in part by ${fact}** — ${q} was answered after this document was written; ` + `the answer is in \`${questionsRel}\` and \`.tldrx/memory/facts.yml\`. ` + `This document was not reconciled: where the two disagree, the fact is what the workspace believes.
+`;
+}
+function affectedDocs(runDir, questionsPath, block) {
+  const self = runRelative(runDir, questionsPath);
+  const askedIn = self === null ? null : phaseIdOf(self);
+  const found = new Map;
+  const consider = (raw, by) => {
+    const rel = resolveInRun(runDir, raw);
+    if (rel === null || rel === self || !rel.endsWith(".md"))
+      return;
+    const phase = phaseIdOf(rel);
+    if (phase === null)
+      return;
+    if (by === "cited" && (askedIn === null || !isEarlier(phase, askedIn)))
+      return;
+    if (!found.has(rel))
+      found.set(rel, { rel, abs: join2(runDir, rel), by });
+  };
+  for (const ref of block.whySrc?.refs ?? []) {
+    if (ref.kind === "file")
+      consider(ref.path, "cited");
+  }
+  for (const raw of declaredAffects(block))
+    consider(raw, "affects");
+  return [...found.values()];
+}
+function stampSuperseded(runDir, questionsPath, block, fact, at) {
+  const questionsRel = runRelative(runDir, questionsPath) ?? "questions.md";
+  const stamped = [];
+  for (const doc of affectedDocs(runDir, questionsPath, block)) {
+    const text = readFileSync(doc.abs, "utf8");
+    if (isStamped(text, fact))
+      continue;
+    const lead = text === "" ? "" : text.endsWith(`
+`) ? `
+` : `
+
+`;
+    appendFileSync(doc.abs, lead + stampText(fact, block.id, questionsRel, at), "utf8");
+    stamped.push(doc);
+  }
+  return stamped;
+}
+function declaredAffects(block) {
+  const raw = block.metadata?.extra.find(([key]) => key === AFFECTS_KEY)?.[1] ?? "";
+  return raw.split(/[,\s]+/).map((part) => part.trim()).filter((part) => part !== "");
+}
+function resolveInRun(runDir, raw) {
+  if (raw === "" || isAbsolute2(raw))
+    return null;
+  const root = join2(runDir, "..", "..");
+  for (const candidate of [join2(runDir, raw), join2(root, raw)]) {
+    const rel = runRelative(runDir, candidate);
+    if (rel === null)
+      continue;
+    if (!existsSync(candidate) || !statSync(candidate).isFile())
+      continue;
+    return rel;
+  }
+  return null;
+}
+function runRelative(runDir, path) {
+  const rel = relative(runDir, path);
+  if (rel === "" || rel.startsWith("..") || isAbsolute2(rel))
+    return null;
+  return rel.split(/[\\/]/).join("/");
+}
+function phaseIdOf(rel) {
+  const first = rel.split("/")[0] ?? "";
+  return PHASE_ID_RE.test(first) ? first : null;
+}
+function isEarlier(phase, than) {
+  return Number(phase.slice(0, 2)) < Number(than.slice(0, 2));
+}
+
+// src/core/answers/captureAnswers.ts
 var TRUNCATION_MARK = " …";
 function factTextFor(title, answer) {
   const whole = `${title} — ${answer}`;
@@ -110,14 +199,15 @@ function factWasTruncated(title, answer) {
   return `${title} — ${answer}`.length > MAX_FACT_CHARS;
 }
 function captureAnswers(questionsPath, ctx) {
-  if (!existsSync(questionsPath))
+  if (!existsSync2(questionsPath))
     return [];
-  let doc = parseQuestions(readFileSync(questionsPath, "utf8"));
+  let doc = parseQuestions(readFileSync2(questionsPath, "utf8"));
   const answered = detectAnswered(doc.blocks);
   if (answered.length === 0)
     return [];
   const log = EventLog.forRun(ctx.runDir);
   const captured = [];
+  const recorded = [];
   FactsStore.update(factsPath(ctx.root), (store) => {
     for (const block of answered) {
       const area = block.metadata?.area ?? "unscoped";
@@ -151,11 +241,44 @@ function captureAnswers(questionsPath, ctx) {
         payload: { fact: fact.id, area: fact.area, kind: fact.kind, q: block.id }
       });
       captured.push({ q: block.id, fact: fact.id, answer: block.answer, area });
+      recorded.push({ block, fact: fact.id });
     }
   });
   writeFileSync(questionsPath, serializeQuestions(doc), "utf8");
+  for (const item of recorded) {
+    markSuperseded(log, ctx, questionsPath, item.block, item.fact);
+  }
   return captured;
 }
+function markSuperseded(log, ctx, questionsPath, block, fact) {
+  try {
+    for (const doc of stampSuperseded(ctx.runDir, questionsPath, block, fact, ctx.at)) {
+      log.tryAppend({
+        ts: ctx.at,
+        run: ctx.run,
+        stage: null,
+        type: "doc.superseded",
+        actor: ctx.actor,
+        cost_usd: 0,
+        payload: { doc: doc.rel, fact, q: block.id, by: doc.by }
+      });
+    }
+  } catch (error) {
+    log.tryAppend({
+      ts: ctx.at,
+      run: ctx.run,
+      stage: null,
+      type: "error",
+      actor: ctx.actor,
+      cost_usd: 0,
+      payload: {
+        message: `could not stamp the documents ${block.id} supersedes: ` + (error instanceof Error ? error.message : String(error)),
+        q: block.id,
+        fact
+      }
+    });
+  }
+}
 
 // src/hooks/answer-capture.ts
 await runHook("answer-capture", async () => {
@@ -164,7 +287,7 @@ await runHook("answer-capture", async () => {
   if (event === "PostToolUse" && payload.tool_name !== "Write" && payload.tool_name !== "Edit")
     return;
   const filePath = filePathOf(payload);
-  if (!filePath.endsWith("questions.md") || !existsSync2(filePath))
+  if (!filePath.endsWith("questions.md") || !existsSync3(filePath))
     return;
   const location = locateWork(filePath);
   if (location === null)

package/dist/hooks/budget-gate.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import {
   budgetGateDeny
-} from "./chunk-9gb21660.js";
+} from "./chunk-dhbxzjfs.js";
 import {
   allow,
   deny,
   readPayload,
   runHook,
   toolInput
-} from "./chunk-tzzwddct.js";
-import"./chunk-b8kxzna2.js";
+} from "./chunk-x6n8b5fp.js";
+import"./chunk-vrhczzxs.js";
 import {
   asRunBudget,
   currentActor,
@@ -29,16 +29,15 @@ import {
   validateRunBudget,
   wouldExceed,
   wouldExceedHostTokens
-} from "./chunk-4cp363kv.js";
+} from "./chunk-7eqhfddw.js";
 import {
   EventLog
-} from "./chunk-rz541e2b.js";
-import"./chunk-9zsqxr6y.js";
-import"./chunk-phmdk72a.js";
+} from "./chunk-h7151g8w.js";
+import"./chunk-rrkdfk7s.js";
+import"./chunk-g4db8rbs.js";
 import {
   noteDeprecations
-} from "./chunk-rpcxsqh3.js";
-import"./chunk-m3mewgnw.js";
+} from "./chunk-97ncnegd.js";
 import"./chunk-39zh2e44.js";
 import {
   PROJECT_WORK_DIR,
@@ -46,7 +45,7 @@ import {
   locateWork,
   parseYaml,
   stageYamlPath
-} from "./chunk-sq44k6g2.js";
+} from "./chunk-9w64mxdh.js";
 
 // src/hooks/budget-gate.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
@@ -74,7 +73,9 @@ function loadRunBudget(runDir) {
 var SPAWN_RE = /^(claude -p|tldrx next|tldrx run auto|tldrx expert train|tldrx seed triage)\b/;
 var RUN_ARG_RE = /--run[= ]([\w.-]+)/;
 var DEFAULT_TRAIN_USD = 2;
+var DEFAULT_FULL_TRAIN_USD = 3;
 var DEFAULT_TRIAGE_USD = 1;
+var FULL_MODE_RE = /--mode[= ]full\b/;
 var MAX_USD_RE = /--max-usd[= ]([0-9]+(?:\.[0-9]+)?)/;
 var MAX_BUDGET_RE = /--max-budget-usd[= ]([0-9]+(?:\.[0-9]+)?)/;
 await runHook("budget-gate", async () => {
@@ -216,7 +217,9 @@ function estimateFor(command, stageBudget) {
     return Number.isFinite(flagged) ? flagged : stageBudget ?? 0;
   }
   if (/^tldrx expert train\b/.test(command)) {
-    return Number.isFinite(flagged) ? flagged : DEFAULT_TRAIN_USD;
+    if (Number.isFinite(flagged))
+      return flagged;
+    return FULL_MODE_RE.test(command) ? DEFAULT_FULL_TRAIN_USD : DEFAULT_TRAIN_USD;
   }
   if (/^tldrx seed triage\b/.test(command)) {
     return Number.isFinite(flagged) ? flagged : DEFAULT_TRIAGE_USD;

package/dist/hooks/{chunk-t1ywrfr4.js → chunk-17gv74sr.js}

@@ -3,7 +3,7 @@ import {
   withWorkspaceLock,
   workspaceRootOfFactsPath,
   writeAtomic
-} from "./chunk-c6t5nx0r.js";
+} from "./chunk-v4ay50nq.js";
 import {
   FACT_CONFIDENCES,
   FACT_KINDS,
@@ -14,7 +14,7 @@ import {
   isLive,
   isRetired,
   noteDeprecations
-} from "./chunk-rpcxsqh3.js";
+} from "./chunk-97ncnegd.js";
 import {
   asDocument,
   isRecord,
@@ -26,15 +26,17 @@ import {
   result
 } from "./chunk-39zh2e44.js";
 import {
-  parseYaml
-} from "./chunk-sq44k6g2.js";
+  SRC_PATTERNS,
+  parseYaml,
+  readableSource
+} from "./chunk-9w64mxdh.js";
 
 // src/core/facts/FactsStore.ts
 import { existsSync, readFileSync } from "node:fs";
 
 // src/core/facts/validateFactsFile.ts
-var ID_RE = /^F\d{3,6}$/;
-var Q_RE = /^Q\d{1,6}$/;
+var ID_RE = SRC_PATTERNS.fact;
+var Q_RE = SRC_PATTERNS.answer;
 function validateFactsFile(input) {
   const issues = [];
   const deprecations = [];
@@ -60,7 +62,7 @@ function validateFactsFile(input) {
     requireKeys(row, ["id", "fact", "area", "repos", "kind", "confidence", "source", "supersedes", "superseded_by", "retired"], path, issues);
     const id = typeof row.id === "string" ? row.id : "";
     if (!ID_RE.test(id))
-      issues.push({ path: `${path}.id`, message: "id must match ^F\\d{3,6}$" });
+      issues.push({ path: `${path}.id`, message: `id must match ${readableSource(ID_RE)}` });
     else if (byId.has(id))
       issues.push({ path: `${path}.id`, message: `duplicate fact id ${id}` });
     else {
@@ -82,7 +84,7 @@ function validateFactsFile(input) {
       requireKeys(row.source, ["who", "when", "run", "q"], `${path}.source`, issues);
       const q = row.source.q;
       if (typeof q === "string" && !Q_RE.test(q)) {
-        issues.push({ path: `${path}.source.q`, message: "expected ^Q\\d+$ or null" });
+        issues.push({ path: `${path}.source.q`, message: `expected ${readableSource(Q_RE)} or null` });
       }
     } else if (row.source !== undefined) {
       issues.push({ path: `${path}.source`, message: "expected a mapping" });