bigpowers 2.86.4 → 2.86.6

package/scripts/test-adapter-render.sh

@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+# story: e37s05
+# test-adapter-render.sh — render, path-traversal and hook-guard checks for
+# every adapter, replacing 11 hand-written test-<target>-adapter.sh scripts.
+#
+# The 11 originals were the same five assertions with the target name
+# substituted, none of them reachable from any gate, and they covered 11 of the
+# 18 adapters that define render_skill(). Their fifth assertion was pure
+# delegation to test-adapters.sh, which is already registry-driven.
+#
+# Adapters are discovered from scripts/adapters/*.sh, and each adapter's output
+# directory variable is read out of its own source (they vary: *_SKILLS,
+# *_RULES, *_EXT_DIR), so adding an adapter needs no edit here.
+#
+# Usage: bash scripts/test-adapter-render.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)); }
+
+TMP_ROOT=$(mktemp -d)
+trap 'rm -rf "$TMP_ROOT"' EXIT
+
+
+
+
+echo "=== test-adapter-render.sh ==="
+
+for adapter in scripts/adapters/*.sh; do
+  id="$(basename "$adapter" .sh)"
+
+  grep -q "^render_skill()" "$adapter" || continue
+
+  # Adapters are sourced, not executed: several (continue, omp, zed) are stubs
+  # with no stdin entrypoint and would silently no-op — and exit 0 — if run as
+  # scripts. Sourcing and calling render_skill directly is how test-adapters.sh
+  # drives them, and it exercises every adapter the same way.
+  #
+  # An adapter may read more than one output variable (gemini uses GEMINI_SKILLS
+  # and GEMINI_EXT_DIR), so point all of them at the sandbox rather than
+  # guessing which one matters.
+  mapfile -t outvars < <(grep -oE '\$\{?[A-Z][A-Z0-9_]*_(SKILLS|RULES|EXT_DIR|OUT|COMMANDS|PROMPTS|HOOKS_DIR)[:-]' "$adapter" \
+    | tr -d '${:-' | sort -u)
+  if [[ ${#outvars[@]} -eq 0 ]]; then
+    echo "  skip: $id — no output directory variable found"
+    continue
+  fi
+
+  render_into() { # $1 = destination dir, $2 = skill name
+    local dir="$1" nm="$2" v
+    local -a envs=()
+    for v in "${outvars[@]}"; do envs+=("$v=$dir"); done
+    ( set +e
+      env "${envs[@]}" bash -c '
+        source "$1" 2>/dev/null || exit 1
+        IR_NAME="$2"; IR_DESCRIPTION="test desc"; IR_BODY="test body"
+        IR_DESC_ESCAPED="test desc"; IR_MODEL=""
+        declare -f render_skill >/dev/null || exit 1
+        render_skill
+      ' _ "$PWD/$adapter" "$nm" >/dev/null 2>&1 )
+  }
+
+  dest="$TMP_ROOT/$id"
+  mkdir -p "$dest"
+  if render_into "$dest" "test-skill" && [[ -n "$(find "$dest" -mindepth 1 2>/dev/null)" ]]; then
+    pass "$id: render_skill writes an artifact from a SkillIR"
+  else
+    fail "$id: render_skill produced no artifact (${outvars[*]})"
+  fi
+
+  # Path traversal must be refused — this is the security assertion the
+  # per-target scripts carried and nothing else covers.
+  #
+  # Each adapter gets its own sandbox parent so the escape probe is isolated:
+  # ../escape from <sandbox>/out lands in <sandbox>, and a single shared parent
+  # would make one adapter's artifact fail every later adapter.
+  sandbox="$TMP_ROOT/sandbox-$id"
+  mkdir -p "$sandbox/out"
+  if render_into "$sandbox/out" "../escape"; then
+    fail "$id: accepted a path-traversal skill name"
+  else
+    pass "$id: rejects path traversal in skill name"
+  fi
+  if [[ -e "$sandbox/escape" ]]; then
+    fail "$id: path traversal escaped into $sandbox"
+  else
+    pass "$id: traversal wrote nothing outside the destination"
+  fi
+
+  # Hook bundle + guard behaviour, only where the target ships hooks.
+  hookdir="scripts/hooks/$id"
+  guard="$hookdir/pre-tool-git-guard.sh"
+  if [[ -f "$guard" ]]; then
+    out="$(echo '{"tool_input":{"command":"git push --force origin main"}}' \
+      | bash "$guard" 2>/dev/null || true)"
+    grep -q 'block' <<<"$out" \
+      && pass "$id: pre-tool guard blocks a dangerous git command" \
+      || fail "$id: pre-tool guard did not block git push --force"
+  fi
+done
+
+# The generic adapter-contract runner stays the source of truth for
+# render_skill/wire_context wiring; assert it is green rather than restating it.
+if bash scripts/test-adapters.sh 2>&1 | grep -q '0 failed'; then
+  pass "test-adapters.sh reports 0 failed across the registry"
+else
+  fail "test-adapters.sh reported failures"
+fi
+
+echo "test-adapter-render: $PASS passed, $FAIL failed"
+[[ "$FAIL" -eq 0 ]] || exit 1

package/scripts/test-adapters.sh

@@ -40,8 +40,13 @@ test_adapter() {
   [[ -f "$adapter_file" ]] || { ta_fail "$id: adapter missing"; return; }
   ta_pass "$id: exists"
 
+  # </dev/null is load-bearing. The caller feeds the target list into a
+  # `while read` loop, so a sourced adapter inherits it on fd 0 — and every
+  # adapter ends in a main block that reads stdin. agy.sh was consuming the
+  # remaining target list and running render_skill with an empty IR_NAME, so
+  # this "registry-driven" runner silently tested exactly one adapter.
   # shellcheck source=/dev/null
-  source "$adapter_file" 2>/dev/null && ta_pass "$id: sourceable" || { ta_fail "$id: source error"; return; }
+  source "$adapter_file" </dev/null 2>/dev/null && ta_pass "$id: sourceable" || { ta_fail "$id: source error"; return; }
 
   local has_skill has_context mode
   has_skill=$(yq -r ".targets[] | select(.id==\"$id\") | .skill != null" "$TARGETS_FILE")
@@ -62,11 +67,13 @@ test_adapter() {
     # to print 5 PASS lines and report 4. Capture the status, tally in-process.
     if (
       cd "$TA_TMPDIR"
+      # </dev/null for the same reason as above — this subshell also inherits
+      # the caller's target list on fd 0.
       # shellcheck source=/dev/null
-      source "$adapter_file"
+      source "$adapter_file" </dev/null
       wire_context >/dev/null 2>&1 || true
       wire_context >/dev/null 2>&1
-    ); then
+    ) </dev/null; then
       ta_pass "$id: idempotent wire_context"
     else
       ta_fail "$id: wire_context failed"

package/scripts/test-install-hub.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# story: e37s05
+# test-install-hub.sh — one registry-driven check of install-hub wiring for
+# every target, replacing 14 hand-written test-<target>-hub.sh scripts.
+#
+# Those 14 were line-for-line identical apart from three substituted tokens, and
+# none of them were reachable from any gate. They also covered only 14 of the 18
+# targets install.sh actually defines, so antigravity, claude, cursor and pi had
+# no hub coverage at all.
+#
+# Targets are discovered from install.sh's own install_<id>() definitions —
+# the authoritative statement of what the hub installs — rather than from a
+# table that would drift. Each target's display label is read out of its
+# install function body, so adding a target needs no edit here.
+#
+# Usage: bash scripts/test-install-hub.sh [--self-test]
+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)); }
+
+INSTALL_SH="scripts/install.sh"
+HELPERS_JS="scripts/lib/install-helpers.js"
+SETUP_JS="bin/setup.js"
+TARGETS_YAML="scripts/targets.yaml"
+INSTALL_SRC="$INSTALL_SH scripts/lib/install-targets-a.sh scripts/lib/install-targets-b.sh scripts/lib/install-targets-c.sh scripts/lib/install-targets-d.sh"
+
+# setup.js registers Kilo under a shortened id; everything else matches 1:1.
+setup_id_for() { [[ "$1" == "kilocode" ]] && echo "kilo" || echo "$1"; }
+
+discover_targets() {
+  # shellcheck disable=SC2086
+  grep -hoE "^install_[a-z0-9]+\(\)" $INSTALL_SRC 2>/dev/null \
+    | sed 's/^install_//; s/()//' | sort -u
+}
+
+# Pull `echo "Label → ..."` out of the target's own install function body.
+label_for() {
+  local id="$1"
+  # shellcheck disable=SC2086
+  # Strip around the arrow with sub() rather than substr()/RLENGTH — the arrow
+  # is multi-byte UTF-8 and byte-indexed slicing corrupts the trailing char.
+  awk -v fn="install_${id}()" '
+    $0 ~ "^" fn { inside = 1; next }
+    inside && /^}/ { exit }
+    inside && /echo "[^"]* →/ {
+      line = $0
+      sub(/^[^"]*"/, "", line)
+      sub(/ →.*$/, "", line)
+      print line; exit
+    }
+  ' $INSTALL_SRC 2>/dev/null | head -1
+}
+
+# Returns the delegate id when install_<id>() does nothing but call another
+# install_<other>, otherwise empty.
+alias_target_for() {
+  local id="$1"
+  # shellcheck disable=SC2086
+  awk -v fn="install_${id}()" '
+    $0 ~ "^" fn { inside = 1; body = ""; next }
+    inside && /^}/ { exit }
+    inside {
+      line = $0
+      gsub(/^[[:space:]]+|[[:space:]]+$/, "", line)
+      if (line != "") body = body line "\n"
+    }
+    END {
+      n = split(body, lines, "\n")
+      count = 0; only = ""
+      for (i = 1; i <= n; i++) if (lines[i] != "") { count++; only = lines[i] }
+      if (count == 1 && only ~ /^install_[a-z0-9]+$/) { sub(/^install_/, "", only); print only }
+    }
+  ' $INSTALL_SRC 2>/dev/null | head -1
+}
+
+echo "=== test-install-hub.sh ==="
+
+TARGETS=$(discover_targets)
+[[ -n "$TARGETS" ]] || { fail "no install_<id>() functions discovered"; echo "test-install-hub: $PASS passed, $FAIL failed"; exit 1; }
+echo "Discovered $(wc -w <<<"$TARGETS" | tr -d ' ') install targets"
+
+DRY_OUT="$(bash "$INSTALL_SH" --dry-run 2>&1 || true)"
+DRY_UNINSTALL="$(bash "$INSTALL_SH" --dry-run --uninstall 2>&1 || true)"
+SETUP_IDS="$(sed -n '/SUPPORTED_IDS = new Set/,/);/p' "$SETUP_JS")"
+
+for id in $TARGETS; do
+  # shellcheck disable=SC2086
+  grep -qE "^uninstall_${id}\(\)" $INSTALL_SRC \
+    && pass "$id: uninstall_${id}() defined" \
+    || fail "$id: uninstall_${id}() missing"
+
+  # Some targets are pure aliases (install_antigravity just calls install_agy).
+  # They own no label; the delegate's label is asserted on its own pass.
+  alias_of="$(alias_target_for "$id")"
+  label="$(label_for "$id")"
+  if [[ -z "$label" && -n "$alias_of" ]]; then
+    pass "$id: alias of $alias_of (label asserted there)"
+  elif [[ -z "$label" ]]; then
+    fail "$id: no 'Label →' line found inside install_${id}()"
+  else
+    grep -qF "$label →" <<<"$DRY_OUT" \
+      && pass "$id: dry-run shows '$label'" \
+      || fail "$id: dry-run missing '$label' section"
+    grep -qF "$label →" <<<"$DRY_UNINSTALL" \
+      && pass "$id: dry-run --uninstall shows '$label'" \
+      || fail "$id: dry-run --uninstall missing '$label' section"
+  fi
+
+  grep -q "case '${id}'" "$HELPERS_JS" \
+    && pass "$id: install-helpers case" \
+    || fail "$id: install-helpers missing case '${id}'"
+
+  sid="$(setup_id_for "$id")"
+  grep -q "'${sid}'" <<<"$SETUP_IDS" \
+    && pass "$id: setup.js SUPPORTED_IDS carries '${sid}'" \
+    || fail "$id: setup.js SUPPORTED_IDS missing '${sid}'"
+done
+
+# Global syntax gates — previously repeated in all 14 scripts.
+bash -n "$INSTALL_SH" && pass "bash -n install.sh" || fail "bash -n install.sh"
+node --check "$HELPERS_JS" >/dev/null 2>&1 && pass "node --check install-helpers.js" || fail "node --check install-helpers.js"
+node --check "$SETUP_JS" >/dev/null 2>&1 && pass "node --check setup.js" || fail "node --check setup.js"
+grep -q "SUPPORTED_IDS = new Set" "$SETUP_JS" && pass "setup.js defines SUPPORTED_IDS" || fail "setup.js missing SUPPORTED_IDS"
+
+# Registry coverage is reported, not enforced: copilot, opencode, claude and
+# antigravity ship install functions but have no targets.yaml row today.
+# Failing on that here would block unrelated work; it is tracked separately.
+for id in $TARGETS; do
+  grep -q "id: ${id}$" "$TARGETS_YAML" || echo "  note: $id installs but has no targets.yaml row"
+done
+
+echo "test-install-hub: $PASS passed, $FAIL failed"
+[[ "$FAIL" -eq 0 ]] || exit 1

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/commit-message/REFERENCE.md

@@ -78,4 +78,4 @@ This table reflects the **out-of-the-box** behavior of `semantic-release` using
 
 - [Conventional Commits — specification](https://www.conventionalcommits.org/en/v1.0.0/#specification)
 - [semantic-release — README (commit format & flow)](https://github.com/semantic-release/semantic-release#commit-message-format)
-- Fork pointer: [semantic-release-baby](https://github.com/danielvm-git/semantic-release-baby) (automation and docs align with upstream semantic-release)
+- Automation and docs align with [semantic-release](https://github.com/semantic-release/semantic-release) upstream; a fork may be substituted without changing this guidance.

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)

package/skills/evolve-skill/REFERENCE.md

@@ -9,4 +9,4 @@
 **Evidence:** path/to/benchmark-report.md
 ```
 
-Benchmark repo: `bigpowers-benchmark` — resolve the local clone on this machine (e.g. `gh repo clone danielvm-git/bigpowers-benchmark` if absent); never assume a hard-coded absolute path.
+Benchmark repo: `bigpowers-benchmark` — resolve the local clone on this machine; clone it from wherever your fork lives if absent. Never assume a hard-coded absolute path or a specific owner.