tldr-experts 0.3.0

package/dist/hooks/chunk-y0jdr3et.js

@@ -0,0 +1,627 @@
+import {
+  asRunBudget,
+  asRunFile,
+  cursorStage,
+  derivePhaseStatus,
+  deriveRunStatus,
+  flatten,
+  isFinished,
+  isTerminal,
+  nowRfc3339,
+  openRunViews,
+  stageAt,
+  validateRunBudget,
+  validateRunFile
+} from "./chunk-sdjnnmzz.js";
+import {
+  EventLog
+} from "./chunk-azctppjh.js";
+import {
+  isAlive,
+  openBlocks,
+  parseQuestions,
+  readLock,
+  withWorkspaceLock,
+  workspaceRootOfRunDir,
+  yamlScalar
+} from "./chunk-j234zf0t.js";
+import {
+  noteDeprecations
+} from "./chunk-t56k6146.js";
+import {
+  listRunDirs,
+  parseYaml
+} from "./chunk-p274ckxv.js";
+
+// src/core/statusline/runSnapshot.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/core/run/RunStore.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+// src/core/run/emitRunYaml.ts
+function inlineList(values) {
+  return `[${values.map((v) => yamlScalar(v)).join(", ")}]`;
+}
+function money(n) {
+  return n.toFixed(2);
+}
+function gatesPolicy(policy) {
+  const entries = Object.entries(policy).map(([id, value]) => `${yamlScalar(id)}: ${yamlScalar(value)}`);
+  return `{${entries.join(", ")}}`;
+}
+function gate(g) {
+  return `{type: ${yamlScalar(g.type)}, status: ${yamlScalar(g.status)}, by: ${yamlScalar(g.by)}, ` + `at: ${yamlScalar(g.at)}, note: ${yamlScalar(g.note)}}`;
+}
+function task(t, indent) {
+  const inner = `${indent}   `;
+  const cost = t.cost_usd === null ? "null" : money(t.cost_usd);
+  const metered = t.metered === false ? ", metered: false" : "";
+  const tokens = t.tokens === undefined ? "" : `, tokens: ${String(t.tokens)}`;
+  return [
+    `${indent} - {id: ${yamlScalar(t.id)}, status: ${yamlScalar(t.status)}, expert: ${yamlScalar(t.expert)}, ` + `model: ${yamlScalar(t.model)}, cost_usd: ${cost}${metered}${tokens},`,
+    `${inner}error: ${yamlScalar(t.error)}, session_id: ${yamlScalar(t.session_id)},`,
+    `${inner}started_at: ${yamlScalar(t.started_at)}, ended_at: ${yamlScalar(t.ended_at)},`,
+    ...t.stopped_by === undefined || t.stopped_by === null ? [] : [`${inner}stopped_by: ${yamlScalar(t.stopped_by)},`],
+    `${inner}outputs: ${inlineList(t.outputs)}}`
+  ].join(`
+`);
+}
+function stage(s) {
+  const lines = [
+    `      - id: ${yamlScalar(s.id)}`,
+    `        status: ${yamlScalar(s.status)}`,
+    `        expert: ${yamlScalar(s.expert)}`,
+    `        model: ${yamlScalar(s.model)}`,
+    `        budget_usd: ${money(s.budget_usd)}`,
+    `        cost_usd: ${money(s.cost_usd)}`,
+    `        started_at: ${yamlScalar(s.started_at)}`,
+    `        ended_at: ${yamlScalar(s.ended_at)}`,
+    `        inputs: ${inlineList(s.inputs)}`,
+    `        outputs: ${inlineList(s.outputs)}`,
+    `        gate: ${gate(s.gate)}`
+  ];
+  if (s.stale === true)
+    lines.push("        stale: true");
+  if (s.tasks.length === 0) {
+    lines.push("        tasks: []");
+  } else {
+    lines.push("        tasks:");
+    for (const t of s.tasks)
+      lines.push(task(t, "       "));
+  }
+  return lines.join(`
+`);
+}
+function emitRunYaml(run) {
+  const lines = [
+    "# tldrx-work/<run>/run.yml — the execution path and the only resume point (spec §2.2).",
+    "# Written by the facilitator alone. Hand-edit at your own risk: every write revalidates.",
+    `version: ${run.version}`,
+    `run: ${yamlScalar(run.run)}`,
+    `title: ${yamlScalar(run.title)}`,
+    `scope: ${yamlScalar(run.scope)}`,
+    `workflow: ${yamlScalar(run.workflow)}`,
+    `repos: ${inlineList(run.repos)}`,
+    `created_at: ${yamlScalar(run.created_at)}`,
+    `updated_at: ${yamlScalar(run.updated_at)}`,
+    `status: ${yamlScalar(run.status)}`,
+    `cursor: {phase: ${yamlScalar(run.cursor.phase)}, stage: ${yamlScalar(run.cursor.stage)}, ` + `task: ${yamlScalar(run.cursor.task)}}`,
+    `budget: {ceiling_usd: ${money(run.budget.ceiling_usd)}, spent_usd: ${money(run.budget.spent_usd)}, ` + `per_agent_max_usd: ${money(run.budget.per_agent_max_usd)}}`
+  ];
+  if (run.triage !== undefined) {
+    lines.push(`triage: {split: ${yamlScalar(run.triage.split)}, depends_on: ${inlineList(run.triage.depends_on)}}`);
+  }
+  if (run.build !== undefined && run.build.epic_branch.length > 0) {
+    lines.push(`build: {epic_branch: ${inlineList(run.build.epic_branch)}}`);
+  }
+  if (run.cancelled !== undefined) {
+    lines.push(`cancelled: {by: ${yamlScalar(run.cancelled.by)}, at: ${yamlScalar(run.cancelled.at)}, ` + `note: ${yamlScalar(run.cancelled.note)}}`);
+  }
+  if (run.gates_policy !== undefined && Object.keys(run.gates_policy).length > 0) {
+    lines.push(`gates_policy: ${gatesPolicy(run.gates_policy)}`);
+  }
+  lines.push("phases:");
+  for (const phase of run.phases) {
+    lines.push(`  - id: ${yamlScalar(phase.id)}`);
+    lines.push(`    status: ${yamlScalar(phase.status)}`);
+    if (phase.stages.length === 0) {
+      lines.push("    stages: []");
+    } else {
+      lines.push("    stages:");
+      for (const s of phase.stages)
+        lines.push(stage(s));
+    }
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function emitBudgetYaml(budget) {
+  const lines = [
+    "# tldrx-work/<run>/budget.yml — the ceiling the facilitator refuses to exceed (spec §2.11).",
+    "# Actuals are rolled up from run.yml task costs; never typed by hand.",
+    `version: ${budget.version}`,
+    `run: ${yamlScalar(budget.run)}`,
+    `ceiling_usd: ${money(budget.ceiling_usd)}`,
+    `per_agent_max_usd: ${money(budget.per_agent_max_usd)}`,
+    `warn_at_pct: ${budget.warn_at_pct}`,
+    `on_exceed: ${yamlScalar(budget.on_exceed)}`,
+    "phases:"
+  ];
+  for (const phase of budget.phases) {
+    lines.push(`  - {id: ${yamlScalar(phase.id)}, ceiling_usd: ${money(phase.ceiling_usd)}, ` + `spent_usd: ${money(phase.spent_usd)}}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+
+// src/core/run/RunStore.ts
+class RunStoreError extends Error {
+}
+
+class RunStore {
+  runDir;
+  events;
+  current;
+  currentBudget;
+  budgetMutated = false;
+  constructor(runDir, run, budget, events) {
+    this.runDir = runDir;
+    this.events = events;
+    this.current = run;
+    this.currentBudget = budget;
+  }
+  static open(runDir) {
+    const runPath = join(runDir, "run.yml");
+    if (!existsSync(runPath))
+      throw new RunStoreError(`no run.yml in ${runDir}`);
+    const doc = parseYaml(readFileSync(runPath, "utf8"));
+    const validation = validateRunFile(doc);
+    noteDeprecations(runPath, validation);
+    if (!validation.ok) {
+      const first = validation.issues[0];
+      throw new RunStoreError(`invalid run.yml (${runPath}): ${first?.path ?? ""} ${first?.message ?? "schema error"}`);
+    }
+    const budgetPath = join(runDir, "budget.yml");
+    if (!existsSync(budgetPath))
+      throw new RunStoreError(`no budget.yml in ${runDir}`);
+    const budgetDoc = parseYaml(readFileSync(budgetPath, "utf8"));
+    const budgetValidation = validateRunBudget(budgetDoc);
+    noteDeprecations(budgetPath, budgetValidation);
+    if (!budgetValidation.ok) {
+      const first = budgetValidation.issues[0];
+      throw new RunStoreError(`invalid budget.yml (${budgetPath}): ${first?.path ?? ""} ${first?.message ?? "schema error"}`);
+    }
+    return new RunStore(runDir, asRunFile(doc), asRunBudget(budgetDoc), EventLog.forRun(runDir));
+  }
+  static find(root, runId) {
+    const dir = listRunDirs(root).find((d) => basename(d) === runId);
+    if (dir === undefined)
+      return null;
+    return RunStore.open(dir);
+  }
+  static findOpen(root) {
+    const open = [];
+    for (const dir of listRunDirs(root)) {
+      let store;
+      try {
+        store = RunStore.open(dir);
+      } catch {
+        continue;
+      }
+      if (isFinished(store.run.status))
+        continue;
+      open.push(store);
+    }
+    return open.sort((a, b) => compareDesc(a.run.updated_at, b.run.updated_at));
+  }
+  static resolve(root, runId) {
+    if (runId !== undefined && runId !== "") {
+      const store = RunStore.find(root, runId);
+      return store === null ? { kind: "none" } : { kind: "one", store };
+    }
+    const open = RunStore.findOpen(root);
+    const only = open[0];
+    if (only === undefined)
+      return { kind: "none" };
+    if (open.length === 1)
+      return { kind: "one", store: only };
+    return { kind: "ambiguous", open };
+  }
+  get run() {
+    return this.current;
+  }
+  get budget() {
+    return this.currentBudget;
+  }
+  get runId() {
+    return this.current.run;
+  }
+  cursorEntry() {
+    return stageAt(this.current, this.current.cursor);
+  }
+  nextEntry() {
+    const all = flatten(this.current);
+    const at = all.findIndex((e) => e.phase.id === this.current.cursor.phase && e.stage.id === this.current.cursor.stage);
+    if (at === -1)
+      return null;
+    return all[at + 1] ?? null;
+  }
+  mutate(fn) {
+    this.current = fn(structuredClone(this.current));
+  }
+  mutateBudget(fn) {
+    this.currentBudget = fn(structuredClone(this.currentBudget));
+    this.budgetMutated = true;
+  }
+  append(event) {
+    this.events.append(event);
+  }
+  save() {
+    const rolled = rollUp(this.current);
+    const runValidation = validateRunFile(rolled);
+    if (!runValidation.ok) {
+      const first = runValidation.issues[0];
+      throw new RunStoreError(`refusing to write an invalid run.yml: ${first?.path ?? ""} ${first?.message ?? ""}`);
+    }
+    withWorkspaceLock(workspaceRootOfRunDir(this.runDir), () => {
+      const budget = rollUpBudget(this.ceilingsToWrite(), rolled);
+      const budgetValidation = validateRunBudget(budget);
+      if (!budgetValidation.ok) {
+        const first = budgetValidation.issues[0];
+        throw new RunStoreError(`refusing to write an invalid budget.yml: ${first?.path ?? ""} ${first?.message ?? ""}`);
+      }
+      writeAtomic(join(this.runDir, "budget.yml"), emitBudgetYaml(budget));
+      writeAtomic(join(this.runDir, "run.yml"), emitRunYaml(rolled));
+      this.current = rolled;
+      this.currentBudget = budget;
+      this.budgetMutated = false;
+    });
+  }
+  ceilingsToWrite() {
+    if (this.budgetMutated)
+      return this.currentBudget;
+    const path = join(this.runDir, "budget.yml");
+    if (!existsSync(path))
+      return this.currentBudget;
+    try {
+      const doc = parseYaml(readFileSync(path, "utf8"));
+      const validation = validateRunBudget(doc);
+      if (!validation.ok)
+        return this.currentBudget;
+      const onDisk = asRunBudget(doc);
+      return {
+        ...onDisk,
+        phases: this.currentBudget.phases.map((mine) => {
+          const theirs = onDisk.phases.find((p) => p.id === mine.id);
+          return theirs === undefined ? mine : { ...mine, ceiling_usd: theirs.ceiling_usd };
+        })
+      };
+    } catch {
+      return this.currentBudget;
+    }
+  }
+}
+function writeAtomic(path, content) {
+  const temp = `${path}.tmp-${String(process.pid)}`;
+  mkdirSync(dirname(path), { recursive: true });
+  try {
+    writeFileSync(temp, content, "utf8");
+    renameSync(temp, path);
+  } catch (error) {
+    try {
+      if (existsSync(temp))
+        rmSync(temp, { force: true });
+    } catch {}
+    throw error;
+  }
+}
+function rollUp(run) {
+  const phases = run.phases.map((phase) => {
+    const stages = phase.stages.map((stage2) => ({
+      ...stage2,
+      cost_usd: round(stage2.tasks.reduce((sum, t) => sum + (t.cost_usd ?? 0), 0))
+    }));
+    const withStages = { ...phase, stages, status: "pending" };
+    return { ...withStages, status: derivePhaseStatus(withStages) };
+  });
+  const spent = round(phases.reduce((sum, p) => sum + p.stages.reduce((s, st) => s + st.cost_usd, 0), 0));
+  const next = {
+    ...run,
+    phases,
+    budget: { ...run.budget, spent_usd: spent },
+    updated_at: nowRfc3339()
+  };
+  return { ...next, status: deriveRunStatus(next) };
+}
+function rollUpBudget(budget, run) {
+  const spentByPhase = new Map;
+  for (const phase of run.phases) {
+    spentByPhase.set(phase.id, round(phase.stages.reduce((sum, s) => sum + s.cost_usd, 0)));
+  }
+  return {
+    ...budget,
+    phases: budget.phases.map((p) => ({ ...p, spent_usd: spentByPhase.get(p.id) ?? p.spent_usd }))
+  };
+}
+function compareDesc(a, b) {
+  if (a > b)
+    return -1;
+  return a < b ? 1 : 0;
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+
+// src/core/facilitator/skipIf.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+function phaseDirs(runDir) {
+  try {
+    return readdirSync(runDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^0[1-9]-/.test(entry.name)).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+function openQuestionIds(path) {
+  if (!existsSync2(path))
+    return [];
+  try {
+    return openBlocks(parseQuestions(readFileSync2(path, "utf8")).blocks).map((block) => block.id);
+  } catch {
+    return [];
+  }
+}
+
+// src/core/statusline/runSnapshot.ts
+var AUTO = "auto";
+function runSnapshot(root) {
+  return fromStore(root) ?? fromTolerantRead(root);
+}
+function openQuestions(snapshot) {
+  const ids = [];
+  for (const phase of phaseDirs(snapshot.runDir)) {
+    ids.push(...openQuestionIds(join2(snapshot.runDir, phase, "questions.md")));
+  }
+  return ids;
+}
+function fromStore(root) {
+  let open;
+  try {
+    open = RunStore.findOpen(root);
+  } catch {
+    return null;
+  }
+  const store = open[0];
+  if (store === undefined)
+    return null;
+  const run = store.run;
+  const entry = store.cursorEntry();
+  const stages = run.phases.flatMap((phase) => phase.stages);
+  return {
+    runDir: store.runDir,
+    run: run.run,
+    title: run.title,
+    scope: run.scope,
+    status: run.status,
+    phase: run.cursor.phase,
+    stage: run.cursor.stage,
+    stageStatus: entry?.stage.status ?? run.status,
+    expert: entry?.stage.expert ?? null,
+    done: stages.filter((stage2) => isTerminal(stage2.status)).length,
+    total: stages.length,
+    ceilingUsd: run.budget.ceiling_usd,
+    spentUsd: run.budget.spent_usd,
+    openCount: open.length,
+    autoGates: stages.filter((s) => s.gate.status === "approved" && s.gate.by === AUTO).length,
+    staleStages: stages.filter((s) => s.stale === true).length,
+    source: "run-store"
+  };
+}
+function fromTolerantRead(root) {
+  const open = openRunViews(root);
+  const view = open[0];
+  if (view === undefined)
+    return null;
+  const stage2 = cursorStage(view);
+  const stages = view.phases.flatMap((phase) => phase.stages);
+  const budget = readBudgetMirror(view.dir);
+  return {
+    runDir: view.dir,
+    run: view.run,
+    title: view.title,
+    scope: view.scope,
+    status: view.status,
+    phase: view.cursor?.phase ?? "",
+    stage: view.cursor?.stage ?? "",
+    stageStatus: stage2?.status === undefined || stage2.status === "" ? view.status : stage2.status,
+    expert: stage2?.expert ?? null,
+    done: stages.filter((s) => isTerminal(s.status)).length,
+    total: stages.length,
+    ceilingUsd: budget.ceiling_usd,
+    spentUsd: budget.spent_usd,
+    openCount: open.length,
+    autoGates: 0,
+    staleStages: 0,
+    source: "tolerant"
+  };
+}
+function readBudgetMirror(runDir) {
+  const path = join2(runDir, "run.yml");
+  if (!existsSync3(path))
+    return { ceiling_usd: 0, spent_usd: 0 };
+  try {
+    const text = readFileSync3(path, "utf8");
+    return {
+      ceiling_usd: numberAfter(text, "ceiling_usd"),
+      spent_usd: numberAfter(text, "spent_usd")
+    };
+  } catch {
+    return { ceiling_usd: 0, spent_usd: 0 };
+  }
+}
+function numberAfter(text, key) {
+  const match = new RegExp(`${key}:\\s*([0-9]+(?:\\.[0-9]+)?)`).exec(text);
+  return match === null ? 0 : Number(match[1]);
+}
+
+// src/core/run/waiting.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { basename as basename2, join as join4 } from "node:path";
+
+// src/core/run/prepared.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+var PENDING_JSON = "pending.json";
+function preparedBundles(runDir, stageId) {
+  const dir = join3(runDir, ".agent", stageId);
+  if (!existsSync4(dir))
+    return [];
+  const found = [];
+  if (existsSync4(join3(dir, PENDING_JSON)))
+    found.push(dir);
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return found;
+  }
+  for (const entry of entries) {
+    const child = join3(dir, entry);
+    try {
+      if (!statSync(child).isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    if (existsSync4(join3(child, PENDING_JSON)))
+      found.push(child);
+  }
+  return found;
+}
+function hasPreparedBundle(runDir, stageId) {
+  return preparedBundles(runDir, stageId).length > 0;
+}
+
+// src/core/run/waiting.ts
+var MOVABLE_KINDS = ["gate", "answer", "ready", "failed", "prepared"];
+function isMovable(kind) {
+  return MOVABLE_KINDS.includes(kind);
+}
+function failureReason(stage2) {
+  const error = [...stage2.tasks].reverse().find((task2) => task2.error !== null)?.error ?? null;
+  return error === null || error.trim() === "" ? null : oneLine(error);
+}
+function oneLine(text) {
+  return text.split(`
+`)[0]?.trim() ?? "";
+}
+function stageAtCursor(run, cursor) {
+  for (const phase of run.phases) {
+    for (const stage2 of phase.stages) {
+      if (phase.id === cursor.phase && stage2.id === cursor.stage)
+        return { phase, stage: stage2 };
+    }
+  }
+  return null;
+}
+function waitingFor(run, runDir) {
+  const cursor = run.cursor;
+  if (cursor === null) {
+    return { kind: "blocked", message: "run.yml records no cursor, so nothing can say where it is", questions: [] };
+  }
+  const entry = stageAtCursor(run, cursor);
+  if (entry === null) {
+    return {
+      kind: "blocked",
+      message: `cursor ${cursor.phase}/${cursor.stage} does not resolve to a stage`,
+      questions: []
+    };
+  }
+  const open = openQuestionIds2(join4(runDir, cursor.phase, "questions.md"));
+  switch (entry.stage.status) {
+    case "awaiting_gate":
+      return {
+        kind: "gate",
+        message: `gate on ${entry.phase.id}/${entry.stage.id} — \`tldrx approve\` or \`tldrx reject --note "…"\``,
+        questions: open
+      };
+    case "awaiting_answer":
+      return {
+        kind: "answer",
+        message: open.length === 0 ? `stage ${entry.stage.id} is waiting on an answer, but ${cursor.phase}/questions.md has no open block` : `${open.length} open question(s) in ${cursor.phase}/questions.md — \`tldrx answer ${open[0] ?? "Q1"} "…"\``,
+        questions: open
+      };
+    case "failed": {
+      const reason = failureReason(entry.stage);
+      return {
+        kind: "failed",
+        message: `${entry.phase.id}/${entry.stage.id} FAILED${reason === null ? "" : `: ${reason}`} — ` + 'retry: `tldrx next` · or: `tldrx reject --note "…"`',
+        questions: open
+      };
+    }
+    case "running": {
+      const holder = readLock(runDir);
+      if (holder !== null && isAlive(holder.pid)) {
+        return {
+          kind: "running",
+          message: `stage is running (pid ${String(holder.pid)}) — wait, or ` + `\`tldrx run unlock ${basename2(runDir)}\` if it died`,
+          questions: open
+        };
+      }
+      if (hasPreparedBundle(runDir, entry.stage.id)) {
+        return {
+          kind: "prepared",
+          message: "a --prepare bundle is waiting — run the prompt and " + `\`tldrx next --commit ${basename2(runDir)}\`, or ` + `\`tldrx reject --run ${basename2(runDir)} --note …\` to discard`,
+          questions: open
+        };
+      }
+      return {
+        kind: "ready",
+        message: `next up: ${entry.phase.id}/${entry.stage.id} (running, but nothing holds it) — \`tldrx next\``,
+        questions: open
+      };
+    }
+    case "done":
+    case "skipped":
+    case "cancelled":
+      return { kind: "done", message: "every stage is terminal — nothing is waiting", questions: open };
+    case "blocked":
+      return { kind: "blocked", message: `stage ${entry.stage.id} is blocked`, questions: open };
+    default:
+      return {
+        kind: "ready",
+        message: `next up: ${entry.phase.id}/${entry.stage.id} (${entry.stage.status}) — \`tldrx next\``,
+        questions: open
+      };
+  }
+}
+function openQuestionIds2(path) {
+  if (!existsSync5(path))
+    return [];
+  try {
+    return openBlocks(parseQuestions(readFileSync4(path, "utf8")).blocks).map((b) => b.id);
+  } catch {
+    return [];
+  }
+}
+
+// src/core/run/runStatus.ts
+var BAR_CELLS = 5;
+function bar(done, total, failed = 0) {
+  if (failed > 0) {
+    const cells = BAR_CELLS - 1;
+    const filled2 = total === 0 ? 0 : Math.min(cells, Math.round(done / total * cells));
+    return `✗${"▓".repeat(filled2)}${"░".repeat(cells - filled2)}`;
+  }
+  const filled = total === 0 ? 0 : Math.round(done / total * BAR_CELLS);
+  return "▓".repeat(filled) + "░".repeat(BAR_CELLS - filled);
+}
+function whatIsWaiting(run, runDir) {
+  return waitingFor(run, runDir);
+}
+
+export { RunStore, runSnapshot, openQuestions, isMovable, bar, whatIsWaiting };

package/dist/hooks/claim-sources.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import {
+  wouldBeContent
+} from "./chunk-t8tdv11p.js";
+import {
+  claimSourcesDeny,
+  claimSourcesEmptySectionDeny,
+  claimSourcesMalformedDeny,
+  claimSourcesUnresolvedDeny
+} from "./chunk-9gb21660.js";
+import {
+  isHandoff,
+  validateHandoff
+} from "./chunk-kw4tffzf.js";
+import {
+  allow,
+  deny,
+  filePathOf,
+  isWriteOrEdit,
+  postContext,
+  readPayload,
+  runHook
+} from "./chunk-1zwcxd3f.js";
+import"./chunk-a8p2rc94.js";
+import"./chunk-g395gk7e.js";
+import {
+  loadWorkspace,
+  locateWork,
+  toSrcContext
+} from "./chunk-p274ckxv.js";
+
+// src/hooks/claim-sources.ts
+await runHook("claim-sources", async () => {
+  const payload = await readPayload();
+  if (!isWriteOrEdit(payload))
+    return;
+  const filePath = filePathOf(payload);
+  if (!filePath.endsWith(".md"))
+    return;
+  const location = locateWork(filePath);
+  if (location === null)
+    return;
+  const wouldBe = wouldBeContent(payload, filePath);
+  if (wouldBe.kind !== "content")
+    return;
+  const looksLikeHandoff = filePath.endsWith("handoff.md") || isHandoff(wouldBe.text);
+  if (!looksLikeHandoff)
+    return;
+  const workspace = loadWorkspace(location.root);
+  const report = validateHandoff(wouldBe.text, toSrcContext(workspace, location.runDir));
+  if (report.ok)
+    return;
+  const relPath = `tldrx-work/${location.run}/${location.relative}`;
+  const parts = [];
+  if (report.unsourced.length > 0)
+    parts.push(claimSourcesDeny(relPath, report.unsourced));
+  if (report.malformed.length > 0)
+    parts.push(claimSourcesMalformedDeny(relPath, report.malformed));
+  if (report.emptySections.length > 0) {
+    parts.push(claimSourcesEmptySectionDeny(relPath, [...report.emptySections]));
+  }
+  if (report.unresolved.length > 0)
+    parts.push(claimSourcesUnresolvedDeny(relPath, report.unresolved));
+  if (parts.length === 0)
+    return;
+  const message = parts.join(`
+`);
+  if (payload.hook_event_name === "PostToolUse")
+    postContext(message);
+  deny(message);
+});
+allow();