@winspan/claude-forge 8.54.4 → 9.12.0

package/dist/skills/distilled/distilled-using-superpowers.md

@@ -0,0 +1,134 @@
+---
+name: distilled-using-superpowers
+version: 0.2.0-distilled
+description: 'Distilled IT-universal skill: using-superpowers (score 4.5/5)'
+keywords:
+  - using
+  - superpowers
+rubric_version: 2
+distilled_from:
+  - upstream: https://github.com/obra/superpowers.git
+    license: MIT
+    commit: f2cbfbefebbfef77321e4c9abc9e949826bea9d7
+    paths:
+      - using-superpowers/SKILL.md
+distilled_at: '2026-06-15T00:58:31.504Z'
+distilled_by: claude-code skill-distiller agent
+it_universal_score: 4.5
+it_universal_dims:
+  d1: 1
+  d2: 0.5
+  d3: 1
+  d4: 1
+  d5: 1
+it_universal_rationale: >-
+  Language-neutral meta-methodology for AI assistant skill invocation; platform-adaptive with no
+  repo-specific paths or project terminology; strong transferable decision flowchart and heuristics.
+---
+
+# Skill-First Workflow: Invoke Relevant Skills Before Any Action
+
+## When to use
+- At the start of **any** conversation or task in an AI assistant (Claude Code, Copilot CLI, Gemini CLI, etc.)
+- Before exploring a codebase, answering a question, or asking a clarifying question
+- Whenever you are about to enter plan mode or take any substantive action
+- When multiple skills might apply and you need to pick the right order
+
+## Core idea
+
+The fundamental discipline is: **check for and invoke relevant skills *before* taking any action — including before asking clarifying questions**. Even a 1% probability that a skill applies is enough to trigger an invocation. Skills describe *how* to approach a task; without checking them first, you may gather information, explore, or plan in a suboptimal or incorrect way. User instructions (project config files, direct requests) always take the highest precedence over skills, which in turn override default system behavior. When you invoke a skill and it turns out to be inapplicable to the situation, you are free to disregard it — but you must check first.
+
+## Steps
+
+1. **Receive user message or prepare to enter plan mode.**
+
+2. **Ask: "Might any skill apply — even with 1% probability?"**
+   - Yes → proceed to step 3.
+   - Definitely not → respond directly.
+
+3. **Invoke the Skill tool** (platform-specific name varies; see Platform notes below).
+   - Announce: *"Using [skill name] to [brief purpose]."*
+
+4. **Apply skill priority order** when multiple skills could apply:
+   - **Process skills first** (brainstorming, debugging, planning) — they determine *how* to approach the task.
+   - **Implementation skills second** (patterns, code generation, domain-specific guides) — they guide execution.
+   - Example: "Let's build X" → brainstorming skill first, then implementation skill.
+   - Example: "Fix this bug" → debugging skill first, then domain-specific skill.
+
+5. **If the invoked skill contains a checklist**, create a to-do item per checklist entry before proceeding.
+
+6. **Follow the skill exactly** (rigid skills) or adapt its principles to context (flexible skills). The skill itself declares which type it is.
+
+7. **Proceed with the task**, informed by the skill's guidance.
+
+## Skill types
+
+| Type | Examples | How to follow |
+|---|---|---|
+| **Rigid** | TDD, debugging protocols | Follow exactly; do not adapt away the discipline |
+| **Flexible** | Design patterns, code style | Adapt principles to context |
+
+The skill document itself tells you which type it is.
+
+## Platform notes
+
+| Platform | Tool name to invoke |
+|---|---|
+| Claude Code | `Skill` tool |
+| Copilot CLI | `skill` tool |
+| Gemini CLI | `activate_skill` tool |
+
+Never use a file-read tool to load skill content — always use the platform's designated skill tool so that the correct version is loaded.
+
+## Instruction precedence
+
+1. **User's explicit instructions** (CLAUDE.md, AGENTS.md, GEMINI.md, direct requests) — highest priority
+2. **Invoked skills** — override default system behavior
+3. **Default system prompt** — lowest priority
+
+If a user config file says "don't do X" and a skill says "always do X," follow the user's config.
+
+## Anti-patterns
+
+- **"This is just a simple question."** → Questions are tasks. Check for skills before answering.
+- **"I need more context first."** → Skill check comes *before* clarifying questions.
+- **"Let me explore the codebase first."** → Skills tell you *how* to explore. Check first.
+- **"I remember this skill from before."** → Skills evolve. Always read the current version via the tool.
+- **"This skill seems like overkill."** → Simple tasks become complex. Invoke and decide afterward.
+- **"I'll just do this one quick thing first."** → Check *before* doing anything.
+- **"I know what that skill says."** → Knowing the concept ≠ using the skill. Invoke it.
+- **"This doesn't count as a real task."** → Any action = task. Check for skills.
+
+## Decision flowchart (text form)
+
+```
+User message received
+        │
+        ▼
+Might any skill apply? (even 1%)
+   │              │
+  Yes             No
+   │              └──► Respond directly
+   ▼
+Invoke Skill tool
+        │
+        ▼
+Announce: "Using [skill] to [purpose]"
+        │
+        ▼
+Skill has a checklist?
+   │              │
+  Yes             No
+   │              └──► Follow skill exactly
+   ▼
+Create one todo per checklist item
+        │
+        ▼
+Follow skill exactly
+        │
+        ▼
+Respond / act
+```
+
+## References
+- Upstream: https://github.com/obra/superpowers.git

