bigpowers 2.86.3 → 2.86.5

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/land-branch.sh

@@ -36,12 +36,18 @@ COMMIT_MSG="${ARGS[1]:-}"
 
 [ -n "$FEATURE_BRANCH" ] && [ -n "$COMMIT_MSG" ] || usage_land
 
-if [[ ! "$COMMIT_MSG" =~ $CONVENTIONAL_REGEX ]]; then
+# Both checks below judge the subject line, not the whole message. The length
+# test used to read ${#COMMIT_MSG}, so any Conventional Commit carrying a body
+# was rejected no matter how short its subject — the error text said "subject
+# line" while the check measured the entire string.
+COMMIT_SUBJECT="${COMMIT_MSG%%$'\n'*}"
+
+if [[ ! "$COMMIT_SUBJECT" =~ $CONVENTIONAL_REGEX ]]; then
   land_branch_deny "Commit message must follow Conventional Commits: <type>(<scope>): <subject>"
 fi
 
-if [ ${#COMMIT_MSG} -gt 72 ]; then
-  land_branch_deny "Commit subject line must be 72 characters or less"
+if [ ${#COMMIT_SUBJECT} -gt 72 ]; then
+  land_branch_deny "Commit subject line must be 72 characters or less (got ${#COMMIT_SUBJECT})"
 fi
 
 # Block AI agent attribution (P1 — CONVENTIONS.md § Git Attribution)

package/scripts/lib/golden-suite-gates.sh

@@ -14,6 +14,15 @@ GOLDEN_GATES=(
   "g09-yaml-roundtrip:bash scripts/golden-g09-yaml-roundtrip.sh:false"
   "g10-trace-anti-vacuity:bash scripts/golden-g10-trace-anti-vacuity.sh:false"
   "g11-gitignore-venv:bash scripts/golden-g11-gitignore-venv.sh:false"
+  # Planning SoT consistency (BUG-2026-07-26-planning-sot-drift): live epic
+  # shards, execution-status.yaml and release-plan.yaml must agree. Self-test
+  # first so a vacuous gate is caught before its verdict is trusted.
+  "g12-status-selftest:bash scripts/golden-g12-status-consistency.sh --self-test:false"
+  "g12-status-consistency:bash scripts/golden-g12-status-consistency.sh:false"
+  # Anti-vacuity for the target-contract seam: every contract declared in
+  # targets.yaml must have a real assertion, and an unknown contract must FAIL
+  # rather than SKIP+exit 0 (seven contracts were fail-open before this).
+  "target-contracts:bash scripts/test-target-contracts.sh:false"
   "install-helpers:bash scripts/test-install-helpers.sh:false"
   "import-boundaries:bash scripts/check-import-boundaries.sh:false"
   "skill-catalog:bash scripts/validate-skill-catalog.sh:false"

package/scripts/lib/target-contracts.sh

@@ -82,6 +82,33 @@ assert_agy_skills_nonempty() {
   return 1
 }
 
+# Generic hooks-manifest assertion for every target that ships one under
+# scripts/hooks/<target>/. Before this existed, cline/codebuddy/codex/kilocode/
+# qwen/trae/windsurf all declared <target>_hooks_manifest in targets.yaml and
+# every one of them fell through run_contract's default branch to SKIP + exit 0
+# — seven declared contracts that could never fail.
+assert_hooks_manifest() {
+  local id="$1"
+  local contract="$2"
+  local target="${contract%_hooks_manifest}"
+  local manifest="scripts/hooks/${target}/hooks-manifest.json"
+
+  if [[ ! -f "$manifest" ]]; then
+    echo "FAIL $id:$contract — $manifest missing"
+    return 1
+  fi
+  # verify-install.sh sources this file without lib/python-env.sh, so resolve an
+  # interpreter locally rather than relying on $PYTHON being set.
+  local py="${PYTHON:-}"
+  [[ -n "$py" ]] || py="$(command -v python3 || command -v python || true)"
+  if [[ -n "$py" ]] && ! "$py" -c "import json; json.load(open('$manifest'))" 2>/dev/null; then
+    echo "FAIL $id:$contract — $manifest is not valid JSON"
+    return 1
+  fi
+  echo "PASS $id:$contract"
+  return 0
+}
+
 run_contract() {
   local id="$1"
   local contract="$2"
@@ -90,10 +117,19 @@ run_contract() {
     symlink_claude_md) assert_symlink_claude_md "$id" ;;
     cursor_rules_nonempty) assert_cursor_rules_nonempty "$id" ;;
     gemini_ext_exists) assert_gemini_ext_exists "$id" ;;
+    # gemini has its own adapter-level validator; keep it ahead of the generic
+    # pattern below so the more specific check wins.
     gemini_hooks_manifest) assert_gemini_hooks_manifest "$id" ;;
+    *_hooks_manifest) assert_hooks_manifest "$id" "$contract" ;;
     pi_skills_nonempty) assert_pi_skills_nonempty "$id" ;;
     agy_skills_nonempty) assert_agy_skills_nonempty "$id" ;;
     aider_bridge) assert_aider_bridge "$id" ;;
