mikoshi-construct 0.1.3 → 0.3.0

package/dist/cli.js

@@ -1,22 +1,27 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path14 from "path";
-import process4 from "process";
+import path22 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,221 @@ 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 existsSync4, readFileSync as readFileSync3, writeFileSync } from "fs";
+import path4 from "path";
+
+// src/detect/existing.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
+import path3 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 DEFAULT_COMPOSITION_DIR = "architecture/composition";
+var COMPOSITION_CANDIDATES = [DEFAULT_COMPOSITION_DIR, "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) => existsSync3(path3.join(dir, candidate)));
+}
+function firstExisting(dir, candidates) {
+  return candidates.find((candidate) => existsSync3(path3.join(dir, candidate))) ?? null;
+}
+function compositionDir(dir) {
+  return COMPOSITION_CANDIDATES.find((candidate) => {
+    const absolute = path3.join(dir, candidate);
+    return existsSync3(absolute) && readdirSync2(absolute).some((file) => file.endsWith(".yaml") || file.endsWith(".yml"));
+  }) ?? null;
+}
+function hasWorkflows(dir) {
+  const workflows = path3.join(dir, ".github", "workflows");
+  return existsSync3(workflows) && readdirSync2(workflows).some((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
+}
+function detectExisting(dir) {
+  return {
+    packageJson: existsSync3(path3.join(dir, "package.json")),
+    tsconfig: existsSync3(path3.join(dir, "tsconfig.json")),
+    eslintConfig: anyExists(dir, ESLINT_CONFIGS),
+    githubWorkflows: hasWorkflows(dir),
+    claudeMd: existsSync3(path3.join(dir, "CLAUDE.md")),
+    agentsMd: existsSync3(path3.join(dir, "AGENTS.md")),
+    cursorRules: existsSync3(path3.join(dir, ".cursor", "rules")),
+    openapi: firstExisting(dir, OPENAPI_CANDIDATES),
+    compositionDir: compositionDir(dir),
+    constructJson: existsSync3(path3.join(dir, "construct.json"))
+  };
+}
+
+// src/manifest.ts
 var MANIFEST_FILE = "construct.json";
+var MANIFEST_VERSION = 4;
 var DISCOVERY_MARKERS = [
   "product",
   "module-map",
@@ -137,7 +317,7 @@ var DISCOVERY_MARKERS = [
 function sha256(content) {
   return createHash("sha256").update(content).digest("hex");
 }
-function markerFile(marker, compositionDir2 = "architecture/composition") {
+function markerFile(marker, compositionDir2) {
   switch (marker) {
     case "composition":
       return compositionDir2;
@@ -148,13 +328,19 @@ function markerFile(marker, compositionDir2 = "architecture/composition") {
   }
 }
 function buildManifest(input) {
-  const files = {};
+  const written = {};
   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)]));
+    written[op.target] = sha256(op.content);
+  const files = { ...input.previous?.files, ...written };
+  const markers = Object.fromEntries(DISCOVERY_MARKERS.map((marker) => [marker, {
+    file: markerFile(marker, input.vars.compositionDir),
+    authoredBy: "unknown",
+    sha: null
+  }]));
   return {
-    construct: input.version,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    manifestVersion: MANIFEST_VERSION,
+    construct: input.previous?.construct ?? input.version,
+    createdAt: input.previous?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     preset: input.preset,
     ai: input.ai,
     review: input.review === "none" ? null : { provider: input.review, model: input.vars.reviewModel },
@@ -163,21 +349,448 @@ function buildManifest(input) {
     contracts: input.contracts ? { path: input.vars.contractPath, types: input.vars.contractTypesOutput } : null,
     vars: input.vars,
     files,
-    discovery
+    variants: { ...input.previous?.variants, ...variantsOf(input.written) },
+    discovery: input.previous?.discovery ?? { baseSha: null, filledAt: null, markers },
+    sync: input.previous?.sync ?? null
+  };
+}
+function variantsOf(written) {
+  return Object.fromEntries(written.flatMap((op) => op.variant == null ? [] : [[op.target, op.variant]]));
+}
+function isTemplateVariant(value) {
+  return value === "default" || value === "existing";
+}
+function upgradeVariants(raw) {
+  const value = raw ?? {};
+  return Object.fromEntries(Object.entries(value).flatMap(([target, variant]) => isTemplateVariant(variant) ? [[target, variant]] : []));
+}
+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 upgradeSync(raw) {
+  const value = raw ?? {};
+  if (typeof value.ranAt !== "string" || typeof value.fromVersion !== "string" || typeof value.toVersion !== "string")
+    return null;
+  return {
+    ranAt: value.ranAt,
+    fromVersion: value.fromVersion,
+    toVersion: value.toVersion,
+    files: typeof value.files === "object" && value.files != null ? { ...value.files } : {},
+    variants: upgradeVariants(value.variants)
+  };
+}
+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 ?? DEFAULT_COMPOSITION_DIR))
+  ]));
+  return {
+    ...manifest,
+    manifestVersion: MANIFEST_VERSION,
+    variants: upgradeVariants(manifest.variants),
+    discovery: {
+      baseSha: typeof discovery.baseSha === "string" ? discovery.baseSha : null,
+      filledAt: typeof discovery.filledAt === "string" ? discovery.filledAt : null,
+      markers
+    },
+    sync: upgradeSync(manifest.sync)
+  };
+}
+function recordSync(manifest, run) {
+  return {
+    ...manifest,
+    sync: {
+      ranAt: run.ranAt,
+      fromVersion: manifest.construct,
+      toVersion: run.toVersion,
+      files: { ...manifest.sync?.files, ...run.files },
+      variants: { ...manifest.sync?.variants, ...run.variants }
+    }
   };
 }
+function recordedShas(manifest) {
+  return { ...manifest.files, ...manifest.sync?.files };
+}
+function recordedVariants(manifest) {
+  return { ...manifest.variants, ...manifest.sync?.variants };
+}
 function writeManifest(root, manifest) {
-  writeFileSync(path2.join(root, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  writeFileSync(path4.join(root, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
 `);
 }
 function readManifest(root) {
-  const file = path2.join(root, MANIFEST_FILE);
-  if (!existsSync2(file))
+  const file = path4.join(root, MANIFEST_FILE);
+  if (!existsSync4(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/version.ts
+import { readFileSync as readFileSync4 } from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+var HERE = path5.dirname(fileURLToPath(import.meta.url));
+function readVersion() {
+  for (const candidate of ["../package.json", "../../package.json"]) {
+    try {
+      const parsed = JSON.parse(readFileSync4(path5.resolve(HERE, candidate), "utf8"));
+      if (parsed.name === "mikoshi-construct" && parsed.version != null)
+        return parsed.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+var VERSION = readVersion();
+
+// src/commands/doctor/baseline.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import path6 from "path";
+function baselineVerdict(root, manifest) {
+  const missingFiles = [];
+  const modifiedFiles = [];
+  for (const [file, hash] of Object.entries(manifest.files)) {
+    const absolute = path6.join(root, file);
+    if (!existsSync5(absolute))
+      missingFiles.push(file);
+    else if (sha256(readFileSync5(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 existsSync6, readFileSync as readFileSync6 } from "fs";
+import path7 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) => existsSync6(path7.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 = readFileSync6(path7.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.ts
+// 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/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 existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
+import path8 from "path";
+
+// src/detect/facts.ts
+function factsTheRepositoryEstablishes(root) {
+  const existing = detectExisting(root);
+  return existing.compositionDir == null ? {} : { compositionDir: existing.compositionDir };
+}
+
+// src/commands/doctor/discovery.ts
 var DISCOVERY_PLACEHOLDER = "_Not discovered yet \u2014 run `/construct-discover`._";
 function markerOpen(marker) {
   return `<!-- construct:discover:${marker} -->`;
@@ -185,318 +798,279 @@ 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 (!existsSync7(directory))
+    return null;
+  const models = readdirSync3(directory).filter((file) => file.endsWith(".yaml")).sort();
+  if (models.length === 0)
+    return null;
+  return models.map((model) => `${model}
+${readFileSync7(path8.join(directory, model), "utf8")}`).join("\n");
+}
+function markerBody(root, marker, file) {
+  const location = path8.join(root, file);
+  if (marker === "composition")
+    return compositionBody(location);
+  if (!existsSync7(location))
+    return null;
+  return blockBody(readFileSync7(location, "utf8"), marker);
+}
+function markerFileFor(root, manifest, marker) {
+  const recordedFile = manifest.discovery.markers[marker].file;
+  if (marker !== "composition")
+    return recordedFile;
+  const decided = manifest.vars?.compositionDir;
+  if (decided != null && decided !== "")
+    return decided;
+  return factsTheRepositoryEstablishes(root).compositionDir ?? recordedFile;
+}
+function missingDiscovery(root, manifest) {
+  return DISCOVERY_MARKERS.filter((marker) => markerBody(root, marker, markerFileFor(root, manifest, marker)) == null);
+}
+
+// src/commands/doctor/evidence.ts
+import { readFileSync as readFileSync11 } from "fs";
+import path12 from "path";
+
+// src/commands/doctor/harness.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import path9 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 = path9.join(root, "package.json");
+  const packageJson = existsSync8(manifestPath) ? JSON.parse(readFileSync8(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) => !existsSync8(path9.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 existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync2 } from "fs";
+import path10 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 readFileSync9(path10.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 = path10.join(root, HUSKY_DIR);
+  if (!existsSync9(directory) || !statSync2(directory).isDirectory())
+    return [];
+  return readdirSync4(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) => existsSync9(path10.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 };
 }
-function printDoctor(ui2, result) {
-  if (result == null) {
-    ui2.flatline("No construct.json here. Run `construct init` first.");
-    return 1;
+
+// src/commands/doctor/workflows.ts
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync10 } from "fs";
+import path11 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"));
   }
-  if (result.harnessProblems.length > 0)
-    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) {
-    ui2.glitch(ui2.lore.discoveryIncomplete, ["", "Missing:", ...result.missingDiscovery.map((marker) => `  ${marker}`), "", "Run: claude \u2192 /construct-discover"]);
+  return steps;
+}
+function readWorkflowFacts(root, commandForms) {
+  const directory = path11.join(root, WORKFLOWS_DIR);
+  if (!existsSync10(directory))
+    return { directory: WORKFLOWS_DIR, files: [], harnessWorkflow: null, unreadable: [] };
+  const files = readdirSync5(directory).filter((file) => file.endsWith(".yml") || file.endsWith(".yaml")).sort();
+  const unreadable = [];
+  let harnessWorkflow = null;
+  for (const file of files) {
+    let source;
+    try {
+      source = readFileSync10(path11.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}`;
   }
-  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) {
-    ui2.ok(ui2.lore.stable);
-    return 0;
+  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 = readFileSync11(path12.join(root, file), "utf8");
+      if (LINT_POLICY_MARKERS.some((marker) => source.includes(marker)))
+        policyTests.push(file);
+    } catch {
+      unreadable.push(file);
+    }
   }
-  return 1;
+  return { harness, runner, workflows, hooks, recordedTests, policyTests, unreadable };
 }
 
-// src/commands/init.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import path13 from "path";
+// 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, markerFileFor(root, manifest, marker)))
+    };
+  });
+}
+function constructAuthored(readings) {
+  return readings.filter((reading) => reading.authorship === "construct");
+}
 
