continuous-improvement 3.9.2 → 3.11.0

package/skills/goal-monitor.md

@@ -0,0 +1,81 @@
+---
+name: goal-monitor
+tier: "2"
+description: Enforces Law 2 (Plan Is Sacred) of the 7 Laws of AI Agent Discipline. Detects when a session has drifted away from its stated goal by scoring recent tool activity against the '## Goal' section of task_plan.md, so drift is caught mid-session instead of at end-of-session reflection.
+origin: continuous-improvement
+user-invocable: true
+---
+
+# Goal Monitor — Continuous Drift Detection
+
+A "Clear Goal" discipline: a stated goal is only useful if something keeps checking the work against it. `task_plan.md` captures the goal once; this skill turns it into a recurring check so a session that has quietly wandered off into unrelated files surfaces the drift while there is still budget to course-correct.
+
+## When to Activate
+
+- After a long stretch of edits, before claiming progress on the original goal.
+- When you suspect the work has sprawled across unrelated areas of the codebase.
+- Before a checkpoint or handoff, to confirm the session stayed on its stated goal.
+- Any time the goal in `task_plan.md` and the actual tool activity might have diverged.
+
+## Core Concept
+
+Law 2 says the plan is sacred. But "sacred" is hollow if nothing measures adherence. Goal Monitor scores the most recent observations against the goal and reports one of three states:
+
+```
+ON GOAL  — recent activity relates to the goal (score >= threshold)
+DRIFT    — most recent activity is unrelated, or touched forbidden paths
+NO DATA  — not enough observations in the window yet
+```
+
+The score is the fraction of recent observations whose tool name, input, or output references a goal keyword — or whose edited path falls under a goal-scope glob.
+
+## Goal Source
+
+The check reads, in order:
+
+1. `task_plan.md` in the project root (seeded by `ci_plan_init` / `/planning-with-files`).
+2. `~/.claude/instincts/<project-hash>/goal.md` (fallback for non-repo sessions).
+3. An explicit `goal_file` argument, if provided.
+
+The plan needs a `## Goal` section. Two optional sections sharpen the signal:
+
+```markdown
+## Goal
+Implement OAuth login with JWT session tokens for the auth service.
+
+## Goal Keywords
+oauth, jwt, login, session
+
+## Goal Scope
+paths: src/auth/**, test/auth/**
+forbidden: src/marketing/**
+```
+
+When `## Goal Keywords` is absent, keywords are auto-extracted from the goal prose (stopwords and short tokens dropped). `## Goal Scope` is optional: `paths` globs count as on-goal matches; `forbidden` globs are a hard drift signal even when keywords also match.
+
+## How to Invoke
+
+The check is exposed as the `ci_goal_check` MCP tool (expert mode) and the `/goal-check` slash command:
+
+```
+ci_goal_check                      # score the last 30 observations against task_plan.md
+ci_goal_check limit=50             # widen the window
+ci_goal_check goal_file=docs/x.md  # score against a specific plan file
+```
+
+## Acting on the Result
+
+- **ON GOAL** — proceed; the plan and the work agree.
+- **DRIFT** — stop and decide explicitly: either steer back to the goal, or, if the goal has legitimately changed, update the `## Goal` section so the plan stays the single source of truth. Do not silently let the work and the plan disagree — that is exactly the Law 2 violation this skill exists to catch.
+- **NO DATA** — keep working; the observation window is still filling.
+
+## Limitations
+
+- Keyword scoring is lexical, not semantic: a goal that says "login" will not match activity that only ever says "authentication". Add synonyms to `## Goal Keywords` when vocabulary diverges.
+- A deliberately broad goal ("refactor the whole repo") will score nearly everything as on-goal. Use `## Goal Scope` to add precision when the goal is narrow.
+
+## Pairs With
+
+- **`proceed-with-the-recommendation`** (orchestrator, Law 2) — run a goal check at phase boundaries to confirm the plan still matches the work.
+- **`para-memory-files`** / planning-with-files — the `## Goal` section this skill reads is the same one those workflows write.
+- **`strategic-compact`** — before compacting a long session, a goal check confirms what the session was actually about.

package/skills/grill-me.md

