@heihei0299/matt-skills 1.3.2 → 1.5.2

package/scripts/sync-upstream.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url';
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const LOCAL_SKILLS_DIR = path.join(ROOT, '.agents', 'skills');
 const PROPRIETARY_PATH = path.join(ROOT, 'config', 'proprietary.json');
+const ENGINEERING_PATH = path.join(ROOT, 'config', 'engineering.json');
 const UPSTREAM_URL = 'https://github.com/mattpocock/skills.git';
 
 // 重命名映射：上游已重命名，本地旧名需迁移
@@ -21,7 +22,16 @@ async function loadProprietary() {
     const raw = await readFile(PROPRIETARY_PATH, 'utf8');
     return new Set(JSON.parse(raw));
   } catch {
-    return new Set(['tdd-implement', 'grill-to-spec', 'diagnose-fix', 'commit-check', 'instance-test']);
+    return new Set(['ci-guard', 'tdd-implement', 'grill-to-spec', 'diagnose-fix', 'commit-check', 'scaffold-functional-test']);
+  }
+}
+
+async function loadEngineering() {
+  try {
+    const raw = await readFile(ENGINEERING_PATH, 'utf8');
+    return new Set(JSON.parse(raw));
+  } catch {
+    return new Set(['ask-matt','code-review','codebase-design','diagnosing-bugs','domain-modeling','grill-with-docs','implement','improve-codebase-architecture','prototype','research','resolving-merge-conflicts','setup-matt-pocock-skills','tdd','to-spec','to-tickets','triage','wayfinder','wizard']);
   }
 }
 
@@ -103,12 +113,19 @@ async function collectLocalSkills(proprietary) {
   return map;
 }
 
