bigpowers 2.86.2 → 2.86.4

package/.zcode/skills/wire-ci/SKILL.md

@@ -1,104 +1,112 @@
 ---
 name: wire-ci
 model: sonnet
-description: "CI pipeline setup with pre-built templates and local validation. Generates GitHub Actions workflows, validates YAML syntax and permissions, supports dry-run via act/gh. The CI equivalent of wire-observability."
+description: "CI pipeline setup with bundled, forge-neutral templates and local validation. Detects the forge from the git remote, generates workflows for supported forges, and skips honestly for the rest. The CI equivalent of wire-observability."
 ---
 
 # Wire CI
 
-> **HARD GATE** — Do not ship a project without CI. Run this skill before first merge to main or when adding CI to an existing project.
+> **HARD GATE (supported forges only)** — Do not ship a project without CI. Run this skill before first merge to main.
+>
+> On a forge bigpowers ships no templates for, this skill **is not a gate**: it reports the forge, explains what it cannot do, and exits 3. A gate that cannot run must not claim it did. See § Unsupported forges.
 >
 > **HARD GATE** — CI that is untestable locally will break every cycle. Always run `--validate` after generating workflows and `--dry-run` before pushing.
 
-Generate, validate, and test CI workflows. Detects your project type, copies org templates from `danielvm-git/.github/workflow-templates/`, and provides local verification to catch auth, permissions, and syntax issues before they reach CI.
+Generate, validate, and test CI workflows. Detects the forge and project type, copies a **bundled** template, and verifies locally before anything reaches CI.
 
-## What this sets up
+## Forge resolution
 
-1. **Test Build Release workflow** — `.github/workflows/test-build-release.yml` with lint → test → build → release (single pipeline, `needs:` chain)
-2. **Deploy workflow** — `.github/workflows/deploy.yml` triggered via `workflow_run` (BigBase/Pages stacks only; CLI/library repos omit this)
-3. **`--validate` mode** — checks YAML syntax, workflow permissions, required secrets, and common pitfalls
-4. **`--dry-run` mode** — runs workflows locally via `act` or `gh workflow run` to prove correctness before push
-5. **Failure pattern documentation** — common CI failure categories and their fixes
+`scripts/lib/detect-forge.sh` resolves the forge, first match wins: `BIGPOWERS_FORGE` env var → `forge:` in `specs/forge.yaml` → the `origin` remote URL → `unknown`.
 
-## Process
+```bash
+bash scripts/wire-ci.sh --detect     # report forge + stack, write nothing
+bash scripts/wire-ci.sh --plan       # show the template that would be used
+bash scripts/wire-ci.sh --apply      # write the workflow
+```
 
-### 1. Detect project type
+GitHub ships templates (`.github/workflows/`). GitLab, Bitbucket, Codeberg, and Gitea are detected but **unsupported** — `--apply` writes nothing and exits 3.
 
-Read the project root for manifest files to determine which template pair to copy:
+## Template source — configurable, bundled by default
 
-| Manifest | Type | Template pair (from `.github` repo) |
-|----------|------|-------------------------------------|
-| `Cargo.toml` | Rust | `test-build-release-monorepo.yml` + `deploy-monorepo.yml` (or monorepo subset) |
-| `package.json` | Node | `test-build-release-node.yml` + `deploy-node.yml` |
-| `setup.py` / `pyproject.toml` | Python | `test-build-release-python.yml` + `deploy-python.yml` |
-| `go.mod` | Go | `test-build-release-go.yml` + `deploy-go.yml` |
-| Static site (no server) | Static | `test-build-release-static.yml` + `deploy-static.yml` |
-| `Package.swift` | Swift | `test-build-release-swift.yml` only (no deploy yet) |
-| Multiple detected | Polyglot | `test-build-release-monorepo.yml` + `deploy-monorepo.yml` |
+Templates live in `docs/templates/ci/<forge>/` **inside the bigpowers package**, so there is no network dependency on any third party's repository. Override with `BIGPOWERS_CI_TEMPLATES=/path/to/your/templates`, laid out as `<root>/<forge>/test-build-release-<stack>.yml`.
 