package/dist/skills/distilled/distilled-verification-before-completion.md

@@ -0,0 +1,213 @@
+---
+name: distilled-verification-before-completion
+version: 0.2.0-distilled
+description: 'Distilled IT-universal skill: verification-before-completion (score 5/5)'
+keywords:
+  - verification
+  - before
+  - completion
+rubric_version: 2
+distilled_from:
+  - upstream: https://github.com/obra/superpowers.git
+    license: MIT
+    commit: f2cbfbefebbfef77321e4c9abc9e949826bea9d7
+    paths:
+      - verification-before-completion/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - django-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - laravel-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - quarkus-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - springboot-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - verification-loop/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - verification-loop/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - laravel-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - quarkus-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - springboot-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - verification-loop/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - django-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - laravel-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - springboot-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - verification-loop/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - verification-loop/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - django-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - laravel-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - quarkus-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - springboot-verification/SKILL.md
+  - upstream: https://github.com/affaan-m/ECC.git
+    license: MIT
+    commit: 928076cc08cbb31e8549cea2883b4f51811de1c8
+    paths:
+      - verification-loop/SKILL.md
+distilled_at: '2026-06-15T00:59:08.307Z'
+distilled_by: claude-code skill-distiller agent
+it_universal_score: 5
+it_universal_dims:
+  d1: 1
+  d2: 1
+  d3: 1
+  d4: 1
+  d5: 1
+it_universal_rationale: >-
+  Language-neutral, tool-chain-neutral verification discipline with zero repo-specific references;
+  the Gate Function and rationalization tables transfer directly to any codebase or workflow.
+---
+
+# Verification Before Completion
+
+## When to use
+- Before claiming "tests pass", "build succeeds", "bug is fixed", or "done"
+- Before committing, opening a PR, or marking a task complete
+- Before expressing any satisfaction or moving to the next task
+- After delegating work to a sub-agent that reports success
+
+## Core idea
+
+Claiming work is complete without fresh evidence is dishonesty, not efficiency. The only valid basis for a success claim is the **actual output of the relevant command run in the current context**. Prior runs, agent self-reports, confidence, and partial checks are not substitutes. Every rationalization for skipping verification is a known failure mode; name it, then reject it.
+
+The rule applies to exact phrases, paraphrases, and any implication of success — spirit over letter.
+
+## The Gate Function
+
+Before making **any** status claim or completion statement, execute all five steps:
+
+1. **IDENTIFY** — What command produces evidence for this claim?
+2. **RUN** — Execute it fully (no cached output, no partial scope)
+3. **READ** — Examine the complete output; check exit code; count failures
+4. **VERIFY** — Does the output confirm the claim?
+   - If NO → state actual status with the evidence
+   - If YES → state the claim *with* the evidence attached
+5. **THEN** — Only now make the claim
+
+Skipping any step = asserting without evidence.
+
+## Common Claim → Required Evidence
+
+| Claim | What actually proves it | What does NOT prove it |
+|---|---|---|
+| Tests pass | Test runner: 0 failures, 0 errors | Previous run; "should pass" |
+| Linter clean | Linter output: 0 issues | Partial file check |
+| Build succeeds | Build command exits 0 | Linter passing; logs look fine |
+| Bug fixed | Original symptom reproduced and passes | Code changed; assumed fixed |
+| Regression test valid | Red → Green cycle verified | Test written but not inverted |
+| Agent completed task | VCS diff shows expected changes | Agent reports "success" |
+| Requirements met | Line-by-line checklist verified | All tests passing |
+
+## Red Flags — Stop Immediately
+
+- Hedging words: "should", "probably", "seems to", "I think"
+- Expressing satisfaction before running verification ("Great!", "Done!", "Perfect!")
+- About to commit or push without having run the check
+- Trusting a delegated agent's self-report without inspecting artifacts
+- Reasoning "partial check is sufficient"
+- Feeling tired and wanting the work to be over
+
+## Rationalization Table
+
+| Excuse heard | Correct response |
+|---|---|
+| "Should work now" | RUN the command |
+| "I'm confident" | Confidence ≠ evidence |
+| "Just this once" | No exceptions |
+| "Linter passed" | Linter ≠ compiler |
+| "Agent said success" | Verify independently via VCS diff |
+| "Partial check is enough" | Partial proves nothing |
+| "Different words, rule doesn't apply" | Spirit over letter |
+
+## Steps (TDD Red-Green Pattern)
+
+When writing a regression test, full verification requires a **red-green cycle**:
+
+1. Write the test
+2. Run → must **pass** (green, with fix in place)
+3. Temporarily revert the fix
+4. Run → must **fail** (red — confirms test is meaningful)
+5. Restore fix
+6. Run → must **pass** again
+
+Skipping the red phase means the test may not actually catch the bug.
+
+## Anti-patterns
+
+- Claiming success based on a run from an earlier message or session
+- Saying "looks good" after reading code without executing it
+- Committing in the same step as implementation without a separate verify step
+- Conflating "agent reports done" with "work is verified done"
+- Using softer phrasing ("it appears to be working") to sidestep the rule — the spirit still applies
+
+## References
+- Upstream: https://github.com/obra/superpowers.git

