wayfind 2.0.13 → 2.0.14

package/plugin/scripts/session-end.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Wayfind plugin — Stop hook
+# Runs incremental conversation indexing with journal export after each session.
+# Extracted decisions get written to the journal directory so they sync via git
+# and the container's journal indexer picks them up.
+#
+# Performance target: <5s for the common case (no new conversations to process).
+
+set -euo pipefail
+
+# Skip export for worker agents in multi-agent swarms.
+# Set TEAM_CONTEXT_SKIP_EXPORT=1 when spawning worker agents so only the
+# orchestrator's decisions flow into the journal.
+if [ "${TEAM_CONTEXT_SKIP_EXPORT:-${MERIDIAN_SKIP_EXPORT:-}}" = "1" ]; then
+  exit 0
+fi
+
+# Find wayfind binary
+WAYFIND="$(command -v wayfind 2>/dev/null || echo "")"
+if [ -z "$WAYFIND" ]; then
+  for candidate in \
+    "$HOME/repos/greg/wayfind/bin/team-context.js" \
+    "$HOME/repos/wayfind/bin/team-context.js"; do
+    if [ -f "$candidate" ]; then
+      WAYFIND="node $candidate"
+      break
+    fi
+  done
+fi
+
+if [ -z "$WAYFIND" ]; then
+  echo "[wayfind] CLI not found — decision extraction skipped. Install: npm install -g wayfind" >&2
+  exit 0
+fi
+
+# ── Fast path: skip reindex if no conversation files changed ──────────────────
+LAST_RUN_FILE="$HOME/.claude/team-context/.last-reindex"
+if [ -f "$LAST_RUN_FILE" ]; then
+  CHANGED=$(find "$HOME/.claude/projects" -name "*.jsonl" -newer "$LAST_RUN_FILE" 2>/dev/null | head -1)
+  if [ -z "$CHANGED" ]; then
+    # No conversation files changed — skip expensive reindex, just sync journals
+    $WAYFIND journal sync 2>/dev/null &
+    exit 0
+  fi
+fi
+
+# Run incremental reindex
+$WAYFIND reindex --conversations-only --export --detect-shifts --write-stats 2>/dev/null || true
+
+# Update the marker so the next session's fast-path check works
+mkdir -p "$HOME/.claude/team-context"
+touch "$LAST_RUN_FILE"
+
+# Sync authored journals to team-context repo (backgrounded)
+$WAYFIND journal sync 2>/dev/null &

package/plugin/scripts/session-start.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# Wayfind plugin — SessionStart hook
+# Rebuilds the Active Projects index and checks for version updates.
+# Runs on every session start via the plugin hook system.
+
+set -euo pipefail
+
+# Find wayfind binary
+WAYFIND="$(command -v wayfind 2>/dev/null || echo "")"
+if [ -z "$WAYFIND" ]; then
+  # Try common local checkout paths
+  for candidate in \
+    "$HOME/repos/greg/wayfind/bin/team-context.js" \
+    "$HOME/repos/wayfind/bin/team-context.js"; do
+    if [ -f "$candidate" ]; then
+      WAYFIND="node $candidate"
+      break
+    fi
+  done
+fi
+
+if [ -z "$WAYFIND" ]; then
+  # No CLI available — plugin still works for skills, just no automation
+  echo "[wayfind] CLI not found. Skills work, but install the CLI for full features: npm install -g wayfind" >&2
+  exit 0
+fi
+
+# Rebuild Active Projects table (idempotent, concurrent-safe)
+$WAYFIND status --write --quiet 2>/dev/null || true
+
+# Check if installed version meets team minimum
+$WAYFIND check-version 2>/dev/null || true

package/plugin/skills/doctor/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: doctor
+description: Run Wayfind health check — validates hooks, state files, backup status, and memory file sizes.
+user-invocable: true
+---
+
+# Wayfind — Doctor
+
+Run a health check on the memory system.
+
+## Step 1: Check if the CLI is available
+
+```bash
+wayfind doctor
+```
+
+If the CLI is installed, its built-in doctor command handles everything. Present the output and stop.
+
+If the CLI is not found, perform the checks manually using Steps 2-3 below.
+
+## Step 2: Manual checks
+
+Use the Read tool (not Bash) for file checks. Use Glob for file discovery.
+
+1. **Hook registered?** — Read `~/.claude/settings.json`. Check if it contains "check-global-state" or if the wayfind plugin is installed (plugin hooks handle this automatically).
+2. **Global state current?** — Read `~/.claude/global-state.md`. Check the "Last updated" line near the top.
+3. **Backup status** — Read `~/.claude/.backup-last-push`. If the file doesn't exist, report "Backup not configured."
+4. **Repos** — Use Glob to find `~/repos/**/.claude/state.md` and `~/repos/**/.claude/team-state.md` files. Report each with its parent repo name.
+5. **Memory files** — Use Glob to find `~/.claude/memory/*.md`. For each file, read it and check if it's unusually large (mention if content seems over ~200 lines). Also count journal files in `~/.claude/memory/journal/`.
+
+## Step 3: Report findings
+
+Report in this format:
+- Items that are working correctly
+- Items that need attention (not broken, but worth knowing)
+- Items that are broken (with how to fix)

