@monte3l/groundwork 1.0.0-rc.2 → 1.0.0-rc.4

package/templates/packs/worktrees/files/.claude/hooks/repair-core-bare.mjs

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+/**
+ * SessionStart + PostToolUse: resets `core.bare = true` back to `false` in a
+ * NORMAL repository's shared `.git/config`.
+ *
+ * Why this exists: Claude Code's `EnterWorktree`/`ExitWorktree` tools are
+ * documented to write `core.bare = true` into the shared config of a
+ * non-bare repo and never restore it (anthropics/claude-code#58345, #69802,
+ * both closed "not planned"). Git applies a shared `core.bare` to the MAIN
+ * worktree only (git-worktree's CONFIGURATION FILE section), so linked
+ * worktrees keep working while the root fails every command with "this
+ * operation must be run in a work tree" -- and `git worktree list` prints
+ * "(bare)" for it. Nothing in Git itself sets the key on a repo created
+ * without `--bare`, and no hook fires on a config write, so this checks at
+ * the moments it is known to happen (a session starting, a worktree tool
+ * returning) and repairs it.
+ *
+ * Reads files only -- no `git` subprocess, so it is cheap enough to run on
+ * every matching tool call. It only acts on a repository that is provably
+ * NOT bare: the common git dir must be named exactly `.git` AND contain an
+ * `index`. The name alone is not enough -- a bare clone stored in a
+ * directory called `.git` (`git clone --bare <url> proj/.git`, a common
+ * worktree layout) passes it, and flipping that one would leave `proj/` a
+ * phantom main worktree with an empty tree. A bare repo never has a
+ * common-dir `index` (linked worktrees keep theirs under `worktrees/<name>/`),
+ * while a normal repo has one after its first checkout or commit; the
+ * trade-off is that a brand-new repo with no checkout yet is left alone.
+ * Only the `bare` key of the `[core]` section is edited, byte-for-byte
+ * otherwise, and only when it reads literally `true`. The write follows
+ * git's own protocol (`config.lock` created exclusively, then renamed, the
+ * original file mode kept), so it can't clobber a concurrent `git config`; a
+ * freshly held lock is skipped quietly and retried on the next trigger, but
+ * one older than a minute is a leftover from a crashed git, which would
+ * otherwise block the repair forever, so it is reported (never deleted: the
+ * hook can't know no git is running).
+ *
+ * Always exits 0 -- advisory infrastructure, never a gate. Stderr is not
+ * shown on exit 0, so a repair that was attempted and FAILED is reported on
+ * stdout as `systemMessage` + `additionalContext` instead, with the manual
+ * fix.
+ */
+import process from "node:process";
+import path from "node:path";
+import {
+  chmodSync,
+  closeSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeSync,
+} from "node:fs";
+import { fileURLToPath } from "node:url";
+
+/**
+ * The filesystem calls of the WRITE phase (everything after `core.bare =
+ * true` is confirmed). `repairCoreBare` takes an optional partial override
+ * of these as a test seam, so a failure at an exact step -- a `statSync`
+ * that throws while another process holds the lock, a `renameSync` that
+ * fails after this run created its own -- can be injected deterministically
+ * on every OS instead of engineered with permissions. Production callers
+ * never pass one.
+ */
+const realFs = {
+  chmodSync,
+  closeSync,
+  openSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeSync,
+};
+
+/** A `config.lock` older than this is treated as left behind by a crashed git. */
+const STALE_LOCK_MS = 60_000;
+
+/**
+ * Walks up from `cwd` to the first `.git` and resolves the COMMON git dir:
+ * the `.git` directory itself, or, for a linked worktree (a `.git` FILE
+ * reading `gitdir: <path>`), the directory named by that git dir's
+ * `commondir` file. Returns "" when none can be resolved. A submodule's
+ * `.git` file has no `commondir`, so it resolves to its own git dir, whose
+ * name isn't `.git` -- left alone on purpose.
+ *
+ * @param {string} cwd
+ * @returns {string}
+ */
+function findCommonDir(cwd) {
+  let dir = path.resolve(cwd);
+  for (;;) {
+    const dotGit = path.join(dir, ".git");
+    const stat = statSync(dotGit, { throwIfNoEntry: false });
+    if (stat !== undefined) {
+      if (stat.isDirectory()) return dotGit;
+      if (!stat.isFile()) return "";
+      const match = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, "utf8"));
+      if (match === null) return "";
+      const gitDir = path.resolve(dir, match[1].trim());
+      const commonFile = path.join(gitDir, "commondir");
+      if (statSync(commonFile, { throwIfNoEntry: false }) === undefined) {
+        return gitDir;
+      }
+      return path.resolve(gitDir, readFileSync(commonFile, "utf8").trim());
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return "";
+    dir = parent;
+  }
+}
+
+/**
+ * Rewrites a `bare = true` line inside the `[core]` section to `bare =
+ * false`, leaving every other byte alone. Returns the new text, or `null`
+ * when there was nothing to change. Only the literal `true` is recognised
+ * (git also accepts `yes`/`on`/`1`; Claude Code writes `true`).
+ *
+ * @param {string} text
+ * @returns {string | null}
+ */
+function resetCoreBare(text) {
+  const lines = text.split("\n");
+  let inCore = false;
+  let changed = false;
+  const out = lines.map((line) => {
+    const section = /^\s*\[([^\]]*)\]/.exec(line);
+    if (section !== null) inCore = /^core$/i.test(section[1].trim());
+    if (!inCore) return line;
+    const bare = /^(\s*bare\s*=\s*)true(\s*(?:[#;].*)?\r?)$/i.exec(line);
+    if (bare === null) return line;
+    changed = true;
+    return `${bare[1]}false${bare[2]}`;
+  });
+  return changed ? out.join("\n") : null;
+}
+
+/**
+ * Quotes `value` for a POSIX shell only when it needs it, so the manual-fix
+ * commands in a message can be pasted as-is even from a path with spaces.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function shellQuote(value) {
+  return /^[\w@%+=:,./-]+$/.test(value)
+    ? value
+    : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+/** @param {unknown} cause */
+function firstLine(cause) {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  return message.split("\n")[0];
+}
+
+/**
+ * Resets `core.bare = true` to `false` in the shared config of the NORMAL
+ * repository containing `cwd`, if it is set. Never throws. `error` is only
+ * present when a repair was needed and could not be completed, so the repo
+ * is still broken.
+ *
+ * @param {string} cwd
+ * @param {Partial<typeof realFs>} [io] Test seam: overrides for the write-phase fs calls.
+ * @returns {{ repaired: boolean; configPath: string; error?: string; staleLock?: string }}
+ */
+export function repairCoreBare(cwd, io = {}) {
+  const fsx = { ...realFs, ...io };
+  let configPath = "";
+  let updated;
+  try {
+    const commonDir = findCommonDir(cwd);
+    if (
+      commonDir === "" ||
+      path.basename(commonDir) !== ".git" ||
+      statSync(path.join(commonDir, "index"), { throwIfNoEntry: false }) ===
+        undefined
+    ) {
+      return { repaired: false, configPath: "" };
+    }
+    configPath = path.join(commonDir, "config");
+    updated = resetCoreBare(readFileSync(configPath, "utf8"));
+  } catch (cause) {
+    // Locating or reading the config failed before we knew anything was
+    // wrong: a missing file just means "not a repo we can repair".
+    if (cause?.code === "ENOENT" || cause?.code === "ENOTDIR") {
+      return { repaired: false, configPath };
+    }
+    process.stderr.write(
+      `repair-core-bare: could not check core.bare (${firstLine(cause)}).\n`,
+    );
+    return { repaired: false, configPath };
+  }
+  if (updated === null) return { repaired: false, configPath };
+
+  // From here on `core.bare = true` is confirmed, so a failure leaves the
+  // repository broken and must be reported, never swallowed.
+  const lock = `${configPath}.lock`;
+  let fd;
+  // Only a lock THIS run created may be removed on failure: otherwise a
+  // failed stat/open would delete the `config.lock` of a live git process.
+  let ownsLock = false;
+  try {
+    const mode = fsx.statSync(configPath).mode & 0o777;
+    try {
+      fd = fsx.openSync(lock, "wx", mode);
+    } catch (cause) {
+      if (cause?.code === "EEXIST") {
+        // Usually git (or another hook run) holds the lock right now: retry
+        // on the next trigger rather than racing it. An old one is a crashed
+        // git's leftover that would block every future repair, so say so.
+        const held = fsx.statSync(lock, { throwIfNoEntry: false });
+        if (held === undefined || Date.now() - held.mtimeMs < STALE_LOCK_MS) {
+          return { repaired: false, configPath };
+        }
+        const minutes = Math.floor((Date.now() - held.mtimeMs) / 60_000);
+        return {
+          repaired: false,
+          configPath,
+          error: `${lock} has been held for ${minutes} min, so no git process is likely still using it`,
+          staleLock: lock,
+        };
+      }
+      throw cause;
+    }
+    ownsLock = true;
+    fsx.writeSync(fd, updated);
+    fsx.closeSync(fd);
+    fd = undefined;
+    fsx.chmodSync(lock, mode);
+    fsx.renameSync(lock, configPath);
+    return { repaired: true, configPath };
+  } catch (cause) {
+    if (fd !== undefined) {
+      try {
+        fsx.closeSync(fd);
+      } catch {
+        // The original failure below is the one worth reporting.
+      }
+    }
+    if (ownsLock) {
+      try {
+        fsx.rmSync(lock, { force: true });
+      } catch (cleanup) {
+        process.stderr.write(
+          `repair-core-bare: left ${lock} behind (${firstLine(cleanup)}).\n`,
+        );
+      }
+    }
+    return { repaired: false, configPath, error: firstLine(cause) };
+  }
+}
+
+function isEntryPoint() {
+  try {
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reads the hook payload from stdin. Resolves to "" for a TTY, a stream
+ * error, or no EOF within `timeoutMs`, so the hook can never hang a tool
+ * call or exit non-zero over its own input.
+ *
+ * @param {number} timeoutMs
+ * @returns {Promise<string>}
+ */
+function readStdin(timeoutMs) {
+  if (process.stdin.isTTY) return Promise.resolve("");
+  return new Promise((resolve) => {
+    const chunks = [];
+    const done = () => {
+      clearTimeout(timer);
+      process.stdin.removeAllListeners();
+      process.stdin.pause();
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    };
+    const timer = setTimeout(done, timeoutMs);
+    timer.unref();
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", done);
+    process.stdin.on("error", done);
+  });
+}
+
+if (isEntryPoint()) {
+  let input = {};
+  try {
+    input = JSON.parse(await readStdin(2000));
+  } catch {
+    // No or invalid payload: fall back to the process cwd.
+  }
+  const cwd =
+    typeof input?.cwd === "string" && input.cwd !== ""
+      ? input.cwd
+      : process.cwd();
+  const { repaired, configPath, error, staleLock } = repairCoreBare(cwd);
+  const eventName =
+    typeof input?.hook_event_name === "string" && input.hook_event_name !== ""
+      ? input.hook_event_name
+      : "SessionStart";
+  if (repaired) {
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: eventName,
+          additionalContext:
+            `repair-core-bare: core.bare was true in ${configPath} (a known ` +
+            "EnterWorktree/ExitWorktree side effect, anthropics/claude-code#58345) " +
+            "and has been reset to false.",
+        },
+      }),
+    );
+  } else if (error !== undefined) {
+    const reset = `\`git config --file ${shellQuote(configPath)} core.bare false\``;
+    const fix =
+      staleLock === undefined
+        ? `run ${reset}`
+        : `first \`rm ${shellQuote(staleLock)}\` (only if no git process is running), then run ${reset}`;
+    process.stdout.write(
+      JSON.stringify({
+        systemMessage: `repair-core-bare: core.bare is still true in ${configPath} (${error}); ${fix}.`,
+        hookSpecificOutput: {
+          hookEventName: eventName,
+          additionalContext:
+            `repair-core-bare FAILED to reset core.bare in ${configPath} (${error}). ` +
+            `git commands in the main checkout will fail until it is fixed: ${fix}.`,
+        },
+      }),
+    );
+  }
+  process.exit(0);
+}

