@jamie-tam/forge 6.0.0

package/dist/__tests__/work-manifest.test.js

@@ -0,0 +1,304 @@
+/**
+ * Smoke test for src/work-manifest.ts.
+ *
+ * Run with: npm run build && node dist/__tests__/work-manifest.test.js
+ *
+ * Zero-test-framework approach (consistent with project minimalism). Asserts
+ * by throwing; prints PASS/FAIL per case; non-zero exit on any failure.
+ */
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { parseManifest, } from "../work-manifest.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Fixtures live in src/__fixtures__/ — at runtime we are in dist/__tests__/, so go up two.
+const FIXTURES = join(__dirname, "..", "..", "src", "__fixtures__", "work-manifest");
+let passed = 0;
+let failed = 0;
+const fails = [];
+function test(name, fn) {
+    try {
+        fn();
+        passed++;
+        console.log(`  PASS  ${name}`);
+    }
+    catch (e) {
+        failed++;
+        const msg = e instanceof Error ? e.message : String(e);
+        fails.push(`${name}: ${msg}`);
+        console.log(`  FAIL  ${name}\n        ${msg}`);
+    }
+}
+function loadFixture(name) {
+    return readFileSync(join(FIXTURES, name), "utf-8");
+}
+function expectOk(result, schema) {
+    if (!result.ok) {
+        throw new Error(`expected ok, got errors:\n${result.errors.map((e) => `  ${e.code} @ ${e.path}: ${e.message}`).join("\n")}`);
+    }
+    if (result.schema !== schema) {
+        throw new Error(`expected schema=${schema}, got ${result.schema}`);
+    }
+    return result.manifest;
+}
+function expectErrors(result, codes) {
+    if (result.ok) {
+        throw new Error(`expected errors [${codes.join(", ")}], but result was ok`);
+    }
+    const present = new Set(result.errors.map((e) => e.code));
+    const missing = codes.filter((c) => !present.has(c));
+    if (missing.length > 0) {
+        throw new Error(`expected errors ${codes.join(", ")} — missing ${missing.join(", ")}\n      got: ${[...present].join(", ")}`);
+    }
+}
+console.log("\n=== work-manifest.ts smoke tests ===\n");
+console.log("Structural: happy paths");
+test("v5 good manifest parses cleanly", () => {
+    expectOk(parseManifest(loadFixture("v5-good.yaml")), "v5");
+});
+test("v4 manifest synthesizes to v5 single-slice", () => {
+    const m = expectOk(parseManifest(loadFixture("v4-legacy.yaml")), "v4");
+    if (!m.slice_graph.slices["legacy-build"]) {
+        throw new Error("expected synthesized 'legacy-build' slice");
+    }
+    if (m.slice_graph.slices["legacy-build"].status !== "complete") {
+        throw new Error(`v4 with all complete tasks should synthesize legacy-build status=complete; got ${m.slice_graph.slices["legacy-build"].status}`);
+    }
+});
+console.log("\nStructural: error paths (verifier returns ALL errors)");
+test("cycle detected", () => {
+    expectErrors(parseManifest(loadFixture("bad-cycle.yaml")), ["E_CYCLE"]);
+});
+test("multi-error fixture surfaces all listed errors", () => {
+    expectErrors(parseManifest(loadFixture("bad-multi-error.yaml")), [
+        "E_BAD_CURRENT_SLICE",
+        "E_BAD_SLICE_ID",
+        "E_MULTIPLE_SKELETONS",
+        "E_SKELETON_NOT_ROOT",
+        "E_VARIANT_REQUIRED",
+        "E_VARIANT_FORBIDDEN",
+        "E_SELF_DEP",
+        "E_UNRESOLVED_DEP",
+        "E_GATE_COLLISION",
+        "E_BAD_ENUM_VALUE",
+    ]);
+});
+test("premature code-review-final blocked", () => {
+    expectErrors(parseManifest(loadFixture("bad-premature-final.yaml")), ["E_PHASE_GATE_PREMATURE"]);
+});
+test("orphan slice detected when skeleton present", () => {
+    expectErrors(parseManifest(loadFixture("bad-orphan-slice.yaml")), ["E_ORPHAN_SLICE"]);
+});
+test("shape violations: bad name regex, missing current_slice, gates: null", () => {
+    expectErrors(parseManifest(loadFixture("bad-shape.yaml")), [
+        "E_BAD_ENUM_VALUE", // name not kebab-case
+        "E_BAD_CURRENT_SLICE", // current_slice missing
+        "E_MISSING_REQUIRED_FIELD", // gates: null
+    ]);
+});
+test("gate payload: bad status value caught", () => {
+    const yaml = `schema_version: "5"
+name: ok
+type: feature
+description: "x"
+status: in-progress
+created: "2026-05-03"
+command: feature
+phases:
+  discover: { codebase-analysis: { status: pending, gate-passed: false } }
+  plan: { brainstorm: { status: pending, gate-passed: false } }
+  quality: { code-review-final: { status: pending, gate-passed: false } }
+  deliver: { pr-created: false }
+  support: { gotchas-recorded: false }
+slice_graph:
+  current_slice: a
+  slices:
+    a:
+      type: feature-slice
+      depends_on: []
+      status: pending
+      gates:
+        build-tdd: { status: bogus-status, gate-passed: "yes" }
+`;
+    expectErrors(parseManifest(yaml), ["E_BAD_ENUM_VALUE", "E_MISSING_REQUIRED_FIELD"]);
+});
+test("depends_on must be an array", () => {
+    const yaml = `schema_version: "5"
+name: ok
+type: feature
+description: "x"
+status: in-progress
+created: "2026-05-03"
+command: feature
+phases:
+  discover: { codebase-analysis: { status: pending, gate-passed: false } }
+  plan: { brainstorm: { status: pending, gate-passed: false } }
+  quality: { code-review-final: { status: pending, gate-passed: false } }
+  deliver: { pr-created: false }
+  support: { gotchas-recorded: false }
+slice_graph:
+  current_slice: a
+  slices:
+    a:
+      type: feature-slice
+      depends_on: "skeleton"
+      status: pending
+      gates: { build-tdd: { status: pending, gate-passed: false } }
+`;
+    expectErrors(parseManifest(yaml), ["E_MISSING_REQUIRED_FIELD"]);
+});
+console.log("\nv6: phase_plan");
+test("v6 good manifest parses cleanly", () => {
+    const m = expectOk(parseManifest(loadFixture("v6-good.yaml")), "v6");
+    if (!m.phase_plan)
+        throw new Error("expected phase_plan to be present");
+    // Scalar form normalized to object
+    if (m.phase_plan.concept?.status !== "skipped") {
+        throw new Error(`expected phase_plan.concept.status=skipped, got ${m.phase_plan.concept?.status}`);
+    }
+    // Object form preserves reason
+    if (m.phase_plan["test-plan"]?.reason !== "typecheck + browser verify only — no test runner installed") {
+        throw new Error(`expected phase_plan.test-plan.reason preserved`);
+    }
+    if (m.phase_plan["test-plan"]?.status !== "active-light") {
+        throw new Error(`expected phase_plan.test-plan.status=active-light`);
+    }
+});
+test("v6 manifest missing phase_plan is rejected", () => {
+    const yaml = `schema_version: "6"
+name: missing-plan
+type: feature
+description: "x"
+status: in-progress
+created: "2026-05-12"
+command: feature
+phases:
+  discover: { codebase-analysis: { status: pending, gate-passed: false } }
+  plan: { brainstorm: { status: pending, gate-passed: false } }
+  quality: { code-review-final: { status: pending, gate-passed: false } }
+  deliver: { pr-created: false }
+  support: { gotchas-recorded: false }
+slice_graph:
+  current_slice: a
+  slices:
+    a: { type: feature-slice, depends_on: [], status: pending, gates: { build-tdd: { status: pending, gate-passed: false } } }
+`;
+    expectErrors(parseManifest(yaml), ["E_MISSING_REQUIRED_FIELD"]);
+});
+test("v6 bad phase_plan: bad enum + bad shape", () => {
+    expectErrors(parseManifest(loadFixture("v6-bad-phase-plan.yaml")), [
+        "E_BAD_PHASE_PLAN_STATUS",
+        "E_BAD_PHASE_PLAN_SHAPE",
+    ]);
+});
+test("v5 manifest parsed under v6 reader leaves phase_plan undefined", () => {
+    const m = expectOk(parseManifest(loadFixture("v5-good.yaml")), "v5");
+    if (m.phase_plan !== undefined) {
+        throw new Error(`expected v5 manifest to have phase_plan=undefined, got ${JSON.stringify(m.phase_plan)}`);
+    }
+});
+test("v6 typo'd phase_plan key triggers W_UNKNOWN_PHASE_PLAN_KEY warning", () => {
+    // Same as v6-good.yaml but with one key intentionally misspelled. Parse
+    // should still succeed (warning, not error) and the warning should name the
+    // bad key so command authors can act on it.
+    const yaml = `schema_version: "6"
+name: typo-feature
+type: feature
+description: "phase_plan with a misspelled key"
+status: in-progress
+created: "2026-05-12"
+command: feature
+phase_plan:
+  discover-codebase: active
+  prototpe: active                # typo — should be "prototype"
+  production-build: active
+  test-plan: active-light
+  uiux-review: active
+  code-review-final: active
+  deliver: active
+  gotchas: as-discovered
+phases:
+  discover: { codebase-analysis: { status: pending, gate-passed: false } }
+  plan: { brainstorm: { status: pending, gate-passed: false } }
+  quality: { code-review-final: { status: pending, gate-passed: false } }
+  deliver: { pr-created: false }
+  support: { gotchas-recorded: false }
+slice_graph:
+  current_slice: a
+  slices:
+    a: { type: feature-slice, depends_on: [], status: pending, gates: { build-tdd: { status: pending, gate-passed: false } } }
+`;
+    const r = parseManifest(yaml);
+    if (!r.ok) {
+        throw new Error(`expected parse to succeed (warning, not error); got errors: ${r.errors.map((e) => e.code).join(", ")}`);
+    }
+    const matching = r.warnings.filter((w) => w.code === "W_UNKNOWN_PHASE_PLAN_KEY");
+    if (matching.length !== 1) {
+        throw new Error(`expected exactly 1 W_UNKNOWN_PHASE_PLAN_KEY warning, got ${matching.length}: ${JSON.stringify(r.warnings)}`);
+    }
+    if (!matching[0].path.includes("prototpe")) {
+        throw new Error(`expected warning path to mention the typo'd key, got ${matching[0].path}`);
+    }
+});
+test("v6 happy-path manifest emits no W_UNKNOWN_PHASE_PLAN_KEY warnings", () => {
+    const r = parseManifest(loadFixture("v6-good.yaml"));
+    if (!r.ok)
+        throw new Error("expected v6-good to parse");
+    const unknown = r.warnings.filter((w) => w.code === "W_UNKNOWN_PHASE_PLAN_KEY");
+    if (unknown.length !== 0) {
+        throw new Error(`expected zero W_UNKNOWN_PHASE_PLAN_KEY warnings on v6-good, got: ${JSON.stringify(unknown)}`);
+    }
+});
+test("variant: empty-string on non-skeleton is forbidden", () => {
+    const yaml = `schema_version: "5"
+name: ok
+type: feature
+description: "x"
+status: in-progress
+created: "2026-05-03"
+command: feature
+phases:
+  discover: { codebase-analysis: { status: pending, gate-passed: false } }
+  plan: { brainstorm: { status: pending, gate-passed: false } }
+  quality: { code-review-final: { status: pending, gate-passed: false } }
+  deliver: { pr-created: false }
+  support: { gotchas-recorded: false }
+slice_graph:
+  current_slice: a
+  slices:
+    a:
+      type: feature-slice
+      variant: ""              # forbidden — must be absent or null
+      depends_on: []
+      status: pending
+      gates: { build-tdd: { status: pending, gate-passed: false } }
+`;
+    expectErrors(parseManifest(yaml), ["E_VARIANT_FORBIDDEN"]);
+});
+// NOTE: transitional tests removed per V5-PLAN §9.2 ("Enforcement is earned,
+// not assumed"). verifyTransition + status-transition enforcement were cut;
+// slice status transitions remain a documented lifecycle convention. If
+// dogfood evidence shows the convention is silently violated, restore both
+// the function and these tests from git history (commit be5ab93's parent).
+console.log("\nMisc: YAML parse errors");
+test("malformed YAML returns E_YAML_PARSE", () => {
+    const r = parseManifest("not: : valid: yaml: at all: \n  - [unclosed");
+    if (r.ok)
+        throw new Error("expected error");
+    if (!r.errors.some((e) => e.code === "E_YAML_PARSE")) {
+        throw new Error(`expected E_YAML_PARSE, got ${r.errors.map((e) => e.code)}`);
+    }
+});
+test("empty YAML returns error", () => {
+    const r = parseManifest("");
+    if (r.ok)
+        throw new Error("expected error");
+});
+console.log(`\n=== ${passed} passed, ${failed} failed ===`);
+if (failed > 0) {
+    console.log("\nFailures:");
+    fails.forEach((f) => console.log("  - " + f));
+    process.exit(1);
+}
+process.exit(0);