package/plugin/skills/init-memory/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: init-memory
+description: Initialize Wayfind for the current repo. Creates .claude/team-state.md (tracked in git) and .claude/personal-state.md (gitignored), ensures correct .gitignore entries, appends session protocol to CLAUDE.md, and registers the repo in the global index. Safe to run multiple times (idempotent).
+user-invocable: true
+---
+
+# Initialize Memory System for Current Repo
+
+Run these steps in order. Skip any step that's already done (this command is idempotent).
+
+## Step 0: Detect and Migrate Old Protocol
+
+Read the repo's `CLAUDE.md` (if it exists). If it contains "Update the project's row in" or "Update the Active Projects row", this repo has the old session protocol that writes to global-state.md.
+
+**Migration:** Replace the matching Session End step with:
+> 3. Do NOT update `~/.claude/global-state.md` — its Active Projects table is rebuilt automatically by `wayfind status`.
+
+Report: "Migrated session protocol — sessions no longer write to global-state.md."
+
+If the old protocol is not detected, skip this step silently.
+
+## Step 1: Detect Context
+
+- Determine the current working directory
+- Check if it's a git repo (`ls .git` or `git rev-parse --show-toplevel`)
+- Read `~/.claude/global-state.md` to check if this repo is already registered
+
+## Step 1.5: Bind repo to team
+
+Check if `.claude/wayfind.json` already exists in the repo.
+
+**If it already exists:** Read it, report the current team binding ("Already bound to team: <team name>"), and ask: "Want to change the team binding?" If the user says no, skip to Step 2. If yes, proceed with team selection below (overwrite the file).
+
+**If it does not exist:** Read `~/.claude/team-context/context.json` to get the list of configured teams.
+
+- **No teams configured (file missing or empty `teams` array):** Tell the user: "No teams configured yet. Run `/wayfind:init-team` first to set up a team, then re-run `/wayfind:init-memory`." **Stop here — do not continue to later steps.**
+
+- **Exactly one team:** Auto-bind to that team. Create `.claude/wayfind.json`:
+  ```json
+  {"team_id": "<teamId>", "bound_at": "<ISO 8601 timestamp>"}
+  ```
+  Report: "Bound to team: <team name> (auto-selected, only team configured)"
+
+- **Multiple teams:** List the teams by name and ask the user which one this repo belongs to. Wait for their answer. Create `.claude/wayfind.json` with their chosen team's ID. Report: "Bound to team: <team name>"
+
+**Verify `.gitignore` coverage:** `.claude/wayfind.json` must be gitignored. Step 3 already includes it in the required entries — confirm this is still the case. If someone removed it, Step 3 will restore it.
+
+## Step 2: Create state files (if missing)
+
+This repo uses TWO state files with different visibility:
+
+**`.claude/team-state.md`** — committed to git (shared team context)
+
+If `.claude/team-state.md` does not exist, create it:
+
+```markdown
+# [Repo Name] — Team State
+
+Last updated: [today's date]
+
+## Architecture & Key Decisions
+<!-- Decisions the whole team should know. Include the "why" not just the "what". -->
+
+## Conventions
+<!-- Patterns, naming, tooling choices that apply across the team. -->
+
+## Current Sprint Focus
+<!-- Team-level "what are we working on right now" -->
+
+## Elicitation Prompts
+
+<!-- These prompts guide the AI to capture richer context at decision moments.
+     The answers aren't for you — they're for your teammates who read the digest. -->
+
+When a technical or product decision is made without stated reasoning, ask one of:
+- "What alternatives did you consider?"
+- "What constraint or requirement drove this choice?"
+- "What would need to change for you to reverse this decision?"
+- "Who else on the team does this affect, and how?"
+- "What's the risk if this assumption is wrong?"
+
+Do not ask if the decision already includes reasoning, tradeoffs, or constraints.
+Do not ask more than once per decision. Do not ask during routine implementation.
+
+## Shared Gotchas
+<!-- Hard-won lessons. What surprised us. What NOT to do. -->
+```
+
+**`.claude/personal-state.md`** — gitignored (your personal context)
+
+If `.claude/personal-state.md` does not exist, create it:
+
+```markdown
+# [Repo Name] — Personal State
+
+Last updated: [today's date]
+
+(This file is gitignored. It's yours — context you wouldn't want teammates reading as objective fact.)
+
+## My Current Focus
+<!-- Your personal next steps -->
+
+## Personal Context
+<!-- Working notes, opinions, relationship dynamics for this repo -->
+
+## What I'm Watching
+<!-- Open questions, things to follow up on -->
+```
+
+## Step 3: Fix `.gitignore`
+
+Check `.gitignore`. Ensure these lines are present:
+
+```
+.claude/personal-state.md
+.claude/state.md
+.claude/settings.local.json
+.claude/memory.db
+.claude/wayfind.json
+```
+
+**Do NOT add `.claude/` as a whole directory.** That breaks skills and commands. Only add the specific files above. Note that `team-state.md` is intentionally NOT gitignored — it is meant to be committed and shared with your team. The `.claude/state.md` entry covers legacy repos that use a single state file instead of the two-file model.
+
+If any of those lines are missing, append them. If `.claude/` (as a directory) is already in `.gitignore`, remove it and replace with the four file-level entries above.
+
+## Step 4: Append Session Protocol to CLAUDE.md
+
+Read the repo's `CLAUDE.md`. If it does NOT already contain "Session State Protocol", append this:
+
+```markdown
+
+## Session State Protocol
+
+**At session start (REQUIRED):**
+1. Read `~/.claude/global-state.md` — preferences, active projects, memory file manifest
+2. Read `.claude/team-state.md` in this repo — shared team context: architecture decisions, conventions, sprint focus, gotchas
+3. Read `.claude/personal-state.md` in this repo — your personal context: current focus, working notes, opinions
+4. Check the Memory Files table in global-state.md — load any `~/.claude/memory/` files relevant to this session's topic
+
+**At session end (when user says stop/done/pause/tomorrow):**
+1. Update `.claude/team-state.md` with shared context: architecture decisions, conventions, gotchas the team should know
+2. Update `.claude/personal-state.md` with personal context: your next steps, working notes, opinions
+3. Do NOT update `~/.claude/global-state.md` — its Active Projects table is rebuilt automatically by `wayfind status`.
+4. If significant new cross-repo context was created (patterns, strategies, decisions), create or update a file in `~/.claude/memory/` and add it to the Memory Files manifest in global-state.md
+
+**Do NOT use external memory databases or CLI tools for state storage.** Use plain markdown files only.
+```
+
+If `CLAUDE.md` doesn't exist, create a minimal one with the repo name as a heading and the block above.
+
+## Step 5: Register State Files in Global Index
+
+Read `~/.claude/global-state.md`. The Active Projects table is auto-generated by `wayfind status --write` — do NOT add rows to it manually.
+
+Add the repo's state files to the State Files table if missing:
+
+```
+| `[full path]/.claude/team-state.md` | Shared team context for this repo |
+| `[full path]/.claude/personal-state.md` | Personal context for this repo (gitignored) |
+```
+
+## Step 6: Report
+
+Tell the user:
+- `.claude/wayfind.json` — bound to team: <team name> (or already bound)
+- `.claude/team-state.md` — created or already existed (committed to git, shared with team)
+- `.claude/personal-state.md` — created or already existed (gitignored, personal only)
+- `.gitignore` — updated or already correct
+- `CLAUDE.md` — protocol appended or already present
+- `global-state.md` — repo registered or already listed
+
+**If they haven't set up team context yet**, mention:
+"Run `/wayfind:init-team` to set up team-level context sharing — shared journals, weekly digests
+(Slack + Notion), and persona state files for your configured personas."
+
+**Mention persona configuration:**
+"Run `wayfind personas` to see and customize your team's personas (defaults: Product, Design, Engineering, Strategy)."

