@jamie-tam/forge 6.0.0 → 6.1.0

package/commands/{task-force.md → parallel.md}

@@ -1,12 +1,12 @@
 ---
-name: task-force
-description: "Dispatch a parallel task-force per item in a user-provided punch list. Phase-aware sizing (light teams in prototype phases, full crew in production). Routes command-shaped items (features, bugfixes, refactors) to their owning commands. Include !max (or --full-power) in your prompt to force full-crew production teams regardless of detected phase."
+name: parallel
+description: "Dispatch parallel agents per item in a user-provided punch list. Phase-aware sizing (light teams in prototype phases, full crew in production). Routes command-shaped items (features, bugfixes, refactors) to their owning commands. Include !max (or --full-power) in your prompt to force full-crew production teams regardless of detected phase."
 argument-hint: "task1; task2; task3 (or numbered/bulleted list); append !max to force full crew"
 ---
 
-# /task-force
+# /parallel
 
-Run a parallel ad-hoc task-force dispatcher over a punch list of independent tasks.
+Run a parallel ad-hoc dispatcher over a punch list of independent tasks.
 
 ## When to use
 
@@ -25,26 +25,26 @@ Run a parallel ad-hoc task-force dispatcher over a punch list of independent tas
 
 ## Process
 
-REQUIRED SUB-SKILL: Use **support-task-force** to:
+REQUIRED SUB-SKILL: Use **support-parallel** to:
 1. Run Codex consent (one-time per run, per `protocols/codex.md`)
 2. Detect repo phase (prototype vs production) from active manifest or repo state
 3. Parse the task list (numbered, bulleted, or semicolon-separated argument)
 4. Classify each task by type (dev / research / debug / docs / review / security / quick / complex / command-shaped)
-5. Route command-shaped items to their owning commands (do NOT dispatch task-forces for them)
+5. Route command-shaped items to their owning commands (do NOT dispatch parallel runs for them)
 6. Assemble a team per task, sized by task type AND phase mode
-7. Dispatch all task-forces in parallel (background subagents)
+7. Dispatch all per-task teams in parallel (background subagents)
 8. Aggregate per-task verdicts with Claude+Codex consensus check
 9. Surface a run-summary with conflicts highlighted
 
 ## Arguments
 
 Either:
-- Pass the list directly: `/task-force update README; explore caching options; add test for parser`
-- Or pass a numbered/bulleted list in the next prompt after invoking `/task-force` bare
+- Pass the list directly: `/parallel update README; explore caching options; add test for parser`
+- Or pass a numbered/bulleted list in the next prompt after invoking `/parallel` bare
 
 ## Output
 
-`.forge/task-force/{run-id}/` containing:
+`.forge/parallel/{run-id}/` containing:
 - `codex.yaml` — Codex consent choice
 - `tasks.yaml` — task classifications
 - `task-{n}/{role}.md` — per-agent output
@@ -63,7 +63,7 @@ Either:
 ### Standard (phase-aware sizing)
 
 ```
-/task-force
+/parallel
 1. Update README with new install steps
 2. Explore options for adding a /status command
 3. Add unit test for parser edge cases
@@ -84,7 +84,7 @@ In prototype phase, the same list dispatches ~5 agents (light templates, no Code
 ### Force full power (`!max` override)
 
 ```
-/task-force !max
+/parallel !max
 1. Update README with new install steps
 2. Add helper function for date parsing
 3. Investigate why CI is flaky on test 17
@@ -100,11 +100,11 @@ Use `!max` (short form) or `--full-power` (canonical form) when prototype code i
 
 ## Manifest
 
-This command does NOT create a `.forge/work/{type}/{name}/` manifest — task-force runs are not phase-gated. State lives in `.forge/task-force/{run-id}/` only.
+This command does NOT create a `.forge/work/{type}/{name}/` manifest — `/parallel` runs are not phase-gated. State lives in `.forge/parallel/{run-id}/` only.
 
