tldr-experts 0.3.0

package/dist/hooks/session-start.js

@@ -0,0 +1,1348 @@
+#!/usr/bin/env node
+import"./chunk-kw4tffzf.js";
+import"./chunk-x98qs959.js";
+import {
+  allow,
+  readPayload,
+  runHook,
+  sessionContext
+} from "./chunk-1zwcxd3f.js";
+import"./chunk-a8p2rc94.js";
+import {
+  RunStore,
+  isMovable,
+  openQuestions,
+  runSnapshot,
+  whatIsWaiting
+} from "./chunk-y0jdr3et.js";
+import {
+  openRunViews
+} from "./chunk-sdjnnmzz.js";
+import"./chunk-azctppjh.js";
+import"./chunk-ae6bkfs5.js";
+import {
+  openBlocks,
+  parseQuestions
+} from "./chunk-j234zf0t.js";
+import"./chunk-t56k6146.js";
+import {
+  classifySrc
+} from "./chunk-g395gk7e.js";
+import {
+  isRecord
+} from "./chunk-0bt6yb2q.js";
+import {
+  PROJECT_FRAMEWORK_DIR,
+  PROJECT_WORK_DIR,
+  STAGES_DIR,
+  TEMPLATES_DIR,
+  findWorkspaceRoot,
+  listRunDirs,
+  parseYaml
+} from "./chunk-p274ckxv.js";
+
+// src/core/status/PendingItem.ts
+function isPending(item) {
+  return item.kind !== "none";
+}
+// src/core/status/initQuestionsItem.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/core/init/questions.ts
+var QUESTIONS_FILE = ".tldrx/init-questions.md";
+
+// src/core/status/initQuestionsItem.ts
+var MAX_LISTED = 5;
+function initQuestionsItem(root) {
+  const path = join(root, ...QUESTIONS_FILE.split("/"));
+  if (!existsSync(path))
+    return null;
+  let open;
+  try {
+    open = openBlocks(parseQuestions(readFileSync(path, "utf8")).blocks);
+  } catch {
+    return null;
+  }
+  if (open.length === 0)
+    return null;
+  const details = open.slice(0, MAX_LISTED).map((block) => `${block.id} · ${block.title}`);
+  if (open.length > MAX_LISTED) {
+    details.push(`… and ${String(open.length - MAX_LISTED)} more in ${QUESTIONS_FILE}`);
+  }
+  details.push("these are facts about your project the tool could not detect; every run reuses the answers");
+  return {
+    kind: "init-questions",
+    summary: `${String(open.length)} setup question${open.length === 1 ? "" : "s"} ` + "about your project have never been answered",
+    command: "tldrx interview --init",
+    details
+  };
+}
+
+// src/core/status/seedSplitItems.ts
+import { closeSync, existsSync as existsSync2, openSync, readSync, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { basename, join as join2, relative } from "node:path";
+
+// src/core/seed/triageInventory.ts
+var STATUS_RE = /^\s*(?:[-*+]\s+)?(?:\*\*|__)?\s*status\s*(?:\*\*|__)?\s*:\s*(?:\*\*|__)?\s*([A-Za-z][A-Za-z-]*)/i;
+function statusLineOf(text) {
+  for (const line of text.split(`
+`)) {
+    const match = STATUS_RE.exec(line);
+    if (match !== null && match[1] !== undefined) {
+      return { status: match[1].toLowerCase(), line: line.trim() };
+    }
+  }
+  return null;
+}
+var DOCUMENT_EXTENSIONS = new Set([".md", ".txt", ".markdown", ".rst", ".adoc", ".pdf", ".doc", ".docx"]);
+
+// src/core/detect/walk.ts
+var SKIPPED_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "bin",
+  "obj",
+  "target",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".next",
+  ".expo",
+  ".gradle",
+  "vendor",
+  "coverage",
+  "graphify-out",
+  ".tldrx",
+  "tldrx-work",
+  ".idea",
+  ".vscode",
+  "Pods",
+  "DerivedData",
+  ".terraform",
+  ".turbo",
+  ".cache",
+  "storybook-static",
+  "playwright-report",
+  "test-results"
+]);
+
+// src/core/seed/collectSeed.ts
+var MAX_SEED_BYTES = 2 * 1024 * 1024;
+
+// src/core/seed/splitFile.ts
+var SPLIT_YML = "split.yml";
+var SPLIT_MD = "split.md";
+var SPLIT_SIZES = ["S", "M", "L"];
+var SPLIT_STATUSES = ["proposed", "applying", "applied"];
+function isAnswered2(question) {
+  return typeof question.answer === "string" && question.answer.trim() !== "";
+}
+class SplitError extends Error {
+}
+function readSplitFile(doc) {
+  if (!isRecord(doc))
+    throw new SplitError("split.yml: expected a mapping at the document root");
+  const status = doc.status;
+  if (typeof status !== "string" || !SPLIT_STATUSES.includes(status)) {
+    throw new SplitError(`split.yml: status must be one of ${SPLIT_STATUSES.join(" | ")}, got ${String(status)}`);
+  }
+  if (typeof doc.source !== "string")
+    throw new SplitError("split.yml: `source` must be a string");
+  return doc;
+}
+var SPLIT_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["shared_context", "exclude", "runs", "questions"],
+  properties: {
+    shared_context: { type: "array", items: { type: "string" } },
+    exclude: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["path", "reason"],
+        properties: { path: { type: "string" }, reason: { type: "string" } }
+      }
+    },
+    runs: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["slug", "scope", "goal", "seeds", "depends_on", "size", "budget_usd", "why"],
+        properties: {
+          slug: { type: "string" },
+          scope: { type: "string" },
+          goal: { type: "string" },
+          seeds: { type: "array", items: { type: "string" } },
+          depends_on: { type: "array", items: { type: "string" } },
+          size: { type: "string", enum: [...SPLIT_SIZES] },
+          budget_usd: { type: "number" },
+          why: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              required: ["claim", "src"],
+              properties: { claim: { type: "string" }, src: { type: "string" } }
+            }
+          }
+        }
+      }
+    },
+    questions: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "text"],
+        properties: {
+          id: { type: "string" },
+          text: { type: "string" },
+          options: { type: "array", items: { type: "string" } }
+        }
+      }
+    }
+  }
+};
+
+// src/core/status/seedSplitItems.ts
+var TRIAGE_DIRNAME = "triage";
+var MAX_LISTED2 = 5;
+var STATUS_HEAD_BYTES = 4096;
+function proposedSplits(root) {
+  const triage = join2(root, PROJECT_FRAMEWORK_DIR, TRIAGE_DIRNAME);
+  let entries;
+  try {
+    entries = readdirSync(triage).sort();
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const entry of entries) {
+    const dir = join2(triage, entry);
+    const path = join2(dir, SPLIT_YML);
+    try {
+      if (!statSync(dir).isDirectory() || !existsSync2(path))
+        continue;
+      const file = readSplitFile(parseYaml(readFileSync2(path, "utf8")));
+      if (file.status !== "proposed" && file.status !== "applying")
+        continue;
+      found.push({ path, rel: toRel(root, path), dir, file });
+    } catch {
+      continue;
+    }
+  }
+  return found;
+}
+function seedSplitItems(root) {
+  return proposedSplits(root).map((split) => splitItem(root, split));
+}
+function splitItem(root, split) {
+  const file = split.file;
+  const open = file.questions.filter((question) => !isAnswered2(question));
+  const rels = seedDocuments(split.dir, file);
+  const proposed = proposedDocs(root, split.dir, rels);
+  const decisions = rels.filter((rel) => /^DECISIONS.*\.md$/i.test(basename(rel)));
+  const details = [
+    `${String(file.runs.length)} run(s) would be created: ${file.runs.map((run) => run.slug).join(", ")}`
+  ];
+  if (open.length === 0) {
+    details.push("no unanswered questions on the split itself");
+  } else {
+    details.push(`${String(open.length)} question(s) the proposal could not answer:`);
+    for (const question of open.slice(0, MAX_LISTED2)) {
+      details.push(`  ${question.id} ${question.text}`);
+    }
+    if (open.length > MAX_LISTED2)
+      details.push(`  … and ${String(open.length - MAX_LISTED2)} more`);
+    details.push(`  answer one with \`tldrx seed answer ${split.rel} <Qid> "<text>"\``);
+  }
+  if (proposed.length > 0) {
+    details.push(`${String(proposed.length)} seed document(s) are still \`proposed\` — decisions nobody has made:`);
+    for (const doc of proposed.slice(0, MAX_LISTED2)) {
+      details.push(`  ${doc.rel} — ${doc.line.replace(/^[-*+]\s+/, "")}`);
+    }
+    if (proposed.length > MAX_LISTED2)
+      details.push(`  … and ${String(proposed.length - MAX_LISTED2)} more`);
+  }
+  for (const rel of decisions)
+    details.push(`decisions are collected in ${rel}`);
+  details.push(`read ${toRel(root, join2(split.dir, SPLIT_MD))}, edit ${split.rel} if you disagree, then apply it`);
+  if (file.status === "applying") {
+    const done = file.created_runs ?? [];
+    return {
+      kind: "seed-split",
+      summary: `\`tldrx seed apply ${split.rel}\` stopped at run ${String(done.length + 1)} of ` + `${String(file.runs.length)} — ${done.length === 0 ? "nothing" : `${String(done.length)} run(s)`} ` + "created, the rest were not",
+      command: `tldrx run status`,
+      details: [
+        done.length === 0 ? "no run was created before it stopped" : `created and left in place: ${done.join(", ")}`,
+        `still to create: ${file.runs.map((run) => run.slug).filter((slug) => !done.some((id) => id === slug || id.endsWith(`-${slug}`))).join(", ")}`,
+        `remove those run dirs (or \`tldrx run cancel\` them), set ${split.rel} back to` + " `status: proposed`, and apply again"
+      ]
+    };
+  }
+  return {
+    kind: "seed-split",
+    summary: `a proposed split of \`${file.source}\` into ${String(file.runs.length)} ` + "piece(s) of work is waiting for your decision — nothing has been created yet",
+    command: `tldrx seed apply ${split.rel} --dry-run`,
+    details
+  };
+}
+function seedDocuments(dir, file) {
+  const inventory = join2(dir, "inventory.json");
+  if (existsSync2(inventory)) {
+    try {
+      const doc = JSON.parse(readFileSync2(inventory, "utf8"));
+      const rels2 = (doc.documents ?? []).map((row) => row.rel).filter((rel) => typeof rel === "string");
+      if (rels2.length > 0)
+        return rels2;
+    } catch {}
+  }
+  const rels = new Set(file.shared_context);
+  for (const entry of file.exclude)
+    rels.add(entry.path);
+  for (const run of file.runs)
+    for (const rel of run.seeds)
+      rels.add(rel);
+  return [...rels].sort();
+}
+function proposedDocs(root, dir, rels) {
+  const cached = cachedStatuses(dir);
+  const found = [];
+  for (const rel of rels) {
+    const head = readHead(join2(root, rel));
+    if (head === null) {
+      if (cached.get(rel) === "proposed")
+        found.push({ rel, line: "Status: proposed (from inventory.json)" });
+      continue;
+    }
+    const status = statusLineOf(head);
+    if (status !== null && status.status === "proposed")
+      found.push({ rel, line: status.line });
+  }
+  return found;
+}
+function cachedStatuses(dir) {
+  const out = new Map;
+  const inventory = join2(dir, "inventory.json");
+  if (!existsSync2(inventory))
+    return out;
+  try {
+    const doc = JSON.parse(readFileSync2(inventory, "utf8"));
+    for (const row of doc.documents ?? []) {
+      if (typeof row.rel === "string" && typeof row.adrStatus === "string")
+        out.set(row.rel, row.adrStatus);
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+function readHead(path) {
+  let fd = null;
+  try {
+    fd = openSync(path, "r");
+    const buffer = Buffer.alloc(STATUS_HEAD_BYTES);
+    const read = readSync(fd, buffer, 0, STATUS_HEAD_BYTES, 0);
+    return buffer.subarray(0, read).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null)
+      closeSync(fd);
+  }
+}
+function toRel(root, path) {
+  const rel = relative(root, path);
+  return rel === "" || rel.startsWith("..") ? path : rel.split("\\").join("/");
+}
+
+// src/core/status/runItems.ts
+import { basename as basename2 } from "node:path";
+
+// src/core/run/dependencies.ts
+var MAX_CHAINS = 24;
+function slugOfRun(runId) {
+  return /^\d{6}-(.+)$/.exec(runId)?.[1] ?? runId;
+}
+function resolveDependencies(inputs) {
+  const idBySlug = new Map;
+  const statusById = new Map;
+  for (const input of inputs) {
+    statusById.set(input.id, input.status);
+    const slug = slugOfRun(input.id);
+    if (!idBySlug.has(slug))
+      idBySlug.set(slug, input.id);
+  }
+  const runs = inputs.map((input) => {
+    const dependsOn = input.dependsOn.map((slug) => idBySlug.get(slug) ?? slug);
+    const blockedBy = dependsOn.filter((id) => statusById.get(id) !== "done");
+    return { id: input.id, dependsOn, blockedBy, runnable: blockedBy.length === 0 && input.movable };
+  });
+  return { runs, order: orderOf(inputs, runs), chains: chainsOf(inputs, runs) };
+}
+function orderOf(inputs, runs) {
+  const known = new Set(inputs.map((input) => input.id));
+  const byId = new Map(runs.map((run) => [run.id, run]));
+  const inputById = new Map(inputs.map((input) => [input.id, input]));
+  const waitingOn = new Map;
+  for (const run of runs) {
+    waitingOn.set(run.id, new Set(run.dependsOn.filter((id) => known.has(id) && id !== run.id)));
+  }
+  const rank = (a, b) => {
+    const left2 = byId.get(a);
+    const right = byId.get(b);
+    const leftRunnable = left2 !== undefined && left2.runnable;
+    const rightRunnable = right !== undefined && right.runnable;
+    if (leftRunnable !== rightRunnable)
+      return leftRunnable ? -1 : 1;
+    const leftAt = inputById.get(a)?.updatedAt ?? "";
+    const rightAt = inputById.get(b)?.updatedAt ?? "";
+    if (leftAt !== rightAt)
+      return rightAt.localeCompare(leftAt);
+    return a.localeCompare(b);
+  };
+  const placed = [];
+  const left = new Set(known);
+  while (left.size > 0) {
+    const ready = [...left].filter((id) => (waitingOn.get(id)?.size ?? 0) === 0).sort(rank);
+    const next = ready[0];
+    if (next === undefined)
+      break;
+    placed.push(next);
+    left.delete(next);
+    for (const id of left)
+      waitingOn.get(id)?.delete(next);
+  }
+  return [...placed, ...[...left].sort(rank)];
+}
+function chainsOf(inputs, runs) {
+  const known = new Set(inputs.map((input) => input.id));
+  const parents = new Map;
+  const children = new Map;
+  for (const id of known)
+    children.set(id, []);
+  for (const run of runs) {
+    const edges = run.dependsOn.filter((id) => known.has(id) && id !== run.id);
+    parents.set(run.id, edges);
+    for (const parent of edges)
+      children.get(parent)?.push(run.id);
+  }
+  const roots = [...known].filter((id) => (parents.get(id) ?? []).length === 0).sort();
+  const chains = [];
+  const walk = (path) => {
+    if (chains.length >= MAX_CHAINS)
+      return;
+    const head = path[path.length - 1] ?? "";
+    const next = (children.get(head) ?? []).filter((id) => !path.includes(id)).sort();
+    if (next.length === 0) {
+      if (path.length > 1)
+        chains.push([...path]);
+      return;
+    }
+    for (const child of next)
+      walk([...path, child]);
+  };
+  for (const root of roots)
+    walk([root]);
+  return chains;
+}
+
+// src/core/status/runItems.ts
+var NEXT_MARK = "← next";
+function dependencyInputs(root) {
+  const out = [];
+  for (const dir of listRunDirs(root)) {
+    let store;
+    try {
+      store = RunStore.open(dir);
+    } catch {
+      continue;
+    }
+    const run = store.run;
+    out.push({
+      id: run.run === "" ? basename2(dir) : run.run,
+      status: run.status,
+      dependsOn: run.triage?.depends_on ?? [],
+      movable: isMovable(whatIsWaiting(run, store.runDir).kind),
+      updatedAt: run.updated_at
+    });
+  }
+  return out;
+}
+function runItems(root) {
+  const open = RunStore.findOpen(root);
+  const unreadable = unreadableItem(root);
+  if (open.length === 0)
+    return unreadable === null ? [] : [unreadable];
+  const inputs = dependencyInputs(root);
+  const known = new Set(inputs.map((input) => input.id));
+  const statuses = new Map(inputs.map((input) => [input.id, input.status]));
+  const resolved = new Map(resolveDependencies(inputs).runs.map((run) => [run.id, run]));
+  const several = open.length > 1;
+  let markedNext = false;
+  const items = open.map((store) => {
+    const run = store.run;
+    const waiting = whatIsWaiting(run, store.runDir);
+    const blockedIds = resolved.get(run.run)?.blockedBy ?? [];
+    const blocked = blockedIds.map(slugOfRun);
+    const runnable = resolved.get(run.run)?.runnable ?? isMovable(waiting.kind);
+    const isNext = runnable && !markedNext;
+    if (isNext)
+      markedNext = true;
+    const details = [];
+    if (isNext) {
+      details.push(`${NEXT_MARK} — the first run you can move; \`tldrx run auto ${run.run}\` runs it headless ` + "until something genuinely needs a person");
+    }
+    details.push(`at ${run.cursor.phase} / ${run.cursor.stage} · run status ${run.status} · waiting: ${waiting.kind}`);
+    for (const id of blockedIds) {
+      const status = known.has(id) ? statuses.get(id) : undefined;
+      details.push(`blocked by ${slugOfRun(id)} — ${status === undefined ? "no run exists for it" : `it is ${status}`}`);
+    }
+    if (waiting.kind === "gate") {
+      details.push(`disagree instead: \`tldrx reject --run ${run.run} --note "<why>"\``);
+    }
+    if (waiting.kind === "answer" && waiting.questions.length > 1) {
+      details.push(`open questions: ${waiting.questions.join(", ")}`);
+    }
+    if (waiting.kind === "failed")
+      details.push(waiting.message);
+    details.push(...machineSignedDetails(run));
+    if (several)
+      details.push("several runs are open, so every command here names its run id");
+    return {
+      kind: "run",
+      summary: summaryOf(run, waiting, blocked),
+      command: blocked.length > 0 ? "" : commandFor(run, waiting),
+      details
+    };
+  });
+  return unreadable === null ? items : [...items, unreadable];
+}
+function unreadableItem(root) {
+  const broken = [];
+  for (const dir of listRunDirs(root)) {
+    try {
+      RunStore.open(dir);
+    } catch (error) {
+      broken.push(`${basename2(dir)} — ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (broken.length === 0)
+    return null;
+  const first = broken[0]?.split(" — ")[0] ?? "";
+  return {
+    kind: "run",
+    summary: `${String(broken.length)} run folder(s) in ${PROJECT_WORK_DIR}/ could not be read, ` + "so nothing here can say what they are waiting on",
+    command: `tldrx run status ${first}`,
+    details: broken
+  };
+}
+var AUTO = "auto";
+function machineSignedDetails(run) {
+  const stages = run.phases.flatMap((phase) => phase.stages.map((stage) => ({ phase, stage })));
+  const auto = stages.filter((e) => e.stage.gate.status === "approved" && e.stage.gate.by === AUTO);
+  const stale = stages.filter((e) => e.stage.stale === true);
+  const details = [];
+  if (auto.length > 0) {
+    const named = auto.map((e) => `${e.phase.id}/${e.stage.id}`).join(", ");
+    const first = auto[0];
+    details.push(`${auto.length} gate(s) signed \`by: auto\`, not by a person — ${named}. ` + `Take one back with \`tldrx reject --run ${run.run} ` + `--stage ${first?.phase.id ?? ""}/${first?.stage.id ?? ""} --note "<why>"\``);
+  }
+  if (stale.length > 0) {
+    details.push(`${stale.length} stage(s) marked stale by a revoked approval — ` + `${stale.map((e) => `${e.phase.id}/${e.stage.id}`).join(", ")}. Their files are still on disk ` + "and were derived from a decision that has since been withdrawn.");
+  }
+  return details;
+}
+function summaryOf(run, waiting, blocked) {
+  const what = run.title === "" ? run.run : `${run.run} ("${run.title}")`;
+  if (blocked.length > 0) {
+    return `run ${what} cannot start yet — it was proposed to follow ${blocked.join(", ")}`;
+  }
+  switch (waiting.kind) {
+    case "gate":
+      return `run ${what} finished a stage and is waiting for you to approve it`;
+    case "answer":
+      return `run ${what} asked you ${String(waiting.questions.length)} question(s) and stopped for the answer`;
+    case "failed":
+      return `run ${what} failed at ${run.cursor.phase}/${run.cursor.stage} and is waiting to be retried or dropped`;
+    case "ready":
+      return `run ${what} is ready to run its next stage`;
+    case "done":
+      return `run ${what} has no stage left to run but is still open`;
+    default:
+      return `run ${what} is blocked at ${run.cursor.phase}/${run.cursor.stage}`;
+  }
+}
+function commandFor(run, waiting) {
+  switch (waiting.kind) {
+    case "gate":
+      return `tldrx approve --run ${run.run}`;
+    case "answer":
+      return `tldrx answer ${waiting.questions[0] ?? "Q1"} "<your answer>" --run ${run.run}`;
+    case "ready":
+    case "failed":
+      return `tldrx next ${run.run}`;
+    default:
+      return "";
+  }
+}
+// src/core/experts/loadExperts.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/core/init/competencyLevel.ts
+var EVIDENCE_KINDS = ["code", "run", "test", "doc", "answer"];
+var ALLOWED_KINDS = EVIDENCE_KINDS.join(", ");
+function isEvidenceKind(value) {
+  return EVIDENCE_KINDS.includes(value);
+}
+var EVIDENCE_CONFIDENCES = ["measured", "inferred", "assumed"];
+function isEvidenceConfidence(value) {
+  return EVIDENCE_CONFIDENCES.includes(value);
+}
+var WEIGHTS = { code: 1, run: 1, test: 1, doc: 0.5, answer: 0.8 };
+var CROSS_MULTIPLIER = 2;
+var ASSUMED_MULTIPLIER = 0.5;
+var THRESHOLDS = [0.5, 1.5, 3, 6, 20];
+var RECENCY_FLOOR = 0.25;
+var RECENCY_HALFLIFE_DAYS = 365;
+var NO_RUN_CAP = 3;
+var MIN_KINDS_FOR_TOP = 2;
+var DAY_MS = 86400000;
+function competencyLevel(evidence, now = new Date) {
+  if (evidence.length === 0)
+    return 0;
+  let weighted = 0;
+  const sources = new Set;
+  const kinds = new Set;
+  for (const item of evidence) {
+    const ageDays = daysBetween(item.at, now);
+    if (ageDays === null)
+      continue;
+    weighted += recency(ageDays) * weightOf(item);
+    sources.add(item.src);
+    kinds.add(item.kind);
+  }
+  let level = THRESHOLDS.filter((threshold) => weighted >= threshold).length;
+  if (!kinds.has("run"))
+    level = Math.min(level, NO_RUN_CAP);
+  if (level === 5 && kinds.size < MIN_KINDS_FOR_TOP)
+    level = 4;
+  return Math.min(level, sources.size);
+}
+function weightOf(item) {
+  const base = WEIGHTS[item.kind];
+  const cross = item.cross === true ? CROSS_MULTIPLIER : 1;
+  const confidence = item.confidence === "assumed" ? ASSUMED_MULTIPLIER : 1;
+  return base * cross * confidence;
+}
+function recency(ageDays) {
+  return Math.max(RECENCY_FLOOR, 1 - ageDays / RECENCY_HALFLIFE_DAYS);
+}
+function daysBetween(at, now) {
+  const then = Date.parse(at);
+  if (Number.isNaN(then))
+    return null;
+  return Math.max(0, (now.getTime() - then) / DAY_MS);
+}
+
+// src/core/experts/evidenceSrc.ts
+function checkEvidenceSrc(kind, src) {
+  const parsed = classifySrc(src);
+  if ("message" in parsed)
+    return { reason: "malformed-src" };
+  return matchesKind(kind, parsed) ? null : { reason: "kind-mismatch" };
+}
+function matchesKind(kind, ref) {
+  switch (kind) {
+    case "code":
+      return ref.kind === "file";
+    case "run":
+      return ref.kind === "cmd" || isRunArtifact(ref);
+    case "test":
+      return ref.kind === "file" || ref.kind === "cmd";
+    case "doc":
+      return ref.kind === "doc";
+    case "answer":
+      return ref.kind === "fact";
+  }
+}
+function isRunArtifact(ref) {
+  return ref.kind === "file" && ref.repo === null && ref.path.startsWith("tldrx-work/");
+}
+
+// src/core/experts/readEvidenceRows.ts
+function readEvidenceRows(input) {
+  if (!Array.isArray(input))
+    return { evidence: [], ignored: [] };
+  const evidence = [];
+  const counts = new Map;
+  const refuse = (reason, kind, src) => {
+    const key = `${reason} ${reason === "unknown-kind" ? kind : `${kind} ${src}`}`;
+    const seen = counts.get(key);
+    counts.set(key, seen === undefined ? { reason, kind, src, count: 1 } : { ...seen, count: seen.count + 1 });
+  };
+  for (const raw of input) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+      continue;
+    const row = raw;
+    const kind = str(row.kind);
+    const src = str(row.src);
+    const at = str(row.at);
+    if (src === "" || at === "")
+      continue;
+    if (!isEvidenceKind(kind)) {
+      refuse("unknown-kind", kind, "");
+      continue;
+    }
+    const problem = checkEvidenceSrc(kind, src);
+    if (problem !== null) {
+      refuse(problem.reason, kind, src);
+      continue;
+    }
+    const confidence = str(row.confidence);
+    evidence.push({
+      kind,
+      src,
+      at,
+      ...row.cross === true ? { cross: true } : {},
+      ...isEvidenceConfidence(confidence) ? { confidence } : {}
+    });
+  }
+  return { evidence, ignored: [...counts.values()] };
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+
+// src/core/experts/loadExperts.ts
+var EXPERTS_DIRNAME = "experts";
+var COMPETENCIES_FILE = "competencies.yml";
+var EXPERT_FILE = "expert.md";
+function expertsDir(root) {
+  return join3(root, PROJECT_FRAMEWORK_DIR, EXPERTS_DIRNAME);
+}
+function expertDir(root, name) {
+  return join3(expertsDir(root), name);
+}
+function loadExperts(root, now = new Date) {
+  const dir = expertsDir(root);
+  if (!existsSync3(dir))
+    return [];
+  const names = readdirSync2(dir).filter((entry) => statSync2(join3(dir, entry)).isDirectory()).sort();
+  return names.map((name) => loadExpert(root, name, now));
+}
+function loadExpert(root, name, now = new Date) {
+  const dir = expertDir(root, name);
+  const path = join3(dir, COMPETENCIES_FILE);
+  const empty = { name, dir, status: "unknown", lastTrained: null, areas: [], drifted: [] };
+  if (!existsSync3(path))
+    return { ...empty, error: `${COMPETENCIES_FILE} is missing` };
+  let doc;
+  try {
+    const parsed = parseYaml(readFileSync3(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { ...empty, error: `${COMPETENCIES_FILE} is not a mapping` };
+    }
+    doc = parsed;
+  } catch (error) {
+    return { ...empty, error: error instanceof Error ? error.message : String(error) };
+  }
+  const areas = Array.isArray(doc.areas) ? doc.areas.map((area) => toArea(name, area, now)).filter((area) => area !== null) : [];
+  return {
+    name: typeof doc.expert === "string" && doc.expert !== "" ? doc.expert : name,
+    dir,
+    status: typeof doc.status === "string" ? doc.status : "unknown",
+    lastTrained: typeof doc.last_trained === "string" ? doc.last_trained : null,
+    areas,
+    drifted: areas.filter((area) => area.storedLevel !== null && area.storedLevel !== area.level),
+    error: null
+  };
+}
+function toArea(expert, input, now) {
+  if (typeof input !== "object" || input === null || Array.isArray(input))
+    return null;
+  const raw = input;
+  const id = str2(raw.id) !== "" ? str2(raw.id) : str2(raw.area);
+  if (id === "")
+    return null;
+  const { evidence, ignored } = readEvidenceRows(raw.evidence);
+  return {
+    id,
+    title: str2(raw.title) !== "" ? str2(raw.title) : id,
+    storedLevel: typeof raw.level === "number" ? raw.level : null,
+    level: competencyLevel(evidence, now),
+    trainPrompt: str2(raw.train_prompt) !== "" ? str2(raw.train_prompt) : `tldrx expert train ${expert} --area ${id} --mode light`,
+    evidence,
+    ignored,
+    newestEvidence: newestDate(evidence)
+  };
+}
+function newestDate(evidence) {
+  let newest = null;
+  for (const item of evidence) {
+    if (newest === null || item.at > newest)
+      newest = item.at;
+  }
+  return newest;
+}
+function str2(value) {
+  return typeof value === "string" ? value : "";
+}
+// src/core/experts/stageCoverage.ts
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
+import { join as join6 } from "node:path";
+
+// src/core/experts/stackExperts.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+function stackExpertNames(root, repos) {
+  const path = join4(root, PROJECT_FRAMEWORK_DIR, "workspace.yml");
+  if (!existsSync4(path))
+    return [];
+  let doc;
+  try {
+    doc = parseYaml(readFileSync4(path, "utf8"));
+  } catch {
+    return [];
+  }
+  const list = doc?.repos;
+  if (!Array.isArray(list))
+    return [];
+  const names = [];
+  for (const row of list) {
+    if (typeof row?.name !== "string" || !repos.includes(row.name))
+      continue;
+    const stack = Array.isArray(row.stack) ? row.stack : [];
+    for (const language of stack) {
+      if (typeof language !== "string" || language === "")
+        continue;
+      const expert = `${language}-stack`;
+      if (!names.includes(expert))
+        names.push(expert);
+    }
+  }
+  return names;
+}
+
+// src/core/experts/selectExperts.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+
+// src/core/experts/expertDocument.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { join as join5 } from "node:path";
+var H2_RE = /^##\s+(.+?)\s*$/;
+function readExpertDocument(root, name) {
+  const path = join5(expertDir(root, name), EXPERT_FILE);
+  if (!existsSync5(path)) {
+    return { path, exists: false, frontMatter: new Map, body: "" };
+  }
+  const text = readFileSync5(path, "utf8");
+  const { frontMatter, body } = splitFrontMatter(text);
+  return { path, exists: true, frontMatter, body };
+}
+function splitFrontMatter(text) {
+  const frontMatter = new Map;
+  if (!text.startsWith(`---
+`))
+    return { frontMatter, body: text };
+  const end = text.indexOf(`
+---`, 3);
+  if (end === -1)
+    return { frontMatter, body: text };
+  for (const line of text.slice(4, end).split(`
+`)) {
+    const colon = line.indexOf(":");
+    if (colon <= 0 || line.trimStart().startsWith("#"))
+      continue;
+    const key = line.slice(0, colon).trim();
+    const value = line.slice(colon + 1).replace(/#.*$/, "").trim().replace(/^"(.*)"$/, "$1");
+    if (key !== "")
+      frontMatter.set(key, value);
+  }
+  const newline = text.indexOf(`
+`, end + 1);
+  return { frontMatter, body: newline === -1 ? "" : text.slice(newline + 1) };
+}
+function section(body, heading) {
+  const lines = body.split(`
+`);
+  const collected = [];
+  let inside = false;
+  for (const line of lines) {
+    const match = H2_RE.exec(line);
+    if (match !== null) {
+      if (inside)
+        break;
+      inside = match[1] === heading;
+      continue;
+    }
+    if (inside)
+      collected.push(line);
+  }
+  return collected.join(`
+`).trim();
+}
+
+// src/core/experts/expertDomain.ts
+var PLACEHOLDER_PATHS = new Set(["path/to/module", "path/to/other"]);
+function readExpertDomain(root, name) {
+  const doc = readExpertDocument(root, name);
+  if (!doc.exists)
+    return { name, exists: false, kind: "", repos: [], paths: [] };
+  return {
+    name,
+    exists: true,
+    kind: doc.frontMatter.get("kind") ?? "",
+    repos: parseList(doc.frontMatter.get("repos") ?? ""),
+    paths: domainPaths(section(doc.body, "Domain"))
+  };
+}
+function parseList(value) {
+  const inner = value.trim().replace(/^\[/, "").replace(/\]$/, "");
+  return inner.split(",").map((item) => item.trim().replace(/^["']|["']$/g, "")).filter((item) => item !== "");
+}
+function domainPaths(body) {
+  const paths = [];
+  for (const line of body.split(`
+`)) {
+    const bullet = /^\s*[-*]\s+(.*)$/.exec(line);
+    if (bullet === null)
+      continue;
+    const text = (bullet[1] ?? "").trim();
+    if (/^repo\s/i.test(text))
+      continue;
+    const code = /`([^`]+)`/.exec(text);
+    const raw = (code?.[1] ?? text.split(/\s+—\s+/)[0] ?? "").trim();
+    const path = normalisePath(raw);
+    if (path === "" || PLACEHOLDER_PATHS.has(path) || !path.includes("/"))
+      continue;
+    if (!paths.includes(path))
+      paths.push(path);
+  }
+  return paths;
+}
+function normalisePath(raw) {
+  return raw.trim().replace(/^[a-z0-9-]+:(?=[^/])/i, "").replace(/^\.\//, "").replace(/\/+$/, "").replace(/\\/g, "/");
+}
+function pathsIntersect(a, b) {
+  const left = normalisePath(a);
+  const right = normalisePath(b);
+  if (left === "" || right === "")
+    return false;
+  if (left === right)
+    return true;
+  return left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+
+// src/core/experts/selectExperts.ts
+var MAX_DOMAIN_SELECTED = 8;
+var LEGACY_STAGE_EXPERTS = ["domain", "stack"];
+function selectExperts(input) {
+  const experts = [];
+  const seen = new Set;
+  const missing = [];
+  const legacy = [];
+  for (const name of input.staged) {
+    if (seen.has(name))
+      continue;
+    seen.add(name);
+    if (!hasExpert(input.root, name)) {
+      if (LEGACY_STAGE_EXPERTS.includes(name))
+        legacy.push(name);
+      else
+        missing.push(name);
+      continue;
+    }
+    experts.push({ name, reason: "stage", relevant: true });
+  }
+  if (input.stackExperts) {
+    for (const name of input.stackNames) {
+      if (seen.has(name))
+        continue;
+      seen.add(name);
+      if (!hasExpert(input.root, name))
+        continue;
+      experts.push({ name, reason: "stack", relevant: true });
+    }
+  }
+  const { picked, overflow } = domainMatches(input, seen);
+  for (const match of picked) {
+    seen.add(match.name);
+    experts.push(match);
+  }
+  return { experts, missing, overflow, legacy };
+}
+function expertNames(root) {
+  const dir = expertsDir(root);
+  if (!existsSync6(dir))
+    return [];
+  return readdirSync3(dir).filter((entry) => {
+    try {
+      return statSync3(`${dir}/${entry}`).isDirectory();
+    } catch {
+      return false;
+    }
+  }).sort();
+}
+function hasExpert(root, name) {
+  return existsSync6(`${expertsDir(root)}/${name}`);
+}
+var DIRECT_WEIGHT = 10;
+var GRAPH_HOPS = 2;
+function domainMatches(input, seen) {
+  if (input.repos.length === 0 && (input.citedPaths ?? []).length === 0) {
+    return { picked: [], overflow: [] };
+  }
+  const repoIsEvidence = (input.workspaceRepoCount ?? 2) >= 2;
+  const cited = input.citedPaths ?? [];
+  const nearby = input.nearbyPaths ?? new Set;
+  const scored = [];
+  for (const name of expertNames(input.root)) {
+    if (seen.has(name))
+      continue;
+    const declared = readExpertDomain(input.root, name);
+    if (declared.kind !== "domain")
+      continue;
+    const direct = countMatches(declared, cited);
+    const near = direct > 0 ? 0 : countMatches(declared, [...nearby]);
+    const score = direct * DIRECT_WEIGHT + near;
+    if (score > 0) {
+      const match = direct > 0 ? matchedPath(declared, cited) ?? "path" : `${String(near)} path(s) within ${String(GRAPH_HOPS)} hops in graph.json`;
+      scored.push({ expert: { name, reason: "domain", match, relevant: true }, score });
+      continue;
+    }
+    if (!repoIsEvidence)
+      continue;
+    const repo = declared.repos.find((r) => input.repos.includes(r));
+    if (repo !== undefined) {
+      scored.push({
+        expert: { name, reason: "domain", match: `repo ${repo}`, relevant: false },
+        score: 0
+      });
+    }
+  }
+  const ranked = [...scored].sort((a, b) => b.score - a.score || (a.expert.name < b.expert.name ? -1 : a.expert.name > b.expert.name ? 1 : 0)).map((entry) => entry.expert);
+  return {
+    picked: ranked.slice(0, MAX_DOMAIN_SELECTED),
+    overflow: ranked.slice(MAX_DOMAIN_SELECTED).map((item) => item.name)
+  };
+}
+function countMatches(declared, paths) {
+  let count = 0;
+  for (const cited of paths) {
+    if (matchedPath(declared, [cited]) !== null)
+      count += 1;
+  }
+  return count;
+}
+function matchedPath(declared, citedPaths) {
+  for (const cited of citedPaths) {
+    for (const path of declared.paths) {
+      if (pathsIntersect(path, cited))
+        return cited;
+      for (const repo of declared.repos) {
+        if (pathsIntersect(`${repo}/${path}`, cited))
+          return cited;
+      }
+    }
+  }
+  return null;
+}
+
+// src/core/experts/stageCoverage.ts
+function stagesLoadingExperts(root) {
+  const repos = workspaceRepos(root);
+  const stackNames = stackExpertNames(root, repos);
+  const byExpert = new Map;
+  for (const stage of stageIds(root)) {
+    const doc = readStage(root, stage);
+    if (doc === null)
+      continue;
+    const selection = selectExperts({
+      root,
+      staged: strings(doc.experts),
+      repos,
+      stackExperts: typeof doc.stack_experts === "boolean" ? doc.stack_experts : true,
+      stackNames
+    });
+    for (const chosen of selection.experts) {
+      const rows = byExpert.get(chosen.name) ?? [];
+      rows.push({ stage, reason: chosen.reason });
+      byExpert.set(chosen.name, rows);
+    }
+  }
+  return byExpert;
+}
+function stageIds(root) {
+  const ids = new Set([
+    ...dirsIn(join6(root, PROJECT_FRAMEWORK_DIR, "stages")),
+    ...dirsIn(STAGES_DIR)
+  ]);
+  return [...ids].sort();
+}
+function dirsIn(dir) {
+  if (!existsSync7(dir))
+    return [];
+  try {
+    return readdirSync4(dir).filter((entry) => {
+      try {
+        return statSync4(join6(dir, entry)).isDirectory() && existsSync7(join6(dir, entry, "stage.yml"));
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function readStage(root, id) {
+  const local = join6(root, PROJECT_FRAMEWORK_DIR, "stages", id, "stage.yml");
+  const path = existsSync7(local) ? local : join6(STAGES_DIR, id, "stage.yml");
+  if (!existsSync7(path))
+    return null;
+  try {
+    const doc = parseYaml(readFileSync6(path, "utf8"));
+    return isRecord(doc) ? doc : null;
+  } catch {
+    return null;
+  }
+}
+function workspaceRepos(root) {
+  const path = join6(root, PROJECT_FRAMEWORK_DIR, "workspace.yml");
+  if (!existsSync7(path))
+    return [];
+  try {
+    const doc = parseYaml(readFileSync6(path, "utf8"));
+    const list = isRecord(doc) && Array.isArray(doc.repos) ? doc.repos : [];
+    return list.map((row) => isRecord(row) && typeof row.name === "string" ? row.name : "").filter((name) => name !== "");
+  } catch {
+    return [];
+  }
+}
+function strings(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+
+// src/core/experts/renderExpertList.ts
+function evidenceCount(expert) {
+  return expert.areas.reduce((total, area) => total + area.evidence.length, 0);
+}
+// src/core/experts/expertKnowledge.ts
+var DEFAULT_KNOWLEDGE_MAX_BYTES = 48 * 1024;
+
+// src/core/experts/roleExperts.ts
+import { join as join7 } from "node:path";
+var ROLE_TEMPLATES_DIR = join7(TEMPLATES_DIR, "experts");
+// src/core/experts/domainRank.ts
+var MAX_GRAPH_BYTES = 64 * 1024 * 1024;
+// src/core/training/mineRuns.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
+import { join as join8, relative as relative2 } from "node:path";
+var MAX_RUN_BYTES = 64 * 1024;
+var MINED_NAMES = ["handoff.md", "retro.md"];
+var MAX_DEPTH = 4;
+function hasMinableFiles(root) {
+  for (const runDir of listRunDirs(root)) {
+    if (findMined(runDir, 0).length > 0)
+      return true;
+  }
+  return false;
+}
+function findMined(dir, depth) {
+  if (depth > MAX_DEPTH)
+    return [];
+  let entries;
+  try {
+    entries = readdirSync5(dir);
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const entry of [...entries].sort()) {
+    if (entry.startsWith("."))
+      continue;
+    const abs = join8(dir, entry);
+    let isDir = false;
+    try {
+      isDir = statSync5(abs).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir)
+      found.push(...findMined(abs, depth + 1));
+    else if (MINED_NAMES.includes(entry))
+      found.push(abs);
+  }
+  return found;
+}
+
+// src/core/status/expertItems.ts
+var MAX_EXPERT_NAMES = 5;
+function expertAdvice(root) {
+  const loads = stagesLoadingExperts(root);
+  const untrained = loadExperts(root).filter((expert) => expert.error === null).filter((expert) => (loads.get(expert.name) ?? []).length > 0).filter((expert) => evidenceCount(expert) === 0).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  if (untrained.length === 0)
+    return [];
+  const minable = hasMinableFiles(root);
+  const trainable = [];
+  const waiting = [];
+  const arealess = [];
+  for (const expert of untrained) {
+    if (expert.areas[0] === undefined)
+      arealess.push(expert.name);
+    else if (isRole(root, expert) && !minable)
+      waiting.push(expert.name);
+    else
+      trainable.push(expert.name);
+  }
+  const details = [];
+  if (trainable.length > 0) {
+    const shown = trainable.slice(0, MAX_EXPERT_NAMES);
+    const more = trainable.length - shown.length;
+    details.push(`train the ones a stage will load: ${shown.join(", ")}` + (more === 0 ? "" : ` (and ${String(more)} more)`));
+    const first = untrained.find((expert) => expert.name === shown[0]);
+    const area = first?.areas[0];
+    if (first !== undefined && area !== undefined) {
+      const mode = isRole(root, first) ? "full" : "light";
+      details.push(`e.g. tldrx expert train ${first.name} --area ${area.id} --mode ${mode} --print-prompt`);
+    }
+  }
+  if (waiting.length > 0) {
+    details.push(waiting.length === 1 ? `${waiting[0] ?? ""} is a role expert: it trains from past runs' handoffs, ` + "and this workspace has none yet" : `${waiting.join(", ")} are role experts: they train from past runs' handoffs, ` + "and this workspace has none yet");
+  }
+  if (arealess.length > 0) {
+    details.push(`${arealess.join(", ")} ${arealess.length === 1 ? "has" : "have"} no competency areas, ` + "so nothing can be trained into them yet");
+  }
+  details.push("an untrained expert reads like a trained one inside the prompt; it just has nothing to say");
+  return [{
+    kind: "expert",
+    summary: `${String(untrained.length)} expert(s) a stage will load have no evidence yet`,
+    command: "tldrx expert list",
+    details
+  }];
+}
+function isRole(root, expert) {
+  return readExpertDomain(root, expert.name).kind === "role";
+}
+
+// src/core/status/workspaceStatus.ts
+var NOTHING_PENDING = {
+  kind: "none",
+  summary: "nothing pending — open work with `tldrx run new <slug> --seed <path>` or `tldrx seed triage <path>`",
+  command: "",
+  details: []
+};
+function buildWorkspaceStatus(root) {
+  const items = [
+    ...safely(() => {
+      const item = initQuestionsItem(root);
+      return item === null ? [] : [item];
+    }),
+    ...safely(() => seedSplitItems(root)),
+    ...safely(() => runItems(root))
+  ];
+  const advice = safely(() => expertAdvice(root));
+  return items.length === 0 ? { root, items: [NOTHING_PENDING], advice, pending: 0 } : { root, items, advice, pending: items.length };
+}
+function safely(build) {
+  try {
+    return build();
+  } catch {
+    return [];
+  }
+}
+// src/core/status/renderWorkspaceStatus.ts
+function sessionStartLines(status, max) {
+  const pending = status.items.filter(isPending);
+  if (pending.length === 0 || max <= 0)
+    return [];
+  const lines = [
+    `tldrx: ${String(pending.length)} pending — \`tldrx status\` for all of it, or \`/tldrx\` to be walked through it`
+  ];
+  for (const item of pending) {
+    if (lines.length >= max)
+      break;
+    lines.push(`tldrx:   [${String(lines.length)}] ${item.summary}`);
+  }
+  return lines;
+}
+// src/hooks/session-start.ts
+var MAX_LINES = 3;
+var MAX_PENDING_LINES = 3;
+var MAX_OPEN_LISTED = 8;
+await runHook("session-start", async () => {
+  const payload = await readPayload();
+  const root = findWorkspaceRoot(payload.cwd ?? process.cwd());
+  if (root === null)
+    return;
+  const pending = renderPending(root);
+  const snapshot = runSnapshot(root);
+  if (snapshot === null) {
+    if (pending.length > 0)
+      sessionContext(pending.join(`
+`));
+    return;
+  }
+  sessionContext([...renderOpenRuns(root, snapshot), ...renderStatus(snapshot), ...pending].join(`
+`));
+});
+function renderPending(root) {
+  try {
+    return sessionStartLines(buildWorkspaceStatus(root), MAX_PENDING_LINES);
+  } catch {
+    return [];
+  }
+}
+function renderOpenRuns(root, newest) {
+  if (newest.openCount < 2)
+    return [];
+  const open = openRunViews(root).slice(0, MAX_OPEN_LISTED);
+  const lines = [
+    `tldrx: ${String(newest.openCount)} runs are open — pass a run id to next/answer/approve/…`
+  ];
+  for (const view of open) {
+    const cursor = view.cursor === null ? "?" : `${view.cursor.phase}/${view.cursor.stage}`;
+    const mark = view.run === newest.run ? "  (newest)" : "";
+    lines.push(`tldrx:   ${view.run} · ${view.status || "unknown"} · ${cursor}${mark}`);
+  }
+  if (newest.openCount > open.length) {
+    lines.push(`tldrx:   … and ${String(newest.openCount - open.length)} more — \`tldrx run status\``);
+  }
+  return lines;
+}
+function renderStatus(snapshot) {
+  const lines = [];
+  const title = snapshot.title === "" ? "" : ` — "${snapshot.title}"`;
+  const scope = snapshot.scope === "" ? "" : ` (${snapshot.scope})`;
+  lines.push(`tldrx: run ${snapshot.run}${title}${scope} · ${snapshot.status || "unknown"}`);
+  if (snapshot.stage !== "") {
+    const expert = snapshot.expert === null ? "" : ` — ${snapshot.expert}`;
+    lines.push(`tldrx: at ${snapshot.phase} / ${snapshot.stage}${expert} · ${snapshot.stageStatus}`);
+  }
+  const pending = pendingLine(snapshot);
+  if (pending !== null)
+    lines.push(pending);
+  return lines.slice(0, MAX_LINES);
+}
+function pendingLine(snapshot) {
+  const open = openQuestions(snapshot);
+  const bits = [];
+  if (open.length > 0) {
+    bits.push(`${String(open.length)} open question${open.length === 1 ? "" : "s"} (${open.slice(0, 3).join(", ")})`);
+  }
+  if (snapshot.status === "awaiting_gate" || snapshot.stageStatus === "awaiting_gate") {
+    bits.push("gate pending: `tldrx approve`");
+  }
+  if (bits.length === 0)
+    return null;
+  return `tldrx: ${bits.join(" · ")}`;
+}
+allow();