package/plugin/skills/init-team/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: init-team
+description: Set up Wayfind team context for your organization. Interactive walkthrough that creates a team, sets up profiles, creates a team context repo, configures Slack digests, sets up Notion integration, and initializes product-state.md for a pilot repo. Run once per team.
+user-invocable: true
+---
+
+# Initialize Team Context (Wayfind)
+
+Interactive setup for team-level context sharing. Walk the user through each step,
+asking questions as needed. Skip steps that are already done (idempotent).
+
+## Quick Start (CLI)
+
+Before running this full walkthrough, you can quickly bootstrap team basics from
+the command line:
+
+```bash
+# Set up your personal profile and persona(s)
+wayfind whoami --setup
+
+# Create a new team (generates a shareable team ID)
+wayfind team create
+
+# Or join an existing team
+wayfind team join <team-id>
+
+# Check your profile and team status
+wayfind whoami
+wayfind team status
+```
+
+These commands create local config files in `~/.claude/team-context/`. The full
+`/wayfind:init-team` walkthrough below sets up the shared infrastructure (repo, Slack,
+Notion, journals).
+
+## Prerequisites Check
+
+Before starting, verify:
+1. Wayfind is installed (`~/.claude/team-context/` exists or `wayfind version` works)
+2. User has a Wayfind profile (`wayfind whoami` -- if not, run `wayfind whoami --setup`, which also asks for Slack user ID)
+3. User has a team configured (`wayfind team status` -- if not, run `wayfind team create`)
+4. User has `gh` CLI authenticated (`gh auth status`)
+5. User is in a git repo within an organization (or can specify one)
+6. Ask: **"Which GitHub org will host the team context repo?"** (e.g., `acme-corp`)
+
+If any prerequisite fails, tell the user what's needed and stop.
+
+## Step 1: Team Context Repo
+
+This repo holds shared journals, strategy state, digest archives, and the GitHub
+Action that generates digests.
+
+Ask: **"Do you already have a team context repo for shared journals and digests? If so, what's the repo name? If not, I'll help you create one."**
+
+### If creating new:
+
+Ask: **"What should the repo be called?"** Suggest: `<org>/engineering-context`
+
+Guide the user:
+```
+gh repo create <org>/<repo-name> --private --description "Team decision trail — journals, digests, strategy (powered by Wayfind)"
+```
+
+Then clone it and create the initial structure:
+```
+<repo>/
+  README.md              # Brief explanation of what this repo is
+  strategy-state.md      # Strategy persona state (from templates/strategy-state.md)
+  context/               # Shared context (product.md, engineering.md, architecture.md)
+  members/               # Member profiles (<username>.json) with slack_user_id
+  journals/              # One subdirectory per team member
+    <username>/          # Journal files sync here from each person's local
+  digests/               # Archive of generated digests
+  prompts/               # Shared team prompts (from templates/prompts-readme.md)
+    README.md            # How to use and contribute prompts
+  deploy/                # Docker deployment (docker-compose.yml, .env, manifest)
+  wayfind.json           # Shared config (webhook URLs, model, excluded repos)
+  .github/workflows/     # Digest generation (added in Step 2)
+```
+
+Commit and push the initial structure.
+
+### If existing:
+
+Clone or pull the repo. Verify it has `journals/`, `digests/`, and `prompts/` directories.
+Create them if missing. If `prompts/` is new, add the README from `templates/prompts-readme.md`.
+
+Store the team context repo path for later steps.
+
+## Step 2: Slack Integration
+
+Ask: **"Do you want weekly digests posted to Slack? You'll need a Slack Incoming Webhook URL. If you have one, paste it. If not, I can walk you through creating one."**
+
+### If they need help creating a webhook:
+1. Go to https://api.slack.com/apps -> Create New App -> From Scratch
+2. Name it "Wayfind Digests" (or team preference), select workspace
+3. Features -> Incoming Webhooks -> Activate
+4. Add New Webhook to Workspace -> Select channel (suggest `#engineering`)
+5. Copy the webhook URL
+
+### Once they have the URL:
+
+Store it as a GitHub repo secret (NOT in plain text):
+```
+gh secret set SLACK_WEBHOOK_URL --repo <org>/<team-context-repo> --body "<webhook-url>"
+```
+
+Ask: **"Which Slack channel(s) should receive digests?"**
+
+### Create the GitHub Action:
+
+Create `.github/workflows/weekly-digest.yml` in the team context repo:
+
+```yaml
+name: Weekly Digest
+
+on:
+  schedule:
+    - cron: '0 10 * * 1'  # Monday 10:00 UTC (adjust for timezone)
+  workflow_dispatch:  # Manual trigger for testing
+
+jobs:
+  digest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install Wayfind
+        run: npm install -g wayfind
+
+      - name: Reindex journals
+        run: wayfind reindex
+
+      - name: Generate and deliver digest
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+        run: wayfind digest --since last-week --deliver
+
+      - name: Archive digest
+        run: |
+          git config user.name "Wayfind Bot"
+          git config user.email "wayfind-bot@users.noreply.github.com"
+          git add digests/
+          git diff --cached --quiet || git commit -m "Weekly digest $(date +%Y-%m-%d)"
+          git push
+```
+
+## Step 3: Notion Integration
+
+Ask: **"Do you want digests and product context visible in Notion?"**
+
+If yes, use Notion MCP tools to create pages and record the page IDs.
+
+## Step 4: Product State for Pilot Repo
+
+Ask: **"Which repo should we set up persona state files for first?"**
+
+Check the team's configured personas and create appropriate state templates.
+
+## Step 5: Journal Sync Configuration
+
+Each team member's journals need to flow to the team context repo:
+
+```bash
+wayfind journal sync
+```
+
+Ensure the session-end hook includes journal sync (the plugin handles this automatically).
+
+## Step 6: Onboarding Instructions
+
+Generate a message the user can send to their team:
+
+```
+Hey team — I've set up Wayfind for our engineering context.
+
+**What you need to do**:
+1. Install the Claude Code plugin:
+   /plugin marketplace add usewayfind/wayfind
+   /plugin install wayfind@usewayfind
+2. For full features (digests, extraction), also install the CLI:
+   npm install -g wayfind
+3. Join our team:
+   wayfind team join [TEAM_ID]
+4. Set up your profile:
+   wayfind whoami --setup
+5. In any repo you work in, run /wayfind:init-memory
+
+That's it. Work normally. Wayfind captures context at the end of each session.
+```
+
+## Step 7: Report
+
+Summarize everything that was set up and tell the user to send the onboarding message.

