tldr-experts 0.5.0 → 0.6.0

package/dist/hooks/{chunk-14zn51kh.js → chunk-7eqhfddw.js}

@@ -1,14 +1,17 @@
+import {
+  EVIDENCE_FILE,
+  gateEvidenceRelPath
+} from "./chunk-h7151g8w.js";
 import {
   MAX_PLAN_STORIES,
   MAX_STORIES_PER_WAVE,
   MAX_WAVES,
   STORY_ID_RE,
   WAVE_ID_RE,
-  parseFrontMatter,
   requirePattern,
   requireStringList,
   requireVersion1
-} from "./chunk-hcrbr430.js";
+} from "./chunk-g4db8rbs.js";
 import {
   asDocument,
   isRecord,
@@ -21,9 +24,6 @@ import {
   requireVersion,
   result
 } from "./chunk-39zh2e44.js";
-import {
-  parseHandoff
-} from "./chunk-q8d3sff9.js";
 import {
   PROJECT_FRAMEWORK_DIR,
   SRC_PATTERNS,
@@ -31,7 +31,7 @@ import {
   listRunDirs,
   parseYaml,
   readableSource
-} from "./chunk-a6rpj2cp.js";
+} from "./chunk-9w64mxdh.js";
 
 // src/hooks/lib/runFile.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -424,19 +424,25 @@ var SKIPPED_DIRS = new Set([
   "test-results"
 ]);
 
