bigpowers 2.88.9 → 2.88.11

package/.gemini/extensions/bigpowers/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.88.9",
+  "version": "2.88.11",
   "description": "81 skills — 73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "keywords": [
     "gemini-extension"

package/.pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.88.9",
+  "version": "2.88.11",
   "description": "81 skills — 73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "keywords": [
     "pi-package"

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [2.88.11](https://github.com/danielvm-git/bigpowers/compare/v2.88.10...v2.88.11) (2026-10-25)
+
+
+### Bug Fixes
+
+* **guard:** resolve git branch per command target, not process cwd ([#154](https://github.com/danielvm-git/bigpowers/issues/154)) ([07c7498](https://github.com/danielvm-git/bigpowers/commit/07c749803c4d5d1c2499c01255fad138ce88e870))
+* **lockfile:** add missing slash in skill path + self-contained resolve_repo_root ([#156](https://github.com/danielvm-git/bigpowers/issues/156)) ([04bda15](https://github.com/danielvm-git/bigpowers/commit/04bda157195f39816cd388a2fb4b0829ca19b20f))
+* **omp-hooks:** inGitRepo bail-early, accept type!(scope) form, echo subject ([#157](https://github.com/danielvm-git/bigpowers/issues/157)) ([9e1b11a](https://github.com/danielvm-git/bigpowers/commit/9e1b11aaf4c63fa951c6916fabda13a836b56f2d)), closes [#147](https://github.com/danielvm-git/bigpowers/issues/147) [#151](https://github.com/danielvm-git/bigpowers/issues/151) [#151](https://github.com/danielvm-git/bigpowers/issues/151)
+
+
+### Performance Improvements
+
+* **sync:** render all skills in one bash process per adapter ([#155](https://github.com/danielvm-git/bigpowers/issues/155)) ([1b56463](https://github.com/danielvm-git/bigpowers/commit/1b564639771c39c3d4bc712f09912751a56ab8ee)), closes [#137](https://github.com/danielvm-git/bigpowers/issues/137)
+
+## [2.88.10](https://github.com/danielvm-git/bigpowers/compare/v2.88.9...v2.88.10) (2026-10-25)
+
+
+### Bug Fixes
+
+* **install:** support Windows without symlink privilege ([#135](https://github.com/danielvm-git/bigpowers/issues/135)) ([c47e3c5](https://github.com/danielvm-git/bigpowers/commit/c47e3c5465679046fe980be0c5593a489efee793)), closes [#134](https://github.com/danielvm-git/bigpowers/issues/134)
+* **srp:** resolve bash via PATH so adapters run on Windows ([#137](https://github.com/danielvm-git/bigpowers/issues/137)) ([c89f4f5](https://github.com/danielvm-git/bigpowers/commit/c89f4f563ed981a312f84cc6ac38e82a9826cd08))
+
 ## [2.88.9](https://github.com/danielvm-git/bigpowers/compare/v2.88.8...v2.88.9) (2026-09-21)
 
 

package/extensions/omp-hooks.ts

@@ -7,7 +7,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { execSync } from "node:child_process";
 import { readdirSync, readFileSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ---------------------------------------------------------------------------
@@ -28,8 +28,10 @@ const DANGEROUS_PATTERNS = [
   /push\s+-f(?:\s|$)/,
 ];
 
+// Conventional Commits specifies `type(scope)!:`, but many repositories write
+// `type!(scope):`. Accept both; the leading type is what matters.
 const CONVENTIONAL_RE =
-  /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([^)]+\))?!?:\s.+/;
+  /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)!?(?:\([^)]+\))?!?:\s.+/;
 
 const PROTECTED_BRANCH_RE = /(?:^|\s|[:])(?:main|master)(?:\s|$)/;
 const PROTECTED_BRANCHES = ["main", "master"] as const;
@@ -157,11 +159,57 @@ function pluginRoot(): string {
 // Git safety helpers
 // ---------------------------------------------------------------------------
 
-function currentBranch(): string {
+// Command-aware branch resolution: `git commit|push` in a bash command must
+// be judged against the repo it will actually run in, not the agent process
+// cwd (which is the session root — often a different repository).
+// Resolve the directory: the last `cd <path>` before it (within the command
+// prefix), overridden by the last `git -C <path>` anywhere in the command.
+// Fail-closed: unresolvable paths fall back to the process cwd — previous
+// behavior, over-blocks, never under-blocks.
+function commandGitCwd(command: string, upTo: number, fallback: string): string {
+  const head = command.slice(0, upTo);
+  const cdMatches = [
+    ...head.matchAll(/\bcd\s+(?:"([^"]+)"|'([^']+)'|([^&|;<(`$][^\s&|;<>]*))/g),
+  ];
+  const cMatches = [
+    ...command.matchAll(/\bgit\s+-C\s+(?:"([^"]+)"|'([^']+)'|([^&|;<(`$][^\s&|;<>]*))/g),
+  ];
+  const m = cMatches.length
+    ? cMatches[cMatches.length - 1]
+    : cdMatches.length
+      ? cdMatches[cdMatches.length - 1]
+      : null;
+  if (!m) return fallback;
+  const p = m[1] ?? m[2] ?? m[3];
+  if (!p || p.includes("$") || p.includes("`")) return fallback;
+  try {
+    const abs = resolve(fallback, p);
+    return statSync(abs).isDirectory() ? abs : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function inGitRepo(cwd?: string): boolean {
+  try {
+    execSync("git rev-parse --git-dir", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3000,
+      stdio: "ignore",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function currentBranch(cwd: string): string {
   try {
     return execSync("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf-8",
       timeout: 3000,
+      cwd,
     }).trim();
   } catch {
     return "unknown";
@@ -367,9 +415,11 @@ export default function bigpowers(pi: ExtensionAPI) {
       }
     }
 
-    const branch = currentBranch();
+    const sessionRoot = process.cwd();
+    if (!inGitRepo(sessionRoot)) return;
+    const pushBranch = currentBranch(commandGitCwd(command, command.length, sessionRoot));
 
-    if (/git\s+push/.test(command) && protectedPushTarget(command, branch)) {
+    if (/git\s+push/.test(command) && protectedPushTarget(command, pushBranch)) {
       return {
         block: true,
         reason:
@@ -378,10 +428,16 @@ export default function bigpowers(pi: ExtensionAPI) {
     }
 
     if (/git\s+commit/.test(command)) {
-      if ((PROTECTED_BRANCHES as readonly string[]).includes(branch)) {
+      const commitBranches = [...command.matchAll(/\bgit\s+commit\b/g)].map((m) =>
+        currentBranch(commandGitCwd(command, m.index ?? 0, sessionRoot)),
+      );
+      const hit = commitBranches.find((b) =>
+        (PROTECTED_BRANCHES as readonly string[]).includes(b),
+      );
+      if (hit) {
         return {
           block: true,
-          reason: `BLOCKED: Direct commits to '${branch}' are forbidden. Use a feature branch.`,
+          reason: `BLOCKED: Direct commits to '${hit}' are forbidden. Use a feature branch.`,
         };
       }
       const msg = extractCommitMessage(command);
@@ -389,8 +445,7 @@ export default function bigpowers(pi: ExtensionAPI) {
         if (!CONVENTIONAL_RE.test(msg)) {
           return {
             block: true,
-            reason:
-              "BLOCKED: Commit message must follow Conventional Commits: <type>(<scope>): <subject>.",
+            reason: `BLOCKED: Commit subject '${msg.split("\n")[0]}' must follow Conventional Commits: <type>(<scope>): <subject>.`,
           };
         }
         if (msg.split("\n")[0].length > 72) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.88.9",
+  "version": "2.88.11",
   "description": "73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "main": "index.js",
   "scripts": {

package/scripts/lib/adapter-render-all.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# story: #138
+# adapter-render-all.sh — render every skill through one adapter in a single
+# bash process.
+#
+# srp-engine.py --all used to spawn one `bash` (plus three `jq`) per
+# skill×adapter — ~1,539 bash and ~4,600 jq processes from one Python process.
+# On constrained Windows sessions that exhausts process-creation resources: the
+# run dies with STATUS_DLL_INIT_FAILED (0xC0000142) and then hangs on orphaned
+# children. Sourcing the adapter once and calling render_skill() in a loop keeps
+# the exact same rendering code while collapsing the process count to one per
+# adapter and removing the per-render jq calls.
+#
+# Input is a NUL-delimited stream written by srp-engine.py, five fields per
+# skill in order — name, description, model, body, pi body — each NUL-terminated
+# so field content may contain newlines.
+#
+# Adapters without a stdin entrypoint (continue, omp, zed) define render_skill
+# but were never driven by srp-engine; they are skipped so behaviour is
+# unchanged.
+#
+# Usage: adapter-render-all.sh <path-to-adapter.sh> <ir-stream-file>
+set -u
+
+adapter="$1"
+stream="$2"
+
+if [[ ! -f "$adapter" ]]; then
+  echo "adapter-render-all: adapter not found: $adapter" >&2
+  exit 1
+fi
+if [[ ! -f "$stream" ]]; then
+  echo "adapter-render-all: IR stream not found: $stream" >&2
+  exit 1
+fi
+
+# A spawned adapter with no stdin entrypoint is a no-op; match that.
+if ! grep -q '\[\[ ! -t 0 \]\]' "$adapter"; then
+  exit 0
+fi
+
+adapter_id="$(basename "$adapter" .sh)"
+
+# Sourcing the adapter runs its stdin entrypoint; point stdin at /dev/null so
+# `[[ ! -t 0 ]]` is true but `cat` yields nothing and the entrypoint no-ops.
+# shellcheck disable=SC1090
+source "$adapter" < /dev/null
+
+if ! declare -f render_skill >/dev/null 2>&1; then
+  exit 0
+fi
+
+exec 3< "$stream"
+status=0
+while IFS= read -r -d '' IR_NAME <&3; do
+  IFS= read -r -d '' IR_DESCRIPTION <&3
+  IFS= read -r -d '' IR_MODEL <&3
+  IFS= read -r -d '' IR_BODY <&3
+  IFS= read -r -d '' IR_BODY_PI <&3
+
+  IR_DESC_ESCAPED=$(echo "$IR_DESCRIPTION" | sed 's/\\/\\\\/g; s/"/\\"/g')
+  if [[ "$adapter_id" == "pi" ]]; then
+    IR_BODY_SKILL="$IR_BODY_PI"
+  else
+    IR_BODY_SKILL="$IR_BODY"
+  fi
+
+  if ! render_skill; then
+    status=1
+    break
+  fi
+done
+exec 3<&-
+exit "$status"

package/scripts/lib/install-helpers.js

@@ -14,6 +14,7 @@
 // story: e72s02
 // story: e68s02
 // story: e65s02
+// story: #134
 // install-helpers.js — symlink helpers for bigpowers setup
 
 const fs = require('fs');
@@ -23,6 +24,50 @@ const path = require('path');
 // directory, which is how "managed" is detected (see assertReplaceable).
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
 
+// Windows denies symlink creation unless the shell is elevated or Developer
+// Mode is on (EPERM). Directory *junctions* need no privilege, and Node reports
+// a junction through lstat/readlink exactly like a symlink — so install,
+// detectExistingInstall, and uninstall keep working. A file cannot be junctioned
+// (the result is a broken reparse point), so a file link on Windows becomes a
+// copy, tracked here so a reinstall replaces it and uninstall removes it.
+const copiesPath = () => path.join(require('os').homedir(), '.bigpowers', 'managed-copies.json');
+
+function managedCopies() {
+  try {
+    return new Set(JSON.parse(fs.readFileSync(copiesPath(), 'utf8')));
+  } catch {
+    return new Set();
+  }
+}
+
+function saveCopies(copies) {
+  fs.mkdirSync(path.dirname(copiesPath()), { recursive: true });
+  fs.writeFileSync(copiesPath(), JSON.stringify([...copies], null, 2));
+}
+
+// Symlink on POSIX; on Windows junction directories and copy (tracked) files.
+function createLink(src, dst) {
+  if (process.platform !== 'win32') {
+    fs.symlinkSync(src, dst);
+    return;
+  }
+  if (!fs.existsSync(src)) return; // source absent from this build (e.g. AGENTS.md)
+  if (fs.statSync(src).isDirectory()) {
+    fs.symlinkSync(src, dst, 'junction');
+    return;
+  }
+  try {
+    fs.symlinkSync(src, dst);
+    const copies = managedCopies();
+    if (copies.delete(dst)) saveCopies(copies); // was a copy; now a real link
+  } catch {
+    fs.copyFileSync(src, dst);
+    const copies = managedCopies();
+    copies.add(dst);
+    saveCopies(copies);
+  }
+}
+
 // Refuse to replace a destination that is not already a bigpowers-managed
 // symlink. Prevents setup from silently destroying a user's own file or
 // directory (e.g. an existing ~/.claude/hooks/rtk-rewrite.sh installed by
@@ -42,6 +87,9 @@ function assertReplaceable(dst) {
       return; // managed by bigpowers — safe to re-link
     }
   }
+  if (st.isFile() && managedCopies().has(dst)) {
+    return; // file copy placed by the Windows fallback — safe to re-link
+  }
   throw new Error(
     `Refusing to replace ${dst}: it exists and is not a bigpowers-managed symlink. ` +
     `Back it up or remove it manually, then re-run setup.`
@@ -58,7 +106,7 @@ function linkSkills(skillsDir, targetDir) {
 
     assertReplaceable(dst);
     fs.rmSync(dst, { force: true });
-    fs.symlinkSync(src, dst);
+    createLink(src, dst);
   }
 }
 
@@ -70,13 +118,13 @@ function linkDir(src, dst) {
   }
   assertReplaceable(dst);
   fs.rmSync(dst, { force: true });
-  fs.symlinkSync(src, dst);
+  createLink(src, dst);
 }
 
 function linkFile(src, dst) {
   assertReplaceable(dst);
   fs.rmSync(dst, { force: true });
-  fs.symlinkSync(src, dst);
+  createLink(src, dst);
 }
 
 function linkRenderedSkills(renderedDir, targetDir) {
@@ -106,7 +154,7 @@ function linkHook(src, dst) {
   }
   assertReplaceable(dst);
   fs.rmSync(dst, { force: true });
-  fs.symlinkSync(src, dst);
+  createLink(src, dst);
   try { fs.chmodSync(src, 0o755); } catch {}
 }
 
@@ -667,6 +715,13 @@ function removeSymlink(p) {
       fs.unlinkSync(p);
       return true;
     }
+    const copies = managedCopies();
+    if (stat.isFile() && copies.has(p)) {
+      fs.unlinkSync(p);
+      copies.delete(p);
+      saveCopies(copies);
+      return true;
+    }
   } catch {}
   return false;
 }

package/scripts/lib/srp-engine.py

@@ -5,7 +5,9 @@ import os
 import sys
 import json
 import glob
+import shutil
 import subprocess
+import tempfile
 
 # Ensure scripts/lib is on the path so sibling modules (link_utils, and the
 # simple_yaml fallback below) resolve regardless of cwd.
@@ -191,6 +193,20 @@ def render_okf_concept(skill_data, okf_wiki_skills):
     with open(okf_file, 'w', encoding='utf-8') as f:
         f.write('\n'.join(lines) + '\n')
 
+def resolve_bash():
+    """Return an explicit path to a usable bash interpreter.
+
+    On Windows, subprocess(['bash', ...]) goes through the Win32
+    CreateProcess search order, which checks C:\\Windows\\System32 before
+    PATH. That finds the WSL launcher stub (System32\\bash.exe) instead of
+    Git Bash and aborts with 'Windows Subsystem for Linux has no installed
+    distributions' on hosts without a WSL distro. shutil.which() honors PATH
+    order, so ask it for an explicit path first; fall back to the bare name
+    for minimal non-Windows environments where nothing is on PATH.
+    """
+    return os.environ.get("BIGPOWERS_BASH") or shutil.which("bash") or "bash"
+
+
 def dispatch_to_adapter(skill_data, target, repo_root):
     adapter_path = os.path.join(repo_root, "scripts", "adapters", f"{target}.sh")
     if not os.path.isfile(adapter_path):
@@ -199,7 +215,7 @@ def dispatch_to_adapter(skill_data, target, repo_root):
 
     # Pipe JSON to the adapter
     proc = subprocess.Popen(
-        ['bash', adapter_path],
+        [resolve_bash(), adapter_path],
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
@@ -216,6 +232,50 @@ def dispatch_to_adapter(skill_data, target, repo_root):
         print(f"Error: adapter {target} failed with exit code {proc.returncode}", file=sys.stderr)
         sys.exit(proc.returncode)
 
+def _write_ir_stream(records):
+    fd, stream_path = tempfile.mkstemp(prefix="bigpowers-ir-", suffix=".bin")
+    with os.fdopen(fd, "wb") as stream:
+        for data in records:
+            pi_body = rewrite_links_for_pi(data['body'], data['name'])
+            for field in (data['name'], data['description'], data['model'], data['body'], pi_body):
+                stream.write(field.encode("utf-8"))
+                stream.write(b"\x00")
+    return stream_path
+
+
+def render_all(records, adapters, repo_root):
+    """Render every skill through each adapter with one bash process per adapter.
+
+    The previous path spawned one bash (plus three jq) per skill×adapter — about
+    1,539 bash and 4,600 jq processes from a single Python process. On constrained
+    Windows sessions that exhausts process-creation resources, so the run dies
+    with STATUS_DLL_INIT_FAILED (0xC0000142) and then hangs on orphaned children.
+    Writing the IR once and letting a small bash driver source the adapter keeps
+    the same rendering code while dropping to one process per adapter.
+    """
+    if not records:
+        return
+
+    driver = os.path.join(repo_root, "scripts", "lib", "adapter-render-all.sh")
+    bash = resolve_bash()
+    stream_path = _write_ir_stream(records)
+    try:
+        for adapter in adapters:
+            adapter_path = os.path.join(repo_root, "scripts", "adapters", f"{adapter}.sh")
+            if not os.path.isfile(adapter_path):
+                print(f"Error: adapter not found: {adapter_path}", file=sys.stderr)
+                sys.exit(1)
+            proc = subprocess.run([bash, driver, adapter_path, stream_path])
+            if proc.returncode != 0:
+                print(f"Error: adapter {adapter} failed with exit code {proc.returncode}", file=sys.stderr)
+                sys.exit(1)
+    finally:
+        try:
+            os.unlink(stream_path)
+        except OSError:
+            pass
+
+
 def main():
     repo_root = resolve_repo_root()
 
@@ -226,19 +286,17 @@ def main():
 
         okf_wiki_skills = os.environ.get("OKF_WIKI_SKILLS", os.path.join(repo_root, "specs", "skills-wiki", "skills"))
 
+        records = []
         for skill_md in skills:
             skill_data = parse_skill(skill_md)
             if not skill_data['name']:
                 continue
+            records.append(skill_data)
 
-            for adapter in adapters:
-                data = skill_data
-                if adapter == "pi":
-                    data = dict(skill_data)
-                    data["body_pi_skill"] = rewrite_links_for_pi(skill_data['body'], skill_data['name'])
-                dispatch_to_adapter(data, adapter, repo_root)
+        render_all(records, adapters, repo_root)
 
-            if okf_mode:
+        if okf_mode:
+            for skill_data in records:
                 render_okf_concept(skill_data, okf_wiki_skills)
         return
 

package/scripts/regenerate-lockfile.sh

@@ -3,6 +3,7 @@
 # regenerate-lockfile.sh — Scan all SKILL.md files and regenerate skills-lock.json
 set -euo pipefail
 source "$(dirname "${BASH_SOURCE[0]}")/lib/skill-common.sh"
+resolve_repo_root
 LOCKFILE="$REPO_ROOT/skills-lock.json"
 records=()
 while IFS= read -r skill_dir; do
@@ -12,7 +13,7 @@ while IFS= read -r skill_dir; do
   description="$_PF_DESCRIPTION"
   if command -v sha256sum &>/dev/null; then sha256=$(sha256sum "$skill_md" | cut -c1-16)
   else sha256=$(shasum -a 256 "$skill_md" | cut -c1-16); fi
-  relpath="${skill_dir#$REPO_ROOT/}SKILL.md"
+  relpath="${skill_dir#$REPO_ROOT/}/SKILL.md"
   records+=("$(jq -n --arg name "$name" --arg desc "$description" --arg sha "$sha256" --arg path "$relpath" \
     '{($name): {description: $desc, sha256: $sha, path: $path}}')")
 done < <(iterate_skills)

package/scripts/test-install-helpers.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 // story: e60s01
+// story: #134
 // Regression selftest for scripts/lib/install-helpers.js (Wave 0 closeout).
 'use strict';
 
@@ -12,9 +13,25 @@ const { mkdtempSync, rmSync } = fs;
 const ROOT = path.resolve(__dirname, '..');
 const tmpHome = mkdtempSync(path.join(os.tmpdir(), 'bp-install-helpers-'));
 process.env.HOME = tmpHome;
+process.env.USERPROFILE = tmpHome; // os.homedir() prefers USERPROFILE on Windows
 
 const { installGlobal, linkHook } = require('../scripts/lib/install-helpers.js');
 
+const isWindows = process.platform === 'win32';
+
+// Directories become junctions on Windows, which lstat reports as symlinks.
+// Files cannot be symlinked without Developer Mode, so createLink copies them;
+// accept either shape and prove a copy matches the source byte-for-byte.
+function assertLinkedFile(dst, src, msg) {
+  const st = fs.lstatSync(dst);
+  if (st.isSymbolicLink()) {
+    assert.strictEqual(fs.readlinkSync(dst), src, msg);
+    return;
+  }
+  assert.ok(isWindows && st.isFile(), `${msg} (expected a symlink, or a Windows copy)`);
+  assert.strictEqual(fs.readFileSync(dst, 'utf8'), fs.readFileSync(src, 'utf8'), msg);
+}
+
 try {
   const hookSrc = path.join(ROOT, 'skills', 'guard-git', 'scripts', 'block-dangerous-git.sh');
   assert.ok(fs.existsSync(hookSrc), `Claude guard-git hook source must exist: ${hookSrc}`);
@@ -40,8 +57,7 @@ try {
   installGlobal({ id: 'claude', name: 'Claude Code' }, ROOT);
 
   const linked = path.join(tmpHome, '.claude', 'hooks', 'block-dangerous-git.sh');
-  assert.ok(fs.lstatSync(linked).isSymbolicLink(), 'block-dangerous-git.sh must be symlinked');
-  assert.strictEqual(fs.readlinkSync(linked), hookSrc, 'symlink must point at skills/guard-git path');
+  assertLinkedFile(linked, hookSrc, 'block-dangerous-git.sh must link to skills/guard-git');
 
   const libLinked = path.join(tmpHome, '.claude', 'hooks', 'lib');
   const libSrc = path.join(ROOT, 'skills', 'guard-git', 'scripts', 'lib');
@@ -53,8 +69,29 @@ try {
   );
 
   const rtkLinked = path.join(tmpHome, '.claude', 'hooks', 'rtk-rewrite.sh');
-  assert.ok(fs.lstatSync(rtkLinked).isSymbolicLink(), 'rtk-rewrite.sh must be symlinked');
-  assert.strictEqual(fs.readlinkSync(rtkLinked), rtkSrc, 'rtk-rewrite symlink must point at scripts/hooks source');
+  assertLinkedFile(rtkLinked, rtkSrc, 'rtk-rewrite.sh must link to scripts/hooks source');
+
+  if (isWindows) {
+    // Windows EPERM regression: without Developer Mode the hooks above are
+    // copies. A reinstall must not trip the "Refusing to replace" guard, and
+    // uninstall must remove the copies and clear them from the manifest.
+    const manifest = path.join(tmpHome, '.bigpowers', 'managed-copies.json');
+    const tracked = () => (fs.existsSync(manifest) ? JSON.parse(fs.readFileSync(manifest, 'utf8')) : []);
+    for (const p of [linked, rtkLinked]) {
+      if (!fs.lstatSync(p).isSymbolicLink()) {
+        assert.ok(tracked().includes(p), `Windows copy must be tracked in the manifest: ${p}`);
+      }
+    }
+    installGlobal({ id: 'claude', name: 'Claude Code' }, ROOT); // idempotent reinstall
+    uninstallTool('claude', ROOT);
+    assert.ok(!fs.existsSync(linked), 'uninstall must remove the block-dangerous-git hook');
+    assert.ok(!fs.existsSync(rtkLinked), 'uninstall must remove the rtk-rewrite hook');
+    assert.deepStrictEqual(
+      tracked().filter((p) => p === linked || p === rtkLinked),
+      [],
+      'uninstall must clear removed copies from the manifest'
+    );
+  }
 
   installGlobal({ id: 'pi', name: 'pi' }, ROOT);
   const piSkill = path.join(tmpHome, '.pi', 'agent', 'skills');
@@ -173,9 +210,10 @@ try {
 
     installLocal({ id: 'codex', name: 'Codex' }, ROOT);
     const localCodexAgents = path.join(tmpCwd, '.codex', 'AGENTS.md');
-    assert.ok(fs.lstatSync(localCodexAgents).isSymbolicLink(), 'local codex install must symlink AGENTS.md');
+    assertLinkedFile(localCodexAgents, path.join(ROOT, 'templates', 'codex', 'AGENTS.md'),
+      'local codex install must link AGENTS.md');
     uninstallTool('codex', ROOT);
-    assert.ok(!fs.existsSync(localCodexAgents), 'uninstallTool(codex) must remove LOCAL AGENTS.md symlink');
+    assert.ok(!fs.existsSync(localCodexAgents), 'uninstallTool(codex) must remove LOCAL AGENTS.md');
   } finally {
     process.chdir(savedCwd);
     rmSync(tmpCwd, { recursive: true, force: true });
@@ -353,8 +391,12 @@ try {
   // package root (e.g. <ROOT>-evil) as managed — needs a path-separator boundary.
   {
     const dst = path.join(tmpHome, 'prefix-boundary-hook.sh');
-    fs.symlinkSync(path.join(`${ROOT}-evil`, 'x.sh'), dst); // dangling foreign link
-      assert.throws(
+    if (isWindows) {
+      fs.writeFileSync(dst, 'foreign\n'); // Windows cannot make this link unprivileged
+    } else {
+      fs.symlinkSync(path.join(`${ROOT}-evil`, 'x.sh'), dst); // dangling foreign link
+    }
+    assert.throws(
         () => linkHook(rtkSrc, dst),
         /Refusing to replace/,
         'managed-symlink check must require a path-separator boundary (prefix sibling is NOT managed)'