package/dist/skills/distilled/distilled-writing-skills.md

@@ -0,0 +1,175 @@
+---
+name: distilled-writing-skills
+version: 0.2.0-distilled
+description: 'Distilled IT-universal skill: writing-skills (score 4/5)'
+keywords:
+  - writing
+  - skills
+rubric_version: 2
+distilled_from:
+  - upstream: https://github.com/obra/superpowers.git
+    license: MIT
+    commit: f2cbfbefebbfef77321e4c9abc9e949826bea9d7
+    paths:
+      - writing-skills/SKILL.md
+distilled_at: '2026-06-15T01:00:38.805Z'
+distilled_by: claude-code skill-distiller agent
+it_universal_score: 4
+it_universal_dims:
+  d1: 1
+  d2: 0.5
+  d3: 1
+  d4: 0.5
+  d5: 1
+it_universal_rationale: >-
+  TDD-for-documentation methodology and description-field optimization (CSO) are language-neutral
+  and applicable to any AI agent skill authoring workflow, regardless of codebase or toolchain.
+---
+
+# Writing Agent Skills (TDD for Process Documentation)
+
+## When to use
+- Creating a new skill document for an AI agent
+- Editing or refactoring an existing skill that agents seem to ignore
+- Verifying a skill actually changes agent behavior before deploying it
+- Debugging why an agent skips or misreads a skill (description optimization)
+- Deciding whether something belongs in a skill vs. a repo-level convention file
+
+## Core idea
+
+Writing skills is **TDD applied to process documentation**. Like software TDD, you first run
+a baseline scenario (RED: watch the agent violate the rule *without* the skill), then write
+the skill (GREEN: agent now complies), then close loopholes found through additional tests
+(REFACTOR). If you skipped the baseline, you don't know whether the skill targets the real
+failure mode. The key artifact is a `SKILL.md` with two critical elements: a precise
+frontmatter `description` that drives **discovery**, and a concise body that drives
+**compliance**. Both must be correct; a great body behind a misleading description is never
+loaded.
+
+## Steps
+
+### 1. RED — establish baseline
+Before writing anything, run a pressure scenario with a subagent. Document the exact
+rationalizations the agent uses to justify the violation. These become the specific failure
+modes the skill must address.
+
+### 2. Write the skill
+
+Create `skills/<skill-name>/SKILL.md` (flat namespace; all skills live in one searchable
+directory):
+
+```markdown
+---
+name: Skill-Name-With-Hyphens
+description: Use when [specific triggering conditions, symptoms, situations]
+---
+
+# Skill Name
+
+## Overview
+Core principle in 1-2 sentences.
+
+## When to Use
+- Symptom A
+- Symptom B
+- NOT when: [counter-indicators]
+
+## Core Pattern
+Before/after comparison or concrete steps.
+
+## Common Mistakes
+What goes wrong + fixes.
+```
+
+**Frontmatter rules:**
+- `name`: letters, numbers, hyphens only (no parentheses or special chars)
+- `description`: **triggering conditions only** — see §Description Anti-patterns below
+- Total frontmatter ≤ 1 024 characters
+
+### 3. GREEN — verify compliance
+Re-run the same pressure scenario with the skill present. Agent should comply. If it still
+violates, sharpen the `description` or tighten the body.
+
+### 4. REFACTOR — close loopholes
+Observe new rationalizations the agent invents. Plug each one. Repeat until no new failure
+modes emerge.
+
+## Description Anti-patterns — CSO Critical
+
+The `description` field is how an agent decides *whether to load* the skill at all. A bad
+description is the #1 reason skills are ignored.
+
+> **Rule: Description = When to Use. NOT What the Skill Does.**
+
+If the description summarises the skill's workflow, the agent may follow that summary
+*instead of* reading the full body. Observed failure: description said "code review between
+tasks" → agent did ONE review and never consulted the two-stage flowchart in the body.
+
+```yaml
+# ❌ BAD: summarises workflow — agent skips body
+description: Use when executing plans - dispatches subagent per task with review between tasks
+
+# ❌ BAD: too much process detail
+description: Use for TDD — write test first, watch it fail, write minimal code, refactor
+
+# ✅ GOOD: triggering conditions only, no workflow
+description: Use when executing implementation plans with independent tasks
+
+# ✅ GOOD: problem-focused triggers
+description: Use when tests have race conditions, timing dependencies, or pass/fail inconsistently
+```
+
+Additional description rules:
+- Start with `Use when…`
+- Write in third person (injected into system prompts)
+- Describe the *problem* (race conditions, inconsistent state), not language-specific
+  symptoms (unless the skill itself is tech-specific — then be explicit)
+- Under 500 characters if possible
+
+## When NOT to create a skill
+
+| Situation | Better home |
+|---|---|
+| One-off solution for a single task | Session notes / inline comment |
+| Standard practice documented elsewhere | Link to that source |
+| Repo-specific conventions | Your repo's convention file (e.g., `CLAUDE.md`, `AGENTS.md`) |
+| Mechanical constraint enforceable by linting/CI | Automate it — save skills for judgment calls |
+
+## Token efficiency
+
+Always-loaded skills consume context in **every conversation**. Keep them tight:
+
+- Always-loaded / getting-started skills: < 150 words each
+- Other frequently-loaded skills: < 500 words
+- Move exhaustive flag lists to `--help`; reference the command rather than duplicating it
+- Cross-reference other skills by name instead of repeating their content
+- One excellent code example beats several mediocre ones
+
+## Naming conventions
+
+Prefer **verb-first gerunds** — active, describes the action being taken:
+
+| ✅ Good | ❌ Bad |
+|---|---|
+| `condition-based-waiting` | `async-test-helpers` |
+| `root-cause-tracing` | `debugging-techniques` |
+| `flatten-with-flags` | `data-structure-refactoring` |
+| `creating-skills` | `skill-creation` |
+
+## Anti-patterns
+
+- **Skipping baseline** — writing a skill without watching the agent fail first means you
+  don't know what failure mode you're actually solving
+- **Workflow summary in description** — causes agent to follow the description shortcut
+  instead of reading the body
+- **Over-documenting** — bloated skills inflate context cost and reduce compliance; every
+  word in a frequently-loaded skill has a runtime price
+- **Project-specific content in skills** — repo paths, local tool names, environment
+  variables; these belong in your repo's convention file, not a reusable skill
+- **Force-loading via direct file links (`@file`)** — burns context before it's needed;
+  reference skill names instead and let the agent decide when to load
+- **Flowcharts for linear instructions** — use numbered lists; reserve flowcharts for
+  non-obvious decision branches where early exit is the common error
+
+## References
+- Upstream: https://github.com/obra/superpowers.git

