@skill-graph/cli 0.5.6

package/docs/marketplace-skill-candidate-list.md

@@ -0,0 +1,272 @@
+# Marketplace Skill Candidate List
+
+> Generated 2026-05-13 from local `SKILL.md` files in the Development workspace.
+>
+> Purpose: a public-safe comb list for deciding what to syndicate to `skills.sh`, SkillsMP, or a generated Skill Graph export surface. Row-level private, customer, local-runtime, and personal exposure risks are removed from this report instead of being repeated here.
+
+## Privacy Gate
+
+This report is itself treated as a publication surface. Skills are excluded from row-level listing when they match any of these signals:
+
+- private project or customer application paths
+- local agent profile or runtime paths
+- archived, specimen, or fixture sources that have not been promoted and scrubbed
+- personal names, local user paths, email addresses, or token/API-key-like strings
+- text that names private projects, local repositories, customer workflows, or private operating context
+
+Excluded rows are counted below but not named. Review the local source directly when deciding whether to generalize one into a new public skill. Do not publish an excluded skill until it has been rewritten as a general, portable skill and re-scanned cleanly.
+
+## Legend
+
+| Label | Meaning |
+|---|---|
+| `P0` | Add through the full Skill Graph export. Canonical Skill Metadata Protocol source already exists and passed the privacy gate. |
+| `P1` | Active Development skill that passed the privacy gate, but still needs migration/enrichment to Skill Metadata Protocol and final human public-release review. |
+| `Excluded` | Not listed row-by-row because publishing the name, path, or description could expose private, customer, personal, local-runtime, archived, specimen, or fixture context. |
+
+## Summary
+
+- Total skill files scanned: **568**
+- Public candidate rows after privacy gate: **143**
+- Excluded from public candidate rows: **425**
+- P0 Skill Graph canonical rows: **80**
+- P1 active Development rows: **63**
+- Legacy/plain frontmatter among public candidates: **63**
+- Public candidate descriptions over the base Agent Skills 1024-character limit: **10**
+- Duplicate names across public candidates: **13**
+
+### Source Counts
+
+| Source | Scanned | Public candidate rows | Excluded rows |
+|---|---:|---:|---:|
+| Skill Graph canonical | 80 | 80 | 0 |
+| Development active | 276 | 63 | 213 |
+| Private project/customer app | 159 | 0 | 159 |
+| Local agent profile | 10 | 0 | 10 |
+| Archived | 37 | 0 | 37 |
+| Skill Graph example/fixture | 6 | 0 | 6 |
+
+### Exclusion Counts
+
+| Privacy or publication risk signal | Count |
+|---|---:|
+| names a private project or local repo | 377 |
+| private project/customer application path | 159 |
+| archived source path | 37 |
+| personal name or local user path | 31 |
+| email address | 22 |
+| local agent profile path | 10 |
+| example or fixture source path | 6 |
+| token/API-key-like string | 2 |
+
+## Immediate Read
+
+- Publish the **P0 Skill Graph canonical library** as the first full-library syndication surface. These rows are already v3 protocol skills and have a working `skill-md` export path.
+- Treat **P1 Development active skills** as a migration queue. They passed the automated privacy gate, but most use legacy/plain frontmatter and still need Skill Metadata Protocol enrichment plus human public-release review.
+- Treat excluded skills as private source material only. Generalize useful ideas into new public skills instead of publishing private or customer-grounded source directly.
+- Do not publish from this report by copying rows manually. Generate exports from vetted source and run verification.
+
+## 2026-05-14 Migration Follow-up
+
+The original counts above are the 2026-05-13 candidate snapshot. A follow-up migration on 2026-05-14 imported 22 unique P1 rows into canonical Skill Graph source after full-body privacy screening and schema_version 4 frontmatter conversion:
+
+`background-jobs`, `command-palette`, `compression`, `content-monitor`, `cron-scheduling`, `diff-analysis`, `entity-relationship-modeling`, `evaluation`, `governance`, `guardrails`, `keywords`, `merge-queue`, `methodology`, `mobile-responsive-ux`, `ontology`, `prioritization`, `real-time-updates`, `reasoning`, `seo-strategy`, `spec-driven-development`, `summarization`, `vercel-composition-patterns`.
+
+Thirteen P1 rows remain rejected as duplicates because canonical Skill Graph skills already own those names: `agent-engineering`, `conceptual-modeling`, `context-management`, `context-window`, `design-thinking`, `diagnosis`, `intent-recognition`, `knowledge-modeling`, `problem-locating-solving`, `prompt-craft`, `semantic-center`, `semantic-relations`, `tool-call-strategy`.
+
+Twenty-eight unique P1 rows remain deferred because their full bodies still contain local agent-profile paths or private project names and must be rewritten as general public skills before publication. One private-named row is withheld from row-level public documentation: `agent-session-handoff`, `agent-task-delegation`, `autonomous-loop-patterns`, `chat-interface`, `cost-aggregation`, `dispatch-loop`, `ghostty`, `git-worktree`, `harness-engineering`, `hook-patterns`, `methodical`, `orchestration`, `perspective`, `quality-doctrine`, `self-evaluation`, `sequential-thinking`, `session-lifecycle`, `streaming`, `task-lifecycle`, `task-path-optimization`, `task-progression`, `task-sizing`, `threaded-conversations`, `token-cost-estimation-findings`, `token-efficiency`, `tui`, `vibe-kanban`.
+
+## Strict Description Review
+
+These public candidate rows exceed the base Agent Skills `description` limit and need export-specific shorter descriptions if a marketplace enforces that limit. Keep the canonical richer source.
+
+| Skill | Description length | Source | Path |
+|---|---:|---|---|
+| `context-graph` | 1597 | Skill Graph canonical | `skills/context-graph/SKILL.md` |
+| `knowledge-modeling` | 1592 | Skill Graph canonical | `skills/knowledge-modeling/SKILL.md` |
+| `context-window` | 1352 | Skill Graph canonical | `skills/context-window/SKILL.md` |
+| `context-management` | 1322 | Skill Graph canonical | `skills/context-management/SKILL.md` |
+| `problem-locating-solving` | 1130 | Skill Graph canonical | `skills/problem-locating-solving/SKILL.md` |
+| `semantic-relations` | 1113 | Skill Graph canonical | `skills/semantic-relations/SKILL.md` |
+| `error-tracking` | 1045 | Skill Graph canonical | `skills/error-tracking/SKILL.md` |
+| `conceptual-modeling` | 1044 | Skill Graph canonical | `skills/conceptual-modeling/SKILL.md` |
+| `pattern-recognition` | 1041 | Skill Graph canonical | `skills/pattern-recognition/SKILL.md` |
+| `orchestration` | 1031 | Development active | `skills/orchestration/SKILL.md` |
+
+## Duplicate Names Across Public Candidates
+
+Duplicate names here are public candidate collisions only. Private/excluded rows are not included in this table.
+
+| Name | Count |
+|---|---:|
+| `agent-engineering` | 2 |
+| `conceptual-modeling` | 2 |
+| `context-management` | 2 |
+| `context-window` | 2 |
+| `design-thinking` | 2 |
+| `diagnosis` | 2 |
+| `intent-recognition` | 2 |
+| `knowledge-modeling` | 2 |
+| `problem-locating-solving` | 2 |
+| `prompt-craft` | 2 |
+| `semantic-center` | 2 |
+| `semantic-relations` | 2 |
+| `tool-call-strategy` | 2 |
+
+## P0 - Skill Graph canonical skills: add through the full Skill Graph export
+
+| Review | Skill | Fit | Action | Type / Scope | Description | Notes | Path |
+|---|---|---|---|---|---|---|---|
+| [ ] | `a11y` | strong-public | Add via full Skill Graph export | capability / portable | Use when building or reviewing interactive UI, forms, navigation, or dynamic content. Covers semantic HTML, keyboard access, focus management, labeling, state-change announcement, and reduced-motion / high-contrast preferences. Do NOT use for color-palette creation, visual branding, feedback-state staging, or prose reading-level accessibility - those belong to `visual-design-foundations`, `interaction-feedback`, and documentation respectively. | - | `skills/a11y/SKILL.md` |
+| [ ] | `agent-engineering` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or evaluating a production AI agent system, choosing a multi-agent coordination pattern (orchestrator/worker, fan-out, consensus, sequential chain, evaluator/optimizer), diagnosing coordination failures (claim races, silent stalls, context contamination, runaway loops), or auditing whether an agent loop is truly production-ready. Covers the four pillars (architecture and lifecycle, task decomposition, coordination patterns, production reliability), the six reliability requirements (observability, cost budgets, idempotency, failure recovery, safety caps, claim locks), the delegation decision framework with overhead crossover, and the most common anti-patterns. Do NOT use for prompt wording (use `prompt-craft`), per-call tool efficiency (use `tool-call-strategy`), context-stack design within a single agent (use `context-engineering`), or runtime debugging of a deployed system (use `debugging`). | duplicate name across public candidates (2 copies) | `skills/agent-engineering/SKILL.md` |
+| [ ] | `agent-eval-design` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing evaluations for AI agents, skills, routers, prompts, tool-use policies, or multi-step workflows: task sets, rubrics, graders, hard negatives, regression cases, traces, and acceptance thresholds. Do NOT use for application test planning (use `testing-strategy`), skill-library health tooling (use `skill-infrastructure`), or live debugging of a failed run (use `debugging`). | - | `skills/agent-eval-design/SKILL.md` |
+| [ ] | `ai-native-development` | strong-public | Add via full Skill Graph export | capability / portable | Use when reasoning about agent autonomy levels, designing auto-improve loops, evaluating AI-generated code quality, or measuring agent productivity in an LLM-assisted codebase. Covers Karpathy's three eras of software (1.0 explicit / 2.0 learned / 3.0 natural-language), the vibe-coding-vs-agentic-engineering distinction, the 0–5 autonomy slider with task-type recommendations, the one-asset / one-metric / one-time-box AutoResearch loop, Software 3.0 productivity metrics, and the documented quality regressions of ungated AI-generated code (the 'vibe hangover'). Do NOT use for choosing a specific autonomy-loop topology (use `agent-engineering`), for the per-prompt authoring discipline (use `prompt-craft`), or for reviewing the AI-generated code that comes out of a Software 3.0 workflow (use `code-review`). | - | `skills/ai-native-development/SKILL.md` |
+| [ ] | `api-design` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or reviewing API surfaces: resources/actions, request and response schemas, status codes, pagination, filtering, idempotency, versioning, auth boundaries, and error envelopes. Do NOT use for non-HTTP system contracts (use `system-interface-contracts`), async event contracts (use `event-contract-design`), database design (use `data-modeling`), or inbound provider webhook mechanics (use `webhook-integration`). | - | `skills/api-design/SKILL.md` |
+| [ ] | `architecture-decision-records` | strong-public | Add via full Skill Graph export | capability / portable | Use when writing, reviewing, or updating Architecture Decision Records: context, decision, options rejected, consequences, status, supersession, and follow-up verification. Do NOT use for general documentation prose (use `documentation`), code review findings (use `code-review`), or choosing between frameworks before a decision exists (use `framework-fit-analysis`). | - | `skills/architecture-decision-records/SKILL.md` |
+| [ ] | `bounded-context-mapping` | strong-public | Add via full Skill Graph export | capability / portable | Use when drawing Domain-Driven Design boundaries: bounded contexts, context maps, ownership seams, upstream/downstream relationships, anti-corruption layers, shared kernels, and translation boundaries. Do NOT use for pre-DDD entity discovery (use `conceptual-modeling`), database schema design (use `data-modeling`), or HTTP endpoint design (use `api-design`). | - | `skills/bounded-context-mapping/SKILL.md` |
+| [ ] | `code-review` | strong-public | Add via full Skill Graph export | workflow / portable | Use when reviewing a pull request, diff, or proposed code change for correctness, clarity, security, performance, and conformance to project conventions — whether the author is a human, an AI agent, or a peer. Covers the pre-review fact-gathering pass, the read-order strategy (tests first, then implementation, then call sites), the severity-grading rubric, the comment-phrasing discipline, and the no-rubber-stamp rule for AI-generated diffs. Do NOT use for AUTHORING the code (use `refactor` for behaviour-preserving changes or `skill-scaffold` for new skills), for chasing a known bug after merge (use `debugging`), or for security-only audits (use `owasp-security` for vulnerability-focused review). | - | `skills/code-review/SKILL.md` |
+| [ ] | `color-system-design` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing a color system — palette construction, semantic color tokens, WCAG contrast ratios, perceptual uniformity in OKLCH/LCH, and light/dark mode parity. Do NOT use for single brand-color picks, runtime theme-switching mechanics, or non-color design tokens. | - | `skills/color-system-design/SKILL.md` |
+| [ ] | `conceptual-modeling` | strong-public | Add via full Skill Graph export | capability / portable | Use when translating business requirements into a structured domain representation, designing a new feature from scratch, or validating that a system's structure matches business reality — before any database schema, API endpoint, or aggregate boundary is named. Covers entity / attribute / relationship identification, cardinality (1:1, 1:N, M:N, 0..1, 1..*), generalization vs specialization (disjoint / overlapping, total / partial), aggregation vs composition, role modeling, the conceptual → logical → physical abstraction ladder, validation against business stakeholders' mental models, and the seven anti-patterns (implementation leakage, missing entity, god entity, phantom relationship, premature normalization, attribute-as-entity, unnamed relationship). Do NOT use for database-specific ER diagrams with PK / FK / normalization (use a logical-modeling skill), formal ontology axioms with OWL or RDFS (use an ontology skill), or DDD tactical design (aggregates, bounded contexts) — conceptual modeling stays one layer above all three. | description 1044 chars (>1024); duplicate name across public candidates (2 copies) | `skills/conceptual-modeling/SKILL.md` |
+| [ ] | `constraint-awareness` | strong-public | Add via full Skill Graph export | capability / portable | Use when prioritizing work in an AI-assisted codebase, designing agent autonomy levels, deciding what to automate vs keep manual, or evaluating whether a process/tool adds value. Covers Theory of Constraints for AI-era engineering: cheap code production, human review/validation/decision bottlenecks, Five Focusing Steps, constraint-aware process design, attention audits, and constraint-shift modeling. Do NOT use for task-effort estimation, backlog scoring with RICE/WSJF/ICE, or routing a task to a specific model. | - | `skills/constraint-awareness/SKILL.md` |
+| [ ] | `context-engineering` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing what information reaches an LLM agent before it reasons — system prompt, persistent memory, always-loaded rules, injected skills, and the user prompt — or when diagnosing why an agent produced a wrong answer despite a clear instruction. Covers the four context failure modes (missing, stale, wrong, overwhelming), the five-layer context stack, four context quality metrics (injection precision and recall, utilization, freshness), the Frequent Intentional Compaction (FIC) protocol, subagent delegation for context-heavy work, and the failure-mode decision tree. Do NOT use for prompt wording (use `prompt-craft`), authoring a new SKILL.md (use `skill-scaffold`), or deciding which skill the router activates for a given query (use `skill-router`). | - | `skills/context-engineering/SKILL.md` |
+| [ ] | `context-graph` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing the multi-graph context architecture of an AI-coding workspace, when analyzing change-propagation impact across skills / docs / memory / scripts, when measuring graph connectivity health (orphan rate, average degree, hub-spoke ratio, cluster count), when classifying the edge types between skills, or when building a discovery layer that lets agents find context they did not already know existed. Covers the four interconnected graphs every mature AI-coding workspace ends up with — Skill Knowledge Graph, Document Routing Graph, Memory Index, Script / Command Registry — plus the cross-graph edges that connect them; orphan detection and remediation priorities; the deterministic-signal recipe for graph synthesis (explicit prose references, manual relations frontmatter, bundle co-membership, shared routing labels, keyword overlap); the three skill-edge types (adjacent, boundary, verify_with) and their per-edge-type caps; the change-propagation checklist that traces a single edit across all four graphs; and the anti-patterns that produce hub-and-spoke topology, drift, or silent orphan accumulation. Do NOT use for authoring or editing individual SKILL.md content (use `skill-scaffold` for authoring and `skill-infrastructure` for maintenance), for validating one skill against the schema (use `graph-audit`), for the live routing-decision step (use `skill-router`), for context-budget allocation inside a single agent session (that is a context-window concern), or for the design-phase 'what should I load for this task' decision (that is a context-management concern). | description 1597 chars (>1024) | `skills/context-graph/SKILL.md` |
+| [ ] | `context-management` | strong-public | Add via full Skill Graph export | capability / portable | Use when deciding what to load into an agent session, recovering from context drift, preparing a clean compaction or session restart, distilling raw inputs (logs, full files, long threads) into a small working summary, or writing a handoff that another agent can resume in under thirty seconds. Covers the working discipline that controls what enters, stays in, and exits an active context window — intake triage with the four-bucket classification (must-have / useful soon / durable background / noise), the six-step context-management loop (state the active question / name the minimum evidence / load cheapest sources first / collapse confirmed facts / drop disproven assumptions / re-check the question), working-set shaping with the distillation pattern (raw 300-line log → 2-line summary; whole file → function + slice + invariant), drift detection signals and anti-drift rules (one active hypothesis, one question, one verification target), the compaction-ready handoff format, and the selective-rebuild recipe for recovering after the thread is lost. Do NOT use for context-window token math (that is a budget skill), prompt wording or template authoring (use `prompt-craft`), persistent cross-session memory curation (a memory-curation skill), or the multi-graph context architecture itself (use `context-graph`). | description 1322 chars (>1024); duplicate name across public candidates (2 copies) | `skills/context-management/SKILL.md` |
+| [ ] | `context-window` | strong-public | Add via full Skill Graph export | capability / portable | Use when allocating context-window budget across the system / skill-injection / working zones, monitoring context health (ok / compact / exhausted), deciding when to compact a session, preserving state through a pre-compact hook so work is not lost, recovering after a compaction, or selecting model-class strategies for 1M / 200K / 128K context windows. Covers the three-zone budget model and per-model practical-budget table; the 80% compaction rule with the 20% safety margin (for completing the current operation, writing the checkpoint, running the closeout protocol, emitting the continuation signal); pre- and post-compact protocols including hook responsibilities and the cross-session persistence hierarchy (git > files-on-disk > durable memory > live context); per-operation token-consumption ranges; the five token-reduction techniques (deterministic-CLI over MCP / heavy-tool, targeted reads with offset+limit, search-before-read, progressive skill disclosure, count-mode for exploration); and the anti-patterns that exhaust the window mid-task. Do NOT use for deciding *what* context to load or drop in the working set (use `context-management`), for designing the prompt itself (use `prompt-craft`), for the multi-graph context architecture (use `context-graph`), or for cross-session persistent memory curation (a memory-curation skill). | description 1352 chars (>1024); duplicate name across public candidates (2 copies) | `skills/context-window/SKILL.md` |
+| [ ] | `dark-mode-implementation` | strong-public | Add via full Skill Graph export | capability / portable | Use when implementing dark mode — prefers-color-scheme detection, theme persistence, flash-of-unstyled-theme prevention, color token mirroring, image and asset variants, and meta theme-color updates. Do NOT use for designing the dark palette itself, designing the token architecture, or generic theme-switching across more than two themes. | - | `skills/dark-mode-implementation/SKILL.md` |
+| [ ] | `data-modeling` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing logical or physical data structures: entities as stored data, keys, constraints, normalization, denormalization, provenance, lifecycle, indexing implications, and schema tradeoffs. Do NOT use for pre-implementation business concept discovery (use `conceptual-modeling`), migrations against an existing database (use `database-migration`), or formal ontology semantics (use `ontology-modeling`). | - | `skills/data-modeling/SKILL.md` |
+| [ ] | `database-migration` | strong-public | Add via full Skill Graph export | capability / portable | Use when planning or applying a raw-SQL database migration to a live PostgreSQL database — adding columns, renaming columns or tables, changing types, creating indexes, adding foreign keys, or running data backfills. Covers zero-downtime patterns (expand / contract, batched backfill, NOT VALID foreign keys, CONCURRENTLY indexes), the unpooled-connection requirement for DDL, branched-database workflows, and rollback strategy. Do NOT use for ORM-managed migrations driven by Prisma/Drizzle/TypeORM CLI scaffolding (the generation rules are tool-specific), for chasing a migration that has already failed in production (use `debugging`), or for designing the row-level-security model itself (use `owasp-security`). | - | `skills/database-migration/SKILL.md` |
+| [ ] | `debugging` | strong-public | Add via full Skill Graph export | workflow / portable | Use when behavior is broken, a test is failing, or runtime output contradicts expectations. Covers failure reproduction, scope reduction by bisection, evidence capture at the moment of failure, root-cause isolation (not symptom patching), fix verification against the same evidence path, and regression-test creation. Do NOT use for feature planning, architectural design, or behavior-preserving refactor. | - | `skills/debugging/SKILL.md` |
+| [ ] | `dependency-architecture` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or auditing dependency structure: package boundaries, runtime vs build dependencies, adapter layers, duplicate-purpose libraries, supply-chain risk, upgrade policy, lock-in, and dependency graph health. Do NOT use for choosing a major framework (use `framework-fit-analysis`), vulnerability-only review (use `owasp-security`), or routine refactoring without dependency boundary changes (use `refactor`). | - | `skills/dependency-architecture/SKILL.md` |
+| [ ] | `design-module-composition` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing reusable component modules — composition patterns, compound components, slot/children APIs, render props, headless component contracts, and the choice between configuration and composition. Do NOT use for application-level architecture, single-use feature components, or visual styling decisions. | - | `skills/design-module-composition/SKILL.md` |
+| [ ] | `design-system-architecture` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or auditing a design system's architecture: token taxonomy, semantic tokens, component APIs, theming, accessibility contracts, documentation, governance, and migration strategy. Do NOT use for information hierarchy and navigation (use `information-architecture`), page-specific layout (use `layout-composition`), visual craft direction (use `visual-design-foundations`), sentence-level UI copy (use `microcopy`), or accessibility-only audits (use `a11y`). | - | `skills/design-system-architecture/SKILL.md` |
+| [ ] | `design-thinking` | strong-public | Add via full Skill Graph export | capability / portable | Use when orchestrating a full human-centered design process across discovery, definition, ideation, prototyping, and testing — when uncertain which stage of the arc a team is in, when deciding whether to loop back, or when routing to the right stage-specific sibling skill. Do NOT use for single-stage execution (go directly to problem-framing, user-research, research-synthesis, journey-mapping, ideation, prototyping, or usability-testing) or for engineering domain discovery (use event-storming). | duplicate name across public candidates (2 copies) | `skills/design-thinking/SKILL.md` |
+| [ ] | `diagnosis` | strong-public | Add via full Skill Graph export | capability / portable | Use when facing an unknown software failure, when symptoms point to different root causes, or when an initial debugging attempt has not converged. Provides a triage-first diagnostic routing framework: classify the failure, collect the right evidence, choose a technique, track confidence, and escalate when stuck. Do NOT use for executing scientific debugging after triage (use `debugging`), code-quality review (use `code-review`), or proactive observability setup. | duplicate name across public candidates (2 copies) | `skills/diagnosis/SKILL.md` |
+| [ ] | `documentation` | strong-public | Add via full Skill Graph export | capability / portable | Use when writing reference docs, guides, tutorials, specs, architecture notes, or any durable technical prose that a future reader has to trust. Covers doc-type selection, audience fit, progressive disclosure, docs-as-code workflow, freshness and drift tracking, and source-of-truth discipline. Do NOT use for runtime debugging, UI accessibility behavior, or behavior-preserving code refactor. | - | `skills/documentation/SKILL.md` |
+| [ ] | `error-tracking` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or extending the exception-reporting pipeline for an application — choosing where error boundaries live (component, section, route, app-global), wrapping the tracker SDK so every reporting call is sanitized and environment-gated, attaching user context without leaking PII, and verifying that every layer's errors actually reach the tracker. Covers the four-surface error-capture model (component boundaries, route fallbacks, global crash handler, manual API), centralized wrapper design (`reportError` / `reportMessage` / `addBreadcrumb` / `setUser`), PII sanitization before any external send, environment-aware gating (dev → local logger, prod → tracker SDK), and the diagnostic question 'does this layer actually report, or does it only log?' Do NOT use for the *visual* error UX seen by the user (use `a11y` for accessible error messages and recovery flows), for chasing a single observed error already captured in the tracker (use `debugging`), or for the broader privacy and PII-retention policy (use `owasp-security`). | description 1045 chars (>1024) | `skills/error-tracking/SKILL.md` |
+| [ ] | `event-contract-design` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or reviewing asynchronous event contracts: producer/consumer ownership, event envelope, schema, topic/channel naming, ordering, idempotency, versioning, compatibility, replay, dead-letter behavior, and AsyncAPI/CloudEvents-style documentation. Do NOT use for domain-event discovery (use `event-storming`), broad interface contracts (use `system-interface-contracts`), inbound provider webhook mechanics (use `webhook-integration`), or HTTP endpoint design (use `api-design`). | - | `skills/event-contract-design/SKILL.md` |
+| [ ] | `event-storming` | strong-public | Add via full Skill Graph export | capability / portable | Use when discovering a domain through events, commands, actors, policies, aggregates, read models, external systems, and temporal workflows before implementation. Do NOT use for event schema/topic contracts (use `event-contract-design`), webhook handler implementation (use `webhook-integration`), generic state transition modeling (use `state-machine-modeling`), or persistence schema design (use `data-modeling`). | - | `skills/event-storming/SKILL.md` |
+| [ ] | `form-ux-architecture` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or auditing form structure and validation UX: field grouping, required vs optional inputs, validation timing, client/server validation split, submission lifecycle, recovery, multi-step forms, and high-risk data entry. Do NOT use for labels and announcements alone (use `a11y`), validation-message wording (use `microcopy`), API schema design (use `api-design`), or stored data modeling (use `data-modeling`). | - | `skills/form-ux-architecture/SKILL.md` |
+| [ ] | `framework-fit-analysis` | strong-public | Add via full Skill Graph export | capability / portable | Use when choosing, replacing, or justifying a framework, library, SDK, runtime, database, UI kit, or platform by fit: constraints, team skill, ecosystem maturity, migration cost, operability, performance, security, and exit cost. Do NOT use for routine dependency hygiene (use `dependency-architecture`), documenting an accepted decision (use `architecture-decision-records`), or framework-specific implementation work. | - | `skills/framework-fit-analysis/SKILL.md` |
+| [ ] | `frontend-architecture` | strong-public | Add via full Skill Graph export | capability / portable | Use when organizing a frontend codebase — module boundaries, component layering, state ownership, data-flow direction, and the separation between feature code and shared primitives. Do NOT use for visual design decisions, specific framework migration tactics, or backend API contract design. | - | `skills/frontend-architecture/SKILL.md` |
+| [ ] | `graph-audit` | strong-public | Add via full Skill Graph export | capability / codebase | Use when checking that every SKILL.md conforms to the schema, that manifest entries match authored frontmatter, or that relation targets point at real sibling skills. Covers schema conformance, manifest sync, relation integrity, eval-artifact coherence, grounding presence, and name-directory parity. Do NOT use for general code review, runtime agent debugging, or auditing non-skill files. | - | `skills/graph-audit/SKILL.md` |
+| [ ] | `ideation` | strong-public | Add via full Skill Graph export | capability / portable | Use when generating a wide range of solution concepts before converging on a direction, running structured idea-generation sessions, breaking out of solution fixation, or moving from divergent to convergent selection with explicit criteria. Do NOT use for collaborative engineering domain discovery (event-storming), solo deep technical design, or making final go/no-go investment decisions — those require different methods. | - | `skills/ideation/SKILL.md` |
+| [ ] | `information-architecture` | strong-public | Add via full Skill Graph export | capability / portable | Use when structuring information for findability: navigation, page hierarchy, docs architecture, sitemap shape, labeling systems, wayfinding, and content grouping. Do NOT use for formal category-governance work (use `taxonomy-design`), responsive page composition (use `layout-composition`), component/token architecture (use `design-system-architecture`), or sentence-level UI text (use `microcopy`). | - | `skills/information-architecture/SKILL.md` |
+| [ ] | `intent-recognition` | strong-public | Add via full Skill Graph export | capability / portable | Use BEFORE any tool call that could modify state, touch sensitive targets, rewrite history, install dependencies, publish packages, or expose credentials/environment data. Classifies intent into Passive/Read, Reconnaissance, Modification, or Destructive/Irreversible using operation type plus target sensitivity, then runs Identify / Confirm / Verify before action. Do NOT use for deciding what code to write, executing already-classified work, reactive post-execution guardrails, or defining upstream governance policy. | duplicate name across public candidates (2 copies) | `skills/intent-recognition/SKILL.md` |
+| [ ] | `interaction-feedback` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing UI feedback around user actions and system state: loading, skeletons, optimistic updates, progress, success, errors, empty states, retries, disabled/pending states, autosave, undo, and perceived latency. Do NOT use for the words inside feedback (use `microcopy`), accessibility announcement mechanics (use `a11y`), business lifecycle modeling (use `state-machine-modeling`), or performance optimization (use `performance-engineering`). | - | `skills/interaction-feedback/SKILL.md` |
+| [ ] | `interaction-patterns` | strong-public | Add via full Skill Graph export | capability / portable | Use when choosing or auditing UI interaction patterns and controls: tabs vs pages, dropdown vs combobox, stepper vs wizard, modal vs inline edit, disclosure, command menus, selection, filtering, and gesture alternatives. Do NOT use for accessibility compliance (use `a11y`), task decomposition (use `task-analysis`), feedback-state staging (use `interaction-feedback`), or reusable component API design (use `design-system-architecture`). | - | `skills/interaction-patterns/SKILL.md` |
+| [ ] | `journey-mapping` | strong-public | Add via full Skill Graph export | capability / portable | Use when mapping a user's experience across multiple touchpoints and time, surfacing emotional peaks and troughs, identifying opportunity moments in a cross-channel flow, or aligning a team on the end-to-end experience including back-stage support processes. Do NOT use for decomposing a single screen into UI steps (use task-analysis) or for drawing back-end service architecture diagrams — journey maps describe human experience, not system topology. | - | `skills/journey-mapping/SKILL.md` |
+| [ ] | `knowledge-modeling` | strong-public | Add via full Skill Graph export | capability / portable | Use when deciding *which representation paradigm* fits a piece of domain knowledge — knowledge graph vs frames vs production rules vs semantic network vs concept map vs procedural ontology vs hybrid — when designing AI-agent context systems, building a knowledge base, structuring a skill or reference library, or planning a GraphRAG retrieval pipeline. Covers the seven paradigms with structure / best-for / weakness tables, the tacit-to-explicit knowledge acquisition pipeline (elicitation → articulation → formalization → validation → encoding), knowledge graph design principles (reify when needed, separate schema from instance, label precisely, bidirectional naming, minimal redundancy), the four knowledge-validation types (completeness / consistency / relevance / currency) plus expert walkthrough, the seven-phase knowledge lifecycle (Create / Validate / Publish / Use / Monitor / Update / Retire), the application to AI-agent systems (skills as frames, routing as rules, memory as graph), and a full GraphRAG section covering the five patterns (entity-anchored retrieval, relationship-aware context, path-based reasoning, subgraph summarization, hybrid vector+graph) with rules for when graph-grounded retrieval beats plain RAG. Do NOT use for the *human-readable* domain analysis layer (use `conceptual-modeling`), for the database / ER design layer (a logical-modeling skill), for pure classification hierarchies (a taxonomy skill), for formal ontology axioms (an ontology skill), or for the live skill-library tooling that consumes modeled knowledge (use `skill-infrastructure`). | description 1592 chars (>1024); duplicate name across public candidates (2 copies) | `skills/knowledge-modeling/SKILL.md` |
+| [ ] | `layout-composition` | strong-public | Add via full Skill Graph export | capability / portable | Use when deciding responsive page or screen structure: section order, scan pattern, grid/flex composition, breakpoints, viewport hierarchy, responsive media, and density. Do NOT use for user-goal decomposition (use `task-analysis`), navigation taxonomy (use `information-architecture`), visual polish (use `visual-design-foundations`), or component/token contracts (use `design-system-architecture`). | - | `skills/layout-composition/SKILL.md` |
+| [ ] | `linguistics` | strong-public | Add via full Skill Graph export | capability / portable | Use when choosing names for files/functions/variables/types/columns, writing or reviewing UI copy/error/onboarding text, disambiguating overloaded terms, or matching tone to end-user/agent/developer audiences. Covers morphology, compound-word order, abbreviation policy, verb-noun rules, polysemy resolution, audience register, blame-free error-message structure, and cross-cultural product-copy awareness. Do NOT use for casing conventions (use naming-conventions), doc structure/type selection (use documentation), or call-site-wide renames (use refactor). | - | `skills/linguistics/SKILL.md` |
+| [ ] | `lint-overlay` | strong-public | Add via full Skill Graph export | overlay / portable | Use when adding or enforcing lint rules as part of a test or verification plan. Extends testing-strategy with lint-specific guidance: rule selection, gate placement, failure triage, and migration planning when introducing rules to an existing codebase. Do NOT use standalone — load the base testing-strategy skill alongside it — and do NOT use for chasing a specific lint failure in one file (that is debugging). | - | `skills/lint-overlay/SKILL.md` |
+| [ ] | `microcopy` | strong-public | Add via full Skill Graph export | capability / portable | Use when writing or reviewing functional UI text: button labels, empty states, tooltips, dialogs, placeholders, loading/progress messages, toasts, inline validation, permission copy, or onboarding steps. Covers interface-copy patterns such as verb-first action labels, acknowledge-explain-guide empty states, one-sentence tooltips, consequence-first confirmations, progressive loading language, and blur/fix validation messages. Do NOT use for marketing persuasion, documentation prose/guide structure, feedback-state staging, or general linguistic rationale behind wording. | - | `skills/microcopy/SKILL.md` |
+| [ ] | `naming-conventions` | strong-public | Add via full Skill Graph export | capability / portable | Use when naming a new file, function, variable, type, route, database column, environment variable, or any other code or system artifact. Covers identifier morphology (verb-noun choice, plural vs singular, prefix/suffix conventions), kebab-case vs camelCase vs snake_case vs PascalCase per artifact kind, abbreviation rules, name-vs-path semantics, the rename-coordination workflow, and detection of names that lie. Do NOT use for content writing (use `documentation`), for restructuring already-named code (use `refactor`), or for human-language copy in product UI (separate skill, not in this library). | - | `skills/naming-conventions/SKILL.md` |
+| [ ] | `observability-modeling` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing telemetry semantics before or during implementation: logs, metrics, traces, events, spans, attributes, correlation IDs, SLOs, alert signals, and diagnostic questions. Do NOT use for domain/business event contracts (use `event-contract-design`), configuring an error tracker alone (use `error-tracking`), performance optimization (use `performance-engineering`), or debugging a current incident (use `debugging`). | - | `skills/observability-modeling/SKILL.md` |
+| [ ] | `ontology-modeling` | strong-public | Add via full Skill Graph export | capability / portable | Use when formalizing domain meaning with classes, properties, constraints, RDF/OWL-style semantics, SHACL-like validation shapes, or reasoning-ready axioms. Do NOT use for simple category trees (use `taxonomy-design`), pre-implementation business entity sketches (use `conceptual-modeling`), database schemas (use `data-modeling`), or broad representation choice (use `knowledge-modeling`). | - | `skills/ontology-modeling/SKILL.md` |
+| [ ] | `owasp-security` | strong-public | Add via full Skill Graph export | capability / portable | Use when reviewing code for security vulnerabilities, threat-modelling a new feature, implementing authentication or authorization, handling user input, or auditing a codebase against the OWASP Top 10 (2021). Covers injection (SQL, NoSQL, command, LDAP, XSS), broken access control, cryptographic failures, insecure design, security misconfiguration, vulnerable dependencies, identification and authentication failures, software and data integrity failures, logging and monitoring failures, and server-side request forgery. Do NOT use for general code review (use `code-review` for the holistic per-PR pass), for chasing a known production bug (use `debugging`), or for writing a security policy doc (use `documentation`). | - | `skills/owasp-security/SKILL.md` |
+| [ ] | `pattern-recognition` | strong-public | Add via full Skill Graph export | capability / portable | Use when auditing code for recurring issues, triaging errors by cluster, detecting drift from established conventions, or when an agent keeps fixing symptoms instead of root causes. Covers the six-step recognition loop (Observe → Cluster → Name → Codify → Detect → Prevent), grep-based audit strategies, error-pattern clustering with normalize-then-hash, board-health patterns (stale tasks, WIP overflow, duplicates), design pattern violations (heading hierarchy, token drift, triple-encoding), domain-encoding patterns (null-vs-zero distinction, integer encoding for monetary amounts, magnitude-conversion at the display boundary, source-rank trust hierarchy), the eval-as-pattern-test pipeline, the 5-Whys for root cause vs symptom analysis, pattern lifecycle states, and six named drift traps. Do NOT use for one-off bug localization without recurrence — fix the bug and move on — or for designing the classification system itself; this skill detects violations of conventions that already exist, while taxonomy design defines the system. | description 1041 chars (>1024) | `skills/pattern-recognition/SKILL.md` |
+| [ ] | `performance-engineering` | strong-public | Add via full Skill Graph export | capability / portable | Use when measuring, diagnosing, budgeting, or improving performance: latency, throughput, Core Web Vitals, database queries, caching, bundle size, concurrency, resource use, and regression prevention. Do NOT use for telemetry schema design alone (use `observability-modeling`), error capture setup (use `error-tracking`), or premature micro-optimization without a measured bottleneck. | - | `skills/performance-engineering/SKILL.md` |
+| [ ] | `printify` | strong-public | Add via full Skill Graph export | capability / portable | Use when working with Printify — the print-on-demand REST API, catalog model (blueprints, print providers, variants, print areas), product creation and publish lifecycle to connected channels, order routing, shipping cost queries, and HMAC SHA-256 webhook verification. Do NOT use for non-Printify POD vendors, generic Shopify storefront work, or print-file (artwork) generation. | - | `skills/printify/SKILL.md` |
+| [ ] | `problem-framing` | strong-public | Add via full Skill Graph export | capability / portable | Use when a team is converging on solutions before agreeing on the problem, when a brief reads as a feature request, when symptoms and root needs are tangled, or when assumptions need surfacing before design work proceeds. Do NOT use for code-level bug triage, runtime failure diagnosis, or root-cause analysis of system errors — those are engineering investigation tasks, not design problem framing. | - | `skills/problem-framing/SKILL.md` |
+| [ ] | `problem-locating-solving` | strong-public | Add via full Skill Graph export | workflow / portable | Use when you need to locate a bug in an unfamiliar codebase, trace a failure from symptom to source, or choose between multiple candidate fixes after the symptom is observed but before any patch is committed. Provides the locate-to-solve workflow: problem-statement contract, search-space reduction by symptom type, boundary-based fault localization (entry-point tracing, differential good-vs-bad-path comparison, binary search through the call chain, minimal repro), root-cause isolation (symptom vs cause analysis), multi-option fix generation with blast-radius comparison, post-fix verification gates (reproduce the failure before, confirm it no longer occurs after, neighbor-path side-effect check, blast-radius check, explanation check), and reflection that promotes one-off fixes into prevention mechanisms when the class could recur. Do NOT use for broad task planning and sequencing once the bug is already localized, for designing the test pyramid or regression suite that locks in absence of a bug class, or for performance forensics — those need test-strategy or measurement-first methodologies, not fault localization. | description 1130 chars (>1024); duplicate name across public candidates (2 copies) | `skills/problem-locating-solving/SKILL.md` |
+| [ ] | `project-knowledge-extraction` | strong-public | Add via full Skill Graph export | capability / portable | Use when extracting durable project knowledge from code, docs, issues, incidents, reports, screenshots, or conversations into reusable context such as skills, ADRs, glossaries, context docs, or memory. Do NOT use for writing a new skill contract (use `skill-scaffold`), maintaining library tooling (use `skill-infrastructure`), or generic documentation polish (use `documentation`). | - | `skills/project-knowledge-extraction/SKILL.md` |
+| [ ] | `prompt-craft` | strong-public | Add via full Skill Graph export | capability / portable | Use when writing, structuring, evaluating, or improving a prompt for an LLM — whether for one-shot completion, agent dispatch, sub-agent spawning, eval grading, or prompt-engineered tools. Covers role and instruction layering, context insertion order, few-shot example selection, output-format constraints, the negative-instruction principle, defence against adversarial input, and iterative prompt-improvement evaluation. Do NOT use when the task is reviewing AI-generated code (use `code-review`), authoring a SKILL.md (use `skill-scaffold`), or selecting which agent to dispatch (use `skill-router` for cross-skill dispatch decisions). | duplicate name across public candidates (2 copies) | `skills/prompt-craft/SKILL.md` |
+| [ ] | `prototyping` | strong-public | Add via full Skill Graph export | capability / portable | Use when building an artifact whose purpose is to answer a specific question — paper sketch, wireframe, clickable mockup, wizard-of-oz, role-play, service prototype, or code spike — at the lowest fidelity sufficient to produce that learning. Do NOT use for production-grade component construction, design-system contribution, or building the actual ship-ready feature — those are design-module-composition and engineering implementation. | - | `skills/prototyping/SKILL.md` |
+| [ ] | `refactor` | strong-public | Add via full Skill Graph export | workflow / portable | Use when reorganizing existing code without changing external behavior — extracting functions, reducing duplication, renaming for clarity, splitting modules, or tightening structure. Covers behavior preservation, duplication reduction, decomposition, naming improvements, structural reorganization, and before/after verification. Do NOT use for bug investigation, adding new product behavior, or writing documentation (even when the docs describe the refactored code). | - | `skills/refactor/SKILL.md` |
+| [ ] | `research-synthesis` | strong-public | Add via full Skill Graph export | capability / portable | Use when turning raw qualitative research output (interview transcripts, field notes, diary entries, observation logs) into themes, patterns, insight statements, and design-ready artifacts via affinity mapping, empathy maps, and jobs-to-be-done framing. Do NOT use for collecting new research, quantitative analysis, statistical inference, or summarizing a single document — synthesis specifically operates on a corpus of qualitative evidence. | - | `skills/research-synthesis/SKILL.md` |
+| [ ] | `semantic-center` | strong-public | Add via full Skill Graph export | workflow / portable | Use when you need to explain how parts of a system, feature, concept, page, workflow, or problem connect; identify the single most important part of something; untangle dense dependencies into a core plus typed relations; or answer 'what is the load-bearing part?' without drifting into implementation or task prioritization. Provides a five-step workflow — classify the unit of analysis, find the single primary part using removal/governance/purpose/weight/decision tests, map secondary parts via typed relations (dependency, input/output, parent/child, owner/owned, cause/effect, constraint/enabler, and others), produce a structured output, and reduce the whole to one final sentence — that forces explanation through one-primary reduction rather than flat lists or chronology. Do NOT use for implementation work (use the relevant domain skill), choosing what to do next (use a prioritization skill), or formal architectural-ownership design (use a domain-modeling skill). | duplicate name across public candidates (2 copies) | `skills/semantic-center/SKILL.md` |
+| [ ] | `semantic-relations` | strong-public | Add via full Skill Graph export | capability / portable | Use when typing edges in a knowledge graph or concept map; resolving synonym, antonym, polysemy, or homonym confusion in naming; testing whether a connection is IS-A, PART-OF, causal, thematic, or merely vague; explaining the difference between two adjacent concepts or skills; or auditing whether hierarchy, graph, or naming decisions rest on the wrong relation type. Covers taxonomic relations (hypernymy/hyponymy, holonymy/meronymy with the substitution test), associative relations (synonymy, antonymy, polysemy, homonymy, metonymy), thematic relations (agent, patient, instrument, location, source, goal, cause, result, beneficiary), relation properties (symmetry, asymmetry, transitivity, reflexivity, irreflexivity), and the application of all of the above to knowledge-graph edge typing, naming disambiguation, and skill-boundary analysis. Do NOT use for formal ontology axioms with reasoning constraints (use an ontology skill), database foreign-key and junction-table design (use an entity-relationship-modeling skill), or operational data correspondence across systems (use a relational-mapping skill). | description 1113 chars (>1024); duplicate name across public candidates (2 copies) | `skills/semantic-relations/SKILL.md` |
+| [ ] | `semantics` | strong-public | Add via full Skill Graph export | capability / portable | Use when naming artifacts across code, APIs, design tokens, commits, HTTP/status signals, UI labels, error codes, or branded types, especially when a name feels ambiguous or misleading. Covers cross-domain meaning-encoding: naming smells, DDD ubiquitous language, SemVer, conventional commits, branded types, semantic design tokens/CSS/APIs, semantic UI affordances, and naming anti-patterns. Do NOT use for word morphology/polysemy (use linguistics), casing formats (use naming-conventions), typed concept relations (use semantic-relations), or in-product UI-text patterns (use microcopy). | - | `skills/semantics/SKILL.md` |
+| [ ] | `semiotics` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or auditing icon systems, colors/badges/shapes, visual metaphors, interface signs, or naming-plus-visual surfaces that users misread. Covers semiotic reasoning across icon/index/symbol, signifier/signified, denotation/connotation/myth, color/shape/position/iconography, affordances, code/API signifiers, and semiotic-coherence audits. Do NOT use for actual UI wording (use `microcopy`), palette/typography craft (use `visual-design-foundations`), accessibility or contrast compliance (use `a11y`), formal class hierarchies, or word morphology rules. | - | `skills/semiotics/SKILL.md` |
+| [ ] | `shopify` | strong-public | Add via full Skill Graph export | capability / portable | Use when working with Shopify — Admin API, Storefront API, OAuth scopes, HMAC SHA-256 webhook verification, GraphQL query-cost handling, Online Store 2.0 themes (sections, blocks, Liquid), metafields and metaobjects, and App Proxy. Do NOT use for generic e-commerce design, non-Shopify storefronts, or internal event-contract design. | - | `skills/shopify/SKILL.md` |
+| [ ] | `skill-infrastructure` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing the deterministic health-tooling layer for a skill library, diagnosing why an existing library is decaying invisibly, deciding which categories of automated check to add (inventory, protocol consistency, conflict detection, routing health, drift sentinel), debugging eval-threshold violations across many skills at once, or auditing whether a skill-system has the safety nets a production library needs. Covers the five categories of skill-health tooling, the library-as-database mental model, eval quality patterns (minimum thresholds, contradiction-check pattern, negative-expectation requirement), maintenance workflows triggered by batch skill changes, and the anti-patterns that cause skill libraries to decay until agents loading them get worse over time. Do NOT use for authoring an individual SKILL.md (use `skill-scaffold`), for running the conformance audit on the Skill Graph repo itself (use `graph-audit`), or for general lint rule selection across a codebase (use `lint-overlay`). | - | `skills/skill-infrastructure/SKILL.md` |
+| [ ] | `skill-router` | strong-public | Add via full Skill Graph export | router / portable | Use when routing an agent request across multiple skills, building or auditing a routing table, detecting routing coverage gaps, or answering questions like 'which skill handles this?', 'who routes X?', or 'why did skill A activate instead of B?'. Covers trigger-label matching, file-path matching, keyword matching, description-based semantic matching, scope/type tiebreakers, and coverage-gap detection. Do NOT use when the target skill is already known (load it directly), when authoring a new skill (use `skill-metadata-template` instead), or when evaluating a SINGLE skill's quality (use `graph-audit`). | - | `skills/skill-router/SKILL.md` |
+| [ ] | `skill-scaffold` | strong-public | Add via full Skill Graph export | capability / reference | Use when creating a new SKILL.md from scratch, adapting an existing skill to a different archetype, or teaching another author the canonical Skill Metadata Protocol frontmatter and body structure. Covers schema-conformant frontmatter, archetype-aware body layout, semantic-layer discipline (description vs Coverage), teaching-layer mechanics (TEMPLATE NOTE blockquotes), the lint-first authoring gate, and the routing-eval honesty rule. Do NOT use when modifying an already-written skill (edit it directly), when writing general technical documentation (use `documentation`), or when fixing a malformed skill detected by lint (use `graph-audit` for systematic library health, not authoring scaffold help). | - | `skills/skill-scaffold/SKILL.md` |
+| [ ] | `state-machine-modeling` | strong-public | Add via full Skill Graph export | capability / portable | Use when modeling lifecycle states, transitions, guards, events, side effects, invalid states, retries, and state invariants for workflows or domain objects. Do NOT use for broad event discovery (use `event-storming`), database schema design (use `data-modeling`), or observability instrumentation after the lifecycle already exists (use `observability-modeling`). | - | `skills/state-machine-modeling/SKILL.md` |
+| [ ] | `system-interface-contracts` | strong-public | Add via full Skill Graph export | capability / portable | Use when defining or reviewing contracts between systems, modules, services, agents, jobs, events, APIs, or teams: ownership, inputs, outputs, invariants, compatibility, errors, idempotency, and versioning. Do NOT use for REST resource design alone (use `api-design`), async event contract detail (use `event-contract-design`), database schemas (use `data-modeling`), or post-failure debugging (use `debugging`). | - | `skills/system-interface-contracts/SKILL.md` |
+| [ ] | `task-analysis` | strong-public | Add via full Skill Graph export | workflow / portable | Use when auditing a route, defining a route contract, reviewing onboarding or setup flows, diagnosing why a page feels confusing, or when the user asks about top tasks, time-to-value, branching, dead ends, or task complexity. Provides goal-driven UX analysis that turns vague critique into explicit goal -> task -> subtask decomposition and a primary / secondary / supporting hierarchy contract for the first viewport. Do NOT use for control-pattern choice (use `interaction-patterns`), visual craft (use `visual-design-foundations`), responsive layout (use `layout-composition`), or accessibility-only QA (use `a11y`). | - | `skills/task-analysis/SKILL.md` |
+| [ ] | `taxonomy-design` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing a controlled classification system: category trees, facets, browse taxonomies, SKOS broader/narrower relationships, tagging rules, and duplicate-category cleanup. Do NOT use for formal ontology axioms with reasoning constraints (use `ontology-modeling`), broad knowledge-representation choice (use `knowledge-modeling`), or one-off edge typing (use `semantic-relations`). | - | `skills/taxonomy-design/SKILL.md` |
+| [ ] | `testing-strategy` | strong-public | Add via full Skill Graph export | capability / portable | Use when planning tests for a bug fix, feature, or refactor — deciding what deserves a test, at which level, with what evidence. Covers test-scope decisions, test-level selection (unit / integration / contract / e2e), effort-to-risk matching, regression targeting, evidence quality, and failure-case coverage. Do NOT use for chasing a known failure (that is `debugging`), for pure doc writing (that is `documentation`), or for conceptual architecture discussion with no verification target (no dedicated skill — treat as strategy, not testing). | - | `skills/testing-strategy/SKILL.md` |
+| [ ] | `theme-system-design` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing a theme system — design tokens, semantic token layering, CSS custom property strategy, runtime theme switching, and theme contract guarantees. Do NOT use for one-off color choices, brand-only palette work, or framework-specific styling-library configuration. | - | `skills/theme-system-design/SKILL.md` |
+| [ ] | `tool-call-strategy` | strong-public | Add via full Skill Graph export | capability / portable | Use when an agent is making too many tool calls, when context is filling from verbose tool outputs, when the same operation could be a script instead of N individual calls, or when designing a tool-use protocol for a new agent or harness. Covers the three costs of every call (token, latency, context pollution), the script-vs-call decision gate, tool-selection decision trees (file-search vs content-search vs targeted-read vs full-read), call batching and parallelization, redundancy avoidance, the poka-yoke principle, subagent delegation for context protection, and cost-benchmark heuristics by task type. Do NOT use for prompt wording (use `prompt-craft`), broader context stack design across the five layers (use `context-engineering`), runtime tool failures or production debugging (use `debugging`), or behaviour-preserving refactor mechanics (use `refactor`). | duplicate name across public candidates (2 copies) | `skills/tool-call-strategy/SKILL.md` |
+| [ ] | `typography-system` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing a typography system — typeface selection and pairing, modular type scale, vertical rhythm, line-height and measure rules, and web font delivery (subsetting, font-display, variable fonts). Do NOT use for body copy writing, single-headline font pairing, or non-text design tokens. | - | `skills/typography-system/SKILL.md` |
+| [ ] | `usability-testing` | strong-public | Add via full Skill Graph export | capability / portable | Use when observing real users attempting tasks on a prototype or live product to surface usability issues — moderated or unmoderated, think-aloud protocol, task scenarios, severity rating, sample sizing per Nielsen's heuristics. Do NOT use for automated test suites, code coverage analysis, CI pipelines, unit/integration testing, or any engineering verification — those are testing-strategy concerns, not human-behavior observation. | - | `skills/usability-testing/SKILL.md` |
+| [ ] | `user-research` | strong-public | Add via full Skill Graph export | capability / portable | Use when planning or conducting generative qualitative research with real users — interviews, contextual inquiry, ethnographic observation, diary studies — to learn what people do, think, and need in their own context. Do NOT use for analytics review, survey statistics, A/B test interpretation, or agent-side intent classification — those are different research practices entirely. | - | `skills/user-research/SKILL.md` |
+| [ ] | `version-control` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or maintaining the shape of a repository's git history — choosing a branching model, deciding rebase vs merge, sizing commits, linking commits to tracker tickets, tagging releases, running parallel work across worktrees, and resolving the merge conflicts that arise from any of the above. Covers trunk-based development, short-lived feature branches, atomic commit discipline, linear-history conventions (rebase + squash), release tagging with annotated tags and SemVer, hotfix flows from tags, and worktree lifecycle for parallel agents or contributors. Do NOT use for the words inside the commit message (Conventional Commits format, identifier naming — use `naming-conventions`), for chasing a release-pipeline failure (use `debugging`), or for reviewing a PR's content (use `code-review`). | - | `skills/version-control/SKILL.md` |
+| [ ] | `visual-design-foundations` | strong-public | Add via full Skill Graph export | capability / portable | Use when designing or auditing visual craft: color palette, typography, spacing, elevation, rhythm, density, visual hierarchy, brand fit, contrast intent, and motion feel. Do NOT use for sign-system meaning (use `semiotics`), token/component architecture (use `design-system-architecture`), responsive structure (use `layout-composition`), or accessibility compliance (use `a11y`). | - | `skills/visual-design-foundations/SKILL.md` |
+| [ ] | `visual-hierarchy` | strong-public | Add via full Skill Graph export | capability / portable | Use when establishing visual hierarchy — type scale ratios, spacing rhythm, contrast as ordering signal, weight and size as importance, and the layered relationship between primary, secondary, and tertiary information. Do NOT use for content writing, information architecture, or specific color palette construction. | - | `skills/visual-hierarchy/SKILL.md` |
+| [ ] | `webhook-integration` | strong-public | Add via full Skill Graph export | capability / portable | Use when implementing or reviewing an inbound webhook handler for any third-party provider - verifying signatures, deduplicating retries, choosing the right HTTP status code for retry vs no-retry, persisting raw payloads before canonical mapping, and quarantining unverifiable events. Covers signature schemes, idempotency patterns, provider retry contracts, raw-then-canonical pipelines, quarantine, secret rotation, and PII-capture timing. Do NOT use for outbound webhook publishing (use `event-contract-design`), general background-job orchestration, or chasing a webhook handler that has already failed in production (use `debugging`). | - | `skills/webhook-integration/SKILL.md` |
+| [ ] | `writing-humanizer` | strong-public | Add via full Skill Graph export | capability / portable | Use when writing or editing human-readable prose such as docs, PRs, issues, release notes, errors, UI copy, commits, tooltips, or support replies, especially when text sounds robotic, padded, monotonous, or overly formal. Covers AI-tell removal, active voice, hedging reduction, readability diagnosis, sentence rhythm, vocabulary variety, tone mapping, paragraph rhythm, bullets-vs-prose choice, and the 5-step humanization workflow. Do NOT use for documentation routing/type selection, code-identifier naming, or in-product UI-text pattern catalogs. | - | `skills/writing-humanizer/SKILL.md` |
+
+## P1 - Active Development skills: migrate/enrich, then publish
+
+| Review | Skill | Fit | Action | Type / Scope | Description | Notes | Path |
+|---|---|---|---|---|---|---|---|
+| [ ] | `agent-engineering` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill covers agent engineering as a production discipline — the architecture, reliability patterns, and operational concerns required to turn non-deterministic LLMs into reliable, auditable systems. Covers task decomposition, context management, multi-agent coordination patterns (orchestrator/worker, fan-out, consensus), production reliability (idempotency, failure recovery, stall detection, safety caps), observability, and cost optimization. Use when designing a new agent system, evaluating orchestration patterns, diagnosing multi-agent coordination failures, or reasoning about agent system trade-offs. Do NOT use for harness/hook implementation (use harness-engineering or hook-patterns), model selection (use agents), or the specific orchestration commands /manage, /solve, /grind (use ai-coding-agents). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/agent-engineering/SKILL.md` |
+| [ ] | `agent-session-handoff` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides patterns for transferring state, context, and progress between agent sessions. Covers the handoff document format (what to persist vs discard), continuation signals (manage-continuation.json), session-start-brief injection (how a new session bootstraps context), handoff verification (how the receiving session confirms it has enough context), cross-model handoff (transferring between Claude, GPT-5.4, Gemini sessions), the compaction bridge (what survives /compact vs what must be persisted to disk), and the anti-patterns that cause context loss between sessions. Use when ending a session that has unfinished work, when starting a session that continues prior work, when designing loop respawn protocols, or when debugging context loss after session transitions. Do NOT use for session health and compaction timing (use session-lifecycle), for individual task progress tracking (use task-progression), or for inter-agent communication channels (use agent-to-agent). | legacy/plain frontmatter | `skills/agent-session-handoff/SKILL.md` |
+| [ ] | `agent-task-delegation` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides the decision framework for when and how an AI agent should delegate work to subagents. Covers delegation criteria (complexity, parallelism, specialization, context protection), subagent type selection from the agent roster, brief composition for effective delegation, isolation strategies (worktrees, sandboxes, background processes), result verification and quality gates after delegation, failure handling (retry, escalate, reassign), multi-model routing (matching task to model strengths), and the anti-patterns that cause delegation failures (fire-and-forget, context loss, over-delegation). Use when deciding whether to delegate or do it yourself, when spawning subagents, when routing work to different models, or when debugging delegation failures. Do NOT use for inter-agent communication channels (use agent-to-agent), for orchestration workflow commands like /solve and /manage (use orchestration), or for brief document format specifically (use agent-task-brief). | legacy/plain frontmatter | `skills/agent-task-delegation/SKILL.md` |
+| [ ] | `autonomous-loop-patterns` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill consolidates autonomous AI agent loop patterns: the Ralph Wiggum exit-code-2 pattern, our manage-loop (manage-continuation.json + manage-loop-hook.py), grind-loop.sh supervisor, completion detection strategies, safety caps, stall detection, and the tradeoffs between simple loops and sophisticated orchestration. Use when designing or debugging autonomous agent loops, choosing between loop approaches, or implementing safety limits. Do NOT use for choosing which command to run (use ai-coding-agents) or for task management (use linear). | legacy/plain frontmatter | `skills/autonomous-loop-patterns/SKILL.md` |
+| [ ] | `background-jobs` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides background job patterns for web applications: job queue architecture, long-running sync operations, progress tracking and reporting, failure handling and retry, job prioritization, and concurrency management. Load when implementing async processing, building job queues, designing progress indicators for long operations, or handling failure recovery for background work. | legacy/plain frontmatter | `skills/background-jobs/SKILL.md` |
+| [ ] | `chat-interface` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides conversational interface patterns for AI-assisted applications — streaming response architecture (SSE), message threading, turn-taking, context carryover, chat UI primitives, conversational UX best practices, and the patterns used by leading AI coding tools. Use when building chat interfaces, implementing streaming responses, designing conversational flows, or integrating AI chat into a product. | legacy/plain frontmatter | `skills/chat-interface/SKILL.md` |
+| [ ] | `command-palette` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | domain / operational | This skill provides keyboard-driven navigation patterns for power users: cmdk-style palette (Cmd+K), fuzzy search across orders/products/settings, action shortcuts, recent items, and contextual commands. Load when implementing command palette UI, keyboard shortcut systems, fuzzy search for navigation, or power-user workflow optimization. | legacy/plain frontmatter | `skills/command-palette/SKILL.md` |
+| [ ] | `compression` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides expertise in data and context compression: SaaS payload optimization (Zstd, Brotli, Gzip), database storage compression, and AI context window compression (Semantic Summarization, Token Pruning). Use when optimizing API latency, reducing storage costs, or managing long-running agent sessions near context limits. Do NOT use for image/video lossy compression (use product-photo) or file archiving. | legacy/plain frontmatter | `skills/compression/SKILL.md` |
+| [ ] | `conceptual-modeling` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / generic | This skill provides conceptual modeling methodology for abstracting real-world domains into structured representations: identifying entities, attributes, and relationships from requirements, choosing abstraction levels, building conceptual schemas independent of implementation, UML class/object/activity diagram patterns, conceptual vs. logical vs. physical model progression, and validation against user mental models. Covers cardinality analysis, generalization/specialization, aggregation/composition, role modeling, and anti-patterns like implementation leaking into conceptual models. Use when translating business requirements into domain models, designing new features from scratch, or validating that a system model matches business reality. Do NOT use for database-specific ER diagrams (use `entity-relationship-modeling`), formal ontology axioms (use `ontology`), or DDD aggregate boundaries (use `domain-modeling`). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/conceptual-modeling/SKILL.md` |
+| [ ] | `content-monitor` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides expertise for a multi-source intelligence pipeline covering YouTube channels (19), GitHub trending/topic pages (14), Reddit subreddits (12), awesome-lists (17), Google Search (6), and RSS/Atom feeds (31 — Hacker News, changelogs, blogs, arXiv, podcasts). Covers source adapter patterns, unified evaluation pipeline, deduplication, scheduling cadence, and actionable intelligence brief generation. Use when adding new content sources to the pipeline, configuring monitoring schedules, understanding the discover/transcribe/summarize/evaluate phases, extending or debugging the discovery pipeline, or deciding which model to use at each pipeline stage. Do NOT use for SEO keyword research — use the keywords skill. Do NOT use for competitive product analysis — use user-research-synthesis. | legacy/plain frontmatter | `skills/content-monitor/SKILL.md` |
+| [ ] | `context-management` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / operational | This skill provides the working discipline for controlling what enters, stays in, and exits an agent session. Covers intake triage, active working-set shaping, context drift recovery, checkpoint handoffs, and compaction-ready state management across long-running tasks. Use when deciding what context to load, reducing context drift, preparing a safe compaction, or recovering after a lost thread. Do NOT use for context window budget math (use context-window), prompt wording (use prompt-craft), or persistent memory curation (use memory-gardener). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/context-management/SKILL.md` |
+| [ ] | `context-window` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides context window management for AI coding agents — budget allocation across system/skill/working zones, context health monitoring (ok/compact/exhausted), compaction timing and hooks, pre-compact state preservation, post-compact recovery, progressive skill disclosure, and the 80% compaction rule. Use when managing context budget, deciding when to compact, recovering from compaction, or optimizing what goes into the context window. | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/context-window/SKILL.md` |
+| [ ] | `cost-aggregation` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides unified multi-model cost tracking across all 7 agent models, with per-task attribution derived from agent-events.js JSONL events, budget alerts using daily/weekly/monthly thresholds, cost trend analysis, and cross-platform reconciliation across Claude MAX, Copilot Pro+, Google AI Studio, and OpenRouter free tier. Covers cost formula application, budget alert tier classification (warn/throttle/stop), aggregation patterns for spend dashboards, marginal vs incremental cost distinctions for subscription billing models, and model-switch recommendations when budget thresholds are hit. Use when tracking token spend across a grind session, setting up budget alerts before a long loop, analyzing cost trends to optimize the model mix, or reconciling spend across subscription and per-token billing platforms. Do NOT use for application billing or subscription management (use the billing-subscription skill instead). | legacy/plain frontmatter | `skills/cost-aggregation/SKILL.md` |
+| [ ] | `cron-scheduling` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides cron job architecture patterns for web applications: Inngest schedule integration, Vercel Cron configuration, retry logic, monitoring and alerting for failed crons, and idempotency requirements. Load when designing scheduled tasks, configuring cron triggers, debugging missed or duplicate executions, or implementing monitoring for recurring jobs. | legacy/plain frontmatter | `skills/cron-scheduling/SKILL.md` |
+| [ ] | `design-thinking` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / operational | This skill provides the Design Thinking meta-orchestration layer for AI agents: mapping the 5-phase cycle (Empathize, Define, Ideate, Prototype, Test) to the existing skill ecosystem, routing agents to the correct specialized skill for each phase, enforcing phase transitions with explicit exit criteria, and preventing the most common AI anti-pattern of skipping directly to Prototype. Covers the Double Diamond (diverge then converge) applied to both product and engineering decisions, Google Design Sprint compression for solo dev + AI workflows, and phase depth calibration by task type. Use when starting a new feature, redesigning an existing surface, planning a multi-step UX improvement, or when an agent has jumped to implementation without understanding the problem. Do NOT use for single-line edits, bug fixes, config changes, or tasks where the solution is already specified (use task-execution or design-execution directly). Do NOT use as a substitute for the specialized skills it routes to. | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/design-thinking/SKILL.md` |
+| [ ] | `diagnosis` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides a triage-first diagnostic routing framework: symptom classification, technique selection matrices, evidence collection protocols, escalation criteria, and cross-domain diagnostic patterns. Functions as the 'triage router' that classifies a problem and selects which debugging methodology to apply — scientific debugging (troubleshooting), locate-to-solve (problem-locating-solving), performance forensics (identifying-bottlenecks), or security investigation (security-scanning). Use when facing an unknown failure and unsure which diagnostic approach to take, when multiple symptoms suggest different root causes, or when initial debugging attempts haven't converged. Do NOT use for executing a specific debugging methodology (use troubleshooting), locating a specific bug (use problem-locating-solving), or security-specific scanning (use security-scanning). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/diagnosis/SKILL.md` |
+| [ ] | `diff-analysis` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides disciplined diff analysis for AI agents: reading code changes as a structured before/after artifact, isolating semantic changes from formatting noise, tracing blast radius across files, and extracting review-ready findings from a patch. Covers unified diff anatomy, hunk-by-hunk interpretation, scope validation, hidden-risk scanning, and intent-vs-diff comparison. Use when analyzing `git diff`, reviewing a patch before commit, or explaining what a changeset actually does. Do NOT use for full code-review verdicts (use code-review), git workflow decisions (use version-control), or pixel/image comparison (use playwright-cli or visual diff tooling). | legacy/plain frontmatter | `skills/diff-analysis/SKILL.md` |
+| [ ] | `dispatch-loop` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / operational | This skill manages the dispatch-and-harvest lifecycle for parallel agent fleets. Covers spawning N loops, coordinating shutdown, and the post-dispatch harvest phase that extracts session findings and feeds them into the auto-improve pipeline. Use when starting multiple concurrent task loops, scaling agent throughput, or understanding how dispatch findings flow into skill evolution. Do NOT use for individual task solve passes (use ai-coding-agents). | legacy/plain frontmatter | `skills/dispatch-loop/SKILL.md` |
+| [ ] | `entity-relationship-modeling` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / generic | This skill provides entity-relationship (ER) modeling patterns for designing database schemas from domain requirements: Chen notation and Crow's Foot notation, entity identification and attribute analysis, primary/foreign key design, normalization (1NF through BCNF), denormalization trade-offs, junction table patterns, inheritance mapping strategies (single-table, class-table, concrete-table), temporal data modeling, and schema evolution/migration patterns. Covers the ER-to-SQL translation pipeline, indexing strategy from access patterns, constraint specification (NOT NULL, UNIQUE, CHECK, FK), and anti-patterns like EAV abuse, polymorphic associations, and over-normalization. Use when designing new database tables, reviewing schema changes, planning migrations, or translating conceptual models into physical database structures. Do NOT use for conceptual domain analysis (use `conceptual-modeling`), formal ontology (use `ontology`), or cross-system data mapping (use `relational-mapping`). | legacy/plain frontmatter | `skills/entity-relationship-modeling/SKILL.md` |
+| [ ] | `evaluation` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides a structured framework for automated agentic evaluation and human feedback loops. It defines the 'Critic' persona, the 5-point quality scale, and the mandatory 'Evaluation-Revision' loop for all critical work. | legacy/plain frontmatter | `skills/evaluation/SKILL.md` |
+| [ ] | `ghostty` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides Ghostty terminal configuration and agent workflow integration: config file syntax, keybinding setup, split-pane management, native AppleScript API (Ghostty 1.3+), spawn-ghostty-tab.sh multi-model agent dispatch, model→CLI routing (Claude/OpenCode/Codex/Gemini), font rendering, GPU backend selection, and recommended settings for Claude Code multi-agent workflows. Use when configuring Ghostty, adding keybindings, spawning agent tabs, debugging Ghostty rendering issues, setting up a multi-tab agent orchestration layout, or understanding how spawn-ghostty-tab.sh routes models to CLIs. Do NOT use for tmux session management (use ai-coding-agents) or other terminal emulators. | legacy/plain frontmatter | `skills/ghostty/SKILL.md` |
+| [ ] | `git-worktree` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides git worktree patterns for parallel agent development: worktree creation and cleanup, subagent isolation via `isolation: worktree` in Claude Code, branch management for parallel workstreams, conflict prevention between concurrent agents, and the worktree lifecycle (create → work → merge → cleanup). Use when running parallel agents on the same repo, isolating subagent work from the main branch, or debugging worktree-related git issues. Do NOT use for general git operations or branch strategy — use git CLI directly. | legacy/plain frontmatter | `skills/git-worktree/SKILL.md` |
+| [ ] | `governance` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides general governance guidance for policy, accountability, and controlled change across product, content, data, design, and operational systems. Covers governance domains, decision rights, RACI-style accountability models, policy lifecycle design, change management, compliance evidence, review cadences, and audit-trail expectations. Use when defining who decides what, setting ownership and approval boundaries, designing or reviewing policy workflows, planning controlled rollout and rollback, or auditing whether a system has enough structure to stay trustworthy as it grows. Do NOT use for agent-specific tool permission and trust-policy design (use agent-governance), or for application RBAC and user permission checks (use nextauth-patterns). | legacy/plain frontmatter | `skills/governance/SKILL.md` |
+| [ ] | `guardrails` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides a unified framework for proactive and reactive agent safety. It bridges agent-governance (proactive policy) and tripwire-guardrails.py (reactive pattern blocking) to prevent dangerous operations, data exfiltration, and irreversible system mutations. Use when planning operations that touch protected files (.env, credentials), performing git mutations (force push, reset), running destructive SQL, or working with PII and secrets. Do NOT use for application-level input validation (use zod-validation) or user RBAC (use nextauth-patterns). Do NOT use for general code logic review (use code-logic). | legacy/plain frontmatter | `skills/guardrails/SKILL.md` |
+| [ ] | `harness-engineering` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill covers the discipline of designing, implementing, and reasoning about the execution harness surrounding AI agents — hooks, configuration layering, permission boundaries, environment injection, process lifecycle, and the distinction between structural vs behavioral control. Use when designing new safety gates, understanding why hooks beat prompt instructions, evaluating harness architecture, configuring settings.json hook registration, or reasoning about control-plane layering. Do NOT use for individual hook implementation details (use hook-patterns), loop checkpoint state machines (use agent-loop-infra), or operational script debugging (use agent-infrastructure). | legacy/plain frontmatter | `skills/harness-engineering/SKILL.md` |
+| [ ] | `hook-patterns` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides Claude Code hook development patterns: PreToolUse and PostToolUse hook lifecycle, security gates (our tripwire-guardrails.py pattern), workflow enforcement (our wrap-gate-hook.py), session lifecycle hooks (SessionStart, PreCompact), prompt injection defense via hooks (Lasso/Sentinel patterns), auto-formatting hooks, and the hook → settings.json registration contract. Use when writing new hooks, debugging hook failures, or designing automated safety gates. Do NOT use for application-level middleware (use middleware-architecture). | legacy/plain frontmatter | `skills/hook-patterns/SKILL.md` |
+| [ ] | `intent-recognition` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides action classification before tool execution. It helps agents recognize whether an intended action is a safe read, a routine mutation, or a high-risk destructive operation. Activate BEFORE any tool call that modifies state — git commands, file writes, database queries, dependency installs, or shell commands with side effects. Do NOT use for deciding what code to write (use code-logic), executing tasks after classification (use task-execution), or defining governance policies (use agent-governance). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/intent-recognition/SKILL.md` |
+| [ ] | `keywords` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides keyword research, clustering, and platform-specific keyword optimization for e-commerce and SaaS. Covers seed keyword expansion, search intent mapping (informational/navigational/transactional/commercial), keyword clustering for topical authority, marketplace-specific keyword rules (Etsy 13-tag limit and 140-char title priority, Amazon backend keywords and 250-byte limit, Shopify product/collection meta fields), long-tail strategy for POD/merch businesses, cannibalization detection, and keyword tracking methodology. Use when performing keyword research, building a keyword strategy, optimizing product listings for marketplace search, choosing keywords for new content, detecting keyword cannibalization, or planning topical clusters. Do NOT use for diagnosing existing SEO problems (use seo-audit), building optimized pages at scale (use seo-strategy), content writing (use copywriting), or site page hierarchy (use site-architecture). | legacy/plain frontmatter | `skills/keywords/SKILL.md` |
+| [ ] | `knowledge-modeling` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / generic | This skill provides knowledge modeling patterns for structuring, representing, and organizing domain knowledge into computable forms: knowledge graphs, frames, semantic networks, production rules, concept maps, and hybrid representations. Covers knowledge acquisition from domain experts, tacit-to-explicit conversion, knowledge validation loops, representation trade-offs (expressiveness vs. tractability), and knowledge lifecycle management. Use when building knowledge bases, designing AI context systems, structuring skill/reference libraries, creating decision support systems, or organizing domain expertise for agent consumption. Do NOT use for database schema design (use `entity-relationship-modeling`), classification hierarchies only (use `taxonomy`), or formal ontology axioms (use `ontology`). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/knowledge-modeling/SKILL.md` |
+| [ ] | `merge-queue` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / operational | This skill manages the serialized merge queue for agent branches. Covers atomic locking, idempotency checks, non-fast-forward merges, and worktree cleanup. Use when merging multiple agent tasks to master, resolving merge conflicts between agents, or cleaning up stale task branches. Do NOT use for standard git operations (use version-control). | legacy/plain frontmatter | `skills/merge-queue/SKILL.md` |
+| [ ] | `methodical` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | Enforces disciplined, complete, step-by-step execution that prevents the LLM failure modes of scope reduction, finding filtering, step skipping, assumed verification, and sycophantic output compression. Provides the explanatory model for WHY agents fail at completeness (RLHF training rewards shorter, cleaner, more positive outputs — 58% sycophancy rate measured in frontier models) and the structural countermeasures: pre-task declarations, step-level evidence receipts, generation/criticism separation, explicit completeness claims, and anti-pattern detection. Use when executing audits, producing reports, creating Linear tasks from findings, verifying acceptance criteria, or any task where completeness and honesty matter more than brevity. Do NOT use for task workflow sequencing (use task-execution), quality definitions per artifact type (use quality-doctrine), or the generate-critique-revise loop mechanics (use self-review-pattern). | legacy/plain frontmatter | `skills/methodical/SKILL.md` |
+| [ ] | `methodology` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / reference | Provides the philosophical framework (methodology), specific techniques (methods), and ordered execution sequences (processes) that govern rigorous agent work. Covers the methodology-method-process stack, Cleanroom defect prevention, PSP/TSP measurement discipline, hypothesis-driven development, DMAIC quality management, aviation checklist design (Gawande), V&V frameworks (DO-178C/NASA), EDDOps for LLM agents, quality gates as hard stops, and the PDCA cycle for standardizing successes. Use when planning multi-step implementations, designing quality gates, establishing verification protocols, building agent checklists calibrated to known failure modes, or when an agent needs to understand WHY a process step exists (not just THAT it exists). Do NOT use for the specific behavioral rules of completeness and honesty (use methodical), quality definitions per artifact (use quality-doctrine), or generate-critique-revise loop mechanics (use self-review-pattern). | legacy/plain frontmatter | `skills/methodology/SKILL.md` |
+| [ ] | `mobile-responsive-ux` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides mobile-specific UX patterns for SaaS dashboards: touch-friendly targets (44px minimum), thumb-zone optimization, swipe gestures, condensed data display, bottom navigation, and pull-to-refresh. Load when designing for mobile users, implementing touch interactions, building responsive dashboard layouts, or optimizing for the Side Hustler persona who checks on mobile. | legacy/plain frontmatter | `skills/mobile-responsive-ux/SKILL.md` |
+| [ ] | `ontology` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / generic | This skill provides formal ontology patterns for structuring domain knowledge: class hierarchies, property axioms, instance classification, upper ontologies (BFO, DOLCE, Schema.org), OWL/RDF modeling patterns, and ontology-driven API and database design. Covers when to formalize domain knowledge into ontological structures, mereology (part-whole), taxonomy vs. ontology distinction, ontological commitment in schema design, and anti-patterns like over-classification and premature formalization. Use when designing domain models that need formal type hierarchies, reasoning about entity classification, building knowledge graphs, or deciding how to structure categories and types in a product. Do NOT use for database ER diagrams (use `entity-relationship-modeling`), linguistic meaning analysis (use `semiotics`), or DDD bounded contexts (use `domain-modeling`). | legacy/plain frontmatter | `skills/ontology/SKILL.md` |
+| [ ] | `orchestration` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides multi-agent orchestration patterns for the Development repo: the 6 thread types (S/P/C/F/M/L — Single, Parallel, Chained, Fusion, Meta, Long-running), the command hierarchy (/solve, /manage, /grind, /orchestrate-loops), dispatch-solver.js for cross-CLI routing, spawn-ghostty-tab.sh for visible agents, file-based coordination (manage-continuation.json, claim locks, worker status), parallel vs sequential execution, worktree isolation, loop control and steering, and the watchdog monitoring layer. Covers thread-type taxonomy, when to use each orchestration level, how agents communicate, and the cost/reliability tradeoffs between tab-based and subagent architectures. Use when coordinating multiple agents, classifying thread types, choosing between /solve vs /manage vs /grind, debugging agent communication, or designing new orchestration workflows. Do NOT use for individual task execution (use task-execution), for loop pattern details (use autonomous-loop-patterns), or for model selection (use agents). | legacy/plain frontmatter; description 1031 chars (>1024) | `skills/orchestration/SKILL.md` |
+| [ ] | `perspective` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides systematic interrogation of framing, assumptions, and perspective before planning or execution begins. Includes the Framing Gate (name what artifacts represent in the real world before processing them), perspective rotation across 5 viewpoints (domain expert, end user, adversary, future maintainer, operator), assumption surfacing protocol, the sequential interrogation pattern (one question at a time with recommended answers grounded in the codebase), devil's advocate opposition, and reframing triggers that detect when you're working from the wrong angle. Fires BEFORE evaluation and self-review — validates premises, not outputs. Use when starting a plan, designing a solution, evaluating artifacts, or any time the work feels technically correct but somehow wrong. Do NOT use for evaluating output quality (use evaluation), running self-review loops (use self-review-pattern), or calibrating reasoning depth (use reasoning). | legacy/plain frontmatter | `skills/perspective/SKILL.md` |
+| [ ] | `prioritization` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / reference | This skill provides prioritization frameworks for AI engineering: RICE-A (adding AI Ambiguity to RICE) for product features, ICE for research experiments, and MoSCoW for MVP/Release scoping. Use when ranking the backlog, deciding which model research path to follow, or defining the scope of a new feature. Do NOT use for one-off task sequencing (use task skill) or personal time management. | legacy/plain frontmatter | `skills/prioritization/SKILL.md` |
+| [ ] | `problem-locating-solving` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / operational | This skill provides an end-to-end workflow for finding where a problem lives and driving it to a verified fix. Covers problem statement construction, search-space reduction, boundary-based localization, root-cause isolation, solution optioning, and regression-proof verification. Use when you need to locate a bug in an unfamiliar codebase, trace a failure from symptom to source, or choose between multiple candidate fixes. Do NOT use for broad task planning (use task-execution), deep domain-specific financial logic review (use code-logic or data-reconciliation), or specialist-only audits such as security scanning and performance forensics. | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/problem-locating-solving/SKILL.md` |
+| [ ] | `prompt-craft` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | Teaches agents how to write, structure, evaluate, and improve prompts and templates for multi-model AI systems. | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/prompt-craft/SKILL.md` |
+| [ ] | `quality-doctrine` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | hybrid / operational | This skill defines what 'better' means per artifact type -- features, auth flows, skills, cleanup, and agent knowledge -- so agents can improve any artifact without removing value or missing quality dimensions. Covers feature self-explanation standards (UI copy, empty states, progressive disclosure), safe cleanup criteria (when removal IS and IS NOT justified), auth quality gates (zero-defect checklist), skill content quality rubrics, agent information architecture (organization over trimming), and visual hierarchy deepening techniques. Use when asked to 'improve', 'make better', 'upgrade', or 'clean up' any artifact, when planning what quality looks like before starting work, or when evaluating whether an improvement actually improved. Do NOT use for UI implementation process (use design-execution), visual quality gate verdicts (use design-review), skill file structure and scaffolding (use skill-scaffold), or task workflow sequencing (use task-execution). | legacy/plain frontmatter | `skills/quality-doctrine/SKILL.md` |
+| [ ] | `real-time-updates` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides live data update patterns for web applications: webhook-to-UI push patterns, Server-Sent Events for dashboard updates, polling fallback strategies, optimistic updates, and stale data indicators. Load when implementing live dashboards, push notifications to the browser, real-time data refresh, or deciding between SSE, WebSocket, and polling. | legacy/plain frontmatter | `skills/real-time-updates/SKILL.md` |
+| [ ] | `reasoning` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / reference | This skill provides reasoning strategy selection for AI agents: when to think deeply vs act fast, extended thinking calibration, chain-of-thought vs tree-of-thought vs ReAct, deterministic-first reasoning doctrine, model-specific reasoning capabilities, and the two-pass pattern (audit then implement). Covers reasoning effort calibration, the thinking-doing balance, reasoning technique routing by task type, and anti-patterns like over-reasoning simple tasks. Use when choosing how much to think before acting, calibrating reasoning depth, or when an agent is either under-thinking (wrong answers) or over-thinking (slow, verbose, circular). Do NOT use for prompt engineering (use prompt-craft) or for model selection (use agents). | legacy/plain frontmatter | `skills/reasoning/SKILL.md` |
+| [ ] | `self-evaluation` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides agentic self-assessment and self-critique patterns — single-agent self-review loops, convergence detection, stuck detection, quality self-scoring, the design audit self-critique cycle, experiment verification, and guardrail-triggered self-correction. Use when an agent needs to evaluate its own work, detect when it's stuck, decide whether to iterate or stop, or perform self-review before marking a task complete. | legacy/plain frontmatter | `skills/self-evaluation/SKILL.md` |
+| [ ] | `semantic-center` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / reference | This skill provides structured analysis for identifying the semantic center of any system, feature, concept, page, or problem and mapping how surrounding parts relate to it. Produces a primary-part + relation-map output that reduces complexity to its core structure. Use when asked to explain how parts connect, identify what matters most, untangle complex dependencies, map architecture, or when the user asks 'what is the important part?' Do NOT use for implementation work (use the relevant domain skill), for model selection (use agents), or for project prioritization (use prioritization). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/semantic-center/SKILL.md` |
+| [ ] | `semantic-relations` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / generic | This skill provides semantic relation analysis for understanding how concepts connect through meaning: taxonomic relations (hypernymy/hyponymy, holonymy/meronymy), associative relations (synonymy, antonymy, polysemy, homonymy), thematic relations (agent, patient, instrument, location), causal relations, temporal relations, and spatial relations. Covers relation detection in domain modeling, naming disambiguation, knowledge graph edge typing, skill boundary analysis, and anti-patterns like vague 'related-to' links and conflated relation types. Use when designing knowledge graphs, analyzing naming conflicts, defining skill boundaries, building taxonomy/ontology edges, creating structured vocabularies, or resolving entity/concept disambiguation. Do NOT use for formal ontology axioms (use `ontology`), database foreign key design (use `entity-relationship-modeling`), or cross-system data mapping (use `relational-mapping`). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/semantic-relations/SKILL.md` |
+| [ ] | `seo-strategy` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | hybrid / operational | SEO implementation strategy for building pages that rank -- covering content strategy, programmatic SEO at scale, marketplace-specific SEO, and AI search optimization. | legacy/plain frontmatter | `skills/seo-strategy/SKILL.md` |
+| [ ] | `sequential-thinking` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / operational | This skill provides structured sequential reasoning for complex multi-step problems: breaking problems into ordered steps, maintaining a thought chain across steps, revising earlier conclusions when new information emerges, and producing a final synthesis. Adapted from the MCP Sequential Thinking server pattern but designed as a native skill with project-specific integration. Use when facing problems that require sustained multi-step analysis, when earlier assumptions may need revision, when the problem has dependencies between parts, or when chain-of-thought reasoning needs explicit structure. Do NOT use for simple tasks that need no decomposition (use reasoning skill's hierarchy), for task execution protocol (use task-execution), or for agent orchestration (use orchestration). | legacy/plain frontmatter | `skills/sequential-thinking/SKILL.md` |
+| [ ] | `session-lifecycle` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides AI agent session lifecycle management: context window health monitoring, compaction timing and hooks, session-start-brief injection, the /wrap protocol, continuation signals (manage-continuation.json), context health states (ok/compact/exhausted), session error extraction, and the /clear fresh-context pattern. Covers session budget allocation, when to compact vs when to restart, cross-session state persistence, and anti-patterns like context exhaustion without wrap. Use when managing session health, deciding when to /compact or /clear, debugging context loss after compaction, or when sessions are dying mid-task. Do NOT use for task execution protocol (use task-execution) or for autonomous loop mechanics (use autonomous-loop-patterns). | legacy/plain frontmatter | `skills/session-lifecycle/SKILL.md` |
+| [ ] | `spec-driven-development` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / reference | This skill provides Spec Driven Development (SDD) expertise for AI engineering: the Specify → Plan → Tasks → Implement lifecycle. Use when starting any non-trivial task, refactoring a core module, or when an agent loop has stalled due to ambiguous requirements. Do NOT use for one-line edits or README fixes. | legacy/plain frontmatter | `skills/spec-driven-development/SKILL.md` |
+| [ ] | `streaming` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides real-time data streaming patterns for web applications — Server-Sent Events (SSE), ReadableStream API, streaming route handlers in Next.js, keep-alive signals, client reconnection, Vercel edge streaming constraints, and the event envelope format. Use when implementing real-time data push, building notification streams, creating progress indicators for long operations, or debugging streaming connection issues. | legacy/plain frontmatter | `skills/streaming/SKILL.md` |
+| [ ] | `summarization` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / reference | Prose condensation and abstraction patterns for AI agents: extracting key findings from long reports, writing executive summaries, creating TLDRs, compressing context for handoffs between agents, progressive summarization (literature notes → permanent notes), audit report condensation, and the discipline of deciding what to keep and what to cut when space is limited. Use when summarizing session findings, writing wrap reports, condensing research for memory files, creating executive summaries of audits, compressing context before agent handoffs, or distilling long documents into actionable briefs. Do NOT use for data compression algorithms (use compression), context window budget management (use token-efficiency), or document structure (use editorial-standards). | legacy/plain frontmatter | `skills/summarization/SKILL.md` |
+| [ ] | `task-lifecycle` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides task lifecycle management for AI agents: decomposition from vague request to actionable work, dependency ordering, acceptance criteria design, the researcher-solver pipeline, task classification (tier, model label, skill labels), the claim-lock system for multi-agent deconfliction, and parent/sub-issue hierarchy patterns. Covers the full Linear lifecycle (Needs Planning to Done), task state transitions, and the rules for when to decompose vs when to execute directly. Use when breaking down work, prioritizing tasks, managing Linear issues, or when agents are picking up tasks without proper research. Do NOT use for Linear CLI commands (use linear skill) or for task execution protocol (use task-execution). | legacy/plain frontmatter | `skills/task-lifecycle/SKILL.md` |
+| [ ] | `task-path-optimization` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides decision frameworks for choosing the optimal execution path before starting work: plan-vs-act gates, agent architecture selection (chaining, routing, parallelization, orchestrator-worker, evaluator-optimizer), scope management heuristics, critical-path analysis across task networks, and context budget awareness. Use when deciding how to approach a task (plan first vs act immediately), decomposing complex work into parallelizable subtasks, choosing between subagent patterns, or when a task has failed twice and needs a fresh approach. Do NOT use for executing the chosen plan (use task-execution), debugging failures (use troubleshooting or diagnosis), or tool-level efficiency (use tool-call-strategy). | legacy/plain frontmatter | `skills/task-path-optimization/SKILL.md` |
+| [ ] | `task-progression` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides progress tracking and reporting patterns for AI agents working through multi-step tasks. Covers progress visibility (what the user needs to see vs internal state), checkpoint and resume patterns for long-running work, milestone markers and phase gates, status reporting formats (structured JSON, markdown, TUI), stall detection (heartbeats, timeouts, watchdog patterns), progress aggregation for parallel and nested sub-tasks, and the anti-patterns that create false progress signals. Use when implementing multi-step tasks, when the user needs progress visibility, when building monitoring for agent loops, or when debugging stalled agents. Do NOT use for task decomposition and lifecycle states (use task-lifecycle), for task execution protocol (use task-execution), or for session-level progress (use session-progression). | legacy/plain frontmatter | `skills/task-progression/SKILL.md` |
+| [ ] | `task-sizing` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / reference | This skill provides effort calibration for AI agent tasks: matching work intensity to task complexity, fast-track vs full protocol selection, task tier classification (cosmetic/structural/architectural), model routing by effort level, skip-step rules, and timeout budgets. Covers the effort decision matrix, the minimum-viable-quality principle, when to go deep vs ship fast, and anti-patterns like gold-plating simple fixes. Use when deciding how much effort a task deserves, choosing between fast-track and full protocol, or when agents are either over-engineering simple tasks or under-investing in complex ones. Do NOT use for model selection specifics (use agents) or for reasoning depth (use reasoning). | legacy/plain frontmatter | `skills/task-sizing/SKILL.md` |
+| [ ] | `threaded-conversations` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides threaded conversation UI and data patterns for comment systems, inline discussions, and nested reply trees -- tree-structured data models, flat vs nested vs hybrid thread rendering, collapse/expand state, reply composition UX, @mention resolution, thread subscription/notification grouping, optimistic updates, real-time sync, and accessibility for threaded interfaces. Use when building comment systems, discussion features, review threads, inline annotations, help desk conversations, or any reply-chain UI. | legacy/plain frontmatter | `skills/threaded-conversations/SKILL.md` |
+| [ ] | `token-cost-estimation/findings` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides the Findings subskill under token-cost-estimation. Covers fix-now versus create-task decisions by combining estimated solve cost with the repo's inline-fix thresholds, verification burden, and critical-domain risk. Use when triaging findings from `/workflow/wrap`, `/workflow/manage`, session-log output, or audits and deciding whether to solve them immediately or create a Linear task. Do NOT use for board-level backlog prioritization (use board-triage), or for measured cost attribution after work already ran (use cost-aggregation). | legacy/plain frontmatter | `skills/token-cost-estimation/findings/SKILL.md` |
+| [ ] | `token-efficiency` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / reference | This skill provides context budget management and token efficiency patterns for AI coding agents: prompt compression techniques, skill-based progressive disclosure (minimal SKILL.md + references/ on demand), context window management, model routing for cost optimization, caching strategies, and the tradeoff between context richness and token spend. Use when optimizing agent workflows for cost, managing context window limits, or deciding how much context to load. Do NOT use for application caching (use redis-caching) or general performance optimization. | legacy/plain frontmatter | `skills/token-efficiency/SKILL.md` |
+| [ ] | `tool-call-strategy` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides optimization strategies for AI agent tool usage: when to use scripts vs individual tool calls, batching and parallelization of independent calls, context budget management, avoiding redundant reads and searches, tool selection decision trees (search tools vs read tools vs terminal tools), and cost-aware call sequencing. Use when an agent is making too many tool calls, when a task could be automated with a script instead of manual tool calls, when context is filling up from verbose tool outputs, or when optimizing agent workflows for speed and token efficiency. Do NOT use for choosing the overall task approach (use task-path-optimization), debugging tool failures (use troubleshooting), or codebase-specific search strategies (use codebase-search). | legacy/plain frontmatter; duplicate name across public candidates (2 copies) | `skills/tool-call-strategy/SKILL.md` |
+| [ ] | `tui` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides Terminal User Interface (TUI) patterns for building agent dashboards, monitoring tools, and interactive terminal applications. Covers framework selection (Ink/React for Node.js, bubbletea for Go, ratatui for Rust, Textual for Python), layout patterns (panels, splits, scrollable regions), real-time data streaming (logs, metrics, live status), keyboard navigation, color and styling (256-color, truecolor, fallbacks), responsive terminal layouts, progress indicators and spinners, and the agent-dashboard terminal architecture. Use when building terminal dashboards, monitoring tools, status displays, interactive CLI applications, or agent observation interfaces. Do NOT use for web UI components (use frontend), for general CLI argument parsing (model already knows this), or for Ghostty terminal configuration (use ghostty). | legacy/plain frontmatter | `skills/tui/SKILL.md` |
+| [ ] | `vercel-composition-patterns` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | capability / operational | This skill provides React composition patterns that scale — compound components, render props, context providers, lifted state, and React 19 API changes. It applies when refactoring components with boolean prop proliferation, designing flexible component APIs, building reusable libraries, or reviewing component architecture — triggered by phrases like "this component has too many props," "design a compound component," "make this more composable," "refactor with render props," or "component API design." Do NOT use for performance optimization — use react-best-practices instead. | legacy/plain frontmatter | `skills/vercel-composition-patterns/SKILL.md` |
+| [ ] | `vibe-kanban` | public-after-migration | Migrate/enrich to Skill Metadata Protocol, re-scan, then publish | workflow / operational | This skill provides a visual Trello-style workflow for managing AI agents. Covers Kanban board usage, worktree isolation per task, and diff-first review processes. Use when managing the agent task board, reviewing agent output via the Orchestrator UI, or setting up isolated worktrees for parallel feature development. Do NOT use for individual coding tasks (use ai-coding-agents). | legacy/plain frontmatter | `skills/vibe-kanban/SKILL.md` |
+
+## Excluded Rows
+
+**425** scanned skill files are intentionally excluded from row-level listing in this report.
+
+Keep them out of `skills.sh`, SkillsMP, README marketplace lists, generated exports, social posts, and outreach material until each one is rewritten as a public-safe skill and passes the privacy gate.