package/templates/packs/worktrees/files/.claude/skills/working-in-worktrees/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: working-in-worktrees
+description: >-
+  Creates, lists, syncs, and safely tears down an isolated git worktree per
+  unit of work -- required once the `worktrees` pack is installed, since
+  `guard-worktree-only.mjs` blocks every src/tests write outside one, on any
+  branch. Use for /working-in-worktrees, "start a worktree", "work in a
+  worktree", "what worktrees are open", "sync this worktree with main", or
+  "finish this worktree" -- and from `starting-work`'s own branch step, which
+  hands off here automatically when this skill is installed.
+---
+
+# working-in-worktrees
+
+Once this pack is installed, `guard-worktree-only.mjs` blocks a src/tests
+write outside a linked worktree under `.claude/worktrees/` -- on any branch,
+for any caller. `starting-work`'s plain `git switch -c` is no longer enough
+by itself: it puts you on the right branch, but not inside a worktree the
+guard will accept. This skill is the missing piece.
+
+Hub-only. Never dispatched as a spoke's own tool.
+
+## Modes
+
+### start `<slug>`
+
+1. `git fetch origin` (or the project's own default-branch equivalent).
+2. Create the worktree with a plain `git worktree add .claude/worktrees/<slug> -b feat/<slug> origin/main`
+   (or `fix/<slug>` for a bug fix) -- **not** `EnterWorktree(name: <slug>)`,
+   which names the branch `worktree-<slug>` instead. Create it with the
+   final branch name up front, so no rename is ever needed.
+3. `EnterWorktree(path: .claude/worktrees/<slug>)` to switch the session's
+   working directory into it (this is the documented way to adopt session
+   tracking for a worktree you created yourself -- see the tool's own "on
+   first entry from the launch directory, the path must appear in
+   `git worktree list`" note).
+   **Known side effect:** Claude Code's `EnterWorktree`/`ExitWorktree` have
+   been reported to leave `core.bare = true` in the main repository's shared
+   `.git/config` (anthropics/claude-code#58345, #69802, both closed "not
+   planned"), which breaks `git status` in the main checkout while worktrees
+   keep working. This pack's `repair-core-bare.mjs` hook resets it after
+   either tool runs; if `git status` ever says "this operation must be run in
+   a work tree", the manual fix is `git config --local core.bare false`. Prefer
+   the `path:` and `keep` forms used in this skill; `EnterWorktree(name: ...)` and
+   `ExitWorktree(remove)` are the calls the upstream reports tie to it.
+4. Copy any of `.env`, `.env.local`, `.env.*.local` that exist in the main
+   checkout into the new worktree (the same list as `.worktreeinclude`). `.worktreeinclude` (this pack ships one) only fires for a
+   worktree Claude Code itself creates -- since this skill creates the
+   directory with plain `git worktree add`, that processing never runs here,
+   so the copy is done by hand.
+5. `pnpm install --frozen-lockfile --prefer-offline` inside the worktree.
+   `ensure-worktree-deps.mjs`'s own `SessionStart` hook is a backstop for
+   `claude --worktree`/a resumed session, not a substitute for this step --
+   it does not fire on a mid-session `EnterWorktree`, which is what steps 2-3
+   just did.
+
+### status
+
+`git worktree list --porcelain`, then for each entry under
+`.claude/worktrees/`: ahead/behind counts against its upstream
+(`git rev-list --left-right --count <branch>...origin/<branch>`), dirty
+state (`git -C <worktree> status --porcelain`), and whether it's locked
+(a `locked` line in the porcelain output).
+
+### sync `<slug>`
+
+Inside `.claude/worktrees/<slug>`: `git fetch origin` then
+`git rebase origin/main`. Report a conflict rather than resolving it
+silently -- the person driving decides how. If this branch was already
+pushed and has an open PR, a rebase means the next push needs
+`--force-with-lease`, never a bare `--force` (CLAUDE.md's "never
+`git push --force`") -- confirm with the user before that push, the same
+as `creating-prs`'s own resync step does.
+
+### finish `<slug>`
+
+The identical safe sequence `finishing-work`'s own worktree-aware steps
+use, applied here directly (this skill's `finish` mode and that skill's
+Step 2/4 exist for the same reason and must never drift apart):
+
+1. Confirm the PR for this branch actually merged (`gh pr view --json
+state,mergedAt`) -- never remove a worktree whose work never landed
+   without asking first. Then `git fetch origin` and run
+   `git log feat/<slug> ^origin/main --oneline`: a squash merge never makes
+   the branch's commits ancestors of `main`, so a non-empty result is either
+   the squashed originals (expected) or a commit added after the PR merged
+   that is about to be abandoned -- compare it with the merged PR's commits
+   and ask before going further, exactly as `finishing-work` Step 4 does.
+2. If the session is still inside this worktree, `ExitWorktree(keep)` to
+   return to the main checkout.
+3. `git -C .claude/worktrees/<slug> status --porcelain` must be empty --
+   investigate first if not. This only sees tracked/untracked-but-not-
+   ignored changes; it says nothing about a gitignored file (a `.env`, an
+   in-progress scratch file) that exists ONLY in this worktree, so **confirm
+   with the user before removing**, not just when `status --porcelain` is
+   non-empty.
+4. `git worktree unlock .claude/worktrees/<slug>` -- only if locked, and
+   only after confirming with the user.
+5. `git worktree remove .claude/worktrees/<slug>` -- confirmed per step 3.
+6. `git worktree prune`.
+7. `git branch -d feat/<slug>` (or `-D` only with the user's go-ahead, per
+   the same squash-merge reasoning `finishing-work` documents).
+
+### fan-out
+
+For genuinely independent units of work only -- not the sequential TDD
+pipeline below. Dispatch each independent unit to its own subagent with
+`isolation: "worktree"` in the Agent call; Claude Code creates and tracks
+that worktree automatically (base ref governed by the `worktree.baseRef`
+setting, default `"fresh"` = the remote default branch). Each unit's result
+becomes its own PR -- a fanned-out worktree is not a place to accumulate one
+combined change across several unrelated units.
+
+`ensure-worktree-deps.mjs` only runs at `SessionStart`, so a worktree created
+this way has **no `node_modules`** when its subagent starts: the first
+`post-edit-verify` run would stop with a "no node_modules" error. Put the
+install in every fan-out brief as its first step (`pnpm install
+--frozen-lockfile --prefer-offline` inside that worktree) -- and dispatch a
+writer spoke for it, since a read-only spoke cannot run it when the
+`harness-extras` pack's `guard-readonly-bash` is installed.
+
+## Policy
+
+- **One worktree per unit of work.** Don't reuse a worktree across unrelated
+  tasks, and don't split one task across worktrees.
+- **The TDD pipeline runs sequentially inside the SAME worktree, with no
+  `isolation` on any spoke.** `test-author` writes the failing tests,
+  `code-implementer` makes them pass, and the review spokes read the diff --
+  all inside the one worktree `start` created. A spoke dispatched from a hub
+  session that is itself inside a worktree inherits that same isolation
+  (Claude Code's own enforcement explicitly covers "every subagent Claude
+  spawns from the isolated session"), so this is safe by construction: a
+  spoke given its own separate `isolation: "worktree"` here would branch
+  from `baseRef` and never see the RED tests `test-author` just wrote.
+- **Per-call `isolation: "worktree"` is only for the fan-out case above** --
+  independent units with no shared in-progress state to see.
+- **Never `git stash` inside a worktree.** The stash stack is shared across
+  every worktree of a repository; stashing here can silently pop into (or
+  clobber) unrelated work in the main checkout or another worktree.

package/templates/packs/worktrees/files/.worktreeinclude

@@ -0,0 +1,11 @@
+# Copies gitignored local-secrets files into every worktree Claude Code
+# creates itself (`claude --worktree`, `isolation: "worktree"`,
+# `EnterWorktree` without a `path`) -- gitignore syntax, per
+# code.claude.com/docs/en/worktrees. Only ever copies a file that is ALSO
+# gitignored, so nothing tracked is ever duplicated. This does NOT fire for
+# a worktree the `working-in-worktrees` skill's `start` mode creates with a
+# plain `git worktree add` -- that mode copies these same files by hand; see
+# its own step for why.
+.env
+.env.local
+.env.*.local

package/templates/packs/worktrees/pack.json

@@ -0,0 +1,64 @@
+{
+  "schemaVersion": 1,
+  "name": "worktrees",
+  "description": "Enforces that all development happens inside isolated git worktrees rather than the main checkout: a skill that creates, lists, syncs, and safely tears down a worktree per unit of work; a hook that installs dependencies into a freshly created worktree automatically; a hook that resets the `core.bare = true` Claude Code's worktree tools leave in a normal repo's shared config; and a guard that blocks a src/tests write outside a worktree the same way guard-branch-isolation.mjs blocks one on main.",
+  "modes": ["fresh", "adopt"],
+  "budget": {
+    "agents": 0,
+    "skills": 1,
+    "hooks": 3,
+    "workflows": 0,
+    "scripts": 0
+  },
+  "requires": {
+    "paths": ["bin/lib/protected-paths.mjs"]
+  },
+  "wiring": {
+    "settings": {
+      "SessionStart": [
+        {
+          "matcher": "startup|resume",
+          "hooks": [
+            {
+              "type": "command",
+              "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/ensure-worktree-deps.mjs\"",
+              "timeout": 300
+            },
+            {
+              "type": "command",
+              "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/repair-core-bare.mjs\"",
+              "timeout": 30
+            }
+          ]
+        }
+      ],
+      "PreToolUse": [
+        {
+          "matcher": "Write|Edit",
+          "hooks": [
+            {
+              "type": "command",
+              "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/guard-worktree-only.mjs\"",
+              "timeout": 30
+            }
+          ]
+        }
+      ],
+      "PostToolUse": [
+        {
+          "matcher": "EnterWorktree|ExitWorktree|Agent",
+          "hooks": [
+            {
+              "type": "command",
+              "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/repair-core-bare.mjs\"",
+              "timeout": 30
+            }
+          ]
+        }
+      ]
+    },
+    "packageScripts": {},
+    "verifySteps": []
+  },
+  "adoptNotes": "ensure-worktree-deps.mjs runs `pnpm install --frozen-lockfile --prefer-offline` automatically the first time a session starts inside a freshly created worktree with no node_modules yet -- this runs every dependency's lifecycle scripts the same way any `pnpm install` does, limited only by whatever `allowBuilds`/`onlyBuiltDependencies` policy the project's own pnpm config already sets (see typescript-guidance's pnpm supply-chain coverage if none is set). If the project sets `worktree.symlinkDirectories: [\"node_modules\"]` in .claude/settings.json, the hook detects the symlink and skips -- installing there would mutate the main checkout's own node_modules through the symlink. guard-worktree-only.mjs blocks every src/tests write outside a linked worktree under .claude/worktrees/, on any branch, for any caller (hub or writer spoke) -- this is stricter than guard-branch-isolation.mjs (which only blocks on main) and guard-hub-src-writes.mjs (which only blocks the hub); confirm the team actually wants every change routed through a worktree before installing this pack, since it changes the day-to-day workflow, not just adds a nicety. `.claude/worktrees/` should already be gitignored (the baseline's own .gitignore covers this); if adopting into a project with a hand-rolled .gitignore that doesn't, add it before installing. repair-core-bare.mjs resets `core.bare = true` to `false` in a non-bare repo's shared .git/config at session start and after EnterWorktree/ExitWorktree/Agent calls: Claude Code's worktree tools are documented to leave it set (anthropics/claude-code#58345, #69802), which breaks `git status` in the main checkout. It only acts on a provably non-bare repository (its common git dir is named .git and contains an index), never on a genuine bare repo -- including a bare clone stored in a directory called .git -- and reports a failed repair on stdout rather than silently."
+}

package/templates/packs/statusline/pack.json

@@ -1,31 +0,0 @@
-{
-  "schemaVersion": 1,
-  "name": "statusline",
-  "description": "A five-row Claude Code statusLine -- session, model, context, quota, work -- plus a per-subagent row renderer, both width-fit to the real terminal. statusLine is the only documented surface carrying live context-window pressure; no hook event receives token data.",
-  "modes": ["fresh", "adopt"],
-  "budget": {
-    "agents": 0,
-    "skills": 0,
-    "hooks": 3,
-    "workflows": 0,
-    "scripts": 0
-  },
-  "wiring": {
-    "settings": {},
-    "settingsTopLevel": {
-      "statusLine": {
-        "type": "command",
-        "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/statusline.mjs\"",
-        "refreshInterval": 30,
-        "padding": 1
-      },
-      "subagentStatusLine": {
-        "type": "command",
-        "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/subagent-statusline.mjs\""
-      }
-    },
-    "packageScripts": {},
-    "verifySteps": []
-  },
-  "adoptNotes": "The three scripts read only the stdin payload, .git/HEAD (via node:fs, never a git subprocess) and process.availableMemory()/os.totalmem(), so they install anywhere a .claude/ directory exists -- no dependency on the baseline's file layout, and no gate to wire. The one real adopt risk is the settings keys: a project that already defines a top-level statusLine or subagentStatusLine collides, and its existing value must be shown and decided on, never overwritten. A .claude/settings.local.json or the user's own ~/.claude/settings.json statusLine also shadows the project one -- check both before concluding the pack is wired. rate_limits.spend_limit and prompt_cache need Claude Code v2.1.251+, and the per-subagent model/contextWindowSize/effort fields need v2.1.205+/v2.1.214+; each renders only when present, so an older Claude Code degrades to fewer segments rather than breaking. The scripts behave the same on macOS and Linux; the memory segment uses process.availableMemory() (Node 22+), and on macOS with an older Node it is hidden rather than shown from os.freemem(), which undercounts there. Below roughly 40 columns the layout drops segments by priority rather than wrapping."
-}