forge-orkes 0.62.0 → 0.63.0

package/experimental/m10/source/skills/orchestrating/SKILL.md

@@ -0,0 +1,223 @@
+---
+name: orchestrating
+description: "[Experimental — M10] Optional backend for Forge stream isolation. Bootstrap worktrees, coordinate merge queue, and optionally use MCP file claims. Prefer Chief/Streams as the user-facing orchestration model."
+---
+
+# Orchestrating
+
+Multi-agent session lifecycle substrate. Worktree isolation + merge queue remain
+useful backend mechanics for Forge Streams. MCP/SQLite file claims are optional
+and experimental defense-in-depth, not the primary coordination model.
+
+## M16 Positioning
+
+Chief/Streams is the preferred user-facing orchestration model. The Project
+Chief decides when a stream needs M10 mechanics such as worktree isolation,
+branch anchoring, merge queue discipline, or claim checks. Users should normally
+ask to start, pause, delegate, conflict-check, merge, or close streams; they
+should not have to invoke M10 directly.
+
+M10 still matters when concurrent streams need hard workspace separation or a
+controlled merge path. It is a backend/substrate, not the project manager.
+
+## When to use
+
+- The Project Chief selects M10 for a stream that needs worktree isolation,
+  merge-queue support, or optional file-claim checks.
+- User explicitly invokes multi-agent mode (`/forge` argument selects multi-agent, or direct skill invocation).
+- Legacy installs may route Full tier work through this skill when
+  `orchestration.auto` remains enabled.
+
+Skip on Quick tier, single-phase work, or when bootstrap checks fail.
+
+## Enforcement scope — what claims actually protect
+
+Claim coordination (`forge_claim_files` + the PreToolUse gate) works for **one** mode only: a **single parent session** operating across a Forge-managed sibling worktree dir (default `../<repo>-worktrees/{anchor}`, configurable via `orchestration.worktree_root`), where main's hooks + `.session-id` apply. **It does NOT reach `Agent isolation:"worktree"` sub-agents** — those run in `.claude/worktrees/agent-*` with no hook config (`.claude` is gitignored), so they fire no SessionStart, claim under nothing, and their edits are **not gated**. For within-milestone fan-out, **worktree isolation + disjoint files behind a frozen contract is the safety — not claims.** Never assume a fan-out sub-agent is claim-protected; it is not. (See ADR-007.)
+
+## Step 1: Bootstrap
+
+Run all checks in `bootstrap-checks.md`:
+
+1. Git version ≥ 2.48
+2. LFS version ≥ 3.6 (skip if not installed)
+3. No divergent submodules — clean pinned submodules pass (auto-inited per worktree in Step 2); refuse only on `-`/`+`/`U` entries (see `bootstrap-checks.md` "Submodule handling")
+4. `core.hooksPath` empty or resolves inside worktree
+5. `git hook run pre-commit` smoke test in fresh worktree
+6. **Enforcement canary (advisory)** — `bash .claude/hooks/forge-claim-check-doctor.sh` reports `gate enforces`. On `GATE IS INERT`, warn loudly that claims provide no protection this session (worktree isolation still applies); do **not** refuse on this one — it never blocks, only surfaces.
+
+**Any check 1–5 fails** → log reason, write `lifecycle.worktree_mode: refused` + `lifecycle.refused_reason` into active milestone state, emit fallback message (see `bootstrap-checks.md`), return to caller. Caller continues single-agent. Check 6 is advisory — it warns, never refuses.
+
+## Step 2: Session ID + worktree
+
+```bash
+session_id=$(uuidgen | cut -c1-8)
+# Anchor the worktree name to the milestone id so the branch is self-describing:
+# the `m-{id}` token lets `forge` resume re-derive the milestone from the branch
+# name alone (its id-token fallback), not only from lifecycle.worktree_branch
+# state — which a moved/redone worktree can leave stale. The uuid suffix keeps the
+# name collision-resistant and unique per session; the `forge/` prefix keeps the GC
+# sweep simple. Milestone ids are dash-free, so `m-{id}` tokenizes cleanly.
+anchor="m-${milestone_id}-${session_id}"
+
+# Worktree root — configurable, repo-scoped by default (ADR-010).
+# Read `orchestration.worktree_root` from .forge/project.yml; if unset, default
+# to a per-repo sibling `../<repo-basename>-worktrees`. Per-repo siblings keep
+# each repo's worktrees in their own dir (no cross-repo mixing when multiple
+# repos share a parent), and resolve deterministically against the repo root
+# rather than the shell cwd. Relative roots resolve against repo root;
+# absolute roots and a leading `~` are honored as-is.
+repo_root=$(git rev-parse --show-toplevel)
+wt_root=$(sed -n '/^orchestration:/,/^[^[:space:]#]/p' "$repo_root/.forge/project.yml" 2>/dev/null \
+          | sed -n 's/^[[:space:]]*worktree_root:[[:space:]]*//p' | tr -d "\"'" | head -1)
+wt_root="${wt_root:-../$(basename "$repo_root")-worktrees}"
+case "$wt_root" in
+  /*)   : ;;                                  # absolute — use as-is
+  "~"*) wt_root="$HOME${wt_root#\~}" ;;       # expand leading ~
+  *)    wt_root="$repo_root/$wt_root" ;;      # relative → resolve against repo root
+esac
+mkdir -p "$wt_root"
+
+git worktree prune
+git worktree add -b forge/${anchor} --lock --reason "forge session m-${milestone_id}" "$wt_root/${anchor}" main
+wt="$wt_root/${anchor}"
+# Submodules don't auto-populate in a new worktree — init them if present. Reuses the
+# superproject's shared .git/modules object store (no re-clone, just a working-tree
+# checkout); ccache absorbs the subsequent rebuild cost across worktrees.
+if [ -n "$(git -C "$wt" submodule status 2>/dev/null)" ]; then
+  ( cd "$wt" && git submodule update --init --recursive )
+fi
+( cd "$wt" && git hook run pre-commit || true )
+```
+
+Verify worktree dir exists, branch locked, and (if applicable) submodule dirs are non-empty. On failure → cleanup partial state, refuse mode.
+
+`anchor` (= `m-{milestone_id}-{session_id}`) names the worktree dir **and** branch from here on; every reference below that used to be `{session_id}` is now `{anchor}`. `session_id` (the bare uuid) is retained only as the collision key + audit id in state.
+
+The **absolute** path Forge resolved (`$wt_root/${anchor}`) is recorded in `lifecycle.worktree_path` (Step 3). Every later operation — Step 4 handback, Step 5 teardown, Step 6 crash-recovery re-attach — uses that recorded path verbatim, never re-deriving it. This decouples in-flight worktrees from the config: changing `orchestration.worktree_root` later (or moving a worktree on disk) does not invalidate them.
+
+## Step 3: State update
+
+Write into `.forge/state/milestone-{id}.yml`:
+
+```yaml
+lifecycle:
+  session_id: "{session_id}"                 # short uuid — collision key + audit id only (not a name, not a claim id)
+  worktree_anchor: "m-{id}-{session_id}"     # milestone-anchored name of the worktree dir + branch
+  claim_session_id: "{claim_session_id}"     # Claude session id — owner of all file claims (see Identity)
+  worktree_path: "{absolute path Forge resolved in Step 2 — $wt_root/m-{id}-{session_id}}"
+  worktree_branch: "forge/m-{id}-{session_id}"
+  worktree_mode: "active"
+  started_at: "{ISO8601}"
+```
+
+Set `current.last_updated` in the milestone file. Do **not** write `state/index.yml` directly — it is a derived registry, regenerated by the `forge` rollup. (The orchestrator owns index.yml; worktree agents never touch it.)
+
+## Step 4: Hand back
+
+Relocate the session into the worktree, then return control to caller (typically `executing`) — instead of only *assuming* the caller is already inside `lifecycle.worktree_path`. Apply the canonical **Native Worktree Entry** contract (identical to the forge ownership-gate option 1):
+
+- **If the `EnterWorktree` tool is available**, call `EnterWorktree({path: {lifecycle.worktree_path}})` to relocate the session into the worktree before returning control, then log `Relocated into worktree {lifecycle.worktree_path} ({lifecycle.worktree_branch})` (independent of any prompt, so the cwd move is visible).
+- **If `EnterWorktree` is unavailable** (older Claude Code CLI, or a non-Claude-Code adapter), fall back to instructing the caller to `cd {path}` (here `cd {lifecycle.worktree_path}`) before continuing — today's implicit assumption stated explicitly.
+- Exit stays `ExitWorktree({action: "keep"})`; teardown remains Step 5 / `git worktree remove` — the native tool never removes the worktree.
+
+All subsequent work runs inside `lifecycle.worktree_path`. Caller honors claim convention.
+
+### Claim convention (executing-skill contract)
+
+State-file ownership: each session writes **only** its own `.forge/state/milestone-{own_id}.yml` and **appends** to `.forge/state/desire-paths/` (new files, never edited). It never writes `state/index.yml` — the registry is regenerated by rollup at teardown. Different milestones = different files, so these writes need no claim and never conflict across worktrees. Same-milestone parallelism is out of scope (one session per milestone — see the concurrent-invocation refusal in Edge Cases).
+
+**Identity (critical — see ADR-007).** File claims are owned by the **Claude session id**, NOT the worktree uuid. The worktree uuid (`session_id` above) only feeds the worktree name (via `anchor`) and serves as the collision/audit key. Read the claim identity from the file the `forge-session-id.sh` SessionStart hook writes:
+
+```bash
+claim_session_id=$(cat "${CLAUDE_PROJECT_DIR:-.}/.forge/.mcp-server/.session-id" 2>/dev/null)
+```
+
+This is the same id the `forge-claim-check.sh` enforcement hook reads from PreToolUse stdin, so a session's own claims are recognized and other sessions' claims block. If the file is missing/empty the hook fail-opens (no enforcement) — surface that rather than proceeding silently in genuine multi-agent work.
+
+Before any `Edit`, `Write`, `MultiEdit`, or `NotebookEdit` on a file outside `.forge/state/milestone-{own_id}.yml`:
+
+1. Call `forge_claim_files` with `{ session_id: claim_session_id, files: [...], ttl_seconds: 900 }`.
+2. On `granted` → proceed with edit.
+3. On `conflict: { holder_session, files: [...] }` → surface holder + files to user. Options:
+   - **wait** → poll `forge_claim_status` until released or TTL expiry.
+   - **skip** → drop the conflicted file from the task scope, continue with rest.
+   - **steal** → only if holder session is provably dead (PreToolUse hook validates). Otherwise refused.
+4. After edit batch → claim auto-extends on continued use; explicit `forge_release_claims` on plan-complete.
+
+PreToolUse hook (installed by plan-03) enforces this — uncaught violations block at hook level, not skill level.
+
+## Step 5: Teardown
+
+Triggered when caller signals work complete OR user requests teardown.
+
+### Step 5.0: Human Verification Gate (hard block — runs first)
+
+Before any merge or worktree removal, read `current.human_verified` from `.forge/state/milestone-{id}.yml`.
+
+- **Present** (`{at, method, ...}`, including a recorded `override`) → gate satisfied, proceed to the merge below.
+- **Absent / null** → **REFUSE teardown.** Code-clean + FF-clean is **not** enough to close a milestone (FORGE.md → Human Verification Gate). Do **not** present teardown as an option, and never offer it as a peer alternative to the outstanding verification. Respond with what's still unverified and offer exactly two paths:
+  1. **Verify now** → run the human verification (device session / visual / e2e walk). Have `verifying` (or this step) record `current.human_verified`, then re-invoke teardown.
+  2. **Record override** → only on an explicit human instruction to close without verifying: write `current.human_verified: {at: "<ISO 8601>", method: "override", override: true, reason}` to the milestone file, surface it, then proceed.
+
+Never merge + remove a worktree while `human_verified` is unset.
+
+```
+forge_queue_commit(branch=forge/m-{id}-{session_id}, base_sha={merge_base})
+```
+
+Branch on response status:
+
+- **`merged`** (response has `new_main_sha`) → **reconcile the working tree first** — `forge_queue_commit` merges *ref-only* (`update-ref`), so the main checkout is now behind HEAD: `git checkout HEAD -- $(git diff --name-only {base_sha} {new_main_sha})` — surgical, merged files only; **never** `git checkout HEAD -- .` (would clobber unrelated WIP) → `forge_release_claims(claim_session_id)` (the Claude session id, not the worktree uuid) → `git worktree remove --force --force "$(yq '.lifecycle.worktree_path' .forge/state/milestone-{id}.yml)"` (double `--force`: Step 2 created the worktree `--lock`ed, and a single `--force` refuses to remove a locked worktree; read the path from state rather than re-deriving it so a moved/non-default worktree still removes cleanly) → `git branch -d forge/m-{id}-{session_id}` → clear `lifecycle.*` (set `worktree_mode: complete`, retain `session_id` for audit) → **State reconcile = Rollup:** regenerate `state/index.yml` from the now-merged `milestone-*.yml` files (`forge` Rollup 1.0) and commit it (`chore(forge): rollup state after teardown — {session_id}`). The merged milestone files are the source of truth; index.yml is never hand-merged.
+- **`conflict`** → invoke `Skill(debugging)` with payload `{ conflicted_files, base_sha, messages, branch }`. Teardown blocks until debugging signals resolution (re-invoke teardown after fix).
+- **`stale_base`** → caller rebases worktree branch onto `current_target_sha` from response, retries `forge_queue_commit`. Max 3 retries → escalate to conflict path.
+
+## Step 6: Crash recovery (next session start)
+
+If no clean teardown happened previously:
+
+1. `git worktree prune` — drops stale admin dirs.
+2. `git branch --list 'forge/*'` — for each branch with no live worktree, prompt user. The branch suffix is the `anchor` (`m-{id}-{session_id}`); the milestone id is the `m-…` token, recoverable from the name alone even if state is stale:
+   - **resume** → re-attach at the path recorded in `lifecycle.worktree_path` (read from `state/milestone-{id}.yml` — the recorded absolute path survives a `worktree_root` config change after the fact). State missing the path → fall back to the current default (`<repo_root>/../<repo-basename>-worktrees/{anchor}`) and warn. `git worktree add <path> forge/{anchor}` and restore lifecycle state.
+   - **delete** → `git branch -D forge/{anchor}`.
+3. MCP server startup handles pidfile takeover + claim TTL expiry independently (see ADR-003).
+
+## Failure modes & operator notes
+
+- **MCP server absent** — bootstrap check 5 (hook smoke) will not detect this. Skill detects on first `forge_claim_files` call: error `MCP_SERVER_UNAVAILABLE` → write `lifecycle.worktree_mode: degraded`, warn user, continue without claim coordination. Hard isolation (worktree) still active; coordination is downgraded to best-effort.
+- **Disk full during worktree add** — `git worktree add` will error. Cleanup any partial `$wt_root/m-{id}-{session_id}/` dir, refuse mode, fall back.
+- **Concurrent orchestrating invocations** — second invocation reads first's `lifecycle.session_id` in state. If present and `worktree_mode: active` → refuse (one orchestration per milestone). Use a separate milestone for parallel orchestrated work.
+- **Worktree path collision** — UUIDv4 short (8 chars) collision negligible at <100 concurrent sessions. If `$wt_root/m-{id}-{session_id}/` already exists → regenerate session_id (the `anchor` recomputes with it), retry up to 3 times.
+- **`worktree_root` changed mid-flight** — Step 3 records the resolved absolute `lifecycle.worktree_path`; teardown + crash-recovery read it from state, never re-derive. Editing `orchestration.worktree_root` in `project.yml` only affects newly created worktrees. Do not relocate live worktrees on disk by hand — `git worktree move` is the supported way; bare `mv` leaves the gitdir pointer stale.
+
+## Example: clean session
+
+```
+user: /forge multi-agent
+forge → orchestrating
+orchestrating: bootstrap OK → session_id=a1b2c3d4 → anchor=m-9-a1b2c3d4 → worktree created at ../<repo>-worktrees/m-9-a1b2c3d4 → state written
+orchestrating → executing (working dir: ../<repo>-worktrees/m-9-a1b2c3d4, branch: forge/m-9-a1b2c3d4)
+executing: claim files → edit → commit (× N tasks)
+executing → verifying (captures current.human_verified on human sign-off) → reviewing (all inside worktree)
+reviewing → orchestrating (teardown)
+orchestrating: Step 5.0 gate — current.human_verified present → forge_queue_commit → merged → release claims → remove worktree → delete branch
+done.
+```
+
+## Example: conflict path
+
+```
+orchestrating: forge_queue_commit → conflict { files: [src/auth.ts] }
+orchestrating → debugging { conflicted_files, base_sha, branch }
+debugging: user resolves → signal resolved
+orchestrating: retry forge_queue_commit → merged → cleanup
+```
+
+## References
+
+- ADR-001 — experimental track / opt-in carve-out
+- ADR-002 — worktrees as isolation substrate
+- ADR-003 — MCP server + per-repo SQLite
+- ADR-004 — merge queue (forge_queue_commit status semantics)
+- ADR-005 — session lifecycle (this skill realizes it)
+- `.forge/research/milestone-10.md` — spike findings
+- `bootstrap-checks.md` — bootstrap check matrix + fallback

