mikoshi-construct 0.1.2 → 0.2.0

package/dist/cli.js

@@ -1,22 +1,27 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path13 from "path";
-import process4 from "process";
+import path21 from "path";
+import process6 from "process";
 import { isTTY } from "@clack/prompts";
 import { defineCommand, runMain } from "citty";
 
-// src/commands/cost.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+// src/commands/cost/index.ts
+import process2 from "process";
+
+// src/commands/cost/claude-code.ts
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "fs";
 import { homedir } from "os";
 import path from "path";
+
+// src/commands/cost/usage.ts
+var PRICE_RELATIVE_TO_INPUT = { cacheWrite: 1.25, cacheRead: 0.1, output: 5 };
 function emptyUsage() {
   return { calls: 0, input: 0, cacheWrite: 0, cacheRead: 0, output: 0, models: [] };
 }
 function billable(usage) {
   return usage.input + usage.cacheWrite + usage.cacheRead + usage.output;
 }
-var PRICE_RELATIVE_TO_INPUT = { cacheWrite: 1.25, cacheRead: 0.1, output: 5 };
 function weighted(usage) {
   return Math.round(usage.input + usage.cacheWrite * PRICE_RELATIVE_TO_INPUT.cacheWrite + usage.cacheRead * PRICE_RELATIVE_TO_INPUT.cacheRead + usage.output * PRICE_RELATIVE_TO_INPUT.output);
 }
@@ -31,6 +36,8 @@ function add(total, part) {
       total.models.push(model);
   }
 }
+
+// src/commands/cost/claude-code.ts
 function projectKey(cwd) {
   return cwd.replace(/[/.]/g, "-");
 }