-**CLI/library repos** (no hosted target): copy only `test-build-release-<stack>.yml` → `test-build-release.yml`. The `release` job is terminal; skip `deploy.yml`. See `docs/how-to/migrate-ci-cd/migration-plan.md` § CLI and library repos.
+## What this sets up
 
-If no manifest is found, prompt the user to specify the type or pass `--type <rust|node|python|go|static|swift>`.
+1. **Test Build Release workflow** — lint → test → build → release in one `needs:` chain
+2. **`--validate` mode** — YAML syntax, workflow permissions, required secrets, common pitfalls
+3. **`--dry-run` mode** — runs workflows locally via `act` before push
+4. **Failure pattern documentation** — see the table below
 
-### 2. Copy test-build-release template
+Deploy workflows are **not** bundled: they are platform-specific. See [REFERENCE.md](REFERENCE.md) for a worked example.
 
-Copy the matching template from `~/Developer/.github/workflow-templates/` to `.github/workflows/test-build-release.yml`. **Do not rename the workflow `name:` field** — deploy listens for `"Test Build Release"`.
+## Process
+
+### 1. Detect forge and stack
+
+```bash
+bash scripts/wire-ci.sh --detect
+```
 
-Edit placeholders: `APP_TYPE`, `SITE_URL`, language versions.
+Stack detection reads the project root:
 
-See [REFERENCE.md](REFERENCE.md) for stack-specific job shapes.
+| Manifest | Stack | Bundled template |
+|----------|-------|------------------|
+| `Cargo.toml` | Rust | `test-build-release-rust.yml` |
+| `package.json` | Node | `test-build-release-node.yml` |
+| `pyproject.toml` / `setup.py` | Python | `test-build-release-python.yml` |
+| `go.mod` | Go | `test-build-release-go.yml` |
 
-### 3. Copy deploy template (hosted stacks only)
+No recognized manifest → exit 3 with the list of manifests it looked for. Do not guess.
 
-If the project deploys to BigBase or GitHub Pages:
+### 2. Apply the template
 
 ```bash
-cp ~/Developer/.github/workflow-templates/deploy-${STACK}.yml .github/workflows/deploy.yml
+bash scripts/wire-ci.sh --apply
 ```
 
-Configure `BIGBASE_SITE_ID`, `BIGBASE_DEPLOY_TOKEN`, and matching `SITE_URL`. Deploy runs via `workflow_run` after TBR succeeds on `main` with `cancel-in-progress: false`.
+**Do not rename the workflow `name:` field** — deploy listens for `"Test Build Release"`.
 
-Skip this step for CLI/library repos.
+Edit placeholders after copying: language versions, `APP_TYPE`, `SITE_URL`.
 
-### 4. Validate workflows (`--validate`)
+### 3. Unsupported forges
 
-Run `wire-ci --validate` to check all generated workflow files:
+`--apply` writes nothing and exits 3. Your options, in the order the runner prints them:
 
-See [REFERENCE.md](REFERENCE.md)
+- point `BIGPOWERS_CI_TEMPLATES` at templates for your forge
+- pin `forge: github` in `specs/forge.yaml` if the remote is misdetected
+- write the CI config by hand
 
-**Exit codes:**
-- `0` — all checks pass (no errors)
-- `1` — YAML syntax errors found
-- `2` — validation warnings only (missing permissions, secrets, etc.)
+Contributing a `docs/templates/ci/gitlab/` set and adding `gitlab` to `FORGE_SUPPORTED_LIST` is the natural next slice — per-forge command mapping (`gh pr checks` → `glab ci status`) is not implemented yet.
 
-### 5. Dry-run workflows (`--dry-run`)
+### 4. Validate workflows (`--validate`)
 
-Attempt to run the generated workflows locally to catch errors before push:
+See [REFERENCE.md](REFERENCE.md). Exit codes: `0` clean, `1` YAML syntax errors, `2` warnings only.
+
+### 5. Dry-run workflows (`--dry-run`)
 