package/dist/active-manifest.js

@@ -0,0 +1,229 @@
+/**
+ * Active manifest pointer — `.forge/state/active-manifest.json`.
+ *
+ * Records which manifest the current session "owns". Used by:
+ *   - `telemetry.sh` to tag every Skill/Agent invocation with a slice context
+ *     captured AT INVOCATION TIME (per Codex round-1 #3 — race semantics).
+ *   - `gate-enforcer.sh` (via `gate-check` CLI) to confirm a gate edit
+ *     targets the same manifest as the active pointer; otherwise refuses.
+ *
+ * Write semantics: atomic rename. The pointer is tiny and infrequently
+ * written; full `flock(2)` is overkill. `O_EXCL`-style temp + atomic
+ * `rename(2)` is sufficient for the single-agent-multiple-tab footgun.
+ *
+ * Read semantics: missing file → null. Corrupt JSON → throw. The system
+ * should never silently degrade enforcement on corruption.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { execSync } from "node:child_process";
+/** Resolve the project's `.forge/state/` directory. Mirrors telemetry.sh /
+ *  session-start.sh resolution: prefer `git rev-parse --show-toplevel`,
+ *  fall back to cwd. */
+export function getStateDir(cwd = process.cwd()) {
+    let projectRoot = cwd;
+    try {
+        const out = execSync("git rev-parse --show-toplevel", {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        projectRoot = out.toString().trim() || cwd;
+    }
+    catch {
+        // Not a git repo; fall back to cwd. Same behavior as the bash hooks.
+    }
+    return resolve(projectRoot, ".forge", "state");
+}
+export function getActivePointerPath(cwd) {
+    return resolve(getStateDir(cwd), "active-manifest.json");
+}
+/** Read the active pointer. Returns null if not set; throws on corruption. */
+export function getActiveManifest(cwd) {
+    const path = getActivePointerPath(cwd);
+    if (!existsSync(path))
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch (e) {
+        throw new Error(`active-manifest pointer at ${path} cannot be read: ${e.message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`active-manifest pointer at ${path} is corrupt JSON: ${e.message}. ` +
+            `Either fix the file by hand or run 'aideas-forge active-manifest clear'.`);
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(`active-manifest pointer at ${path} is not a JSON object`);
+    }
+    const p = parsed;
+    if (typeof p.manifest_path !== "string" ||
+        typeof p.set_at !== "string" ||
+        typeof p.set_by !== "string") {
+        throw new Error(`active-manifest pointer at ${path} is missing required fields or has wrong types ` +
+            `(manifest_path, set_at, set_by all required, all strings); content: ${raw.slice(0, 200)}`);
+    }
+    if (!isAbsolute(p.manifest_path)) {
+        throw new Error(`active-manifest pointer manifest_path "${p.manifest_path}" must be absolute. ` +
+            `Re-run 'aideas-forge active-manifest set <path>' or 'clear'.`);
+    }
+    // Stale-pointer detection: the pointed-to manifest must still exist as a
+    // regular file. Otherwise enforcement would silently skip slice context.
+    let stat;
+    try {
+        stat = statSync(p.manifest_path);
+    }
+    catch (e) {
+        throw new Error(`active-manifest pointer references a manifest that cannot be read: ` +
+            `${p.manifest_path} (${e.message}). ` +
+            `Run 'aideas-forge active-manifest clear' or set a valid manifest.`);
+    }
+    if (!stat.isFile()) {
+        throw new Error(`active-manifest pointer references "${p.manifest_path}" which is not a regular file ` +
+            `(directory or other). Run 'aideas-forge active-manifest clear'.`);
+    }
+    return {
+        manifest_path: p.manifest_path,
+        set_at: p.set_at,
+        set_by: p.set_by,
+    };
+}
+/** Write the active pointer atomically. Verifies the manifest path exists
+ *  unless `skipExistsCheck` is true. */
+export function setActiveManifest(manifestPath, opts = {}) {
+    const absManifest = isAbsolute(manifestPath)
+        ? manifestPath
+        : resolve(opts.cwd ?? process.cwd(), manifestPath);
+    if (!opts.skipExistsCheck) {
+        let stat;
+        try {
+            stat = statSync(absManifest);
+        }
+        catch (e) {
+            throw new Error(`manifest does not exist: ${absManifest} (${e.message})`);
+        }
+        if (!stat.isFile()) {
+            throw new Error(`manifest path is not a regular file: ${absManifest} (got ${stat.isDirectory() ? "directory" : "other"})`);
+        }
+    }
+    const stateDir = getStateDir(opts.cwd);
+    mkdirSync(stateDir, { recursive: true });
+    const pointer = {
+        manifest_path: absManifest,
+        set_at: new Date().toISOString(),
+        set_by: opts.setBy ?? "manual",
+    };
+    const finalPath = getActivePointerPath(opts.cwd);
+    // Atomic write: write to .tmp, rename. POSIX rename(2) is atomic on the
+    // same filesystem; the .tmp suffix avoids torn reads if the writer dies
+    // mid-write or another tab races us. Always clean up the tmp file on
+    // failure — orphans would confuse later operators.
+    const tmpPath = `${finalPath}.${process.pid}.tmp`;
+    let renamed = false;
+    try {
+        writeFileSync(tmpPath, JSON.stringify(pointer, null, 2) + "\n", { mode: 0o644 });
+        renameSync(tmpPath, finalPath);
+        renamed = true;
+    }
+    finally {
+        if (!renamed) {
+            try {
+                rmSync(tmpPath, { force: true });
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+        }
+    }
+    return pointer;
+}
+/** Delete the active pointer. Idempotent — no error if already absent.
+ *  Returns true if a pointer existed before this call and was cleared,
+ *  false if there was nothing to clear. Concurrent-safe: uses force:true
+ *  so a racing clear does not throw. */
+export function clearActiveManifest(cwd) {
+    const path = getActivePointerPath(cwd);
+    const existedBefore = existsSync(path);
+    rmSync(path, { force: true });
+    return existedBefore;
+}
+export async function activeManifestCli(args) {
+    const subcommand = args[0];
+    switch (subcommand) {
+        case "set": {
+            // Parse --set-by flag (supports `--set-by foo` and `--set-by=foo bar`).
+            let setBy = "manual";
+            const positionals = [];
+            for (let i = 1; i < args.length; i++) {
+                const tok = args[i];
+                if (tok === "--set-by") {
+                    setBy = args[++i] ?? "";
+                    if (!setBy) {
+                        console.error("--set-by requires a value");
+                        return { exitCode: 1 };
+                    }
+                }
+                else if (tok.startsWith("--set-by=")) {
+                    setBy = tok.slice("--set-by=".length);
+                    if (!setBy) {
+                        console.error("--set-by requires a value");
+                        return { exitCode: 1 };
+                    }
+                }
+                else if (tok.startsWith("--")) {
+                    console.error(`unknown flag: ${tok}`);
+                    return { exitCode: 1 };
+                }
+                else {
+                    positionals.push(tok);
+                }
+            }
+            const path = positionals[0];
+            if (!path) {
+                console.error("Usage: aideas-forge active-manifest set <path-to-manifest.yaml> [--set-by <label>]");
+                return { exitCode: 1 };
+            }
+            if (positionals.length > 1) {
+                console.error(`unexpected extra arguments: ${positionals.slice(1).join(" ")}. ` +
+                    `Use --set-by "your label" for multi-word labels.`);
+                return { exitCode: 1 };
+            }
+            try {
+                const ptr = setActiveManifest(path, { setBy });
+                console.log(`Active manifest set:\n  ${ptr.manifest_path}\n  (set_by: ${ptr.set_by}, at ${ptr.set_at})`);
+                return { exitCode: 0 };
+            }
+            catch (e) {
+                console.error(`active-manifest set failed: ${e.message}`);
+                return { exitCode: 1 };
+            }
+        }
+        case "get": {
+            try {
+                const ptr = getActiveManifest();
+                if (!ptr) {
+                    console.log("(no active manifest)");
+                    return { exitCode: 0 };
+                }
+                console.log(`${ptr.manifest_path}\n  set_by: ${ptr.set_by}\n  set_at: ${ptr.set_at}`);
+                return { exitCode: 0 };
+            }
+            catch (e) {
+                console.error(`active-manifest get failed: ${e.message}`);
+                return { exitCode: 2 };
+            }
+        }
+        case "clear": {
+            const cleared = clearActiveManifest();
+            console.log(cleared ? "Active manifest cleared." : "(no active manifest to clear)");
+            return { exitCode: 0 };
+        }
+        default:
+            console.error("Usage: aideas-forge active-manifest <set <path> [set_by] | get | clear>");
+            return { exitCode: 1 };
+    }
+}

package/dist/cli.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { argv, exit } from "node:process";
+import { init } from "./init.js";
+import { update } from "./update.js";
+import { uninstall } from "./uninstall.js";
+import { verifyManifestCli } from "./verify-manifest.js";
+import { acceptDream, listDreams, rejectDream } from "./wiki.js";
+import { wikiUi } from "./wiki-ui.js";
+const USAGE = `
+forge — AI Development Life Cycle
+
+Usage:
+  forge init                           Install forge into the current project
+  forge update                         Sync forge assets to the latest version
+  forge uninstall                      Remove forge from the current project
+  forge verify-manifest [path]         Verify a v6 work-manifest (default: ./manifest.yaml)
+  forge wiki status                    List pending wiki dreams awaiting review
+  forge wiki accept <dream_id>         Accept a dream (atomic swap into aiwiki/)
+  forge wiki reject <dream_id> --reason "..."   Reject a dream with reason
+  forge wiki ui [--port N] [--no-open] Launch local web UI for dream review
+  forge --help                         Show this message
+
+Options (init/update/uninstall):
+  --force      Overwrite all files (init/update) or include CLAUDE.md/AGENTS.md (uninstall)
+  --dry-run    Preview changes without applying them
+  --purge      Remove .forge/ state directory (uninstall only)
+
+Options (verify-manifest):
+  --json                  Machine-readable output (for hook consumption)
+
+Options (wiki ui):
+  --port N        Listen on port N (default: 8765; auto-finds free port if busy)
+  --no-open       Do not auto-open browser
+`.trim();
+const args = argv.slice(2);
+const command = args[0];
+const flags = new Set(args.slice(1));
+switch (command) {
+    case "init":
+        await init({
+            force: flags.has("--force"),
+            dryRun: flags.has("--dry-run"),
+        });
+        break;
+    case "update":
+        await update({
+            force: flags.has("--force"),
+            dryRun: flags.has("--dry-run"),
+        });
+        break;
+    case "uninstall":
+        await uninstall({
+            force: flags.has("--force"),
+            purge: flags.has("--purge"),
+            dryRun: flags.has("--dry-run"),
+        });
+        break;
+    case "verify-manifest": {
+        // First positional arg after `verify-manifest` is the path; defaults to ./manifest.yaml.
+        const positional = args.slice(1).find((a) => !a.startsWith("--"));
+        const code = await verifyManifestCli({
+            path: positional ?? "./manifest.yaml",
+            json: flags.has("--json"),
+        });
+        exit(code);
+        break;
+    }
+    case "wiki": {
+        const sub = args[1];
+        const root = process.cwd();
+        if (sub === "status") {
+            const dreams = await listDreams(root);
+            if (dreams.length === 0) {
+                console.log("No pending dreams.");
+            }
+            else {
+                console.log(`Pending dreams: ${dreams.length}\n`);
+                for (const d of dreams) {
+                    const age = d.age_human;
+                    const detail = d.trigger_detail ? ` (${d.trigger_detail})` : "";
+                    console.log(`  ${d.dream_id}`);
+                    console.log(`    trigger: ${d.trigger}${detail}`);
+                    console.log(`    created: ${d.created_at} (${age})`);
+                    console.log(`    changes: +${d.new_pages} new, ~${d.changed_pages} changed, -${d.deleted_pages} deleted`);
+                    console.log(`    lint:    ${d.lint_status}`);
+                    console.log("");
+                }
+                console.log("Review with: forge wiki ui");
+                console.log("Accept with: forge wiki accept <dream_id>");
+                console.log("Reject with: forge wiki reject <dream_id> --reason \"...\"");
+            }
+            break;
+        }
+        if (sub === "accept") {
+            const dreamId = args[2];
+            if (!dreamId) {
+                console.error("Usage: forge wiki accept <dream_id>");
+                exit(1);
+            }
+            try {
+                const result = await acceptDream(dreamId, root);
+                console.log(`Accepted ${dreamId}`);
+                console.log(`  ${result.accepted_files.length} files swapped into aiwiki/`);
+                console.log(`  Originals archived to ${result.archived_to}`);
+            }
+            catch (err) {
+                console.error(`Accept failed: ${err.message}`);
+                exit(1);
+            }
+            break;
+        }
+        if (sub === "reject") {
+            const dreamId = args[2];
+            if (!dreamId) {
+                console.error("Usage: forge wiki reject <dream_id> --reason \"...\"");
+                exit(1);
+            }
+            const reasonIdx = args.indexOf("--reason");
+            const reason = reasonIdx !== -1 ? args[reasonIdx + 1] : "";
+            if (!reason) {
+                console.error("--reason is required");
+                exit(1);
+            }
+            try {
+                await rejectDream(dreamId, reason, root);
+                console.log(`Rejected ${dreamId}`);
+                console.log(`  reason: ${reason}`);
+            }
+            catch (err) {
+                console.error(`Reject failed: ${err.message}`);
+                exit(1);
+            }
+            break;
+        }
+        if (sub === "ui") {
+            const portIdx = args.indexOf("--port");
+            const port = portIdx !== -1 ? Number(args[portIdx + 1]) : undefined;
+            const code = await wikiUi({
+                port: Number.isFinite(port) ? port : undefined,
+                noOpen: flags.has("--no-open"),
+            });
+            exit(code);
+        }
+        console.error(`Unknown wiki subcommand: ${sub ?? "(none)"}`);
+        console.error("Run: forge --help");
+        exit(1);
+        break;
+    }
+    case "--help":
+    case "-h":
+    case undefined:
+        console.log(USAGE);
+        break;
+    default:
+        console.error(`Unknown command: ${command}\n`);
+        console.log(USAGE);
+        exit(1);
+}