package/experimental/m10/source/skills/orchestrating/bootstrap-checks.md

@@ -0,0 +1,70 @@
+# Bootstrap Checks
+
+Run before worktree creation. Any failure → refuse worktree mode, fall back to single-agent.
+
+| Check | Command | Pass criterion | Fail action | Reason |
+|-------|---------|----------------|-------------|--------|
+| Git version | `git --version` | major.minor ≥ 2.48 | refuse worktree mode | Known worktree bugs < 2.48 (admin-dir leaks, prune races) |
+| LFS version | `git lfs version` (skip if not installed) | ≥ 3.6 OR not installed | refuse worktree mode | Known worktree-locking bugs < 3.6 |
+| Submodule scan | `git submodule status` | empty OR every entry clean (` ` prefix, in-sync with recorded pin) | refuse only on divergent (`+`) / conflicted (`U`) entries — see "Submodule handling" below | Clean pins are safe: every worktree wants the same SHA, so the shared `.git/modules` HEAD never contends. Divergent working state is the real hazard. New worktrees auto-init submodules (SKILL Step 2) |
+| `core.hooksPath` | `git config core.hooksPath` | empty OR path resolves inside worktree | refuse worktree mode | Husky/lefthook silent-skip risk when path points outside worktree |
+| Hook smoke test | `git hook run pre-commit` in fresh worktree | exit 0 OR matches main-repo exit code | refuse worktree mode | Confirms hook plumbing actually fires inside worktree |
+| Enforcement canary (advisory) | `bash .claude/hooks/forge-claim-check-doctor.sh` | canary line reports `gate enforces` | **warn, do not refuse** | Proves the claim gate actually denies a foreign claim — catches the inert-gate class (identity read from wrong source / hook unwired) that prereqs can't see |
+
+## Fallback message
+
+On any check failure, emit verbatim to user:
+
+```
+M10 worktree mode unavailable: <reason>. Continuing in single-agent mode. See ADR-005 for compatibility matrix.
+```
+
+Replace `<reason>` with the failing check name + observed value (e.g., "Git version 2.45.1 < required 2.48").
+
+## Submodule handling (conditional)
+
+Submodules do **not** auto-populate in a fresh worktree — `git worktree add` carries the gitlinks but leaves the directories empty until `git submodule update --init` runs (SKILL Step 2 does this). The historic blanket refusal was over-conservative; the real hazard is two worktrees fighting over the shared `.git/modules` HEAD/index when they point a submodule at *different* SHAs. Pinned third-party deps (e.g. JUCE, nanovg) never trigger that — every worktree converges on the one recorded SHA.
+
+Classify `git submodule status` output:
+
+| Observed | Meaning | Action |
+|----------|---------|--------|
+| empty | no submodules | pass |
+| every line ` ` (space) prefix | all clean, in-sync with recorded pin | **warn + proceed** — Step 2 will `submodule update --init --recursive` |
+| any line `-` (uninitialized) in main repo | superproject itself hasn't inited | refuse — init in the main checkout first (`git submodule update --init`) |
+| any line `+` (divergent SHA) | working tree ahead/behind recorded pin | refuse — uncommitted submodule movement is the shared-`.git/modules` hazard |
+| any line `U` (merge conflict) | unresolved submodule conflict | refuse |
+
+Warn-and-proceed message:
+
+```
+M10: <N> submodule(s) present and clean — proceeding. Each worktree auto-inits them
+(shared .git/modules object store, no re-clone). Ensure builds tolerate the one-time init.
+```
+
+## State write on refusal
+
+```yaml
+lifecycle:
+  worktree_mode: refused
+  refused_reason: "<check name>: <observed>"
+  refused_at: "{ISO8601}"
+```
+
+## Check execution order
+
+Run checks 1→5 in order. First failure halts the sequence — no point running hook smoke if Git itself is too old. Record the failing check name + observed value as `refused_reason` so the user knows exactly what to fix.
+
+## Remediation hints
+
+| Failing check | User remediation |
+|---------------|------------------|
+| Git version | Upgrade Git to ≥ 2.48 (Homebrew: `brew upgrade git`; apt: backports or PPA) |
+| LFS version | Upgrade Git LFS to ≥ 3.6 OR uninstall if not actually used |
+| Submodule scan | Only fails on uninitialized (`-`), divergent (`+`), or conflicted (`U`) submodules. Run `git submodule update --init --recursive` in the main checkout so every submodule sits at its recorded pin, then retry. Clean pinned submodules are supported |
+| `core.hooksPath` | Either unset (`git config --unset core.hooksPath`) or move hook dir inside repo tree so it resolves under each worktree |
+| Hook smoke test | Inspect failing hook output; common cause is hook script assuming `$PWD` is main repo root — fix to use `git rev-parse --show-toplevel` |
+
+## Re-running checks
+
+Bootstrap is idempotent and cheap (~200ms total). Skill re-runs on every session start; users do not invoke directly. If a check transiently fails (e.g., LFS not yet installed during initial setup), simply restart the orchestration entry.