-If an active feature/bugfix manifest exists, the task-force run-id is appended to its current phase as `task-force-runs: [...]` for audit.
+If an active feature/bugfix manifest exists, the parallel run-id is appended to its current phase as `parallel-runs: [...]` for audit.
 
 ## See also
 
-- `skills/support-task-force/SKILL.md` — full process documentation
+- `skills/support-parallel/SKILL.md` — full process documentation
 - `/feature`, `/bugfix`, `/refactor` — for command-shaped work that this skill refuses to swallow

package/commands/resume.md

@@ -10,7 +10,7 @@ Resume a paused work item without restarting completed phases.
 
 ## Scope
 
-Resumes an existing in-flight work item by reading its manifest and re-entering its owning command (`/feature`, `/greenfield`, `/bugfix`, `/hotfix`, `/refactor`) at the first unfinished phase. Does NOT create new work items, modify gate state, re-run already-passed gates, or abort/escalate work. Invoke after a session break, after a manifest update, or whenever the user wants to continue paused work.
+Resumes an existing in-flight work item by reading its manifest and re-entering its owning command (`/feature`, `/greenfield`, `/bugfix`, `/hotfix`, `/refactor`) at the first unfinished phase. Does NOT create new work items, modify gate state, re-run already-passed gates, or escalate work. Invoke after a session break, after a manifest update, or whenever the user wants to continue paused work.
 
 ## Input
 
@@ -19,7 +19,7 @@ Accept `type/name` when provided, such as `feature/add-payments`. If omitted, ru
 ## Steps
 
 1. Read `.forge/work/{type}/{name}/manifest.yaml`.
-2. If `status` is `completed`, `abandoned`, or `escalated`, do not resume. Surface the status and any `successor_path`.
+2. If `status` is `completed` or `escalated`, do not resume. Surface the status and any `successor_path`.
 3. Identify the last completed phase and the first incomplete phase using the same gate-skip rules as the owning command.
 4. Invoke the owning command (`/feature`, `/greenfield`, `/bugfix`, `/hotfix`, or `/refactor`) with the work item name and instruct it to resume from the manifest.
 5. Do not recreate manifests, delete files, or rerun phases whose gates already passed.

package/commands/setup.md

@@ -96,34 +96,35 @@ After confirmation, fill both project docs. Show the filled content for review b
 STOP. Present the filled CLAUDE.md and AGENTS.md content to the user for review before writing. Do NOT write files without user confirmation.
 </GATE>
 
-## Step 2a: Configure Gate Enforcement Mode
+## Step 2a: Apply Gate Enforcement Mode
 
 `npx @jamie-tam/forge init` installs PreToolUse hooks that block manifest `gate-passed: true` edits unless telemetry shows the matching skill was invoked via the Skill tool. Useful for production-grade work; high-friction for prototype iteration where most phases are explicitly skipped.
 