package/plugin/skills/journal/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: journal
+description: Generate a journal summary — weekly digest, drift detection, and recurring lessons from AI session journals.
+user-invocable: true
+---
+
+# Wayfind — Journal Summary
+
+Aggregate AI session journal entries into a weekly digest with drift detection and recurring lesson extraction.
+
+## Step 1: Run journal-summary.sh
+
+Look for `~/.claude/team-context/journal-summary.sh`. If found, run it based on what the user asked:
+
+```bash
+# This week (default)
+bash ~/.claude/team-context/journal-summary.sh
+
+# Last week
+bash ~/.claude/team-context/journal-summary.sh --last-week
+
+# Specific date range
+bash ~/.claude/team-context/journal-summary.sh --from 2026-02-01 --to 2026-02-28
+
+# All history as Markdown (good for Notion/GitHub)
+bash ~/.claude/team-context/journal-summary.sh --all --format markdown
+
+# Team aggregate (each subdir is a contributor's journal dir)
+bash ~/.claude/team-context/journal-summary.sh --team ~/team-journals
+
+# Custom journal directory
+bash ~/.claude/team-context/journal-summary.sh --dir ~/.ai-memory/memory/journal
+```
+
+## Step 2: If journal-summary.sh is not installed
+
+Try the CLI instead:
+```bash
+wayfind journal summary
+```
+
+If neither is available, tell the user: "Install the Wayfind CLI for journal summaries: `npm install -g wayfind`"
+
+## Step 3: Interpret results
+
+The summary surfaces four key sections:
+
+- **Sessions by Repo** — Every session in the period, grouped by repo. Warning marks on drifted sessions.
+- **Drift Log** — Sessions where "On track?" indicated scope creep or goal drift. Review these to identify recurring blockers.
+- **Recurring Lessons** — Lessons that appeared in 2+ sessions. These are strong candidates to add to `CLAUDE.md` or `global-state.md` so the AI learns from them.
+- **All Lessons** — Full lesson archive for the period, with markers on recurring ones.
+
+## Options quick reference
+
+```
+--dir <path>        Journal directory (auto-detects ~/.claude or ~/.ai-memory)
+--team <path>       Team mode: each subdirectory is a contributor's journal dir
+--week              This week Mon-Sun (default)
+--last-week         Last week Mon-Sun
+--from <YYYY-MM-DD> Start date
+--to   <YYYY-MM-DD> End date (default: today)
+--all               All available journal files
+--format markdown   Output as Markdown instead of plain text
+```

