mikoshi-construct 0.1.0

package/dist/cli.js

@@ -0,0 +1,1492 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import path13 from "path";
+import process4 from "process";
+import { isTTY } from "@clack/prompts";
+import { defineCommand, runMain } from "citty";
+
+// src/commands/cost.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+function emptyUsage() {
+  return { calls: 0, input: 0, cacheWrite: 0, cacheRead: 0, output: 0, models: [] };
+}
+function billable(usage) {
+  return usage.input + usage.cacheWrite + usage.cacheRead + usage.output;
+}
+var PRICE_RELATIVE_TO_INPUT = { cacheWrite: 1.25, cacheRead: 0.1, output: 5 };
+function weighted(usage) {
+  return Math.round(usage.input + usage.cacheWrite * PRICE_RELATIVE_TO_INPUT.cacheWrite + usage.cacheRead * PRICE_RELATIVE_TO_INPUT.cacheRead + usage.output * PRICE_RELATIVE_TO_INPUT.output);
+}
+function add(total, part) {
+  total.calls += part.calls;
+  total.input += part.input;
+  total.cacheWrite += part.cacheWrite;
+  total.cacheRead += part.cacheRead;
+  total.output += part.output;
+  for (const model of part.models) {
+    if (!total.models.includes(model))
+      total.models.push(model);
+  }
+}
+function projectKey(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+function claudeProjectsDir() {
+  return path.join(homedir(), ".claude", "projects");
+}
+function readUsage(file) {
+  const totals = emptyUsage();
+  for (const line of readFileSync(file, "utf8").split("\n")) {
+    if (!line.startsWith("{"))
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const message = entry.message;
+    if (message?.role !== "assistant" || message.usage == null)
+      continue;
+    totals.calls += 1;
+    totals.input += message.usage.input_tokens ?? 0;
+    totals.cacheWrite += message.usage.cache_creation_input_tokens ?? 0;
+    totals.cacheRead += message.usage.cache_read_input_tokens ?? 0;
+    totals.output += message.usage.output_tokens ?? 0;
+    if (message.model != null && !totals.models.includes(message.model))
+      totals.models.push(message.model);
+  }
+  return totals;
+}
+function directories(parent) {
+  if (!existsSync(parent))
+    return [];
+  return readdirSync(parent).map((name) => path.join(parent, name)).filter((entry) => statSync(entry).isDirectory());
+}
+function collectRuns(sessionDir) {
+  return directories(path.join(sessionDir, "subagents", "workflows")).map((dir) => {
+    const agents = readdirSync(dir).filter((file) => file.startsWith("agent-") && file.endsWith(".jsonl")).map((file) => {
+      const metaPath = path.join(dir, file.replace(/\.jsonl$/, ".meta.json"));
+      const meta = existsSync(metaPath) ? JSON.parse(readFileSync(metaPath, "utf8")) : {};
+      return { label: meta.description ?? path.basename(file), type: meta.agentType ?? "?", usage: readUsage(path.join(dir, file)) };
+    });
+    const total = emptyUsage();
+    for (const agent of agents)
+      add(total, agent.usage);
+    return { session: path.basename(sessionDir), run: path.basename(dir), startedAt: statSync(dir).mtime.toISOString(), agents, total };
+  });
+}
+function collectWorkflowRuns(cwd, projectsDir = claudeProjectsDir()) {
+  const projectDir = path.join(projectsDir, projectKey(cwd));
+  if (!existsSync(projectDir))
+    return null;
+  return directories(projectDir).flatMap(collectRuns).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+function fmt(value) {
+  return value.toLocaleString("en-US");
+}
+function printCost(ui2, runs, last) {
+  if (runs == null) {
+    ui2.flatline("No Claude Code session data for this directory.");
+    return 1;
+  }
+  const selected = last ? runs.slice(-1) : runs;
+  if (selected.length === 0) {
+    ui2.glitch("No /implement runs recorded here yet.");
+    return 0;
+  }
+  const grand = emptyUsage();
+  for (const run of selected) {
+    ui2.line(`${ui2.theme.accent(run.run)} ${ui2.theme.dim(`${run.startedAt} \xB7 ${run.total.models.join(", ")}`)}`);
+    for (const agent of run.agents) {
+      ui2.line(`  ${agent.type.padEnd(12)} ${agent.label.padEnd(28)} calls ${String(agent.usage.calls).padStart(3)}  in ${fmt(agent.usage.input).padStart(8)}  cache-w ${fmt(agent.usage.cacheWrite).padStart(9)}  cache-r ${fmt(agent.usage.cacheRead).padStart(10)}  out ${fmt(agent.usage.output).padStart(7)}`);
+    }
+    ui2.line(`  ${ui2.theme.bold(`total ${fmt(billable(run.total))} billable tokens in ${run.total.calls} calls`)} ${ui2.theme.dim(`\u2248 ${fmt(weighted(run.total))} input-equivalent`)}`);
+    ui2.line();
+    add(grand, run.total);
+  }
+  if (selected.length > 1)
+    ui2.line(`${ui2.theme.bold(`${selected.length} runs: ${fmt(billable(grand))} billable tokens in ${grand.calls} calls`)} ${ui2.theme.dim(`\u2248 ${fmt(weighted(grand))} input-equivalent (cache-write \xD7${PRICE_RELATIVE_TO_INPUT.cacheWrite}, cache-read \xD7${PRICE_RELATIVE_TO_INPUT.cacheRead}, output \xD7${PRICE_RELATIVE_TO_INPUT.output})`)}`);
+  return 0;
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import path3 from "path";
+
+// src/manifest.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import path2 from "path";
+var MANIFEST_FILE = "construct.json";
+var DISCOVERY_MARKERS = [
+  "product",
+  "module-map",
+  "commands",
+  "composition-roots",
+  "dependency-policy",
+  "high-effort-areas",
+  "composition",
+  "security-invariants",
+  "defects-vs-variance",
+  "open-questions"
+];
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function markerFile(marker, compositionDir2 = "architecture/composition") {
+  switch (marker) {
+    case "composition":
+      return compositionDir2;
+    case "security-invariants":
+      return "architecture/security-invariants.md";
+    default:
+      return "AGENTS.md";
+  }
+}
+function buildManifest(input) {
+  const files = {};
+  for (const op of input.written)
+    files[op.target] = sha256(op.content);
+  const discovery = Object.fromEntries(DISCOVERY_MARKERS.map((marker) => [marker, markerFile(marker, input.vars.compositionDir)]));
+  return {
+    construct: input.version,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    preset: input.preset,
+    ai: input.ai,
+    review: input.review === "none" ? null : { provider: input.review, model: input.vars.reviewModel },
+    harness: { command: input.vars.harnessCommand },
+    report: { usage: true },
+    contracts: input.contracts ? { path: input.vars.contractPath, types: input.vars.contractTypesOutput } : null,
+    vars: input.vars,
+    files,
+    discovery
+  };
+}
+function writeManifest(root, manifest) {
+  writeFileSync(path2.join(root, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function readManifest(root) {
+  const file = path2.join(root, MANIFEST_FILE);
+  if (!existsSync2(file))
+    return null;
+  return JSON.parse(readFileSync2(file, "utf8"));
+}
+
+// src/commands/doctor.ts
+var DISCOVERY_PLACEHOLDER = "_Not discovered yet \u2014 run `/construct-discover`._";
+function markerOpen(marker) {
+  return `<!-- construct:discover:${marker} -->`;
+}
+function markerClose(marker) {
+  return `<!-- /construct:discover:${marker} -->`;
+}
+function isMarkerFilled(document, marker) {
+  const start = document.indexOf(markerOpen(marker));
+  const stop = document.indexOf(markerClose(marker));
+  if (start === -1 || stop === -1 || stop < start)
+    return false;
+  const body = document.slice(start + markerOpen(marker).length, stop).trim();
+  return body !== "" && body !== DISCOVERY_PLACEHOLDER;
+}
+var REQUIRED_QUALITY_STEPS = ["lint", "typecheck", "test"];
+function contractProblems(root, contracts, scriptName, quality) {
+  if (contracts == null)
+    return [];
+  const problems = [contracts.path, contracts.types].filter((file) => !existsSync3(path3.join(root, file))).map((file) => `${file} is missing (construct.json \u2192 contracts)`);
+  if (!quality.includes("contracts:check"))
+    problems.push(`"${scriptName}" does not run contracts:check`);
+  return problems;
+}
+function harnessProblems(root, manifest) {
+  const command = manifest.harness.command;
+  const manifestPath = path3.join(root, "package.json");
+  if (!existsSync3(manifestPath))
+    return ["package.json is missing"];
+  const pkg = JSON.parse(readFileSync3(manifestPath, "utf8"));
+  const scripts = pkg.scripts ?? {};
+  const scriptName = command.replace(/^(pnpm|npm|yarn|bun)\s+(run\s+)?/, "");
+  const quality = scripts[scriptName];
+  if (quality == null)
+    return [`package.json has no "${scriptName}" script (harness command is "${command}")`];
+  return [
+    ...REQUIRED_QUALITY_STEPS.filter((step) => !quality.includes(step)).map((step) => `"${scriptName}" does not run ${step}`),
+    ...contractProblems(root, manifest.contracts, scriptName, quality)
+  ];
+}
+function runDoctor(root) {
+  const manifest = readManifest(root);
+  if (manifest == null)
+    return null;
+  const missingFiles = [];
+  const modifiedFiles = [];
+  for (const [file, hash] of Object.entries(manifest.files)) {
+    const absolute = path3.join(root, file);
+    if (!existsSync3(absolute))
+      missingFiles.push(file);
+    else if (sha256(readFileSync3(absolute, "utf8")) !== hash)
+      modifiedFiles.push(file);
+  }
+  const missingDiscovery = DISCOVERY_MARKERS.filter((marker) => {
+    const location = path3.join(root, manifest.discovery[marker]);
+    if (marker === "composition")
+      return !existsSync3(location) || !readdirSync2(location).some((file) => file.endsWith(".yaml"));
+    return !existsSync3(location) || !isMarkerFilled(readFileSync3(location, "utf8"), marker);
+  });
+  const problems = harnessProblems(root, manifest);
+  return {
+    ok: missingFiles.length === 0 && problems.length === 0,
+    missingFiles,
+    modifiedFiles,
+    missingDiscovery,
+    harnessProblems: problems
+  };
+}
+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.modifiedFiles.length > 0)
+    ui2.line(ui2.theme.dim(`  ${result.modifiedFiles.length} baseline files modified since init (expected once the project evolves).`));
+  if (result.ok) {
+    ui2.ok(ui2.lore.stable);
+    return 0;
+  }
+  return 1;
+}
+
+// src/commands/init.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import path12 from "path";
+
+// src/detect/index.ts
+import { existsSync as existsSync7 } from "fs";
+import path7 from "path";
+import process from "process";
+
+// src/detect/existing.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3 } from "fs";
+import path4 from "path";
+var ESLINT_CONFIGS = ["eslint.config.js", "eslint.config.mjs", "eslint.config.cjs", "eslint.config.ts", ".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json", ".eslintrc.yml"];
+var COMPOSITION_CANDIDATES = ["architecture/composition", "docs/architecture/composition", "docs/composition", "composition"];
+var OPENAPI_CANDIDATES = ["contracts/api/openapi.yaml", "contracts/api/openapi.yml", "contracts/openapi.yaml", "openapi.yaml", "openapi.yml", "openapi.json", "api/openapi.yaml", "docs/openapi.yaml"];
+function anyExists(dir, candidates) {
+  return candidates.some((candidate) => existsSync4(path4.join(dir, candidate)));
+}
+function firstExisting(dir, candidates) {
+  return candidates.find((candidate) => existsSync4(path4.join(dir, candidate))) ?? null;
+}
+function compositionDir(dir) {
+  return COMPOSITION_CANDIDATES.find((candidate) => {
+    const absolute = path4.join(dir, candidate);
+    return existsSync4(absolute) && readdirSync3(absolute).some((file) => file.endsWith(".yaml") || file.endsWith(".yml"));
+  }) ?? null;
+}
+function hasWorkflows(dir) {
+  const workflows = path4.join(dir, ".github", "workflows");
+  return existsSync4(workflows) && readdirSync3(workflows).some((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
+}
+function detectExisting(dir) {
+  return {
+    packageJson: existsSync4(path4.join(dir, "package.json")),
+    tsconfig: existsSync4(path4.join(dir, "tsconfig.json")),
+    eslintConfig: anyExists(dir, ESLINT_CONFIGS),
+    githubWorkflows: hasWorkflows(dir),
+    claudeMd: existsSync4(path4.join(dir, "CLAUDE.md")),
+    agentsMd: existsSync4(path4.join(dir, "AGENTS.md")),
+    cursorRules: existsSync4(path4.join(dir, ".cursor", "rules")),
+    openapi: firstExisting(dir, OPENAPI_CANDIDATES),
+    compositionDir: compositionDir(dir),
+    constructJson: existsSync4(path4.join(dir, "construct.json"))
+  };
+}
+
+// src/detect/layout.ts
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import path5 from "path";
+var IGNORED_ENTRIES = /* @__PURE__ */ new Set([".git", ".DS_Store", ".gitignore", ".gitattributes", "LICENSE", "README.md", ".idea", ".vscode"]);
+function isEmptyDir(dir) {
+  if (!existsSync5(dir))
+    return true;
+  return readdirSync4(dir).every((entry) => IGNORED_ENTRIES.has(entry));
+}
+function hasWorkspacesField(dir) {
+  const manifest = path5.join(dir, "package.json");
+  if (!existsSync5(manifest))
+    return false;
+  try {
+    const parsed = JSON.parse(readFileSync4(manifest, "utf8"));
+    return parsed.workspaces != null;
+  } catch {
+    return false;
+  }
+}
+function detectMonorepoTools(dir) {
+  const tools = [];
+  if (existsSync5(path5.join(dir, "pnpm-workspace.yaml")))
+    tools.push("pnpm-workspace");
+  if (hasWorkspacesField(dir))
+    tools.push("npm-workspaces");
+  if (existsSync5(path5.join(dir, "turbo.json")))
+    tools.push("turbo");
+  if (existsSync5(path5.join(dir, "nx.json")))
+    tools.push("nx");
+  return tools;
+}
+function detectWorkspaceDirs(dir) {
+  return ["apps", "packages", "libs", "services"].filter((name) => existsSync5(path5.join(dir, name)) && statSync2(path5.join(dir, name)).isDirectory());
+}
+function packageName(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync4(path5.join(dir, "package.json"), "utf8"));
+    return typeof parsed.name === "string" && parsed.name !== "" ? parsed.name : null;
+  } catch {
+    return null;
+  }
+}
+function detectWorkspacePackages(root, workspaceDirs) {
+  return workspaceDirs.flatMap((parent) => readdirSync4(path5.join(root, parent)).sort().map((entry) => `${parent}/${entry}`).filter((dir) => existsSync5(path5.join(root, dir, "package.json"))).map((dir) => ({ dir, name: packageName(path5.join(root, dir)) ?? dir.split("/").at(-1) ?? dir })));
+}
+function detectLayout(dir, monorepoTools, workspaceDirs, hasSrc) {
+  if (isEmptyDir(dir))
+    return "empty";
+  if (monorepoTools.length > 0 || workspaceDirs.length > 0)
+    return "monorepo";
+  if (hasSrc || existsSync5(path5.join(dir, "package.json")))
+    return "single";
+  return "unknown";
+}
+
+// src/detect/package-manager.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import path6 from "path";
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"]
+];
+function fromPackageManagerField(dir) {
+  const manifest = path6.join(dir, "package.json");
+  if (!existsSync6(manifest))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync5(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 (existsSync6(path6.join(dir, lockfile)))
+      return manager;
+  }
+  return existsSync6(path6.join(dir, "package.json")) ? "npm" : "none";
+}
+var pnpmVersionCache;
+function detectPnpmVersion() {
+  if (pnpmVersionCache !== void 0)
+    return pnpmVersionCache;
+  try {
+    pnpmVersionCache = execFileSync("pnpm", ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+  } catch {
+    pnpmVersionCache = null;
+  }
+  return pnpmVersionCache;
+}
+
+// src/detect/index.ts
+function detect(dir) {
+  const root = path7.resolve(dir);
+  const monorepoTools = detectMonorepoTools(root);
+  const workspaceDirs = detectWorkspaceDirs(root);
+  const hasSrc = existsSync7(path7.join(root, "src"));
+  return {
+    dir: root,
+    packageManager: detectPackageManager(root),
+    pnpmVersion: detectPnpmVersion(),
+    layout: detectLayout(root, monorepoTools, workspaceDirs, hasSrc),
+    monorepoTools,
+    workspaceDirs,
+    workspacePackages: detectWorkspacePackages(root, workspaceDirs),
+    hasSrc,
+    nodeMajor: Number(process.versions.node.split(".")[0]),
+    existing: detectExisting(root)
+  };
+}
+
+// src/materialize/apply.ts
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import path8 from "path";
+function applyPlan(root, ops) {
+  const written = [];
+  for (const op of ops) {
+    if (op.action === "skip")
+      continue;
+    const absolute = path8.join(root, op.target);
+    mkdirSync(path8.dirname(absolute), { recursive: true });
+    writeFileSync2(absolute, op.content);
+    written.push(op);
+  }
+  return written;
+}
+
+// src/materialize/plan.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import path10 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 existsSync8, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import path9 from "path";
+import { fileURLToPath } from "url";
+var HERE = path9.dirname(fileURLToPath(import.meta.url));
+function templatesRoot() {
+  const candidates = [path9.resolve(HERE, "../templates"), path9.resolve(HERE, "../../templates")];
+  const found = candidates.find((candidate) => existsSync8(candidate));
+  if (found == null)
+    throw new Error(`templates directory not found next to ${HERE}`);
+  return found;
+}
+var EXISTING_SUFFIX = ".existing.eta";
+function toTargetPath(relative) {
+  const segments = relative.split(path9.sep).map((segment) => segment.startsWith("_") ? `.${segment.slice(1)}` : segment);
+  const joined = segments.join("/");
+  if (joined.endsWith(EXISTING_SUFFIX))
+    return { target: joined.slice(0, -EXISTING_SUFFIX.length), rendered: true, variant: "existing" };
+  return joined.endsWith(".eta") ? { target: joined.slice(0, -".eta".length), rendered: true, variant: "default" } : { target: joined, rendered: false, variant: "default" };
+}
+function walk(root, current, files) {
+  for (const entry of readdirSync5(current).sort()) {
+    const absolute = path9.join(current, entry);
+    if (statSync3(absolute).isDirectory())
+      walk(root, absolute, files);
+    else if (entry !== ".DS_Store")
+      files.push(path9.relative(root, absolute));
+  }
+}
+function listTemplateFiles(group) {
+  const root = path9.join(templatesRoot(), group);
+  if (!existsSync8(root))
+    throw new Error(`template group "${group}" does not exist`);
+  const files = [];
+  walk(root, root, files);
+  return files.map((relative) => {
+    const { target, rendered, variant } = toTargetPath(relative);
+    return { group, source: path9.join(root, relative), target, rendered, variant };
+  });
+}
+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 mountTarget(mount, target) {
+  return mount.into == null || mount.into === "." ? target : `${mount.into.replace(/\/$/, "")}/${target}`;
+}
+function readTemplate(source, rendered, vars) {
+  const raw = readFileSync6(source, "utf8");
+  return rendered ? render(raw, vars) : raw;
+}
+var SORTED_SECTIONS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+var MANIFEST_KEY_ORDER = [
+  "name",
+  "type",
+  "version",
+  "private",
+  "packageManager",
+  "description",
+  "author",
+  "license",
+  "homepage",
+  "repository",
+  "bugs",
+  "keywords",
+  "sideEffects",
+  "exports",
+  "main",
+  "module",
+  "types",
+  "bin",
+  "files",
+  "engines",
+  "scripts",
+  "peerDependencies",
+  "dependencies",
+  "optionalDependencies",
+  "devDependencies",
+  "pnpm",
+  "overrides"
+];
+function sortSections(manifest) {
+  const result = { ...manifest };
+  for (const section of SORTED_SECTIONS) {
+    const value = result[section];
+    if (typeof value === "object" && value != null && !Array.isArray(value))
+      result[section] = Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
+  }
+  return result;
+}
+function orderManifestKeys(manifest) {
+  const rank = (key) => {
+    const index = MANIFEST_KEY_ORDER.indexOf(key);
+    return index === -1 ? MANIFEST_KEY_ORDER.length : index;
+  };
+  return Object.fromEntries(Object.entries(manifest).sort(([a], [b]) => rank(a) - rank(b)));
+}
+function layerJson(earlier, later) {
+  const base = JSON.parse(earlier);
+  const override = JSON.parse(later);
+  return `${JSON.stringify(orderManifestKeys(sortSections(mergeJson(override, base, []))), null, 2)}
+`;
+}
+var NOT_ADDED_TO_EXISTING_MANIFEST = ["version"];
+function planOne(root, target, content, conflicts, existingVariant) {
+  const strategy = strategyFor(target);
+  const absolute = path10.join(root, target);
+  const exists = existsSync9(absolute);
+  if (!exists)
+    return { target, strategy, action: "create", content: strategy === "append-block" ? appendBlock("", content, target) : content };
+  if (strategy === "merge-json") {
+    const existing = JSON.parse(readFileSync6(absolute, "utf8"));
+    const incoming = JSON.parse(content);
+    for (const key of NOT_ADDED_TO_EXISTING_MANIFEST)
+      delete incoming[key];
+    const localConflicts = [];
+    const merged = mergeJson(existing, incoming, localConflicts);
+    conflicts.push(...localConflicts.map((key) => `${target}: ${key}`));
+    return { target, strategy, action: "merge", content: `${JSON.stringify(orderManifestKeys(sortSections(merged)), null, 2)}
+` };
+  }
+  if (strategy === "append-block") {
+    const existing = readFileSync6(absolute, "utf8");
+    return { target, strategy, action: "append", content: appendBlock(existing, existingVariant ?? content, target) };
+  }
+  return { target, strategy, action: "skip", content, note: "exists, review manually" };
+}
+function planMaterialize(root, groups, vars, options) {
+  const conflicts = [];
+  const omittedGroups = [];
+  const layered = /* @__PURE__ */ new Map();
+  const existingVariants = /* @__PURE__ */ new Map();
+  for (const mount of groups.map(toMount)) {
+    if (mount.onlyWhenEmpty === true && !options.emptyTarget) {
+      omittedGroups.push(mount.group);
+      continue;
+    }
+    for (const file of listTemplateFiles(mount.group)) {
+      const target = mountTarget(mount, file.target);
+      const content = readTemplate(file.source, file.rendered, vars);
+      if (file.variant === "existing") {
+        existingVariants.set(target, content);
+        continue;
+      }
+      const previous = layered.get(target);
+      layered.set(target, previous == null || strategyFor(target) !== "merge-json" ? content : layerJson(previous, content));
+    }
+  }
+  const ops = [...mapRulesForTargets(layered, options.ai).entries()].map(([target, content]) => planOne(root, target, content, conflicts, existingVariants.get(target))).sort((a, b) => a.target.localeCompare(b.target));
+  return { ops, conflicts, omittedGroups };
+}
+
+// src/presets/index.ts
+var AI_TARGET_LABELS = {
+  claude: "Claude Code",
+  cursor: "Cursor",
+  both: "Claude Code, Cursor"
+};
+var EXPRESS_APP = "stacks/express-api/app";
+var EXPRESS_REPO = "stacks/express-api/repo";
+var HTTP_CONTRACT = "stacks/http-contract";
+function sampleWorkspace(scope) {
+  return [
+    { dir: "packages/shared", name: `${scope}/shared` },
+    { dir: "apps/api", name: `${scope}/api` }
+  ];
+}
+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/ui/prompts.ts
+import { cancel, confirm, isCancel, multiselect, select, text } from "@clack/prompts";
+var PROJECT_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+function isValidProjectName(value) {
+  return PROJECT_NAME_PATTERN.test(value);
+}
+function toAiTarget(selected) {
+  if (selected.includes("claude") && selected.includes("cursor"))
+    return "both";
+  return selected.includes("cursor") ? "cursor" : "claude";
+}
+function fromAiTarget(target) {
+  return target === "both" ? ["claude", "cursor"] : [target];
+}
+function createClackPrompter(lore, streams = {}) {
+  const settle = (value) => {
+    if (isCancel(value)) {
+      cancel(lore.cancelled, streams);
+      return void 0;
+    }
+    return value;
+  };
+  return {
+    async preset(choices, initial) {
+      const answer = await select({
+        ...streams,
+        message: lore.askPreset,
+        options: choices.map((choice) => ({
+          value: choice.id,
+          label: choice.label,
+          hint: choice.available ? choice.description : lore.presetUnavailable,
+          disabled: !choice.available
+        })),
+        initialValue: initial
+      });
+      return settle(answer);
+    },
+    async aiTarget(initial) {
+      const answer = await multiselect({
+        ...streams,
+        message: lore.askAi,
+        options: [
+          { value: "claude", label: AI_TARGET_LABELS.claude },
+          { value: "cursor", label: AI_TARGET_LABELS.cursor }
+        ],
+        initialValues: fromAiTarget(initial),
+        required: true
+      });
+      const selected = settle(answer);
+      return selected == null ? void 0 : toAiTarget(selected);
+    },
+    async projectName(initial) {
+      const answer = await text({
+        ...streams,
+        message: lore.askName,
+        initialValue: initial,
+        validate: (value2) => isValidProjectName(value2 ?? "") ? void 0 : lore.nameInvalid
+      });
+      const value = settle(answer);
+      return value?.trim();
+    },
+    async review(initial) {
+      return settle(await confirm({ ...streams, message: lore.askReview, initialValue: initial }));
+    },
+    async confirm(message) {
+      return settle(await confirm({ ...streams, message, initialValue: true }));
+    }
+  };
+}
+
+// src/version.ts
+import { readFileSync as readFileSync7 } from "fs";
+import path11 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var HERE2 = path11.dirname(fileURLToPath2(import.meta.url));
+function readVersion() {
+  for (const candidate of ["../package.json", "../../package.json"]) {
+    try {
+      const parsed = JSON.parse(readFileSync7(path11.resolve(HERE2, candidate), "utf8"));
+      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";
+}
+function printDetectReport(ui2, report) {
+  const layout = report.layout === "monorepo" && report.monorepoTools.length > 0 ? `monorepo (${report.monorepoTools.join(", ")})` : report.layout;
+  ui2.tree([
+    ["Directory", report.dir],
+    ["Runtime", `Node.js ${report.nodeMajor}`],
+    ["Package manager", report.pnpmVersion == null ? report.packageManager : `${report.packageManager} (pnpm ${report.pnpmVersion} installed)`],
+    ["Layout", layout],
+    ["Workspace dirs", report.workspaceDirs.length > 0 ? `${report.workspaceDirs.join(", ")} (${report.workspacePackages.length} packages)` : "none"],
+    ["src/", yesNo(report.hasSrc)],
+    ["Contracts", report.existing.openapi ?? "none"],
+    ["tsconfig / ESLint config", `${yesNo(report.existing.tsconfig)} / ${yesNo(report.existing.eslintConfig)}`],
+    ["GitHub workflows", yesNo(report.existing.githubWorkflows)],
+    ["CLAUDE.md / AGENTS.md / .cursor/rules", `${yesNo(report.existing.claudeMd)} / ${yesNo(report.existing.agentsMd)} / ${yesNo(report.existing.cursorRules)}`],
+    ["construct.json", yesNo(report.existing.constructJson)]
+  ]);
+}
+
+// src/commands/init.ts
+var CANCELLED = /* @__PURE__ */ Symbol("cancelled");
+function aborted(skipped = [], conflicts = []) {
+  return { status: "aborted", written: [], skipped, conflicts };
+}
+function suggestedPreset(report) {
+  if (report.layout === "unknown")
+    return void 0;
+  return report.layout === "monorepo" ? "monorepo" : "node-backend";
+}
+function parsePreset(value) {
+  if (!isPresetId(value))
+    throw new Error(`unknown preset "${value}"`);
+  return value;
+}
+function parseAi(value) {
+  if (value === "claude" || value === "cursor" || value === "both")
+    return value;
+  throw new Error(`unknown AI target "${value}" (claude | cursor | both)`);
+}
+function parseReview(value) {
+  if (value === "claude" || value === "none")
+    return value;
+  throw new Error(`unknown review provider "${value}" (claude | none)`);
+}
+function parseProjectName(value) {
+  if (!isValidProjectName(value))
+    throw new Error(`invalid project name "${value}"`);
+  return value;
+}
+async function askChoices(ui2, options, report, root, prompter) {
+  const suggested = suggestedPreset(report);
+  let presetId = options.preset == null ? void 0 : parsePreset(options.preset);
+  if (presetId == null) {
+    if (report.layout === "unknown")
+      ui2.glitch(ui2.lore.unknownStructure);
+    if (prompter == null) {
+      if (suggested == null)
+        return CANCELLED;
+      presetId = suggested;
+    } else {
+      presetId = await prompter.preset(PRESET_LIST, suggested);
+      if (presetId == null)
+        return CANCELLED;
+    }
+  }
+  let ai = options.ai == null ? void 0 : parseAi(options.ai);
+  if (ai == null) {
+    ai = prompter == null ? "claude" : await prompter.aiTarget("claude");
+    if (ai == null)
+      return CANCELLED;
+  }
+  let projectName = options.name == null ? void 0 : parseProjectName(options.name);
+  if (projectName == null) {
+    const fallback = defaultProjectName(root);
+    projectName = prompter == null ? fallback : await prompter.projectName(fallback);
+    if (projectName == null)
+      return CANCELLED;
+  }
+  let review = options.review == null ? void 0 : parseReview(options.review);
+  if (review == null) {
+    const wanted = prompter == null ? false : await prompter.review(false);
+    if (wanted == null)
+      return CANCELLED;
+    review = wanted ? "claude" : "none";
+  }
+  return { presetId, ai, projectName, review };
+}
+async function runInit(ui2, options, prompter) {
+  const root = path12.resolve(options.dir);
+  mkdirSync2(root, { recursive: true });
+  if (!options.yes && prompter == null) {
+    ui2.glitch(ui2.lore.needsTerminal);
+    return aborted();
+  }
+  const interactive = options.yes ? void 0 : prompter;
+  ui2.soulkiller();
+  ui2.line(`  ${ui2.theme.dim("\u2514\u2500")} ${ui2.theme.dim(ui2.lore.soulkillerDetail)}`);
+  ui2.line();
+  const report = detect(root);
+  ui2.phase(1, 4, "\u26A1", ui2.lore.phaseScan);
+  printDetectReport(ui2, report);
+  ui2.line();
+  ui2.phase(2, 4, "\u{1F9E0}", ui2.lore.phaseConfigure);
+  const choices = await askChoices(ui2, options, report, root, interactive);
+  if (choices === CANCELLED)
+    return aborted();
+  const { presetId, ai, projectName, review } = choices;
+  const preset = getPreset(presetId);
+  if (!preset.available)
+    throw new Error(`preset "${presetId}" is not available yet in v${VERSION}`);
+  if (report.packageManager !== "pnpm" && report.packageManager !== "none")
+    ui2.glitch(`This repository uses ${report.packageManager}; the construct harness scripts assume pnpm in v${VERSION}.`);
+  ui2.tree([
+    ["Project", projectName],
+    ["Preset", `${preset.label} \u2014 ${preset.description}`],
+    ["AI Netrunners", AI_TARGET_LABELS[ai]],
+    ["Code review", review === "claude" ? `Claude on pull requests (${options.reviewModel ?? DEFAULT_REVIEW_MODEL})` : "none"]
+  ]);
+  ui2.line();
+  const vars = {
+    projectName,
+    scope: `@${projectName}`,
+    nodeMajor: String(report.nodeMajor),
+    contracts: preset.contracts ? "true" : "false",
+    contractPath: "contracts/api/openapi.yaml",
+    contractTypesOutput: "src/contracts/openapi.ts",
+    compositionDir: report.existing.compositionDir ?? "architecture/composition",
+    harnessCommand: "pnpm run quality",
+    packageManager: "pnpm",
+    pnpmVersion: report.pnpmVersion ?? "",
+    reviewModel: options.reviewModel ?? DEFAULT_REVIEW_MODEL,
+    constructVersion: VERSION,
+    ...preset.vars(report, projectName)
+  };
+  const groups = [...preset.groups, ...aiGroups(ai), ...reviewGroups(review)];
+  const plan = planMaterialize(root, groups, vars, { emptyTarget: report.layout === "empty", ai });
+  ui2.phase(3, 4, "\u{1F4BE}", ui2.lore.phaseMaterialize);
+  ui2.tree([[ui2.lore.materializeAi], [ui2.lore.materializeContracts], [ui2.lore.materializePolicies]]);
+  ui2.line();
+  const creates = plan.ops.filter((op) => op.action === "create");
+  const merges = plan.ops.filter((op) => op.action === "merge" || op.action === "append");
+  const skips = plan.ops.filter((op) => op.action === "skip");
+  const skipped = skips.map((op) => op.target);
+  for (const op of creates)
+    ui2.line(`  ${ui2.theme.ok("+")} ${op.target}`);
+  for (const op of merges)
+    ui2.line(`  ${ui2.theme.accent("~")} ${op.target} ${ui2.theme.dim(`(${op.action})`)}`);
+  for (const op of skips)
+    ui2.line(`  ${ui2.theme.dim("=")} ${ui2.theme.dim(`${op.target} \u2014 ${op.note ?? "exists"}`)}`);
+  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")
+    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);
+  if (skips.length > 0 && !report.existing.constructJson)
+    ui2.glitch(ui2.lore.wireHarness, ui2.lore.wireHarnessSteps);
+  if (options.dryRun) {
+    ui2.line(ui2.theme.dim(ui2.lore.dryRun));
+    return { status: "dry-run", written: [], skipped, conflicts: plan.conflicts };
+  }
+  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 }));
+  ui2.phase(4, 4, "\u2705", ui2.lore.phaseOnline);
+  ui2.tree([
+    ["Written", `${written.length} files`],
+    ["Next", `${vars.packageManager} install && ${vars.harnessCommand}`],
+    ["Then", ai === "cursor" ? "open Cursor and ask the agent to run the construct discovery" : "claude \u2192 /construct-discover"]
+  ]);
+  return { status: "done", written: written.map((op) => op.target), skipped, conflicts: plan.conflicts };
+}
+
+// src/ui/console.ts
+import process2 from "process";
+
+// src/ui/lore.ts
+var BANNER = String.raw`
+  ███╗   ███╗██╗██╗  ██╗ ██████╗ ███████╗██╗  ██╗██╗
+  ████╗ ████║██║██║ ██╔╝██╔═══██╗██╔════╝██║  ██║██║
+  ██╔████╔██║██║█████╔╝ ██║   ██║███████╗███████║██║
+  ██║╚██╔╝██║██║██╔═██╗ ██║   ██║╚════██║██╔══██║██║
+  ██║ ╚═╝ ██║██║██║  ██╗╚██████╔╝███████║██║  ██║██║
+  ╚═╝     ╚═╝╚═╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚═╝`;
+var LORE = {
+  subtitle: (version) => `--- CONSTRUCT ENGINE v${version} // ARASAKA SUB-NET ---`,
+  johnnyWakeUp: "Wake up, Netrunner. We have a repository to build.",
+  soulkiller: "RUNNING SOULKILLER PROTOCOL...",
+  soulkillerDetail: "Extracting codebase consciousness...",
+  phaseScan: "REPOSITORY SCAN COMPLETE",
+  phaseConfigure: "CONSTRUCT CONFIGURATION",
+  phaseMaterialize: "MATERIALIZING CONSTRUCT",
+  phaseOnline: "CONSTRUCT ONLINE",
+  materializeAi: "Injecting instruction sets for AI Netrunners...",
+  materializeContracts: "Generating architecture contracts...",
+  materializePolicies: "Locking ESLint & Security policies...",
+  askPreset: "Which construct are we building?",
+  askAi: "Which Netrunners will jack in?",
+  askName: "Project name",
+  askReview: "Add the Claude code-review workflow on pull requests? (label-triggered, needs a CODE_REVIEW_API_KEY secret)",
+  presetUnavailable: "not materialized yet in this version",
+  nameInvalid: 'lowercase letters, digits, "-", "." and "_" only',
+  cancelled: "Netrunner jacked out. Nothing was written.",
+  needsTerminal: "No terminal for the interactive flow; pass --yes (and --preset) to run non-interactively.",
+  confirm: "Inject Construct into repository?",
+  dryRun: "DRY RUN \u2014 nothing was written.",
+  sampleOmitted: "Sample sources omitted: the directory is not empty. Discovery maps what is already here.",
+  unknownStructure: "I don't recognize this structure. Choose a target directory with --dir.",
+  glitch: "GLITCH",
+  flatlined: "FLATLINED",
+  stable: "CONSTRUCT STABLE",
+  discoveryIncomplete: "Discovery incomplete.",
+  wireHarness: "Existing configs were kept, so the harness is not wired in yet. /construct-discover does this first; by hand:",
+  wireHarnessSteps: [
+    "eslint: ignore scripts/construct/*.workflow.mjs (the ladder script uses top-level return)",
+    "tsconfig: include scripts/**/*.ts; vitest: include scripts/tests/**/*.test.ts",
+    "package.json: make the quality script run composition:check (and contracts:check when there is a contract)"
+  ]
+};
+var PLAIN_LORE = {
+  subtitle: (version) => `mikoshi-construct v${version}`,
+  johnnyWakeUp: "Wake up, Netrunner. We have a repository to build.",
+  soulkiller: "Inspecting repository...",
+  soulkillerDetail: "Detecting stack and layout...",
+  phaseScan: "Repository scan complete",
+  phaseConfigure: "Configuration",
+  phaseMaterialize: "Writing baseline",
+  phaseOnline: "Done",
+  materializeAi: "Writing AI agent instructions...",
+  materializeContracts: "Writing architecture and contracts...",
+  materializePolicies: "Writing lint and security policies...",
+  askPreset: "Preset",
+  askAi: "AI agents",
+  askName: "Project name",
+  askReview: "Add the Claude code-review workflow on pull requests? (label-triggered, needs a CODE_REVIEW_API_KEY secret)",
+  presetUnavailable: "not available yet in this version",
+  nameInvalid: 'lowercase letters, digits, "-", "." and "_" only',
+  cancelled: "Cancelled. Nothing was written.",
+  needsTerminal: "No terminal for the interactive flow; pass --yes (and --preset) to run non-interactively.",
+  confirm: "Write these files?",
+  dryRun: "Dry run \u2014 nothing was written.",
+  sampleOmitted: "Sample sources omitted: the directory is not empty. Discovery maps what is already here.",
+  unknownStructure: "Unrecognized project structure. Choose a target directory with --dir.",
+  glitch: "WARNING",
+  flatlined: "ERROR",
+  stable: "OK",
+  discoveryIncomplete: "Discovery incomplete.",
+  wireHarness: "Existing configs were kept, so the harness is not wired in yet. /construct-discover does this first; by hand:",
+  wireHarnessSteps: [
+    "eslint: ignore scripts/construct/*.workflow.mjs (the ladder script uses top-level return)",
+    "tsconfig: include scripts/**/*.ts; vitest: include scripts/tests/**/*.test.ts",
+    "package.json: make the quality script run composition:check (and contracts:check when there is a contract)"
+  ]
+};
+
+// src/ui/console.ts
+var stdoutWriter = (text2) => {
+  process2.stdout.write(text2);
+};
+function createUi(theme, write = stdoutWriter) {
+  const plain = theme.name === "plain";
+  const lore = plain ? PLAIN_LORE : LORE;
+  const out = (text2 = "") => {
+    write(`${text2}
+`);
+  };
+  const icon = (glyph, fallback) => plain ? fallback : glyph;
+  return {
+    theme,
+    lore,
+    banner(version, johnny2) {
+      if (plain) {
+        out(lore.subtitle(version));
+        out();
+        return;
+      }
+      if (johnny2) {
+        out();
+        out(theme.accent(theme.bold(lore.johnnyWakeUp)));
+        out(theme.dim(lore.subtitle(version)));
+        out();
+        return;
+      }
+      out(theme.primary(BANNER));
+      out(theme.accent(`  ${lore.subtitle(version)}`));
+      out();
+    },
+    soulkiller() {
+      out(`${icon("\u{1F480}", ">>")} ${theme.accent(lore.soulkiller)}`);
+    },
+    phase(index, total, glyph, title) {
+      out(`${theme.primary(`[${index}/${total}]`)} ${icon(glyph, "*")} ${theme.accent(theme.bold(title))}`);
+    },
+    tree(lines) {
+      lines.forEach(([label, value], position) => {
+        const branch = position === lines.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
+        const rendered = value == null ? label : `${label}: ${theme.detected(value)}`;
+        out(`  ${theme.dim(branch)} ${rendered}`);
+      });
+    },
+    line: out,
+    ok(text2) {
+      out(`${icon("\u2705", "[ok]")} ${theme.ok(theme.bold(text2))}`);
+    },
+    glitch(text2, details = []) {
+      out(`${icon("\u26A0", "[warn]")} ${theme.warn(`${lore.glitch}:`)} ${text2}`);
+      for (const detail of details)
+        out(`    ${theme.dim(detail)}`);
+    },
+    flatline(text2) {
+      out(`${icon("\u2620", "[error]")} ${theme.fail(`${lore.flatlined}:`)} ${text2}`);
+    }
+  };
+}
+
+// src/ui/theme.ts
+import process3 from "process";
+import pc from "picocolors";
+function rgb(r, g, b) {
+  return (text2) => `\x1B[38;2;${r};${g};${b}m${text2}\x1B[39m`;
+}
+var identity = (text2) => text2;
+function supportsColor() {
+  if (process3.env.NO_COLOR != null && process3.env.NO_COLOR !== "")
+    return false;
+  if (process3.env.FORCE_COLOR != null && process3.env.FORCE_COLOR !== "0")
+    return true;
+  return pc.isColorSupported;
+}
+function truecolor() {
+  const term = process3.env.COLORTERM ?? "";
+  return term === "truecolor" || term === "24bit";
+}
+var PLAIN = {
+  name: "plain",
+  primary: identity,
+  accent: identity,
+  detected: identity,
+  dim: identity,
+  ok: identity,
+  warn: identity,
+  fail: identity,
+  bold: identity
+};
+function arasaka() {
+  const tc = truecolor();
+  return {
+    name: "arasaka",
+    primary: tc ? rgb(230, 0, 46) : pc.red,
+    accent: tc ? rgb(252, 238, 10) : pc.yellow,
+    detected: tc ? rgb(0, 240, 255) : pc.cyan,
+    dim: pc.dim,
+    ok: tc ? rgb(0, 255, 159) : pc.green,
+    warn: pc.yellow,
+    fail: (text2) => pc.bold(pc.red(text2)),
+    bold: pc.bold
+  };
+}
+function johnny() {
+  const tc = truecolor();
+  return {
+    ...arasaka(),
+    name: "johnny",
+    primary: tc ? rgb(255, 60, 0) : pc.red,
+    accent: tc ? rgb(255, 176, 0) : pc.yellow,
+    detected: tc ? rgb(255, 120, 60) : pc.magenta
+  };
+}
+function resolveTheme(options) {
+  if (options.plain === true || !supportsColor())
+    return PLAIN;
+  return options.johnny === true ? johnny() : arasaka();
+}
+
+// src/cli.ts
+var commonArgs = {
+  dir: { type: "string", description: "Target directory", default: "." },
+  plain: { type: "boolean", description: "No colors, no lore (CI-friendly)", default: false },
+  johnny: { type: "boolean", description: "Wake up, Netrunner.", default: false }
+};
+function ui(args) {
+  return createUi(resolveTheme({ plain: args.plain, johnny: args.johnny }));
+}
+var init = defineCommand({
+  meta: { name: "init", description: "Materialize the construct: architecture, contracts, harness, AI instructions" },
+  args: {
+    ...commonArgs,
+    preset: { type: "string", description: `Preset: ${PRESET_IDS.join(" | ")}` },
+    ai: { type: "string", description: "AI target: claude | cursor | both (default: claude)" },
+    name: { type: "string", description: "Project name (defaults to the directory name)" },
+    review: { type: "string", description: "AI code review on pull requests: claude | none (default: none)" },
+    reviewModel: { type: "string", description: `Model for the review workflow (default: ${DEFAULT_REVIEW_MODEL})` },
+    yes: { type: "boolean", alias: "y", description: "Non-interactive: take defaults and skip the confirmation", default: false },
+    dryRun: { type: "boolean", description: "Print the plan, write nothing", default: false }
+  },
+  async run({ args }) {
+    const console = ui(args);
+    console.banner(VERSION, args.johnny);
+    try {
+      const prompter = isTTY(process4.stdout) && process4.stdin.isTTY === true ? createClackPrompter(console.lore) : void 0;
+      const result = await runInit(console, { dir: args.dir, preset: args.preset, ai: args.ai, name: args.name, review: args.review, reviewModel: args.reviewModel, yes: args.yes, dryRun: args.dryRun }, prompter);
+      process4.exitCode = result.status === "aborted" ? 1 : 0;
+    } catch (error) {
+      console.flatline(error instanceof Error ? error.message : String(error));
+      process4.exitCode = 1;
+    }
+  }
+});
+var soulkill = defineCommand({
+  meta: { name: "soulkill", description: "Extract the facts about a repository without writing anything (alias: inspect, capture)" },
+  args: {
+    ...commonArgs,
+    json: { type: "boolean", description: "Machine-readable report", default: false }
+  },
+  run({ args }) {
+    const report = detect(args.dir);
+    if (args.json) {
+      process4.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+      return;
+    }
+    const console = ui(args);
+    console.banner(VERSION, args.johnny);
+    console.soulkiller();
+    console.line();
+    printDetectReport(console, report);
+  }
+});
+var doctor = defineCommand({
+  meta: { name: "doctor", description: "Check that the construct baseline and discovery are intact" },
+  args: {
+    ...commonArgs,
+    json: { type: "boolean", description: "Machine-readable report", default: false }
+  },
+  run({ args }) {
+    const result = runDoctor(args.dir);
+    if (args.json) {
+      process4.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+      process4.exitCode = result?.ok === true ? 0 : 1;
+      return;
+    }
+    const console = ui(args);
+    process4.exitCode = printDoctor(console, result);
+  }
+});
+var cost = defineCommand({
+  meta: { name: "cost", description: "Token usage of the /implement runs recorded for this directory (from Claude Code session data)" },
+  args: {
+    ...commonArgs,
+    last: { type: "boolean", description: "Only the most recent run", default: false },
+    json: { type: "boolean", description: "Machine-readable report", default: false }
+  },
+  run({ args }) {
+    const runs = collectWorkflowRuns(path13.resolve(args.dir));
+    if (args.json) {
+      const selected = runs == null ? null : args.last ? runs.slice(-1) : runs;
+      process4.stdout.write(`${JSON.stringify(selected, null, 2)}
+`);
+      process4.exitCode = runs == null ? 1 : 0;
+      return;
+    }
+    const console = ui(args);
+    process4.exitCode = printCost(console, runs, args.last);
+  }
+});
+var main = defineCommand({
+  meta: {
+    name: "construct",
+    version: VERSION,
+    description: "mikoshi-construct \u2014 bootstrap for AI-native software projects"
+  },
+  subCommands: {
+    init,
+    soulkill,
+    inspect: soulkill,
+    capture: soulkill,
+    doctor,
+    cost
+  }
+});
+runMain(main);