-**Default suggestion** (computed from Step 2 profile):
-- If signals match **prototype mode** (path under `pocs/`, `package.json` `"private": true` with no CI, no `aiwiki/architecture/`): suggest **disable**
-- If signals match **production mode** (CI configured, tests present, codified architecture exists or imminent): suggest **keep enabled**
+**Apply automatically based on detected mode** (no prompt — the user has not yet seen a gate fire and can't reasonably decide upfront; setup chooses the mode-appropriate default and tells the user how to change it later).
 
-Ask the user:
+Detect from the Step 2 profile:
 
-```
-Gate enforcement (PreToolUse hooks that block manifest gate-passed edits without skill-invocation telemetry):
-
-Suggested for this project: <KEEP ENABLED | DISABLE>
-
-  • Keep enabled — production-grade discipline; manifests cannot lie about gate state
-  • Disable     — prototype iteration; faster loop, telemetry still recorded for retrospective audit
-
-Choice? [Y]es (keep enabled) / [d]isable / [k]eep enabled regardless of suggestion
-```
+| Mode signal | Decision |
+|---|---|
+| Working under `pocs/`, OR `package.json` has `"private": true` with no CI configured, OR `aiwiki/architecture/` is empty/missing | **Disable** — prototype iteration; faster loop |
+| CI configured, tests present, codified architecture exists or imminent | **Keep enabled** — production discipline; manifests cannot lie about gate state |
 
 **On "disable"**: remove the two gate-enforcer matcher entries from `.claude/settings.local.json` (the entries with `matcher: Edit` or `matcher: Write` whose command invokes `.claude/hooks/scripts/gate-enforcer.sh`). The file is gitignored so this is a local-only change. Keep the PostToolUse telemetry hook — telemetry is still recorded for retrospective audit; only the blocking is removed.
 
 **On "keep enabled"**: leave settings.local.json as installed.
 
-Tell the user: "Gate enforcement <enabled / disabled>. To toggle later, edit `.claude/settings.local.json` — see `hooks/hooks.json` in the forge repo for the canonical entries."
+**Then tell the user, plainly:**
+
+```
+Gate enforcement: <enabled | disabled>
+  Reason: <mode signal that triggered it>
+  To change: remove or restore the two gate-enforcer PreToolUse entries in
+  .claude/settings.local.json (canonical entries in hooks/hooks.json).
+  First time you hit a real gate-passed edit and want to opt in (or out),
+  surface the toggle then — no upfront commitment.
+```
 
-Note in the manifest or session memo what was chosen, so future sessions don't have to re-detect.
+Note in the manifest or session memo what was applied, so future sessions don't have to re-detect.
 
 ## Step 3: Create .forge Directory
 

package/commands/status.md

@@ -9,12 +9,12 @@ List active work items from `.forge/work/` without modifying files.
 
 ## Scope
 
-Reports in-flight `.forge/work/` items and their current phase. Read-only — does not modify manifests, files, or wiki. Does NOT resume work, route between commands, or judge whether a stalled item should be aborted. Invoke when the user asks "what's in flight?", before `/resume` (to pick a target), or before `/abort` (to confirm which item).
+Reports in-flight `.forge/work/` items and their current phase. Read-only — does not modify manifests, files, or wiki. Does NOT resume work or route between commands. Invoke when the user asks "what's in flight?" or before `/resume` (to pick a target).
 
 ## Steps
 
 1. Find manifests at `.forge/work/*/*/manifest.yaml`.
-2. Exclude items whose `status` is `completed`, `abandoned`, or `escalated`.
+2. Exclude items whose `status` is `completed` or `escalated`.
 3. For each remaining item, infer the current phase from the first phase or gate that is not complete, locked, skipped, or not-applicable. Prefer explicit fields such as `build.current_phase` when present.
 4. Print a table:
 

package/dist/__tests__/hooks.test.js

@@ -0,0 +1,334 @@
+/**
+ * Tests for src/hooks.ts — focus on the uninstall reverse-merge path.
+ *
+ * Regression: src/uninstall.ts previously did rmSync on settings.local.json
+ * unconditionally, wiping user-added permissions/env/hooks. The fix is a
+ * symmetric unmergeHooks + uninstallHooks pair that removes only forge-owned
+ * entries.
+ *
+ * Run with: npm run build && node dist/__tests__/hooks.test.js
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { unmergeHooks, uninstallHooks } from "../hooks.js";
+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 mkTempRoot() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "forge-hooks-test-"));
+}
+function writeSettings(claudeDir, settings) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+    const p = path.join(claudeDir, "settings.local.json");
+    fs.writeFileSync(p, JSON.stringify(settings, null, 2) + "\n");
+    return p;
+}
+function readSettings(settingsPath) {
+    return JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+}
+console.log("\n=== hooks.ts: unmergeHooks ===\n");
+test("unmergeHooks drops events where every entry is forge-owned", () => {
+    const forge = {
+        PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "x" }] }],
+    };
+    const existing = {
+        PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "x" }] }],
+    };
+    const result = unmergeHooks(existing, forge);
+    if (Object.keys(result).length !== 0) {
+        throw new Error(`expected empty result, got keys: ${Object.keys(result).join(",")}`);
+    }
+});
+test("unmergeHooks preserves user entries within a forge-managed event", () => {
+    const forge = {
+        PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "forge-cmd" }] }],
+    };
+    const existing = {
+        PreToolUse: [
+            { matcher: "Bash", hooks: [{ type: "command", command: "user-cmd" }] },
+            { matcher: "Bash", hooks: [{ type: "command", command: "forge-cmd" }] },
+        ],
+    };
+    const result = unmergeHooks(existing, forge);
+    if (!result.PreToolUse || result.PreToolUse.length !== 1) {
+        throw new Error(`expected 1 user entry, got ${result.PreToolUse?.length ?? 0}`);
+    }
+    const remaining = result.PreToolUse[0];
+    const cmd = remaining.hooks[0].command;
+    if (cmd !== "user-cmd") {
+        throw new Error(`expected user-cmd preserved, got ${cmd}`);
+    }
+});
+test("unmergeHooks passes through events forge doesn't manage", () => {
+    const forge = {
+        PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "x" }] }],
+    };
+    const existing = {
+        PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "x" }] }],
+        Stop: [{ matcher: "", hooks: [{ type: "command", command: "user-stop" }] }],
+    };
+    const result = unmergeHooks(existing, forge);
+    if (!result.Stop || result.Stop.length !== 1) {
+        throw new Error("Stop event (not managed by forge) should be preserved");
+    }
+    if (result.PreToolUse) {
+        throw new Error("PreToolUse should have been dropped (only forge entries)");
+    }
+});
+test("unmergeHooks preserves user entry order", () => {
+    const forge = {
+        PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: "f" }] }],
+    };
+    const existing = {
+        PreToolUse: [
+            { matcher: "Bash", hooks: [{ type: "command", command: "u1" }] },
+            { matcher: "Bash", hooks: [{ type: "command", command: "f" }] },
+            { matcher: "Bash", hooks: [{ type: "command", command: "u2" }] },
+        ],
+    };
+    const result = unmergeHooks(existing, forge);
+    const cmds = result.PreToolUse.map((e) => e.hooks[0].command);
+    if (cmds.join(",") !== "u1,u2") {
+        throw new Error(`order broken: got ${cmds.join(",")}`);
+    }
+});
+console.log("\n=== hooks.ts: uninstallHooks (end-to-end) ===\n");
+test("uninstallHooks returns 'absent' when settings.local.json does not exist", () => {
+    const root = mkTempRoot();
+    const result = uninstallHooks(root, { dryRun: false });
+    if (result.action !== "absent") {
+        throw new Error(`expected 'absent', got '${result.action}'`);
+    }
+});
+test("uninstallHooks deletes file when only forge hooks existed (the buggy old behavior — but only when nothing else is present)", () => {
+    const root = mkTempRoot();
+    // Simulate a fresh forge install — only forge hooks, no user content.
+    // Read the real forge hooks.json to construct realistic input.
+    const realHooks = JSON.parse(fs.readFileSync(path.join(process.cwd(), "hooks", "hooks.json"), "utf-8")).hooks;
+    const settingsPath = writeSettings(path.join(root, ".claude"), { hooks: realHooks });
+    const result = uninstallHooks(root, { dryRun: false });
+    if (result.action !== "deleted") {
+        throw new Error(`expected 'deleted', got '${result.action}'`);
+    }
+    if (fs.existsSync(settingsPath)) {
+        throw new Error("settings.local.json should have been deleted");
+    }
+});
+test("uninstallHooks PRESERVES user permissions when stripping forge hooks (the bug fix)", () => {
+    const root = mkTempRoot();
+    const realHooks = JSON.parse(fs.readFileSync(path.join(process.cwd(), "hooks", "hooks.json"), "utf-8")).hooks;
+    const userPermissions = {
+        allow: ["Bash(npm test)", "Bash(git status)"],
+    };
+    const settingsPath = writeSettings(path.join(root, ".claude"), {
+        permissions: userPermissions,
+        hooks: realHooks,
+    });
+    const result = uninstallHooks(root, { dryRun: false });
+    if (result.action !== "updated") {
+        throw new Error(`expected 'updated', got '${result.action}'`);
+    }
+    if (!fs.existsSync(settingsPath)) {
+        throw new Error("settings.local.json was deleted but should have been preserved");
+    }
+    const settings = readSettings(settingsPath);
+    if (!settings.permissions) {
+        throw new Error("user permissions were wiped");
+    }
+    const perms = settings.permissions;
+    if (perms.allow.length !== 2 || perms.allow[0] !== "Bash(npm test)") {
+        throw new Error(`permissions corrupted: ${JSON.stringify(settings.permissions)}`);
+    }
+    if (settings.hooks) {
+        throw new Error("forge hooks key should be gone (it was empty after removal)");
+    }
+});
+test("uninstallHooks preserves user-added hooks within a forge-managed event", () => {
+    const root = mkTempRoot();
+    const realHooks = JSON.parse(fs.readFileSync(path.join(process.cwd(), "hooks", "hooks.json"), "utf-8")).hooks;
+    // User added their own PreToolUse hook alongside the forge ones.
+    const userHook = { matcher: "Edit", hooks: [{ type: "command", command: "my-lint.sh" }] };
+    const blended = {
+        ...realHooks,
+        PreToolUse: [...(realHooks.PreToolUse ?? []), userHook],
+    };
+    const settingsPath = writeSettings(path.join(root, ".claude"), { hooks: blended });
+    const result = uninstallHooks(root, { dryRun: false });
+    if (result.action !== "updated") {
+        throw new Error(`expected 'updated', got '${result.action}'`);
+    }
+    const settings = readSettings(settingsPath);
+    const hooks = settings.hooks;
+    if (!hooks?.PreToolUse || hooks.PreToolUse.length !== 1) {
+        throw new Error(`expected 1 surviving user PreToolUse entry, got ${hooks?.PreToolUse?.length ?? 0}`);
+    }
+    const surviving = hooks.PreToolUse[0];
+    if (surviving.matcher !== "Edit") {
+        throw new Error(`wrong entry survived: ${JSON.stringify(surviving)}`);
+    }
+});
+test("uninstallHooks dryRun does not mutate the file", () => {
+    const root = mkTempRoot();
+    const realHooks = JSON.parse(fs.readFileSync(path.join(process.cwd(), "hooks", "hooks.json"), "utf-8")).hooks;
+    const settingsPath = writeSettings(path.join(root, ".claude"), {
+        permissions: { allow: ["Bash(npm test)"] },
+        hooks: realHooks,
+    });
+    const before = fs.readFileSync(settingsPath, "utf-8");
+    const result = uninstallHooks(root, { dryRun: true });
+    if (result.action !== "updated") {
+        throw new Error(`expected 'updated', got '${result.action}'`);
+    }
+    const after = fs.readFileSync(settingsPath, "utf-8");
+    if (before !== after) {
+        throw new Error("dryRun mutated settings.local.json");
+    }
+});
+console.log("\n=== hooks.ts: forge_owned marker (stale-accumulation prevention) ===\n");
+test("unmergeHooks removes entries marked forge_owned: true even when command differs", () => {
+    // Scenario: a future forge release changes the gate-enforcer command (adds
+    // a flag, updates path). User's settings.local.json still has the OLD
+    // command, marked forge_owned: true from when it was installed. unmerge
+    // against the NEW forge entry set should still detect and remove the old
+    // entry by marker — not leave it stranded as "user-defined".
+    const newForge = {
+        PreToolUse: [
+            {
+                forge_owned: true,
+                matcher: "Edit",
+                hooks: [{ type: "command", command: "bash X.sh --strict" }],
+            },
+        ],
+    };
+    const existingWithOldVersion = {
+        PreToolUse: [
+            {
+                forge_owned: true,
+                matcher: "Edit",
+                hooks: [{ type: "command", command: "bash X.sh" }], // OLD command
+            },
+        ],
+    };
+    const result = unmergeHooks(existingWithOldVersion, newForge);
+    if (Object.keys(result).length !== 0) {
+        throw new Error(`expected the old-version forge entry to be removed by marker, got keys: ${Object.keys(result).join(",")}`);
+    }
+});
+test("mergeHooks replaces a marker-tagged old entry with new forge entry (no stale accumulation)", () => {
+    // Same scenario as above but for mergeHooks: install of v7 over an
+    // existing v6 install (where v6 entries have forge_owned: true but the
+    // command string differs). The merged result should have ONLY the new
+    // entry, not both.
+    const newForge = {
+        PreToolUse: [
+            {
+                forge_owned: true,
+                matcher: "Edit",
+                hooks: [{ type: "command", command: "bash X.sh --strict" }],
+            },
+        ],
+    };
+    const existingWithOldVersion = {
+        PreToolUse: [
+            {
+                forge_owned: true,
+                matcher: "Edit",
+                hooks: [{ type: "command", command: "bash X.sh" }],
+            },
+        ],
+    };
+    // installHooks → mergeHooks (mergeHooks isn't exported; verify via
+    // unmergeHooks identity instead by checking what the merged output WOULD
+    // keep. The user-entry filter inside mergeHooks uses isForgeOwned exactly
+    // like unmergeHooks does, so unmergeHooks of existing→{} confirms the
+    // stale entry is correctly identified as forge-owned and gone.)
+    const remaining = unmergeHooks(existingWithOldVersion, newForge);
+    if (remaining.PreToolUse !== undefined) {
+        throw new Error(`stale v6 entry survived: ${JSON.stringify(remaining.PreToolUse)}`);
+    }
+});
+test("identity fallback still works for legacy entries without the marker", () => {
+    // Backward compat: installations made before the marker shipped have
+    // forge entries WITHOUT forge_owned. As long as the command string still
+    // matches verbatim against current forge, identity match catches them.
+    const forge = {
+        PreToolUse: [
+            {
+                forge_owned: true,
+                matcher: "Edit",
+                hooks: [{ type: "command", command: "bash X.sh" }],
+            },
+        ],
+    };
+    const existingLegacy = {
+        PreToolUse: [
+            // Same content as forge entry but WITHOUT the forge_owned marker —
+            // the shape of an entry installed before the marker shipped.
+            // Note: identity fallback compares stringified entries, so the
+            // legacy entry needs to be byte-identical to a current forge entry
+            // MINUS the marker. We include the marker on the comparator side
+            // (forgeStrings) so the legacy entry would not exact-match.
+            // The test below verifies an entry whose stringified form is in
+            // the forgeStrings set still gets removed — i.e. exact match.
+            {
+                forge_owned: true,
+                matcher: "Edit",
+                hooks: [{ type: "command", command: "bash X.sh" }],
+            },
+        ],
+    };
+    const result = unmergeHooks(existingLegacy, forge);
+    if (Object.keys(result).length !== 0) {
+        throw new Error(`exact-match entry should have been removed, got ${JSON.stringify(result)}`);
+    }
+});
+test("user entries WITHOUT marker and WITHOUT exact-match survive", () => {
+    // The real backward-compat behavior: a user entry that is not forge-owned
+    // (no marker, no identity match) must always survive.
+    const forge = {
+        PreToolUse: [
+            {
+                forge_owned: true,
+                matcher: "Edit",
+                hooks: [{ type: "command", command: "bash forge.sh" }],
+            },
+        ],
+    };
+    const existing = {
+        PreToolUse: [
+            {
+                matcher: "Edit",
+                hooks: [{ type: "command", command: "bash my-user-script.sh" }],
+            },
+        ],
+    };
+    const result = unmergeHooks(existing, forge);
+    if (!result.PreToolUse || result.PreToolUse.length !== 1) {
+        throw new Error("user entry should have survived");
+    }
+    const cmd = result.PreToolUse[0].hooks[0].command;
+    if (cmd !== "bash my-user-script.sh") {
+        throw new Error(`wrong entry survived: ${cmd}`);
+    }
+});
+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/__tests__/init.test.js

@@ -0,0 +1,110 @@
+/**
+ * Tests for src/init.ts — focus on ensureGitignoreEntries.
+ *
+ * Regression: hooks/scripts/pre-compact.sh used to append `.forge/state/` to
+ * the user's .gitignore from a runtime hook. The fix moves that to install
+ * time via ensureGitignoreEntries, called from init().
+ *
+ * Run with: npm run build && node dist/__tests__/init.test.js
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { ensureGitignoreEntries } from "../init.js";
+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 mkTempRoot() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "forge-init-test-"));
+}
+console.log("\n=== init.ts: ensureGitignoreEntries ===\n");
+test("creates .gitignore with both entries when file does not exist", () => {
+    const root = mkTempRoot();
+    const added = ensureGitignoreEntries(root);
+    if (added.length !== 2) {
+        throw new Error(`expected 2 entries added, got ${added.length}: ${added.join(",")}`);
+    }
+    const content = fs.readFileSync(path.join(root, ".gitignore"), "utf-8");
+    if (!content.includes(".forge/state/"))
+        throw new Error(".forge/state/ missing");
+    if (!content.includes(".forge/local.yaml"))
+        throw new Error(".forge/local.yaml missing");
+});
+test("appends only missing entries when one is already present", () => {
+    const root = mkTempRoot();
+    fs.writeFileSync(path.join(root, ".gitignore"), "node_modules/\n.forge/state/\n");
+    const added = ensureGitignoreEntries(root);
+    if (added.length !== 1 || added[0] !== ".forge/local.yaml") {
+        throw new Error(`expected only [.forge/local.yaml], got ${added.join(",")}`);
+    }
+    const content = fs.readFileSync(path.join(root, ".gitignore"), "utf-8");
+    // Should still have the original lines intact
+    if (!content.includes("node_modules/"))
+        throw new Error("user content corrupted");
+    if (content.match(/\.forge\/state\//g).length !== 1) {
+        throw new Error(".forge/state/ duplicated");
+    }
+});
+test("is idempotent: re-run adds nothing when entries already present", () => {
+    const root = mkTempRoot();
+    ensureGitignoreEntries(root); // first call adds both
+    const first = fs.readFileSync(path.join(root, ".gitignore"), "utf-8");
+    const added = ensureGitignoreEntries(root); // second call should add nothing
+    if (added.length !== 0) {
+        throw new Error(`expected idempotent re-run to add nothing, got ${added.join(",")}`);
+    }
+    const second = fs.readFileSync(path.join(root, ".gitignore"), "utf-8");
+    if (first !== second) {
+        throw new Error("idempotent re-run mutated the file");
+    }
+});
+test("treats wildcard .forge/ as covering both entries (no-op)", () => {
+    const root = mkTempRoot();
+    fs.writeFileSync(path.join(root, ".gitignore"), ".forge/\n");
+    const added = ensureGitignoreEntries(root);
+    if (added.length !== 0) {
+        throw new Error(`expected .forge/ to cover both, got ${added.join(",")}`);
+    }
+    const content = fs.readFileSync(path.join(root, ".gitignore"), "utf-8");
+    if (content !== ".forge/\n")
+        throw new Error("file should be untouched");
+});
+test("treats .forge (without trailing slash) as covering both entries (no-op)", () => {
+    const root = mkTempRoot();
+    fs.writeFileSync(path.join(root, ".gitignore"), ".forge\n");
+    const added = ensureGitignoreEntries(root);
+    if (added.length !== 0) {
+        throw new Error(`expected .forge to cover both, got ${added.join(",")}`);
+    }
+});
+test("preserves a missing trailing newline by adding its own leading newline", () => {
+    const root = mkTempRoot();
+    // User's file with no trailing newline (common from manual edits)
+    fs.writeFileSync(path.join(root, ".gitignore"), "node_modules/");
+    ensureGitignoreEntries(root);
+    const content = fs.readFileSync(path.join(root, ".gitignore"), "utf-8");
+    // Should not have produced "node_modules/.forge/state/" smushed together
+    if (!content.startsWith("node_modules/\n")) {
+        throw new Error(`leading newline not inserted: ${JSON.stringify(content)}`);
+    }
+});
+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);