-// src/core/plan/branchModel.ts
-var BRANCH_MODELS = ["per-epic", "integration"];
-function isBranchModelKind(value) {
-  return typeof value === "string" && BRANCH_MODELS.includes(value);
+// src/core/facilitator/paths.ts
+import { join as join2, relative, sep } from "node:path";
+function agentDir(runDir, stageId) {
+  return join2(runDir, ".agent", stageId);
+}
+function evidencePath(runDir, stageId) {
+  return join2(agentDir(runDir, stageId), EVIDENCE_FILE);
+}
+function gateEvidencePath(runDir, phaseId, stageId) {
+  return join2(runDir, ...gateEvidenceRelPath(phaseId, stageId).split("/"));
 }
 
 // src/core/experts/expertDocument.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 
 // src/core/experts/loadExperts.ts
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 
 // src/core/init/competencyLevel.ts
 var EVIDENCE_KINDS = ["code", "run", "test", "doc", "answer"];
@@ -568,21 +574,21 @@ var EXPERTS_DIRNAME = "experts";
 var COMPETENCIES_FILE = "competencies.yml";
 var EXPERT_FILE = "expert.md";
 function expertsDir(root) {
-  return join2(root, PROJECT_FRAMEWORK_DIR, EXPERTS_DIRNAME);
+  return join3(root, PROJECT_FRAMEWORK_DIR, EXPERTS_DIRNAME);
 }
 function expertDir(root, name) {
-  return join2(expertsDir(root), name);
+  return join3(expertsDir(root), name);
 }
 function loadExperts(root, now = new Date) {
   const dir = expertsDir(root);
   if (!existsSync2(dir))
     return [];
-  const names = readdirSync(dir).filter((entry) => statSync(join2(dir, entry)).isDirectory()).sort();
+  const names = readdirSync(dir).filter((entry) => statSync(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 = join2(dir, COMPETENCIES_FILE);
+  const path = join3(dir, COMPETENCIES_FILE);
   const empty = { name, dir, status: "unknown", lastTrained: null, areas: [], drifted: [] };
   if (!existsSync2(path))
     return { ...empty, error: `${COMPETENCIES_FILE} is missing` };
@@ -641,7 +647,7 @@ function str3(value) {
 // src/core/experts/expertDocument.ts
 var H2_RE = /^##\s+(.+?)\s*$/;
 function readExpertDocument(root, name) {
-  const path = join3(expertDir(root, name), EXPERT_FILE);
+  const path = join4(expertDir(root, name), EXPERT_FILE);
   if (!existsSync3(path)) {
     return { path, exists: false, frontMatter: new Map, body: "" };
   }
@@ -746,218 +752,6 @@ function pathsIntersect(a, b) {
 // src/core/experts/expertKnowledge.ts
 var DEFAULT_KNOWLEDGE_MAX_BYTES = 48 * 1024;
 
-// src/core/facilitator/paths.ts
-import { join as join4, relative, sep } from "node:path";
-
-// src/core/text/evidence.ts
-var EVIDENCE_VERSION = 1;
-var EVIDENCE_FILE = "evidence.md";
-var GATE_EVIDENCE_DIR = "gate-evidence";
-function gateEvidenceRelPath(phaseId, stageId) {
-  return `${phaseId}/${GATE_EVIDENCE_DIR}/${stageId}.md`;
-}
-var EVIDENCE_VERDICTS = ["sign", "sign-with-fixlist", "refuse"];
-var EVIDENCE_ROLES = ["agent"];
-var DIFF_VS_STORIES = ["matches", "diverges", "n-a"];
-var REQUIRED_EVIDENCE_KEYS = [
-  "version",
-  "gate",
-  "role",
-  "by",
-  "at",
-  "verdict",
-  "read",
-  "citations",
-  "touches",
-  "diff_vs_stories"
-];
-function parseEvidence(text) {
-  const parsed = parseFrontMatter(text);
-  const body = parseHandoff(parsed.frontMatter.body);
-  const bodyLine = parsed.frontMatter.bodyLine;
-  if (parsed.doc === null) {
-    return {
-      front: null,
-      frontIssues: [front(0, parsed.issue?.message ?? "front matter could not be read")],
-      body,
-      bodyLine
-    };
-  }
-  if (!isRecord2(parsed.doc)) {
-    return {
-      front: null,
-      frontIssues: [front(0, "front matter is empty — it must be a mapping of the keys design §A.5 names")],
-      body,
-      bodyLine
-    };
-  }
-  const issues = [];
-  const doc = parsed.doc;
-  for (const key of REQUIRED_EVIDENCE_KEYS) {
-    if (!(key in doc) || doc[key] === undefined) {
-      issues.push(front(0, `front matter is missing required key \`${key}\``));
-    }
-  }
-  const version = doc.version;
-  if (version !== undefined && version !== EVIDENCE_VERSION) {
-    issues.push(front(0, `\`version\` must be ${String(EVIDENCE_VERSION)}, got ${describe(version)}`));
-  }
-  const gate = requireText(doc.gate, "gate", issues);
-  const role = requireEnum2(doc.role, EVIDENCE_ROLES, "role", issues);
-  const by = requireText(doc.by, "by", issues);
-  const at = requireText(doc.at, "at", issues);
-  const verdict = requireEnum2(doc.verdict, EVIDENCE_VERDICTS, "verdict", issues);
-  const read = requireStrings(doc.read, "read", issues);
-  const citations = requireCitations(doc.citations, issues);
-  const touches = requireTouches(doc.touches, issues);
-  const diff = requireEnum2(doc.diff_vs_stories, DIFF_VS_STORIES, "diff_vs_stories", issues);
-  const caveats = doc.caveats === undefined ? [] : requireStrings(doc.caveats, "caveats", issues);
-  const recommend = requireRecommendations(doc.recommend, issues);
-  if (issues.length > 0)
-    return { front: null, frontIssues: issues, body, bodyLine };
-  return {
-    front: {
-      version: EVIDENCE_VERSION,
-      gate,
-      role,
-      by,
-      at,
-      verdict,
-      read,
-      citations,
-      touches,
-      diff_vs_stories: diff,
-      caveats,
-      recommend
-    },
-    frontIssues: [],
-    body,
-    bodyLine
-  };
-}
-var GUIDANCE = {
-  Read: "One bullet per file or artefact you opened, each ending with a `[src: …]` token for it.",
-  "Citations checked": "Which of this stage's citations you re-checked, and what each one turned out to be. " + "Sample honestly: `citations.sampled` above must match what is listed here.",
-  "Touches audited": "The touched paths you looked at, and every path outside the surface the What and the " + "stories declared. Name a new area rather than absorbing it.",
-  Verdict: "SIGN, SIGN-with-fixlist or REFUSE, and the measurement behind it — a command you ran, " + "a file you read. A verdict with no source is an opinion."
-};
-function front(line, message) {
-  return { kind: "front-matter", line, message };
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function requireText(value, key, issues) {
-  if (typeof value === "string" && value.trim() !== "")
-    return value.trim();
-  if (value !== undefined)
-    issues.push(front(0, `\`${key}\` must be a non-empty string, got ${describe(value)}`));
-  return "";
-}
-function requireEnum2(value, allowed, key, issues) {
-  if (typeof value === "string" && allowed.includes(value))
-    return value;
-  if (value !== undefined) {
-    issues.push(front(0, `\`${key}\` must be one of ${allowed.join(" | ")}, got ${describe(value)}`));
-  }
-  return allowed[0];
-}
-function requireStrings(value, key, issues) {
-  if (!Array.isArray(value)) {
-    if (value !== undefined)
-      issues.push(front(0, `\`${key}\` must be a list, got ${describe(value)}`));
-    return [];
-  }
-  const out = [];
-  for (const [i, entry] of value.entries()) {
-    if (typeof entry === "string")
-      out.push(entry);
-    else
-      issues.push(front(0, `\`${key}[${String(i)}]\` must be a string, got ${describe(entry)}`));
-  }
-  return out;
-}
-function requireCount(value, key, issues) {
-  if (typeof value === "number" && Number.isInteger(value) && value >= 0)
-    return value;
-  issues.push(front(0, `\`${key}\` must be a whole number of 0 or more, got ${describe(value)}`));
-  return 0;
-}
-function requireCitations(value, issues) {
-  if (!isRecord2(value)) {
-    if (value !== undefined) {
-      issues.push(front(0, "`citations` must be a mapping `{sampled, of, resolved, refuted}`, got " + describe(value)));
-    }
-    return { sampled: 0, of: 0, resolved: 0, refuted: 0 };
-  }
-  return {
-    sampled: requireCount(value.sampled, "citations.sampled", issues),
-    of: requireCount(value.of, "citations.of", issues),
-    resolved: requireCount(value.resolved, "citations.resolved", issues),
-    refuted: requireCount(value.refuted, "citations.refuted", issues)
-  };
-}
-function requireTouches(value, issues) {
-  if (!isRecord2(value)) {
-    if (value !== undefined) {
-      issues.push(front(0, "`touches` must be a mapping `{audited, outside_surface, new_areas}`, got " + describe(value)));
-    }
-    return { audited: 0, outside_surface: 0, new_areas: [] };
-  }
-  return {
-    audited: requireCount(value.audited, "touches.audited", issues),
-    outside_surface: requireCount(value.outside_surface, "touches.outside_surface", issues),
-    new_areas: requireStrings(value.new_areas, "touches.new_areas", issues)
-  };
-}
-function requireRecommendations(value, issues) {
-  if (value === undefined)
-    return [];
-  if (!Array.isArray(value)) {
-    issues.push(front(0, `\`recommend\` must be a list of {q, option, why, src}, got ${describe(value)}`));
-    return [];
-  }
-  const out = [];
-  for (const [i, entry] of value.entries()) {
-    if (!isRecord2(entry)) {
-      issues.push(front(0, `\`recommend[${String(i)}]\` must be a mapping {q, option, why, src}`));
-      continue;
-    }
-    const path = `recommend[${String(i)}]`;
-    for (const key of ["q", "option", "why", "src"]) {
-      if (!(key in entry))
-        issues.push(front(0, `\`${path}\` is missing \`${key}\``));
-    }
-    out.push({
-      q: requireText(entry.q, `${path}.q`, issues),
-      option: requireText(entry.option, `${path}.option`, issues),
-      why: requireText(entry.why, `${path}.why`, issues),
-      src: requireText(entry.src, `${path}.src`, issues)
-    });
-  }
-  return out;
-}
-function describe(value) {
-  if (value === null || value === undefined)
-    return "nothing";
-  if (Array.isArray(value))
-    return "a list";
-  if (typeof value === "object")
-    return "a mapping";
-  return typeof value === "string" ? `\`${value}\`` : String(value);
-}
-
-// src/core/facilitator/paths.ts
-function agentDir(runDir, stageId) {
-  return join4(runDir, ".agent", stageId);
-}
-function evidencePath(runDir, stageId) {
-  return join4(agentDir(runDir, stageId), EVIDENCE_FILE);
-}
-function gateEvidencePath(runDir, phaseId, stageId) {
-  return join4(runDir, ...gateEvidenceRelPath(phaseId, stageId).split("/"));
-}
-
 // src/core/facilitator/dispatchNotes.ts
 var DISPATCH_NOTES_MAX_BYTES = 8 * 1024;
 
@@ -1001,7 +795,10 @@ var KINDS = {
   fact: { shape: `\`F<nnn>\` (${readableSource(SRC_PATTERNS.fact)})`, example: "F102" },
   cmd: { shape: `\`$ <command> → exit <n>\` (${readableSource(SRC_PATTERNS.cmd)})`, example: "$ bun test → exit 0" },
   graph: { shape: "`graph:<node id>`", example: "graph:hunt-engine" },
-  absent: { shape: "`absent:<the path you looked at>`", example: "absent:docs/retention.md" },
+  absent: {
+    shape: "`absent:<the path you looked at>` — add `#<what you searched for>` to have it CHECKED",
+    example: "absent:docs/retention.md#retention"
+  },
   aidlc: {
     shape: `\`aidlc:<file>:<line>\` or \`aidlc:<file>#Q<n>\` (${readableSource(SRC_PATTERNS.aidlcLine)})`,
     example: "aidlc:intents/260821/design.md:14"
@@ -1461,344 +1258,6 @@ function wouldExceedHostTokens(budget, phaseId, spentTokens) {
   };
 }
 
-// src/core/run/gatePolicy.ts
-var GATE_POLICIES = ["human", "auto", "agent"];
-function isGatePolicy(value) {
-  return typeof value === "string" && GATE_POLICIES.includes(value);
-}
-function validateGatesPolicy(value, stageIds, issues) {
-  if (value === undefined || value === null)
-    return;
-  if (!isRecord(value)) {
-    issues.push({
-      path: "gates_policy",
-      message: `expected a mapping of stage id -> ${GATE_POLICIES.join(" | ")}`
-    });
-    return;
-  }
-  const known = new Set(stageIds);
-  for (const [key, raw] of Object.entries(value)) {
-    if (!isGatePolicy(raw)) {
-      issues.push({
-        path: `gates_policy.${key}`,
-        message: `expected one of ${GATE_POLICIES.join(" | ")}, got ${JSON.stringify(raw)}`
-      });
-    }
-    if (known.size > 0 && !known.has(key)) {
-      issues.push({ path: `gates_policy.${key}`, message: `names no stage in this run` });
-    }
-  }
-}
-
-// src/core/run/RunFile.ts
-var STAGE_STATUSES = [
-  "pending",
-  "ready",
-  "running",
-  "awaiting_answer",
-  "awaiting_gate",
-  "blocked",
-  "done",
-  "failed",
-  "skipped",
-  "cancelled"
-];
-var TERMINAL_STATUSES2 = ["done", "failed", "skipped", "cancelled"];
-var GATE_TYPES = ["approve", "checks", "auto"];
-var GATE_STATUSES = ["pending", "approved", "rejected", "n-a"];
-var ATTENDED_BY = ["host"];
-var RUN_ID_RE = /^\d{6}-[a-z0-9-]{1,40}$/;
-var PHASE_ID_RE = /^0[1-5]-[a-z]+$/;
-var MAX_PHASES2 = 5;
-var MAX_STAGES = 40;
-var MAX_TASKS = 200;
-function isTerminal2(status) {
-  return TERMINAL_STATUSES2.includes(status);
-}
-function isFinished(status) {
-  return status === "done" || status === "cancelled";
-}
-function isAttendedByHost(run) {
-  return run.attended_by === "host";
-}
-function flatten(run) {
-  const out = [];
-  for (const phase of run.phases)
-    for (const stage of phase.stages)
-      out.push({ phase, stage });
-  return out;
-}
-function stageAt(run, cursor) {
-  return flatten(run).find((e) => e.phase.id === cursor.phase && e.stage.id === cursor.stage) ?? null;
-}
-function deriveRunStatus(run) {
-  const all = flatten(run);
-  if (run.cancelled !== undefined)
-    return "cancelled";
-  if (all.some((e) => e.stage.status === "failed"))
-    return "failed";
-  if (all.length > 0 && all.every((e) => isTerminal2(e.stage.status)))
-    return "done";
-  return stageAt(run, run.cursor)?.stage.status ?? "pending";
-}
-function derivePhaseStatus(phase) {
-  if (phase.stages.length === 0)
-    return "skipped";
-  if (phase.stages.some((s) => s.status === "failed"))
-    return "failed";
-  if (phase.stages.every((s) => isTerminal2(s.status)))
-    return "done";
-  const live = phase.stages.find((s) => !isTerminal2(s.status));
-  return live?.status ?? "pending";
-}
-function validateRunFile(input) {
-  const issues = [];
-  const deprecations = [];
-  const doc = asDocument(input, issues);
-  if (!doc)
-    return result(issues);
-  requireVersion(doc, issues, deprecations);
-  requireKeys(doc, ["run", "title", "scope", "workflow", "repos", "created_at", "updated_at", "status", "cursor", "budget", "phases"], "", issues);
-  if (typeof doc.run !== "string" || !RUN_ID_RE.test(doc.run)) {
-    issues.push({ path: "run", message: "run id must match ^\\d{6}-[a-z0-9-]{1,40}$" });
-  }
-  requireString(doc.title, "title", issues);
-  requireString(doc.scope, "scope", issues);
-  requireString(doc.workflow, "workflow", issues);
-  requireString(doc.created_at, "created_at", issues);
-  requireString(doc.updated_at, "updated_at", issues);
-  requireEnum(doc.status, STAGE_STATUSES, "status", issues);
-  requireArray(doc.repos, "repos", issues);
-  let cursor = null;
-  if (isRecord(doc.cursor)) {
-    requireKeys(doc.cursor, ["phase", "stage", "task"], "cursor", issues);
-    cursor = {
-      phase: String(doc.cursor.phase ?? ""),
-      stage: String(doc.cursor.stage ?? ""),
-      task: typeof doc.cursor.task === "string" ? doc.cursor.task : null
-    };
-  } else if (doc.cursor !== undefined) {
-    issues.push({ path: "cursor", message: "expected a mapping" });
-  }
-  if (isRecord(doc.budget)) {
-    requireKeys(doc.budget, ["ceiling_usd", "spent_usd", "per_agent_max_usd"], "budget", issues);
-    requireNumber(doc.budget.ceiling_usd, "budget.ceiling_usd", issues);
-    requireNumber(doc.budget.spent_usd, "budget.spent_usd", issues);
-    requireNumber(doc.budget.per_agent_max_usd, "budget.per_agent_max_usd", issues);
-  } else if (doc.budget !== undefined) {
-    issues.push({ path: "budget", message: "expected a mapping" });
-  }
-  if (doc.build !== undefined) {
-    if (isRecord(doc.build)) {
-      requireKeys(doc.build, ["epic_branch"], "build", issues);
-      if (requireArray(doc.build.epic_branch, "build.epic_branch", issues)) {
-        doc.build.epic_branch.forEach((branch, i) => {
-          requireString(branch, `build.epic_branch[${i}]`, issues);
-        });
-      }
-      if (doc.build.branch_model !== undefined && !isBranchModelKind(doc.build.branch_model)) {
-        issues.push({
-          path: "build.branch_model",
-          message: `expected one of ${BRANCH_MODELS.join(" | ")}`
-        });
-      }
-    } else {
-      issues.push({ path: "build", message: "expected a mapping" });
-    }
-  }
-  if (doc.cancelled !== undefined) {
-    if (isRecord(doc.cancelled)) {
-      requireKeys(doc.cancelled, ["by", "at", "note"], "cancelled", issues);
-      requireString(doc.cancelled.by, "cancelled.by", issues);
-      requireString(doc.cancelled.at, "cancelled.at", issues);
-      requireString(doc.cancelled.note, "cancelled.note", issues);
-    } else {
-      issues.push({ path: "cancelled", message: "expected a mapping" });
-    }
-  }
-  if (doc.triage !== undefined) {
-    if (isRecord(doc.triage)) {
-      requireKeys(doc.triage, ["split", "depends_on"], "triage", issues);
-      requireString(doc.triage.split, "triage.split", issues);
-      if (requireArray(doc.triage.depends_on, "triage.depends_on", issues)) {
-        doc.triage.depends_on.forEach((slug, i) => {
-          requireString(slug, `triage.depends_on[${i}]`, issues);
-        });
-      }
-    } else {
-      issues.push({ path: "triage", message: "expected a mapping" });
-    }
-  }
-  if (doc.attended_by !== undefined)
-    requireEnum(doc.attended_by, ATTENDED_BY, "attended_by", issues);
-  if (doc.keep_worktrees !== undefined && typeof doc.keep_worktrees !== "boolean") {
-    issues.push({ path: "keep_worktrees", message: `expected a boolean, got ${typeof doc.keep_worktrees}` });
-  }
-  if (!requireArray(doc.phases, "phases", issues))
-    return result(issues, deprecations);
-  const phases = doc.phases;
-  if (phases.length > MAX_PHASES2) {
-    issues.push({ path: "phases", message: `${phases.length} phases exceeds the ${MAX_PHASES2} cap` });
-  }
-  const declaredStageIds = [];
-  for (const phase of phases) {
-    if (!isRecord(phase) || !Array.isArray(phase.stages))
-      continue;
-    for (const stage of phase.stages) {
-      if (isRecord(stage) && typeof stage.id === "string")
-        declaredStageIds.push(stage.id);
-    }
-  }
-  validateGatesPolicy(doc.gates_policy, declaredStageIds, issues);
-  let stageCount = 0;
-  let taskCount = 0;
-  let running = 0;
-  let cursorResolves = false;
-  let spentFromTasks = 0;
-  const phaseIds = new Set;
-  phases.forEach((phase, i) => {
-    const base = `phases[${i}]`;
-    if (!isRecord(phase)) {
-      issues.push({ path: base, message: "expected a mapping" });
-      return;
-    }
-    requireKeys(phase, ["id", "status", "stages"], base, issues);
-    const phaseId = typeof phase.id === "string" ? phase.id : "";
-    if (!PHASE_ID_RE.test(phaseId)) {
-      issues.push({ path: `${base}.id`, message: "phase id must match ^0[1-5]-[a-z]+$" });
-    }
-    if (phaseIds.has(phaseId))
-      issues.push({ path: `${base}.id`, message: `duplicate phase id ${phaseId}` });
-    phaseIds.add(phaseId);
-    requireEnum(phase.status, STAGE_STATUSES, `${base}.status`, issues);
-    if (!requireArray(phase.stages, `${base}.stages`, issues))
-      return;
-    const stageIds = new Set;
-    phase.stages.forEach((stage, j) => {
-      const path = `${base}.stages[${j}]`;
-      stageCount++;
-      if (!isRecord(stage)) {
-        issues.push({ path, message: "expected a mapping" });
-        return;
-      }
-      requireKeys(stage, ["id", "status", "expert", "model", "budget_usd", "cost_usd", "started_at", "ended_at", "inputs", "outputs", "gate", "tasks"], path, issues);
-      const stageId = typeof stage.id === "string" ? stage.id : "";
-      if (stageIds.has(stageId))
-        issues.push({ path: `${path}.id`, message: `duplicate stage id ${stageId}` });
-      stageIds.add(stageId);
-      requireEnum(stage.status, STAGE_STATUSES, `${path}.status`, issues);
-      if (stage.status === "running")
-        running++;
-      requireNumber(stage.budget_usd, `${path}.budget_usd`, issues);
-      requireNumber(stage.cost_usd, `${path}.cost_usd`, issues);
-      requireArray(stage.inputs, `${path}.inputs`, issues);
-      requireArray(stage.outputs, `${path}.outputs`, issues);
-      if (stage.stale !== undefined && typeof stage.stale !== "boolean") {
-        issues.push({ path: `${path}.stale`, message: "expected true or false" });
-      }
-      checkOrder(stage.started_at, stage.ended_at, path, issues);
-      if (cursor !== null && cursor.phase === phaseId && cursor.stage === stageId)
-        cursorResolves = true;
-      if (isRecord(stage.gate)) {
-        const gate = stage.gate;
-        requireKeys(gate, ["type", "status", "by", "at", "note"], `${path}.gate`, issues);
-        requireEnum(gate.type, GATE_TYPES, `${path}.gate.type`, issues);
-        requireEnum(gate.status, GATE_STATUSES, `${path}.gate.status`, issues);
-        if (gate.status === "approved" && (typeof gate.by !== "string" || typeof gate.at !== "string")) {
-          issues.push({ path: `${path}.gate`, message: "an approved gate needs both `by` and `at`" });
-        }
-        validateGateEvidence(gate.evidence, `${path}.gate.evidence`, issues);
-      } else if (stage.gate !== undefined) {
-        issues.push({ path: `${path}.gate`, message: "expected a mapping" });
-      }
-      if (requireArray(stage.tasks, `${path}.tasks`, issues)) {
-        const taskIds = new Set;
-        stage.tasks.forEach((task, k) => {
-          const tp = `${path}.tasks[${k}]`;
-          taskCount++;
-          if (!isRecord(task)) {
-            issues.push({ path: tp, message: "expected a mapping" });
-            return;
-          }
-          requireKeys(task, ["id", "status", "cost_usd", "error", "session_id"], tp, issues);
-          const taskId = typeof task.id === "string" ? task.id : "";
-          if (!/^t\d+$/.test(taskId))
-            issues.push({ path: `${tp}.id`, message: "task id must match ^t\\d+$" });
-          if (taskIds.has(taskId))
-            issues.push({ path: `${tp}.id`, message: `duplicate task id ${taskId}` });
-          taskIds.add(taskId);
-          requireEnum(task.status, STAGE_STATUSES, `${tp}.status`, issues);
-          if (task.cost_usd !== null)
-            requireNumber(task.cost_usd, `${tp}.cost_usd`, issues);
-          if (task.metered !== undefined && typeof task.metered !== "boolean") {
-            issues.push({ path: `${tp}.metered`, message: "expected true or false" });
-          }
-          if (task.cost_usd === null && task.metered !== false) {
-            issues.push({ path: `${tp}.metered`, message: "a null cost_usd must be marked `metered: false`" });
-          }
-          if (typeof task.cost_usd === "number")
-            spentFromTasks += task.cost_usd;
-          checkOrder(task.started_at, task.ended_at, tp, issues);
-        });
-      }
-    });
-  });
-  if (stageCount > MAX_STAGES)
-    issues.push({ path: "phases", message: `${stageCount} stages exceeds the ${MAX_STAGES} cap` });
-  if (taskCount > MAX_TASKS)
-    issues.push({ path: "phases", message: `${taskCount} tasks exceeds the ${MAX_TASKS} cap` });
-  if (running > 1)
-    issues.push({ path: "phases", message: `${running} stages are running; tldrx is single-writer` });
-  if (cursor !== null && !cursorResolves) {
-    issues.push({ path: "cursor", message: `cursor ${cursor.phase}/${cursor.stage} does not resolve to a stage` });
-  }
-  if (isRecord(doc.budget) && typeof doc.budget.spent_usd === "number") {
-    if (Math.abs(doc.budget.spent_usd - spentFromTasks) > 0.01) {
-      issues.push({
-        path: "budget.spent_usd",
-        message: `${doc.budget.spent_usd} does not match the task total ${round5(spentFromTasks)} (tolerance 0.01)`
-      });
-    }
-  }
-  return result(issues, deprecations);
-}
-function checkOrder(started, ended, path, issues) {
-  if (typeof started === "string" && typeof ended === "string" && ended < started) {
-    issues.push({ path: `${path}.ended_at`, message: "ended_at is before started_at" });
-  }
-}
-function round5(n) {
-  return Math.round(n * 100) / 100;
-}
-function asRunFile(input) {
-  return input;
-}
-var GATE_EVIDENCE_KEYS = [
-  "path",
-  "role",
-  "verdict",
-  "sampled",
-  "of",
-  "resolved",
-  "refuted",
-  "outside_surface"
-];
-function validateGateEvidence(value, base, issues) {
-  if (value === undefined || value === null)
-    return;
-  if (!isRecord(value)) {
-    issues.push({ path: base, message: "expected a mapping" });
-    return;
-  }
-  requireKeys(value, GATE_EVIDENCE_KEYS, base, issues);
-  requireString(value.path, `${base}.path`, issues);
-  requireEnum(value.role, EVIDENCE_ROLES, `${base}.role`, issues);
-  requireEnum(value.verdict, EVIDENCE_VERDICTS, `${base}.verdict`, issues);
-  for (const key of ["sampled", "of", "resolved", "refuted", "outside_surface"]) {
-    requireNumber(value[key], `${base}.${key}`, issues);
-  }
-}
-
 // src/core/budget/budgetView.ts
 function raiseCommand(runId, phaseId, amountUsd) {
   return `tldrx budget raise ${phaseId} ${amountUsd.toFixed(2)} --run ${runId}`;
@@ -1807,4 +1266,4 @@ function shortBy(estimate, remaining) {
   return Math.max(0.01, Math.ceil((estimate - remaining) * 100) / 100);
 }
 
-export { loadRunView, isAttendedByHostView, runSpend, hostTokensIn, renderRunEconomies, cursorStage, openRunViews, newestActiveRun, currentActor, nowRfc3339, DEFAULT_ON_HOST_TOKENS_EXCEED, DEFAULT_ECONOMY, economyFor, isHostTokens, validateRunBudget, asRunBudget, expertsDir, loadExperts, readExpertDomain, pathsIntersect, parseEvidence, evidencePath, gateEvidencePath, stackExpertNames, remainingWork, wouldExceed, wouldExceedHostTokens, isTerminal2 as isTerminal, isFinished, isAttendedByHost, flatten, stageAt, deriveRunStatus, derivePhaseStatus, validateRunFile, asRunFile, raiseCommand, shortBy };
+export { loadRunView, isAttendedByHostView, runSpend, hostTokensIn, renderRunEconomies, cursorStage, openRunViews, newestActiveRun, currentActor, nowRfc3339, DEFAULT_ON_HOST_TOKENS_EXCEED, DEFAULT_ECONOMY, economyFor, isHostTokens, validateRunBudget, asRunBudget, evidencePath, gateEvidencePath, expertsDir, loadExperts, readExpertDomain, pathsIntersect, stackExpertNames, remainingWork, wouldExceed, wouldExceedHostTokens, raiseCommand, shortBy };

package/dist/hooks/{chunk-nadqsr3w.js → chunk-97ncnegd.js}

@@ -1,6 +1,6 @@
 import {
   parseSrcToken
-} from "./chunk-a6rpj2cp.js";
+} from "./chunk-9w64mxdh.js";
 
 // src/core/text/questions.ts
 var REQUIRED_METADATA_KEYS = ["id", "status", "area", "asked_by", "asked_at"];