package/plugin/skills/review-prs/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: review-prs
+description: Review overnight NanoClaw PRs — fact-check, assess against repo conventions, summarize, and offer merge/revise/close for each.
+user-invocable: true
+---
+
+# Review NanoClaw PRs
+
+Review open pull requests created by NanoClaw overnight. For each PR: read the diff, assess quality, fact-check where possible, and present a summary with a recommendation.
+
+## Step 0: Discover repos
+
+Read the Wayfind context registry to find repos to scan:
+
+```bash
+cat ~/.claude/team-context/context.json 2>/dev/null | node -e "
+  const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));
+  const teams = d.teams || {};
+  Object.values(teams).forEach(t => {
+    if (t.repos) t.repos.forEach(r => console.log(r));
+    if (t.path) console.log(t.path);
+  });
+" 2>/dev/null
+```
+
+If no context registry exists, ask the user which repos to scan. Store the list for subsequent steps.
+
+Also detect the GitHub owner by reading git remote from each repo path, or ask the user.
+
+## Step 1: Find open NanoClaw PRs
+
+For each discovered repo, check for open NanoClaw PRs:
+
+```bash
+for repo in {owner/repo list from Step 0}; do
+  echo "=== $repo ==="
+  gh pr list --repo "$repo" --state open --json number,title,headRefName,createdAt,additions,deletions,changedFiles 2>/dev/null | jq -r '.[] | select(.headRefName | startswith("nanoclaw/")) | "PR #\(.number): \(.title) (+\(.additions)/-\(.deletions), \(.changedFiles) files)"'
+done
+```
+
+If no open NanoClaw PRs found, report "No overnight PRs to review" and stop.
+
+## Step 2: Review each PR in parallel
+
+**Spawn one Agent per PR** using the Agent tool with `run_in_background: true`. Each agent reviews its assigned PR independently. If there are 2+ PRs, all agents run concurrently. If there is only 1 PR, still spawn an agent for the review and a second agent to fact-check sources in parallel.
+
+Each agent should:
+
+1. **Get the full diff:**
+   ```bash
+   gh pr diff {number} --repo {owner/repo}
+   ```
+
+2. **Get PR metadata:**
+   ```bash
+   gh pr view {number} --repo {owner/repo} --json title,body,headRefName,createdAt
+   ```
+
+3. **Assess the content:**
+
+   For **competitive intel** PRs (files in `docs/competitive-intel/`):
+   - Read `docs/competitive-intel/MONITORING.md` for the required template
+   - Does it follow the template?
+   - Are sources cited? Do URLs look plausible (not hallucinated)?
+   - Are threat assessments reasonable given what we know?
+   - Does it claim `Verified: Yes` without evidence of verification?
+   - Are there new HIGH-threat competitors that need a full analysis file?
+   - Spot-check 2-3 factual claims using `gh api` or web search
+
+   For **code** PRs:
+   - Does it compile/pass tests? (`npm test` if applicable)
+   - Are changes scoped correctly (not too broad)?
+   - Any obvious bugs, security issues, or style violations?
+   - Does it match the repo's conventions?
+
+   For **documentation** PRs:
+   - Is the content accurate and well-structured?
+   - Does it duplicate existing docs?
+
+4. **Check the PR title.** NanoClaw often uses the raw prompt as the title. Flag if it needs fixing.
+
+Wait for all agents to complete, then synthesize their findings into the summary below.
+
+## Step 3: Present summary
+
+For each PR, present:
+
+```
+### PR #{number}: {title} ({repo})
+**Files:** {list}
+**Quality:** {Good / Needs revision / Reject}
+
+**Summary:** {2-3 sentences on what the PR does}
+
+**Issues found:**
+- {issue 1}
+- {issue 2}
+(or "None — clean PR")
+
+**Fact-check results:**
+- {claim}: {verified/unverified/incorrect}
+
+**Recommendation:** Merge / Merge after fixes / Request revision / Close
+
+{If merge after fixes: list the specific fixes needed}
+```
+
+## Step 4: Act on decisions
+
+After presenting all summaries, ask the user what to do with each PR. Support these actions:
+
+- **Merge**: `gh pr merge {number} --repo {repo} --merge --delete-branch`
+- **Fix title then merge**: `gh pr edit {number} --repo {repo} --title "{new title}"` then merge
+- **Request changes**: Post a review comment and leave open
+- **Close**: `gh pr close {number} --repo {repo}`
+- **Skip**: Leave for later
+
+After merging any PRs, pull main:
+```bash
+git checkout main && git pull
+```