@@ -0,0 +1,66 @@
+---
+name: grill-me
+tier: "2"
+description: Enforces Law 1 (Research Before Executing) of the 7 Laws of AI Agent Discipline. Interview the user relentlessly about a plan or design until shared understanding is reached, resolving every branch of the decision tree before any code is written. Ported from mattpocock/skills under MIT.
+origin: https://github.com/mattpocock/skills
+---
+
+# /grill-me — Interrogate the plan before executing it
+
+Ported verbatim in behavior from [mattpocock/skills `productivity/grill-me`](https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md) (MIT, © 2026 Matt Pocock). Cold-storage snapshot at [`third-party/mattpocock-skills/skills/productivity/grill-me/SKILL.md`](../third-party/mattpocock-skills/skills/productivity/grill-me/SKILL.md); SHA pin in [`third-party/MANIFEST.md`](../third-party/MANIFEST.md).
+
+## What this skill does
+
+Interview the user relentlessly about every aspect of the 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.
+
+If a question can be answered by exploring the codebase, explore the codebase instead.
+
+## When to fire it
+
+- The user has just stated a goal at a high level ("add auth", "speed up the API") with no spec underneath.
+- A `/proceed-with-the-recommendation` walk is about to start but the recommendation list itself is ambiguous about scope or success criteria.
+- An RFC, PRD, or plan doc is being drafted and the user wants pressure on the assumptions before writing it.
+- The user types "grill me", "stress-test this plan", or "interview me about X".
+- `gateguard` is firing because the agent does not have enough grounding to proceed safely on a Write/Edit/Bash — alignment is missing, not just facts.
+
+## How it differs from `gateguard`
+
+`gateguard` is a tool-boundary gate that blocks Edit / Write / Bash until the agent provides concrete investigation (importers, schemas, user instruction). It catches the case where the agent thinks it knows enough to mutate state. `grill-me` is the conversational layer one floor above: it surfaces the missing decisions before any tool call would even be attempted. They compose:
+
+| Gap | Caught by |
+|---|---|
+| Agent has no spec, no plan — about to invent one | `grill-me` |
+| Agent has a plan but specific branches are under-specified | `grill-me` |
+| Agent is about to Edit / Write / Bash without grounding | `gateguard` |
+| Plan exists, grounded, but the implementation drifts | `verification-loop`, `tdd-workflow` |
+
+## Interview discipline
+
+Five rules the agent should hold while grilling:
+
+1. **One question at a time.** Multi-question turns let the user skim and answer the easy ones. Force depth on each branch.
+2. **Always recommend.** Every question carries a "my answer would be X because Y" so the user can confirm, override, or expose a third option you hadn't considered.
+3. **Explore before asking.** If `grep` / `ls` / a quick read can answer the question, do that first. Do not waste user attention on questions the codebase already answers.
+4. **Walk the tree, do not jump.** Resolve dependencies in order — do not ask about deployment if you have not pinned the data model yet.
+5. **Stop when the spec is shippable.** The end state is a plan a fresh agent could execute cold, not an endless interview. When the next agent could pick up the doc and run, stop.
+
+## How it fits the 7 Laws
+
+| Law | Role of this skill |
+|---|---|
+| Law 1 (Research Before Executing) | Pre-execution interrogation closes the alignment gap that misaligns the agent with the user before any tool call. |
+| Law 2 (Plan Is Sacred) | The interview produces a plan grounded in real decisions, not invented defaults. |
+| Law 4 (Verify Before Reporting) | Every recommended answer is a falsifiable claim the user can correct in the moment. |
+
+## Companion / alternative skills
+
+- [`gateguard`](./gateguard.md) — tool-boundary gate; blocks Edit / Write / Bash until grounding is presented. Fires after `grill-me` has aligned the spec.
+- [`workspace-surface-audit`](./workspace-surface-audit.md) — Law 1 surface audit; inventory of MCP servers, plugins, env, hooks. Use when the missing context is "what is available in this repo" rather than "what should we build."
+- [`superpowers:brainstorming`](https://github.com/obra/superpowers/blob/main/skills/brainstorming/SKILL.md) — Socratic design refinement. Use for open-ended ideation; use `grill-me` once the idea is committed and needs hardening.
+- [`handoff`](./handoff.md) — session-end compaction. Pair with `grill-me`: grill at start, handoff at end.
+
+## Attribution
+
+This skill is a port of [mattpocock/skills `productivity/grill-me`](https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/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/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.