-    *) echo "SKIP $id:$contract — unknown contract"; return 0 ;;
+    # A contract declared in targets.yaml with no assertion behind it is a
+    # broken contract, not a no-op. Failing here is what makes the registry an
+    # enforced interface rather than documentation.
+    *)
+      echo "FAIL $id:$contract — unknown contract (no assertion implemented)"
+      return 1
+      ;;
   esac
 }

package/scripts/sync-status-from-epics.sh

@@ -1,5 +1,13 @@
 #!/usr/bin/env bash
 # sync-status-from-epics.sh — seed execution-status.yaml keys from epic shards
+#
+# SEEDER, NOT A RECONCILER. `keys` is preloaded from execution-status.yaml
+# itself and applied with setdefault(), so an already-present key keeps its
+# existing value; epic.yaml's stories[].status is never read. Running this does
+# NOT pull a capsule's status into the SoT — it only adds missing keys and
+# refreshes task counters. Drift between a capsule and the SoT is detected by
+# scripts/golden-g12-status-consistency.sh (G-12), not corrected here.
+# See specs/bugs/BUG-2026-07-26-planning-sot-drift.md.
 set -euo pipefail
 source "$(dirname "${BASH_SOURCE[0]}")/lib/python-env.sh"
 source "$(dirname "${BASH_SOURCE[0]}")/lib/skill-common.sh"

package/scripts/test-target-contracts.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# story: e37s08
+# test-target-contracts.sh — anti-vacuity guard for run_contract.
+#
+# Every contract named in scripts/targets.yaml must have a real assertion behind
+# it. run_contract used to end in `*) echo "SKIP ..."; return 0`, so seven
+# declared contracts (cline/codebuddy/codex/kilocode/qwen/trae/windsurf
+# _hooks_manifest) silently passed forever. This test fails if that default ever
+# returns to being permissive, or if targets.yaml declares a contract nothing
+# implements.
+#
+# Usage: bash scripts/test-target-contracts.sh
+set -euo pipefail
+source "$(dirname "${BASH_SOURCE[0]}")/lib/skill-common.sh"
+resolve_repo_root
+cd "$REPO_ROOT"
+
+PASS=0
+FAIL=0
+pass() { echo "PASS: $1"; PASS=$((PASS + 1)); }
+fail() { echo "FAIL: $1" >&2; FAIL=$((FAIL + 1)); }
+
+echo "=== test-target-contracts.sh ==="
+
+# shellcheck source=lib/target-contracts.sh
+source "$REPO_ROOT/scripts/lib/target-contracts.sh"
+
+# 1. An unknown contract MUST fail. This is the anti-vacuity assertion.
+set +e
+out=$(run_contract "faketarget" "definitely_not_a_real_contract" 2>&1)
+rc=$?
+set -e
+if [[ $rc -ne 0 ]]; then
+  pass "unknown contract fails (exit $rc)"
+else
+  fail "unknown contract returned 0 — run_contract is fail-open again: $out"
+fi
+
+# 2. Every contract declared in targets.yaml must resolve to an assertion.
+#    Probing with a nonexistent target id means a real assertion returns 1 with
+#    a FAIL line, while a missing implementation hits the default branch and
+#    reports "unknown contract".
+declared=$(grep -E "^      - [a-z0-9_]+$" scripts/targets.yaml | sed 's/^      - //' | sort -u)
+[[ -n "$declared" ]] || fail "no contracts parsed from targets.yaml"
+
+for c in $declared; do
+  set +e
+  out=$(run_contract "__probe__" "$c" 2>&1)
+  set -e
+  if grep -q "unknown contract" <<<"$out"; then
+    fail "$c declared in targets.yaml but no assertion implements it"
+  else
+    pass "$c has an implementation"
+  fi
+done
+
+# 3. Every *_hooks_manifest target must actually ship a parseable manifest.
+for c in $declared; do
+  case "$c" in
+    gemini_hooks_manifest) continue ;;  # adapter-level validator, not a file check
+    *_hooks_manifest)
+      t="${c%_hooks_manifest}"
+      if [[ -f "scripts/hooks/${t}/hooks-manifest.json" ]]; then
+        pass "$t ships hooks-manifest.json"
+      else
+        fail "$t declares $c but scripts/hooks/${t}/hooks-manifest.json is missing"
+      fi
+      ;;
+  esac
+done
+
+echo "test-target-contracts: $PASS passed, $FAIL failed"
+[[ "$FAIL" -eq 0 ]] || exit 1