-// src/detect/index.ts
-import { existsSync as existsSync8 } from "fs";
-import path8 from "path";
-import process from "process";
-
-// src/detect/existing.ts
-import { existsSync as existsSync4, readdirSync as readdirSync3 } from "fs";
-import path4 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)));
-}
-function firstExisting(dir, candidates) {
-  return candidates.find((candidate) => existsSync4(path4.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"));
-  }) ?? null;
-}
-function hasWorkflows(dir) {
-  const workflows = path4.join(dir, ".github", "workflows");
-  return existsSync4(workflows) && readdirSync3(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")),
-    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")),
-    openapi: firstExisting(dir, OPENAPI_CANDIDATES),
-    compositionDir: compositionDir(dir),
-    constructJson: existsSync4(path4.join(dir, "construct.json"))
-  };
-}
-
-// src/detect/layout.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import path6 from "path";
-
-// src/detect/workspaces.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import path5 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 (!existsSync5(file))
-    return null;
-  try {
-    return readFileSync4(file, "utf8");
-  } catch {
-    return null;
-  }
-}
-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(path5.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(path5.join(dir, "package.json"));
-  if (content == null)
-    return false;
-  let workspaces;
-  try {
-    ({ 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 (!existsSync6(dir))
-    return true;
-  return readdirSync4(dir).every((entry) => IGNORED_ENTRIES.has(entry));
-}
-function detectMonorepoTools(dir) {
-  const tools = [];
-  if (declaresPnpmPackages(dir))
-    tools.push("pnpm-workspace");
-  if (declaresNpmWorkspaces(dir))
-    tools.push("npm-workspaces");
-  if (existsSync6(path6.join(dir, "turbo.json")))
-    tools.push("turbo");
-  if (existsSync6(path6.join(dir, "nx.json")))
-    tools.push("nx");
-  return tools;
-}
-function detectWorkspaceDirs(dir) {
-  return ["apps", "packages", "libs", "services"].filter((name) => existsSync6(path6.join(dir, name)) && statSync2(path6.join(dir, name)).isDirectory());
-}
-function packageName(dir) {
-  try {
-    const parsed = JSON.parse(readFileSync5(path6.join(dir, "package.json"), "utf8"));
-    return typeof parsed.name === "string" && parsed.name !== "" ? parsed.name : null;
-  } catch {
-    return null;
+// 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 detectWorkspacePackages(root, workspaceDirs) {
-  return workspaceDirs.flatMap((parent) => readdirSync4(path6.join(root, parent)).sort().map((entry) => `${parent}/${entry}`).filter((dir) => existsSync6(path6.join(root, dir, "package.json"))).map((dir) => ({ dir, name: packageName(path6.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 || existsSync6(path6.join(dir, "package.json")))
-    return "single";
-  return "unknown";
+};
+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/detect/package-manager.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import path7 from "path";
-var LOCKFILES = [
-  ["pnpm-lock.yaml", "pnpm"],
-  ["bun.lockb", "bun"],
-  ["bun.lock", "bun"],
-  ["yarn.lock", "yarn"],
-  ["package-lock.json", "npm"]
-];
-function fromPackageManagerField(dir) {
-  const manifest = path7.join(dir, "package.json");
-  if (!existsSync7(manifest))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync6(manifest, "utf8"));
-    const name = parsed.packageManager?.split("@")[0];
-    return name === "pnpm" || name === "npm" || name === "yarn" || name === "bun" ? name : null;
-  } catch {
+// 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;
-  }
-}
-function detectPackageManager(dir) {
-  const declared = fromPackageManagerField(dir);
-  if (declared != null)
-    return declared;
-  for (const [lockfile, manager] of LOCKFILES) {
-    if (existsSync7(path7.join(dir, lockfile)))
-      return manager;
-  }
-  return existsSync7(path7.join(dir, "package.json")) ? "npm" : "none";
-}
-var pnpmVersionCache;
-function detectPnpmVersion() {
-  if (pnpmVersionCache !== void 0)
-    return pnpmVersionCache;
-  try {
-    pnpmVersionCache = execFileSync("pnpm", ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
-  } catch {
-    pnpmVersionCache = null;
-  }
-  return pnpmVersionCache;
-}
-
-// src/detect/index.ts
-function detect(dir) {
-  const root = path8.resolve(dir);
-  const monorepoTools = detectMonorepoTools(root);
-  const workspaceDirs = detectWorkspaceDirs(root);
-  const hasSrc = existsSync8(path8.join(root, "src"));
-  return {
-    dir: root,
-    packageManager: detectPackageManager(root),
-    pnpmVersion: detectPnpmVersion(),
-    layout: detectLayout(root, monorepoTools, workspaceDirs, hasSrc),
-    monorepoTools,
-    workspaceDirs,
-    workspacePackages: detectWorkspacePackages(root, workspaceDirs),
-    hasSrc,
-    nodeMajor: Number(process.versions.node.split(".")[0]),
-    existing: detectExisting(root)
-  };
+  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/materialize/apply.ts
-import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
-import path9 from "path";
-function applyPlan(root, ops) {
-  const written = [];
-  for (const op of ops) {
-    if (op.action === "skip")
-      continue;
-    const absolute = path9.join(root, op.target);
-    mkdirSync(path9.dirname(absolute), { recursive: true });
-    writeFileSync2(absolute, op.content);
-    written.push(op);
-  }
-  return written;
-}
+// src/sync/replay.ts
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
+import { tmpdir } from "os";
+import path15 from "path";
 
 // src/materialize/plan.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
+import path14 from "path";
 
 // src/materialize/rules.ts
 var CLAUDE_RULES_DIR = ".claude/rules/";
@@ -593,7 +1167,7 @@ function strategyFor(target) {
     return "append-block";
   return "create";
 }
-function isObject(value) {
+function isJsonObject(value) {
   return typeof value === "object" && value != null && !Array.isArray(value);
 }
 function mergeJson(existing, incoming, conflicts, prefix = "") {
@@ -605,7 +1179,7 @@ function mergeJson(existing, incoming, conflicts, prefix = "") {
       continue;
     }
     const current = existing[key];
-    if (isObject(current) && isObject(value)) {
+    if (isJsonObject(current) && isJsonObject(value)) {
       result[key] = mergeJson(current, value, conflicts, at);
       continue;
     }
@@ -614,7 +1188,7 @@ function mergeJson(existing, incoming, conflicts, prefix = "") {
   }
   return result;
 }
-function markersFor(target) {
+function blockMarkers(target) {
   return target.endsWith(".gitignore") ? [GITIGNORE_BEGIN, GITIGNORE_END] : [BLOCK_BEGIN, BLOCK_END];
 }
 var DISCOVERY_OPEN = /<!-- construct:discover:([\w-]+) -->/g;
@@ -627,6 +1201,16 @@ function discoveryBlock(document, marker) {
     return null;
   return { start: start + open.length, end, body: document.slice(start + open.length, end) };
 }
+function withoutDiscoveryBodies(document) {
+  let result = document;
+  for (const [, marker] of document.matchAll(DISCOVERY_OPEN)) {
+    const block = discoveryBlock(result, marker);
+    if (block == null)
+      continue;
+    result = `${result.slice(0, block.start)}${result.slice(block.end)}`;
+  }
+  return result;
+}
 function preserveDiscovery(existing, incoming) {
   let result = incoming;
   for (const [, marker] of existing.matchAll(DISCOVERY_OPEN)) {
@@ -638,13 +1222,20 @@ function preserveDiscovery(existing, incoming) {
   }
   return result;
 }
+function substituteBlock(existing, produced, target) {
+  const [begin, end] = blockMarkers(target);
+  const opening = existing.indexOf(begin) + begin.length;
+  const closing = existing.indexOf(end);
+  const incoming = produced.slice(produced.indexOf(begin) + begin.length, produced.indexOf(end));
+  return `${existing.slice(0, opening)}${preserveDiscovery(existing, incoming)}${existing.slice(closing)}`;
+}
 function withoutSecondH1(existing, block) {
   if (existing.trim() === "" || !/^# /m.test(existing))
     return block;
   return block.replace(/^# (.*)$/m, "## $1");
 }
 function appendBlock(existing, block, target) {
-  const [begin, end] = markersFor(target);
+  const [begin, end] = blockMarkers(target);
   const wrapped = `${begin}
 ${preserveDiscovery(existing, withoutSecondH1(existing, block)).trimEnd()}
 ${end}
@@ -658,43 +1249,43 @@ ${end}
 }
 
 // src/materialize/templates.ts
-import { existsSync as existsSync9, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
-import path10 from "path";
-import { fileURLToPath } from "url";
-var HERE = path10.dirname(fileURLToPath(import.meta.url));
+import { existsSync as existsSync11, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
+import path13 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var HERE2 = path13.dirname(fileURLToPath2(import.meta.url));
 function templatesRoot() {
-  const candidates = [path10.resolve(HERE, "../templates"), path10.resolve(HERE, "../../templates")];
-  const found = candidates.find((candidate) => existsSync9(candidate));
+  const candidates = [path13.resolve(HERE2, "../templates"), path13.resolve(HERE2, "../../templates")];
+  const found = candidates.find((candidate) => existsSync11(candidate));
   if (found == null)
-    throw new Error(`templates directory not found next to ${HERE}`);
+    throw new Error(`templates directory not found next to ${HERE2}`);
   return found;
 }
 var EXISTING_SUFFIX = ".existing.eta";
 function toTargetPath(relative) {
-  const segments = relative.split(path10.sep).map((segment) => segment.startsWith("_") ? `.${segment.slice(1)}` : segment);
+  const segments = relative.split(path13.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 = path10.join(current, entry);
+  for (const entry of readdirSync6(current).sort()) {
+    const absolute = path13.join(current, entry);
     if (statSync3(absolute).isDirectory())
       walk(root, absolute, files);
     else if (entry !== ".DS_Store")
-      files.push(path10.relative(root, absolute));
+      files.push(path13.relative(root, absolute));
   }
 }
 function listTemplateFiles(group) {
-  const root = path10.join(templatesRoot(), group);
-  if (!existsSync9(root))
+  const root = path13.join(templatesRoot(), group);
+  if (!existsSync11(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: path10.join(root, relative), target, rendered, variant };
+    return { group, source: path13.join(root, relative), target, rendered, variant };
   });
 }
 var BLOCK = /^[ \t]*\{\{#(if|unless) (\w+)\}\}[ \t]*\n([\s\S]*?)^[ \t]*\{\{\/\1\}\}[ \t]*\n/gm;
@@ -721,7 +1312,7 @@ function mountTarget(mount, target) {
   return mount.into == null || mount.into === "." ? target : `${mount.into.replace(/\/$/, "")}/${target}`;
 }
 function readTemplate(source, rendered, vars) {
-  const raw = readFileSync7(source, "utf8");
+  const raw = readFileSync12(source, "utf8");
   return rendered ? render(raw, vars) : raw;
 }
 var SORTED_SECTIONS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
@@ -779,12 +1370,13 @@ function layerJson(earlier, later) {
 var NOT_ADDED_TO_EXISTING_MANIFEST = ["version"];
 function planOne(root, target, content, conflicts, existingVariant) {
   const strategy = strategyFor(target);
-  const absolute = path11.join(root, target);
-  const exists = existsSync10(absolute);
-  if (!exists)
-    return { target, strategy, action: "create", content: strategy === "append-block" ? appendBlock("", content, target) : content };
+  const absolute = path14.join(root, target);
+  const exists = existsSync12(absolute);
+  if (!exists) {
+    return strategy === "append-block" ? { target, strategy, action: "create", content: appendBlock("", content, target), variant: "default" } : { target, strategy, action: "create", content };
+  }
   if (strategy === "merge-json") {
-    const existing = JSON.parse(readFileSync7(absolute, "utf8"));
+    const existing = JSON.parse(readFileSync12(absolute, "utf8"));
     const incoming = JSON.parse(content);
     for (const key of NOT_ADDED_TO_EXISTING_MANIFEST)
       delete incoming[key];
@@ -795,8 +1387,14 @@ function planOne(root, target, content, conflicts, existingVariant) {
 ` };
   }
   if (strategy === "append-block") {
-    const existing = readFileSync7(absolute, "utf8");
-    return { target, strategy, action: "append", content: appendBlock(existing, existingVariant ?? content, target) };
+    const existing = readFileSync12(absolute, "utf8");
+    return {
+      target,
+      strategy,
+      action: "append",
+      content: appendBlock(existing, existingVariant ?? content, target),
+      variant: existingVariant == null ? "default" : "existing"
+    };
   }
   return { target, strategy, action: "skip", content, note: "exists, review manually" };
 }
@@ -821,143 +1419,743 @@ function planMaterialize(root, groups, vars, options) {
       layered.set(target, previous == null || strategyFor(target) !== "merge-json" ? content : layerJson(previous, content));
     }
   }
-  const ops = [...mapRulesForTargets(layered, options.ai).entries()].map(([target, content]) => planOne(root, target, content, conflicts, existingVariants.get(target))).sort((a, b) => a.target.localeCompare(b.target));
-  return { ops, conflicts, omittedGroups };
-}
-
-// src/presets/index.ts
-var AI_TARGET_LABELS = {
-  claude: "Claude Code",
-  cursor: "Cursor",
-  both: "Claude Code, Cursor"
-};
-var EXPRESS_APP = "stacks/express-api/app";
-var EXPRESS_REPO = "stacks/express-api/repo";
-var HTTP_CONTRACT = "stacks/http-contract";
-function sampleWorkspace(scope) {
-  return [
-    { dir: "packages/shared", name: `${scope}/shared` },
-    { dir: "apps/api", name: `${scope}/api` }
-  ];
+  const ops = [...mapRulesForTargets(layered, options.ai).entries()].map(([target, content]) => planOne(root, target, content, conflicts, existingVariants.get(target))).sort((a, b) => a.target.localeCompare(b.target));
+  return { ops, conflicts, omittedGroups, existingVariants: Object.fromEntries(existingVariants) };
+}
+
+// src/presets/index.ts
+var AI_TARGET_LABELS = {
+  claude: "Claude Code",
+  cursor: "Cursor",
+  both: "Claude Code, Cursor"
+};
+var EXPRESS_APP = "stacks/express-api/app";
+var EXPRESS_REPO = "stacks/express-api/repo";
+var HTTP_CONTRACT = "stacks/http-contract";
+function sampleWorkspace(scope) {
+  return [
+    { dir: "packages/shared", name: `${scope}/shared` },
+    { dir: "apps/api", name: `${scope}/api` }
+  ];
+}
+function quote(value) {
+  return `'${value}'`;
+}
+function renderWorkspacePolicy(packages, sample) {
+  const names = packages.map((pkg) => pkg.name);
+  const allowedFor = (pkg) => {
+    if (sample)
+      return pkg.dir.startsWith("apps/") ? names.filter((name) => name !== pkg.name) : [];
+    return names.filter((name) => name !== pkg.name);
+  };
+  const lines = packages.map((pkg) => `  ${quote(pkg.dir)}: [${allowedFor(pkg).map(quote).join(", ")}],`);
+  return {
+    workspacePackages: `[${names.map(quote).join(", ")}]`,
+    allowedWorkspaceImports: `{
+${lines.join("\n")}
+}`
+  };
+}
+var PRESETS = {
+  "node-backend": {
+    id: "node-backend",
+    label: "Node.js backend",
+    description: "Express + TypeScript, contract-first HTTP API, composition root, harness",
+    groups: [
+      "base",
+      "harness",
+      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,
+    available: true,
+    vars: () => ({
+      contractPath: "contracts/api/openapi.yaml",
+      contractTypesOutput: "src/contracts/openapi.ts",
+      contractTypesImport: "./openapi.js",
+      contractPathFromConfig: "../contracts/api/openapi.yaml",
+      appRoot: ""
+    })
+  },
+  "node-frontend": {
+    id: "node-frontend",
+    label: "Node.js frontend",
+    description: "Vite + TypeScript, platform CSS rules, composition root, harness; no API contract",
+    groups: [
+      "base",
+      "harness",
+      { group: "presets/node-frontend/sample", onlyWhenEmpty: true },
+      "presets/node-frontend/baseline"
+    ],
+    contracts: false,
+    available: true,
+    vars: () => ({
+      contractPath: "",
+      contractTypesOutput: ""
+    })
+  },
+  "node-library": {
+    id: "node-library",
+    label: "Node.js library or CLI",
+    description: "TypeScript package with no HTTP contract: architecture policy, composition models, harness",
+    groups: ["base", "harness"],
+    contracts: false,
+    available: true,
+    vars: () => ({
+      contractPath: "",
+      contractTypesOutput: ""
+    })
+  },
+  "monorepo": {
+    id: "monorepo",
+    label: "pnpm monorepo",
+    description: "apps/* + packages/*, catalog:, contract types in packages/shared, dependency policy in lint",
+    groups: [
+      "base",
+      "harness",
+      HTTP_CONTRACT,
+      { group: EXPRESS_APP, into: "apps/api", onlyWhenEmpty: true },
+      { group: EXPRESS_REPO, onlyWhenEmpty: true },
+      { group: "presets/monorepo/sample", onlyWhenEmpty: true },
+      "presets/monorepo/baseline"
+    ],
+    contracts: true,
+    available: true,
+    vars: (report, projectName) => {
+      const detected = report.workspacePackages;
+      const packages = detected.length > 0 ? detected : sampleWorkspace(`@${projectName}`);
+      return {
+        contractPath: "contracts/api/openapi.yaml",
+        contractTypesOutput: "packages/shared/src/api/openapi.ts",
+        contractTypesImport: `@${projectName}/shared`,
+        contractPathFromConfig: "../../../contracts/api/openapi.yaml",
+        appRoot: "apps/api/",
+        ...renderWorkspacePolicy(packages, detected.length === 0)
+      };
+    }
+  }
+};
+var PRESET_IDS = Object.keys(PRESETS);
+var PRESET_LIST = Object.values(PRESETS);
+function isPresetId(value) {
+  return value in PRESETS;
+}
+function getPreset(id) {
+  return PRESETS[id];
+}
+function aiGroups(target) {
+  return target === "both" ? ["ai/shared", "ai/claude", "ai/cursor"] : ["ai/shared", `ai/${target}`];
+}
+var DEFAULT_REVIEW_MODEL = "claude-sonnet-5";
+function reviewGroups(provider) {
+  return provider === "claude" ? ["ai/review"] : [];
+}
+function defaultProjectName(dir) {
+  const base = dir.split(/[\\/]/).filter(Boolean).at(-1) ?? "project";
+  return base.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+}
+
+// src/sync/ownership.ts
+function ownedText(target, content) {
+  if (strategyFor(target) !== "append-block")
+    return content;
+  if (!carriesConstructBlock(target, content))
+    return "";
+  const [begin, end] = blockMarkers(target);
+  return withoutDiscoveryBodies(content.slice(content.indexOf(begin) + begin.length, content.indexOf(end)));
+}
+function blockSpansDocument(target, content) {
+  const [begin, end] = blockMarkers(target);
+  const before = content.slice(0, content.indexOf(begin));
+  const after = content.slice(content.indexOf(end) + end.length);
+  return `${before}${after}`.trim() === "";
+}
+function carriesConstructBlock(target, content) {
+  const [begin, end] = blockMarkers(target);
+  const start = content.indexOf(begin);
+  const stop = content.indexOf(end);
+  return start !== -1 && stop > start;
+}
+function ownedSha(target, content) {
+  return sha256(ownedText(target, content));
+}
+function matchesRecordedSha(recorded, target, content) {
+  const asOwnedViewWrittenBySync = ownedSha(target, content);
+  const asWholeFileWrittenByInit = sha256(content);
+  return recorded === asOwnedViewWrittenBySync || recorded === asWholeFileWrittenByInit;
+}
+function parseObject(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return isJsonObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function compareKeys(present, produced, prefix) {
+  const owned = [];
+  for (const [key, value] of Object.entries(produced)) {
+    const at = prefix === "" ? key : `${prefix}.${key}`;
+    if (!(key in present)) {
+      owned.push({ key: at, class: "add" });
+      continue;
+    }
+    const current = present[key];
+    if (isJsonObject(current) && isJsonObject(value)) {
+      owned.push(...compareKeys(current, value, at));
+      continue;
+    }
+    owned.push({ key: at, class: JSON.stringify(current) === JSON.stringify(value) ? "keep" : "conflict" });
+  }
+  return owned;
+}
+function ownedKeys(present, produced) {
+  const current = parseObject(present);
+  const template = parseObject(produced);
+  if (current == null || template == null)
+    return null;
+  return compareKeys(current, template, "");
+}
+
+// src/sync/classify.ts
+var PATH_CLASSES = ["add", "keep", "update", "conflict", "unknown", "removed", "orphaned", "foreign"];
+var BLOCK_REPLACED_WHOLE_DISCOVERY_BODIES_CARRIED_OVER = "block-replaced-whole-discovery-bodies-carried-over";
+function classFromKeys(keys) {
+  if (keys.some((key) => key.class === "conflict"))
+    return "conflict";
+  return keys.some((key) => key.class === "add") ? "update" : "keep";
+}
+function compareDeclaredBlock(target, present, produced, variant) {
+  if (!carriesConstructBlock(target, present))
+    return "conflict";
+  if (variant == null)
+    return "unknown";
+  return ownedText(target, present) === ownedText(target, produced) ? "keep" : "update";
+}
+function shapeSuggests(target, present) {
+  return blockSpansDocument(target, present) ? "default" : "existing";
+}
+function compareOwnedView(target, recordedSha, present, produced) {
+  if (ownedText(target, present) === ownedText(target, produced))
+    return "keep";
+  if (matchesRecordedSha(recordedSha, target, present))
+    return "update";
+  return "conflict";
+}
+function classifyPath(state) {
+  const { target, recordedSha, present, produced } = state;
+  const variant = state.variant ?? null;
+  const strategy = strategyFor(target);
+  const classified = (value, keys = []) => ({
+    target,
+    strategy,
+    class: value,
+    keys,
+    writeEffect: writeEffectFor(strategy, value),
+    ...strategy === "append-block" ? { variant } : {},
+    ...value === "unknown" && present != null ? { shape: shapeSuggests(target, present) } : {}
+  });
+  if (present == null) {
+    if (recordedSha != null)
+      return classified("removed");
+    return produced == null ? null : classified("add");
+  }
+  if (produced == null)
+    return classified(recordedSha == null ? "foreign" : "orphaned");
+  if (strategy === "merge-json") {
+    const keys = ownedKeys(present, produced);
+    if (keys == null)
+      return classified("conflict");
+    return classified(recordedSha == null ? "conflict" : classFromKeys(keys), keys);
+  }
+  if (recordedSha == null)
+    return classified("conflict");
+  if (strategy === "append-block")
+    return classified(compareDeclaredBlock(target, present, produced, variant));
+  return classified(compareOwnedView(target, recordedSha, present, produced));
+}
+var WRITABLE_CLASSES = /* @__PURE__ */ new Set(["add", "update"]);
+var WRITABLE_STRATEGIES = /* @__PURE__ */ new Set(["create", "append-block"]);
+function willBeWritten(strategy, value) {
+  return WRITABLE_CLASSES.has(value) && WRITABLE_STRATEGIES.has(strategy);
+}
+function writeEffectFor(strategy, value) {
+  return strategy === "append-block" && willBeWritten(strategy, value) ? BLOCK_REPLACED_WHOLE_DISCOVERY_BODIES_CARRIED_OVER : null;
+}
+function isWritable(classification) {
+  return willBeWritten(classification.strategy, classification.class);
+}
+function classifyRepository(state) {
+  const targets = [.../* @__PURE__ */ new Set([...Object.keys(state.recorded), ...Object.keys(state.present), ...Object.keys(state.produced)])].sort();
+  return targets.flatMap((target) => {
+    const classification = classifyPath({
+      target,
+      recordedSha: state.recorded[target] ?? null,
+      present: state.present[target] ?? null,
+      produced: state.produced[target] ?? null,
+      variant: state.variants?.[target] ?? null
+    });
+    return classification == null ? [] : [classification];
+  });
+}
+
+// src/sync/variant.ts
+function existingForm(target, template) {
+  return appendBlock("", template, target);
+}
+function shasOfDefaultForm(target, producedDefault) {
+  return [sha256(producedDefault), ownedSha(target, producedDefault)];
+}
+function shasOfExistingForm(target, template, present) {
+  return [sha256(appendBlock(present, template, target)), ownedSha(target, existingForm(target, template))];
+}
+function establishVariant(input) {
+  if (input.recordedVariant != null)
+    return { variant: input.recordedVariant, evidence: "recorded" };
+  if (input.existingTemplate == null)
+    return { variant: "default", evidence: "sole-variant" };
+  if (input.recordedSha == null)
+    return null;
+  const reconstructed = [
+    ["default", shasOfDefaultForm(input.target, input.producedDefault)],
+    ["existing", shasOfExistingForm(input.target, input.existingTemplate, input.present)]
+  ];
+  const matched = reconstructed.filter(([, shas]) => shas.includes(input.recordedSha)).map(([variant]) => variant);
+  return matched.length === 1 ? { variant: matched[0], evidence: "reconstructed" } : null;
+}
+
+// src/sync/replay.ts
+var NO_TREE_TO_PLAN_AGAINST = path15.join(tmpdir(), "mikoshi-construct-replay-renders-against-no-tree");
+function replayedGroups(manifest) {
+  const preset = getPreset(manifest.preset);
+  return [...preset.groups, ...aiGroups(manifest.ai), ...reviewGroups(manifest.review?.provider ?? "none")];
+}
+function varsRecordingMisses(manifest, version, facts, missed) {
+  const asRecordedExceptTheRunningVersion = { ...manifest.vars, constructVersion: version };
+  return new Proxy(asRecordedExceptTheRunningVersion, {
+    get(target, key) {
+      if (typeof key !== "string")
+        return Reflect.get(target, key);
+      const value = target[key];
+      if (value != null)
+        return value;
+      const established = facts[key];
+      if (established != null)
+        return established;
+      missed.add(key);
+      return "";
+    }
+  });
+}
+function missingVariables(manifest, missed) {
+  const names = [...missed].sort().join(", ");
+  return `construct.json was written by construct ${manifest.construct} and carries no value for ${names}, which today's ${manifest.preset} templates render. Add ${missed.size === 1 ? "it" : "each of them"} under "vars" in construct.json and run the sync again.`;
+}
+function contentByTarget(ops) {
+  return Object.fromEntries(ops.map((op) => [op.target, op.content]));
+}
+function producedByTemplates(manifest, vars, recorded) {
+  const groups = replayedGroups(manifest);
+  const plan = (emptyTarget) => planMaterialize(NO_TREE_TO_PLAN_AGAINST, groups, vars, { emptyTarget, ai: manifest.ai });
+  const withoutSamples = plan(false);
+  const kept = contentByTarget(withoutSamples.ops);
+  if (withoutSamples.omittedGroups.length === 0)
+    return { produced: kept, existingVariants: withoutSamples.existingVariants };
+  const withSamples = plan(true);
+  const sampled = contentByTarget(withSamples.ops);
+  const sampleWasMaterialized = Object.keys(sampled).some((target) => !(target in kept) && recorded[target] != null);
+  return sampleWasMaterialized ? { produced: sampled, existingVariants: withSamples.existingVariants } : { produced: kept, existingVariants: withoutSamples.existingVariants };
+}
+function establishedVariants(input) {
+  const recordedVariant = recordedVariants(input.manifest);
+  const established = {};
+  for (const [target, producedDefault] of Object.entries(input.templates.produced)) {
+    const present = input.present[target];
+    if (strategyFor(target) !== "append-block" || present == null)
+      continue;
+    const variant = establishVariant({
+      target,
+      recordedVariant: recordedVariant[target] ?? null,
+      recordedSha: input.recorded[target] ?? null,
+      present,
+      producedDefault,
+      existingTemplate: input.templates.existingVariants[target] ?? null
+    });
+    if (variant != null)
+      established[target] = variant;
+  }
+  return established;
+}
+function producedInTheVariantThatWroteIt(templates, variants) {
+  const produced = { ...templates.produced };
+  for (const [target, established] of Object.entries(variants)) {
+    const template = templates.existingVariants[target];
+    if (established.variant === "existing" && template != null)
+      produced[target] = existingForm(target, template);
+  }
+  return produced;
+}
+function presentInTree(root, targets) {
+  const present = {};
+  for (const target of new Set(targets)) {
+    const absolute = path15.join(root, target);
+    if (existsSync13(absolute))
+      present[target] = readFileSync13(absolute, "utf8");
+  }
+  return present;
+}
+function replay(input) {
+  const missed = /* @__PURE__ */ new Set();
+  const vars = varsRecordingMisses(input.manifest, input.version, input.facts, missed);
+  const recorded = recordedShas(input.manifest);
+  const templates = producedByTemplates(input.manifest, vars, recorded);
+  if (missed.size > 0)
+    throw new Error(missingVariables(input.manifest, missed));
+  const present = presentInTree(input.root, [...Object.keys(recorded), ...Object.keys(templates.produced)]);
+  const variants = establishedVariants({ manifest: input.manifest, recorded, present, templates });
+  const produced = producedInTheVariantThatWroteIt(templates, variants);
+  return {
+    fromVersion: input.manifest.construct,
+    toVersion: input.version,
+    present,
+    produced,
+    variants,
+    classifications: classifyRepository({ recorded, present, produced, variants })
+  };
+}
+
+// src/sync/write.ts
+var PENDING_CLASSES = ["add", "update"];
+function isPending(classification) {
+  return PENDING_CLASSES.includes(classification.class);
+}
+function contentToWrite(classification, input) {
+  const produced = input.produced[classification.target] ?? "";
+  const present = input.present[classification.target];
+  if (classification.strategy !== "append-block" || present == null)
+    return produced;
+  return substituteBlock(present, produced, classification.target);
+}
+function variantWritten(classification, input) {
+  if (classification.strategy !== "append-block")
+    return null;
+  return classification.variant?.variant ?? (input.present[classification.target] == null ? "default" : null);
+}
+function plannedWrite(classification, input) {
+  const content = contentToWrite(classification, input);
+  return {
+    target: classification.target,
+    strategy: classification.strategy,
+    content,
+    ownedSha: ownedSha(classification.target, content),
+    variant: variantWritten(classification, input),
+    writeEffect: classification.writeEffect
+  };
+}
+function planWrites(input) {
+  const writes = [];
+  const refused = [];
+  for (const classification of input.classifications) {
+    if (isWritable(classification))
+      writes.push(plannedWrite(classification, input));
+    else if (isPending(classification))
+      refused.push(classification);
+  }
+  return { writes, refused };
+}
+
+// src/commands/doctor/version-gap.ts
+function versionGap(root, manifest, version) {
+  try {
+    const { fromVersion, toVersion, classifications } = replay({ root, manifest, version, facts: factsTheRepositoryEstablishes(root) });
+    return { materializedBy: fromVersion, readBy: toVersion, pending: classifications.filter(isPending).length };
+  } catch {
+    return { materializedBy: manifest.construct, readBy: version, pending: null };
+  }
+}
+
+// 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 gapReading(ui2, gap) {
+  if (gap.pending == null)
+    return ui2.lore.baselineGapUnknown;
+  return gap.pending === 0 ? ui2.lore.baselineCurrent : ui2.lore.baselineMoved(gap.pending);
+}
+function printVersionGap(ui2, gap) {
+  ui2.line(ui2.theme.dim(`  ${ui2.lore.syncVersionGap(gap.materializedBy, gap.readBy)}`));
+  ui2.line(ui2.theme.dim(`  ${gapReading(ui2, gap)}`));
+}
+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) {
+    ui2.flatline("No construct.json here. Run `construct init` first.");
+    return 1;
+  }
+  if (result.harnessProblems.length > 0)
+    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)
+    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).`));
+  printVersionGap(ui2, result.versionGap);
+  if (result.ok)
+    ui2.ok(ui2.lore.stable);
+  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, version = VERSION) {
+  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),
+    versionGap: versionGap(root, manifest, version)
+  };
+}
+
+// src/commands/init.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import path21 from "path";
+
+// src/detect/index.ts
+import { existsSync as existsSync17 } from "fs";
+import path19 from "path";
+import process3 from "process";
+
+// src/detect/layout.ts
+import { existsSync as existsSync15, readdirSync as readdirSync7, readFileSync as readFileSync15, statSync as statSync4 } from "fs";
+import path17 from "path";
+
+// src/detect/workspaces.ts
+import { existsSync as existsSync14, readFileSync as readFileSync14 } from "fs";
+import path16 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 (!existsSync14(file))
+    return null;
+  try {
+    return readFileSync14(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+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(path16.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(path16.join(dir, "package.json"));
+  if (content == null)
+    return false;
+  let workspaces;
+  try {
+    ({ 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 (!existsSync15(dir))
+    return true;
+  return readdirSync7(dir).every((entry) => IGNORED_ENTRIES.has(entry));
+}
+function detectMonorepoTools(dir) {
+  const tools = [];
+  if (declaresPnpmPackages(dir))
+    tools.push("pnpm-workspace");
+  if (declaresNpmWorkspaces(dir))
+    tools.push("npm-workspaces");
+  if (existsSync15(path17.join(dir, "turbo.json")))
+    tools.push("turbo");
+  if (existsSync15(path17.join(dir, "nx.json")))
+    tools.push("nx");
+  return tools;
+}
+function detectWorkspaceDirs(dir) {
+  return ["apps", "packages", "libs", "services"].filter((name) => existsSync15(path17.join(dir, name)) && statSync4(path17.join(dir, name)).isDirectory());
+}
+function packageName(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync15(path17.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) => readdirSync7(path17.join(root, parent)).sort().map((entry) => `${parent}/${entry}`).filter((dir) => existsSync15(path17.join(root, dir, "package.json"))).map((dir) => ({ dir, name: packageName(path17.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 || existsSync15(path17.join(dir, "package.json")))
+    return "single";
+  return "unknown";
+}
+
+// src/detect/package-manager.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import path18 from "path";
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"]
+];
+function fromPackageManagerField(dir) {
+  const manifest = path18.join(dir, "package.json");
+  if (!existsSync16(manifest))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync16(manifest, "utf8"));
+    const name = parsed.packageManager?.split("@")[0];
+    return name === "pnpm" || name === "npm" || name === "yarn" || name === "bun" ? name : null;
+  } catch {
+    return null;
+  }
+}
+function detectPackageManager(dir) {
+  const declared = fromPackageManagerField(dir);
+  if (declared != null)
+    return declared;
+  for (const [lockfile, manager] of LOCKFILES) {
+    if (existsSync16(path18.join(dir, lockfile)))
+      return manager;
+  }
+  return existsSync16(path18.join(dir, "package.json")) ? "npm" : "none";
 }
-function quote(value) {
-  return `'${value}'`;
+var pnpmVersionCache;
+function detectPnpmVersion() {
+  if (pnpmVersionCache !== void 0)
+    return pnpmVersionCache;
+  try {
+    pnpmVersionCache = execFileSync("pnpm", ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+  } catch {
+    pnpmVersionCache = null;
+  }
+  return pnpmVersionCache;
 }
-function renderWorkspacePolicy(packages, sample) {
-  const names = packages.map((pkg) => pkg.name);
-  const allowedFor = (pkg) => {
-    if (sample)
-      return pkg.dir.startsWith("apps/") ? names.filter((name) => name !== pkg.name) : [];
-    return names.filter((name) => name !== pkg.name);
-  };
-  const lines = packages.map((pkg) => `  ${quote(pkg.dir)}: [${allowedFor(pkg).map(quote).join(", ")}],`);
+
+// src/detect/index.ts
+function detect(dir) {
+  const root = path19.resolve(dir);
+  const monorepoTools = detectMonorepoTools(root);
+  const workspaceDirs = detectWorkspaceDirs(root);
+  const hasSrc = existsSync17(path19.join(root, "src"));
   return {
-    workspacePackages: `[${names.map(quote).join(", ")}]`,
-    allowedWorkspaceImports: `{
-${lines.join("\n")}
-}`
+    dir: root,
+    packageManager: detectPackageManager(root),
+    pnpmVersion: detectPnpmVersion(),
+    layout: detectLayout(root, monorepoTools, workspaceDirs, hasSrc),
+    monorepoTools,
+    workspaceDirs,
+    workspacePackages: detectWorkspacePackages(root, workspaceDirs),
+    hasSrc,
+    nodeMajor: Number(process3.versions.node.split(".")[0]),
+    existing: detectExisting(root)
   };
 }
-var PRESETS = {
-  "node-backend": {
-    id: "node-backend",
-    label: "Node.js backend",
-    description: "Express + TypeScript, contract-first HTTP API, composition root, harness",
-    groups: [
-      "base",
-      "harness",
-      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,
-    available: true,
-    vars: () => ({
-      contractPath: "contracts/api/openapi.yaml",
-      contractTypesOutput: "src/contracts/openapi.ts",
-      contractTypesImport: "./openapi.js",
-      contractPathFromConfig: "../contracts/api/openapi.yaml",
-      appRoot: ""
-    })
-  },
-  "node-frontend": {
-    id: "node-frontend",
-    label: "Node.js frontend",
-    description: "Vite + TypeScript, platform CSS rules, composition root, harness; no API contract",
-    groups: [
-      "base",
-      "harness",
-      { group: "presets/node-frontend/sample", onlyWhenEmpty: true },
-      "presets/node-frontend/baseline"
-    ],
-    contracts: false,
-    available: true,
-    vars: () => ({
-      contractPath: "",
-      contractTypesOutput: ""
-    })
-  },
-  "node-library": {
-    id: "node-library",
-    label: "Node.js library or CLI",
-    description: "TypeScript package with no HTTP contract: architecture policy, composition models, harness",
-    groups: ["base", "harness"],
-    contracts: false,
-    available: true,
-    vars: () => ({
-      contractPath: "",
-      contractTypesOutput: ""
-    })
-  },
-  "monorepo": {
-    id: "monorepo",
-    label: "pnpm monorepo",
-    description: "apps/* + packages/*, catalog:, contract types in packages/shared, dependency policy in lint",
-    groups: [
-      "base",
-      "harness",
-      HTTP_CONTRACT,
-      { group: EXPRESS_APP, into: "apps/api", onlyWhenEmpty: true },
-      { group: EXPRESS_REPO, onlyWhenEmpty: true },
-      { group: "presets/monorepo/sample", onlyWhenEmpty: true },
-      "presets/monorepo/baseline"
-    ],
-    contracts: true,
-    available: true,
-    vars: (report, projectName) => {
-      const detected = report.workspacePackages;
-      const packages = detected.length > 0 ? detected : sampleWorkspace(`@${projectName}`);
-      return {
-        contractPath: "contracts/api/openapi.yaml",
-        contractTypesOutput: "packages/shared/src/api/openapi.ts",
-        contractTypesImport: `@${projectName}/shared`,
-        contractPathFromConfig: "../../../contracts/api/openapi.yaml",
-        appRoot: "apps/api/",
-        ...renderWorkspacePolicy(packages, detected.length === 0)
-      };
-    }
+
+// src/materialize/apply.ts
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import path20 from "path";
+function applyPlan(root, ops) {
+  const written = [];
+  for (const op of ops) {
+    if (op.action === "skip")
+      continue;
+    const absolute = path20.join(root, op.target);
+    mkdirSync(path20.dirname(absolute), { recursive: true });
+    writeFileSync2(absolute, op.content);
+    written.push(op);
   }
-};
-var PRESET_IDS = Object.keys(PRESETS);
-var PRESET_LIST = Object.values(PRESETS);
-function isPresetId(value) {
-  return value in PRESETS;
-}
-function getPreset(id) {
-  return PRESETS[id];
-}
-function aiGroups(target) {
-  return target === "both" ? ["ai/shared", "ai/claude", "ai/cursor"] : ["ai/shared", `ai/${target}`];
-}
-var DEFAULT_REVIEW_MODEL = "claude-sonnet-5";
-function reviewGroups(provider) {
-  return provider === "claude" ? ["ai/review"] : [];
-}
-function defaultProjectName(dir) {
-  const base = dir.split(/[\\/]/).filter(Boolean).at(-1) ?? "project";
-  return base.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+  return written;
 }
 
 // src/ui/prompts.ts
@@ -1030,24 +2228,6 @@ function createClackPrompter(lore, streams = {}) {
   };
 }
 
-// src/version.ts
-import { readFileSync as readFileSync8 } from "fs";
-import path12 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var HERE2 = path12.dirname(fileURLToPath2(import.meta.url));
-function readVersion() {
-  for (const candidate of ["../package.json", "../../package.json"]) {
-    try {
-      const parsed = JSON.parse(readFileSync8(path12.resolve(HERE2, candidate), "utf8"));
-      if (parsed.name === "mikoshi-construct" && parsed.version != null)
-        return parsed.version;
-    } catch {
-    }
-  }
-  return "0.0.0";
-}
-var VERSION = readVersion();
-
 // src/commands/soulkill.ts
 function yesNo(value) {
   return value ? "yes" : "no";
@@ -1071,6 +2251,13 @@ function printDetectReport(ui2, report) {
 
 // src/commands/init.ts
 var CANCELLED = /* @__PURE__ */ Symbol("cancelled");
+var RESTATED_BY_THE_RUNNING_BINARY = ["constructVersion"];
+function varsThisRunChanged(previous, vars) {
+  return Object.entries(vars).filter(([name]) => !RESTATED_BY_THE_RUNNING_BINARY.includes(name)).flatMap(([name, to]) => {
+    const from = previous.vars[name];
+    return from == null || from === to ? [] : [{ name, from, to }];
+  });
+}
 function aborted(skipped = [], conflicts = []) {
   return { status: "aborted", written: [], skipped, conflicts };
 }
@@ -1138,7 +2325,7 @@ async function askChoices(ui2, options, report, root, prompter) {
   return { presetId, ai, projectName, review };
 }
 async function runInit(ui2, options, prompter) {
-  const root = path13.resolve(options.dir);
+  const root = path21.resolve(options.dir);
   mkdirSync2(root, { recursive: true });
   if (!options.yes && prompter == null) {
     ui2.glitch(ui2.lore.needsTerminal);
@@ -1176,7 +2363,7 @@ async function runInit(ui2, options, prompter) {
     contracts: preset.contracts ? "true" : "false",
     contractPath: "contracts/api/openapi.yaml",
     contractTypesOutput: "src/contracts/openapi.ts",
-    compositionDir: report.existing.compositionDir ?? "architecture/composition",
+    compositionDir: report.existing.compositionDir ?? DEFAULT_COMPOSITION_DIR,
     harnessCommand: "pnpm run quality",
     packageManager: "pnpm",
     pnpmVersion: report.pnpmVersion ?? "",
@@ -1202,7 +2389,7 @@ async function runInit(ui2, options, prompter) {
   ui2.line();
   if (plan.omittedGroups.length > 0)
     ui2.line(ui2.theme.dim(`  ${ui2.lore.sampleOmitted}`));
-  if (report.existing.compositionDir != null && report.existing.compositionDir !== "architecture/composition")
+  if (report.existing.compositionDir != null && report.existing.compositionDir !== DEFAULT_COMPOSITION_DIR)
     ui2.line(ui2.theme.dim(`  Existing composition models found at ${report.existing.compositionDir}/ \u2014 kept there, not moved.`));
   if (plan.conflicts.length > 0)
     ui2.glitch("Existing values kept; review these keys by hand:", plan.conflicts);
@@ -1215,7 +2402,17 @@ async function runInit(ui2, options, prompter) {
   if (interactive != null && await interactive.confirm(ui2.lore.confirm) !== true)
     return aborted(skipped, plan.conflicts);
   const written = applyPlan(root, plan.ops);
-  writeManifest(root, buildManifest({ version: VERSION, preset: presetId, ai, review, vars, written, contracts: preset.contracts }));
+  const previous = readManifest(root);
+  const manifest = buildManifest({ version: VERSION, preset: presetId, ai, review, vars, written, contracts: preset.contracts, previous });
+  writeManifest(root, manifest);
+  if (previous != null) {
+    const carriedOver = Object.keys(previous.files).filter((target) => !written.some((op) => op.target === target)).length;
+    const added = written.filter((op) => previous.files[op.target] == null).length;
+    ui2.line(ui2.theme.dim(`  ${ui2.lore.recordCarriedOver(carriedOver, added)}`));
+    const changed = varsThisRunChanged(previous, vars);
+    if (changed.length > 0)
+      ui2.line(ui2.theme.dim(`  ${ui2.lore.recordVarsChanged(changed)}`));
+  }
   ui2.phase(4, 4, "\u2705", ui2.lore.phaseOnline);
   ui2.tree([
     ["Written", `${written.length} files`],
@@ -1225,10 +2422,202 @@ async function runInit(ui2, options, prompter) {
   return { status: "done", written: written.map((op) => op.target), skipped, conflicts: plan.conflicts };
 }
 
+// src/commands/sync/report.ts
+var SYNC_EXIT = {
+  upToDate: 0,
+  noManifest: 1,
+  pending: 2
+};
+var SYNC_APPLY_EXIT = {
+  written: 0,
+  noManifest: 1,
+  refused: 2
+};
+var LISTED_CLASSES = ["add", "update", "conflict", "unknown", "removed", "orphaned"];
+var CLASS_COLUMN = Math.max(...PATH_CLASSES.map((value) => value.length)) + 2;
+function pendingCount(report) {
+  return PENDING_CLASSES.reduce((total, value) => total + report.counts[value], 0);
+}
+function syncExit(report) {
+  if (report == null)
+    return SYNC_EXIT.noManifest;
+  return pendingCount(report) === 0 ? SYNC_EXIT.upToDate : SYNC_EXIT.pending;
+}
+function actionableKeys(entry) {
+  return entry.keys.filter((key) => key.class !== "keep").map((key) => `${key.key} (${key.class})`);
+}
+function syncJson(report) {
+  return {
+    fromVersion: report.fromVersion,
+    toVersion: report.toVersion,
+    counts: report.counts,
+    paths: report.classifications.map((entry) => ({
+      target: entry.target,
+      class: entry.class,
+      strategy: entry.strategy,
+      ...entry.keys.length === 0 ? {} : { keys: entry.keys },
+      ...entry.variant == null ? {} : { variant: entry.variant.variant, variantEvidence: entry.variant.evidence },
+      ...entry.shape == null ? {} : { shape: entry.shape },
+      ...entry.writeEffect == null ? {} : { writeEffect: entry.writeEffect }
+    }))
+  };
+}
+function note(ui2, entry) {
+  if (entry.strategy === "merge-json") {
+    const keys = actionableKeys(entry);
+    return keys.length === 0 ? "" : ui2.lore.syncMergedKeys(keys);
+  }
+  if (entry.class === "unknown")
+    return ui2.lore.syncVariantUnknown(entry.shape ?? "");
+  return entry.writeEffect == null ? "" : ui2.lore.syncWriteEffect[entry.writeEffect] ?? "";
+}
+var COUNT_ORDER = ["add", "update", "conflict", "unknown", "removed", "orphaned", "keep", "foreign"];
+function printCounts(ui2, report) {
+  ui2.line(ui2.theme.accent(ui2.lore.syncClasses));
+  for (const value of COUNT_ORDER) {
+    if (report.counts[value] === 0)
+      continue;
+    const meaning = ui2.lore.syncClassMeaning[value] ?? "";
+    ui2.line(`  ${value.padEnd(CLASS_COLUMN)}${String(report.counts[value]).padStart(3)}  ${ui2.theme.dim(meaning)}`);
+  }
+}
+function printPaths(ui2, report) {
+  for (const value of LISTED_CLASSES) {
+    const entries = report.classifications.filter((entry) => entry.class === value);
+    if (entries.length === 0)
+      continue;
+    ui2.line();
+    ui2.line(`${ui2.theme.accent(value)} ${ui2.theme.dim(`\u2014 ${ui2.lore.syncClassMeaning[value] ?? ""}`)}`);
+    for (const entry of entries) {
+      const detail = note(ui2, entry);
+      ui2.line(`  ${entry.target}${detail === "" ? "" : ui2.theme.dim(` \u2014 ${detail}`)}`);
+    }
+  }
+}
+function printMergedNote(ui2, report) {
+  const listed = report.classifications.filter((entry) => LISTED_CLASSES.includes(entry.class));
+  if (!listed.some((entry) => entry.strategy === "merge-json"))
+    return;
+  ui2.line();
+  ui2.line(ui2.theme.dim(ui2.lore.syncMergedNotWritten));
+}
+function printSync(ui2, report) {
+  if (report == null) {
+    ui2.flatline(ui2.lore.syncNoManifest);
+    return SYNC_EXIT.noManifest;
+  }
+  ui2.line(ui2.theme.accent(ui2.theme.bold(ui2.lore.syncTitle)));
+  ui2.line(ui2.theme.bold(ui2.lore.syncVersionGap(report.fromVersion, report.toVersion)));
+  ui2.line();
+  printCounts(ui2, report);
+  printPaths(ui2, report);
+  printMergedNote(ui2, report);
+  const pending = pendingCount(report);
+  ui2.line();
+  ui2.line(pending === 0 ? ui2.lore.syncNothingToWrite : ui2.lore.syncPending(pending));
+  return syncExit(report);
+}
+function syncApplyExit(result) {
+  if (result == null)
+    return SYNC_APPLY_EXIT.noManifest;
+  return result.refused.length === 0 ? SYNC_APPLY_EXIT.written : SYNC_APPLY_EXIT.refused;
+}
+function syncApplyJson(result) {
+  return {
+    ...syncJson(result.report),
+    written: result.written,
+    pending: result.refused.map((entry) => entry.target),
+    ranAt: result.ranAt
+  };
+}
+function printWritten(ui2, result) {
+  if (result.written.length === 0)
+    return;
+  const byTarget = new Map(result.report.classifications.map((entry) => [entry.target, entry]));
+  ui2.line();
+  ui2.line(ui2.theme.accent(ui2.lore.syncApplyWritten));
+  for (const target of result.written) {
+    const entry = byTarget.get(target);
+    const detail = entry == null ? "" : note(ui2, entry);
+    ui2.line(`  ${target}${detail === "" ? "" : ui2.theme.dim(` \u2014 ${detail}`)}`);
+  }
+}
+function printUnknownVariants(ui2, result) {
+  const unknown = result.report.classifications.filter((entry) => entry.class === "unknown");
+  if (unknown.length === 0)
+    return;
+  ui2.line();
+  ui2.line(ui2.theme.accent(ui2.lore.syncApplyUnknown));
+  for (const entry of unknown)
+    ui2.line(`  ${entry.target}${ui2.theme.dim(` \u2014 ${note(ui2, entry)}`)}`);
+}
+function printRefused(ui2, result) {
+  if (result.refused.length === 0)
+    return;
+  ui2.line();
+  ui2.line(ui2.theme.accent(ui2.lore.syncApplyRefused));
+  for (const entry of result.refused) {
+    const detail = note(ui2, entry);
+    ui2.line(`  ${entry.target}${detail === "" ? "" : ui2.theme.dim(` \u2014 ${detail}`)}`);
+  }
+  ui2.line(ui2.theme.dim(ui2.lore.syncMergedNotWritten));
+}
+function printSyncApply(ui2, result) {
+  if (result == null) {
+    ui2.flatline(ui2.lore.syncNoManifest);
+    return SYNC_APPLY_EXIT.noManifest;
+  }
+  ui2.line(ui2.theme.accent(ui2.theme.bold(ui2.lore.syncApplyTitle)));
+  ui2.line(ui2.theme.bold(ui2.lore.syncVersionGap(result.report.fromVersion, result.report.toVersion)));
+  printWritten(ui2, result);
+  printUnknownVariants(ui2, result);
+  printRefused(ui2, result);
+  ui2.line();
+  ui2.line(result.written.length === 0 ? ui2.lore.syncApplyNothingWritten : ui2.lore.syncApplyWrote(result.written.length));
+  if (result.refused.length > 0)
+    ui2.line(ui2.lore.syncApplyLeftToYou(result.refused.length));
+  return syncApplyExit(result);
+}
+
+// src/commands/sync/index.ts
+function countByClass(classifications) {
+  const counts = Object.fromEntries(PATH_CLASSES.map((value) => [value, 0]));
+  for (const entry of classifications)
+    counts[entry.class] += 1;
+  return counts;
+}
+function runSync(root, version) {
+  const manifest = readManifest(root);
+  if (manifest == null)
+    return null;
+  const { fromVersion, toVersion, classifications } = replay({ root, manifest, version, facts: factsTheRepositoryEstablishes(root) });
+  return { fromVersion, toVersion, counts: countByClass(classifications), classifications };
+}
+function applySync(root, version) {
+  const manifest = readManifest(root);
+  if (manifest == null)
+    return null;
+  const { fromVersion, toVersion, present, produced, classifications } = replay({ root, manifest, version, facts: factsTheRepositoryEstablishes(root) });
+  const report = { fromVersion, toVersion, counts: countByClass(classifications), classifications };
+  const { writes, refused } = planWrites({ classifications, present, produced });
+  const written = applyPlan(root, writes.map((write) => ({ target: write.target, strategy: write.strategy, action: "create", content: write.content })));
+  const ranAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (writes.length > 0) {
+    writeManifest(root, recordSync(manifest, {
+      ranAt,
+      toVersion: version,
+      files: Object.fromEntries(writes.map((write) => [write.target, write.ownedSha])),
+      variants: Object.fromEntries(writes.flatMap((write) => write.variant == null ? [] : [[write.target, write.variant]]))
+    }));
+  }
+  return { report, written: written.map((op) => op.target), refused, ranAt };
+}
+
 // src/ui/console.ts
-import process2 from "process";
+import process4 from "process";
 
 // src/ui/lore.ts
+var BLOCK_REPLACED_WHOLE = "block-replaced-whole-discovery-bodies-carried-over";
 var BANNER = String.raw`
   ███╗   ███╗██╗██╗  ██╗ ██████╗ ███████╗██╗  ██╗██╗
   ████╗ ████║██║██║ ██╔╝██╔═══██╗██╔════╝██║  ██║██║
@@ -1264,12 +2653,68 @@ 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.`,
+  baselineCurrent: "The baseline reads back what today's templates produce.",
+  baselineMoved: (count) => `THE BASELINE MOVED ON: ${count} recorded path${count === 1 ? "" : "s"} a sync would add or update \u2014 run \`construct sync\`.`,
+  baselineGapUnknown: "What a sync would add or update cannot be established from this manifest: run `construct sync`.",
+  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",
+  syncTitle: "BRAINDANCE \u2014 ENGRAM REPLAY",
+  syncClasses: "PATH CLASSES",
+  syncClassMeaning: {
+    add: "not in the tree; the templates produce it",
+    update: "the construct owns this and the template moved on",
+    conflict: "yours \u2014 you wrote or changed it; sync never touches these",
+    unknown: "which template variant wrote this block cannot be established; you changed nothing, and sync writes nothing here",
+    removed: "you deleted it; sync never puts it back",
+    orphaned: "the construct wrote it once and no longer produces it; it is yours now",
+    keep: "already what the templates produce",
+    foreign: "never ours"
+  },
+  syncMergedKeys: (keys) => `keys: ${keys.join(", ")}`,
+  syncMergedNotWritten: "A merged target is reported by its keys and never rewritten: no merge-json file is written in this version.",
+  syncWriteEffect: {
+    [BLOCK_REPLACED_WHOLE]: "the construct block is replaced whole \u2014 edits between the delimiters do not survive; the discovery marker bodies are carried over"
+  },
+  syncVariantUnknown: (shape) => `no record of the variant that wrote it and no rendering matches the recorded hash; the shape reads like the ${shape} variant, which is a guess and never enough to write on`,
+  syncApplyUnknown: "BEYOND THE BLACKWALL",
+  syncNothingToWrite: "NOTHING TO WRITE \u2014 the replay reads back what the tree already carries.",
+  syncPending: (count) => `${count} path${count === 1 ? "" : "s"} can be written: run \`construct sync --apply\`.`,
+  syncApplyTitle: "RELIC WRITE",
+  syncApplyWritten: "WRITTEN",
+  syncApplyRefused: "LEFT TO YOU",
+  syncApplyWrote: (count) => `${count} path${count === 1 ? "" : "s"} written. The manifest records the owned view of each of them.`,
+  syncApplyNothingWritten: "NOTHING WRITTEN \u2014 the tree already carries what the construct owns.",
+  syncApplyLeftToYou: (count) => `${count} path${count === 1 ? "" : "s"} the record cannot prove the construct owns. Yours to carry across.`,
+  syncVersionGap: (from, to) => `ENGRAM CUT BY v${from} // REPLAYED BY v${to}`,
+  syncNoManifest: "No construct.json here. Run `construct init` first.",
+  recordCarriedOver: (carried, added) => `ENGRAM EXTENDED: ${carried} record${carried === 1 ? "" : "s"} carried over from the construct.json already here, ${added} added.`,
+  recordVarsChanged: (changed) => `ENGRAM REWRITTEN: this run changed ${changed.map((entry) => `${entry.name} (${entry.from} \u2192 ${entry.to})`).join(", ")} in the record; the recorded hashes were taken with the old value${changed.length === 1 ? "" : "s"}.`
 };
 var PLAIN_LORE = {
   subtitle: (version) => `mikoshi-construct v${version}`,
@@ -1299,17 +2744,73 @@ 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.`,
+  baselineCurrent: "The baseline reads back what today's templates produce.",
+  baselineMoved: (count) => `The baseline moved on: ${count} recorded path${count === 1 ? "" : "s"} a sync would add or update \u2014 run \`construct sync\`.`,
+  baselineGapUnknown: "What a sync would add or update cannot be established from this manifest: run `construct sync`.",
+  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",
+  syncTitle: "Sync report",
+  syncClasses: "Classes",
+  syncClassMeaning: {
+    add: "not in the tree; the templates produce it",
+    update: "the construct owns this and the template moved on",
+    conflict: "yours \u2014 you wrote or changed it; sync never touches these",
+    unknown: "which template variant wrote this block cannot be established; you changed nothing, and sync writes nothing here",
+    removed: "you deleted it; sync never puts it back",
+    orphaned: "the construct wrote it once and no longer produces it; it is yours now",
+    keep: "already what the templates produce",
+    foreign: "never ours"
+  },
+  syncMergedKeys: (keys) => `keys: ${keys.join(", ")}`,
+  syncMergedNotWritten: "A merged target is reported by its keys and never rewritten: no merge-json file is written in this version.",
+  syncWriteEffect: {
+    [BLOCK_REPLACED_WHOLE]: "the construct block is replaced whole \u2014 edits between the delimiters do not survive; the discovery marker bodies are carried over"
+  },
+  syncVariantUnknown: (shape) => `no record of the variant that wrote it and no rendering matches the recorded hash; the shape reads like the ${shape} variant, which is a guess and never enough to write on`,
+  syncApplyUnknown: "Variant unknown",
+  syncNothingToWrite: "Nothing to write: the replay reads back what the tree already carries.",
+  syncPending: (count) => `${count} path${count === 1 ? "" : "s"} can be written: run \`construct sync --apply\`.`,
+  syncApplyTitle: "Sync apply",
+  syncApplyWritten: "Written",
+  syncApplyRefused: "Left to you",
+  syncApplyWrote: (count) => `${count} path${count === 1 ? "" : "s"} written. The manifest records the owned view of each of them.`,
+  syncApplyNothingWritten: "Nothing written: the tree already carries what the construct owns.",
+  syncApplyLeftToYou: (count) => `${count} path${count === 1 ? "" : "s"} the record cannot prove the construct owns. Yours to carry across.`,
+  syncVersionGap: (from, to) => `Materialized by construct ${from}, read by ${to}.`,
+  syncNoManifest: "No construct.json here. Run `construct init` first.",
+  recordCarriedOver: (carried, added) => `Carried over ${carried} record${carried === 1 ? "" : "s"} from the construct.json already here; added ${added}.`,
+  recordVarsChanged: (changed) => `This run changed ${changed.map((entry) => `${entry.name} (${entry.from} -> ${entry.to})`).join(", ")} in the record; the recorded hashes were taken with the old value${changed.length === 1 ? "" : "s"}.`
 };
 
 // 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";
@@ -1368,21 +2869,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 = {
@@ -1451,12 +2952,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;
     }
   }
 });
@@ -1469,7 +2970,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;
     }
@@ -1489,13 +2990,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({
@@ -1506,16 +3007,49 @@ var cost = defineCommand({
     json: { type: "boolean", description: "Machine-readable report", default: false }
   },
   run({ args }) {
-    const runs = collectWorkflowRuns(path14.resolve(args.dir));
+    const report = costReport(path22.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;
     }
+    process6.exitCode = printCost(ui(args), report, args.last);
+  }
+});
+var sync = defineCommand({
+  meta: { name: "sync", description: "Classify what today's construct would change in this repository; --apply writes what it owns" },
+  args: {
+    ...commonArgs,
+    json: { type: "boolean", description: "Machine-readable report", default: false },
+    apply: { type: "boolean", description: "Write the paths the construct owns \u2014 the only way sync writes; never a conflict, a removal or a merged file", default: false }
+  },
+  run({ args }) {
     const console = ui(args);
-    process4.exitCode = printCost(console, runs, args.last);
+    if (args.apply) {
+      try {
+        const result = applySync(args.dir, VERSION);
+        if (args.json) {
+          process6.stdout.write(`${JSON.stringify(result == null ? null : syncApplyJson(result), null, 2)}
+`);
+          process6.exitCode = syncApplyExit(result);
+          return;
+        }
+        process6.exitCode = printSyncApply(console, result);
+      } catch (error) {
+        console.flatline(error instanceof Error ? error.message : String(error));
+        process6.exitCode = 1;
+      }
+      return;
+    }
+    const report = runSync(args.dir, VERSION);
+    if (args.json) {
+      process6.stdout.write(`${JSON.stringify(report == null ? null : syncJson(report), null, 2)}
+`);
+      process6.exitCode = syncExit(report);
+      return;
+    }
+    process6.exitCode = printSync(console, report);
   }
 });
 var main = defineCommand({
@@ -1530,6 +3064,7 @@ var main = defineCommand({
     inspect: soulkill,
     capture: soulkill,
     doctor,
+    sync,
     cost
   }
 });