-See [REFERENCE.md](REFERENCE.md)
+See [REFERENCE.md](REFERENCE.md).
 
 > **act** runs workflows in a local Docker environment — the most accurate pre-push validation.
-> **gh workflow run** sends the workflow to GitHub but doesn't execute locally — useful for checking YAML parsing but not for testing the actual steps.
+> **gh workflow run** sends the workflow to GitHub but does not execute locally.
 
 ### 6. Document common CI failure patterns
 
-Add the following to the project's documentation or CLAUDE.md after setup:
-
 | Failure | Cause | Fix |
 |---------|-------|-----|
-| `npm publish` fails | `NPM_TOKEN` not set as repo secret | Add `NPM_TOKEN` to GitHub repo secrets |
-| `semantic-release` fails on push | Missing `permissions: contents: write` | Add `permissions: contents: write` to release job |
-| `cargo publish` auth fail | `CARGO_REGISTRY_TOKEN` not set | Add token to `~/.cargo/config.toml` or env |
-| `go vet` fails | Go version mismatch | Match `go.mod` `go` directive with setup-go version |
-| `cargo clippy` errors | New lints in Rust nightly | `cargo clippy --fix` or allow specific lints |
-| `act` not found | Docker not running or act not installed | `brew install act` / `docker ps` to verify Docker |
-| Hardcoded Node version stale | `.nvmrc` exists but workflow uses hardcoded version | Use `node-version-file: .nvmrc` instead |
-| Deploy never runs | TBR workflow renamed | Keep `name: Test Build Release` in test-build-release.yml |
-| Release rebuilds binary | Artifact not downloaded | `release` job must `download-artifact` from `build` |
+| `npm publish` fails | `NPM_TOKEN` not set as repo secret | Add `NPM_TOKEN` to repo secrets |
+| `semantic-release` fails on push | Missing `permissions: contents: write` | Add it to the release job |
+| `cargo publish` auth fail | `CARGO_REGISTRY_TOKEN` not set | Add token to env or `~/.cargo/config.toml` |
+| `go vet` fails | Go version mismatch | Use `go-version-file: go.mod` |
+| `cargo clippy` errors | New nightly lints | Pin the toolchain; `cargo clippy --fix` |
+| `act` not found | Docker not running or act missing | `brew install act`; `docker ps` |
+| Hardcoded Node version stale | `.nvmrc` exists but workflow hardcodes | Use `node-version-file: .nvmrc` |
+| Deploy never runs | TBR workflow renamed | Keep `name: Test Build Release` |
+| Release rebuilds binary | Artifact not downloaded | `release` must `download-artifact` from `build` |
 
 ## Verify
 
-→ verify: `test -f skills/wire-ci/REFERENCE.md && test -f .github/workflows/sync-skills.yml`
+→ verify: `bash scripts/wire-ci.sh --self-test`
+→ verify: `test -f docs/templates/ci/github/test-build-release-node.yml && test -f scripts/lib/detect-forge.sh`
 → verify: `grep -q wire-ci SKILL-INDEX.md`
 
 ---
@@ -121,19 +129,26 @@ Add the following to the project's documentation or CLAUDE.md after setup:
 ### Create CI for a Go project (TBR + optional deploy)
 
 ```bash
-# Copy org templates
-cp ~/Developer/.github/workflow-templates/test-build-release-go.yml .github/workflows/test-build-release.yml
-cp ~/Developer/.github/workflow-templates/deploy-go.yml .github/workflows/deploy.yml
+# Resolve forge + stack, then apply the bundled template
+bash scripts/wire-ci.sh --detect
+bash scripts/wire-ci.sh --apply
 
 wire-ci --validate
 wire-ci --dry-run
 ```
 
+To use your own org templates instead of the bundled ones:
+
+```bash
+BIGPOWERS_CI_TEMPLATES=/path/to/your/templates bash scripts/wire-ci.sh --apply
+```
+
 ### Create CI for a CLI tool (TBR only, no deploy)
 
 ```bash
-cp ~/Developer/.github/workflow-templates/test-build-release-go.yml .github/workflows/test-build-release.yml
+bash scripts/wire-ci.sh --apply
 # Edit release job to download build artifact — see big-release dogfood
+# CLI/library repos: delete deploy.yml; the release job is terminal.
 
 wire-ci --validate
 ```
