continuous-improvement 3.9.2 → 3.12.3

package/skills/grill-with-docs.md

@@ -0,0 +1,252 @@
+---
+name: grill-with-docs
+tier: "2"
+description: Enforces Law 1 (Research Before Executing) and Law 7 (Learn From Every Session) of the 7 Laws of AI Agent Discipline. Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates CONTEXT.md + ADRs inline as decisions crystallise. Ported from mattpocock/skills under MIT.
+origin: https://github.com/mattpocock/skills
+---
+
+# /grill-with-docs — Grill the plan AND update the docs as decisions land
+
+Ported in behavior from [mattpocock/skills `engineering/grill-with-docs`](https://github.com/mattpocock/skills/blob/main/skills/engineering/grill-with-docs/SKILL.md) (MIT, © 2026 Matt Pocock). Cold-storage snapshot of the three upstream files (`SKILL.md`, `CONTEXT-FORMAT.md`, `ADR-FORMAT.md`) at [`third-party/mattpocock-skills/skills/engineering/grill-with-docs/`](../third-party/mattpocock-skills/skills/engineering/grill-with-docs/); SHA pin in [`third-party/MANIFEST.md`](../third-party/MANIFEST.md).
+
+The two format specs (CONTEXT.md format, ADR format) are inlined as appendices in this file so the bundled skill is self-contained — see [Appendix A: CONTEXT.md format](#appendix-a-contextmd-format) and [Appendix B: ADR format](#appendix-b-adr-format).
+
+## What this skill does
+
+<what-to-do>
+
+Interview the user relentlessly about every aspect of this plan until shared understanding is reached. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide a recommended answer.
+
+Ask questions one at a time, waiting for feedback on each before continuing.
+
+If a question can be answered by exploring the codebase, explore the codebase instead.
+
+</what-to-do>
+
+## Domain awareness
+
+During codebase exploration, also look for existing documentation:
+
+### File structure
+
+Most repos have a single context:
+
+```
+/
+├── CONTEXT.md
+├── docs/
+│   └── adr/
+│       ├── 0001-event-sourced-orders.md
+│       └── 0002-postgres-for-write-model.md
+└── src/
+```
+
+If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives:
+
+```
+/
+├── CONTEXT-MAP.md
+├── docs/
+│   └── adr/                          ← system-wide decisions
+├── src/
+│   ├── ordering/
+│   │   ├── CONTEXT.md
+│   │   └── docs/adr/                 ← context-specific decisions
+│   └── billing/
+│       ├── CONTEXT.md
+│       └── docs/adr/
+```
+
+Create files lazily — only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed.
+
+## During the session
+
+### Challenge against the glossary
+
+When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?"
+
+### Sharpen fuzzy language
+
+When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? Those are different things."
+
+### Discuss concrete scenarios
+
+When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.
+
+### Cross-reference with code
+
+When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is right?"
+
+### Update CONTEXT.md inline
+
+When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [Appendix A](#appendix-a-contextmd-format).
+
+Don't couple `CONTEXT.md` to implementation details. Only include terms that are meaningful to domain experts.
+
+### Offer ADRs sparingly
+
+Only offer to create an ADR when all three are true:
+
+1. **Hard to reverse** — the cost of changing your mind later is meaningful
+2. **Surprising without context** — a future reader will wonder "why did they do it this way?"
+3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
+
+If any of the three is missing, skip the ADR. Use the format in [Appendix B](#appendix-b-adr-format).
+
+## How it fits the 7 Laws
+
+| Law | Role of this skill |
+|---|---|
+| Law 1 (Research Before Executing) | Pre-execution interrogation + codebase exploration close the alignment gap before any tool call. |
+| Law 2 (Plan Is Sacred) | The interview produces a plan grounded in domain language, not invented defaults. |
+| Law 7 (Learn From Every Session) | CONTEXT.md updates persist resolved jargon across sessions; ADRs persist decisions across years. |
+
+## How it differs from `grill-me`
+
+| Skill | Focus |
+|---|---|
+| [`grill-me`](./grill-me.md) | Conversation-only grilling. No artifact. Use when there is no project to update or the project has no docs convention yet. |
+| `grill-with-docs` | Grilling that **updates `CONTEXT.md` and `docs/adr/` inline as decisions land**. Use once the project has, or is willing to start, a shared-language doc. |
+
+If a repo has no CONTEXT.md and the conversation is exploratory, start with `grill-me`. Once the user commits to a direction, switch to `grill-with-docs` to capture terminology and decisions as they crystallise.
+
+## Companion / alternative skills
+
+- [`grill-me`](./grill-me.md) — same interview discipline, no doc artifact.
+- [`handoff`](./handoff.md) — end-of-session compaction; pairs with grill-with-docs (grill to align, handoff to compact).
+- [`workspace-surface-audit`](./workspace-surface-audit.md) — inventory of available tooling; complementary to the domain-language interview.
+- [`gateguard`](./gateguard.md) — tool-boundary gate that fires after alignment is reached.
+
+## Attribution
+
+This skill is a port of [mattpocock/skills `engineering/grill-with-docs`](https://github.com/mattpocock/skills/blob/main/skills/engineering/grill-with-docs/SKILL.md) (with bundled `CONTEXT-FORMAT.md` and `ADR-FORMAT.md` inlined as appendices). MIT-licensed upstream, MIT-licensed here. See [`third-party/mattpocock-skills/LICENSE`](../third-party/mattpocock-skills/LICENSE) for the verbatim license and [`third-party/mattpocock-skills/OUR_NOTES.md`](../third-party/mattpocock-skills/OUR_NOTES.md) for the vendoring rationale and drift radar.
+
+---
+
+## Appendix A: CONTEXT.md format
+
+### Structure
+
+```md
+# {Context Name}
+
+{One or two sentence description of what this context is and why it exists.}
+
+## Language
+
+**Order**:
+{A concise description of the term}
+_Avoid_: Purchase, transaction
+
+**Invoice**:
+A request for payment sent to a customer after delivery.
+_Avoid_: Bill, payment request
+
+**Customer**:
+A person or organization that places orders.
+_Avoid_: Client, buyer, account
+
+## Relationships
+
+- An **Order** produces one or more **Invoices**
+- An **Invoice** belongs to exactly one **Customer**
+
+## Example dialogue
+
+> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?"
+> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed."
+
+## Flagged ambiguities
+
+- "account" was used to mean both **Customer** and **User** — resolved: these are distinct concepts.
+```
+
+### Rules
+
+- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid.
+- **Flag conflicts explicitly.** If a term is used ambiguously, call it out in "Flagged ambiguities" with a clear resolution.
+- **Keep definitions tight.** One sentence max. Define what it IS, not what it does.
+- **Show relationships.** Use bold term names and express cardinality where obvious.
+- **Only include terms specific to this project's context.** General programming concepts (timeouts, error types, utility patterns) don't belong even if the project uses them extensively. Before adding a term, ask: is this a concept unique to this context, or a general programming concept? Only the former belongs.
+- **Group terms under subheadings** when natural clusters emerge. If all terms belong to a single cohesive area, a flat list is fine.
+- **Write an example dialogue.** A conversation between a dev and a domain expert that demonstrates how the terms interact naturally and clarifies boundaries between related concepts.
+
+### Single vs multi-context repos
+
+**Single context (most repos):** One `CONTEXT.md` at the repo root.
+
+**Multiple contexts:** A `CONTEXT-MAP.md` at the repo root lists the contexts, where they live, and how they relate to each other:
+
+```md
+# Context Map
+
+## Contexts
+
+- Ordering — receives and tracks customer orders
+- Billing — generates invoices and processes payments
+- Fulfillment — manages warehouse picking and shipping
+
+## Relationships
+
+- **Ordering → Fulfillment**: Ordering emits `OrderPlaced` events; Fulfillment consumes them to start picking
+- **Fulfillment → Billing**: Fulfillment emits `ShipmentDispatched` events; Billing consumes them to generate invoices
+- **Ordering ↔ Billing**: Shared types for `CustomerId` and `Money`
+```
+
+The skill infers which structure applies:
+
+- If `CONTEXT-MAP.md` exists, read it to find contexts
+- If only a root `CONTEXT.md` exists, single context
+- If neither exists, create a root `CONTEXT.md` lazily when the first term is resolved
+
+When multiple contexts exist, infer which one the current topic relates to. If unclear, ask.
+
+---
+
+## Appendix B: ADR format
+
+ADRs live in `docs/adr/` and use sequential numbering: `0001-slug.md`, `0002-slug.md`, etc.
+
+Create the `docs/adr/` directory lazily — only when the first ADR is needed.
+
+### Template
+
+```md
+# {Short title of the decision}
+
+{1-3 sentences: what's the context, what did we decide, and why.}
+```
+
+That's it. An ADR can be a single paragraph. The value is in recording *that* a decision was made and *why* — not in filling out sections.
+
+### Optional sections
+
+Only include these when they add genuine value. Most ADRs won't need them.
+
+- **Status** frontmatter (`proposed | accepted | deprecated | superseded by ADR-NNNN`) — useful when decisions are revisited
+- **Considered Options** — only when the rejected alternatives are worth remembering
+- **Consequences** — only when non-obvious downstream effects need to be called out
+
+### Numbering
+
+Scan `docs/adr/` for the highest existing number and increment by one.
+
+### When to offer an ADR
+
+All three of these must be true:
+
+1. **Hard to reverse** — the cost of changing your mind later is meaningful
+2. **Surprising without context** — a future reader will look at the code and wonder "why on earth did they do it this way?"
+3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
+
+If a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing."
+
+#### What qualifies
+
+- **Architectural shape.** "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres."
+- **Integration patterns between contexts.** "Ordering and Billing communicate via domain events, not synchronous HTTP."
+- **Technology choices that carry lock-in.** Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out.
+- **Boundary and scope decisions.** "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s.
+- **Deliberate deviations from the obvious path.** "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate.
+- **Constraints not visible in the code.** "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract."
+- **Rejected alternatives when the rejection is non-obvious.** If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months.

package/skills/handoff.md

@@ -0,0 +1,59 @@
+---
+name: handoff
+tier: "2"
+description: Enforces Law 5 (Reflect After Every Session) of the 7 Laws of AI Agent Discipline. Compact the current conversation into a handoff document for another agent to pick up. Ported from mattpocock/skills under MIT.
+argument-hint: "What will the next session be used for?"
+origin: https://github.com/mattpocock/skills
+---
+
+# /handoff — Hand the session off to a fresh agent
+
+Ported verbatim in behavior from [mattpocock/skills `in-progress/handoff`](https://github.com/mattpocock/skills/blob/main/skills/in-progress/handoff/SKILL.md) (MIT, © 2026 Matt Pocock). Cold-storage snapshot at [`third-party/mattpocock-skills/skills/in-progress/handoff/SKILL.md`](../third-party/mattpocock-skills/skills/in-progress/handoff/SKILL.md); SHA pin in [`third-party/MANIFEST.md`](../third-party/MANIFEST.md).
+
+## What this skill does
+
+Write a handoff document summarising the current conversation so a fresh agent can continue the work. Save it to a path produced by `mktemp -t handoff-XXXXXX.md` (read the file before you write to it).
+
+Suggest the skills to be used, if any, by the next session.
+
+Do not duplicate content already captured in other artifacts (PRDs, plans, ADRs, issues, commits, diffs). Reference them by path or URL instead.
+
+If the user passed arguments, treat them as a description of what the next session will focus on and tailor the doc accordingly.
+
+## When to fire it
+
+- End of a working session that did not finish the task — you want the next agent to pick up cold without re-reading the whole transcript.
+- Context budget approaching the ceiling and `/compact` would lose load-bearing state — write a handoff doc first, then compact.
+- Switching from one repo or branch to another mid-session — capture what was decided in the active context before the swap.
+- Before invoking a long-running autonomous loop (`/ralph`, `/loop`) that will run while you are away.
+
+## What goes in the doc
+
+The handoff is a brief, not a transcript. A useful one fits on one screen and answers, in order:
+
+1. **Goal** — the one-sentence outcome the user is steering toward.
+2. **Current state** — what is actually true on disk / in the system right now (branch, last commit, open files, last verified step).
+3. **Decisions made this session** — only what is not already in commits, PRDs, ADRs, or the plan doc.
+4. **Open questions** — blocking choices the next agent needs the user to answer before continuing.
+5. **Next concrete step** — the single action the next agent should take first.
+6. **Skills to load** — names of the skills the next session should activate (e.g. `verification-loop`, `superpowers:writing-plans`, `gateguard`).
+
+Anything that is already captured elsewhere gets a path or URL pointer, not a duplicate.
+
+## How it fits the 7 Laws
+
+| Law | Role of this skill |
+|---|---|
+| Law 5 (Reflect After Every Session) | The handoff is the reflection artifact — what changed, what was decided, what remains. |
+| Law 7 (Learn From Every Session) | Naming the skills the next session should activate is a learned-pattern signal. |
+| Law 2 (Plan Is Sacred) | The "next concrete step" preserves the existing plan across the session boundary instead of restarting from blank. |
+
+## Companion / alternative skills
+
+- [`strategic-compact`](./strategic-compact.md) — compact the current session at a phase boundary instead of writing a handoff doc. Use when the session continues with the same agent.
+- [`para-memory-files`](./para-memory-files.md) — durable cross-session memory under `~/.claude/memory/`. Use for classified facts (user, project, feedback, reference), not per-session handoff briefs.
+- `superpowers:writing-plans` — produce the plan doc the handoff can reference instead of duplicating.
+
+## Attribution
+
+This skill is a port of [mattpocock/skills `in-progress/handoff`](https://github.com/mattpocock/skills/blob/main/skills/in-progress/handoff/SKILL.md). MIT-licensed upstream, MIT-licensed here. See [`third-party/mattpocock-skills/LICENSE`](../third-party/mattpocock-skills/LICENSE) for the verbatim license and [`third-party/mattpocock-skills/OUR_NOTES.md`](../third-party/mattpocock-skills/OUR_NOTES.md) for the vendoring rationale and drift radar.

package/skills/para-memory-files.md

@@ -63,7 +63,7 @@ $AGENT_HOME/life/
 - Significant project or company in the user's life.
 - Otherwise, note it in daily notes.
 
-For the atomic fact YAML schema and memory decay rules, see [references/schemas.md](references/schemas.md).
+Atomic facts in `items.yaml` use the fields `id`, `created`, `content`, and optional `status` (`active` or `superseded`) with `superseded_by` pointing to the replacing fact. Memory decay is manual: rewrite `summary.md` weekly from active facts and move inactive entity folders to `archives/`.
 
 ### Layer 2: Daily Notes (`$AGENT_HOME/memory/YYYY-MM-DD.md`)
 

package/skills/proceed-with-the-recommendation.md

@@ -57,21 +57,95 @@ Do NOT use when:
 - User scoped the work ("just the first one", "only the safe ones") — honor the scope
 - Recommendations conflict with project agent-instruction files (CLAUDE.md / AGENTS.md / GEMINI.md / equivalent)
 
+## Fast-Path: `--once` Mode
+
+For single-item, low-risk confirmations, the seven-phase flow below is overkill — P-MAG + plan-restate + reflect + three-section close add more ceremony than the work itself. `--once` is an opt-in fast path that runs **Phase 1 (Pre-Flight) + Phase 3 (Execute) + Phase 4 (Verify) only**. Phase 0 (P-MAG), Phase 2 (Plan), Phase 5 (Iterate-on-failure restart), Phase 6 (Reflect), and Phase 7 (three-section close) are skipped.
+
+### When `--once` applies
+
+Invoke `--once` only when ALL of the following hold:
+
+- The prior turn's recommendation list contained **exactly one** item.
+- The item is tagged **`safe`** in Phase 1 (not `caution`, not `needs-approval`).
+- The item is fully verifiable with a single smallest check (one typecheck, one curl, one read-back, one command output snippet).
+- The user explicitly added `--once` to the trigger or invoked `/proceed-with-the-recommendation --once`.
+
+### Trigger phrases for `--once`
+
+- `/proceed-with-the-recommendation --once`
+- `/proceed --once`
+- "proceed once with that"
+- "just do that one"
+- Any standard trigger phrase plus the literal `--once` suffix anywhere in the user message
+
+### What runs under `--once`
+
+| Phase | Status under `--once` |
+|---|---|
+| Phase 0 — P-MAG | **Skipped.** Reason: single-item runs do not accumulate enough state to need a past-mistake gate; running it twice on the same surface within minutes is wasted ceremony. |
+| Phase 1 — Pre-Flight | **Runs.** Restate the one item, tag it `safe`, route it. |
+| Phase 2 — Plan | **Skipped.** Reason: a one-line item does not need a `docs/plans/` artifact. |
+| Phase 3 — Execute | **Runs.** Route to the preferred skill or inline fallback. |
+| Phase 4 — Verify | **Runs.** Smallest check, with the output snippet quoted verbatim. |
+| Phase 5 — Iterate | **Halts on failure.** If Phase 4 fails, do NOT silently restart — report the failure and stop. The operator decides whether to re-invoke the full flow. |
+| Phase 6 — Reflect | **Skipped.** No Reflection block, no `observations.jsonl` append, no `Will NOT repeat:` carry-forward. |
+| Phase 7 — Three-section close | **Skipped.** The reply ends with a single line: `Done: <item>. Verified: <check + output>.` No tiered tables, no WILD/RISA, no `Want me to: A or B?` closer. |
+
+### Hard preconditions (refuse `--once` if any fail)
+
+`--once` MUST refuse and fall back to the full flow if:
+
+- The recommendation list has more than one item. The seven-phase flow exists because multi-item runs accumulate state across items; the fast path cannot guarantee that.
+- The item is tagged `caution` or `needs-approval`. P-MAG is the gate that catches "we already broke this last week"; skipping it on caution-tagged work is exactly the failure pattern the gate was built for.
+- The item touches `>3` files, `>150` LOC, or any of `.github/`, `bin/`, `lib/`, `src/`, `third-party/`. Those surfaces have explicit invariants (`verify:all`, the third-party vendor contract, the `.mts` build pipeline) that the seven-phase flow protects.
+- The item is destructive (deploy, force-push, DB drop, secret rotation, file delete that is not a generated artifact). These always route through the full flow regardless of size.
+
+If a precondition fails, emit one line: `--once refused: <reason>. Falling back to full proceed flow.` and continue with Phase 0.
+
+### What you give up
+
+`--once` trades reflection + learning + close-discipline for speed. Concrete losses per skipped phase:
+
+- **No P-MAG read** — past mistakes from prior sessions are not surfaced. Acceptable on single-file safe edits; risky on anything touching code paths the operator has corrected before.
+- **No Reflect block** — the run does not append to `observations.jsonl`. Mulahazah will not learn from this iteration.
+- **No three-section close** — the next turn cannot use `wild-risa-balance` tier inference from a `## Recommendation (expert|beginner)` heading because no such heading shipped.
+
+`--once` is the right call when the work is genuinely smaller than the ceremony. For anything larger, the seven-phase flow is the discipline.
+
+### Example
+
+Prior turn (last item from a five-item recommendation block):
+
+> 5. Run `npm run verify:docs-substrings` and confirm green before committing.
+
+Operator: `/proceed --once`
+
+Under `--once`, the entire response is two lines:
+
+```
+Routed to: inline (Bash). Item: "Run npm run verify:docs-substrings and confirm green." Tag: safe.
+Done: ran `npm run verify:docs-substrings`. Verified: `OK docs-substrings: all 150 substring assertion(s) match their target files.`
+```
+
+No Phase 0 quote, no `Will NOT repeat:`, no Reflection, no tiered tables, no `Want me to:` closer.
+
 ## Phase 0: Acknowledge (Past Mistake Acknowledgment Gate / P-MAG)
 
 Before research begins, the skill must read its own track record. The instinct system records corrections; this gate forces the read at the moment they actually matter — before a new recommendation list is touched. **Three rules, in order. None is optional.**
 
 ### Rule 1 — Acknowledge before context (right context from the beginning)
 
-Scan three surfaces and quote literal evidence:
+Run [`scripts/scan-past-mistakes.mjs`](../scripts/scan-past-mistakes.mjs) at the project root. Scan three surfaces in one pass and surface every entry with a citation:
+
+- `~/.claude/instincts/<project-hash>/observations.jsonl` — last N (default 10) entries with `type: failure` or `correction` (legacy `event` field also matched for pre-2026-05-06 rows)
+- `~/.claude/projects/<project-hash>/memory/feedback_*.md` — every file whose frontmatter declares `type: feedback`; the canonical home of the operator's named corrections (e.g. `feedback_past_mistake_gate.md`, `feedback_no_git_add_all_on_windows.md`)
+- `<project-root>/CLAUDE.md` "## Past Mistakes" table rows (if present)
 
-- `~/.claude/instincts/<project-hash>/observations.jsonl` — last 10 entries with `type: failure` or `correction`
-- `~/.claude/projects/<project-hash>/memory/feedback_*.md` — auto-memory `feedback`-typed entries (named-pattern corrections the operator declared in prior sessions); `~/.claude/projects/<project-hash>/memory/MEMORY.md` is the index of these files
-- The active project's `CLAUDE.md` "Past Mistakes" section (if present)
+Pass `--json` for machine consumption, or override paths via `--observations <path>`, `--memory-dir <dir>`, `--claude-md <path>` (the auto-detection derives all three from the project root via the standard `<hash>` convention). If the script outputs `No prior mistakes recorded — proceed.`, all three surfaces were empty and Rule 1 is satisfied.
 
-The auto-memory `feedback_*.md` surface is the canonical home of the operator's named corrections (e.g. `feedback_past_mistake_gate.md`, `feedback_no_git_add_all_on_windows.md`). Skipping it because the file path is project-host-specific is the most common silent failure of this gate — the rule explicitly enumerates it so this skill cannot rationalize the omission.
+For each scanned entry, emit one line: `Past mistake observed: <quote>. Source: <file:line>. Active in current scope: yes|no.` The script provides the quote + source citation; the active-in-scope judgment is yours — read each surface against the recommendation list and decide.
 
-Emit one line per matching entry: `Past mistake observed: <quote>. Source: <file:line>. Active in current scope: yes|no.` If all three surfaces are empty, emit `No prior mistakes recorded — proceed.` Never skip silently — silent skip defeats the instinct system.
+Skipping this scan because the surface paths are project-host-specific is the historically most common silent failure of this gate; the script removes that excuse. If the script must run, a skip surfaces as no output emitted at all — making the bypass detectable rather than invisible.
 
 ### Rule 2 — Clearance gate (don't proceed until the mistake is gone)
 
@@ -128,6 +202,8 @@ For each item in the ORIGINAL order:
 
 ### Routing Table (with Inline Fallbacks)
 
+Run [`scripts/route-recommendation.mjs "<item>"`](../scripts/route-recommendation.mjs) to match a single recommendation item to its preferred chain + inline fallback. Default mode prints the matched row; `--json` for programmatic consumption; `--list` enumerates every row. The programmatic source of truth is [`scripts/route-recommendation.routes.json`](../scripts/route-recommendation.routes.json) — the table below is the human-readable documentation that mirrors it. If they drift, the routes.json file wins.
+
 Rows whose **Preferred skill** is not bundled with the `continuous-improvement` plugin carry a `(Reference behavior — does not require <skill>.)` marker on the fallback cell. The marker makes the soft-dependency contract visible at point of use: the inline fallback is fully self-contained and runs without that skill installed. Rows whose preferred skill ships with the plugin (`ralph`, `tdd-workflow`, `continuous-improvement`) carry no marker — the dedicated skill is always available.
 
 | Recommendation type | Preferred skill | Inline fallback |

package/skills/ralph.md

@@ -3,6 +3,7 @@ name: ralph
 tier: companion
 description: "Enforces Law 6 (Iterate Means One Thing) of the 7 Laws of AI Agent Discipline at PRD scale. Ralph is an autonomous AI agent loop that runs repeatedly until all PRD items are complete. Converts PRDs to executable JSON, implements stories iteratively with quality checks, and tracks progress."
 origin: https://github.com/snarktank/ralph
+disable-model-invocation: true
 ---
 
 # Ralph — Autonomous Agent Loop

package/skills/recall.md

@@ -0,0 +1,50 @@
+---
+name: recall
+tier: "1"
+description: Enforces Law 1 (Research Before Executing) of the 7 Laws of AI Agent Discipline. Makes past sessions first-class research material by searching the observation log with BM25 ranking, so 'have I hit this before?' is answerable before re-deriving a fix or repeating a mistake.
+origin: continuous-improvement
+user-invocable: true
+---
+
+# Recall — Episodic Search Over Past Sessions
+
+Law 1 says research before executing. The cheapest research is your own history: the exact error you are staring at may have been solved three sessions ago. `observations.jsonl` already records every tool call, but an append-only log is not searchable. Recall turns that log into a ranked, queryable memory.
+
+## When to Activate
+
+- Before tackling a problem that feels familiar ("haven't I seen this error before?").
+- Before a risky or destructive operation — check whether a past attempt failed.
+- Before reading large files from scratch — a past session may already summarize the relevant facts.
+- When onboarding into an unfamiliar area of the codebase that you have touched before.
+
+## Core Concept
+
+Recall builds an in-memory BM25 index over the observation rows and answers a query with the most relevant past activity, newest-first on ties:
+
+```
+ci_recall query="permission denied push"
+ci_recall query="jq command not found" k=3
+ci_recall query="auth login" since=7d
+```
+
+Each result is a past tool call with a redacted snippet, a relevance score, and a timestamp.
+
+## Privacy
+
+Snippets are passed through a secret redactor before they are surfaced. AWS access keys, JWT-shaped triplets, bearer tokens, `KEY`/`SECRET`/`TOKEN`/`PASSWORD` assignments, and long hex strings are masked. The observation log already caps output at 200 characters; redaction is the second layer.
+
+## Limitations
+
+- **Lexical, not semantic.** A query for "login" will not surface activity that only ever said "authentication". Search with the vocabulary that actually appeared in the tool calls, or try several phrasings.
+- **Scoped to the captured history.** Recall only knows what the hooks recorded. Thin-schema rows (no input/output, emitted when the Node observer is not wired) contribute little signal.
+- **In-memory rebuild per query.** Dependency-free and fast at current volumes; a `node:sqlite` FTS5 index is a planned follow-up if the log grows past ~100k rows.
+
+## How to Invoke
+
+Exposed as the `ci_recall` MCP tool (expert mode) and the `/recall` slash command. `query` is required; `k` (default 5) and `since` (ISO timestamp or `7d`/`24h`/`30m`) are optional.
+
+## Pairs With
+
+- **`gateguard`** (Law 1) — before clearing a high-risk action, recall whether a past attempt at the same thing failed.
+- **`continuous-improvement`** (core SKILL.md, Law 7 — Learn From Every Session) — recall is the retrieval side of the same observation log the instinct engine learns from.
+- **`workspace-surface-audit`** — recall confirms whether the environment facts the audit records have bitten this project before.

package/skills/reconcile.md

@@ -0,0 +1,80 @@
+---
+name: reconcile
+tier: "2"
+description: Enforces Law 1 (Research Before Executing) of the 7 Laws of AI Agent Discipline. Establishes git ground truth — branch, status, stashes, worktrees, ahead/behind — before any mutation, halts on protected or destructive operations, and verifies a push actually landed instead of assuming it did.
+origin: continuous-improvement
+user-invocable: true
+---
+
+# Reconcile — Ground-Truth Git State Before You Touch It
+
+Law 1 says research before executing. The most expensive skipped research is the state of your own repo: a branch that shifted under you, a push that silently did not land, a stash from a session you forgot. This skill establishes git ground truth first, acts only on a known state, and stops at every operation that is hard to reverse.
+
+## When to Activate
+
+- Before any branch/merge/rebase/push when more than one session, loop, or agent may be writing to the tree.
+- When the working tree looks different from what you expect (unexpected branch, surprise modifications, a half-finished merge).
+- Before cleaning up: consolidating branches, dropping stashes, removing worktrees.
+- After a push, to confirm it actually landed on the remote.
+
+## Establish Ground Truth First
+
+Read before you write. Capture the full state in one pass:
+
+```
+git branch --show-current
+git status --porcelain=v1
+git rev-list --left-right --count @{u}...HEAD     # behind / ahead of upstream
+git stash list
+git worktree list
+ls .git/MERGE_HEAD .git/rebase-merge .git/rebase-apply 2>/dev/null   # in-progress operation?
+```
+
+On Windows with `autocrlf=true`, `git status` reports phantom line-ending-only modifications. Trust `git diff --stat` (and `git diff --ignore-all-space`) for real content drift, not `git status`. Never stage with `git add -A` / `git add .` on such a tree — stage by explicit filename.
+
+## Detect a Concurrent Writer
+
+When another session/loop may be active, do not assume the tree is yours:
+
+- An in-progress `MERGE_HEAD` / `rebase-merge` you did not start means another actor is mid-operation. Do not "help" by editing conflicted files — wait, or hand off.
+- Re-read the current branch immediately before any mutation; if it shifted since your snapshot, re-survey from the top.
+- If `.git/index` keeps changing while you are idle, a writer is active. Pause and surface it rather than racing.
+- If `gateguard` is installed, its Parallel-Actor Gate already captured this baseline on the session's first mutation (via `scripts/git-state-snapshot.sh`) and divergence-checks every later mutation — `reconcile` complements that gate, it does not replace it. Without gateguard, run the snapshot above yourself.
+
+## Classify, Then Act
+
+Map the upstream relationship before choosing an action:
+
+- **even** (0 ahead / 0 behind) → safe to branch.
+- **ahead only** → push (after the protected-op gate below) or open a PR.
+- **behind only** → `git pull --ff-only`.
+- **diverged** (both) → rebase or merge deliberately; never blind `--force`.
+
+Branch from a base only after confirming `local <base>` equals `origin/<base>` — a squash-merge will otherwise silently bundle ahead-of-origin commits.
+
+## Halt on Protected or Destructive Operations
+
+STOP and get explicit authorization before:
+
+- Pushing to a protected branch (e.g. `main`) — this repo's flow is feature branch + PR, never direct push.
+- `git push --force` / `--force-with-lease`, `git reset --hard`, `git clean -fd`, `worktree remove` on a dirty worktree, or dropping a stash with uncommitted value.
+
+If a rebase has diverged and force-push is gated, do not force-recover — supersede via a new branch + new PR.
+
+## Verify the Push Actually Landed
+
+A push that printed no error is still a claim. Confirm:
+
+```
+git rev-parse HEAD
+git ls-remote origin refs/heads/<branch>     # remote tip must equal local HEAD
+```
+
+If the remote ref is absent or behind, the push did not land — investigate before reporting success.
+
+## Pairs With
+
+- **`recall`** (Law 1) — before a risky git op, recall whether the same operation failed on this repo before.
+- **`gateguard`** (Law 1) — the runtime gate (`hooks/gateguard.mjs`); `reconcile` is the procedure you run once a destructive git action is in play.
+- **`safety-guard`** — destructive-operation guardrails for production and autonomous runs.
+- **`audit`** (Law 4) — when an audit ends in a fix, `reconcile` is the safe path from branch to landed PR.

package/skills/recovery-classification.md

@@ -3,6 +3,7 @@ name: recovery-classification
 tier: "2"
 description: "Enforces Law 4 (Verify Before Reporting) of the 7 Laws of AI Agent Discipline. After any failure in the verification ladder or auto-loop, classify the failure class before retrying — provider, tool-schema, deterministic-policy, git, worktree, runtime — so retry-vs-pause-vs-self-heal-vs-stop is an intentional decision, not a generic 'try again'."
 origin: continuous-improvement
+user-invocable: false
 ---
 
 # Recovery Classification Skill

package/skills/safety-guard.md

@@ -3,6 +3,7 @@ name: safety-guard
 tier: "2"
 description: Enforces Law 3 (One Thing at a Time) of the 7 Laws of AI Agent Discipline by scoping edits to a directory and blocking destructive shell commands. Use this skill to prevent destructive operations when working on production systems or running agents autonomously.
 origin: continuous-improvement
+disable-model-invocation: true
 ---
 
 # Safety Guard — Prevent Destructive Operations