mikoshi-construct 0.2.0 → 0.3.1

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path21 from "path";
+import path22 from "path";
 import process6 from "process";
 import { isTTY } from "@clack/prompts";
 import { defineCommand, runMain } from "citty";
@@ -258,10 +258,50 @@ import process from "process";
 
 // src/manifest.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+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 = 2;
+var MANIFEST_VERSION = 4;
 var DISCOVERY_MARKERS = [
   "product",
   "module-map",
@@ -277,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;
@@ -288,9 +328,10 @@ 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);
+    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",
@@ -298,8 +339,8 @@ function buildManifest(input) {
   }]));
   return {
     manifestVersion: MANIFEST_VERSION,
-    construct: input.version,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    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 },
@@ -308,9 +349,21 @@ function buildManifest(input) {
     contracts: input.contracts ? { path: input.vars.contractPath, types: input.vars.contractTypesOutput } : null,
     vars: input.vars,
     files,
-    discovery: { baseSha: null, filledAt: null, markers }
+    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 };
@@ -321,31 +374,63 @@ function upgradeMarker(recorded, file) {
     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))
+    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(path3.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 = path3.join(root, MANIFEST_FILE);
-  if (!existsSync3(file))
+  const file = path4.join(root, MANIFEST_FILE);
+  if (!existsSync4(file))
     return null;
   return upgradeManifest(JSON.parse(readFileSync3(file, "utf8")));
 }
@@ -466,17 +551,35 @@ function costReport(cwd, options = {}) {
   };
 }
 
+// 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 existsSync4, readFileSync as readFileSync4 } from "fs";
-import path4 from "path";
+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 = path4.join(root, file);
-    if (!existsSync4(absolute))
+    const absolute = path6.join(root, file);
+    if (!existsSync5(absolute))
       missingFiles.push(file);
-    else if (sha256(readFileSync4(absolute, "utf8")) !== hash)
+    else if (sha256(readFileSync5(absolute, "utf8")) !== hash)
       modifiedFiles.push(file);
   }
   return { missingFiles, modifiedFiles };
@@ -512,8 +615,8 @@ function ciCheck(evidence) {
 }
 
 // src/commands/doctor/runner.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import path7 from "path";
 var RUNNER_CONFIG_FILES = [
   "vitest.config.ts",
   "vitest.config.mts",
@@ -601,7 +704,7 @@ function matchesAnyGlob(file, globs) {
 }
 function readRunnerFacts(root, harnessText) {
   const invokedByHarness = harnessText.includes("vitest");
-  const file = RUNNER_CONFIG_FILES.find((candidate) => existsSync5(path5.join(root, candidate))) ?? null;
+  const file = RUNNER_CONFIG_FILES.find((candidate) => existsSync6(path7.join(root, candidate))) ?? null;
   if (file == null) {
     return {
       file: null,
@@ -612,7 +715,7 @@ function readRunnerFacts(root, harnessText) {
   }
   let source;
   try {
-    source = readFileSync5(path5.join(root, file), "utf8");
+    source = readFileSync6(path7.join(root, file), "utf8");
   } catch {
     return { file, globs: null, note: `${file} cannot be read, so the include list is unknown`, invokedByHarness };
   }
@@ -678,8 +781,16 @@ function redGateCheck(evidence) {
 }
 
 // src/commands/doctor/discovery.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
-import path6 from "path";
+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} -->`;
@@ -696,33 +807,42 @@ function blockBody(document, marker) {
   return body === "" || body === DISCOVERY_PLACEHOLDER ? null : body;
 }
 function compositionBody(directory) {
-  if (!existsSync6(directory))
+  if (!existsSync7(directory))
     return null;
-  const models = readdirSync2(directory).filter((file) => file.endsWith(".yaml")).sort();
+  const models = readdirSync3(directory).filter((file) => file.endsWith(".yaml")).sort();
   if (models.length === 0)
     return null;
   return models.map((model) => `${model}
-${readFileSync6(path6.join(directory, model), "utf8")}`).join("\n");
+${readFileSync7(path8.join(directory, model), "utf8")}`).join("\n");
 }
 function markerBody(root, marker, file) {
-  const location = path6.join(root, file);
+  const location = path8.join(root, file);
   if (marker === "composition")
     return compositionBody(location);
-  if (!existsSync6(location))
+  if (!existsSync7(location))
     return null;
-  return blockBody(readFileSync6(location, "utf8"), marker);
+  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, manifest.discovery.markers[marker].file) == null);
+  return DISCOVERY_MARKERS.filter((marker) => markerBody(root, marker, markerFileFor(root, manifest, marker)) == null);
 }
 
 // src/commands/doctor/evidence.ts