-export async function compare({ upstreamUrl, tmpDir, ref } = {}) {
+export async function compare({ upstreamUrl, tmpDir, ref, onlyProgramming = true } = {}) {
   const proprietary = await loadProprietary();
+  const engineering = await loadEngineering();
   const fetched = await fetchUpstream({ tmpDir, upstreamUrl, ref });
   const upstreamRoot = fetched.dest;
-  const upstreamMap = await collectUpstreamSkills(upstreamRoot);
-  const localMap = await collectLocalSkills(proprietary);
+  const upstreamMapFull = await collectUpstreamSkills(upstreamRoot);
+  const localMapFull = await collectLocalSkills(proprietary);
+  // 编程子集：engineering 桶即编程（默认），--all 则含 productivity
+  const upstreamMap = onlyProgramming
+    ? new Map([...upstreamMapFull.entries()].filter(([, v]) => v.bucket === 'engineering'))
+    : upstreamMapFull;
+  const localMap = localMapFull;
+  const isEngineering = (name) => engineering.has(name);
 
   const added = [];
   const updated = [];
@@ -118,27 +135,28 @@ export async function compare({ upstreamUrl, tmpDir, ref } = {}) {
 
   // 检测重命名：本地旧名存在且上游新名存在，且本地旧名不在上游
   for (const [oldName, newName] of Object.entries(RENAMES)) {
-    if (localMap.has(oldName) && upstreamMap.has(newName) && !upstreamMap.has(oldName)) {
-      renamed.push({ from: oldName, to: newName });
+    if (onlyProgramming) {
+      if (localMap.has(oldName) && upstreamMap.has(newName) && !upstreamMap.has(oldName)) {
+        renamed.push({ from: oldName, to: newName });
+      }
+    } else {
+      if (localMap.has(oldName) && upstreamMapFull.has(newName) && !upstreamMapFull.has(oldName)) {
+        renamed.push({ from: oldName, to: newName });
+      }
     }
   }
   const renamedFrom = new Set(renamed.map((r) => r.from));
   const renamedTo = new Set(renamed.map((r) => r.to));
 
   for (const [name, u] of upstreamMap.entries()) {
-    if (renamedTo.has(name)) continue; // 重命名的新名单独处理
+    if (renamedTo.has(name)) continue;
     const local = localMap.get(name);
-    if (!local) {
-      added.push(name);
-    } else if (local.hash !== u.hash) {
-      updated.push(name);
-    } else {
-      same.push(name);
-    }
+    if (!local) added.push(name);
+    else if (local.hash !== u.hash) updated.push(name);
+    else same.push(name);
   }
-  // 重命名的也算 updated（需迁移）
   for (const r of renamed) {
-    const u = upstreamMap.get(r.to);
+    const u = upstreamMap.get(r.to) || upstreamMapFull.get(r.to);
     const local = localMap.get(r.from);
     if (local && u && local.hash !== u.hash) updated.push(`${r.from}→${r.to}`);
     else if (!local) added.push(r.to);
@@ -147,35 +165,46 @@ export async function compare({ upstreamUrl, tmpDir, ref } = {}) {
 
   for (const name of localMap.keys()) {
     if (renamedFrom.has(name)) continue;
-    if (!upstreamMap.has(name) && !renamedTo.has(name)) {
-      removed.push(name);
-    }
+    if (upstreamMap.has(name) || renamedTo.has(name)) continue;
+    // 编程模式下仅报告 engineering 本地技能的删除；productivity/instance-test 等跳过
+    if (onlyProgramming && !isEngineering(name)) continue;
+    // 全量模式下所有本地非独有且不在上游的都视为 removed
+    removed.push(name);
   }
 
+  const localCount = onlyProgramming
+    ? [...localMap.keys()].filter(isEngineering).length
+    : localMap.size;
   return {
     head: fetched.head,
     dest: fetched.dest,
     upstreamMap,
+    upstreamMapFull,
     localMap,
+    localMapFull,
     proprietary: [...proprietary],
+    engineering: [...engineering],
+    onlyProgramming,
     result: { added: added.sort(), updated: updated.sort(), same: same.sort(), removed: removed.sort(), renamed },
-    counts: { upstream: upstreamMap.size, local: localMap.size },
+    counts: { upstream: upstreamMap.size, local: localCount, upstreamFull: upstreamMapFull.size, localFull: localMapFull.size },
   };
 }
 
-export async function applySync({ upstreamUrl, tmpDir, ref, dryRun = false, force = false } = {}) {
+export async function applySync({ upstreamUrl, tmpDir, ref, dryRun = false, force = false, onlyProgramming = true } = {}) {
   const proprietary = await loadProprietary();
-  const cmp = await compare({ upstreamUrl, tmpDir, ref });
-  const { dest, head, upstreamMap, result } = cmp;
+  const cmp = await compare({ upstreamUrl, tmpDir, ref, onlyProgramming });
+  const { dest, head, upstreamMap, upstreamMapFull, result } = cmp;
+  const effectiveMap = onlyProgramming ? upstreamMap : upstreamMapFull;
   const actions = [];
 
   if (dryRun) {
     return { ...cmp, actions, dryRun: true };
   }
 
-  // 处理重命名：删除旧目录，复制新目录
+  // 处理重命名
   for (const r of result.renamed) {
-    const src = upstreamMap.get(r.to).dir;
+    const src = effectiveMap.get(r.to)?.dir || upstreamMapFull.get(r.to)?.dir;
+    if (!src) continue;
     const dst = path.join(LOCAL_SKILLS_DIR, r.to);
     const oldDst = path.join(LOCAL_SKILLS_DIR, r.from);
     await rm(oldDst, { recursive: true, force: true });
@@ -184,21 +213,18 @@ export async function applySync({ upstreamUrl, tmpDir, ref, dryRun = false, forc
     actions.push(`rename ${r.from} → ${r.to}`);
   }
 
-  // 新增
   for (const name of result.added) {
-    // 跳过已通过重命名处理的新名
     if (result.renamed.some((r) => r.to === name)) continue;
-    const src = upstreamMap.get(name)?.dir;
+    const src = effectiveMap.get(name)?.dir || upstreamMapFull.get(name)?.dir;
     if (!src) continue;
     const dst = path.join(LOCAL_SKILLS_DIR, name);
     await cp(src, dst, { recursive: true, force: true });
     actions.push(`add ${name}`);
   }
 
-  // 更新
   for (const name of result.updated) {
-    if (name.includes('→')) continue; // 已处理
-    const src = upstreamMap.get(name)?.dir;
+    if (name.includes('→')) continue;
+    const src = effectiveMap.get(name)?.dir || upstreamMapFull.get(name)?.dir;
     if (!src) continue;
     const dst = path.join(LOCAL_SKILLS_DIR, name);
     await rm(dst, { recursive: true, force: true });
@@ -206,10 +232,8 @@ export async function applySync({ upstreamUrl, tmpDir, ref, dryRun = false, forc
     actions.push(`update ${name}`);
   }
 
-  // 删除（上游已删且非独有）
   for (const name of result.removed) {
     const dst = path.join(LOCAL_SKILLS_DIR, name);
-    // 仅当非独有且上游确实不存在时删除；默认执行，需 --force 才删？按自动覆盖策略直接删
     await rm(dst, { recursive: true, force: true });
     actions.push(`remove ${name}`);
   }
@@ -219,12 +243,12 @@ export async function applySync({ upstreamUrl, tmpDir, ref, dryRun = false, forc
 
   return { ...cmp, dest: null, actions, head };
 }
-
 function formatTable(cmp) {
-  const { result, counts, head } = cmp;
+  const { result, counts, head, onlyProgramming } = cmp;
   const lines = [];
   lines.push(`上游 HEAD: ${head}`);
-  lines.push(`本地非独有: ${counts.local}  上游: ${counts.upstream}`);
+  const modeHint = onlyProgramming ? '（仅编程，engineering）' : '（全量，含 productivity）';
+  lines.push(`本地非独有: ${counts.local}  上游: ${counts.upstream} ${modeHint}`);
   lines.push('');
   const totalDiff = result.added.length + result.updated.length + result.removed.length + result.renamed.length;
   if (totalDiff === 0) {
@@ -248,24 +272,26 @@ async function main() {
     check: args.includes('--check'),
     apply: args.includes('--apply') || args.includes('--update'),
     verbose: args.includes('--verbose') || args.includes('-v'),
+    all: args.includes('--all'),
   };
+  const onlyProgramming = !opts.all;
   const upstreamIdx = args.indexOf('--upstream');
   const upstreamUrl = upstreamIdx !== -1 ? args[upstreamIdx + 1] : undefined;
   const refIdx = args.indexOf('--ref');
   const ref = refIdx !== -1 ? args[refIdx + 1] : undefined;
   const tmpIdx = args.indexOf('--tmp');
   const tmpDir = tmpIdx !== -1 ? args[tmpIdx + 1] : undefined;
-
   if (args.includes('--help') || args.includes('-h') || args.length === 0) {
     process.stdout.write(`sync-upstream — 对比/同步 mattpocock/skills 上游技能
 
 Usage:
-  node scripts/sync-upstream.js --check [--json] [--upstream <url>] [--ref <ref>]
-  node scripts/sync-upstream.js --apply [--dry-run] [--force] [--upstream <url>] [--ref <ref>]
+  node scripts/sync-upstream.js --check [--all] [--json] [--upstream <url>] [--ref <ref>]
+  node scripts/sync-upstream.js --apply [--all] [--dry-run] [--force] [--upstream <url>] [--ref <ref>]
 
 Options:
   --check     只对比，不改动文件（默认）
   --apply     应用同步（覆盖 .agents/skills 非独有技能）
+  --all       包含非编程技能（productivity）；默认仅同步编程相关（engineering）
   --dry-run   演练模式，不写文件
   --json      以 JSON 输出结果
   --upstream  上游仓库 URL（默认 https://github.com/mattpocock/skills.git）
@@ -278,9 +304,9 @@ Options:
   }
 
   if (opts.apply) {
-    const res = await applySync({ upstreamUrl, tmpDir, ref, dryRun: opts.dryRun, force: opts.force });
+    const res = await applySync({ upstreamUrl, tmpDir, ref, dryRun: opts.dryRun, force: opts.force, onlyProgramming });
     if (opts.json) {
-      process.stdout.write(JSON.stringify({ head: res.head, result: res.result, actions: res.actions, dryRun: opts.dryRun }, null, 2) + '\n');
+      process.stdout.write(JSON.stringify({ head: res.head, result: res.result, actions: res.actions, dryRun: opts.dryRun, onlyProgramming }, null, 2) + '\n');
     } else {
       process.stdout.write(formatTable(res) + '\n');
       if (res.actions.length) {
@@ -295,9 +321,9 @@ Options:
   }
 
   // 默认 --check
-  const cmp = await compare({ upstreamUrl, tmpDir, ref });
+  const cmp = await compare({ upstreamUrl, tmpDir, ref, onlyProgramming });
   if (opts.json) {
-    process.stdout.write(JSON.stringify({ head: cmp.head, counts: cmp.counts, result: cmp.result }, null, 2) + '\n');
+    process.stdout.write(JSON.stringify({ head: cmp.head, counts: cmp.counts, result: cmp.result, onlyProgramming }, null, 2) + '\n');
   } else {
     process.stdout.write(formatTable(cmp) + '\n');
   }

package/template/.agents/skills/ask-matt/PHASE-BOUNDARIES.md

@@ -0,0 +1,55 @@
+# Phase boundaries
+
+A **phase** is a chunk of work inside a session: the grilling, the implementation, the QA. The definition is fuzzy on purpose: a phase ends when you think *"ok, we're done with that"*.
+
+The **phase boundary** is the gap between two phases, and it is the only place this decision belongs. Mid-phase there is no decision to make: continue, or split the work that's left into subagents. Compacting mid-phase makes the agent lose the thread.
+
+## The five options
+
+| Option       | What it does                                                    |
+| ------------ | --------------------------------------------------------------- |
+| **Continue** | Stay in the session. No context switch at all.                    |
+| **`/clear`** | Empty the context window and start from nothing.                  |
+| **`/handoff`** | Write a portable markdown file and seed a session anywhere with it. |
+| **Subagent** | Send the task to its own context window and get a report back.     |
+| **`/compact`** | Compress this context and seed a fresh session with the summary.  |
+
+## The tree
+
+Work top to bottom at the boundary. The first **yes** wins.
+
+**1. Can you continue in this session?** Two things make the answer yes: the next phase needs this phase as a **primary source**, or you have enough [smart zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone) left (~150k tokens) for the next phase to fit. Grilling → implementation is the standard yes: the implementation wants the reasoning verbatim, not a summary of it. Continue costs nothing and loses nothing, so rule it out before anything else.
+
+**2. Is the context irrelevant to what comes next?** Is everything in this session (the exploration, the decisions, the dead ends) disposable? If so, **`/clear`**. It is the cheapest move on the board: it takes no time and hands back the whole window. `/clear` also isn't terminal: the old session stays resumable.
+
+The cost of getting this wrong is one-way. Clear a *relevant* context and you lose the **why** behind what you built, and no amount of reading the diff back gets it returned.
+
+**3. Do you need to hand off?** `/handoff` is narrow. You need it only when you are:
+
+- swapping to a **new harness** (Claude → Codex),
+- moving to a **new directory** or repo,
+- sending the work to a **colleague**,
+- or forking a side task you found **mid-phase** without derailing what you're doing.
+
+That list is the whole clause. What `/handoff` buys is **portability**: a file that travels. If nothing is travelling, you don't need it.
+
+**4. Can the task be done AFK?** Is it scoped tightly enough to run with you away from the keyboard, no steering? Then send it to a **subagent** and leave this session untouched. Automated review is the standard case: the agent reads the diff and reports, and you aren't needed while it does.
+
+**5. Otherwise, `/compact`.** Relevant context, same harness, same directory, and you need to stay in the loop: this is where the tree lands, and it lands here often. Pass it an instruction (`/compact we're going to QA this area`) so the summary keeps what the next phase needs.
+
+`/compact` is the **default, not the first reach**. It sits at the bottom because the four questions above it are all cheaper or more precise. The failure mode when people start here is a fresh session that is confidently wrong about a decision the summary flattened.
+
+## Primary and secondary sources
+
+Every move except **Continue** turns a **primary source** into a **secondary source**: the session as it happened, replaced by a summary of it. The trade is always the same shape:
+
+| Source                            | Information | Noise | Room to move |
+| --------------------------------- | ----------- | ----- | ------------ |
+| Primary (Continue)                | Full        | Lots  | Little       |
+| Secondary (`/compact`, `/handoff`) | Lossy       | Less  | Lots         |
+
+This is why question 1 comes first. You only pay the lossiness when staying costs more than it saves.
+
+## These are judgement calls
+
+The questions are not objective: each has taste in it, and the same boundary can go two ways on two days. The value is in asking them **in order**, at the boundary rather than in the middle of the work.

package/template/.agents/skills/ask-matt/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: ask-matt
+description: Ask which skill or flow fits your situation. A router over the skills in this repo.
+disable-model-invocation: true
+---
+
+# Ask Matt
+
+You don't remember every skill, so ask.
+
+A **flow** is a path through the skills. Most paths run along one **main flow**, and two **on-ramps** merge onto it. Everything else is standalone, or a vocabulary layer that runs underneath.
+
+## The main flow: idea → ship
+
+The route most work travels. You have an idea and want it built.
+
+1. **`/grill-with-docs`** sharpens the idea by interview. Start here whenever you are **working in a working directory**: it's stateful, retaining what it learns in `CONTEXT.md` and ADRs. (No working directory? Use `/grill-me` instead, covered under Standalone. Both run the same `/grilling` primitive; `grill-with-docs` is the one that leaves a paper trail, which makes it the better of the two whenever a repo is there to leave it in.)
+2. **Branch: can you settle every question in conversation?** If a question needs a runnable answer (state, business logic, a UI you have to see), detour through a prototype, bridged by **`/handoff`** in both directions (a prototype lives in its own directory, which is exactly what `/handoff` is for; see Phase boundaries):
+   - **`/handoff`** out, then open a fresh session against that file,
+   - **`/prototype`** to answer the question with throwaway code,
+   - **`/handoff`** back what you learned, and reference it from the original idea thread.
+3. **Branch: is this a multi-session build?**
+   - **Yes** → **`/to-spec`** (turn the thread into a spec), then **`/to-tickets`** to split it into tracer-bullet tickets, each declaring its **blocking edges**. On a local tracker that's one file per ticket under `.scratch/<feature>/issues/`, worked blockers-first by hand; on a real tracker the edges become native blocking links, so any ticket whose blockers are done can be grabbed: kick off **`/implement`** per ticket, **`/clear`ing context between each one**. Each ticket is self-contained, so the last one's context is disposable.
+   - **No** → **`/implement`** right here, in the same context window.
+
+   Either way, **`/implement`** builds each issue by driving **`/tdd`** internally (one red-green slice at a time), then closes out by running **`/code-review`**, a two-axis review (Standards + Spec) of the diff, before committing. Reach for **`/tdd`** on its own when you just want to build a concrete behaviour test-first without a full spec, and **`/code-review`** on its own whenever you want to review a branch or PR against a fixed point.
+
+### Context hygiene
+
+Keep steps 1–3 in **one unbroken context window** (don't compact or clear until after `/to-tickets`) so the grilling, spec, and tickets all build on the same thinking. Each `/implement` then starts fresh, working from the ticket.
+
+The limit on this is the **[smart zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone)**: the window (~150k tokens on state-of-the-art models) within which the model still reasons sharply. If a session approaches it before `/to-tickets`, don't push on degraded; `/compact` at the nearest phase boundary and carry on (see Phase boundaries).
+
+## On-ramps
+
+A starting situation that generates work, then merges onto the main flow.
+
+- **Bugs and requests piling up** → **`/triage`**. It moves issues through triage roles and produces agent-ready issues, which **`/implement`** later picks up.
+
+  Triage is only for issues **you didn't create**: bug reports, incoming feature requests, anything that arrives raw. Tickets that `/to-tickets` produced are already agent-ready, so **don't triage them**.
+
+- **Something's broken** → **`/diagnosing-bugs`**. For the hard ones: the bug that resists a first glance, the intermittent flake, the regression that crept in between two known-good states. It refuses to theorise until it has a **tight feedback loop** (one command that already goes red on *this* bug), then fixes with a regression test. Its post-mortem hands off to **`/improve-codebase-architecture`** when the real finding is that there's no good seam to lock the bug down.
+
+- **A huge, foggy effort: a greenfield project or a huge feature build, too big for one session** → **`/wayfinder`**, the most cognitively demanding flow here. When the way from here to the destination isn't visible yet, it charts a **shared map** of **decision tickets** on the issue tracker and resolves them one at a time, producing **decisions, not deliverables**, until the fog is pushed back and the way is clear. Where **`/grill-with-docs`** sharpens an idea you can hold in one session, wayfinder is for the idea you can't, and it's slower and denser, so save it for exactly that, never a well-scoped feature.
+
+  When the map clears, **it hands off, it doesn't build**: merge onto the main flow at **`/to-spec`**, which collapses the map's linked decisions into a buildable plan, then `/to-tickets` and `/implement` as usual. Looping the map straight into `/implement` skips that collapse and throws the linked detail away, so go straight to `/implement` only when the effort turned out genuinely small.
+
+## Codebase health
+
+Not feature work, just upkeep.
+
+- **`/improve-codebase-architecture`** runs whenever you have a spare moment to keep the codebase good for agents to operate in. It surfaces **deepening opportunities**; picking one _generates an idea_ you can take into the main flow at `/grill-with-docs`. It's the survey that finds the candidates; **`/codebase-design`** (below) is the bench you design the chosen one on.
+
+## Vocabulary underneath
+
+Two model-invoked references that run *beneath* the other skills, each the single source of truth for its vocabulary. Reach for them directly when the **words**, not the process, are the problem; or let the skills above pull them in.
+
+- **`/domain-modeling`**: sharpen the project's *domain* language: challenge a fuzzy term, resolve an overloaded word ("account" doing three jobs), record a hard-to-reverse decision as an ADR. It's the active discipline `/grill-with-docs` drives to keep `CONTEXT.md` a clean glossary.
+- **`/codebase-design`** is the deep-module vocabulary (module, interface, depth, seam, adapter, leverage, locality) for designing a module's *shape*: a lot of behaviour behind a small interface at a clean seam. `/tdd` and `/improve-codebase-architecture` both speak it.
+
+## Phase boundaries
+
+A **phase** is a chunk of work inside a session: the grilling, the implementation, the QA. At the **boundary** between two of them you have five options, and picking between them is the fuzziest decision in this whole map:
+
+- **Continue**: stay put. Costs nothing, loses nothing.
+- **`/clear`**: empty the window, when nothing here matters to what's next.
+- **`/handoff`** writes a portable markdown file. Narrow: only for a **new harness**, a **new directory**, a **colleague**, or forking a side task **mid-phase**. What it buys is portability.
+- **Subagent**: send a tightly-scoped task to its own window and get a report back.
+- **`/compact`** compresses this context and seeds a fresh session with it. The **default**, at the bottom of the tree rather than the first reach.
+
+Read [PHASE-BOUNDARIES.md](PHASE-BOUNDARIES.md) for the ordered tree: the five questions, the reasoning behind each branch, and why the primary-source cost makes **Continue** the one to rule out first. Make the decision **at** a boundary; mid-phase, continue or split the rest into subagents.
+
+## Standalone
+
+Off the main flow entirely.
+
+- **`/grill-me`**: the same relentless interview as `/grill-with-docs`, but **stateless**: it saves nothing locally and builds no `CONTEXT.md`. Reach for it when you are **not working in a working directory** (sharpening a plan, a design, a piece of writing, anything with no repo under it). If you are in a working directory, use `/grill-with-docs` instead: it runs the same interview and leaves a paper trail, so it is strictly the better one.
+- **`/grilling`** is the interview primitive itself: rounds, the frontier, facts are the agent's job and decisions are yours. `/grill-me` and `/grill-with-docs` are the two named ways in, and `/triage`, `/wayfinder` and `/improve-codebase-architecture` all run it internally. Reach for it directly only when you want the interview with no wrapper around it.
+- **`/resolving-merge-conflicts`** works an in-progress merge or rebase conflict hunk by hunk, resolving by **intent** traced to each side's primary source rather than by picking lines, then finishes the operation. It never runs `--abort`. Standalone and off every flow: reach for it when you are already mid-conflict.
+- **`/prototype`** is a small, throwaway program that answers one design question: does this state model feel right, or what should this UI look like. Throwaway is a constraint on how the code is written, not a promise to destroy it: the answer folds into the real code, and the prototype itself is kept as a **primary source** on a `prototype/<name>` branch out of main, pointed at from the implementation issue. It's the detour in step 2 of the main flow, but reach for it any time a design question is hard to settle on paper.
+- **`/research`**: delegate reading legwork to a **background agent**: it investigates a question against **primary sources**, then leaves a cited Markdown file in the repo. Keep working while it reads. The file it produces is something to take *into* the main flow at `/grill-with-docs`, since research feeds the thinking rather than replacing it.
+- **`/to-questionnaire`** comes in when the thing blocking you isn't in your head or the codebase but in **someone else's**, and it writes them a questionnaire to fill in. It's the inverse of `/grill-me`: instead of interviewing you about the subject, it interviews you about the **send** (who it's going to, what you need back) and aims the questions at the gap. What comes back is material for `/grill-with-docs` or `/to-spec`.
+- **`/wizard`** is for the steps only a **human** can take: provisioning infrastructure, setting up credentials or CI secrets, clicking through an unfamiliar third-party dashboard, running a one-off migration or cutover. It generates an interactive bash script that opens each URL, captures each value, and writes it into `.env` and GitHub secrets, so the procedure stops being something you re-explain to an agent every time. Model-invoked, so the agent reaches for it the moment it hits a wall only you can pass. If the agent could just do it itself, it should; this is for where a human is genuinely in the loop.
+- **`/wait-what`** is the corrective for a message that didn't land. Use it mid-conversation, inside any other skill, and the agent re-pitches what it just said with the context you were missing, in plain English, using the `CONTEXT.md` vocabulary. It works after the fact; `/grill-with-docs` is the upfront cure, because a shared language agreed early is what stops the jargon arriving at all.
+- **`/teach`**: learn a concept over multiple sessions, using the current directory as a stateful workspace.
+- **`/writing-for-agents`** is the reference for writing documents agents consume: skills, AGENTS.md, pointed-at docs.
+
+## Precondition
+
+**`/setup-matt-pocock-skills`**: run before your first engineering flow to configure the issue tracker, triage labels, and doc layout the other skills assume. Custom issue trackers also work.

package/template/.agents/skills/ask-matt/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Ask Matt"
+  short_description: "Find the right skill or workflow"
+policy:
+  allow_implicit_invocation: false

package/template/.agents/skills/ci-guard/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: ci-guard
+description: "Guard the GitHub Actions release pipeline: orchestrate workflow flow, enforce pre-release verification, and self-correct after publish. Use when CI is flaky/failing, when setting up or editing .github/workflows/ci.yml, or before tagging a release to npm."
+---
+
+# CI Guard
+
+**guard** 为领衔词的发布门禁技能：以一次**可复现的失败**为起点，把 `verify → build → publish` 编排成不可绕过的门，把**预发布校验**做成硬门槛，把**发布后自纠**做成闭环。本技能沉淀自 `heihei0299/pi-switch` 23 次运行中 14 次失败的复盘（见 `.scratch/research/ci-actions-调研.md`）——不替代 `diagnose-fix` 的通用诊断，只收敛 CI/发布这一条链。
+
+## 何时用
+
+- Actions 持续红 / 偶发红（尤其是 `verify` 单点红而 `publish` 仍绿）
+- 新建或改动 `.github/workflows/ci.yml`、调整 `cargo test` / `clippy` / `rustfmt` 参数
+- 打 tag 前、发 npm 前、或发布后需要自检/回滚
+
+## 三段式门禁
+
+```
+① 编排 flows → ② 预发布 gate → ③ 发布后自纠
+```
+
+每段有**完成条件**（可验证），未满足不进入下一段。
+
+---
+
+### ① 编排 flows —— 让工作流不可被绕过
+
+**做**：
+- `on`：`push.tags: ["v*"]` **必须**同时配 `push.branches: [main]`（或 `master`）+ `pull_request.branches: [main]` + `workflow_dispatch`。否则直推 `main` 的修复（如 `2d68f62`）无法被 CI 验证，tag 才暴露问题
+- `jobs` 依赖：`publish.needs: [build, verify]`，**禁止** `needs: build` 单依赖。门禁失效的直接原因就是 `verify` 红仍发包
+- `permissions` 最小化：`verify`/`build` 只需 `contents: read`，仅 `publish` 保留 `contents: write` + `packages: write`（或 `id-token: write` 若用 OIDC）
+- `concurrency`：`group: ci-${{ github.ref }}` + `cancel-in-progress: true`，避免同分支并行互踩
+
+**完成条件**：
+- [ ] `git diff HEAD -- .github/workflows/ci.yml` 显示 `on.push.branches` 存在
+- [ ] `publish.needs` 包含 `verify`
+- [ ] `workflow_dispatch` 可手动触发全量
+
+---
+
+### ② 预发布 gate —— 测试 GitHub Action 流程
+
+本段是**硬门槛**，顺序固定：`action lint → workflow dry-run → dispatch 验证`，任一步红即阻断 `publish`。
+
+**action lint**：
+- `actionlint` 校验 `.github/workflows/ci.yml` 语法与 `on/needs/permissions` 完整性
+- `yamllint` 检查缩进与重复键
+
+**workflow dry-run**：
+- `act --dry-run` 或 `gh workflow view` 模拟 `verify/build/publish` 三 job 依赖与 `if` 条件
+- 校验 `publish.needs` 含 `verify` 且 `workflow_dispatch` 可手动触发
+
+**dispatch 验证**：
+- 通过 `gh workflow run ci.yml --ref main -f dry_run=true` 触发试运行，观察 `verify` 日志与产物上传
+- 失败即阻断 `publish`，日志留存于 Actions
+
+**完成条件**：
+- [ ] `actionlint` 0 error
+- [ ] `act --dry-run` 三 job 依赖正确
+- [ ] `workflow_dispatch` 试运行通过
+
+---
+
+### ③ 发布后自纠 —— 发出去的包自己负责
+
+**发布时**：
+- `npm publish --access public` 仅在 `if: startsWith(github.ref, 'refs/tags/v')` 且 `needs` 全绿时执行
+- 发布前 `actions/download-artifact` 校验 `if-no-files-found: error`，发布后 `npm view <pkg>@<version> version` 回读确认
+
+**自纠**：
+- 失败即 **阻断**：`verify` 红 → `publish` 不执行（由 `needs` 保证）；`publish` 自身失败（`409 already exists` / `401`）→ 工作流整体 `failure`，不静默
+- 发布后 30s 内 `curl https://registry.npmjs.org/<pkg>/<version>` 校验可用；失败则 `gh issue create --title "chore(release): vX.Y.Z 发布后自检失败" --body "run: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"` 并 `gh release delete vX.Y.Z --yes`（或 `npm unpublish <pkg>@<version>` 在 72h 内）
+- `workflow_dispatch` 支持 `inputs.rollback_version` 手动回滚
+
+**完成条件**：
+- [ ] `npm view` 回读与 tag 一致
+- [ ] 失败路径有 issue/通知（非静默）
+- [ ] `git tag` 与 `package.json version` 一致（`scripts/release.sh` 或 `npm version` 保证）
+
+---
+
+## 反模式
+
+- **单依赖 publish**：`needs: build` 是本仓 7 次带病发布的根因
+- **仅 tag 触发**：`push.branches` 缺失导致主干修复无 CI
+- **静默发布**：`publish` 失败不建 issue / 不删 tag，下次 `409` 叠加
+- **`-A clippy::all`**：掩盖真实告警
+
+## 引用
+
+- 调研：`.scratch/research/ci-actions-调研.md`（23 次运行全量、`proxy.rs:115` vs `config.rs:460` 对比）
+- 修复：`2d68f62 fix(ci): gate publish on verify and serialize Rust tests`
+- 关联技能：`diagnose-fix`（通用诊断）、`commit-check`（提交前门禁）、`tdd`（测试隔离后的回归）
+

package/template/.agents/skills/ci-guard/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "CI Guard"
+  short_description: "Guard release pipeline: orchestrate flows, enforce verify gate, self-correct after publish"
+policy:
+  allow_implicit_invocation: false

package/template/.agents/skills/code-review/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: code-review
+description: "Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes: Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/spec asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to \"review since X\"."
+---
+
+Two-axis review of the diff between `HEAD` and a fixed point the user supplies:
+
+- **Standards**: does the code conform to this repo's documented coding standards?
+- **Spec**: does the code faithfully implement the originating issue / spec?
+
+Both axes run as **parallel sub-agents** so they don't pollute each other's context, then this skill aggregates their findings.
+
+The issue tracker should have been provided to you. If `docs/agents/issue-tracker.md` is missing, tell the user to run `/setup-matt-pocock-skills`.
+
+## Process
+
+### 1. Pin the fixed point
+
+Whatever the user said is the fixed point (a commit SHA, branch name, tag, `main`, `HEAD~5`, etc.). If they didn't specify one, ask for it.
+
+Capture the diff command once: `git diff <fixed-point>...HEAD` (three-dot, so the comparison is against the merge-base). Also note the list of commits via `git log <fixed-point>..HEAD --oneline`.
+
+Before going further, confirm the fixed point resolves (`git rev-parse <fixed-point>`) and the diff is non-empty. A bad ref or empty diff should fail here, not inside two parallel sub-agents.
+
+### 2. Identify the spec source
+
+Look for the originating spec, in this order:
+
+1. Issue references in the commit messages (`#123`, `Closes #45`, GitLab `!67`, etc.), fetched via the workflow in `docs/agents/issue-tracker.md`.
+2. A path the user passed as an argument.
+3. A spec file under `docs/`, `specs/`, or `.scratch/` matching the branch name or feature.
+4. If nothing is found, ask the user where the spec is. If they say there isn't one, the **Spec** sub-agent will skip and report "no spec available".
+
+### 3. Identify the standards sources
+
+Anything in the repo that documents how code should be written, such as `CODING_STANDARDS.md` or `CONTRIBUTING.md`.
+
+On top of whatever the repo documents, the Standards axis always carries the **smell baseline** below: a fixed set of Fowler code smells (_Refactoring_, ch.3) that applies even when a repo documents nothing. Two rules bind it:
+
+- **The repo overrides.** A documented repo standard always wins; where it endorses something the baseline would flag, suppress the smell.
+- **Always a judgement call.** Each smell is a labelled heuristic ("possible Feature Envy"), never a hard violation. Like any standard here, skip anything tooling already enforces.
+
+Each smell reads *what it is* → *how to fix*; match it against the diff:
+
+- **Mysterious Name**: a function, variable, or type whose name doesn't reveal what it does or holds. → rename it; if no honest name comes, the design's murky.
+- **Duplicated Code**: the same logic shape appears in more than one hunk or file in the change. → extract the shared shape, call it from both.
+- **Feature Envy**: a method that reaches into another object's data more than its own. → move the method onto the data it envies.
+- **Data Clumps**: the same few fields or params keep travelling together (a type wanting to be born). → bundle them into one type, pass that.
+- **Primitive Obsession**: a primitive or string standing in for a domain concept that deserves its own type. → give the concept its own small type.
+- **Repeated Switches**: the same `switch`/`if`-cascade on the same type recurs across the change. → replace with polymorphism, or one map both sites share.
+- **Shotgun Surgery**: one logical change forces scattered edits across many files in the diff. → gather what changes together into one module.
+- **Divergent Change**: one file or module is edited for several unrelated reasons. → split so each module changes for one reason.
+- **Speculative Generality**: abstraction, parameters, or hooks added for needs the spec doesn't have. → delete it; inline back until a real need shows.
+- **Message Chains**: long `a.b().c().d()` navigation the caller shouldn't depend on. → hide the walk behind one method on the first object.
+- **Middle Man**: a class or function that mostly just delegates onward. → cut it, call the real target direct.
+- **Refused Bequest**: a subclass or implementer that ignores or overrides most of what it inherits. → drop the inheritance, use composition.
+
+### 4. Spawn both sub-agents in parallel
+
+**Standards sub-agent prompt** should include:
+
+- The full diff command and commit list.
+- The list of standards-source files you found in step 3, **plus the smell baseline from step 3** pasted in full (the sub-agent has no other access to it).
+- The brief: "Report, per file/hunk where relevant, (a) every place the diff violates a documented standard: cite the standard (file + the rule); and (b) any baseline smell you spot: name it and quote the hunk. Distinguish hard violations from judgement calls: documented-standard breaches can be hard, but baseline smells are always judgement calls, and a documented repo standard overrides the baseline. Skip anything tooling enforces. Under 400 words."
+
+**Spec sub-agent prompt** should include:
+
+- The diff command and commit list.
+- The path or fetched contents of the spec.
+- The brief: "Report: (a) requirements the spec asked for that are missing or partial; (b) behaviour in the diff that wasn't asked for (scope creep); (c) requirements that look implemented but where the implementation looks wrong. Quote the spec line for each finding. Under 400 words."
+
+If the spec is missing, skip the Spec sub-agent and note this in the final report.
+
+### 5. Aggregate
+
+Present the two reports under `## Standards` and `## Spec` headings, verbatim or lightly cleaned. Do **not** merge or rerank findings, because the two axes are deliberately separate (see _Why two axes_).
+
+End with a one-line summary: total findings per axis, and the worst issue _within each axis_ (if any). Don't pick a single winner across axes: that's the reranking the separation exists to prevent.
+
+## Why two axes
+
+A change can pass one axis and fail the other:
+
+- Code that follows every standard but implements the wrong thing → **Standards pass, Spec fail.**
+- Code that does exactly what the issue asked but breaks the project's conventions → **Spec pass, Standards fail.**
+
+Reporting them separately stops one axis from masking the other.

package/template/.agents/skills/code-review/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Code Review"
+  short_description: "Review a diff on standards and spec"

package/template/.agents/skills/codebase-design/DEEPENING.md

@@ -0,0 +1,37 @@
+# Deepening
+
+How to deepen a cluster of shallow modules safely, given its dependencies. Assumes the vocabulary in [SKILL.md](SKILL.md): **module**, **interface**, **seam**, **adapter**.
+
+## Dependency categories
+
+When assessing a candidate for deepening, classify its dependencies. The category determines how the deepened module is tested across its seam.
+
+### 1. In-process
+
+Pure computation, in-memory state, no I/O. Always deepenable: merge the modules and test through the new interface directly. No adapter needed.
+
+### 2. Local-substitutable
+
+Dependencies that have local test stand-ins (PGLite for Postgres, in-memory filesystem). Deepenable if the stand-in exists. The deepened module is tested with the stand-in running in the test suite. The seam is internal; no port at the module's external interface.
+
+### 3. Remote but owned (Ports & Adapters)
+
+Your own services across a network boundary (microservices, internal APIs). Define a **port** (interface) at the seam. The deep module owns the logic; the transport is injected as an **adapter**. Tests use an in-memory adapter. Production uses an HTTP/gRPC/queue adapter.
+
+Recommendation shape: *"Define a port at the seam, implement an HTTP adapter for production and an in-memory adapter for testing, so the logic sits in one deep module even though it's deployed across a network."*
+
+### 4. True external (Mock)
+
+Third-party services (Stripe, Twilio, etc.) you don't control. The deepened module takes the external dependency as an injected port; tests provide a mock adapter.
+
+## Seam discipline
+
+- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a port unless at least two adapters are justified (typically production + test). A single-adapter seam is just indirection.
+- **Internal seams vs external seams.** A deep module can have internal seams (private to its implementation, used by its own tests) as well as the external seam at its interface. Don't expose internal seams through the interface just because tests use them.
+
+## Testing strategy: replace, don't layer
+
+- Old unit tests on shallow modules become waste once tests at the deepened module's interface exist; delete them.
+- Write new tests at the deepened module's interface. The **interface is the test surface**.
+- Tests assert on observable outcomes through the interface, not internal state.
+- Tests should survive internal refactors, since they describe behaviour, not implementation. If a test has to change when the implementation changes, it's testing past the interface.