package/experimental/m10/uninstall.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# Forge M10 experimental uninstaller.
+# Preserves claims.db by default. Pass --purge to remove it.
+# Usage: bash uninstall.sh [--purge] /path/to/forge-repo
+
+set -euo pipefail
+
+PURGE=0
+TARGET=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --purge) PURGE=1; shift ;;
+    -h|--help) echo "Usage: $0 [--purge] /path/to/forge-repo"; exit 0 ;;
+    *) TARGET="$1"; shift ;;
+  esac
+done
+
+[[ -z "$TARGET" ]] && { echo "ERROR: target repo path required" >&2; exit 2; }
+[[ -d "$TARGET" ]] || { echo "ERROR: target '$TARGET' does not exist" >&2; exit 2; }
+
+say() { echo "  $*"; }
+
+echo "==> M10 experimental uninstaller"
+echo "    target: $TARGET"
+[[ $PURGE -eq 1 ]] && echo "    mode:   --purge (claims.db will be removed)"
+echo
+
+# Remove MCP server dir
+if [[ -d "$TARGET/.forge/.mcp-server" ]]; then
+  if [[ $PURGE -eq 0 && -f "$TARGET/.forge/.mcp-server/claims.db" ]]; then
+    say "preserving claims.db; removing rest of .mcp-server/"
+    find "$TARGET/.forge/.mcp-server" -mindepth 1 -not -name claims.db -delete
+  else
+    rm -rf "$TARGET/.forge/.mcp-server"
+    say "removed .forge/.mcp-server/"
+  fi
+fi
+
+# Remove hooks
+for h in forge-claim-check.sh forge-claim-check-doctor.sh; do
+  [[ -f "$TARGET/.claude/hooks/$h" ]] && { rm -f "$TARGET/.claude/hooks/$h"; say "removed hook $h"; }
+done
+
+# Remove orchestrating skill
+[[ -d "$TARGET/.claude/skills/orchestrating" ]] && {
+  rm -rf "$TARGET/.claude/skills/orchestrating"
+  say "removed orchestrating skill"
+}
+
+# Strip .mcp.json entry
+if [[ -f "$TARGET/.mcp.json" ]] && jq -e '.mcpServers["forge-orchestrator"]' "$TARGET/.mcp.json" >/dev/null 2>&1; then
+  tmp=$(mktemp)
+  jq 'del(.mcpServers["forge-orchestrator"])' "$TARGET/.mcp.json" > "$tmp"
+  mv "$tmp" "$TARGET/.mcp.json"
+  say "removed forge-orchestrator from .mcp.json"
+fi
+
+# Strip settings.json hook entry
+if [[ -f "$TARGET/.claude/settings.json" ]]; then
+  tmp=$(mktemp)
+  jq '.hooks.PreToolUse = ((.hooks.PreToolUse // []) | map(select((.hooks // []) | all(.command != ".claude/hooks/forge-claim-check.sh"))))' \
+    "$TARGET/.claude/settings.json" > "$tmp"
+  mv "$tmp" "$TARGET/.claude/settings.json"
+  say "removed claim-check hook from settings.json"
+fi
+
+echo
+echo "==> Done."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-orkes",
-  "version": "0.62.0",
+  "version": "0.63.0",
   "description": "Set up the Forge meta-prompting framework for Claude Code in your project",
   "bin": {
     "create-forge": "./bin/create-forge.js"
@@ -11,7 +11,8 @@
   },
   "files": [
     "bin/",
-    "template/"
+    "template/",
+    "experimental/"
   ],
   "keywords": [
     "claude",

package/template/.claude/settings.json

@@ -47,13 +47,7 @@
       "Edit(**/secrets/**)",
       "Edit(**/.secrets/**)",
       "Edit(**/*.pem)",
-      "Edit(**/*.key)",
-      "Write(**/.env)",
-      "Write(**/.env.*)",
-      "Write(**/secrets/**)",
-      "Write(**/.secrets/**)",
-      "Write(**/*.pem)",
-      "Write(**/*.key)"
+      "Edit(**/*.key)"
     ]
   },
   "hooks": {