rsc-universal 0.1.1

package/skills/seo-geo/scripts/verify.sh

@@ -0,0 +1,236 @@
+#!/usr/bin/env bash
+# verify.sh — seo-geo on-page artifact gate (read-only).
+#
+# Usage:
+#   bash scripts/verify.sh [TARGET]
+#     TARGET = a file or directory containing the produced artifacts
+#              (HTML head, JSON-LD blocks, an optional robots.txt).
+#              Defaults to the current directory.
+#
+# What it checks across *.html *.htm *.json *.jsonld and robots.txt under TARGET:
+#   (a) NO DEAD schema @type appears (FAQPage, Course, ClaimReview,
+#       SpecialAnnouncement, VehicleListing, EstimatedSalary, LearningVideo) —
+#       the highest-value guard against shipping dead markup.
+#   (b) Each .json/.jsonld parses as valid JSON and carries @context + @type
+#       (when a JSON parser is available; skipped with a warning otherwise).
+#   (c) <title> text ≤ 60 chars; meta description ≤ 160 chars; exactly one <h1>.
+#   (d) If a robots.txt is present, it does not Disallow a search/citation bot
+#       (Googlebot, OAI-SearchBot, PerplexityBot, Claude-SearchBot) at the root.
+#
+# Read-only: reads files only, no writes, no network, no installs. Safe to re-run.
+# Exits 0 on an empty/clean target (no false failure); non-zero on any violation.
+#
+# Portability: stock macOS bash 3.2. No `mapfile`; no empty-array expansion under
+# set -u. `set -e` intentionally OFF (each check owns its exit code).
+
+set -u
+
+if [ -t 1 ] && command -v tput >/dev/null 2>&1; then
+  RED="$(tput setaf 1)"; GREEN="$(tput setaf 2)"; YELLOW="$(tput setaf 3)"; RESET="$(tput sgr0)"
+else
+  RED=""; GREEN=""; YELLOW=""; RESET=""
+fi
+
+failures=0
+fail() { printf '%s\n' "${RED}FAIL: $1${RESET}"; failures=$((failures + 1)); }
+ok()   { printf '%s\n' "${GREEN}OK: $1${RESET}"; }
+warn() { printf '%s\n' "${YELLOW}SKIP: $1${RESET}"; }
+
+TARGET="${1:-.}"
+if [ ! -e "$TARGET" ]; then
+  fail "target not found: $TARGET"
+  exit 1
+fi
+
+# --- collect candidate files (portable; no mapfile) ------------------------
+markup_files=""
+robots_files=""
+json_files=""
+if [ -d "$TARGET" ]; then
+  while IFS= read -r f; do markup_files="${markup_files}${f}
+"; done <<EOF
+$(find "$TARGET" -type f \( -name '*.html' -o -name '*.htm' \) 2>/dev/null)
+EOF
+  while IFS= read -r f; do json_files="${json_files}${f}
+"; done <<EOF
+$(find "$TARGET" -type f \( -name '*.json' -o -name '*.jsonld' \) 2>/dev/null)
+EOF
+  while IFS= read -r f; do robots_files="${robots_files}${f}
+"; done <<EOF
+$(find "$TARGET" -type f -name 'robots.txt' 2>/dev/null)
+EOF
+else
+  case "$TARGET" in
+    *.html|*.htm) markup_files="$TARGET" ;;
+    *.json|*.jsonld) json_files="$TARGET" ;;
+    *robots.txt) robots_files="$TARGET" ;;
+    *) markup_files="$TARGET" ;;  # treat unknown single file as markup-bearing
+  esac
+fi
+
+# Strip blank lines.
+markup_files="$(printf '%s\n' "$markup_files" | grep -v '^[[:space:]]*$' || true)"
+json_files="$(printf '%s\n' "$json_files" | grep -v '^[[:space:]]*$' || true)"
+robots_files="$(printf '%s\n' "$robots_files" | grep -v '^[[:space:]]*$' || true)"
+
+scanned=0
+
+DEAD_TYPES='FAQPage Course ClaimReview SpecialAnnouncement VehicleListing EstimatedSalary LearningVideo'
+
+# --- (a) dead schema types, across markup + json ---------------------------
+all_for_dead="$(printf '%s\n%s\n' "$markup_files" "$json_files" | grep -v '^[[:space:]]*$' || true)"
+if [ -n "$all_for_dead" ]; then
+  printf '%s\n' "$all_for_dead" | while IFS= read -r f; do
+    [ -f "$f" ] || continue
+    for t in $DEAD_TYPES; do
+      # match "@type": "FAQPage" with flexible spacing/quoting
+      if grep -Eq "@type[\"']?[[:space:]]*:[[:space:]]*[\"']?$t([\"',}[:space:]]|$)" "$f"; then
+        printf 'DEAD %s %s\n' "$t" "$f"
+      fi
+    done
+  done > /tmp/seo_geo_dead.$$  2>/dev/null || true
+  if [ -s /tmp/seo_geo_dead.$$ ]; then
+    while IFS= read -r line; do
+      t="$(printf '%s' "$line" | awk '{print $2}')"
+      f="$(printf '%s' "$line" | cut -d' ' -f3-)"
+      fail "dead schema @type '$t' in $f — deprecated/retired, dead markup"
+    done < /tmp/seo_geo_dead.$$
+  fi
+  rm -f /tmp/seo_geo_dead.$$ 2>/dev/null || true
+fi
+
+# --- (b) JSON-LD validity + @context/@type --------------------------------
+json_parser=""
+if command -v python3 >/dev/null 2>&1; then json_parser="python3"; fi
+
+if [ -n "$json_files" ]; then
+  printf '%s\n' "$json_files" | while IFS= read -r f; do
+    [ -f "$f" ] || continue
+    scanned=1
+    if [ -n "$json_parser" ]; then
+      python3 - "$f" <<'PY'
+import json, sys
+p = sys.argv[1]
+try:
+    with open(p) as fh:
+        data = json.load(fh)
+except Exception:
+    sys.exit(3)
+def has(d):
+    if isinstance(d, dict):
+        return ("@context" in d and "@type" in d) or any(has(v) for v in d.values())
+    if isinstance(d, list):
+        return any(has(x) for x in d)
+    return False
+sys.exit(0 if has(data) else 4)
+PY
+      rc=$?
+      if [ "$rc" -eq 3 ]; then echo "JSONERR-PARSE $f"; elif [ "$rc" -eq 4 ]; then echo "JSONERR-CTX $f"; fi
+    fi
+  done > /tmp/seo_geo_json.$$ 2>/dev/null || true
+  if [ -z "$json_parser" ]; then
+    warn "python3 not found — skipping JSON-LD validity/@context check"
+  fi
+  if [ -s /tmp/seo_geo_json.$$ ]; then
+    while IFS= read -r line; do
+      kind="$(printf '%s' "$line" | awk '{print $1}')"
+      f="$(printf '%s' "$line" | cut -d' ' -f2-)"
+      case "$kind" in
+        JSONERR-PARSE) fail "invalid JSON in $f" ;;
+        JSONERR-CTX)   fail "JSON-LD missing @context/@type in $f" ;;
+      esac
+    done < /tmp/seo_geo_json.$$
+  fi
+  rm -f /tmp/seo_geo_json.$$ 2>/dev/null || true
+fi
+
+# --- (c) head discipline: title<=60, meta desc<=160, exactly one h1 --------
+if [ -n "$markup_files" ]; then
+  printf '%s\n' "$markup_files" | while IFS= read -r f; do
+    [ -f "$f" ] || continue
+    # title length
+    title="$(tr '\n' ' ' < "$f" | grep -oiE '<title>[^<]*</title>' | head -1 | sed -E 's/<\/?title>//gI')"
+    if [ -n "$title" ]; then
+      tlen=$(printf '%s' "$title" | wc -c | tr -d ' ')
+      if [ "$tlen" -gt 60 ]; then echo "TITLE $tlen $f"; fi
+    fi
+    # meta description length
+    desc="$(tr '\n' ' ' < "$f" | grep -oiE "<meta[^>]+name=[\"']description[\"'][^>]*>" | head -1 | grep -oiE "content=[\"'][^\"']*[\"']" | head -1 | sed -E "s/content=[\"']//I; s/[\"']$//")"
+    if [ -n "$desc" ]; then
+      dlen=$(printf '%s' "$desc" | wc -c | tr -d ' ')
+      if [ "$dlen" -gt 160 ]; then echo "DESC $dlen $f"; fi
+    fi
+    # h1 count
+    h1c="$(tr '\n' ' ' < "$f" | grep -oiE '<h1[ >]' | wc -l | tr -d ' ')"
+    if [ "$h1c" != "0" ] && [ "$h1c" != "1" ]; then echo "H1 $h1c $f"; fi
+  done > /tmp/seo_geo_head.$$ 2>/dev/null || true
+  if [ -s /tmp/seo_geo_head.$$ ]; then
+    while IFS= read -r line; do
+      kind="$(printf '%s' "$line" | awk '{print $1}')"
+      n="$(printf '%s' "$line" | awk '{print $2}')"
+      f="$(printf '%s' "$line" | cut -d' ' -f3-)"
+      case "$kind" in
+        TITLE) fail "<title> is $n chars (>60) in $f" ;;
+        DESC)  fail "meta description is $n chars (>160) in $f" ;;
+        H1)    fail "$n <h1> elements (expected exactly 1) in $f" ;;
+      esac
+    done < /tmp/seo_geo_head.$$
+  fi
+  rm -f /tmp/seo_geo_head.$$ 2>/dev/null || true
+fi
+
+# --- (d) robots.txt not self-blocking search/citation bots -----------------
+SEARCH_BOTS='Googlebot OAI-SearchBot PerplexityBot Claude-SearchBot'
+if [ -n "$robots_files" ]; then
+  printf '%s\n' "$robots_files" | while IFS= read -r rf; do
+    [ -f "$rf" ] || continue
+    # Walk groups: a User-agent line opens a group; collect bots until a Disallow: /.
+    awk -v bots="$SEARCH_BOTS" '
+      function lc(s){return tolower(s)}
+      BEGIN{ n=split(bots,B," "); for(i=1;i<=n;i++) want[lc(B[i])]=B[i]; ng=0 }
+      {
+        line=$0
+        sub(/#.*/,"",line)
+        gsub(/\r/,"",line)
+        if (line ~ /^[[:space:]]*[Uu]ser-agent[[:space:]]*:/) {
+          if (!inblock){ delete cur; cc=0; inblock=1 }
+          ua=line; sub(/^[^:]*:[[:space:]]*/,"",ua); gsub(/[[:space:]]+$/,"",ua)
+          cur[++cc]=ua
+          next
+        }
+        if (line ~ /^[[:space:]]*[Dd]isallow[[:space:]]*:/) {
+          val=line; sub(/^[^:]*:[[:space:]]*/,"",val); gsub(/[[:space:]]+$/,"",val)
+          if (val=="/"){ for(i=1;i<=cc;i++){ b=lc(cur[i]); if (b in want) print want[b] } }
+          next
+        }
+        if (line ~ /[^[:space:]]/ && line !~ /^[[:space:]]*[Aa]llow[[:space:]]*:/ && line !~ /^[[:space:]]*[Ss]itemap[[:space:]]*:/ && line !~ /^[[:space:]]*[Cc]rawl-delay/) {
+          inblock=0
+        }
+      }
+    ' "$rf" | sort -u | while IFS= read -r bot; do
+      [ -n "$bot" ] && echo "ROBOTS $bot $rf"
+    done
+  done > /tmp/seo_geo_robots.$$ 2>/dev/null || true
+  if [ -s /tmp/seo_geo_robots.$$ ]; then
+    while IFS= read -r line; do
+      bot="$(printf '%s' "$line" | awk '{print $2}')"
+      f="$(printf '%s' "$line" | cut -d' ' -f3-)"
+      fail "robots.txt blocks search/citation bot '$bot' (Disallow: /) in $f — removes you from that engine's results/citations"
+    done < /tmp/seo_geo_robots.$$
+  fi
+  rm -f /tmp/seo_geo_robots.$$ 2>/dev/null || true
+fi
+
+# --- verdict ---------------------------------------------------------------
+if [ -z "$markup_files" ] && [ -z "$json_files" ] && [ -z "$robots_files" ]; then
+  ok "no SEO artifacts under '$TARGET' — nothing to lint"
+  exit 0
+fi
+
+if [ "$failures" -eq 0 ]; then
+  ok "seo-geo artifacts pass: no dead schema, valid JSON-LD, head limits, robots not self-blocking"
+  exit 0
+fi
+
+printf '%s\n' "${RED}${failures} violation(s) — fix before shipping.${RESET}"
+exit 1

package/skills/ship/SKILL.md

@@ -0,0 +1,258 @@
+---
+name: ship
+description: "Use when the work is complete and verified and it is time to CLOSE the development branch — the final phase of the rsc SDD chain, after review approves the diff. Triggers: 'ship it', 'close the branch', 'open the PR', 'merge this', 'merge into main', 'create the pull request', 'how do I land this work', 'finish this feature', 'haz el merge', 'abre el PR', 'cierra la rama', 'súbelo a main', 'clean up the branch', 'I'm done, what now'. Presents exactly three landing options (direct merge / pull request / park-or-discard) matched to the workflow, runs the pre-ship safety checklist (review verdict, clean tree, rebased, no secrets), and writes the commit and PR. HARD RULE: git authorship is ALWAYS Eric — never Claude. No Co-Authored-By Claude, no 'generated with' footer in any commit or PR body. NOT running lint/type/test (that is verify), NOT reading the diff adversarially (that is review), NOT the deploy/release mechanics to a server (that is deployment). Honors the harness accompaniment dial."
+tags: [sdd, ship, release, pr]
+recommends: []
+profiles: [core, full]
+origin: risco
+---
+
+# Ship — close the development branch
+
+Ship is the **last gate** of the rsc SDD chain: `constitution → specify → clarify → plan → tasks → analyze → implement → verify → review → **ship**`. Everything upstream proved the work is *correct* and *green*; ship is the act of **landing it** — turning an approved branch into merged history, a pull request, or a clean parked branch — without breaking the trunk and without ever forging the author.
+
+This skill owns one decision and its safe execution: **how does this work integrate?** It does not write code, run test gates, or read the diff for defects — those phases already happened. It takes a diff that *earned* its verdict and gets it home.
+
+## The hard rule: git authorship is Eric, never Claude
+
+> **Every commit and every PR ships under Eric's name. No `Co-Authored-By: Claude`. No `Co-Authored-By` for any AI. No "🤖 Generated with Claude Code" footer. No "made by an agent" line in the PR body. Nothing that attributes the work to a tool.**
+
+This is non-negotiable and it is the reason this skill exists as its own phase. The work is Eric's; the agent is a tool he used, like an editor or a compiler. You do not credit the compiler in the commit message.
+
+Concretely, before any commit or PR:
+
+- **Never** append a trailer, footer, or body line crediting Claude, an AI, an agent, or "Claude Code".
+- **Never** pass `--author` to set a non-Eric author. The repo's configured `user.name` / `user.email` (Eric's) is the author and committer.
+- If `git config user.email` is unset or clearly not Eric's, **stop and ask** which identity to commit under — do not guess, and do not substitute an agent identity.
+- If you find a Claude/AI trailer in a commit you are about to push (e.g. left over from an upstream tool), **strip it** before the branch lands.
+
+Verify it after writing the commit:
+
+```bash
+git log -1 --format='%an <%ae>%n%n%b' | grep -iE 'co-authored-by.*(claude|anthropic|ai)|generated with|claude code' \
+  && echo "AUTHORSHIP VIOLATION — strip the trailer before shipping" \
+  || echo "authorship clean"
+```
+
+A non-empty match is a blocker. Amend the commit and re-check before the branch goes anywhere.
+
+## Read these first
+
+1. `02-DOCS/wiki/harness/user-profile.md` — the **accompaniment dial** (L0..L3). It sets how much you narrate and how you frame the three options, never whether you run the safety checklist. See "Accompaniment dial" below.
+2. The **review verdict** for this branch — ship runs only on `APPROVE` or `APPROVE WITH NITS`. If the last verdict was `CHANGES REQUESTED`, the loop goes back to `implement`, not forward to ship.
+3. `02-DOCS/wiki/sdd/decisions.md` and the spec/plan slug — so the commit message and PR body describe *what shipped against which spec*, not a vague "various changes".
+
+If there is no review verdict on record, say so and treat it as a red flag — do not ship a diff that skipped the `review` phase. Offer to run review first.
+
+## When to use / When NOT to use
+
+Use when:
+
+- A branch has passed `verify` (green gates) and `review` (approved), and the work needs to land.
+- The user says "ship it", "merge this", "open the PR", "close the branch", "I'm done" — and the code is actually ready.
+- A finished branch needs to be parked or discarded cleanly (abandoned spike, superseded approach).
+
+Do NOT use when (route elsewhere):
+
+- Lint / type-check / tests / audit still need to run and go green → that is the **verify** phase (`../verify/SKILL.md`). Ship assumes green.
+- The diff hasn't been read for defects, or a review comment needs processing → that is **review** (`../review/SKILL.md`).
+- The merge is clean but now it must reach a *server* — provisioning, release pipeline, environment promotion, rollback → that is **deployment** (`../deployment/SKILL.md`). Ship lands the code in the repo; deployment puts it in production.
+- You need to *create* the isolated branch/worktree to start work → that is **worktrees** (`../worktrees/SKILL.md`). Ship is the close, not the open.
+
+## The pre-ship safety checklist
+
+Run this before presenting the landing options. Any unchecked item is a stop — surface it, don't ship around it.
+
+- [ ] **Review verdict is APPROVE / APPROVE WITH NITS** (not CHANGES REQUESTED, not absent).
+- [ ] **Working tree is clean** — `git status --short` is empty. No stray edits sneaking into the merge.
+- [ ] **On a feature branch, not the trunk** — `git rev-parse --abbrev-ref HEAD` is not `main`/`master`. If work landed directly on the trunk, that is its own problem; flag it.
+- [ ] **Rebased / up to date with the base** — branch is on top of latest `main`; conflicts resolved locally, not punted to the merge.
+- [ ] **No secrets in the diff** — scan the staged/branch diff for keys, tokens, `.env` values (`git diff main... | grep -iE 'api[_-]?key|secret|password|token|BEGIN .*PRIVATE KEY'`). A hit is a blocker.
+- [ ] **Authorship is Eric** — `git config user.email` is Eric's; no AI trailer in any commit on the branch (run the grep above across `main..HEAD`).
+- [ ] **Commit history is intelligible** — squashed or organized so the history reads as deliberate, not "wip wip fix fix".
+
+```bash
+# one-shot pre-ship snapshot (read-only)
+echo "branch:   $(git rev-parse --abbrev-ref HEAD)"
+echo "clean?:   $([ -z "$(git status --short)" ] && echo yes || echo NO-dirty)"
+echo "behind:   $(git rev-list --count HEAD..origin/main 2>/dev/null || echo '?') commits behind origin/main"
+git log main..HEAD --format='%an <%ae>' | sort -u   # authors on this branch — expect only Eric
+git diff main...HEAD | grep -icE 'api[_-]?key|secret|password|token|BEGIN .*PRIVATE KEY' \
+  | sed 's/^/secret-hits: /'
+```
+
+## The three landing options — always present exactly three
+
+This mirrors the harness "siempre 3 opciones" pattern. Gather the one fact that changes the answer (does this repo use PRs / require review on `main`?), then present **exactly three** with an honest recommendation matched to the workflow and the accompaniment level.
+
+| Option | What it does | Choose it when |
+| --- | --- | --- |
+| **1. Direct merge to trunk** | Fast-forward or `--no-ff` merge into `main`, push, delete the branch | Solo repo or trusted-trunk workflow; `main` is not protected; you are the only reviewer and review already passed |
+| **2. Pull request** | Push the branch, open a PR with a spec-linked body, let CI / a human gate the merge | `main` is protected; a team or CI must sign off; you want the change reviewable in the forge even if you self-merge |
+| **3. Park or discard** | Keep the branch un-merged (park) or delete it (discard) | The approach was superseded, the spike answered its question, or the work is paused — it should not land |
+
+Recommend based on repo signals: protected `main` or an existing PR culture (look for `.github/`, prior PRs via `gh pr list`) → recommend **option 2**. A solo project with no protection and a passed review → **option 1** is honest and faster. Never default to a PR ceremony the repo doesn't use, and never force-merge a repo that gates `main`.
+
+### Delivery strategy from SDD config
+
+Read `02-DOCS/wiki/sdd/config.yaml` and the `Review Workload Forecast` in the plan if present.
+
+- `single-pr` keeps option 2 as one PR.
+- `ask-on-risk` pauses when the forecast exceeds the review budget and asks before landing a large diff.
+- `autochain` uses stacked PRs when tasks are reviewable in dependency order.
+- `exception` permits a larger single PR only when the user explicitly accepts the review risk.
+
+Stacked PR / feature-track support still fits inside the three landing options: it is a shape of **option 2**, not a fourth option. Use a feature-track branch when several stacked PRs should integrate together before trunk.
+
+## Executing each option
+
+### Option 1 — direct merge
+
+```bash
+git switch main && git pull --ff-only
+git merge --no-ff feature/<slug> -m "feat: <what shipped> (<spec-slug>)"   # no AI trailer
+git push origin main
+git branch -d feature/<slug>          # delete merged branch; -D only if intentionally dropping unmerged work
+git push origin --delete feature/<slug> 2>/dev/null || true
+```
+
+Use `--no-ff` so the feature is one legible merge commit tied to the spec. Confirm the trunk still builds after the merge if the repo has a local gate (defer the actual run to `verify`).
+
+### Option 2 — pull request
+
+Write the **commit(s)** clean, push, then open the PR with `gh`. The PR body links the spec/plan and lists what shipped — **and carries no AI attribution.**
+
+```bash
+git push -u origin feature/<slug>
+gh pr create \
+  --title "feat: <what shipped> (<spec-slug>)" \
+  --body-file /tmp/ship-pr-body.md          # body authored per the template below — NO AI footer
+```
+
+PR body shape (no generated-with line, ever):
+
+```markdown
+## What
+
+<one-paragraph summary of the change, in plain terms>
+
+## Why
+
+Implements `02-DOCS/wiki/sdd/specs/<slug>.md`. <the user-facing reason>
+
+## How
+
+- <key implementation point>
+- <key implementation point>
+
+## Verification
+
+- `verify` phase: lint / types / tests green (see the verification record).
+- Acceptance criteria from the spec: all met.
+- Review verdict: APPROVE.
+```
+
+Then either let the gate run (team/CI) or self-merge once green: `gh pr merge --squash --delete-branch` (or `--merge` to preserve the history). Squash when the branch history is noisy; preserve when each commit is meaningful.
+
+For stacked PRs, create each PR against the previous branch or against a feature-track branch, with bodies that name their dependency:
+
+```markdown
+Depends on: <previous PR or feature-track branch>
+Part of: <spec-slug>
+```
+
+Never stack to hide review risk. Stack because each slice is independently reviewable and follows the task dependency order.
+
+### Option 3 — park or discard
+
+- **Park:** leave the branch, push it so it's not lost (`git push -u origin feature/<slug>`), and log *why it's parked* to `02-DOCS/wiki/sdd/decisions.md`. Do not merge.
+- **Discard:** deletion is **destructive** — require an explicit confirmation that quotes the branch name (e.g. the literal `yes, delete feature/<slug>`) before `git branch -D`. Anything ambiguous means keep it. Log the discard and the reason so the dead-end is remembered, not re-attempted.
+
+## Commit message discipline
+
+The commit is the durable record. Make it describe the change and tie it to the spec — and keep it Eric's.
+
+- **Subject:** `type: imperative summary (<spec-slug>)` — `feat:`, `fix:`, `refactor:`, etc. Under ~72 chars.
+- **Body:** *why*, not a restatement of the diff. Reference the spec slug and any decision logged in `decisions.md`.
+- **Footer:** issue/PR refs only. **No `Co-Authored-By` for any AI. No "generated with" line.** This is where the violation usually sneaks in — leave the footer clean.
+
+## Accompaniment dial (L0..L3)
+
+Read the level from `02-DOCS/wiki/harness/user-profile.md`. It changes the narration, **never** the safety checklist or the authorship rule.
+
+- **L0** — run the checklist silently, state the recommended option in one line, execute on a yes. `Clean, rebased, authorship Eric. Recommend PR (main is protected). Open it?`
+- **L1** — the three options as one-liners with the recommendation and its *why*.
+- **L2** — the full options table, the checklist results, and why the recommended option fits this repo's workflow.
+- **L3** — the above plus teaching: what a fast-forward vs `--no-ff` merge does to history, why a protected `main` wants a PR, what squashing trades away — framed for a non-technical owner ("a PR is asking permission before changing the shared copy"). Still never skips a checklist item.
+
+When no profile exists, default to L2 and proceed — don't stall the ship to ask for a dial setting.
+
+## Anti-patterns → STOP
+
+| Rationalization | Reality |
+| --- | --- |
+| "I'll add `Co-Authored-By: Claude` to be transparent" | No. The work is Eric's. No AI trailer, ever — this is the whole point of the phase. |
+| "A 'Generated with Claude Code' footer is just polite" | It forges the record. Strip it. The commit credits Eric and only Eric. |
+| "Review didn't formally approve but it's obviously fine" | No verdict = not ready. Ship runs on APPROVE only. Route back to review. |
+| "The tree has a couple of stray edits, they're harmless" | A dirty tree means the merge is not the reviewed diff. Clean it or stash it first. |
+| "`main` is protected but I'll just force-merge, I'm sure" | Protected means PR. Don't bypass the gate the repo deliberately set. |
+| "I'll rebase and resolve conflicts during the merge" | Resolve before. A conflicted merge commit hides what actually shipped. |
+| "This branch is dead, I'll just delete it" | Discard is destructive — confirm with the quoted branch name and log why first. |
+| "Squash everything, history doesn't matter" | Squash noise, preserve meaning. The history is the next reader's spec. |
+| "There's a key in the diff but it's a test key" | A secret in the diff is a blocker regardless. Pull it out before landing. |
+
+## Red flags — abort and re-plan
+
+- Any commit on the branch carries an AI `Co-Authored-By` or "generated with" line → strip it; do not push until clean.
+- `git config user.email` is unset or not Eric's → stop and ask which identity to commit under.
+- No review verdict, or the last verdict was `CHANGES REQUESTED` → not shippable; route to review/implement.
+- The branch is `main`/`master` itself → work landed on the trunk directly; flag it, don't paper over it.
+- A secret matches in the branch diff → blocker; remove it (and rotate it if it was ever pushed).
+
+## Where this writes
+
+Ship is mostly git actions, but the outcome is recorded so the knowledge model stays whole:
+
+- **The landing decision** (which of the three options, and why) → append to `02-DOCS/wiki/sdd/decisions.md`, the same append-only log `implement`, `verify`, and `review` write to. Parks and discards are logged with their reason so dead-ends aren't re-walked.
+- A **shipped feature** flips its spec under `02-DOCS/wiki/sdd/specs/<slug>.md` to a shipped state (note the merge commit / PR). The harness owns the wiki; ship just keeps the `sdd/` rows in the root `CLAUDE.md` `## Knowledge map` honest.
+- An **archive bundle** closes the loop under `02-DOCS/wiki/sdd/archive/<slug>/`:
+  - `final-report.md` — what shipped, why, landing decision, links.
+  - `apply-progress.md` — copy or link to `progress/<slug>.md`.
+  - `verification.md` — copy or link to the verification record.
+  - `review.md` — review verdict and nits.
+  - `state.yaml` — `shipped`, `parked` or `discarded`, PR/merge refs, date.
+
+Archive after option 1/2 lands, and also after option 3 parks/discards so paused or abandoned work is remembered.
+
+## Result envelope
+
+End with:
+
+```json result-envelope
+{
+  "status": "complete",
+  "executive_summary": "Branch landed/parked/discarded and SDD archive updated.",
+  "artifact": "02-DOCS/wiki/sdd/archive/<slug>/final-report.md",
+  "next_recommended": "none",
+  "risk": "low|medium|high",
+  "skill_resolution": {
+    "used": ["ship"],
+    "missing": [],
+    "fallback": [],
+    "compact_rules": ["Keep exactly three landing options.", "Archive the final state."]
+  },
+  "evidence": ["review verdict", "verification record", "PR/merge/park/discard reference"]
+}
+```
+
+## Next in the chain
+
+Ship is the end of the SDD loop for a feature. Two onward paths:
+
+- The code is merged but must reach a **server / release** — provisioning, pipeline, environment promotion, rollback → hand off to **deployment** (`../deployment/SKILL.md`). Ship lands it in the repo; deployment puts it in front of users.
+- The next feature starts the loop again at **specify** (`../specify/SKILL.md`) — or at **constitution** if the project's principles changed. The `sdd` dispatcher (`../sdd/SKILL.md`) routes whichever comes next.
+
+## Orientación (siempre)
+
+Cierra cada turno con el **bloque-brújula** (📍 dónde estás · ✅ qué hiciste · 🧭 por qué · ➡️ siguiente, terminando en pregunta), calibrado al dial de `02-DOCS/wiki/harness/user-profile.md`. **Nunca termines en seco.** Protocolo completo: skill `orient` → `skills/orient/references/orientation-contract.md`. (Defiere a `suggest` el "¿instalo la skill que falta?".)
+