@@ -277,6 +292,10 @@ jobs:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           run-id: ${{ github.event.workflow_run.id }}
           path: deploy-meta
+      # BigBase-specific composite action, not a bigpowers default: this deploy
+      # example targets the author's own hosting stack. Replace it with your
+      # platform's deploy step (or drop the deploy job entirely for CLI and
+      # library repos). bigpowers itself ships no deploy templates. (GH #104)
       - uses: danielvm-git/.github/actions/bigbase-deploy@9c56ac10c629f3baa110ddb19136579e3c90d690  # v1
         with:
           site_id: ${{ secrets.BIGBASE_SITE_ID }}

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [2.86.4](https://github.com/danielvm-git/bigpowers/compare/v2.86.3...v2.86.4) (2026-07-26)
+
+
+### Bug Fixes
+
+* **specs:** reconcile planning SoT drift and gate it with G-12 ([d8553a7](https://github.com/danielvm-git/bigpowers/commit/d8553a748d4cdc81fa612564f84600a62c4789ce))
+
+## [2.86.3](https://github.com/danielvm-git/bigpowers/compare/v2.86.2...v2.86.3) (2026-07-26)
+
+
+### Bug Fixes
+
+* **adapters:** make copy-mode context wiring idempotent ([2154e5f](https://github.com/danielvm-git/bigpowers/commit/2154e5f55140c8cb8f9c0ea22a7ea7bacf55f99e)), closes [#106](https://github.com/danielvm-git/bigpowers/issues/106)
+* **specs:** give e60s01 a runnable verify ([585f0aa](https://github.com/danielvm-git/bigpowers/commit/585f0aa78ecc25dba5c13fccd1090c1b626900af)), closes [#106](https://github.com/danielvm-git/bigpowers/issues/106)
+* **sync:** restore .pi and .gemini artifacts dropped by a concurrent sync ([b901340](https://github.com/danielvm-git/bigpowers/commit/b901340d08cbd74e34853beb8e9aad6fbec66698))
+* **test:** scope agy gemini-path assertion to install_agy body ([1ac37f0](https://github.com/danielvm-git/bigpowers/commit/1ac37f0c0673e031996b7d9dde8ba0304d2a6ca1)), closes [#106](https://github.com/danielvm-git/bigpowers/issues/106)
+* **test:** stop ta_cleanup EXIT trap forcing exit 1 ([cd409ef](https://github.com/danielvm-git/bigpowers/commit/cd409efcf2d8d92f8796114f50871cd55538067d)), closes [#106](https://github.com/danielvm-git/bigpowers/issues/106)
+* **verify:** execute story-level verify: commands ([#106](https://github.com/danielvm-git/bigpowers/issues/106)) ([9b3f82a](https://github.com/danielvm-git/bigpowers/commit/9b3f82a18c18014a70380e1062de81c268639ef9)), closes [#96](https://github.com/danielvm-git/bigpowers/issues/96)
+* **verify:** story-level verify and CI template fix ([#104](https://github.com/danielvm-git/bigpowers/issues/104), [#106](https://github.com/danielvm-git/bigpowers/issues/106)) ([049c7c9](https://github.com/danielvm-git/bigpowers/commit/049c7c9529fa0584b6823033e68e2fb7281ff750))
+* **wire-ci:** un-hardcode template source, skip unsupported forges ([#104](https://github.com/danielvm-git/bigpowers/issues/104)) ([31a6fac](https://github.com/danielvm-git/bigpowers/commit/31a6fac06f823b55a00b38637d06f01b555b25c8))
+
 ## [2.86.2](https://github.com/danielvm-git/bigpowers/compare/v2.86.1...v2.86.2) (2026-07-26)
 
 

package/SKILL-INDEX.md

@@ -65,7 +65,7 @@
 | 37 | Build | `quick-fix` | "Streamlined fast-path for trivial data-only fixes — no TDD, no branching cere | ✅ Active |
 | 38 | Build | `setup-environment` | Pre-install dependencies and configure tools before development work begins. Use | ✅ Active |
 | 39 | Build | `spike-prototype` | Throw-away prototype for unknown problem spaces. Output is learning notes in spe | ✅ Active |
-| 40 | Build | `wire-ci` | "CI pipeline setup with pre-built templates and local validation. Generates GitH | ✅ Active |
+| 40 | Build | `wire-ci` | "CI pipeline setup with bundled, forge-neutral templates and local validation. D | ✅ Active |
 | 41 | Build | `wire-observability` | Add structured JSON logging, observability commands, and idempotent setup script | ✅ Active |
 | 42 | Verify | `audit-code` | Self-review checklist for the coding agent to run before dispatching a reviewer. | ✅ Active |
 | 43 | Verify | `context7-mcp` | Fetch current library docs via Context7 MCP instead of training data. Use when u | ✅ Active |

package/package.json

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

package/scripts/golden-g12-status-consistency.sh

@@ -0,0 +1,232 @@
+#!/usr/bin/env bash
+# story: e51s04
+# golden-g12-status-consistency.sh — Planning SoT Consistency Gate (G-12)
+#
+# CONVENTIONS.md § specs/ declares specs/execution-status.yaml the sole SoT for
+# story state. Nothing enforced that. sync-status-from-epics.sh is a *seeder*:
+# it preloads keys from execution-status.yaml itself and uses setdefault(), so
+# an existing key keeps its old value and epic.yaml's stories[].status is never
+# read. Story status written by build-epic step 8 into a capsule could therefore
+# disagree with the SoT forever, undetected
+# (BUG-2026-07-26-planning-sot-drift).
+#
+# This gate makes the two agree or fails.
+#
+# Authority model (CONVENTIONS.md § specs/): execution-status.yaml is the sole
+# SoT for story state; a capsule's stories[].status is derived. Capsules under
+# specs/epics/archive/ are frozen historical records — an archived shard that
+# still reads 'todo' while the SoT reads 'done' is normal history, not drift, so
+# archive/ is excluded. Status vocabulary is normalised before comparison
+# ('passing' == 'done'; 'todo'/'planned'/'not-started' == 'backlog').
+#
+# Checks:
+#   1. A LIVE capsule must not disagree with execution-status.yaml (both the
+#      stories: and development_status: sections). In practice this catches a
+#      capsule marked done by build-epic step 8 whose SoT was never updated.
+#   2. Every capsule_dir in release-plan.yaml must resolve to a real directory.
+#   3. A live capsule must not also exist under archive/ — two shards for one
+#      epic makes "which status is authoritative" undecidable.
+#
+# Usage: bash scripts/golden-g12-status-consistency.sh [--self-test]
+# Exit 0: SoT is consistent
+# Exit 1: drift detected (or, under --self-test, the gate failed to detect
+#         deliberately injected drift — a vacuous gate, G-08 bug class)
+
+set -euo pipefail
+source "$(dirname "${BASH_SOURCE[0]}")/lib/python-env.sh"
+source "$(dirname "${BASH_SOURCE[0]}")/lib/skill-common.sh"
+resolve_repo_root
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+NC='\033[0m'
+
+SELF_TEST=0
+[[ "${1:-}" == "--self-test" ]] && SELF_TEST=1
+
+check_tree() {
+  # $1 = specs dir to check
+  $PYTHON - "$1" <<'PY'
+import sys, re
+from pathlib import Path
+import yaml
+
+specs = Path(sys.argv[1])
+epics_dir = specs / "epics"
+exec_path = specs / "execution-status.yaml"
+rp_path = specs / "release-plan.yaml"
+
+problems = []
+archived_skipped = 0
+
+# Status vocabulary normalisation — different skills have written different
+# words for the same state over the repo's history.
+ALIASES = {
+    "passing": "done",
+    "complete": "done",
+    "completed": "done",
+    "todo": "backlog",
+    "planned": "backlog",
+    "not-started": "backlog",
+}
+
+
+def norm(v):
+    return ALIASES.get(str(v).strip().lower(), str(v).strip().lower())
+
+
+exec_data = yaml.safe_load(exec_path.read_text(encoding="utf-8")) or {}
+dev = exec_data.get("development_status") or {}
+stories = exec_data.get("stories") or {}
+
+# --- Check 1: LIVE epic.yaml story status vs execution-status.yaml ---
+for epic_file in sorted(epics_dir.rglob("epic.yaml")):
+    rel = epic_file.relative_to(specs)
+    if "archive" in epic_file.relative_to(epics_dir).parts:
+        archived_skipped += 1
+        continue
+
+    try:
+        ed = yaml.safe_load(epic_file.read_text(encoding="utf-8")) or {}
+    except Exception as exc:
+        problems.append(f"unparseable epic shard {rel}: {exc}")
+        continue
+
+    for story in ed.get("stories") or []:
+        if not isinstance(story, dict):
+            continue
+        sid = story.get("id")
+        declared = story.get("status")
+        if not sid or not declared:
+            continue
+        if not re.match(r"^e\d+s\d+$", str(sid)):
+            continue
+
+        sot_detail = stories.get(sid, {})
+        sot_detail = sot_detail.get("status") if isinstance(sot_detail, dict) else None
+        sot_summary = dev.get(sid)
+
+        if sot_detail is not None and norm(sot_detail) != norm(declared):
+            problems.append(
+                f"{sid}: {rel} says '{declared}' but execution-status.yaml "
+                f"stories.{sid}.status says '{sot_detail}'"
+            )
+        if sot_summary is not None and norm(sot_summary) != norm(declared):
+            problems.append(
+                f"{sid}: {rel} says '{declared}' but execution-status.yaml "
+                f"development_status.{sid} says '{sot_summary}'"
+            )
+
+# --- Check 2: release-plan.yaml capsule_dir resolves ---
+if rp_path.exists():
+    rp = yaml.safe_load(rp_path.read_text(encoding="utf-8")) or {}
+    for ep in rp.get("epics") or []:
+        if not isinstance(ep, dict):
+            continue
+        cd = ep.get("capsule_dir")
+        if cd and not (specs / cd).is_dir():
+            problems.append(
+                f"{ep.get('id')}: release-plan.yaml capsule_dir '{cd}' does not exist"
+            )
+
+# --- Check 3: no epic has both a live and an archived capsule ---
+archive_dir = epics_dir / "archive"
+if archive_dir.is_dir():
+    live = {p.name for p in epics_dir.iterdir() if p.is_dir() and p.name != "archive"}
+    for p in archive_dir.iterdir():
+        if p.is_dir() and p.name in live:
+            problems.append(
+                f"{p.name}: capsule exists both live and under archive/ — "
+                f"authoritative status is undecidable"
+            )
+
+if archived_skipped:
+    print(f"  info: {archived_skipped} archived capsule(s) skipped (frozen history)")
+
+if problems:
+    for p in problems:
+        print(f"  DRIFT {p}")
+    print(f"\n{len(problems)} inconsistencies")
+    sys.exit(1)
+
+print("  ok  : epic shards, execution-status.yaml and release-plan.yaml agree")
+sys.exit(0)
+PY
+}
+
+if [[ "$SELF_TEST" -eq 1 ]]; then
+  echo "=== G-12 self-test: prove the gate can fail ==="
+  TMP=$(mktemp -d)
+  trap 'rm -rf "$TMP"' EXIT
+  # Copy only what check_tree reads — specs/ as a whole is ~28MB and the copy
+  # would dominate the gate's runtime.
+  mkdir -p "$TMP/specs"
+  cp -R "$REPO_ROOT/specs/epics" "$TMP/specs/epics"
+  cp "$REPO_ROOT/specs/execution-status.yaml" "$TMP/specs/"
+  cp "$REPO_ROOT/specs/release-plan.yaml" "$TMP/specs/"
+
+  # Inject drift into a LIVE capsule. Archived shards are excluded from the
+  # check, so mutating one would prove nothing — the gate would rightly stay
+  # silent and the self-test would report a false vacuity failure.
+  $PYTHON - "$TMP/specs" <<'PY'
+import sys, re
+from pathlib import Path
+import yaml
+
+specs = Path(sys.argv[1])
+epics_dir = specs / "epics"
+exec_path = specs / "execution-status.yaml"
+data = yaml.safe_load(exec_path.read_text(encoding="utf-8")) or {}
+
+for epic_file in sorted(epics_dir.rglob("epic.yaml")):
+    if "archive" in epic_file.relative_to(epics_dir).parts:
+        continue
+    ed = yaml.safe_load(epic_file.read_text(encoding="utf-8")) or {}
+    for story in ed.get("stories") or []:
+        if not isinstance(story, dict):
+            continue
+        sid, st = story.get("id"), story.get("status")
+        if sid and st and re.match(r"^e\d+s\d+$", str(sid)):
+            flipped = "backlog" if st != "backlog" else "done"
+            data.setdefault("stories", {}).setdefault(sid, {})["status"] = flipped
+            data.setdefault("development_status", {})[sid] = flipped
+            exec_path.write_text(
+                yaml.dump(data, default_flow_style=False, sort_keys=False),
+                encoding="utf-8",
+            )
+            print(f"injected: {sid} {st} -> {flipped} (live capsule)")
+            sys.exit(0)
+print("ERROR: no live story with a status found to mutate", file=sys.stderr)
+sys.exit(2)
+PY
+
+  set +e
+  check_tree "$TMP/specs" >/dev/null 2>&1
+  injected_exit=$?
+  set -e
+
+  if [[ $injected_exit -ne 0 ]]; then
+    echo -e "${GREEN}PASS${NC} G-12 detected injected drift (exit $injected_exit)"
+    echo "G-12 self-test: PASS"
+    exit 0
+  fi
+  echo -e "${RED}FAIL${NC} G-12 passed on deliberately drifted specs — vacuous gate"
+  echo "G-12 self-test: FAIL — same bug class as G-08 / BUG-2026-07-26-planning-sot-drift"
+  exit 1
+fi
+
+echo "=== G-12: Planning SoT Consistency ==="
+set +e
+output=$(check_tree "$REPO_ROOT/specs" 2>&1)
+actual_exit=$?
+set -e
+echo "$output"
+
+if [[ $actual_exit -eq 0 ]]; then
+  echo -e "${GREEN}PASS${NC} planning SoT is consistent"
+  echo "G-12: PASS"
+  exit 0
+fi
+echo -e "${RED}FAIL${NC} planning SoT has drifted"
+echo "G-12: FAIL — see BUG-2026-07-26-planning-sot-drift"
+exit 1

package/scripts/lib/context-wire.sh

@@ -54,6 +54,15 @@ wire_context_mode() {
     symlink|copy)
       [[ -n "$file" ]] || { echo "context-wire: file required for mode=$mode" >&2; return 1; }
       if [[ "$mode" == "copy" ]]; then
+        [[ -f "$src" ]] || { echo "context-wire: source missing: $src" >&2; return 1; }
+        # Already wired — nothing to do. kilocode and windsurf declare
+        # `mode: copy, file: AGENTS.md` in targets.yaml, and the source is also
+        # AGENTS.md, so a bare `cp` fails with "are identical" and made
+        # wire_context non-idempotent. wire_symlink_or_copy already guards this;
+        # the copy branch did not. (#106)
+        if [[ -f "$file" ]] && cmp -s "$src" "$file" 2>/dev/null; then
+          return 0
+        fi
         cp "$src" "$file"
       else
         wire_symlink_or_copy "$src" "$file"

package/scripts/lib/detect-forge.sh

@@ -0,0 +1,105 @@
+#!/usr/bin/env bash
+# story: GH-104-forge-neutrality
+# detect-forge.sh — resolve which git forge a project uses.
+#
+# bigpowers ships to solo devs generally, but its CI advice assumed GitHub
+# everywhere (GH #104). This is the seam: skills ask which forge is in play and
+# what it supports, instead of hardcoding `gh` and `.github/workflows/`.
+#
+# Resolution order (first match wins):
+#   1. BIGPOWERS_FORGE environment variable  — explicit override
+#   2. forge: key in specs/forge.yaml        — per-project setting
+#   3. the `origin` remote URL               — inferred
+#   4. "unknown"                             — no remote, or an unrecognized host
+#
+# Source this file, then call detect_forge / forge_is_supported / forge_ci_path.
+
+if [[ -n "${DETECT_FORGE_LOADED:-}" ]]; then return 0; fi
+DETECT_FORGE_LOADED=1
+
+FORGE_UNKNOWN="unknown"
+
+# Forges whose CI templates bigpowers actually ships. Anything else must be
+# reported honestly and skipped — never silently handed GitHub Actions config.
+FORGE_SUPPORTED_LIST="github"
+
+_forge_from_remote_url() {
+  local url="$1"
+  case "$url" in
+    "") echo "$FORGE_UNKNOWN" ;;
+    *github.com[:/]*|*github.*.com[:/]*) echo "github" ;;
+    *gitlab.com[:/]*|*gitlab.*[:/]*)     echo "gitlab" ;;
+    *bitbucket.org[:/]*)                 echo "bitbucket" ;;
+    *codeberg.org[:/]*)                  echo "codeberg" ;;
+    *gitea.*[:/]*)                       echo "gitea" ;;
+    *) echo "$FORGE_UNKNOWN" ;;
+  esac
+}
+
+_forge_from_config() {
+  local repo_root="$1"
+  local config="$repo_root/specs/forge.yaml"
+  [[ -f "$config" ]] || return 1
+  local value
+  value=$(grep -E '^forge:' "$config" 2>/dev/null | head -1 \
+    | sed -E 's/^forge:[[:space:]]*//; s/^"(.*)"$/\1/; s/[[:space:]]*$//')
+  [[ -n "$value" ]] || return 1
+  printf '%s' "$value"
+}
+
+# Echo the forge id. Never fails — an undetectable forge is "unknown", which
+# callers must treat as "skip honestly", not as "assume GitHub".
+detect_forge() {
+  local repo_root="${1:-.}"
+
+  if [[ -n "${BIGPOWERS_FORGE:-}" ]]; then
+    printf '%s\n' "$BIGPOWERS_FORGE"
+    return 0
+  fi
+
+  local configured
+  if configured=$(_forge_from_config "$repo_root"); then
+    printf '%s\n' "$configured"
+    return 0
+  fi
+
+  local url
+  url=$(git -C "$repo_root" remote get-url origin 2>/dev/null || echo "")
+  _forge_from_remote_url "$url"
+}
+
+forge_is_supported() {
+  local forge="$1"
+  case " $FORGE_SUPPORTED_LIST " in
+    *" $forge "*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+# Where a forge expects its CI config. Empty for unsupported forges — callers
+# must check forge_is_supported first rather than treating "" as a path.
+forge_ci_path() {
+  local forge="$1"
+  case "$forge" in
+    github) echo ".github/workflows" ;;
+    gitlab) echo ".gitlab-ci.yml" ;;
+    *) echo "" ;;
+  esac
+}
+
+# Root of the bundled CI templates. Overridable so a user can point at their own
+# org templates; the previous hardcoded `danielvm-git/.github` made every
+# installation depend on one person's personal repository.
+#
+# Resolved against the bigpowers package — NOT the target project. Templates
+# ship with bigpowers; deriving this from the project being wired would look for
+# them inside the user's repo, where they do not exist.
+forge_template_root() {
+  if [[ -n "${BIGPOWERS_CI_TEMPLATES:-}" ]]; then
+    printf '%s' "$BIGPOWERS_CI_TEMPLATES"
+    return 0
+  fi
+  local package_root
+  package_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+  printf '%s' "$package_root/docs/templates/ci"
+}