@mmerterden/multi-agent-pipeline 11.1.0 → 11.2.0

package/CHANGELOG.md

@@ -14,6 +14,27 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ---
 
+## [11.2.0] - 2026-07-07
+
+Skill mining + an install-safety fix.
+
+- **Fix (data-loss): `install.js` no longer clobbers user-owned rules.** `rules/`
+  is authored/evolved locally and is deliberately never synced back to the repo
+  (privacy). The installer used to `wipe + copy` it on every update, which
+  reverted local edits (including the git attribution rule). Rules now install
+  write-if-missing: new baseline rules are added, existing local rules are
+  preserved untouched. New `copyDir({ skipExisting })` option backs this.
+- **Two skills mined from the corporate iOS toolkit and genericized into
+  `ai-common-engineering-toolkit` (v0.1.2):**
+  - `skill-creator` — the house rules for authoring skills (description-first
+    discovery, lean SKILL.md as an index, progressive disclosure, reference vs
+    workflow vs tool layers, no-prefix naming, grow-from-failure), with a
+    template, pre-ship checklist, good/bad examples, and a multi-architect audit
+    script. All corporate references scrubbed.
+  - `backlog` — a deferred-work registry where every deferred job lands with its
+    full spec + origin + unblock condition (deferred -> ready -> in-progress ->
+    done, never deleted), so deferral never means loss.
+
 ## [11.1.0] - 2026-07-07
 
 Harness-hardening pass: four techniques adapted from studying cross-harness agent

package/install/_common.mjs