package/dist/skills/registry.d.ts

@@ -4,72 +4,76 @@ export interface Skill {
     keywords: string[];
     content: string;
     path: string;
-    isOfficial?: boolean;
+    /**
+     * Marks claude-forge-shipped built-in skills (currently the
+     * `src/skills/distilled/*.md` set). Historically called "official";
+     * semantics simplified to "built-in" after the official-purge spec
+     * (2026-05-27, 1110).
+     */
+    isBuiltin?: boolean;
     description?: string;
+    /**
+     * Phase 7 — Skill ↔ Agent pairing (frontmatter field, parse-only).
+     * The push-injection path that consumed this (skill_pairing directive +
+     * workflow_recommendations write) was deleted with spec 1200 / decision
+     * fe6f98cd; the field is still parsed so frontmatter round-trips cleanly.
+     */
+    spawn_agent?: string;
+    /**
+     * Optional template body sent as the spawned agent's prompt. Reserved for
+     * future use — current Phase 7 wiring injects a fixed directive built from
+     * the original prompt. Stored here so frontmatter parsing round-trips
+     * cleanly when the field IS supplied.
+     */
+    spawn_agent_prompt?: string;
 }
 /**
  * Simple skill registry that scans ~/.claude/skills/*.md
- * and matches by keywords in frontmatter
+ * and matches by keywords in frontmatter.
+ *
+ * D R-B (2026-05-29, spec 0902 §2.4.4 / decision f5a5b030 Option B): the
+ * Anthropic-SDK-backed `SemanticSkillMatcher` was deleted. The registry is
+ * now **keyword-only**. Constructor accepts no args; callers that used to
+ * pass `(apiKey, model, baseURL)` should drop those — they were silently
+ * ignored in R-A and are gone entirely now. Schema field
+ * `config.skill_matching.api_key` was removed from the `ForgeConfig` JSON
+ * schema in D R-D; daemon still grep-warns the raw yaml on startup.
+ *
+ * Dead-code removal (2026-06-10, decision ed98c8e8): the keyword-matching
+ * API (`match` / `matchWithConfidence` / `matchWithDetails` / private
+ * `matchKeywords`) and the keyword scoring helper file were deleted — the
+ * skill push route is gone; skills are now pull-only via MCP
+ * (`skill-list` / `skill-invoke`), which only need `getAll` / `get` /
+ * `getManifest` / `reload`.
  */
 export declare class SkillRegistry {
     private skills;
-    private semanticMatcher;
-    constructor(apiKey?: string, model?: string, baseURL?: string);
+    constructor();
     /**
-     * Resolve the directory containing official built-in skill .md files.
-     * Uses import.meta.url for ESM compatibility (works in both dev and npm-installed environments).
+     * Resolve the directory containing built-in distilled skill .md files.
+     * Uses import.meta.url for ESM compatibility (dev + npm-installed).
      */
-    private resolveBuiltinDir;
+    private resolveDistilledDir;
     /**
-     * Scan ~/.claude/skills/ for markdown files with frontmatter
-     * Official skills are loaded first, then user skills (which can override)
+     * Scan claude-forge built-in distilled skills + ~/.claude/skills/ for
+     * user skills. Built-in skills load first; user skills load second and
+     * can override by id.
      *
-     * Supports two formats:
-     * 1. Flat format: ~/.claude/skills/skill-name.md
-     * 2. Directory format: ~/.claude/skills/skill-name/SKILL.md (agent-skills format)
+     * User-skill formats supported:
+     * 1. Flat: ~/.claude/skills/skill-name.md
+     * 2. Directory: ~/.claude/skills/skill-name/SKILL.md (agent-skills format)
      */
     private scan;
-    /**
-     * Match a prompt against skill keywords with hybrid approach:
-     * 1. Try semantic matching (AI-powered) if available
-     * 2. Fall back to keyword matching if semantic fails or not configured
-     */
-    match(prompt: string, keywords?: string[], context?: {
-        recentFiles?: string[];
-    }): Promise<Skill | null>;
-    /**
-     * Like match(), but also returns the confidence score (0-100) so callers
-     * can compare across alternatives (e.g. agent vs skill routing).
-     */
-    matchWithConfidence(prompt: string, keywords?: string[], context?: {
-        recentFiles?: string[];
-    }): Promise<{
-        skill: Skill;
-        confidence: number;
-        source: 'semantic' | 'keyword';
-    } | null>;
-    /**
-     * Keyword-based matching (fallback method)
-     * Supports fallback to description-based substring matching when keywords are empty
-     */
-    private matchKeywords;
-    /**
-     * Flexible keyword matching with word boundary for English, substring for Chinese
-     */
-    private matchKeywordFlexible;
-    /**
-     * Match with full result details (for debugging/logging)
-     */
-    matchWithDetails(prompt: string, keywords?: string[], context?: {
-        recentFiles?: string[];
-    }): Promise<{
-        skill: Skill;
-        confidence: number;
-        matchedKeywords: string[];
-    }[]>;
     /** Return all loaded skills */
     getAll(): Skill[];
-    /** Get a skill by ID */
+    /**
+     * Get a skill by ID. Returns `undefined` for unknown ids.
+     *
+     * The legacy `official-*` → `distilled-*` alias fallback was removed by
+     * the official-purge spec (2026-05-27, 1110). Old `official-*` ids no
+     * longer resolve; historical rows in `skill_invocations` with those ids
+     * are not migrated (user-accepted residue).
+     */
     get(id: string): Skill | undefined;
     /**
      * Get skill manifest (id + description + keywords) for Agent pre-declaration

package/dist/skills/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/skills/registry.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,eAAe,CAAqC;gBAEhD,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;IAY7D;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAKzB;;;;;;;OAOG;IACH,OAAO,CAAC,IAAI;IA2GZ;;;;OAIG;IACG,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO,EAAE,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAKjH;;;OAGG;IACG,mBAAmB,CACvB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,EAAO,EACvB,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GACnC,OAAO,CAAC;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;KAAE,GAAG,IAAI,CAAC;IA+BvF;;;OAGG;YACW,aAAa;IAuE3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAY5B;;OAEG;IACG,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO,EAAE,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;;;;;IAkCpG,+BAA+B;IAC/B,MAAM,IAAI,KAAK,EAAE;IAIjB,wBAAwB;IACxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAIlC;;OAEG;IACH,WAAW,IAAI,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAS3F,mCAAmC;IACnC,MAAM,IAAI,IAAI;CAIf"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/skills/registry.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAiC;;IAO/C;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAK3B;;;;;;;;OAQG;IACH,OAAO,CAAC,IAAI;IA6HZ,+BAA+B;IAC/B,MAAM,IAAI,KAAK,EAAE;IAIjB;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAIlC;;OAEG;IACH,WAAW,IAAI,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAS3F,mCAAmC;IACnC,MAAM,IAAI,IAAI;CAIf"}