package/skills/ship/evals/README.md

@@ -0,0 +1,89 @@
+# Eval harness — ship
+
+These evals run through an **agent harness** (an agent that loads skills on
+demand), not a plain shell script. `cases.yaml` is the fixture; this file is the
+procedure. Two things are measured: **triggering** (does `ship` fire on
+"close the branch / merge / open the PR" and stay quiet for its siblings) and
+**capability** (does loading `ship` produce a safe, Eric-only landing — runs the
+pre-ship checklist, strips AI authorship, picks the right of three options).
+
+## Setup
+
+- Use the same agent/model for every trial; vary only which skills are loaded.
+- Triggering trials: load the **full skill catalog** so the agent can route to a
+  sibling, then observe which skill it selects.
+- Capability trials: compare **only `ship` loaded** vs **no skill loaded**.
+
+## 1. Triggering
+
+For each item in `should_trigger` and `should_not_trigger`:
+
+1. Start a fresh agent session with the full catalog available.
+2. Feed the `prompt` verbatim as the user message.
+3. Record which skill (if any) the agent invokes.
+4. Run **3–5 trials** per prompt — selection is stochastic.
+
+Pass conditions:
+
+- `should_trigger`: **ship** is invoked in the majority of trials. The set mixes
+  the three landing modes — direct merge ("merge into main", "squash and merge"),
+  pull request ("open the PR"), and park/discard ("clean up the branch, shouldn't
+  merge") — plus the authorship concern ("don't credit Claude", "strip the
+  generated-with footer"). All must fire `ship`.
+- `should_not_trigger`: ship is **not** invoked; ideally the agent routes to the
+  listed `route_to` sibling. These near-misses are the adjacent phases that ship
+  explicitly defers to: **verify** (run the gates), **review** (read the diff),
+  **deployment** (reach a server), **worktrees** (open isolated work), and the
+  **postgresdb** stack skill (author SQL). All five siblings exist in this repo,
+  so a correct routing lands on the named target.
+
+**Pass bar: >= 90% trigger accuracy** across all trials. A prompt that flaps
+below majority counts as a fail for that prompt; >= 90% of prompts must pass
+clean.
+
+## 2. Capability
+
+For the `capability` scenario, run two arms:
+
+- **WITH**: only `ship` loaded.
+- **WITHOUT**: no skill loaded (baseline model behavior).
+
+Run each arm 3 times. Grade every response against the scenario's `must_include`
+rubric — one point per item that is genuinely present (actually performed, not
+hand-waved). The scenario is built to discriminate on the skill's reason to
+exist: an approved branch carrying a leftover `Co-Authored-By: Claude` trailer
+and a "Generated with Claude Code" footer, in a repo with a protected `main`. The
+win is (a) detecting and **stripping** the AI authorship before pushing, (b)
+recommending the **PR** option because `main` is protected, and (c) producing a
+spec-linked commit/PR body with **no AI attribution**.
+
+Pass conditions:
+
+- **WITH** the skill covers **>= 80%** of `must_include` items on average.
+- The skill **measurably improves** the output: WITH coverage must beat WITHOUT
+  by a clear margin (target **>= 25 percentage points**). The discriminating
+  items are the authorship ones — baselines frequently *add* a Co-Authored-By
+  Claude trailer or a "generated with" footer as a default courtesy; the skill
+  should flip that to actively stripping it. A response that adds any AI
+  attribution is a hard fail on those items regardless of other coverage.
+
+## Scoring summary
+
+| Dimension | Metric | Pass bar |
+|---|---|---|
+| Triggering | trigger accuracy across all prompts/trials | >= 90% |
+| Capability | rubric coverage WITH skill | >= 80% |
+| Capability | WITH minus WITHOUT (lift) | >= 25 pts |
+
+## Notes / honesty
+
+- These are LLM-graded, stochastic evals — re-run on skill edits and treat small
+  score deltas as noise, not signal.
+- `route_to` targets (`verify`, `review`, `deployment`, `worktrees`,
+  `postgresdb`) all exist in this repo's catalog, so a near-miss that lands on
+  the named sibling is a clean pass. A mis-route to an *absent* skill would be a
+  catalog gap, not a `ship` fault — but none of these targets are absent.
+- The authorship items are the point of the skill, not a side check. Grade them
+  strictly: "stripped the trailer" must be an actual amend/edit, and the produced
+  commit/PR body must contain zero AI attribution. "Mentioned authorship" without
+  acting is not a pass.

package/skills/ship/evals/cases.yaml

@@ -0,0 +1,44 @@
+skill: ship
+
+should_trigger:
+  - prompt: "Review's done and approved. Ship it — open the PR and get this branch landed."
+    why: "Flagship trigger: approved diff, explicit 'ship it' + 'open the PR' + 'land the branch'. Squarely the ship phase, the close of the SDD chain."
+  - prompt: "Esta rama ya pasó verify y review. Haz el merge a main y borra la rama."
+    why: "Spanish trigger — branch passed verify+review, 'merge to main and delete the branch'. Same close-the-branch action in the user's other language."
+  - prompt: "I'm done with the feature and everything's green. What now — how do I land this?"
+    why: "Non-obvious phrasing: no literal 'merge'/'PR' word, but 'done', 'green', 'how do I land this' is exactly the moment ship presents the three landing options."
+  - prompt: "Can you write a clean commit message and open a pull request for this change? Make sure it doesn't credit Claude or any AI as a co-author."
+    why: "Directly invokes the authorship hard rule (no Co-Authored-By Claude) alongside the commit+PR action — the defining concern this skill owns."
+  - prompt: "This spike didn't pan out — the approach is superseded. Clean up the branch, I don't think it should merge."
+    why: "The park/discard landing option (option 3). 'Clean up the branch', 'shouldn't merge' is the abandon path ship handles, including the destructive-confirm + log-the-reason discipline."
+  - prompt: "Squash my wip commits into one good commit and push it so I can merge into main."
+    why: "Commit-history hygiene + landing to trunk. Squashing noisy wip commits and merging is ship's commit-message discipline and option 1 (direct merge)."
+  - prompt: "The PR body got auto-generated with a 'Generated with Claude Code' footer — strip that and make sure the author is me before this lands."
+    why: "Authorship-violation cleanup: stripping the generated-with footer and confirming Eric is the author, immediately before landing. Core ship safety behavior."
+
+should_not_trigger:
+  - prompt: "Run lint, type-check and the whole test suite on my branch and tell me if it's green before I do anything else."
+    route_to: "verify"
+    why: "Running the gates to green is the verify phase. Ship assumes green and refuses to run when the gates haven't passed; this is the prerequisite, not the close."
+  - prompt: "Tear this diff apart before it goes out — what's actually wrong with the logic?"
+    route_to: "review"
+    why: "Adversarial reading of the diff for defects is the review phase. Ship lands an already-approved diff; it never reads code for correctness."
+  - prompt: "The merge is in. Now provision the server and roll this out to production with a rollback plan."
+    route_to: "deployment"
+    why: "Server provisioning, release pipeline and rollback are the deployment phase. Ship lands code in the repo; deployment puts it in front of users — explicitly routed out in 'When NOT to use'."
+  - prompt: "I'm starting a new feature and want it isolated from my current work — set up a worktree."
+    route_to: "worktrees"
+    why: "Creating the isolated branch/worktree to OPEN work is the worktrees phase. Ship is the close, not the open; opposite end of the loop."
+  - prompt: "Write me a Postgres migration to add a nullable discount_cents column to the orders table."
+    route_to: "postgresdb"
+    why: "Authoring SQL/migration code is owned by the postgresdb stack skill. There is no branch to land here — it's implementation work, not a close."
+
+capability:
+  - scenario: "An approved branch `feature/discount-codes` is ready to land. The user asks to commit and open a PR. The repo's `main` is protected (a `.github/` with prior PRs exists), and a leftover commit on the branch carries the trailer 'Co-Authored-By: Claude <noreply@anthropic.com>' plus a 'Generated with Claude Code' footer. Decide how to land it and produce the commit/PR."
+    must_include:
+      - "Runs the pre-ship safety checklist: confirms the review verdict is APPROVE, the tree is clean, the branch is rebased on main, and scans the diff for secrets — before presenting any option."
+      - "Detects the AI authorship trailer/footer and treats it as a BLOCKER: strips the Co-Authored-By Claude trailer and the 'Generated with Claude Code' footer (amends the commit) before anything is pushed."
+      - "Confirms git author is Eric (checks git config user.email) and never passes --author for an agent identity."
+      - "Presents exactly THREE landing options (direct merge / pull request / park-or-discard) and recommends the PR option BECAUSE main is protected / the repo has a PR culture (.github + prior PRs)."
+      - "Writes a spec-linked commit message and PR body (What/Why/How/Verification referencing 02-DOCS/wiki/sdd/specs/<slug>.md) that contains NO AI attribution — no Co-Authored-By, no generated-with footer."
+      - "Logs the landing decision to 02-DOCS/wiki/sdd/decisions.md and keeps the sdd/ Knowledge-map rows honest; verifies authorship clean (the git log grep) before claiming the branch is shipped."