@@ -59,7 +59,7 @@ export function ensureDir(dir) {
  * @param {{ exclude?: Array<string|RegExp>, useSymlinks?: boolean }} [opts]
  */
 export function copyDir(src, dest, opts = {}) {
-  const { exclude = [], useSymlinks = false } = opts;
+  const { exclude = [], useSymlinks = false, skipExisting = false } = opts;
   if (useSymlinks) {
     symlinkDir(src, dest);
     return;
@@ -69,6 +69,14 @@ export function copyDir(src, dest, opts = {}) {
     return;
   }
   ensureDir(dest);
+  // skipExisting: never overwrite a file that already exists in dest. Used for
+  // user-owned trees (rules/) so an update adds new baseline files but preserves
+  // the user's locally-evolved copies. cpSync with force:false + errorOnExist:false
+  // silently skips existing files.
+  if (skipExisting) {
+    cpSync(src, dest, { recursive: true, force: false, errorOnExist: false });
+    return;
+  }
   if (exclude.length === 0) {
     cpSync(src, dest, { recursive: true, force: true });
     return;

package/install/claude.mjs

@@ -108,9 +108,18 @@ function installRules(pipelineSrc, dest, useSymlinks) {
   console.log("  [Claude Code] Installing rules...");
   const rulesSrc = join(pipelineSrc, "rules");
   if (!existsSync(rulesSrc)) return;
-  wipeDir(dest);
-  copyDir(rulesSrc, dest, { useSymlinks });
-  console.log(`    -> ${countFiles(rulesSrc)} files copied to ${dest}`);
+  // rules/ is USER-OWNED: users evolve their global rules locally and the sync
+  // deliberately never pushes rules/ back to the repo (privacy). So an update
+  // must NOT wipe+overwrite them (that reverts local edits, including the git
+  // attribution rule). Install only files that do not already exist; leave the
+  // user's existing rules untouched. (Symlink mode is a dev choice and keeps its
+  // link-replace behavior.)
+  if (useSymlinks) {
+    copyDir(rulesSrc, dest, { useSymlinks });
+  } else {
+    copyDir(rulesSrc, dest, { skipExisting: true });
+  }
+  console.log(`    -> rules present (existing local rules preserved)`);
 }
 
 function installSchemas(pipelineSrc, dest, useSymlinks) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "11.1.0",
+  "version": "11.2.0",
   "description": "8-phase AI development pipeline with full orchestration on Claude Code and Copilot CLI. Analysis, planning, TDD, CLI-aware parallel review with consensus surfacing + Fable triage, default-FAIL evidence gates, secret + intent guards, per-phase cost ledger, persistent learnings memory, wiki generation, commit automation. Token-preserving uninstall.",
   "type": "module",
   "main": "index.js",

package/pipeline/scripts/build-stack-plugins.mjs

@@ -36,7 +36,7 @@ const EXTERNAL = join(PIPE_ROOT, 'pipeline/skills/shared/external');
 const DRY = args.includes('--dry-run');
 
 const COMMON_PLUGIN = 'ai-common-engineering-toolkit';
-const COMMON_SKILLS = ['accessibility-compliance-accessibility-audit', 'firebase', 'humanizer', 'council', 'search-first', 'agent-introspection-debugging'];
+const COMMON_SKILLS = ['accessibility-compliance-accessibility-audit', 'firebase', 'humanizer', 'council', 'search-first', 'agent-introspection-debugging', 'skill-creator', 'backlog'];
 
 // Apple/Xcode-only skills that match no stack pattern → iOS plugin only.
 const APPLE_ONLY = [

package/pipeline/scripts/fixtures/install-layout.tsv

@@ -7,10 +7,10 @@
 .claude/schemas	23
 .claude/scripts	180
 .claude/settings.json	1
-.claude/skills	563
+.claude/skills	572
 .copilot/agents	8
 .copilot/copilot-instructions.md	1
 .copilot/lib	24
 .copilot/schemas	23
 .copilot/scripts	180
-.copilot/skills	600
+.copilot/skills	609

package/pipeline/skills/.skills-index.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-07-07T15:10:40.029Z",
-  "skillCount": 226,
+  "generatedAt": "2026-07-07T16:08:36.778Z",
+  "skillCount": 228,
   "entries": [
     {
       "name": "accessibility-compliance-accessibility-audit",
@@ -201,6 +201,15 @@
       "triggerPaths": [],
       "relativePath": "shared/external/background-processing/SKILL.md"
     },
+    {
+      "name": "backlog",
+      "description": "The engineering backlog registry for deferred-but-approved work in this codebase. Every job the user defers ('defer it', 'add it to the list', 'later', 'not now') lands HERE with its full spec, origin, and unblock condition, so deferral never means loss. Load when the user defers work, asks 'what's ",
+      "platform": null,
+      "group": "external",
+      "triggerKeywords": [],
+      "triggerPaths": [],
+      "relativePath": "shared/external/backlog/SKILL.md"
+    },
     {
       "name": "callkit-voip",
       "description": "Implement VoIP calling with CallKit and PushKit. Use when building incoming/outgoing call flows, registering for VoIP push notifications, configuring CXProvider and CXCallController, handling call actions, coordinating audio sessions, or creating Call Directory extensions for caller ID and call bloc",
@@ -1605,6 +1614,15 @@
       "triggerPaths": [],
       "relativePath": "shared/external/shareplay-activities/SKILL.md"
     },
+    {
+      "name": "skill-creator",
+      "description": "Author and refine skills for a plugin/toolkit efficiently. Use when creating a new skill, trimming or splitting an existing one, writing a skill's description, or choosing skill vs command vs agent vs CLAUDE.md. Encodes the house rules — lean SKILL.md as an index, progressive disclosure into bundled",
+      "platform": null,
+      "group": "external",
+      "triggerKeywords": [],
+      "triggerPaths": [],
+      "relativePath": "shared/external/skill-creator/SKILL.md"
+    },
     {
       "name": "speech-recognition",
       "description": "Transcribe speech to text using Apple's Speech framework. Use when implementing live microphone transcription with AVAudioEngine, recognizing recorded audio files, handling speech and microphone authorization, choosing on-device vs server-backed SFSpeechRecognizer behavior, or adopting SpeechAnalyze",

package/pipeline/skills/shared/external/backlog/BACKLOG.md

@@ -0,0 +1,32 @@
+# Backlog
+
+Deferred-but-approved work, kept whole. Entries move `deferred` -> `ready` -> `in-progress` -> `done` and are never deleted. The full spec travels verbatim from when the job was deferred.
+
+## Ready
+
+_(nothing yet)_
+
+## Deferred
+
+_(nothing yet)_
+
+## In progress
+
+_(nothing yet)_
+
+## Done
+
+_(nothing yet)_
+
+---
+
+### Entry template
+
+```
+#### <id> — <title>
+- state: deferred | ready | in-progress | done
+- origin: <task / PR / finding / conversation that spawned it>
+- unblock: <condition that makes it actionable, or "none">
+- spec: |
+    <FULL description, verbatim from when it was deferred. Not a summary.>
+```

package/pipeline/skills/shared/external/backlog/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: backlog
+version: 1.0.0
+description: "The engineering backlog registry for deferred-but-approved work in this codebase. Every job the user defers ('defer it', 'add it to the list', 'later', 'not now') lands HERE with its full spec, origin, and unblock condition, so deferral never means loss. Load when the user defers work, asks 'what's on the backlog / the list', says 'work the backlog' / 'pick up <item>', or when completing an item. The bundled BACKLOG.md is the registry; entries move deferred -> ready -> in-progress -> done and are never deleted."
+user-invocable: true
+argument-hint: [list | add | pick <id> | done <id>]
+allowed-tools: Read, Grep, Glob, Edit, Write
+---
+
+# backlog — deferred work, kept whole
+
+> **Layer:** workflow — the deterministic registry routine for deferred jobs.
+> **Bundled:** [BACKLOG.md](BACKLOG.md) — the registry. The heart of this skill.
+> **Iron rule:** moving a job onto this list is a MOVE, never a rewrite — the FULL spec
+> travels verbatim. A compressed one-liner is a loss; the point of the backlog is that
+> deferring costs nothing later.
+
+## When to load
+
+- The user defers work: "defer it", "add it to the list", "later", "not now", "backlog this".
+- The user asks about it: "what's on the backlog", "what's on the list", "what's owed".
+- The user works it: "work the backlog", "pick up <id>", "do the next one".
+- An item completes: mark it done (never delete).
+
+## The registry contract
+
+Every entry in `BACKLOG.md` carries, verbatim:
+
+- **id** — short stable slug (`kebab-case`), assigned on add.
+- **title** — one line.
+- **state** — `deferred` -> `ready` -> `in-progress` -> `done`. Entries only move forward; nothing is deleted.
+- **origin** — where it came from (the task/PR/finding/conversation that spawned it).
+- **spec** — the FULL description, verbatim from when it was deferred. Not a summary.
+- **unblock** — the condition that makes it actionable (a dependency, a decision, a date). `deferred` items without an unblock condition are just `ready`.
+
+Prefer an append-only markdown table or section list in `BACKLOG.md`; never overwrite an entry's spec on a state change — only its `state` line moves.
+
+## Operations
+
+| Command | Action |
+|---|---|
+| `list` | Show entries grouped by state (ready first, then deferred, then in-progress; done collapsed). |
+| `add` | Capture the deferred job with its full spec + origin + unblock condition. Assign an id. |
+| `pick <id>` | Move `ready`/`deferred` -> `in-progress`; surface the full spec so work resumes with zero context loss. |
+| `done <id>` | Move -> `done`. Keep the entry (it becomes the record of what was owed and delivered). |
+
+## Why keep it whole
+
+The failure mode this skill prevents: an agent defers a job with a one-line note, the surrounding context evaporates, and picking it up later means re-deriving the spec (or silently dropping it). Storing the full spec at defer-time makes deferral safe — the cost of "later" is paid once, up front, not lost.

package/pipeline/skills/shared/external/skill-creator/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: skill-creator
+version: 1.0.0
+description: "Author and refine skills for a plugin/toolkit efficiently. Use when creating a new skill, trimming or splitting an existing one, writing a skill's description, or choosing skill vs command vs agent vs CLAUDE.md. Encodes the house rules — lean SKILL.md as an index, progressive disclosure into bundled files, the reference (descriptive) vs workflow (imperative) split, no-prefix naming, and growing a skill from observed failures. Bundles a template, a pre-ship checklist, and good/bad description examples."
+user-invocable: true
+argument-hint: [new | trim | description]
+allowed-tools: Read, Write, Edit, Glob
+---
+
+# skill-creator — how to write skills here
+
+> **Layer:** reference (knowledge)
+> **Use when:** creating/trimming a skill, writing a description, or choosing skill vs command/agent/CLAUDE.md.
+> **Bundled (read on demand):** [template.md](template.md) · [checklist.md](checklist.md) · [examples.md](examples.md) · [label-check.md](label-check.md) · [audit.md](audit.md)
+
+## 1. Is a skill the right tool?
+- **CLAUDE.md** — broad facts/rules true *every* session.
+- **Skill** — on-demand procedure or knowledge for a recurring task.
+- **Subagent/agent** — needs independent reasoning + its own context/tools.
+- **MCP server** — structured integration with an external system's API.
+
+## 2. The description is discovery (the 90% lever)
+It's the *only* thing the model sees when deciding to load the skill. **Write it first.** Include **what + when + trigger words + one example trigger**, in third person. (Anthropic's data: vague→specific lifts activation ~20%→50%; adding examples ~72%→90%.) Good/bad pairs in [examples.md](examples.md).
+
+## 3. Keep it lean (it stays in context every turn once loaded)
+- `SKILL.md` is an **index** — aim for ~1 page, hard cap ~500 lines.
+- Push detail into bundled files **one level deep** (reference, examples, scripts). They cost zero tokens until read; nested-deeper files get partially read — don't nest.
+- A **script executes without its source entering context** — prefer a script over asking the model to regenerate code.
+- Challenge every line: *"would Claude err without this?"* If no, cut it.
+
+## 4. Pick the right degree of freedom (= our layers)
+- **reference skill → descriptive:** invariants, conventions + pointers to canonical files, decision heuristics, pitfalls, escape hatches. **No numbered procedures.**
+- **workflow skill → imperative spine:** a numbered procedure **only** for deterministic/irreversible steps (branch/PR, codegen, build/verify). Cite reference skills for the judgment.
+- **tool skill → thin index over a script/CLI:** lean SKILL.md (when + the run command + sub-commands at a glance), heavy detail in a bundled `reference.md`; the script is the engine (e.g. `tools/figma-utility`).
+
+## 5. Naming
+No platform prefix — the toolkit name + description already carry it. Reference = aspect noun (`navigation`); workflow = verb-phrase (`branch-and-pr`). Avoid vague/reserved (`helper`, `utils`, `claude-*`). For a name/title/strict-rule label that must carry its **whole intent**, validate it with the fresh-subagent inference test in [label-check.md](label-check.md) before committing.
+
+## 6. Grow it from real usage — don't pre-write
+1. Do the task **without** a skill; note where Claude actually fails.
+2. Write the **minimum** that fixes those gaps.
+3. Watch Claude use it: move reused detail up into SKILL.md, cut detail it ignores, sharpen the description if it didn't trigger.
+
+## Before shipping
+Start from [template.md](template.md); run [checklist.md](checklist.md). For a new or
+substantially-changed skill that must be trusted, run the **multi-architect audit**
+([audit.md](audit.md)) — a panel of distinct-lens reviewers + synthesis, looped
+fix → re-audit until no blockers/majors remain.

package/pipeline/skills/shared/external/skill-creator/audit.md

@@ -0,0 +1,59 @@
+# Multi-architect audit — adversarial quality gate for a skill
+
+The [checklist](checklist.md) is the self-review floor. This is the **high-confidence
+gate**: a panel of N independent reviewers, each a *distinct lens*, reads the skill
+against the rubric + ground truth, then a synthesizer dedups and rules. You **loop
+fix → re-audit until it passes** (no blockers/majors). Run it before shipping a new
+or substantially-changed skill, or whenever a skill must be trusted.
+
+Use the [Workflow tool](scripts/audit-panel.js) to fan the panel out — it returns
+`{remaining, clearsBar, verdict}`.
+
+## The loop (run to convergence)
+1. **Panel** — N agents, one lens each, read-only. Each returns specific findings
+   (severity · file:location · problem · concrete fix). Empty if its lens is clean.
+2. **Synthesize** — dedup overlaps; **drop false positives** (verify each against the
+   real files/repo before keeping); classify blocker / major / minor / nit;
+   `clearsBar = no blockers and no majors remain`.
+3. **If not clean** — apply the do-now set (blockers + majors + cheap high-value
+   minors), then run a **fresh** panel (see "Fresh each round") and repeat.
+4. **Stop** when `clearsBar` is true. The later/nit list is optional polish.
+
+## Rules that make it trustworthy
+- **Fresh panel each round.** After a fix, re-run the panel anew so agents read the
+  *current* files — do not reuse a prior run's cached results (they reflect the old
+  state and will report fixed issues as open / miss regressions).
+- **Verify before keeping.** Every finding must be confirmed against the actual file
+  or repo. The synthesizer drops anything it can't reproduce. Prefer findings that
+  cite a line and a reproduction.
+- **Ground-truth, not vibes.** Give the panel the rubric ([SKILL.md](SKILL.md) +
+  [checklist.md](checklist.md)), an exemplar skill, and the real source the skill
+  describes (e.g. the iOS repo). Agents read; they don't assume.
+- **Watch for regressions.** A fix can break something — the red-team lens and the
+  fresh re-audit exist to catch it (e.g. a broadened check that now false-positives).
+- **clearsBar gates the merge.** Don't merge with an open blocker/major.
+
+## Lenses — pick the set for the task
+One distinct lens per agent (+ a synthesizer). Two ready-made sets:
+
+**General skill audit** — discovery · leanness · shape/layer · scripts · accuracy-vs-source · domain-correctness · wiring · boundaries · red-team → synthesis.
+
+**Prompt-engineering audit** (when the concern is *prompt quality* — descriptions,
+instructions, triggering):
+1. **description-as-discovery** — what + when + trigger words + example; would it activate on a real task?
+2. **disambiguation** — distinct from siblings; a reader can tell when to pick this vs a neighbor.
+3. **trigger coverage** — the real user phrasings (and synonyms) are covered.
+4. **instruction clarity** — steps are unambiguous, ordered, single-interpretation; no vague directives.
+5. **degrees of freedom / layer fit** — reference=descriptive (no numbered procedure), workflow=spine, tool=thin-index; freedom matches the task.
+6. **progressive disclosure / leanness** — SKILL.md is an index; detail bundled one level deep; no duplication.
+7. **token efficiency** — every line is load-bearing; nothing restates what the model already knows.
+8. **consistency** — terminology, naming, paths, cross-references, examples all agree.
+9. **anti-patterns / misfire** — would the model over-apply it, skip a gate, hallucinate a path, or follow it into a wrong output?
+10. **red-team** — adversarially try to make it not trigger, trigger wrongly, or produce broken output; hunt overclaims (says X, the script doesn't).
+
+Scale the panel to risk: a quick check is ~3 lenses; a thorough gate is ~10.
+
+## Scope of fixes per round
+Fix **blockers + majors** always; fold in **cheap, high-value minors** while you're
+in the file. Defer speculative nits and pre-existing/out-of-scope drift to the
+"later" list (and `log()`/note them — don't silently drop coverage).

package/pipeline/skills/shared/external/skill-creator/checklist.md

@@ -0,0 +1,32 @@
+# Pre-ship checklist
+
+Run before considering a skill done.
+
+## Discovery
+- [ ] `description` says **what + when + trigger words**, third person, and names the platform (iOS/SwiftUI).
+- [ ] Description disambiguates from sibling skills (a reader can tell when to pick this vs a neighbor).
+- [ ] Tested: in a fresh task that should trigger it, does the model actually reach for it? If not, sharpen the description.
+
+## Leanness
+- [ ] `SKILL.md` reads like an index, ~1 page (hard cap ~500 lines).
+- [ ] Detail lives in bundled files **one level deep** — no nested-deeper references.
+- [ ] Every line survives "would Claude err without this?" — no over-explaining, no restating what the model knows.
+- [ ] Deterministic code is a **script**, not prose asking the model to regenerate it.
+
+## Shape
+- [ ] Layer is explicit (reference or workflow) and matches the content.
+- [ ] **Reference** skill has **no numbered procedures** — heuristics + pointers only.
+- [ ] **Workflow** skill's numbered steps are **only** the deterministic/irreversible spine, and it has a **verification gate**.
+- [ ] Conventions **point to canonical files** rather than pasting code that will rot.
+
+## Naming & wiring
+- [ ] Name has **no platform prefix**; reference = aspect noun, workflow = verb-phrase; not vague/reserved.
+- [ ] Registered in the plugin manifest (`<plugin>/.claude-plugin/plugin.json` `skills` array) and the marketplace version bumped (`.github/plugin/marketplace.json`).
+- [ ] Listed in the `index` skill's route table.
+
+## House rules
+- [ ] No AI/Claude/Anthropic attribution anywhere in the skill or its examples.
+- [ ] Escape hatches name the skill to hand off to when this one doesn't apply.
+
+## High-confidence gate (new / substantially-changed skills)
+- [ ] Ran the multi-architect audit ([audit.md](audit.md)) and looped fix → re-audit until `clearsBar` (no blockers/majors).

package/pipeline/skills/shared/external/skill-creator/examples.md

@@ -0,0 +1,65 @@
+# Examples — descriptions & shape
+
+## Descriptions: the discovery lever
+
+**Bad (vague — rarely triggers):**
+```yaml
+description: Helps with navigation
+```
+Why it fails: no "when", no trigger words, no platform — the router can't tell what task this matches.
+
+**Good (what + when + triggers + platform):**
+```yaml
+description: "In-app navigation for a SwiftUI iOS app — the coordinator-per-domain pattern, the tab shell, cross-domain navigation, deep links, and modals. Reach for this when adding a screen, a tab, a deep link, or a modal, or deciding how one screen reaches another."
+```
+Why it works: states the domain, lists concrete triggers ("adding a screen, a tab, a deep link"), names the platform, and implies the boundary.
+
+**Workflow example (action + when to run):**
+```yaml
+description: "Branch, commit, push, and open a PR for this repo. Owns the git/PR spine and house guardrails — type-first branch names, no AI attribution, no force-push, correct base branch. Reach for this whenever a change is ready to ship."
+```
+
+### Recipe
+`<what it covers/does> + <concrete when/trigger phrases> + <platform> + <implied boundary vs siblings>`
+
+---
+
+## Shape: reference vs workflow
+
+**Wrong — a reference skill drifting into a procedure:**
+```markdown
+## Procedures
+1. Open the file
+2. Add the wrapper
+3. Register the route
+4. Build and run
+```
+A reference (knowledge) skill should describe *the rule and where the canonical example lives*, not script the keystrokes.
+
+**Right — reference stays descriptive:**
+```markdown
+## Decision rules
+- New screen in a domain → add `<Name>Screen` under its Presentation layer,
+  wrap content in the domain's container, route via the domain coordinator.
+  Canonical: `<repo>/Features/Profile/ProfileScreen.swift`.
+```
+
+**Right — workflow earns its numbered steps** (deterministic/irreversible spine):
+```markdown
+## Procedures
+1. Pre-flight: `git status` clean? on base branch?
+2. Branch: `git checkout -b <type>/<scope>/<desc>`
+3. Commit: stage; conventional message; strip any AI co-author trailer.
+4. Push; never force-push a protected branch.
+5. PR: `gh pr create --base <base> …` (no AI footer).
+## Verification
+- `git log -1` shows clean message, no AI trailer, correct author.
+```
+
+---
+
+## Leanness: cut what the model already knows
+
+**Bloat:** "PDF files are documents that contain text and images. To read them you first need a library that can parse the binary format…"
+
+**Lean:** "Extract text from PDFs with `pdfplumber`."

package/pipeline/skills/shared/external/skill-creator/label-check.md

@@ -0,0 +1,43 @@
+# Label intent check — does a title carry its own meaning?
+
+A label (rule title, section header, principle/constraint name) is the handle a reader grasps *before* the body. If the handle leaks the wrong shape — ambiguous, one-sided, or off-topic — the reader forms the wrong model and the body has to fight it. This is a cheap test that catches that early: have **fresh subagents infer the rule from the label alone**, then compare against your intended meaning. Convergence = the label is self-carrying.
+
+## When to run it
+- Naming a **strict rule** or constraint inside a skill (the kind a reader must obey).
+- A **section header** that gates non-trivial content (phase/principle/constraint names).
+- Any label meant to convey the **whole intent** of its body (not a summary — the intent).
+- Skip it for purely organizational labels ("Examples", "See also") — they carry no intent.
+
+## Inputs (collect first)
+1. **Candidate label** — the exact string under test.
+2. **Surrounding context** — one paragraph: which skill/doc, what adjacent labels cover, the domain concepts in play.
+3. **Intended meaning** — 1–3 sentences of ground truth (what the body says / what the reader should walk away believing). **Not** shown to the inference agents. If you can't state it in 3 sentences, the body is unclear — fix that first.
+
+## Procedure
+**One iteration = 5 parallel subagents**, each given ONLY the label + context (never the body), each forced to commit:
+```
+Context: <surrounding context — 1 paragraph>.
+The label under test is: **"<candidate label>"**
+You have NOT seen the body. From ONLY this label + context, what do you infer it
+enforces / requires / means? 1–2 concrete sentences, under 80 words. Commit — no
+hedging, no clarifying questions.
+```
+Launch all 5 in the **same** message (parallel) so they're independent by construction.
+
+**Convergence (per iteration), comparing the 5 inferences to the intended meaning:**
+- **PASS** — ≥4/5 cover *all* key intent beats (including the bidirectional / edge / scope beat, if the intent has one). Wording drift is fine.
+- **PARTIAL** — they consistently catch one side of a bidirectional rule but miss the other, or over-extend into an adjacent concern. Revise the label, re-run.
+- **FAIL** — inferences diverge wildly or miss the core beat. Revise, re-run.
+
+**Idempotency (after a PASS):** run **2 more rounds**, 5 fresh agents each (3×5 = 15 inferences), same prompt. Require **all 3 rounds PASS** with no new systematic miss — confirms the PASS wasn't luck. A regression in round 2/3 → treat as PARTIAL and iterate.
+
+**Termination:** converged (3/3 PASS) → apply the label. 3 iterations without a PASS → stop, hand back the best candidate + the persistent miss; don't force a label that won't stick.
+
+## Defaults
+5 agents/round · 3 rounds · 80-word inference cap · max 3 iterations before handing back. High-stakes labels (top-level skill names, protocol names) → 7 agents × 3 rounds; throwaway section headers → 3 × 2.
+
+## Anti-patterns
+- **Giving agents the body** — defeats the test (you're checking the label's *self-carrying* power).
+- **Running sequentially** — they'd anchor on each other; must be parallel.
+- **Tweaking one word on a FAIL** — step back and rethink the concept the label names, don't polish a wrong handle.
+- **Accepting "mostly right"** — a label that reliably misses a beat misleads every reader the same way. Fix it, or accept the rule is one-sided and split the body.

package/pipeline/skills/shared/external/skill-creator/scripts/audit-panel.js

@@ -0,0 +1,83 @@
+// audit-panel.js — Workflow template for the multi-architect skill audit.
+//
+// Run with the Workflow tool. Edit the CONFIG block for your target, then launch.
+// Returns { remaining, clearsBar, verdict }. If clearsBar is false, apply the
+// `remaining` blockers/majors, then RE-RUN A FRESH copy (do NOT resume — agents
+// must read the current files). Loop until clearsBar. See ../audit.md.
+
+export const meta = {
+  name: 'skill-audit-panel',
+  description: 'Adversarial N-architect audit of a skill against the skill-creator rubric',
+  phases: [{ title: 'Audit' }, { title: 'Synthesis' }],
+}
+
+// ── CONFIG — edit these ──────────────────────────────────────────────────────
+const TARGET = `
+- <abs path to SKILL.md>
+- <abs path to each bundled file / script>
+`
+const RUBRIC = `<abs path to reference/skill-creator/SKILL.md> + checklist.md`
+const EXEMPLAR = `<abs path to a known-good skill of the same layer>`
+const GROUND_TRUTH = `<abs path to the real source the skill describes (e.g. the iOS repo), with key facts>`
+// Pick a lens set from audit.md (general or prompt-engineering). [label, brief] pairs:
+const LENSES = [
+  ['discovery', 'description-as-discovery: what+when+trigger words+example; would it activate on a real task?'],
+  ['disambiguation', 'distinct from sibling skills; a reader can tell when to pick this vs a neighbor.'],
+  ['triggers', 'real user phrasings + synonyms are covered.'],
+  ['clarity', 'instructions unambiguous, ordered, single-interpretation; no vague directives.'],
+  ['layer', 'degrees of freedom match the layer (reference=descriptive / workflow=spine / tool=thin-index).'],
+  ['leanness', 'SKILL.md is an index; detail bundled one level deep; no duplication or bloat.'],
+  ['tokens', 'every line load-bearing; nothing restates what the model already knows.'],
+  ['consistency', 'terminology, naming, paths, cross-refs, examples all agree.'],
+  ['misfire', 'would the model over-apply, skip a gate, hallucinate a path, or follow it to a wrong output?'],
+  ['redteam', 'adversarially make it not trigger / trigger wrongly / produce broken output; hunt overclaims (says X, script does not).'],
+]
+// ─────────────────────────────────────────────────────────────────────────────
+
+const COMMON = `
+You are auditing a skill. Read the CURRENT files and report ONLY genuine, specific,
+reproducible findings for YOUR lens. Verify against the rubric + ground truth — do
+not assume. Read-only; do NOT edit. If your lens is clean, return an empty array.
+
+TARGET (the skill under audit):${TARGET}
+RUBRIC (the bar): ${RUBRIC}
+EXEMPLAR (known-good of this layer): ${EXEMPLAR}
+GROUND TRUTH (what the skill describes): ${GROUND_TRUTH}
+
+Each finding: severity (blocker|major|minor|nit), file:location, the problem, the concrete fix.
+`
+
+const FINDING = {
+  type: 'object', additionalProperties: false,
+  properties: {
+    severity: { type: 'string', enum: ['blocker', 'major', 'minor', 'nit'] },
+    location: { type: 'string' }, problem: { type: 'string' }, fix: { type: 'string' },
+  }, required: ['severity', 'location', 'problem', 'fix'],
+}
+const LENS_SCHEMA = {
+  type: 'object', additionalProperties: false,
+  properties: { lens: { type: 'string' }, findings: { type: 'array', items: FINDING } },
+  required: ['lens', 'findings'],
+}
+
+phase('Audit')
+const results = await parallel(LENSES.map(([lens, brief]) => () =>
+  agent(`${COMMON}\n\nYOUR LENS — ${lens}: ${brief}`, { label: `audit:${lens}`, phase: 'Audit', schema: LENS_SCHEMA })
+))
+const all = results.filter(Boolean).flatMap(r => r.findings.map(f => ({ ...f, lens: r.lens })))
+
+phase('Synthesis')
+const SYNTH = {
+  type: 'object', additionalProperties: false,
+  properties: {
+    remaining: { type: 'array', items: { type: 'object', additionalProperties: false,
+      properties: { ...FINDING.properties, lenses: { type: 'string' } },
+      required: [...FINDING.required, 'lenses'] } },
+    clearsBar: { type: 'boolean' },
+    verdict: { type: 'string' },
+  }, required: ['remaining', 'clearsBar', 'verdict'],
+}
+return await agent(
+  `${COMMON}\n\nYou are the SYNTHESIS architect. Below are ${all.length} raw findings from ${LENSES.length} lenses. Dedup overlaps (note which lenses raised each). DROP false positives — verify against the files before keeping; if you cannot reproduce it, drop it. Classify each survivor; set clearsBar=true ONLY if no blockers and no majors remain. One-paragraph verdict.\n\nRAW:\n${JSON.stringify(all, null, 2)}`,
+  { label: 'synthesis', phase: 'Synthesis', schema: SYNTH }
+)

package/pipeline/skills/shared/external/skill-creator/template.md

@@ -0,0 +1,67 @@
+# Skill skeletons
+
+Two skeletons — pick by layer. Both stay lean; push detail into one-level-deep bundled files.
+
+Frontmatter fields used in this toolkit: `name`, `description` (required-quality), `user-invocable`, `argument-hint` (optional), `allowed-tools`.
+
+---
+
+## Reference skill (descriptive — knowledge)
+
+No numbered procedures. Principles + pointers + heuristics.
+
+```markdown
+---
+name: <aspect-noun>          # e.g. navigation — NO platform prefix
+description: <what it covers + when to reach for it + trigger words. Say "iOS/SwiftUI" so the router can disambiguate.>
+user-invocable: true
+allowed-tools: Read, Grep, Glob, Bash, Edit, Write
+---
+
+# <name> — <short title>
+
+> **Layer:** reference (knowledge)
+> **Use when:** <trigger>   **Hand off to:** <sibling skill>
+
+## Scope
+In / out, 1–2 lines.
+
+## Invariants            <!-- non-negotiables + the why -->
+## Conventions & golden paths   <!-- point to canonical files; don't paste code -->
+## Decision rules        <!-- if X do A; when unsure, ask/verify -->
+## Pitfalls              <!-- known traps -->
+## Escape hatches        <!-- when this doesn't apply → which skill -->
+```
+
+---
+
+## Workflow skill (imperative — action)
+
+Has a numbered procedure, but only for the deterministic/irreversible spine. Cite reference skills for judgment. Always include a verification gate.
+
+```markdown
+---
+name: <verb-phrase>         # e.g. branch-and-pr
+description: <what it does + when to run it + trigger words (iOS/SwiftUI).>
+user-invocable: true
+argument-hint: [<step> | ...]
+allowed-tools: Bash, Read
+---
+
+# <name> — <short title>
+
+> **Layer:** workflow (action)
+> **Use when:** <trigger>   **Don't use when:** <hand off>
+
+## Scope
+In / out, 1–2 lines.
+
+## Invariants            <!-- hard rules / guardrails -->
+## Conventions & golden paths   <!-- base branch, auth, canonical commands -->
+## Decision rules        <!-- branch when…, escalate when… -->
+## Procedures            <!-- IMPERATIVE: only deterministic/irreversible steps -->
+1. ...
+## Verification          <!-- IMPERATIVE: prove it worked (build/run/test) -->
+## Pitfalls
+## Escape hatches
+```

package/pipeline/skills/skills-index.md

@@ -3,7 +3,7 @@
 > Auto-generated by `pipeline/scripts/build-skills-index.mjs`  -  do not hand-edit.
 > Regenerate with `node pipeline/scripts/build-skills-index.mjs`.
 
-**226 skills** across 5 groups.
+**228 skills** across 5 groups.
 
 | Group | Name | Platform | Description |
 |-------|------|----------|-------------|
@@ -29,6 +29,7 @@
 | external | `authentication` |  -  | Implement iOS authentication flows with AuthenticationServices and LocalAuthentication. Use when building Sign in with Apple, passkey/WebAut |
 | external | `avkit` |  -  | Create media playback experiences using AVKit. Use when adding video players with AVPlayerViewController, enabling Picture-in-Picture, routi |
 | external | `background-processing` |  -  | Schedule and execute background work on iOS using BGTaskScheduler. Use when registering BGAppRefreshTask for short background fetches, BGPro |
+| external | `backlog` |  -  | The engineering backlog registry for deferred-but-approved work in this codebase. Every job the user defers ('defer it', 'add it to the list |
 | external | `callkit-voip` |  -  | Implement VoIP calling with CallKit and PushKit. Use when building incoming/outgoing call flows, registering for VoIP push notifications, co |
 | external | `ci-cd-pipelines` |  -  | CI/CD pipelines: GitHub Actions workflows, Docker multi-stage builds, environment management, secret management, deployment strategies |
 | external | `clean-code` |  -  | This skill embodies the principles of \"Clean Code\" by Robert C. Martin (Uncle Bob). Use it to transform \"code that works\" into \"code th |
@@ -185,6 +186,7 @@
 | external | `room-database` |  -  | Implement Room database persistence on Android with @Entity, @Dao, @Database, Flow-based reactive queries, TypeConverters for complex types, |
 | external | `search-first` |  -  | \| |
 | external | `shareplay-activities` |  -  | Build shared real-time experiences using GroupActivities and SharePlay. Use when implementing shared media playback, collaborative app featu |
+| external | `skill-creator` |  -  | Author and refine skills for a plugin/toolkit efficiently. Use when creating a new skill, trimming or splitting an existing one, writing a s |
 | external | `speech-recognition` |  -  | Transcribe speech to text using Apple's Speech framework. Use when implementing live microphone transcription with AVAudioEngine, recognizin |
 | external | `spm-build-analysis` |  -  | Analyze Swift Package Manager dependencies, package plugins, module variants, and CI-oriented build overhead that slow Xcode builds. Use whe |
 | external | `storekit` |  -  | Implement, review, or improve in-app purchases and subscriptions using StoreKit 2. Use when building paywalls with SubscriptionStoreView or  |