package/scripts/tombstone-skill.sh

@@ -54,9 +54,15 @@ STORY_TAGS=$(grep -E '^#\s*story:' "$OLD_SKILL_MD" || true)
 CURRENT_VERSION=$(jq -r '.version' package.json 2>/dev/null)
 CREATED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
+# A tombstone is still a live SKILL.md for its transition window, so it must
+# carry the same required frontmatter as any other skill. Omitting `model:`
+# made docs/references/model-profiles.md count one fewer skill than there are
+# skill directories, which fails validate-doctrine's skill-count check.
 cat > "$OLD_SKILL_MD" <<STUBEOF
 ---
 name: ${OLD_NAME}
+model: haiku
+effort: light
 description: "TOMBSTONE — renamed/merged to ${NEW_NAME}. This stub resolves for one release then is removed."
 ---
 

package/skills/craft-skill/SKILL.md

@@ -48,7 +48,7 @@ Skill-body instructional prose MUST follow [AGENTIC-STE.md](../../docs/AGENTIC-S
    - Any reference materials to include?
    - What specs/ output does it produce (if any)?
 
-2. **Verify Principles** — Ensure the skill aligns with [PRINCIPLES.md](https://github.com/danielvm-git/bigpowers/blob/main/docs/PRINCIPLES.md):
+2. **Verify Principles** — Ensure the skill aligns with [PRINCIPLES.md](../../docs/PRINCIPLES.md):
    - Is it atomic (verb-noun)?
    - Is it "deep" (simple interface, complex internal logic)?
    - Does it include Hard Gates?
@@ -62,7 +62,7 @@ Skill-body instructional prose MUST follow [AGENTIC-STE.md](../../docs/AGENTIC-S
    **Auto-skill from library README:** When user provides a library README or API docs URL, extract triggers and HARD GATEs.
    Draft verify commands and specs/ output into SKILL.md. Do NOT invent APIs not in the source.
 
-4. Add `model:` frontmatter (`haiku` | `sonnet` | `opus`) per [model-profiles.md](https://github.com/danielvm-git/bigpowers/blob/main/docs/references/model-profiles.md).
+4. Add `model:` frontmatter (`haiku` | `sonnet` | `opus`) per [model-profiles.md](../../docs/references/model-profiles.md).
 
 > **STREAM CONTINUITY** — When writing file content, output in continuous chunks of ~200 lines. Do not pause. Continue immediately until complete. If you need time, emit a placeholder comment rather than going silent.
 

package/skills/define-success/SKILL.md

@@ -1,69 +1,15 @@
-ARCHIVED: content absorbed into plan-work
-
 ---
 name: define-success
-model: sonnet
-effort: standard
-description: 'Convert an imperative task statement into explicit "step → verify: <cmd>" pairs before implementation begins. Use before plan-work when success criteria are unclear, when a task lacks verifiable checkpoints, or when user says "how will we know this is done?".'
+model: haiku
+effort: light
+description: "TOMBSTONE — renamed/merged to plan-work. This stub resolves for one release then is removed."
 ---
 
-# Define Success
-
-Transform "do X" into "step → verify: <cmd>" pairs. This is the pre-flight check before `plan-work` or `develop-tdd` — it makes success observable and removes ambiguity about when you're done.
-
-> **HARD GATE** — Success criteria must be testable and user-observable. "Code should be fast" is not testable. "Pageload latency < 2s" is testable.
-
-## Why this matters
-
-"Implement user authentication" is not a plan. It has no checkpoints, no evidence requirement, and no way to know if you're done. The Karpathy principle: every step must be independently verifiable with a runnable command. If you can't verify it, you can't prove it works.
-
-## Process
-
-### 1. Read the task statement
-
-Take the task as stated (from conversation, or from `specs/epics/ (see slice-tasks)`, or from `specs/product/SCOPE_LATEST.yaml`).
-
-### 2. Break into observable outcomes
-
-For each thing the task requires, identify:
-- The smallest unit of observable behavior that proves something works
-- The command that proves it
-
-Work at the level of behaviors (what the system does) not implementation steps (how you'll write the code).
-
-### 3. Write the pairs
-
-Format each pair as:
-```
-N. [What must be true] → verify: <runnable command>
-```
-
-Examples:
-
-```
-Task: "Add user registration to the API"
-
-1. POST /users accepts {email, name} and returns {id, email, name} → verify: curl -s -X POST http://localhost:3000/users -H 'Content-Type: application/json' -d '{"email":"test@test.com","name":"Test"}' | jq .id
-2. Duplicate email is rejected with 409 → verify: npm test -- user-registration.test.ts
-3. Missing email is rejected with 400 and descriptive error → verify: npm test -- user-validation.test.ts
-4. Password is hashed (never stored in plaintext) → verify: npm test -- user-security.test.ts
-5. All existing tests still pass → verify: npm test
-```
-
-### 4. Challenge completeness
-
-Ask yourself:
-- Is there any behavior the task requires that isn't covered by a verify step?
-- Is every verify step runnable right now without additional setup?
-- Does the final step verify the whole thing end-to-end?
-
-Add any missing pairs.
-
-### 5. Output
+# define-success (tombstoned)
 
-Present the pairs to the user and ask: "Does this capture everything the task requires? Anything missing?"
+This skill has been renamed or merged into `plan-work`. Use `plan-work` instead.
 
-Once confirmed, these pairs become the skeleton for `plan-work`'s steps. Pass them along when calling `plan-work`.
+This stub exists for one release as a transition aid, then is removed once
+`scripts/validate-tombstones.sh` flags it as expired.
 
-## Verify
 

package/skills/deploy/SKILL.md

@@ -74,7 +74,7 @@ Platform-agnostic — supports multiple deployment targets via environment varia
 |----------|---------|---------|
 | Vercel | `VERCEL_TOKEN`, `VERCEL_PROJECT_ID` | `vercel deploy --prod --token $VERCEL_TOKEN` |
 | Netlify | `NETLIFY_AUTH_TOKEN`, `NETLIFY_SITE_ID` | `netlify deploy --prod --auth $NETLIFY_AUTH_TOKEN --dir $ARTIFACT_DIR` |
-| BigBase MCP | MCP tool call | `mcp deploy` via BigBase server |
+| Platform MCP | MCP tool call | `mcp deploy` via your platform MCP server |
 | rsync/SSH | `DEPLOY_SSH_USER`, `DEPLOY_SSH_HOST`, `DEPLOY_SSH_PATH` | `rsync -avz $ARTIFACT_DIR/ $DEPLOY_SSH_USER@$DEPLOY_SSH_HOST:$DEPLOY_SSH_PATH` |
 | Custom | `DEPLOY_COMMAND` | Run any deploy command string |
 

package/skills/elaborate-spec/SKILL.md

@@ -65,7 +65,7 @@ Once the user has answered the main questions, probe for assumptions:
 
 ### 4. Synthesize and confirm
 
-Summarize your understanding in 3–5 bullet points aligned with [countable-story-format.md](https://github.com/danielvm-git/bigpowers/blob/main/docs/countable-story-format.md):
+Summarize your understanding in 3–5 bullet points aligned with [countable-story-format.md](../../docs/countable-story-format.md):
 - The problem (feeds into §1 Business narrative)
 - The solution and main flow (feeds into §5)
 - The key constraints and alternative flows (feeds into §6)