-import { readFileSync as readFileSync10 } from "fs";
-import path10 from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import path12 from "path";
 
 // src/commands/doctor/harness.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import path7 from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import path9 from "path";
 var REQUIRED_QUALITY_STEPS = ["lint", "typecheck", "test"];
 var SCRIPT_REFERENCE = /(?:^|&&|\|\||;)\s*(?:pnpm|npm|yarn|bun)\s+(?:run\s+)?([\w:.-]+)/g;
 function harnessScriptName(command) {
@@ -740,8 +860,8 @@ function expandScript(scripts, name, seen) {
 }
 function readHarnessFacts(root, command) {
   const script = harnessScriptName(command);
-  const manifestPath = path7.join(root, "package.json");
-  const packageJson = existsSync7(manifestPath) ? JSON.parse(readFileSync7(manifestPath, "utf8")) : null;
+  const 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 {
@@ -760,7 +880,7 @@ function runsHarnessCommand(text2, forms) {
 function contractProblems(root, contracts, script, body) {
   if (contracts == null)
     return [];
-  const problems = [contracts.path, contracts.types].filter((file) => !existsSync7(path7.join(root, file))).map((file) => `${file} is missing (construct.json \u2192 contracts)`);
+  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;
@@ -778,8 +898,8 @@ function harnessProblems(root, manifest, facts) {
 }
 
 // src/commands/doctor/hooks.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync as statSync2 } from "fs";
-import path8 from "path";
+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";
@@ -787,20 +907,20 @@ var GIT_CONFIG = ".git/config";
 var HOOK_SCRIPTS = ["precommit", "pre-commit", "prepush", "pre-push"];
 function read(root, file) {
   try {
-    return readFileSync8(path8.join(root, file), "utf8");
+    return readFileSync9(path10.join(root, file), "utf8");
   } catch {
     return null;
   }
 }
 function huskyHooks(root) {
-  const directory = path8.join(root, HUSKY_DIR);
-  if (!existsSync8(directory) || !statSync2(directory).isDirectory())
+  const directory = path10.join(root, HUSKY_DIR);
+  if (!existsSync9(directory) || !statSync2(directory).isDirectory())
     return [];
-  return readdirSync3(directory).filter((entry) => !entry.startsWith("_") && !entry.startsWith(".")).sort().map((entry) => `${HUSKY_DIR}/${entry}`);
+  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) => existsSync8(path8.join(root, file))));
+  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);
@@ -823,8 +943,8 @@ function readHookFacts(root, packageJson, scripts, commandForms) {
 }
 
 // src/commands/doctor/workflows.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
-import path9 from "path";
+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) {
@@ -851,16 +971,16 @@ function runStepTexts(source) {
   return steps;
 }
 function readWorkflowFacts(root, commandForms) {
-  const directory = path9.join(root, WORKFLOWS_DIR);
-  if (!existsSync9(directory))
+  const directory = path11.join(root, WORKFLOWS_DIR);
+  if (!existsSync10(directory))
     return { directory: WORKFLOWS_DIR, files: [], harnessWorkflow: null, unreadable: [] };
-  const files = readdirSync4(directory).filter((file) => file.endsWith(".yml") || file.endsWith(".yaml")).sort();
+  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 = readFileSync9(path9.join(directory, file), "utf8");
+      source = readFileSync10(path11.join(directory, file), "utf8");
     } catch {
       unreadable.push(`${WORKFLOWS_DIR}/${file}`);
       continue;
@@ -887,7 +1007,7 @@ function gatherEvidence(root, manifest) {
   const unreadable = [...workflows.unreadable];
   for (const file of recordedTests) {
     try {
-      const source = readFileSync10(path10.join(root, file), "utf8");
+      const source = readFileSync11(path12.join(root, file), "utf8");
       if (LINT_POLICY_MARKERS.some((marker) => source.includes(marker)))
         policyTests.push(file);
     } catch {
@@ -909,7 +1029,7 @@ function discoveryProvenance(root, manifest) {
     return {
       marker,
       file: recorded.file,
-      authorship: markerAuthorship(recorded, markerBody(root, marker, recorded.file))
+      authorship: markerAuthorship(recorded, markerBody(root, marker, markerFileFor(root, manifest, marker)))
     };
   });
 }
@@ -943,541 +1063,256 @@ function weakestLink(checks) {
   return { id: weakest.id, level: weakest.level };
 }
 
-// src/commands/doctor/report.ts
-function checkLine(ui2, check) {
-  return `  ${check.id.padEnd(16)} ${check.level}  ${check.state.padEnd(8)} ${ui2.theme.dim(check.evidence)}`;
+// 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 existsSync12, readFileSync as readFileSync12 } from "fs";
+import path14 from "path";
+
+// src/materialize/rules.ts
+var CLAUDE_RULES_DIR = ".claude/rules/";
+var CURSOR_RULES_DIR = ".cursor/rules/";
+var DISCOVERY_PROTOCOL = ".claude/commands/construct-discover.md";
+var CURSOR_DISCOVERY_RULE = ".cursor/rules/construct-discover.mdc";
+var FRONTMATTER = /^---\n([\s\S]*?)\n---\n/;
+function unquote(value) {
+  return value.trim().replace(/^(["'])(.*)\1$/, "$2");
 }
-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 parseFrontmatter(block) {
+  const paths = [];
+  let description;
+  let inPaths = false;
+  for (const line of block.split("\n")) {
+    const item = /^\s*-\s+(\S.*)$/.exec(line);
+    if (inPaths && item != null) {
+      paths.push(unquote(item[1]));
+      continue;
+    }
+    inPaths = /^paths:\s*$/.test(line);
+    const scalar = /^description:\s*(\S.*)$/.exec(line);
+    if (scalar != null)
+      description = unquote(scalar[1]);
+  }
+  return { description, paths };
 }
-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 firstHeading(body) {
+  return /^#\s+(\S.*)$/m.exec(body)?.[1].trim();
 }
-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 parseClaudeRule(content) {
+  const match = FRONTMATTER.exec(content);
+  const body = match == null ? content : content.slice(match[0].length).replace(/^\n+/, "");
+  const front = match == null ? { paths: [] } : parseFrontmatter(match[1]);
+  return { description: front.description ?? firstHeading(body) ?? "Project rule", paths: front.paths, body };
 }
-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).`));
-  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;
+function isClaudeRule(target) {
+  return target.startsWith(CLAUDE_RULES_DIR) && target.endsWith(".md");
 }
-
-// src/commands/doctor/index.ts
-function runDoctor(root) {
-  const manifest = readManifest(root);
-  if (manifest == null)
-    return null;
-  const evidence = gatherEvidence(root, manifest);
-  const baseline = baselineVerdict(root, manifest);
-  const problems = harnessProblems(root, manifest, evidence.harness);
-  const checks = [
-    lintPolicyCheck(evidence),
-    constructTestsCheck(evidence),
-    ciCheck(evidence),
-    hookCheck(evidence),
-    redGateCheck(evidence)
-  ];
-  return {
-    ok: baseline.missingFiles.length === 0 && problems.length === 0,
-    missingFiles: baseline.missingFiles,
-    modifiedFiles: baseline.modifiedFiles,
-    missingDiscovery: missingDiscovery(root, manifest),
-    provenance: discoveryProvenance(root, manifest),
-    harnessProblems: problems,
-    warnings: typecheckWarnings(manifest.preset, evidence),
-    checks,
-    weakestLink: weakestLink(checks)
-  };
+function cursorRuleTarget(target) {
+  return `${CURSOR_RULES_DIR}${target.slice(CLAUDE_RULES_DIR.length, -".md".length)}.mdc`;
 }
+function toCursorRule(content) {
+  const rule = parseClaudeRule(content);
+  const always = rule.paths.length === 0;
+  const globs = always ? "" : `globs: ${rule.paths.join(", ")}
+`;
+  return `---
+description: ${rule.description}
+${globs}alwaysApply: ${always}
+---
 
-// src/commands/init.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import path20 from "path";
-
-// src/detect/index.ts
-import { existsSync as existsSync14 } from "fs";
-import path15 from "path";
-import process3 from "process";
+${rule.body}`;
+}
+function toCursorDiscoveryRule(content) {
+  const rule = parseClaudeRule(content);
+  const body = rule.body.replaceAll("$ARGUMENTS", "what the user asked to (re)discover");
+  return `---
+description: ${rule.description}
+alwaysApply: false
+---
 
-// src/detect/existing.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5 } from "fs";
-import path11 from "path";
-var ESLINT_CONFIGS = ["eslint.config.js", "eslint.config.mjs", "eslint.config.cjs", "eslint.config.ts", ".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json", ".eslintrc.yml"];
-var COMPOSITION_CANDIDATES = ["architecture/composition", "docs/architecture/composition", "docs/composition", "composition"];
-var OPENAPI_CANDIDATES = ["contracts/api/openapi.yaml", "contracts/api/openapi.yml", "contracts/openapi.yaml", "openapi.yaml", "openapi.yml", "openapi.json", "api/openapi.yaml", "docs/openapi.yaml"];
-function anyExists(dir, candidates) {
-  return candidates.some((candidate) => existsSync10(path11.join(dir, candidate)));
+${body}`;
 }
-function firstExisting(dir, candidates) {
-  return candidates.find((candidate) => existsSync10(path11.join(dir, candidate))) ?? null;
+function mapRulesForTargets(files, ai) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [target, content] of files) {
+    const rule = isClaudeRule(target);
+    const protocol = target === DISCOVERY_PROTOCOL;
+    if (!rule && !protocol) {
+      result.set(target, content);
+      continue;
+    }
+    if (ai !== "cursor")
+      result.set(target, content);
+    if (ai !== "claude")
+      result.set(protocol ? CURSOR_DISCOVERY_RULE : cursorRuleTarget(target), protocol ? toCursorDiscoveryRule(content) : toCursorRule(content));
+  }
+  return result;
 }
-function compositionDir(dir) {
-  return COMPOSITION_CANDIDATES.find((candidate) => {
-    const absolute = path11.join(dir, candidate);
-    return existsSync10(absolute) && readdirSync5(absolute).some((file) => file.endsWith(".yaml") || file.endsWith(".yml"));
-  }) ?? null;
+
+// src/materialize/strategies.ts
+var MERGE_JSON = /* @__PURE__ */ new Set(["package.json"]);
+var APPEND_BLOCK = /* @__PURE__ */ new Set([".gitignore", "CLAUDE.md", "AGENTS.md"]);
+var BLOCK_BEGIN = "<!-- construct:begin -->";
+var BLOCK_END = "<!-- construct:end -->";
+var GITIGNORE_BEGIN = "# construct:begin";
+var GITIGNORE_END = "# construct:end";
+function strategyFor(target) {
+  const basename = target.split("/").at(-1) ?? target;
+  if (MERGE_JSON.has(basename))
+    return "merge-json";
+  if (APPEND_BLOCK.has(basename))
+    return "append-block";
+  return "create";
 }
-function hasWorkflows(dir) {
-  const workflows = path11.join(dir, ".github", "workflows");
-  return existsSync10(workflows) && readdirSync5(workflows).some((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
+function isJsonObject(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
 }
-function detectExisting(dir) {
-  return {
-    packageJson: existsSync10(path11.join(dir, "package.json")),
-    tsconfig: existsSync10(path11.join(dir, "tsconfig.json")),
-    eslintConfig: anyExists(dir, ESLINT_CONFIGS),
-    githubWorkflows: hasWorkflows(dir),
-    claudeMd: existsSync10(path11.join(dir, "CLAUDE.md")),
-    agentsMd: existsSync10(path11.join(dir, "AGENTS.md")),
-    cursorRules: existsSync10(path11.join(dir, ".cursor", "rules")),
-    openapi: firstExisting(dir, OPENAPI_CANDIDATES),
-    compositionDir: compositionDir(dir),
-    constructJson: existsSync10(path11.join(dir, "construct.json"))
-  };
+function mergeJson(existing, incoming, conflicts, prefix = "") {
+  const result = { ...existing };
+  for (const [key, value] of Object.entries(incoming)) {
+    const at = prefix === "" ? key : `${prefix}.${key}`;
+    if (!(key in existing)) {
+      result[key] = value;
+      continue;
+    }
+    const current = existing[key];
+    if (isJsonObject(current) && isJsonObject(value)) {
+      result[key] = mergeJson(current, value, conflicts, at);
+      continue;
+    }
+    if (JSON.stringify(current) !== JSON.stringify(value))
+      conflicts.push(at);
+  }
+  return result;
 }
-
-// src/detect/layout.ts
-import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
-import path13 from "path";
-
-// src/detect/workspaces.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
-import path12 from "path";
-var TOP_LEVEL_PACKAGES_KEY = /^packages:(.*)$/m;
-var EMPTY_FLOW_SEQUENCE = /^\[\s*\]$/;
-var BLOCK_SEQUENCE_ENTRY = /^[ \t]+-[ \t]*\S/;
-function readIfPresent(file) {
-  if (!existsSync11(file))
-    return null;
-  try {
-    return readFileSync11(file, "utf8");
-  } catch {
+function blockMarkers(target) {
+  return target.endsWith(".gitignore") ? [GITIGNORE_BEGIN, GITIGNORE_END] : [BLOCK_BEGIN, BLOCK_END];
+}
+var DISCOVERY_OPEN = /<!-- construct:discover:([\w-]+) -->/g;
+function discoveryBlock(document, marker) {
+  const open = `<!-- construct:discover:${marker} -->`;
+  const close = `<!-- /construct:discover:${marker} -->`;
+  const start = document.indexOf(open);
+  const end = document.indexOf(close);
+  if (start === -1 || end === -1 || end < start)
     return null;
-  }
+  return { start: start + open.length, end, body: document.slice(start + open.length, end) };
 }
-function startsBlockSequence(rest) {
-  for (const line of rest.split("\n")) {
-    if (line.trim() === "" || line.trimStart().startsWith("#"))
+function withoutDiscoveryBodies(document) {
+  let result = document;
+  for (const [, marker] of document.matchAll(DISCOVERY_OPEN)) {
+    const block = discoveryBlock(result, marker);
+    if (block == null)
       continue;
-    return BLOCK_SEQUENCE_ENTRY.test(line);
+    result = `${result.slice(0, block.start)}${result.slice(block.end)}`;
   }
-  return false;
-}
-function declaresPnpmPackages(dir) {
-  const content = readIfPresent(path12.join(dir, "pnpm-workspace.yaml"));
-  if (content == null)
-    return false;
-  const match = TOP_LEVEL_PACKAGES_KEY.exec(content);
-  if (match == null)
-    return false;
-  const inline = match[1].trim();
-  if (inline.startsWith("["))
-    return !EMPTY_FLOW_SEQUENCE.test(inline);
-  if (inline !== "")
-    return false;
-  return startsBlockSequence(content.slice(match.index + match[0].length));
+  return result;
 }
-function declaresNpmWorkspaces(dir) {
-  const content = readIfPresent(path12.join(dir, "package.json"));
-  if (content == null)
-    return false;
-  let workspaces;
-  try {
-    ({ workspaces } = JSON.parse(content));
-  } catch {
-    return false;
+function preserveDiscovery(existing, incoming) {
+  let result = incoming;
+  for (const [, marker] of existing.matchAll(DISCOVERY_OPEN)) {
+    const previous = discoveryBlock(existing, marker);
+    const next = discoveryBlock(result, marker);
+    if (previous == null || next == null || previous.body.trim() === "" || previous.body.includes("_Not discovered yet"))
+      continue;
+    result = `${result.slice(0, next.start)}${previous.body}${result.slice(next.end)}`;
   }
-  if (Array.isArray(workspaces))
-    return workspaces.length > 0;
-  const packages = workspaces?.packages;
-  return Array.isArray(packages) && packages.length > 0;
-}
-
-// src/detect/layout.ts
-var IGNORED_ENTRIES = /* @__PURE__ */ new Set([".git", ".DS_Store", ".gitignore", ".gitattributes", "LICENSE", "README.md", ".idea", ".vscode"]);
-function isEmptyDir(dir) {
-  if (!existsSync12(dir))
-    return true;
-  return readdirSync6(dir).every((entry) => IGNORED_ENTRIES.has(entry));
+  return result;
 }
-function detectMonorepoTools(dir) {
-  const tools = [];
-  if (declaresPnpmPackages(dir))
-    tools.push("pnpm-workspace");
-  if (declaresNpmWorkspaces(dir))
-    tools.push("npm-workspaces");
-  if (existsSync12(path13.join(dir, "turbo.json")))
-    tools.push("turbo");
-  if (existsSync12(path13.join(dir, "nx.json")))
-    tools.push("nx");
-  return tools;
+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 detectWorkspaceDirs(dir) {
-  return ["apps", "packages", "libs", "services"].filter((name) => existsSync12(path13.join(dir, name)) && statSync3(path13.join(dir, name)).isDirectory());
+function withoutSecondH1(existing, block) {
+  if (existing.trim() === "" || !/^# /m.test(existing))
+    return block;
+  return block.replace(/^# (.*)$/m, "## $1");
 }
-function packageName(dir) {
-  try {
-    const parsed = JSON.parse(readFileSync12(path13.join(dir, "package.json"), "utf8"));
-    return typeof parsed.name === "string" && parsed.name !== "" ? parsed.name : null;
-  } catch {
-    return null;
-  }
+function appendBlock(existing, block, target) {
+  const [begin, end] = blockMarkers(target);
+  const wrapped = `${begin}
+${preserveDiscovery(existing, withoutSecondH1(existing, block)).trimEnd()}
+${end}
+`;
+  const start = existing.indexOf(begin);
+  const stop = existing.indexOf(end);
+  if (start !== -1 && stop !== -1 && stop > start)
+    return `${existing.slice(0, start)}${wrapped}${existing.slice(stop + end.length).replace(/^\n/, "")}`;
+  const separator = existing.length === 0 || existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+  return `${existing}${separator}${wrapped}`;
 }
-function detectWorkspacePackages(root, workspaceDirs) {
-  return workspaceDirs.flatMap((parent) => readdirSync6(path13.join(root, parent)).sort().map((entry) => `${parent}/${entry}`).filter((dir) => existsSync12(path13.join(root, dir, "package.json"))).map((dir) => ({ dir, name: packageName(path13.join(root, dir)) ?? dir.split("/").at(-1) ?? dir })));
+
+// src/materialize/templates.ts
+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 = [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 ${HERE2}`);
+  return found;
 }
-function detectLayout(dir, monorepoTools, workspaceDirs, hasSrc) {
-  if (isEmptyDir(dir))
-    return "empty";
-  if (monorepoTools.length > 0 || workspaceDirs.length > 0)
-    return "monorepo";
-  if (hasSrc || existsSync12(path13.join(dir, "package.json")))
-    return "single";
-  return "unknown";
+var EXISTING_SUFFIX = ".existing.eta";
+function toTargetPath(relative) {
+  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" };
 }
-
-// src/detect/package-manager.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
-import path14 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 = path14.join(dir, "package.json");
-  if (!existsSync13(manifest))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync13(manifest, "utf8"));
-    const name = parsed.packageManager?.split("@")[0];
-    return name === "pnpm" || name === "npm" || name === "yarn" || name === "bun" ? name : null;
-  } catch {
-    return null;
+function walk(root, current, files) {
+  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(path13.relative(root, absolute));
   }
 }
-function detectPackageManager(dir) {
-  const declared = fromPackageManagerField(dir);
-  if (declared != null)
-    return declared;
-  for (const [lockfile, manager] of LOCKFILES) {
-    if (existsSync13(path14.join(dir, lockfile)))
-      return manager;
-  }
-  return existsSync13(path14.join(dir, "package.json")) ? "npm" : "none";
+function listTemplateFiles(group) {
+  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: path13.join(root, relative), target, rendered, variant };
+  });
 }
-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;
+var BLOCK = /^[ \t]*\{\{#(if|unless) (\w+)\}\}[ \t]*\n([\s\S]*?)^[ \t]*\{\{\/\1\}\}[ \t]*\n/gm;
+var VARIABLE = /\{\{\s*(\w+)\s*\}\}/g;
+function lookup(vars, name, match) {
+  const value = vars[name];
+  if (value == null)
+    throw new Error(`template variable "${name}" is not defined (${match})`);
+  return value;
 }
-
-// src/detect/index.ts
-function detect(dir) {
-  const root = path15.resolve(dir);
-  const monorepoTools = detectMonorepoTools(root);
-  const workspaceDirs = detectWorkspaceDirs(root);
-  const hasSrc = existsSync14(path15.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(process3.versions.node.split(".")[0]),
-    existing: detectExisting(root)
-  };
+function isTruthy(value) {
+  return value !== "" && value !== "false";
 }
-
-// src/materialize/apply.ts
-import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
-import path16 from "path";
-function applyPlan(root, ops) {
-  const written = [];
-  for (const op of ops) {
-    if (op.action === "skip")
-      continue;
-    const absolute = path16.join(root, op.target);
-    mkdirSync(path16.dirname(absolute), { recursive: true });
-    writeFileSync2(absolute, op.content);
-    written.push(op);
-  }
-  return written;
+function render(template, vars) {
+  const expanded = template.replaceAll(BLOCK, (match, kind, name, body) => isTruthy(lookup(vars, name, match)) === (kind === "if") ? body : "");
+  return expanded.replaceAll(VARIABLE, (match, name) => lookup(vars, name, match));
 }
 
 // src/materialize/plan.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
-import path18 from "path";
-
-// src/materialize/rules.ts
-var CLAUDE_RULES_DIR = ".claude/rules/";
-var CURSOR_RULES_DIR = ".cursor/rules/";
-var DISCOVERY_PROTOCOL = ".claude/commands/construct-discover.md";
-var CURSOR_DISCOVERY_RULE = ".cursor/rules/construct-discover.mdc";
-var FRONTMATTER = /^---\n([\s\S]*?)\n---\n/;
-function unquote(value) {
-  return value.trim().replace(/^(["'])(.*)\1$/, "$2");
-}
-function parseFrontmatter(block) {
-  const paths = [];
-  let description;
-  let inPaths = false;
-  for (const line of block.split("\n")) {
-    const item = /^\s*-\s+(\S.*)$/.exec(line);
-    if (inPaths && item != null) {
-      paths.push(unquote(item[1]));
-      continue;
-    }
-    inPaths = /^paths:\s*$/.test(line);
-    const scalar = /^description:\s*(\S.*)$/.exec(line);
-    if (scalar != null)
-      description = unquote(scalar[1]);
-  }
-  return { description, paths };
-}
-function firstHeading(body) {
-  return /^#\s+(\S.*)$/m.exec(body)?.[1].trim();
-}
-function parseClaudeRule(content) {
-  const match = FRONTMATTER.exec(content);
-  const body = match == null ? content : content.slice(match[0].length).replace(/^\n+/, "");
-  const front = match == null ? { paths: [] } : parseFrontmatter(match[1]);
-  return { description: front.description ?? firstHeading(body) ?? "Project rule", paths: front.paths, body };
-}
-function isClaudeRule(target) {
-  return target.startsWith(CLAUDE_RULES_DIR) && target.endsWith(".md");
-}
-function cursorRuleTarget(target) {
-  return `${CURSOR_RULES_DIR}${target.slice(CLAUDE_RULES_DIR.length, -".md".length)}.mdc`;
-}
-function toCursorRule(content) {
-  const rule = parseClaudeRule(content);
-  const always = rule.paths.length === 0;
-  const globs = always ? "" : `globs: ${rule.paths.join(", ")}
-`;
-  return `---
-description: ${rule.description}
-${globs}alwaysApply: ${always}
----
-
-${rule.body}`;
-}
-function toCursorDiscoveryRule(content) {
-  const rule = parseClaudeRule(content);
-  const body = rule.body.replaceAll("$ARGUMENTS", "what the user asked to (re)discover");
-  return `---
-description: ${rule.description}
-alwaysApply: false
----
-
-${body}`;
-}
-function mapRulesForTargets(files, ai) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [target, content] of files) {
-    const rule = isClaudeRule(target);
-    const protocol = target === DISCOVERY_PROTOCOL;
-    if (!rule && !protocol) {
-      result.set(target, content);
-      continue;
-    }
-    if (ai !== "cursor")
-      result.set(target, content);
-    if (ai !== "claude")
-      result.set(protocol ? CURSOR_DISCOVERY_RULE : cursorRuleTarget(target), protocol ? toCursorDiscoveryRule(content) : toCursorRule(content));
-  }
-  return result;
-}
-
-// src/materialize/strategies.ts
-var MERGE_JSON = /* @__PURE__ */ new Set(["package.json"]);
-var APPEND_BLOCK = /* @__PURE__ */ new Set([".gitignore", "CLAUDE.md", "AGENTS.md"]);
-var BLOCK_BEGIN = "<!-- construct:begin -->";
-var BLOCK_END = "<!-- construct:end -->";
-var GITIGNORE_BEGIN = "# construct:begin";
-var GITIGNORE_END = "# construct:end";
-function strategyFor(target) {
-  const basename = target.split("/").at(-1) ?? target;
-  if (MERGE_JSON.has(basename))
-    return "merge-json";
-  if (APPEND_BLOCK.has(basename))
-    return "append-block";
-  return "create";
-}
-function isObject(value) {
-  return typeof value === "object" && value != null && !Array.isArray(value);
-}
-function mergeJson(existing, incoming, conflicts, prefix = "") {
-  const result = { ...existing };
-  for (const [key, value] of Object.entries(incoming)) {
-    const at = prefix === "" ? key : `${prefix}.${key}`;
-    if (!(key in existing)) {
-      result[key] = value;
-      continue;
-    }
-    const current = existing[key];
-    if (isObject(current) && isObject(value)) {
-      result[key] = mergeJson(current, value, conflicts, at);
-      continue;
-    }
-    if (JSON.stringify(current) !== JSON.stringify(value))
-      conflicts.push(at);
-  }
-  return result;
-}
-function markersFor(target) {
-  return target.endsWith(".gitignore") ? [GITIGNORE_BEGIN, GITIGNORE_END] : [BLOCK_BEGIN, BLOCK_END];
-}
-var DISCOVERY_OPEN = /<!-- construct:discover:([\w-]+) -->/g;
-function discoveryBlock(document, marker) {
-  const open = `<!-- construct:discover:${marker} -->`;
-  const close = `<!-- /construct:discover:${marker} -->`;
-  const start = document.indexOf(open);
-  const end = document.indexOf(close);
-  if (start === -1 || end === -1 || end < start)
-    return null;
-  return { start: start + open.length, end, body: document.slice(start + open.length, end) };
-}
-function preserveDiscovery(existing, incoming) {
-  let result = incoming;
-  for (const [, marker] of existing.matchAll(DISCOVERY_OPEN)) {
-    const previous = discoveryBlock(existing, marker);
-    const next = discoveryBlock(result, marker);
-    if (previous == null || next == null || previous.body.trim() === "" || previous.body.includes("_Not discovered yet"))
-      continue;
-    result = `${result.slice(0, next.start)}${previous.body}${result.slice(next.end)}`;
-  }
-  return result;
-}
-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 wrapped = `${begin}
-${preserveDiscovery(existing, withoutSecondH1(existing, block)).trimEnd()}
-${end}
-`;
-  const start = existing.indexOf(begin);
-  const stop = existing.indexOf(end);
-  if (start !== -1 && stop !== -1 && stop > start)
-    return `${existing.slice(0, start)}${wrapped}${existing.slice(stop + end.length).replace(/^\n/, "")}`;
-  const separator = existing.length === 0 || existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
-  return `${existing}${separator}${wrapped}`;
-}
-
-// src/materialize/templates.ts
-import { existsSync as existsSync15, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
-import path17 from "path";
-import { fileURLToPath } from "url";
-var HERE = path17.dirname(fileURLToPath(import.meta.url));
-function templatesRoot() {
-  const candidates = [path17.resolve(HERE, "../templates"), path17.resolve(HERE, "../../templates")];
-  const found = candidates.find((candidate) => existsSync15(candidate));
-  if (found == null)
-    throw new Error(`templates directory not found next to ${HERE}`);
-  return found;
-}
-var EXISTING_SUFFIX = ".existing.eta";
-function toTargetPath(relative) {
-  const segments = relative.split(path17.sep).map((segment) => segment.startsWith("_") ? `.${segment.slice(1)}` : segment);
-  const joined = segments.join("/");
-  if (joined.endsWith(EXISTING_SUFFIX))
-    return { target: joined.slice(0, -EXISTING_SUFFIX.length), rendered: true, variant: "existing" };
-  return joined.endsWith(".eta") ? { target: joined.slice(0, -".eta".length), rendered: true, variant: "default" } : { target: joined, rendered: false, variant: "default" };
-}
-function walk(root, current, files) {
-  for (const entry of readdirSync7(current).sort()) {
-    const absolute = path17.join(current, entry);
-    if (statSync4(absolute).isDirectory())
-      walk(root, absolute, files);
-    else if (entry !== ".DS_Store")
-      files.push(path17.relative(root, absolute));
-  }
-}
-function listTemplateFiles(group) {
-  const root = path17.join(templatesRoot(), group);
-  if (!existsSync15(root))
-    throw new Error(`template group "${group}" does not exist`);
-  const files = [];
-  walk(root, root, files);
-  return files.map((relative) => {
-    const { target, rendered, variant } = toTargetPath(relative);
-    return { group, source: path17.join(root, relative), target, rendered, variant };
-  });
-}
-var BLOCK = /^[ \t]*\{\{#(if|unless) (\w+)\}\}[ \t]*\n([\s\S]*?)^[ \t]*\{\{\/\1\}\}[ \t]*\n/gm;
-var VARIABLE = /\{\{\s*(\w+)\s*\}\}/g;
-function lookup(vars, name, match) {
-  const value = vars[name];
-  if (value == null)
-    throw new Error(`template variable "${name}" is not defined (${match})`);
-  return value;
-}
-function isTruthy(value) {
-  return value !== "" && value !== "false";
-}
-function render(template, vars) {
-  const expanded = template.replaceAll(BLOCK, (match, kind, name, body) => isTruthy(lookup(vars, name, match)) === (kind === "if") ? body : "");
-  return expanded.replaceAll(VARIABLE, (match, name) => lookup(vars, name, match));
-}
-
-// src/materialize/plan.ts
-function toMount(group) {
-  return typeof group === "string" ? { group } : group;
+function toMount(group) {
+  return typeof group === "string" ? { group } : group;
 }
 function mountTarget(mount, target) {
   return mount.into == null || mount.into === "." ? target : `${mount.into.replace(/\/$/, "")}/${target}`;
 }
 function readTemplate(source, rendered, vars) {
-  const raw = readFileSync14(source, "utf8");
+  const raw = readFileSync12(source, "utf8");
   return rendered ? render(raw, vars) : raw;
 }
 var SORTED_SECTIONS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
@@ -1535,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 = path18.join(root, target);
-  const exists = existsSync16(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(readFileSync14(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];
@@ -1551,8 +1387,14 @@ function planOne(root, target, content, conflicts, existingVariant) {
 ` };
   }
   if (strategy === "append-block") {
-    const existing = readFileSync14(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" };
 }
@@ -1577,142 +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 };
+  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";
+}
+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/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(", ")}],`);
+// 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 },
-      "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
@@ -1785,24 +2228,6 @@ function createClackPrompter(lore, streams = {}) {
   };
 }
 
-// src/version.ts
-import { readFileSync as readFileSync15 } from "fs";
-import path19 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var HERE2 = path19.dirname(fileURLToPath2(import.meta.url));
-function readVersion() {
-  for (const candidate of ["../package.json", "../../package.json"]) {
-    try {
-      const parsed = JSON.parse(readFileSync15(path19.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";
@@ -1826,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 };
 }
@@ -1893,7 +2325,7 @@ async function askChoices(ui2, options, report, root, prompter) {
   return { presetId, ai, projectName, review };
 }
 async function runInit(ui2, options, prompter) {
-  const root = path20.resolve(options.dir);
+  const root = path21.resolve(options.dir);
   mkdirSync2(root, { recursive: true });
   if (!options.yes && prompter == null) {
     ui2.glitch(ui2.lore.needsTerminal);
@@ -1931,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 ?? "",
@@ -1957,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);
@@ -1970,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`],
@@ -1980,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 process4 from "process";
 
 // src/ui/lore.ts
+var BLOCK_REPLACED_WHOLE = "block-replaced-whole-discovery-bodies-carried-over";
 var BANNER = String.raw`
   ███╗   ███╗██╗██╗  ██╗ ██████╗ ███████╗██╗  ██╗██╗
   ████╗ ████║██║██║ ██╔╝██╔═══██╗██╔════╝██║  ██║██║
@@ -2021,6 +2655,9 @@ var LORE = {
   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}`,
@@ -2046,7 +2683,38 @@ var LORE = {
   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"
+  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}`,
@@ -2078,6 +2746,9 @@ var PLAIN_LORE = {
   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}`,
@@ -2103,7 +2774,38 @@ var PLAIN_LORE = {
   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"
+  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
@@ -2305,7 +3007,7 @@ var cost = defineCommand({
     json: { type: "boolean", description: "Machine-readable report", default: false }
   },
   run({ args }) {
-    const report = costReport(path21.resolve(args.dir));
+    const report = costReport(path22.resolve(args.dir));
     if (args.json) {
       process6.stdout.write(`${JSON.stringify(costJson(report, args.last), null, 2)}
 `);
@@ -2315,6 +3017,41 @@ var cost = defineCommand({
     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);
+    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({
   meta: {
     name: "construct",
@@ -2327,6 +3064,7 @@ var main = defineCommand({
     inspect: soulkill,
     capture: soulkill,
     doctor,
+    sync,
     cost
   }
 });