@@ -80,48 +87,181 @@ function collectRuns(sessionDir) {
   });
 }
 function collectWorkflowRuns(cwd, projectsDir = claudeProjectsDir()) {
-  const projectDir = path.join(projectsDir, projectKey(cwd));
-  if (!existsSync(projectDir))
+  return directories(path.join(projectsDir, projectKey(cwd))).flatMap(collectRuns).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+function resolvedPath(cwd) {
+  try {
+    return realpathSync(cwd);
+  } catch {
     return null;
-  return directories(projectDir).flatMap(collectRuns).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+  }
 }
-function fmt(value) {
-  return value.toLocaleString("en-US");
+function mainWorktreePath(cwd) {
+  const dotGit = path.join(cwd, ".git");
+  if (!existsSync(dotGit) || !statSync(dotGit).isFile())
+    return null;
+  const gitdir = readFileSync(dotGit, "utf8").match(/^gitdir: *(\S.*)$/m)?.[1]?.trim();
+  return gitdir?.match(/^(.+)\/\.git\/worktrees\/[^/]+\/?$/)?.[1] ?? null;
 }
-function printCost(ui2, runs, last) {
-  if (runs == null) {
-    ui2.flatline("No Claude Code session data for this directory.");
-    return 1;
+function recordedElsewhere(cwd, key, projectsDir) {
+  return [resolvedPath(cwd), mainWorktreePath(cwd)].filter((candidate) => candidate != null).map(projectKey).filter((candidate) => candidate !== key && existsSync(path.join(projectsDir, candidate)));
+}
+function lookalikeKeys(cwd, key, projectsDir) {
+  const suffix = `-${path.basename(cwd)}`;
+  return directories(projectsDir).map((dir) => path.basename(dir)).filter((name) => name !== key && name.endsWith(suffix));
+}
+var ClaudeCodeCostSource = class {
+  constructor(projectsDir = claudeProjectsDir()) {
+    this.projectsDir = projectsDir;
   }
-  const selected = last ? runs.slice(-1) : runs;
-  if (selected.length === 0) {
-    ui2.glitch("No /implement runs recorded here yet.");
-    return 0;
+  projectsDir;
+  runtime = "claude-code";
+  readable() {
+    return existsSync(this.projectsDir);
   }
-  const grand = emptyUsage();
-  for (const run of selected) {
-    ui2.line(`${ui2.theme.accent(run.run)} ${ui2.theme.dim(`${run.startedAt} \xB7 ${run.total.models.join(", ")}`)}`);
-    for (const agent of run.agents) {
-      ui2.line(`  ${agent.type.padEnd(12)} ${agent.label.padEnd(28)} calls ${String(agent.usage.calls).padStart(3)}  in ${fmt(agent.usage.input).padStart(8)}  cache-w ${fmt(agent.usage.cacheWrite).padStart(9)}  cache-r ${fmt(agent.usage.cacheRead).padStart(10)}  out ${fmt(agent.usage.output).padStart(7)}`);
+  read(cwd) {
+    const key = projectKey(cwd);
+    if (existsSync(path.join(this.projectsDir, key))) {
+      const runs = collectWorkflowRuns(cwd, this.projectsDir);
+      return { status: runs.length > 0 ? "ok" : "empty", runs, key, candidates: [] };
     }
-    ui2.line(`  ${ui2.theme.bold(`total ${fmt(billable(run.total))} billable tokens in ${run.total.calls} calls`)} ${ui2.theme.dim(`\u2248 ${fmt(weighted(run.total))} input-equivalent`)}`);
-    ui2.line();
-    add(grand, run.total);
+    const recorded = recordedElsewhere(cwd, key, this.projectsDir);
+    if (recorded.length > 0)
+      return { status: "mismatch", runs: [], key, candidates: recorded };
+    const lookalikes = lookalikeKeys(cwd, key, this.projectsDir);
+    if (lookalikes.length > 0)
+      return { status: "unknown", runs: [], key, candidates: lookalikes };
+    return { status: "empty", runs: [], key, candidates: [] };
   }
-  if (selected.length > 1)
-    ui2.line(`${ui2.theme.bold(`${selected.length} runs: ${fmt(billable(grand))} billable tokens in ${grand.calls} calls`)} ${ui2.theme.dim(`\u2248 ${fmt(weighted(grand))} input-equivalent (cache-write \xD7${PRICE_RELATIVE_TO_INPUT.cacheWrite}, cache-read \xD7${PRICE_RELATIVE_TO_INPUT.cacheRead}, output \xD7${PRICE_RELATIVE_TO_INPUT.output})`)}`);
-  return 0;
+};
+
+// src/commands/cost/ledger.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import path2 from "path";
+var LEDGER_FILE = ".construct/runs.jsonl";
+var TEXT_FIELDS = ["at", "task", "effort", "status", "rung"];
+var COUNT_FIELDS = ["agents", "toolUses", "seconds"];
+function isText(value) {
+  return typeof value === "string" && value !== "";
+}
+function isCount(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isTokenCount(value) {
+  return value === "unknown" || isCount(value);
+}
+function attemptFaults(value, index) {
+  if (value == null || typeof value !== "object")
+    return [`attempts[${index}] is not a record`];
+  const attempt = value;
+  return [
+    isCount(attempt.rung) ? null : `attempts[${index}].rung`,
+    isText(attempt.effort) ? null : `attempts[${index}].effort`,
+    isText(attempt.outcome) ? null : `attempts[${index}].outcome`,
+    typeof attempt.reason === "string" ? null : `attempts[${index}].reason`
+  ].filter((fault) => fault != null);
+}
+function attemptListFaults(value) {
+  if (!Array.isArray(value))
+    return ["attempts"];
+  return value.flatMap(attemptFaults);
+}
+function undeclaredFields(record) {
+  const missing = [
+    ...TEXT_FIELDS.filter((field) => !isText(record[field])),
+    ...COUNT_FIELDS.filter((field) => !isCount(record[field]))
+  ];
+  if (!isTokenCount(record.tokens))
+    missing.push("tokens");
+  missing.push(...attemptListFaults(record.attempts));
+  return missing;
+}
+function toAttempt(value) {
+  const attempt = value;
+  return { rung: attempt.rung, effort: attempt.effort, outcome: attempt.outcome, reason: attempt.reason };
+}
+function toEntry(raw) {
+  if (raw == null || typeof raw !== "object" || Array.isArray(raw))
+    return "not a run record";
+  const record = raw;
+  const missing = undeclaredFields(record);
+  if (missing.length > 0)
+    return `missing or invalid: ${missing.join(", ")}`;
+  return {
+    run: isText(record.run) ? record.run : null,
+    at: record.at,
+    task: record.task,
+    effort: record.effort,
+    status: record.status,
+    rung: record.rung,
+    attempts: record.attempts.map(toAttempt),
+    agents: record.agents,
+    tokens: record.tokens,
+    toolUses: record.toolUses,
+    seconds: record.seconds
+  };
+}
+function readLedger(root) {
+  const file = path2.join(root, LEDGER_FILE);
+  const reading = { entries: [], malformed: [] };
+  if (!existsSync2(file))
+    return reading;
+  readFileSync2(file, "utf8").split("\n").forEach((text2, index) => {
+    const line = index + 1;
+    if (text2.trim() === "")
+      return;
+    let raw;
+    try {
+      raw = JSON.parse(text2);
+    } catch {
+      reading.malformed.push({ line, reason: "not JSON" });
+      return;
+    }
+    const entry = toEntry(raw);
+    if (typeof entry === "string")
+      reading.malformed.push({ line, reason: entry });
+    else
+      reading.entries.push(entry);
+  });
+  return reading;
+}
+function summarizeLedger(reading) {
+  const anyTokenUnknown = reading.entries.some((entry) => entry.tokens === "unknown");
+  const counted = reading.entries.reduce((total, entry) => total + (entry.tokens === "unknown" ? 0 : entry.tokens), 0);
+  return {
+    runs: reading.entries.length,
+    agents: reading.entries.reduce((total, entry) => total + entry.agents, 0),
+    failures: reading.entries.filter((entry) => entry.status !== "done").length,
+    tokens: anyTokenUnknown ? "unknown" : counted,
+    malformed: reading.malformed
+  };
+}
+function withoutTokenTotals(summary) {
+  return { ...summary, tokens: "unknown" };
+}
+function hasLedgerFindings(summary) {
+  return summary.runs > 0 || summary.malformed.length > 0;
+}
+function reconcile(entries, runs) {
+  const sessionRuns = new Set(runs.map((run) => run.run));
+  const ledgerRuns = entries.map((entry) => entry.run).filter((run) => run != null);
+  const joinable = new Set(ledgerRuns);
+  return {
+    entriesWithoutSession: [...joinable].filter((run) => !sessionRuns.has(run)),
+    sessionsWithoutEntry: runs.map((run) => run.run).filter((run) => !joinable.has(run)),
+    unjoinable: entries.length - ledgerRuns.length
+  };
 }
 
-// src/commands/doctor.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import path3 from "path";
+// src/commands/cost/runtime.ts
+import process from "process";
 
 // src/manifest.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import path2 from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import path3 from "path";
 var MANIFEST_FILE = "construct.json";
+var MANIFEST_VERSION = 2;
 var DISCOVERY_MARKERS = [
   "product",
   "module-map",
@@ -151,8 +291,13 @@ function buildManifest(input) {
   const files = {};
   for (const op of input.written)
     files[op.target] = sha256(op.content);
-  const discovery = Object.fromEntries(DISCOVERY_MARKERS.map((marker) => [marker, markerFile(marker, input.vars.compositionDir)]));
+  const markers = Object.fromEntries(DISCOVERY_MARKERS.map((marker) => [marker, {
+    file: markerFile(marker, input.vars.compositionDir),
+    authoredBy: "unknown",
+    sha: null
+  }]));
   return {
+    manifestVersion: MANIFEST_VERSION,
     construct: input.version,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     preset: input.preset,
@@ -163,21 +308,378 @@ function buildManifest(input) {
     contracts: input.contracts ? { path: input.vars.contractPath, types: input.vars.contractTypesOutput } : null,
     vars: input.vars,
     files,
-    discovery
+    discovery: { baseSha: null, filledAt: null, markers }
+  };
+}
+function upgradeMarker(recorded, file) {
+  if (typeof recorded === "string")
+    return { file: recorded, authoredBy: "unknown", sha: null };
+  const value = recorded ?? {};
+  return {
+    file: typeof value.file === "string" ? value.file : file,
+    authoredBy: value.authoredBy === "construct" ? "construct" : "unknown",
+    sha: typeof value.sha === "string" ? value.sha : null
+  };
+}
+function upgradeManifest(raw) {
+  const manifest = raw;
+  const discovery = manifest.discovery ?? {};
+  const recorded = discovery.markers ?? discovery;
+  const markers = Object.fromEntries(DISCOVERY_MARKERS.map((marker) => [
+    marker,
+    upgradeMarker(recorded[marker], markerFile(marker, manifest.vars?.compositionDir))
+  ]));
+  return {
+    ...manifest,
+    manifestVersion: MANIFEST_VERSION,
+    discovery: {
+      baseSha: typeof discovery.baseSha === "string" ? discovery.baseSha : null,
+      filledAt: typeof discovery.filledAt === "string" ? discovery.filledAt : null,
+      markers
+    }
   };
 }
 function writeManifest(root, manifest) {
-  writeFileSync(path2.join(root, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  writeFileSync(path3.join(root, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
 `);
 }
 function readManifest(root) {
-  const file = path2.join(root, MANIFEST_FILE);
-  if (!existsSync2(file))
+  const file = path3.join(root, MANIFEST_FILE);
+  if (!existsSync3(file))
     return null;
-  return JSON.parse(readFileSync2(file, "utf8"));
+  return upgradeManifest(JSON.parse(readFileSync3(file, "utf8")));
+}
+
+// src/commands/cost/runtime.ts
+var CLAUDE_CODE_ENV = ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"];
+var CURSOR_ENV = ["CURSOR_AGENT", "CURSOR_TRACE_ID"];
+function anySet(env, names) {
+  return names.some((name) => (env[name] ?? "") !== "");
+}
+function resolveRuntime(root, env = process.env) {
+  if (anySet(env, CLAUDE_CODE_ENV))
+    return "claude-code";
+  if (anySet(env, CURSOR_ENV))
+    return "cursor";
+  return readManifest(root)?.ai === "cursor" ? "cursor" : "claude-code";
+}
+
+// src/commands/cost/report.ts
+var COST_EXIT = {
+  ok: 0,
+  empty: 0,
+  mismatch: 1,
+  unknown: 1,
+  unsupported: 3
+};
+function selectRuns(report, last) {
+  const runs = report.runs ?? [];
+  return last ? runs.slice(-1) : runs;
+}
+function costJson(report, last) {
+  const runs = selectRuns(report, last);
+  return {
+    status: report.status,
+    runtime: report.runtime,
+    ...report.key == null ? {} : { key: report.key },
+    ...report.candidates == null || report.candidates.length === 0 ? {} : { candidates: report.candidates },
+    ...runs.length === 0 ? {} : { runs },
+    ...report.ledger == null ? {} : { ledger: report.ledger },
+    ...report.reconciliation == null ? {} : { reconciliation: report.reconciliation }
+  };
+}
+function fmt(value) {
+  return value.toLocaleString("en-US");
+}
+function tokens(value) {
+  return value === "unknown" ? "unknown" : fmt(value);
+}
+function printLedger(ui2, ledger, reconciliation) {
+  if (ledger == null && reconciliation == null)
+    return;
+  if (ledger != null) {
+    ui2.line(ui2.theme.dim(ui2.lore.ledgerCounts(ledger.runs, ledger.agents, ledger.failures, tokens(ledger.tokens))));
+    if (ledger.malformed.length > 0)
+      ui2.glitch(ui2.lore.ledgerMalformed(ledger.malformed.length), ledger.malformed.map((entry) => `line ${entry.line}: ${entry.reason}`));
+  }
+  if (reconciliation == null)
+    return;
+  ui2.line(ui2.theme.dim(ui2.lore.ledgerDrift(reconciliation.entriesWithoutSession.length, reconciliation.sessionsWithoutEntry.length, reconciliation.unjoinable)));
+  for (const run of reconciliation.entriesWithoutSession)
+    ui2.line(ui2.theme.dim(`    ${run}: ${ui2.lore.ledgerEntryWithoutSession}`));
+  for (const run of reconciliation.sessionsWithoutEntry)
+    ui2.line(ui2.theme.dim(`    ${run}: ${ui2.lore.ledgerSessionWithoutEntry}`));
+}
+function printRuns(ui2, runs) {
+  const grand = emptyUsage();
+  for (const run of runs) {
+    ui2.line(`${ui2.theme.accent(run.run)} ${ui2.theme.dim(`${run.startedAt} \xB7 ${run.total.models.join(", ")}`)}`);
+    for (const agent of run.agents)
+      ui2.line(`  ${agent.type.padEnd(12)} ${agent.label.padEnd(28)} calls ${String(agent.usage.calls).padStart(3)}  in ${fmt(agent.usage.input).padStart(8)}  cache-w ${fmt(agent.usage.cacheWrite).padStart(9)}  cache-r ${fmt(agent.usage.cacheRead).padStart(10)}  out ${fmt(agent.usage.output).padStart(7)}`);
+    ui2.line(`  ${ui2.theme.bold(`total ${fmt(billable(run.total))} billable tokens in ${run.total.calls} calls`)} ${ui2.theme.dim(`\u2248 ${fmt(weighted(run.total))} input-equivalent`)}`);
+    ui2.line();
+    add(grand, run.total);
+  }
+  if (runs.length > 1)
+    ui2.line(`${ui2.theme.bold(`${runs.length} runs: ${fmt(billable(grand))} billable tokens in ${grand.calls} calls`)} ${ui2.theme.dim(`\u2248 ${fmt(weighted(grand))} input-equivalent (cache-write \xD7${PRICE_RELATIVE_TO_INPUT.cacheWrite}, cache-read \xD7${PRICE_RELATIVE_TO_INPUT.cacheRead}, output \xD7${PRICE_RELATIVE_TO_INPUT.output})`)}`);
+}
+function printCost(ui2, report, last) {
+  const key = report.key ?? "";
+  const candidates = report.candidates ?? [];
+  switch (report.status) {
+    case "unsupported":
+      ui2.glitch(ui2.lore.costUnsupported(report.runtime));
+      break;
+    case "mismatch":
+      ui2.glitch(ui2.lore.costKeyMismatch(key), candidates);
+      break;
+    case "unknown":
+      ui2.glitch(ui2.lore.costKeyUnknown(key), candidates);
+      break;
+    case "empty":
+      ui2.glitch(ui2.lore.costEmpty);
+      break;
+    case "ok":
+      printRuns(ui2, selectRuns(report, last));
+      break;
+  }
+  printLedger(ui2, report.ledger, report.reconciliation);
+  return COST_EXIT[report.status];
+}
+
+// src/commands/cost/index.ts
+function costReport(cwd, options = {}) {
+  const runtime = resolveRuntime(cwd, options.env ?? process2.env);
+  const reading = readLedger(cwd);
+  const ledger = summarizeLedger(reading);
+  const reported = hasLedgerFindings(ledger);
+  const source = runtime === "claude-code" ? new ClaudeCodeCostSource(options.projectsDir) : null;
+  if (source == null || !source.readable())
+    return { status: "unsupported", runtime, ...reported ? { ledger: withoutTokenTotals(ledger) } : {} };
+  const result = source.read(cwd);
+  const joinable = result.status === "ok" || result.status === "empty";
+  return {
+    runtime,
+    ...result,
+    ...reported ? { ledger } : {},
+    ...joinable && (reported || result.runs.length > 0) ? { reconciliation: reconcile(reading.entries, result.runs) } : {}
+  };
+}
+
+// src/commands/doctor/baseline.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import path4 from "path";
+function baselineVerdict(root, manifest) {
+  const missingFiles = [];
+  const modifiedFiles = [];
+  for (const [file, hash] of Object.entries(manifest.files)) {
+    const absolute = path4.join(root, file);
+    if (!existsSync4(absolute))
+      missingFiles.push(file);
+    else if (sha256(readFileSync4(absolute, "utf8")) !== hash)
+      modifiedFiles.push(file);
+  }
+  return { missingFiles, modifiedFiles };
+}
+
+// src/commands/doctor/enforcement.ts
+function harnessReach(evidence) {
+  const command = `"${evidence.harness.command}"`;
+  if (evidence.workflows.harnessWorkflow != null)
+    return { level: "L3", evidence: `${evidence.workflows.harnessWorkflow} runs ${command}` };
+  if (evidence.hooks.runsHarness && evidence.hooks.manager != null)
+    return { level: "L2", evidence: `${evidence.hooks.manager} runs ${command}, and a local hook is bypassable with --no-verify` };
+  return { level: "L0", evidence: `no workflow and no hook configuration runs ${command}` };
+}
+function reached(id, state, evidence, detail) {
+  const reach = harnessReach(evidence);
+  return { id, level: reach.level, state, evidence: `${detail}; ${reach.evidence}` };
+}
+function absent(id, detail) {
+  return { id, level: "L0", state: "absent", evidence: detail };
+}
+
+// src/commands/doctor/checks/ci.ts
+var ID = "ci";
+var SCOPE = "branch protection and organisation rulesets live in the GitHub API, not in the repository, so doctor cannot see whether this blocks a merge";
+function ciCheck(evidence) {
+  const workflows = evidence.workflows;
+  const reach = harnessReach(evidence);
+  if (workflows.harnessWorkflow != null)
+    return { id: ID, level: reach.level, state: "present", evidence: `${reach.evidence}; ${SCOPE}` };
+  const seen = workflows.files.length === 0 ? `${workflows.directory} holds no workflow file` : `none of ${workflows.files.map((file) => `${workflows.directory}/${file}`).join(", ")} runs "${evidence.harness.command}"`;
+  return { id: ID, level: reach.level, state: "unknown", evidence: `${seen}; ${SCOPE}` };
+}
+
+// src/commands/doctor/runner.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import path5 from "path";
+var RUNNER_CONFIG_FILES = [
+  "vitest.config.ts",
+  "vitest.config.mts",
+  "vitest.config.js",
+  "vitest.config.mjs",
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs"
+];
+var STRING_LITERAL = /^(['"])(.*)\1$/;
+function literalEntries(body) {
+  const trimmed = body.trim();
+  if (trimmed === "")
+    return [];
+  const entries = trimmed.split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+  const values = entries.map((entry) => STRING_LITERAL.exec(entry)?.[2]);
+  return values.every((value) => value != null) ? values : null;
+}
+function includeGlobs(source) {
+  const found = [];
+  let literal = false;
+  for (const match of source.matchAll(/include\s*:\s*/g)) {
+    const rest = source.slice(match.index + match[0].length);
+    if (!rest.startsWith("["))
+      return null;
+    const close = rest.indexOf("]");
+    if (close === -1)
+      return null;
+    const entries = literalEntries(rest.slice(1, close));
+    if (entries == null)
+      return null;
+    literal = true;
+    found.push(...entries);
+  }
+  return literal ? found : null;
+}
+function escapeLiteral(character) {
+  return /[.+^${}()|[\]\\]/.test(character) ? `\\${character}` : character;
+}
+function globToRegExp(glob) {
+  let pattern = "";
+  let braces = 0;
+  for (let index = 0; index < glob.length; index += 1) {
+    const character = glob[index];
+    if (character === "*" && glob[index + 1] === "*" && glob[index + 2] === "/") {
+      pattern += "(?:[^/]+/)*";
+      index += 2;
+      continue;
+    }
+    if (character === "*" && glob[index + 1] === "*") {
+      pattern += ".*";
+      index += 1;
+      continue;
+    }
+    if (character === "*") {
+      pattern += "[^/]*";
+      continue;
+    }
+    if (character === "?") {
+      pattern += "[^/]";
+      continue;
+    }
+    if (character === "{") {
+      braces += 1;
+      pattern += "(?:";
+      continue;
+    }
+    if (character === "}" && braces > 0) {
+      braces -= 1;
+      pattern += ")";
+      continue;
+    }
+    if (character === "," && braces > 0) {
+      pattern += "|";
+      continue;
+    }
+    pattern += escapeLiteral(character);
+  }
+  return new RegExp(`^${pattern}$`);
+}
+function matchesAnyGlob(file, globs) {
+  const normalized = file.replace(/^\.\//, "");
+  return globs.some((glob) => globToRegExp(glob.replace(/^\.\//, "")).test(normalized));
+}
+function readRunnerFacts(root, harnessText) {
+  const invokedByHarness = harnessText.includes("vitest");
+  const file = RUNNER_CONFIG_FILES.find((candidate) => existsSync5(path5.join(root, candidate))) ?? null;
+  if (file == null) {
+    return {
+      file: null,
+      globs: null,
+      note: `no runner config file (${RUNNER_CONFIG_FILES[0]} or a sibling) exists, so the include list cannot be read`,
+      invokedByHarness
+    };
+  }
+  let source;
+  try {
+    source = readFileSync5(path5.join(root, file), "utf8");
+  } catch {
+    return { file, globs: null, note: `${file} cannot be read, so the include list is unknown`, invokedByHarness };
+  }
+  const globs = includeGlobs(source);
+  if (globs == null)
+    return { file, globs: null, note: `the include in ${file} is not a literal list of strings, so doctor cannot say what the runner collects`, invokedByHarness };
+  return { file, globs, note: `${file} includes ${globs.map((glob) => `"${glob}"`).join(", ")}`, invokedByHarness };
+}
+
+// src/commands/doctor/checks/construct-tests.ts
+var ID2 = "construct-tests";
+function constructTestsCheck(evidence) {
+  const recorded = evidence.recordedTests;
+  if (recorded.length === 0)
+    return absent(ID2, "construct.json records no test file; weakest link: there are no construct tests to run");
+  const runner = evidence.runner;
+  if (runner.globs == null)
+    return reached(ID2, "unknown", evidence, `construct.json records ${recorded.length} test files, but ${runner.note}`);
+  const orphan = recorded.find((file) => !matchesAnyGlob(file, runner.globs ?? []));
+  if (orphan != null)
+    return absent(ID2, `${orphan} is recorded in construct.json, but ${runner.note}, so the runner never collects it; weakest link: a construct test that nothing runs`);
+  if (!runner.invokedByHarness)
+    return absent(ID2, `construct.json records ${recorded.length} test files and ${runner.note}, but "${evidence.harness.script}" does not run the test runner; weakest link: the harness command never reaches them`);
+  return reached(ID2, "present", evidence, `all ${recorded.length} test files recorded in construct.json match the include in ${runner.file}, and "${evidence.harness.script}" runs the test runner`);
+}
+
+// src/commands/doctor/checks/hook.ts
+var ID3 = "hook";
+function hookCheck(evidence) {
+  const hooks = evidence.hooks;
+  if (hooks.manager != null) {
+    const runs = hooks.runsHarness ? `runs "${evidence.harness.command}"` : `does not run "${evidence.harness.command}"`;
+    return { id: ID3, level: "L2", state: "present", evidence: `${hooks.manager} installs a git hook and ${runs}; a local hook is bypassable with --no-verify` };
+  }
+  if (hooks.script != null)
+    return { id: ID3, level: "L0", state: "present", evidence: `package.json script "${hooks.script}" is claimed as a guard, but no .husky, lefthook, simple-git-hooks or core.hooksPath configuration installs it; weakest link: nobody is obliged to run it` };
+  return { id: ID3, level: "L0", state: "absent", evidence: "no .husky, lefthook, simple-git-hooks or core.hooksPath configuration and no pre-commit script in package.json" };
+}
+
+// src/commands/doctor/checks/lint-policy.ts
+var ID4 = "lint-policy";
+function lintPolicyCheck(evidence) {
+  const policy = evidence.policyTests[0];
+  if (policy == null) {
+    if (evidence.unreadable.length > 0)
+      return reached(ID4, "unknown", evidence, `${evidence.unreadable[0]} cannot be read, so doctor cannot say whether a lint policy check exists`);
+    return absent(ID4, "no file recorded in construct.json runs ESLint over the lint policy this repository declares; weakest link: the repository has no policy check to run");
+  }
+  const runner = evidence.runner;
+  if (runner.globs == null)
+    return reached(ID4, "unknown", evidence, `${policy} runs ESLint over the lint policy this repository declares, but ${runner.note}`);
+  if (!matchesAnyGlob(policy, runner.globs))
+    return absent(ID4, `${policy} runs ESLint over the lint policy this repository declares, but ${runner.note}; weakest link: the runner never collects the policy check`);
+  if (!runner.invokedByHarness)
+    return absent(ID4, `${policy} runs ESLint over the lint policy this repository declares and ${runner.note}, but "${evidence.harness.script}" does not run the test runner; weakest link: the harness command never reaches the policy check`);
+  return reached(ID4, "present", evidence, `${policy} runs ESLint over the lint policy this repository declares, ${runner.note}, and "${evidence.harness.script}" runs the test runner`);
 }
 
-// src/commands/doctor.ts
+// src/commands/doctor/checks/red-gate.ts
+var ID5 = "red-gate";
+function redGateCheck(evidence) {
+  return reached(ID5, "unknown", evidence, `doctor executes nothing from the repository it inspects, so whether "${evidence.harness.command}" passes on a clean checkout is unproven here; CI is where that is proven`);
+}
+
+// src/commands/doctor/discovery.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import path6 from "path";
 var DISCOVERY_PLACEHOLDER = "_Not discovered yet \u2014 run `/construct-discover`._";
 function markerOpen(marker) {
   return `<!-- construct:discover:${marker} -->`;
@@ -185,66 +687,290 @@ function markerOpen(marker) {
 function markerClose(marker) {
   return `<!-- /construct:discover:${marker} -->`;
 }
-function isMarkerFilled(document, marker) {
+function blockBody(document, marker) {
   const start = document.indexOf(markerOpen(marker));
   const stop = document.indexOf(markerClose(marker));
   if (start === -1 || stop === -1 || stop < start)
-    return false;
+    return null;
   const body = document.slice(start + markerOpen(marker).length, stop).trim();
-  return body !== "" && body !== DISCOVERY_PLACEHOLDER;
+  return body === "" || body === DISCOVERY_PLACEHOLDER ? null : body;
 }
+function compositionBody(directory) {
+  if (!existsSync6(directory))
+    return null;
+  const models = readdirSync2(directory).filter((file) => file.endsWith(".yaml")).sort();
+  if (models.length === 0)
+    return null;
+  return models.map((model) => `${model}
+${readFileSync6(path6.join(directory, model), "utf8")}`).join("\n");
+}
+function markerBody(root, marker, file) {
+  const location = path6.join(root, file);
+  if (marker === "composition")
+    return compositionBody(location);
+  if (!existsSync6(location))
+    return null;
+  return blockBody(readFileSync6(location, "utf8"), marker);
+}
+function missingDiscovery(root, manifest) {
+  return DISCOVERY_MARKERS.filter((marker) => markerBody(root, marker, manifest.discovery.markers[marker].file) == null);
+}
+
+// src/commands/doctor/evidence.ts
+import { readFileSync as readFileSync10 } from "fs";
+import path10 from "path";
+
+// src/commands/doctor/harness.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import path7 from "path";
 var REQUIRED_QUALITY_STEPS = ["lint", "typecheck", "test"];
-function contractProblems(root, contracts, scriptName, quality) {
+var SCRIPT_REFERENCE = /(?:^|&&|\|\||;)\s*(?:pnpm|npm|yarn|bun)\s+(?:run\s+)?([\w:.-]+)/g;
+function harnessScriptName(command) {
+  return command.replace(/^(pnpm|npm|yarn|bun)\s+(run\s+)?/, "");
+}
+function expandScript(scripts, name, seen) {
+  if (seen.has(name))
+    return "";
+  seen.add(name);
+  const body = scripts[name];
+  if (body == null)
+    return "";
+  const referenced = [...body.matchAll(SCRIPT_REFERENCE)].map((match) => match[1]);
+  return [body, ...referenced.map((reference) => expandScript(scripts, reference, seen))].join(" && ");
+}
+function readHarnessFacts(root, command) {
+  const script = harnessScriptName(command);
+  const manifestPath = path7.join(root, "package.json");
+  const packageJson = existsSync7(manifestPath) ? JSON.parse(readFileSync7(manifestPath, "utf8")) : null;
+  const scripts = packageJson?.scripts ?? {};
+  const body = scripts[script] ?? null;
+  return {
+    command,
+    script,
+    scripts,
+    body,
+    resolved: expandScript(scripts, script, /* @__PURE__ */ new Set()),
+    commandForms: [command, `pnpm run ${script}`, `pnpm ${script}`, `npm run ${script}`, `yarn ${script}`],
+    packageJson
+  };
+}
+function runsHarnessCommand(text2, forms) {
+  return forms.some((form) => text2.includes(form));
+}
+function contractProblems(root, contracts, script, body) {
   if (contracts == null)
     return [];
-  const problems = [contracts.path, contracts.types].filter((file) => !existsSync3(path3.join(root, file))).map((file) => `${file} is missing (construct.json \u2192 contracts)`);
-  if (!quality.includes("contracts:check"))
-    problems.push(`"${scriptName}" does not run contracts:check`);
+  const problems = [contracts.path, contracts.types].filter((file) => !existsSync7(path7.join(root, file))).map((file) => `${file} is missing (construct.json \u2192 contracts)`);
+  if (!body.includes("contracts:check"))
+    problems.push(`"${script}" does not run contracts:check`);
   return problems;
 }
-function harnessProblems(root, manifest) {
-  const command = manifest.harness.command;
-  const manifestPath = path3.join(root, "package.json");
-  if (!existsSync3(manifestPath))
+function harnessProblems(root, manifest, facts) {
+  if (facts.packageJson == null)
     return ["package.json is missing"];
-  const pkg = JSON.parse(readFileSync3(manifestPath, "utf8"));
-  const scripts = pkg.scripts ?? {};
-  const scriptName = command.replace(/^(pnpm|npm|yarn|bun)\s+(run\s+)?/, "");
-  const quality = scripts[scriptName];
-  if (quality == null)
-    return [`package.json has no "${scriptName}" script (harness command is "${command}")`];
+  const body = facts.body;
+  if (body == null)
+    return [`package.json has no "${facts.script}" script (harness command is "${facts.command}")`];
   return [
-    ...REQUIRED_QUALITY_STEPS.filter((step) => !quality.includes(step)).map((step) => `"${scriptName}" does not run ${step}`),
-    ...contractProblems(root, manifest.contracts, scriptName, quality)
+    ...REQUIRED_QUALITY_STEPS.filter((step) => !body.includes(step)).map((step) => `"${facts.script}" does not run ${step}`),
+    ...contractProblems(root, manifest.contracts, facts.script, body)
   ];
 }
-function runDoctor(root) {
-  const manifest = readManifest(root);
-  if (manifest == null)
+
+// src/commands/doctor/hooks.ts
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync as statSync2 } from "fs";
+import path8 from "path";
+var LEFTHOOK_FILES = ["lefthook.yml", "lefthook.yaml", "lefthook.toml", "lefthook.json", ".lefthook.yml", ".lefthook.yaml"];
+var SIMPLE_GIT_HOOKS_FILES = [".simple-git-hooks.js", ".simple-git-hooks.cjs", ".simple-git-hooks.mjs", ".simple-git-hooks.json", "simple-git-hooks.json"];
+var HUSKY_DIR = ".husky";
+var GIT_CONFIG = ".git/config";
+var HOOK_SCRIPTS = ["precommit", "pre-commit", "prepush", "pre-push"];
+function read(root, file) {
+  try {
+    return readFileSync8(path8.join(root, file), "utf8");
+  } catch {
     return null;
-  const missingFiles = [];
-  const modifiedFiles = [];
-  for (const [file, hash] of Object.entries(manifest.files)) {
-    const absolute = path3.join(root, file);
-    if (!existsSync3(absolute))
-      missingFiles.push(file);
-    else if (sha256(readFileSync3(absolute, "utf8")) !== hash)
-      modifiedFiles.push(file);
   }
-  const missingDiscovery = DISCOVERY_MARKERS.filter((marker) => {
-    const location = path3.join(root, manifest.discovery[marker]);
-    if (marker === "composition")
-      return !existsSync3(location) || !readdirSync2(location).some((file) => file.endsWith(".yaml"));
-    return !existsSync3(location) || !isMarkerFilled(readFileSync3(location, "utf8"), marker);
+}
+function huskyHooks(root) {
+  const directory = path8.join(root, HUSKY_DIR);
+  if (!existsSync8(directory) || !statSync2(directory).isDirectory())
+    return [];
+  return readdirSync3(directory).filter((entry) => !entry.startsWith("_") && !entry.startsWith(".")).sort().map((entry) => `${HUSKY_DIR}/${entry}`);
+}
+function managerFiles(root, packageJson) {
+  const files = [...huskyHooks(root)];
+  files.push(...[...LEFTHOOK_FILES, ...SIMPLE_GIT_HOOKS_FILES].filter((file) => existsSync8(path8.join(root, file))));
+  if (packageJson != null && "simple-git-hooks" in packageJson)
+    files.push("package.json (simple-git-hooks)");
+  const gitConfig = read(root, GIT_CONFIG);
+  if (gitConfig != null && gitConfig.includes("hooksPath"))
+    files.push(`${GIT_CONFIG} (core.hooksPath)`);
+  return files;
+}
+function readHookFacts(root, packageJson, scripts, commandForms) {
+  const files = managerFiles(root, packageJson);
+  const script = HOOK_SCRIPTS.find((name) => scripts[name] != null) ?? null;
+  const sources = files.map((file) => {
+    if (file.startsWith("package.json"))
+      return JSON.stringify(packageJson?.["simple-git-hooks"] ?? "");
+    return read(root, file.split(" ")[0]) ?? "";
   });
-  const problems = harnessProblems(root, manifest);
-  return {
-    ok: missingFiles.length === 0 && problems.length === 0,
-    missingFiles,
-    modifiedFiles,
-    missingDiscovery,
-    harnessProblems: problems
-  };
+  const manager = files[0] ?? null;
+  const scriptRunsHarness = script != null && runsHarnessCommand(scripts[script] ?? "", commandForms);
+  const installed = sources.some((source) => runsHarnessCommand(source, commandForms) || scriptRunsHarness && script != null && source.includes(script));
+  return { manager, script, runsHarness: manager != null && installed };
+}
+
+// src/commands/doctor/workflows.ts
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
+import path9 from "path";
+var WORKFLOWS_DIR = ".github/workflows";
+var RUN_STEP = /(?:^|\s)run:[ \t]*(\S.*)$/;
+function runStepTexts(source) {
+  const lines = source.split("\n");
+  const steps = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const inline = RUN_STEP.exec(lines[index])?.[1];
+    if (inline == null)
+      continue;
+    if (!inline.startsWith("|") && !inline.startsWith(">")) {
+      steps.push(inline.trim());
+      continue;
+    }
+    const indent = lines[index].length - lines[index].trimStart().length;
+    const block = [];
+    for (let next = index + 1; next < lines.length; next += 1) {
+      const line = lines[next];
+      if (line.trim() !== "" && line.length - line.trimStart().length <= indent)
+        break;
+      block.push(line.trim());
+    }
+    steps.push(block.join("\n"));
+  }
+  return steps;
+}
+function readWorkflowFacts(root, commandForms) {
+  const directory = path9.join(root, WORKFLOWS_DIR);
+  if (!existsSync9(directory))
+    return { directory: WORKFLOWS_DIR, files: [], harnessWorkflow: null, unreadable: [] };
+  const files = readdirSync4(directory).filter((file) => file.endsWith(".yml") || file.endsWith(".yaml")).sort();
+  const unreadable = [];
+  let harnessWorkflow = null;
+  for (const file of files) {
+    let source;
+    try {
+      source = readFileSync9(path9.join(directory, file), "utf8");
+    } catch {
+      unreadable.push(`${WORKFLOWS_DIR}/${file}`);
+      continue;
+    }
+    if (harnessWorkflow == null && runStepTexts(source).some((step) => runsHarnessCommand(step, commandForms)))
+      harnessWorkflow = `${WORKFLOWS_DIR}/${file}`;
+  }
+  return { directory: WORKFLOWS_DIR, files, harnessWorkflow, unreadable };
+}
+
+// src/commands/doctor/evidence.ts
+var TEST_FILE = /\.test\.[cm]?[jt]s$/;
+var LINT_POLICY_MARKERS = ["calculateConfigForFile", "lintText", "lintFiles"];
+function recordedTestFiles(manifest) {
+  return Object.keys(manifest.files).filter((file) => TEST_FILE.test(file)).sort();
+}
+function gatherEvidence(root, manifest) {
+  const harness = readHarnessFacts(root, manifest.harness.command);
+  const runner = readRunnerFacts(root, harness.resolved);
+  const workflows = readWorkflowFacts(root, harness.commandForms);
+  const hooks = readHookFacts(root, harness.packageJson, harness.scripts, harness.commandForms);
+  const recordedTests = recordedTestFiles(manifest);
+  const policyTests = [];
+  const unreadable = [...workflows.unreadable];
+  for (const file of recordedTests) {
+    try {
+      const source = readFileSync10(path10.join(root, file), "utf8");
+      if (LINT_POLICY_MARKERS.some((marker) => source.includes(marker)))
+        policyTests.push(file);
+    } catch {
+      unreadable.push(file);
+    }
+  }
+  return { harness, runner, workflows, hooks, recordedTests, policyTests, unreadable };
+}
+
+// src/commands/doctor/provenance.ts
+function markerAuthorship(recorded, body) {
+  if (recorded.authoredBy !== "construct" || recorded.sha == null || body == null)
+    return "unknown";
+  return sha256(body) === recorded.sha ? "construct" : "owner";
+}
+function discoveryProvenance(root, manifest) {
+  return DISCOVERY_MARKERS.map((marker) => {
+    const recorded = manifest.discovery.markers[marker];
+    return {
+      marker,
+      file: recorded.file,
+      authorship: markerAuthorship(recorded, markerBody(root, marker, recorded.file))
+    };
+  });
+}
+function constructAuthored(readings) {
+  return readings.filter((reading) => reading.authorship === "construct");
+}
+
+// src/commands/doctor/typecheck.ts
+var CAVEATS = {
+  "node-frontend": {
+    checkers: ["vue-tsc", "svelte-check"],
+    text: "node-frontend: `tsc --noEmit` does not see `.vue` or `.svelte` single-file components, so a Vite app that adds them needs the framework's own checker (vue-tsc, svelte-check) in the harness"
+  }
+};
+function typecheckWarnings(preset, evidence) {
+  const caveat = CAVEATS[preset];
+  if (caveat == null || caveat.checkers.some((checker) => evidence.harness.resolved.includes(checker)))
+    return [];
+  return [caveat.text];
+}
+
+// src/commands/doctor/verdict.ts
+var CHECK_IDS = ["lint-policy", "construct-tests", "ci", "hook", "red-gate"];
+var LEVELS = ["L0", "L1", "L2", "L3", "L4"];
+function weakestLink(checks) {
+  const claimed = checks.filter((check) => check.state === "present");
+  if (claimed.length === 0)
+    return null;
+  const ordered = [...claimed].sort((left, right) => CHECK_IDS.indexOf(left.id) - CHECK_IDS.indexOf(right.id));
+  const weakest = ordered.reduce((current, check) => LEVELS.indexOf(check.level) < LEVELS.indexOf(current.level) ? check : current);
+  return { id: weakest.id, level: weakest.level };
+}
+
+// src/commands/doctor/report.ts
+function checkLine(ui2, check) {
+  return `  ${check.id.padEnd(16)} ${check.level}  ${check.state.padEnd(8)} ${ui2.theme.dim(check.evidence)}`;
+}
+function printChecks(ui2, checks) {
+  ui2.line();
+  ui2.line(ui2.theme.accent(ui2.lore.enforcement));
+  for (const check of checks)
+    ui2.line(checkLine(ui2, check));
+}
+function printProvenance(ui2, provenance) {
+  const authored = constructAuthored(provenance);
+  if (authored.length === 0)
+    return;
+  ui2.line();
+  ui2.line(ui2.theme.accent(ui2.lore.provenance));
+  for (const reading of authored)
+    ui2.line(`  ${reading.marker.padEnd(20)} ${ui2.theme.dim(reading.file)}`);
+  ui2.line(ui2.theme.dim(`  ${ui2.lore.stillConstructAuthored(authored.length)}`));
+}
+function printWeakestLink(ui2, weakest) {
+  ui2.line();
+  if (weakest == null) {
+    ui2.line(ui2.theme.bold(ui2.lore.weakestLinkNone));
+    return;
+  }
+  const lift = ui2.lore.levelLift[weakest.level];
+  ui2.line(`${ui2.theme.bold(ui2.lore.weakestLink(weakest.id, weakest.level))}${lift == null ? "" : ui2.theme.dim(` \u2014 ${lift}`)}`);
 }
 function printDoctor(ui2, result) {
   if (result == null) {
@@ -255,124 +981,198 @@ function printDoctor(ui2, result) {
     ui2.glitch("Harness is broken.", result.harnessProblems);
   if (result.missingFiles.length > 0)
     ui2.glitch("Baseline files are missing.", result.missingFiles);
-  if (result.missingDiscovery.length > 0) {
+  if (result.missingDiscovery.length > 0)
     ui2.glitch(ui2.lore.discoveryIncomplete, ["", "Missing:", ...result.missingDiscovery.map((marker) => `  ${marker}`), "", "Run: claude \u2192 /construct-discover"]);
-  }
+  if (result.warnings.length > 0)
+    ui2.glitch(ui2.lore.typecheckCaveat, result.warnings);
   if (result.modifiedFiles.length > 0)
     ui2.line(ui2.theme.dim(`  ${result.modifiedFiles.length} baseline files modified since init (expected once the project evolves).`));
-  if (result.ok) {
+  if (result.ok)
     ui2.ok(ui2.lore.stable);
-    return 0;
-  }
-  return 1;
+  printProvenance(ui2, result.provenance);
+  printChecks(ui2, result.checks);
+  printWeakestLink(ui2, result.weakestLink);
+  return result.ok ? 0 : 1;
+}
+
+// src/commands/doctor/index.ts
+function runDoctor(root) {
+  const manifest = readManifest(root);
+  if (manifest == null)
+    return null;
+  const evidence = gatherEvidence(root, manifest);
+  const baseline = baselineVerdict(root, manifest);
+  const problems = harnessProblems(root, manifest, evidence.harness);
+  const checks = [
+    lintPolicyCheck(evidence),
+    constructTestsCheck(evidence),
+    ciCheck(evidence),
+    hookCheck(evidence),
+    redGateCheck(evidence)
+  ];
+  return {
+    ok: baseline.missingFiles.length === 0 && problems.length === 0,
+    missingFiles: baseline.missingFiles,
+    modifiedFiles: baseline.modifiedFiles,
+    missingDiscovery: missingDiscovery(root, manifest),
+    provenance: discoveryProvenance(root, manifest),
+    harnessProblems: problems,
+    warnings: typecheckWarnings(manifest.preset, evidence),
+    checks,
+    weakestLink: weakestLink(checks)
+  };
 }
 
 // src/commands/init.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import path12 from "path";
+import path20 from "path";
 
 // src/detect/index.ts
-import { existsSync as existsSync7 } from "fs";
-import path7 from "path";
-import process from "process";
+import { existsSync as existsSync14 } from "fs";
+import path15 from "path";
+import process3 from "process";
 
 // src/detect/existing.ts
-import { existsSync as existsSync4, readdirSync as readdirSync3 } from "fs";
-import path4 from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync5 } from "fs";
+import path11 from "path";
 var ESLINT_CONFIGS = ["eslint.config.js", "eslint.config.mjs", "eslint.config.cjs", "eslint.config.ts", ".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json", ".eslintrc.yml"];
 var COMPOSITION_CANDIDATES = ["architecture/composition", "docs/architecture/composition", "docs/composition", "composition"];
 var OPENAPI_CANDIDATES = ["contracts/api/openapi.yaml", "contracts/api/openapi.yml", "contracts/openapi.yaml", "openapi.yaml", "openapi.yml", "openapi.json", "api/openapi.yaml", "docs/openapi.yaml"];
 function anyExists(dir, candidates) {
-  return candidates.some((candidate) => existsSync4(path4.join(dir, candidate)));
+  return candidates.some((candidate) => existsSync10(path11.join(dir, candidate)));
 }
 function firstExisting(dir, candidates) {
-  return candidates.find((candidate) => existsSync4(path4.join(dir, candidate))) ?? null;
+  return candidates.find((candidate) => existsSync10(path11.join(dir, candidate))) ?? null;
 }
 function compositionDir(dir) {
   return COMPOSITION_CANDIDATES.find((candidate) => {
-    const absolute = path4.join(dir, candidate);
-    return existsSync4(absolute) && readdirSync3(absolute).some((file) => file.endsWith(".yaml") || file.endsWith(".yml"));
+    const absolute = path11.join(dir, candidate);
+    return existsSync10(absolute) && readdirSync5(absolute).some((file) => file.endsWith(".yaml") || file.endsWith(".yml"));
   }) ?? null;
 }
 function hasWorkflows(dir) {
-  const workflows = path4.join(dir, ".github", "workflows");
-  return existsSync4(workflows) && readdirSync3(workflows).some((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
+  const workflows = path11.join(dir, ".github", "workflows");
+  return existsSync10(workflows) && readdirSync5(workflows).some((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
 }
 function detectExisting(dir) {
   return {
-    packageJson: existsSync4(path4.join(dir, "package.json")),
-    tsconfig: existsSync4(path4.join(dir, "tsconfig.json")),
+    packageJson: existsSync10(path11.join(dir, "package.json")),
+    tsconfig: existsSync10(path11.join(dir, "tsconfig.json")),
     eslintConfig: anyExists(dir, ESLINT_CONFIGS),
     githubWorkflows: hasWorkflows(dir),
-    claudeMd: existsSync4(path4.join(dir, "CLAUDE.md")),
-    agentsMd: existsSync4(path4.join(dir, "AGENTS.md")),
-    cursorRules: existsSync4(path4.join(dir, ".cursor", "rules")),
+    claudeMd: existsSync10(path11.join(dir, "CLAUDE.md")),
+    agentsMd: existsSync10(path11.join(dir, "AGENTS.md")),
+    cursorRules: existsSync10(path11.join(dir, ".cursor", "rules")),
     openapi: firstExisting(dir, OPENAPI_CANDIDATES),
     compositionDir: compositionDir(dir),
-    constructJson: existsSync4(path4.join(dir, "construct.json"))
+    constructJson: existsSync10(path11.join(dir, "construct.json"))
   };
 }
 
 // src/detect/layout.ts
-import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import path5 from "path";
-var IGNORED_ENTRIES = /* @__PURE__ */ new Set([".git", ".DS_Store", ".gitignore", ".gitattributes", "LICENSE", "README.md", ".idea", ".vscode"]);
-function isEmptyDir(dir) {
-  if (!existsSync5(dir))
-    return true;
-  return readdirSync4(dir).every((entry) => IGNORED_ENTRIES.has(entry));
+import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
+import path13 from "path";
+
+// src/detect/workspaces.ts
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
+import path12 from "path";
+var TOP_LEVEL_PACKAGES_KEY = /^packages:(.*)$/m;
+var EMPTY_FLOW_SEQUENCE = /^\[\s*\]$/;
+var BLOCK_SEQUENCE_ENTRY = /^[ \t]+-[ \t]*\S/;
+function readIfPresent(file) {
+  if (!existsSync11(file))
+    return null;
+  try {
+    return readFileSync11(file, "utf8");
+  } catch {
+    return null;
+  }
 }
-function hasWorkspacesField(dir) {
-  const manifest = path5.join(dir, "package.json");
-  if (!existsSync5(manifest))
+function startsBlockSequence(rest) {
+  for (const line of rest.split("\n")) {
+    if (line.trim() === "" || line.trimStart().startsWith("#"))
+      continue;
+    return BLOCK_SEQUENCE_ENTRY.test(line);
+  }
+  return false;
+}
+function declaresPnpmPackages(dir) {
+  const content = readIfPresent(path12.join(dir, "pnpm-workspace.yaml"));
+  if (content == null)
+    return false;
+  const match = TOP_LEVEL_PACKAGES_KEY.exec(content);
+  if (match == null)
     return false;
+  const inline = match[1].trim();
+  if (inline.startsWith("["))
+    return !EMPTY_FLOW_SEQUENCE.test(inline);
+  if (inline !== "")
+    return false;
+  return startsBlockSequence(content.slice(match.index + match[0].length));
+}
+function declaresNpmWorkspaces(dir) {
+  const content = readIfPresent(path12.join(dir, "package.json"));
+  if (content == null)
+    return false;
+  let workspaces;
   try {
-    const parsed = JSON.parse(readFileSync4(manifest, "utf8"));
-    return parsed.workspaces != null;
+    ({ workspaces } = JSON.parse(content));
   } catch {
     return false;
   }
+  if (Array.isArray(workspaces))
+    return workspaces.length > 0;
+  const packages = workspaces?.packages;
+  return Array.isArray(packages) && packages.length > 0;
+}
+
+// src/detect/layout.ts
+var IGNORED_ENTRIES = /* @__PURE__ */ new Set([".git", ".DS_Store", ".gitignore", ".gitattributes", "LICENSE", "README.md", ".idea", ".vscode"]);
+function isEmptyDir(dir) {
+  if (!existsSync12(dir))
+    return true;
+  return readdirSync6(dir).every((entry) => IGNORED_ENTRIES.has(entry));
 }
 function detectMonorepoTools(dir) {
   const tools = [];
-  if (existsSync5(path5.join(dir, "pnpm-workspace.yaml")))
+  if (declaresPnpmPackages(dir))
     tools.push("pnpm-workspace");
-  if (hasWorkspacesField(dir))
+  if (declaresNpmWorkspaces(dir))
     tools.push("npm-workspaces");
-  if (existsSync5(path5.join(dir, "turbo.json")))
+  if (existsSync12(path13.join(dir, "turbo.json")))
     tools.push("turbo");
-  if (existsSync5(path5.join(dir, "nx.json")))
+  if (existsSync12(path13.join(dir, "nx.json")))
     tools.push("nx");
   return tools;
 }
 function detectWorkspaceDirs(dir) {
-  return ["apps", "packages", "libs", "services"].filter((name) => existsSync5(path5.join(dir, name)) && statSync2(path5.join(dir, name)).isDirectory());
+  return ["apps", "packages", "libs", "services"].filter((name) => existsSync12(path13.join(dir, name)) && statSync3(path13.join(dir, name)).isDirectory());
 }
 function packageName(dir) {
   try {
-    const parsed = JSON.parse(readFileSync4(path5.join(dir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync12(path13.join(dir, "package.json"), "utf8"));
     return typeof parsed.name === "string" && parsed.name !== "" ? parsed.name : null;
   } catch {
     return null;
   }
 }
 function detectWorkspacePackages(root, workspaceDirs) {
-  return workspaceDirs.flatMap((parent) => readdirSync4(path5.join(root, parent)).sort().map((entry) => `${parent}/${entry}`).filter((dir) => existsSync5(path5.join(root, dir, "package.json"))).map((dir) => ({ dir, name: packageName(path5.join(root, dir)) ?? dir.split("/").at(-1) ?? dir })));
+  return workspaceDirs.flatMap((parent) => readdirSync6(path13.join(root, parent)).sort().map((entry) => `${parent}/${entry}`).filter((dir) => existsSync12(path13.join(root, dir, "package.json"))).map((dir) => ({ dir, name: packageName(path13.join(root, dir)) ?? dir.split("/").at(-1) ?? dir })));
 }
 function detectLayout(dir, monorepoTools, workspaceDirs, hasSrc) {
   if (isEmptyDir(dir))
     return "empty";
   if (monorepoTools.length > 0 || workspaceDirs.length > 0)
     return "monorepo";
-  if (hasSrc || existsSync5(path5.join(dir, "package.json")))
+  if (hasSrc || existsSync12(path13.join(dir, "package.json")))
     return "single";
   return "unknown";
 }
 
 // src/detect/package-manager.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
+import path14 from "path";
 var LOCKFILES = [
   ["pnpm-lock.yaml", "pnpm"],
   ["bun.lockb", "bun"],
@@ -381,11 +1181,11 @@ var LOCKFILES = [
   ["package-lock.json", "npm"]
 ];
 function fromPackageManagerField(dir) {
-  const manifest = path6.join(dir, "package.json");
-  if (!existsSync6(manifest))
+  const manifest = path14.join(dir, "package.json");
+  if (!existsSync13(manifest))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync5(manifest, "utf8"));
+    const parsed = JSON.parse(readFileSync13(manifest, "utf8"));
     const name = parsed.packageManager?.split("@")[0];
     return name === "pnpm" || name === "npm" || name === "yarn" || name === "bun" ? name : null;
   } catch {
@@ -397,10 +1197,10 @@ function detectPackageManager(dir) {
   if (declared != null)
     return declared;
   for (const [lockfile, manager] of LOCKFILES) {
-    if (existsSync6(path6.join(dir, lockfile)))
+    if (existsSync13(path14.join(dir, lockfile)))
       return manager;
   }
-  return existsSync6(path6.join(dir, "package.json")) ? "npm" : "none";
+  return existsSync13(path14.join(dir, "package.json")) ? "npm" : "none";
 }
 var pnpmVersionCache;
 function detectPnpmVersion() {
@@ -416,10 +1216,10 @@ function detectPnpmVersion() {
 
 // src/detect/index.ts
 function detect(dir) {
-  const root = path7.resolve(dir);
+  const root = path15.resolve(dir);
   const monorepoTools = detectMonorepoTools(root);
   const workspaceDirs = detectWorkspaceDirs(root);
-  const hasSrc = existsSync7(path7.join(root, "src"));
+  const hasSrc = existsSync14(path15.join(root, "src"));
   return {
     dir: root,
     packageManager: detectPackageManager(root),
@@ -429,21 +1229,21 @@ function detect(dir) {
     workspaceDirs,
     workspacePackages: detectWorkspacePackages(root, workspaceDirs),
     hasSrc,
-    nodeMajor: Number(process.versions.node.split(".")[0]),
+    nodeMajor: Number(process3.versions.node.split(".")[0]),
     existing: detectExisting(root)
   };
 }
 
 // src/materialize/apply.ts
 import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
-import path8 from "path";
+import path16 from "path";
 function applyPlan(root, ops) {
   const written = [];
   for (const op of ops) {
     if (op.action === "skip")
       continue;
-    const absolute = path8.join(root, op.target);
-    mkdirSync(path8.dirname(absolute), { recursive: true });
+    const absolute = path16.join(root, op.target);
+    mkdirSync(path16.dirname(absolute), { recursive: true });
     writeFileSync2(absolute, op.content);
     written.push(op);
   }
@@ -451,8 +1251,8 @@ function applyPlan(root, ops) {
 }
 
 // src/materialize/plan.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
-import path10 from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
+import path18 from "path";
 
 // src/materialize/rules.ts
 var CLAUDE_RULES_DIR = ".claude/rules/";
@@ -614,43 +1414,43 @@ ${end}
 }
 
 // src/materialize/templates.ts
-import { existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
-import path9 from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
+import path17 from "path";
 import { fileURLToPath } from "url";
-var HERE = path9.dirname(fileURLToPath(import.meta.url));
+var HERE = path17.dirname(fileURLToPath(import.meta.url));
 function templatesRoot() {
-  const candidates = [path9.resolve(HERE, "../templates"), path9.resolve(HERE, "../../templates")];
-  const found = candidates.find((candidate) => existsSync8(candidate));
+  const candidates = [path17.resolve(HERE, "../templates"), path17.resolve(HERE, "../../templates")];
+  const found = candidates.find((candidate) => existsSync15(candidate));
   if (found == null)
     throw new Error(`templates directory not found next to ${HERE}`);
   return found;
 }
 var EXISTING_SUFFIX = ".existing.eta";
 function toTargetPath(relative) {
-  const segments = relative.split(path9.sep).map((segment) => segment.startsWith("_") ? `.${segment.slice(1)}` : segment);
+  const segments = relative.split(path17.sep).map((segment) => segment.startsWith("_") ? `.${segment.slice(1)}` : segment);
   const joined = segments.join("/");
   if (joined.endsWith(EXISTING_SUFFIX))
     return { target: joined.slice(0, -EXISTING_SUFFIX.length), rendered: true, variant: "existing" };
   return joined.endsWith(".eta") ? { target: joined.slice(0, -".eta".length), rendered: true, variant: "default" } : { target: joined, rendered: false, variant: "default" };
 }
 function walk(root, current, files) {
-  for (const entry of readdirSync5(current).sort()) {
-    const absolute = path9.join(current, entry);
-    if (statSync3(absolute).isDirectory())
+  for (const entry of readdirSync7(current).sort()) {
+    const absolute = path17.join(current, entry);
+    if (statSync4(absolute).isDirectory())
       walk(root, absolute, files);
     else if (entry !== ".DS_Store")
-      files.push(path9.relative(root, absolute));
+      files.push(path17.relative(root, absolute));
   }
 }
 function listTemplateFiles(group) {
-  const root = path9.join(templatesRoot(), group);
-  if (!existsSync8(root))
+  const root = path17.join(templatesRoot(), group);
+  if (!existsSync15(root))
     throw new Error(`template group "${group}" does not exist`);
   const files = [];
   walk(root, root, files);
   return files.map((relative) => {
     const { target, rendered, variant } = toTargetPath(relative);
-    return { group, source: path9.join(root, relative), target, rendered, variant };
+    return { group, source: path17.join(root, relative), target, rendered, variant };
   });
 }
 var BLOCK = /^[ \t]*\{\{#(if|unless) (\w+)\}\}[ \t]*\n([\s\S]*?)^[ \t]*\{\{\/\1\}\}[ \t]*\n/gm;
@@ -677,7 +1477,7 @@ function mountTarget(mount, target) {
   return mount.into == null || mount.into === "." ? target : `${mount.into.replace(/\/$/, "")}/${target}`;
 }
 function readTemplate(source, rendered, vars) {
-  const raw = readFileSync6(source, "utf8");
+  const raw = readFileSync14(source, "utf8");
   return rendered ? render(raw, vars) : raw;
 }
 var SORTED_SECTIONS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
@@ -735,12 +1535,12 @@ function layerJson(earlier, later) {
 var NOT_ADDED_TO_EXISTING_MANIFEST = ["version"];
 function planOne(root, target, content, conflicts, existingVariant) {
   const strategy = strategyFor(target);
-  const absolute = path10.join(root, target);
-  const exists = existsSync9(absolute);
+  const absolute = path18.join(root, target);
+  const exists = existsSync16(absolute);
   if (!exists)
     return { target, strategy, action: "create", content: strategy === "append-block" ? appendBlock("", content, target) : content };
   if (strategy === "merge-json") {
-    const existing = JSON.parse(readFileSync6(absolute, "utf8"));
+    const existing = JSON.parse(readFileSync14(absolute, "utf8"));
     const incoming = JSON.parse(content);
     for (const key of NOT_ADDED_TO_EXISTING_MANIFEST)
       delete incoming[key];
@@ -751,7 +1551,7 @@ function planOne(root, target, content, conflicts, existingVariant) {
 ` };
   }
   if (strategy === "append-block") {
-    const existing = readFileSync6(absolute, "utf8");
+    const existing = readFileSync14(absolute, "utf8");
     return { target, strategy, action: "append", content: appendBlock(existing, existingVariant ?? content, target) };
   }
   return { target, strategy, action: "skip", content, note: "exists, review manually" };
@@ -825,7 +1625,6 @@ var PRESETS = {
       HTTP_CONTRACT,
       { group: EXPRESS_APP, onlyWhenEmpty: true },
       { group: EXPRESS_REPO, onlyWhenEmpty: true },
-      { group: "presets/node-backend/sample", onlyWhenEmpty: true },
       "presets/node-backend/baseline"
     ],
     contracts: true,
@@ -987,14 +1786,14 @@ function createClackPrompter(lore, streams = {}) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync7 } from "fs";
-import path11 from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import path19 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var HERE2 = path11.dirname(fileURLToPath2(import.meta.url));
+var HERE2 = path19.dirname(fileURLToPath2(import.meta.url));
 function readVersion() {
   for (const candidate of ["../package.json", "../../package.json"]) {
     try {
-      const parsed = JSON.parse(readFileSync7(path11.resolve(HERE2, candidate), "utf8"));
+      const parsed = JSON.parse(readFileSync15(path19.resolve(HERE2, candidate), "utf8"));
       if (parsed.name === "mikoshi-construct" && parsed.version != null)
         return parsed.version;
     } catch {
@@ -1094,7 +1893,7 @@ async function askChoices(ui2, options, report, root, prompter) {
   return { presetId, ai, projectName, review };
 }
 async function runInit(ui2, options, prompter) {
-  const root = path12.resolve(options.dir);
+  const root = path20.resolve(options.dir);
   mkdirSync2(root, { recursive: true });
   if (!options.yes && prompter == null) {
     ui2.glitch(ui2.lore.needsTerminal);
@@ -1182,7 +1981,7 @@ async function runInit(ui2, options, prompter) {
 }
 
 // src/ui/console.ts
-import process2 from "process";
+import process4 from "process";
 
 // src/ui/lore.ts
 var BANNER = String.raw`
@@ -1220,12 +2019,34 @@ var LORE = {
   flatlined: "FLATLINED",
   stable: "CONSTRUCT STABLE",
   discoveryIncomplete: "Discovery incomplete.",
+  provenance: "AUTHORSHIP TRACE",
+  stillConstructAuthored: (count) => `Still the construct's own words: ${count} marker${count === 1 ? "" : "s"} nobody has stood behind yet.`,
+  enforcement: "ENFORCEMENT TRACE",
+  typecheckCaveat: "Typecheck cannot carry this stack alone.",
+  weakestLink: (id, level) => `WEAKEST LINK: ${id} at ${level}`,
+  levelLift: {
+    L0: "wire it to a hook or a workflow step and it climbs",
+    L1: "only a reviewer stands behind it; a hook or a workflow step raises it",
+    L2: "a hook is bypassable with --no-verify; running it in CI too raises it",
+    L3: "L3 is the ceiling doctor can read: branch protection is what makes it blocking, and that lives in the API",
+    L4: "nothing above this"
+  },
+  weakestLinkNone: "WEAKEST LINK: nothing is claimed",
   wireHarness: "Existing configs were kept, so the harness is not wired in yet. /construct-discover does this first; by hand:",
   wireHarnessSteps: [
     "eslint: ignore scripts/construct/*.workflow.mjs (the ladder script uses top-level return)",
     "tsconfig: include scripts/**/*.ts; vitest: include scripts/tests/**/*.test.ts",
     "package.json: make the quality script run composition:check (and contracts:check when there is a contract)"
-  ]
+  ],
+  costUnsupported: (runtime) => `No usage feed: the ${runtime} runtime does not expose per-run token usage.`,
+  costEmpty: "No /implement runs recorded here yet.",
+  costKeyMismatch: (key) => `Runs for this repository were recorded under another path. Looked up: ${key}`,
+  costKeyUnknown: (key) => `Runs may be recorded under another path \u2014 the evidence is not conclusive. Looked up: ${key}`,
+  ledgerCounts: (runs, agents, failures, tokens2) => `Ledger, kept by hand and trusted by nobody: ${runs} runs, ${agents} agents, ${failures} unfinished, ${tokens2} tokens.`,
+  ledgerMalformed: (count) => `${count} ledger line${count === 1 ? "" : "s"} could not be read as a run record.`,
+  ledgerDrift: (entriesWithoutSession, sessionsWithoutEntry, unjoinable) => `Ledger against the traces it claims: ${entriesWithoutSession} entries with no session, ${sessionsWithoutEntry} sessions with no entry, ${unjoinable} entries with no run id.`,
+  ledgerEntryWithoutSession: "logged as a run, no session behind it",
+  ledgerSessionWithoutEntry: "ran, never logged"
 };
 var PLAIN_LORE = {
   subtitle: (version) => `mikoshi-construct v${version}`,
@@ -1255,17 +2076,39 @@ var PLAIN_LORE = {
   flatlined: "ERROR",
   stable: "OK",
   discoveryIncomplete: "Discovery incomplete.",
+  provenance: "Discovery provenance",
+  stillConstructAuthored: (count) => `Unchanged since discovery wrote them: ${count} marker${count === 1 ? "" : "s"} nobody has stood behind yet.`,
+  enforcement: "Enforcement",
+  typecheckCaveat: "Typecheck cannot carry this stack alone.",
+  weakestLink: (id, level) => `Weakest link: ${id} at ${level}`,
+  levelLift: {
+    L0: "wire it to a hook or a workflow step and it climbs",
+    L1: "only a reviewer stands behind it; a hook or a workflow step raises it",
+    L2: "a hook is bypassable with --no-verify; running it in CI too raises it",
+    L3: "L3 is the ceiling doctor can read: branch protection is what makes it blocking, and that lives in the API",
+    L4: "nothing above this"
+  },
+  weakestLinkNone: "Weakest link: nothing is claimed",
   wireHarness: "Existing configs were kept, so the harness is not wired in yet. /construct-discover does this first; by hand:",
   wireHarnessSteps: [
     "eslint: ignore scripts/construct/*.workflow.mjs (the ladder script uses top-level return)",
     "tsconfig: include scripts/**/*.ts; vitest: include scripts/tests/**/*.test.ts",
     "package.json: make the quality script run composition:check (and contracts:check when there is a contract)"
-  ]
+  ],
+  costUnsupported: (runtime) => `The ${runtime} runtime does not expose per-run token usage.`,
+  costEmpty: "No /implement runs recorded here yet.",
+  costKeyMismatch: (key) => `Runs for this repository were recorded under another path. Looked up: ${key}`,
+  costKeyUnknown: (key) => `Runs may be recorded under another path \u2014 the evidence is not conclusive. Looked up: ${key}`,
+  ledgerCounts: (runs, agents, failures, tokens2) => `Ledger (a skill step writes it, nothing enforces it): ${runs} runs, ${agents} agents, ${failures} unfinished, ${tokens2} tokens.`,
+  ledgerMalformed: (count) => `${count} ledger line${count === 1 ? "" : "s"} could not be read as a run record.`,
+  ledgerDrift: (entriesWithoutSession, sessionsWithoutEntry, unjoinable) => `Ledger against the runtime: ${entriesWithoutSession} entries with no session, ${sessionsWithoutEntry} sessions with no entry, ${unjoinable} entries with no run id.`,
+  ledgerEntryWithoutSession: "logged as a run, no session behind it",
+  ledgerSessionWithoutEntry: "ran, never logged"
 };
 
 // src/ui/console.ts
 var stdoutWriter = (text2) => {
-  process2.stdout.write(text2);
+  process4.stdout.write(text2);
 };
 function createUi(theme, write = stdoutWriter) {
   const plain = theme.name === "plain";
@@ -1324,21 +2167,21 @@ function createUi(theme, write = stdoutWriter) {
 }
 
 // src/ui/theme.ts
-import process3 from "process";
+import process5 from "process";
 import pc from "picocolors";
 function rgb(r, g, b) {
   return (text2) => `\x1B[38;2;${r};${g};${b}m${text2}\x1B[39m`;
 }
 var identity = (text2) => text2;
 function supportsColor() {
-  if (process3.env.NO_COLOR != null && process3.env.NO_COLOR !== "")
+  if (process5.env.NO_COLOR != null && process5.env.NO_COLOR !== "")
     return false;
-  if (process3.env.FORCE_COLOR != null && process3.env.FORCE_COLOR !== "0")
+  if (process5.env.FORCE_COLOR != null && process5.env.FORCE_COLOR !== "0")
     return true;
   return pc.isColorSupported;
 }
 function truecolor() {
-  const term = process3.env.COLORTERM ?? "";
+  const term = process5.env.COLORTERM ?? "";
   return term === "truecolor" || term === "24bit";
 }
 var PLAIN = {
@@ -1407,12 +2250,12 @@ var init = defineCommand({
     const console = ui(args);
     console.banner(VERSION, args.johnny);
     try {
-      const prompter = isTTY(process4.stdout) && process4.stdin.isTTY === true ? createClackPrompter(console.lore) : void 0;
+      const prompter = isTTY(process6.stdout) && process6.stdin.isTTY === true ? createClackPrompter(console.lore) : void 0;
       const result = await runInit(console, { dir: args.dir, preset: args.preset, ai: args.ai, name: args.name, review: args.review, reviewModel: args.reviewModel, yes: args.yes, dryRun: args.dryRun }, prompter);
-      process4.exitCode = result.status === "aborted" ? 1 : 0;
+      process6.exitCode = result.status === "aborted" ? 1 : 0;
     } catch (error) {
       console.flatline(error instanceof Error ? error.message : String(error));
-      process4.exitCode = 1;
+      process6.exitCode = 1;
     }
   }
 });
@@ -1425,7 +2268,7 @@ var soulkill = defineCommand({
   run({ args }) {
     const report = detect(args.dir);
     if (args.json) {
-      process4.stdout.write(`${JSON.stringify(report, null, 2)}
+      process6.stdout.write(`${JSON.stringify(report, null, 2)}
 `);
       return;
     }
@@ -1445,13 +2288,13 @@ var doctor = defineCommand({
   run({ args }) {
     const result = runDoctor(args.dir);
     if (args.json) {
-      process4.stdout.write(`${JSON.stringify(result, null, 2)}
+      process6.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
-      process4.exitCode = result?.ok === true ? 0 : 1;
+      process6.exitCode = result?.ok === true ? 0 : 1;
       return;
     }
     const console = ui(args);
-    process4.exitCode = printDoctor(console, result);
+    process6.exitCode = printDoctor(console, result);
   }
 });
 var cost = defineCommand({
@@ -1462,16 +2305,14 @@ var cost = defineCommand({
     json: { type: "boolean", description: "Machine-readable report", default: false }
   },
   run({ args }) {
-    const runs = collectWorkflowRuns(path13.resolve(args.dir));
+    const report = costReport(path21.resolve(args.dir));
     if (args.json) {
-      const selected = runs == null ? null : args.last ? runs.slice(-1) : runs;
-      process4.stdout.write(`${JSON.stringify(selected, null, 2)}
+      process6.stdout.write(`${JSON.stringify(costJson(report, args.last), null, 2)}
 `);
-      process4.exitCode = runs == null ? 1 : 0;
+      process6.exitCode = COST_EXIT[report.status];
       return;
     }
-    const console = ui(args);
-    process4.exitCode = printCost(console, runs, args.last);
+    process6.exitCode = printCost(ui(args), report, args.last);
   }
 });
 var main = defineCommand({