@jamie-tam/forge 6.0.0

package/dist/copy.js

@@ -0,0 +1,124 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+function fileChanged(srcPath, destPath) {
+    if (!existsSync(destPath))
+        return true;
+    return readFileSync(srcPath, "utf-8") !== readFileSync(destPath, "utf-8");
+}
+/**
+ * Copy a directory of .md files (flat) to a target directory.
+ */
+export function copyFlatDir(src, dest, opts) {
+    const result = { changed: [], unchanged: [], added: [], skipped: [] };
+    if (!existsSync(src))
+        return result;
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src)) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const srcPath = join(src, entry);
+        const destPath = join(dest, entry);
+        if (existsSync(destPath) && !opts.force) {
+            result.skipped.push(entry);
+        }
+        else if (!existsSync(destPath)) {
+            cpSync(srcPath, destPath);
+            result.added.push(entry);
+        }
+        else if (fileChanged(srcPath, destPath)) {
+            cpSync(srcPath, destPath);
+            result.changed.push(entry);
+        }
+        else {
+            result.unchanged.push(entry);
+        }
+    }
+    return result;
+}
+/**
+ * Copy a directory tree (skills have subdirectories with templates/).
+ */
+export function copyTreeDir(src, dest, opts) {
+    const result = { changed: [], unchanged: [], added: [], skipped: [] };
+    if (!existsSync(src))
+        return result;
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src)) {
+        const srcPath = join(src, entry);
+        const destPath = join(dest, entry);
+        if (existsSync(destPath) && !opts.force) {
+            result.skipped.push(entry);
+        }
+        else if (!existsSync(destPath)) {
+            cpSync(srcPath, destPath, { recursive: true });
+            result.added.push(entry);
+        }
+        else if (statSync(srcPath).isDirectory()
+            ? treeChanged(srcPath, destPath)
+            : fileChanged(srcPath, destPath)) {
+            cpSync(srcPath, destPath, { recursive: true });
+            result.changed.push(entry);
+        }
+        else {
+            result.unchanged.push(entry);
+        }
+    }
+    return result;
+}
+/**
+ * Check if any file in a directory tree differs.
+ * Only walks the source tree — does not detect extra files in destination.
+ * Stale destination-only files are a /validate concern, not an install concern.
+ */
+function treeChanged(srcDir, destDir) {
+    for (const entry of readdirSync(srcDir)) {
+        const srcPath = join(srcDir, entry);
+        const destPath = join(destDir, entry);
+        if (statSync(srcPath).isDirectory()) {
+            if (treeChanged(srcPath, destPath))
+                return true;
+        }
+        else if (fileChanged(srcPath, destPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Copy rules directory, preserving the common/ and language-specific/ structure.
+ */
+export function copyRules(src, dest, opts) {
+    const result = { changed: [], unchanged: [], added: [], skipped: [] };
+    if (!existsSync(src))
+        return result;
+    mkdirSync(dest, { recursive: true });
+    for (const subdir of readdirSync(src)) {
+        const srcSub = join(src, subdir);
+        if (!statSync(srcSub).isDirectory())
+            continue;
+        const destSub = join(dest, subdir);
+        mkdirSync(destSub, { recursive: true });
+        for (const file of readdirSync(srcSub)) {
+            if (!file.endsWith(".md"))
+                continue;
+            const srcFile = join(srcSub, file);
+            const destFile = join(destSub, file);
+            const label = `${subdir}/${file}`;
+            if (existsSync(destFile) && !opts.force) {
+                result.skipped.push(label);
+            }
+            else if (!existsSync(destFile)) {
+                cpSync(srcFile, destFile);
+                result.added.push(label);
+            }
+            else if (fileChanged(srcFile, destFile)) {
+                cpSync(srcFile, destFile);
+                result.changed.push(label);
+            }
+            else {
+                result.unchanged.push(label);
+            }
+        }
+    }
+    return result;
+}

package/dist/gate-check.js

@@ -0,0 +1,326 @@
+/**
+ * gate-check CLI — diffs an in-flight manifest edit and reports gate
+ * transitions for downstream enforcement (gate-enforcer.sh).
+ *
+ * Replaces hand-rolled YAML grepping in bash. Reads a Claude Code hook
+ * payload from stdin, applies the proposed Edit/Write to the on-disk
+ * manifest, and emits the list of gates whose `gate-passed` field is
+ * transitioning. Each transition includes its scope (slice vs manifest)
+ * and the containing slice ID where applicable.
+ *
+ * Per Codex Phase 2 design review: the bash hook MUST NOT hand-roll
+ * YAML path tracking. This is the helper.
+ *
+ * Spec:
+ *   - Input (stdin, JSON): { tool_name: "Edit"|"Write", tool_input: {...} }
+ *   - Edit input:  { file_path, old_string, new_string }
+ *   - Write input: { file_path, content }
+ *   - Ambiguous Edit (old_string matches 0 or >1 times): fail-closed exit 1.
+ *   - YAML parse error in old or new: emitted as error; exit 2.
+ *
+ * Output (JSON when --json):
+ *   { ok: true, transitions: [{gate, scope, slice_id?, transition, path}, ...] }
+ *   { ok: false, error: "..." }
+ *
+ * Exit codes:
+ *   0 — transitions extracted (list may be empty)
+ *   1 — bad payload, ambiguous edit, or unable to compute new content
+ *   2 — internal/file/YAML error
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { load as yamlLoad } from "js-yaml";
+// ============================================================================
+// Public API
+// ============================================================================
+export function gateCheck(payload) {
+    // Defend against malformed payloads: stdin can deliver `null`, an array,
+    // or a primitive (`JSON.parse("42") === 42`). Reject before dereferencing.
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return {
+            ok: false,
+            error: "payload must be a JSON object (got null, array, or primitive)",
+            exitCode: 1,
+        };
+    }
+    const tool = payload.tool_name;
+    const input = payload.tool_input ?? {};
+    if (tool !== "Edit" && tool !== "Write") {
+        return {
+            ok: true,
+            transitions: [],
+        }; // not a manifest edit; no-op
+    }
+    const filePath = input.file_path;
+    if (!filePath) {
+        return { ok: false, error: "tool_input.file_path is required", exitCode: 1 };
+    }
+    // Read current content (may not exist yet for first Write).
+    let oldContent = "";
+    if (existsSync(filePath)) {
+        try {
+            oldContent = readFileSync(filePath, "utf-8");
+        }
+        catch (e) {
+            return {
+                ok: false,
+                error: `cannot read current file ${filePath}: ${e.message}`,
+                exitCode: 2,
+            };
+        }
+    }
+    // Compute proposed new content.
+    let newContent;
+    if (tool === "Write") {
+        if (typeof input.content !== "string") {
+            return { ok: false, error: "Write requires tool_input.content (string)", exitCode: 1 };
+        }
+        newContent = input.content;
+    }
+    else {
+        // Edit
+        if (typeof input.old_string !== "string" || typeof input.new_string !== "string") {
+            return {
+                ok: false,
+                error: "Edit requires tool_input.old_string and tool_input.new_string (strings)",
+                exitCode: 1,
+            };
+        }
+        if (input.old_string === "") {
+            return { ok: false, error: "Edit old_string must not be empty", exitCode: 1 };
+        }
+        const occurrences = countOccurrences(oldContent, input.old_string);
+        if (occurrences === 0) {
+            return {
+                ok: false,
+                error: `Edit old_string not found in ${filePath}; cannot compute proposed content`,
+                exitCode: 1,
+            };
+        }
+        if (occurrences > 1) {
+            return {
+                ok: false,
+                error: `Edit old_string is ambiguous (${occurrences} occurrences in ${filePath}); broaden the match before retrying`,
+                exitCode: 1,
+            };
+        }
+        newContent = oldContent.replace(input.old_string, input.new_string);
+    }
+    // Parse both as YAML. Use raw js-yaml; gate-check only needs the
+    // structural shape, not v5 invariants (those are verify-manifest's job).
+    let oldParsed;
+    let newParsed;
+    try {
+        oldParsed = oldContent ? yamlLoad(oldContent) : {};
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: `current file ${filePath} is not valid YAML: ${e.message}`,
+            exitCode: 2,
+        };
+    }
+    try {
+        newParsed = yamlLoad(newContent);
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: `proposed content is not valid YAML: ${e.message}`,
+            exitCode: 2,
+        };
+    }
+    if (newParsed === null || newParsed === undefined) {
+        return { ok: false, error: "proposed content is empty", exitCode: 1 };
+    }
+    if (!isPlainObject(newParsed)) {
+        return {
+            ok: false,
+            error: "proposed content is not a YAML mapping (got array, scalar, or non-plain object like Date)",
+            exitCode: 1,
+        };
+    }
+    // Walk both manifests for gates; diff.
+    let oldGates;
+    let newGates;
+    try {
+        oldGates = collectGates(oldParsed);
+        newGates = collectGates(newParsed);
+    }
+    catch (e) {
+        // collectGates throws on non-boolean gate-passed (per Codex round-2 #1):
+        // strings/numbers/arrays must fail closed, not silently coerce to truthy.
+        return { ok: false, error: e.message, exitCode: 1 };
+    }
+    const transitions = [];
+    // Iterate paths in sorted order so output is deterministic across runs.
+    const allPaths = [...new Set([...oldGates.keys(), ...newGates.keys()])].sort();
+    for (const yamlPath of allPaths) {
+        const oldVal = oldGates.get(yamlPath);
+        const newVal = newGates.get(yamlPath);
+        const oldPassed = oldVal?.gatePassed ?? false;
+        const newPassed = newVal?.gatePassed ?? false;
+        if (oldPassed === newPassed)
+            continue;
+        const ref = newVal ?? oldVal;
+        // Scope is position-derived (structural truth, per Codex round-2 #4).
+        // The bash hook reads gate-requirements.json for skill/agent lookups;
+        // gate-check does not — that avoided a precedence inversion where a
+        // mis-configured `scope: manifest` on a slice gate could emit a
+        // contradictory `{scope: "manifest", slice_id: "..."}`.
+        const scope = ref.sliceId ? "slice" : "manifest";
+        transitions.push({
+            gate: ref.gate,
+            scope,
+            ...(ref.sliceId ? { slice_id: ref.sliceId } : {}),
+            transition: oldPassed ? "true-to-false" : "false-to-true",
+            path: yamlPath,
+        });
+    }
+    return { ok: true, transitions };
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function countOccurrences(haystack, needle) {
+    if (needle === "")
+        return 0;
+    let count = 0;
+    let idx = 0;
+    while (true) {
+        const found = haystack.indexOf(needle, idx);
+        if (found === -1)
+            return count;
+        count++;
+        idx = found + needle.length;
+    }
+}
+/** Walk a parsed manifest tree and collect every gate location. Returns a
+ *  map keyed by full YAML path → { gate, sliceId, gatePassed }. */
+function collectGates(manifest) {
+    const out = new Map();
+    if (!manifest || typeof manifest !== "object")
+        return out;
+    const m = manifest;
+    // Phase gates: phases.<phase>.<gate-name> = { status, gate-passed }
+    const phases = m.phases;
+    if (phases && typeof phases === "object" && !Array.isArray(phases)) {
+        for (const [phaseName, phaseBlock] of Object.entries(phases)) {
+            if (!phaseBlock || typeof phaseBlock !== "object" || Array.isArray(phaseBlock))
+                continue;
+            for (const [gateName, gateVal] of Object.entries(phaseBlock)) {
+                if (isGateObject(gateVal)) {
+                    const ymlPath = `phases.${phaseName}.${gateName}`;
+                    out.set(ymlPath, {
+                        gate: gateName,
+                        gatePassed: extractGatePassed(gateVal, ymlPath),
+                    });
+                }
+            }
+        }
+    }
+    // Slice gates: slice_graph.slices.<id>.gates.<gate-name> = { status, gate-passed }
+    const sg = m.slice_graph;
+    if (sg && typeof sg === "object" && !Array.isArray(sg)) {
+        const slices = sg.slices;
+        if (slices && typeof slices === "object" && !Array.isArray(slices)) {
+            for (const [sliceId, slice] of Object.entries(slices)) {
+                if (!slice || typeof slice !== "object" || Array.isArray(slice))
+                    continue;
+                const gates = slice.gates;
+                if (!gates || typeof gates !== "object" || Array.isArray(gates))
+                    continue;
+                for (const [gateName, gateVal] of Object.entries(gates)) {
+                    if (isGateObject(gateVal)) {
+                        const ymlPath = `slice_graph.slices.${sliceId}.gates.${gateName}`;
+                        out.set(ymlPath, {
+                            gate: gateName,
+                            sliceId,
+                            gatePassed: extractGatePassed(gateVal, ymlPath),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return out;
+}
+/** Strict boolean extraction — fail closed on non-boolean gate-passed.
+ *  Per Codex round-2 #1: `Boolean("false")` is truthy, which would suppress
+ *  expected false→true transitions. Strings, numbers, arrays must throw. */
+function extractGatePassed(gateVal, yamlPath) {
+    const raw = gateVal["gate-passed"];
+    if (raw === true)
+        return true;
+    if (raw === false)
+        return false;
+    throw new Error(`gate-passed at ${yamlPath} must be a boolean (got ${typeof raw}: ${JSON.stringify(raw)})`);
+}
+/** A plain object (not array, not Date, not RegExp, not null). js-yaml will
+ *  happily return a Date for a bare YAML timestamp at the document root —
+ *  that passes `typeof === "object"` and would slip through naive checks. */
+function isPlainObject(v) {
+    return Object.prototype.toString.call(v) === "[object Object]";
+}
+function isGateObject(v) {
+    return Boolean(v &&
+        typeof v === "object" &&
+        !Array.isArray(v) &&
+        "gate-passed" in v);
+}
+// ============================================================================
+// CLI entry point — `aideas-forge gate-check [--json]`
+// ============================================================================
+export async function gateCheckCli(args) {
+    const json = args.includes("--json");
+    // Read JSON payload from stdin.
+    let stdin;
+    try {
+        stdin = await readStdin();
+    }
+    catch (e) {
+        return emitError(json, `failed to read stdin: ${e.message}`, 2);
+    }
+    let payload;
+    try {
+        payload = JSON.parse(stdin);
+    }
+    catch (e) {
+        return emitError(json, `stdin is not valid JSON: ${e.message}`, 1);
+    }
+    const result = gateCheck(payload);
+    if (!result.ok) {
+        return emitError(json, result.error, result.exitCode);
+    }
+    if (json) {
+        process.stdout.write(JSON.stringify({ ok: true, transitions: result.transitions }) + "\n");
+    }
+    else if (result.transitions.length === 0) {
+        console.log("No gate transitions detected.");
+    }
+    else {
+        console.log(`${result.transitions.length} gate transition(s):`);
+        for (const t of result.transitions) {
+            const where = t.slice_id ? ` (slice: ${t.slice_id})` : "";
+            console.log(`  ${t.transition.padEnd(13)}  ${t.gate}${where}  [${t.scope}]  @ ${t.path}`);
+        }
+    }
+    return 0;
+}
+function emitError(json, message, exitCode) {
+    if (json) {
+        process.stdout.write(JSON.stringify({ ok: false, error: message }) + "\n");
+    }
+    else {
+        console.error(message);
+    }
+    return exitCode;
+}
+function readStdin() {
+    return new Promise((res, rej) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => (data += chunk));
+        process.stdin.on("end", () => res(data));
+        process.stdin.on("error", rej);
+    });
+}

package/dist/hooks.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { SOURCE } from "./paths.js";
+/**
+ * Install forge hooks into the project's .claude/settings.local.json.
+ * Copies hook scripts to .claude/hooks/ and merges hook definitions
+ * into existing settings without clobbering user hooks.
+ */
+export function installHooks(projectRoot, opts) {
+    const claudeDir = resolve(projectRoot, ".claude");
+    const settingsPath = join(claudeDir, "settings.local.json");
+    const hooksDir = join(claudeDir, "hooks");
+    const scriptsDir = join(hooksDir, "scripts");
+    const configDir = join(hooksDir, "config");
+    // Copy hook scripts
+    const srcScripts = join(SOURCE.hooks, "scripts");
+    const srcConfig = join(SOURCE.hooks, "config");
+    if (existsSync(srcScripts)) {
+        mkdirSync(scriptsDir, { recursive: true });
+        cpSync(srcScripts, scriptsDir, { recursive: true });
+    }
+    if (existsSync(srcConfig)) {
+        mkdirSync(configDir, { recursive: true });
+        cpSync(srcConfig, configDir, { recursive: true });
+    }
+    // Read forge hook definitions
+    const srcHooksJson = join(SOURCE.hooks, "hooks.json");
+    if (!existsSync(srcHooksJson)) {
+        return { installed: false, message: "No hooks.json found in package" };
+    }
+    const forgeHooks = JSON.parse(readFileSync(srcHooksJson, "utf-8")).hooks;
+    // Read existing settings
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    }
+    // Merge forge hooks with existing hooks
+    const existingHooks = (settings.hooks ?? {});
+    settings.hooks = mergeHooks(existingHooks, forgeHooks);
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    return { installed: true, message: "Hooks merged" };
+}
+/**
+ * Merge forge hooks into existing hooks by event type.
+ * For each event forge defines, remove any existing entry that exactly
+ * matches a forge entry (old or new), then append the new forge entries.
+ * User-defined entries that don't match any forge entry are preserved.
+ */
+function mergeHooks(existing, forge) {
+    const merged = { ...existing };
+    for (const [event, forgeEntries] of Object.entries(forge)) {
+        const existingEntries = merged[event] ?? [];
+        const forgeStrings = new Set(forgeEntries.map((e) => JSON.stringify(e)));
+        // Keep only entries that are NOT identical to a forge entry
+        const userEntries = existingEntries.filter((entry) => !forgeStrings.has(JSON.stringify(entry)));
+        merged[event] = [...userEntries, ...forgeEntries];
+    }
+    return merged;
+}

package/dist/init.js

@@ -0,0 +1,140 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { cwd } from "node:process";
+import { SOURCE, targets } from "./paths.js";
+import { copyFlatDir, copyRules, copyTreeDir } from "./copy.js";
+import { installHooks } from "./hooks.js";
+import { verify } from "./verify.js";
+import { collectHashes, writeManifest } from "./manifest.js";
+import { hasForgeMarkers, mergeForgeBlock } from "./merge.js";
+function summarize(label, r) {
+    const parts = [];
+    if (r.added.length)
+        parts.push(`${r.added.length} new`);
+    if (r.changed.length)
+        parts.push(`${r.changed.length} updated`);
+    if (r.unchanged.length)
+        parts.push(`${r.unchanged.length} unchanged`);
+    if (r.skipped.length)
+        parts.push(`${r.skipped.length} skipped`);
+    console.log(`  ${label.padEnd(12)} ${parts.join(", ")}`);
+    for (const f of r.added)
+        console.log(`               + ${f}`);
+    for (const f of r.changed)
+        console.log(`               ~ ${f}`);
+}
+export async function init(opts) {
+    const projectRoot = cwd();
+    const t = targets(projectRoot);
+    if (opts.dryRun) {
+        console.log("forge init --dry-run\n");
+        console.log("Would install to:", t.claude);
+        console.log("Directories: agents, commands, skills, rules, references, protocols, templates, hooks");
+        console.log("Generates: CLAUDE.md, AGENTS.md");
+        console.log("\nNo files were changed.");
+        return;
+    }
+    console.log("forge init\n");
+    // Check if already initialized (skip check during update)
+    if (!opts.mergeMarkers && existsSync(t.forgeJson) && !opts.force) {
+        const meta = JSON.parse(readFileSync(t.forgeJson, "utf-8"));
+        console.log(`Already initialized (v${meta.version}). Use --force to re-install, or 'forge update' to sync.`);
+        return;
+    }
+    // Validate templates upfront (fail before any filesystem writes)
+    if (opts.mergeMarkers) {
+        for (const src of [SOURCE.claudeMdTemplate, SOURCE.agentsMdTemplate]) {
+            if (existsSync(src) && !hasForgeMarkers(readFileSync(src, "utf-8"))) {
+                console.error(`Template ${src} is missing valid FORGE markers.`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+    }
+    mkdirSync(t.claude, { recursive: true });
+    // Copy assets
+    const agents = copyFlatDir(SOURCE.agents, t.agents, opts);
+    summarize("agents:", agents);
+    const commands = copyFlatDir(SOURCE.commands, t.commands, opts);
+    summarize("commands:", commands);
+    const skills = copyTreeDir(SOURCE.skills, t.skills, opts);
+    summarize("skills:", skills);
+    const rules = copyRules(SOURCE.rules, t.rules, opts);
+    summarize("rules:", rules);
+    const protocols = copyFlatDir(SOURCE.protocols, t.protocols, opts);
+    summarize("protocols:", protocols);
+    const references = copyRules(SOURCE.references, t.references, opts);
+    summarize("references:", references);
+    const templates = copyTreeDir(SOURCE.templates, t.templates, opts);
+    summarize("templates:", templates);
+    // Install hooks (merges with existing)
+    const hooks = installHooks(projectRoot, opts);
+    console.log(`  hooks:       ${hooks.message}`);
+    // Generate project docs from templates (marker-merge during update)
+    for (const [label, src, dest] of [
+        ["CLAUDE.md", SOURCE.claudeMdTemplate, t.claudeMd],
+        ["AGENTS.md", SOURCE.agentsMdTemplate, t.agentsMd],
+    ]) {
+        if (!existsSync(src))
+            continue;
+        const templateContent = readFileSync(src, "utf-8");
+        if (!existsSync(dest)) {
+            writeFileSync(dest, templateContent);
+            console.log(`  ${label}: generated from template`);
+        }
+        else if (opts.mergeMarkers) {
+            const existingContent = readFileSync(dest, "utf-8");
+            const merged = mergeForgeBlock(existingContent, templateContent);
+            if (merged !== null) {
+                if (merged !== existingContent) {
+                    writeFileSync(dest, merged);
+                    console.log(`  ${label}: framework sections updated (user content preserved)`);
+                }
+                else {
+                    console.log(`  ${label}: unchanged`);
+                }
+            }
+            else {
+                console.log(`  ${label}: preserved (no forge markers — add markers to enable merge)`);
+            }
+        }
+        else if (opts.force) {
+            writeFileSync(dest, templateContent);
+            console.log(`  ${label}: generated from template`);
+        }
+        else {
+            console.log(`  ${label}: exists (skipped)`);
+        }
+    }
+    // Structural verification
+    const pkg = JSON.parse(readFileSync(resolve(SOURCE.agents, "..", "package.json"), "utf-8"));
+    console.log("\nVerifying installation...");
+    const check = verify(projectRoot);
+    if (check.failed.length === 0) {
+        console.log(`  ${check.passed.length} checks passed`);
+        // Build file manifest with checksums
+        const files = {};
+        for (const dir of [t.agents, t.commands, t.skills, t.rules, t.protocols, t.references, t.templates]) {
+            if (existsSync(dir)) {
+                Object.assign(files, collectHashes(dir, t.claude));
+            }
+        }
+        // Write manifest
+        mkdirSync(t.forgeState, { recursive: true });
+        const manifest = {
+            version: pkg.version,
+            installedAt: new Date().toISOString(),
+            files,
+        };
+        writeManifest(t.forgeJson, manifest);
+        console.log(`\nForge v${pkg.version} installed (${Object.keys(files).length} files tracked).`);
+        console.log("Run /setup to configure your project profile, then /validate for consistency check.");
+    }
+    else {
+        console.log(`  ${check.passed.length} passed, ${check.failed.length} FAILED:`);
+        for (const f of check.failed)
+            console.log(`    ✗ ${f}`);
+        console.log(`\nInstallation incomplete. Fix the above and re-run.`);
+        process.exitCode = 1;
+    }
+}