Sync ctx c1d8405

GitHub commit: c1d8405b4f0c57d84408e49871fc027890e40a5d

.agents/skills/MATTP0COCK-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matt Pocock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.agents/skills/README.md

@@ -0,0 +1,15 @@
+# Matt Pocock skills for Codex
+
+This directory contains 22 skills adapted from
+[`mattpocock/skills`](https://github.com/mattpocock/skills), installed for
+Codex through the Agent Skills standard. The upstream baseline is
+`ed37663cc5fbef691ddfecd080dff42f7e7e350d`; the local copies intentionally use
+lighter, judgment-based entrypoints and progressive disclosure.
+
+`skills-lock.json` records that upstream baseline. Review upstream changes
+before merging them; a blind skills update may overwrite the local adaptations.
+
+The upstream Claude plugin is not required. Deprecated, in-progress, personal,
+and miscellaneous skills are intentionally excluded.
+
+See `MATTP0COCK-LICENSE` for the upstream MIT license.

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

@@ -0,0 +1,19 @@
+---
+name: ask-matt
+description: Recommend the smallest Matt Pocock skill or short skill sequence that fits the user's current goal.
+---
+
+# Route to a skill
+
+1. Identify the user's immediate outcome, the context already available, and
+   whether they want advice, investigation, planning, implementation, or
+   review.
+2. Recommend the smallest skill that materially helps. Use a sequence only
+   when each handoff adds value; do not force the full idea-to-ship flow.
+3. Explain the recommendation and any important tradeoff in a few sentences.
+   If two choices are genuinely close, present both and recommend one.
+4. Mention setup only when the chosen workflow depends on missing tracker or
+   domain configuration.
+
+Read [references/skill-map.md](references/skill-map.md) when the choice is not
+obvious or the user asks to see the available routes.

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

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

.agents/skills/ask-matt/references/skill-map.md

@@ -0,0 +1,19 @@
+# Skill map
+
+Use this as a routing reference, not a mandatory pipeline.
+
+| Need | Likely skill | Notes |
+|---|---|---|
+| Stress-test an idea | `grilling`, `grill-me`, `grill-with-docs` | Choose the stateful variant only when durable domain notes are useful. |
+| Resolve a design question with evidence | `prototype`, `research` | Prototype behavior or UI; research facts and sources. |
+| Plan an unusually large, unclear effort | `wayfinder` | Use only when one session cannot expose the route. |
+| Turn settled thinking into work | `to-spec`, `to-tickets` | A spec is optional; tickets help when work needs coordination. |
+| Implement or test-first build | `implement`, `tdd` | Invoke TDD when test-first development is the user's chosen approach. |
+| Review a change | `code-review` | Compare the diff with repository standards and the intended behavior. |
+| Diagnose a difficult failure | `diagnosing-bugs` | Establish useful feedback before committing to a theory. |
+| Resolve Git conflicts | `resolving-merge-conflicts` | Preserve intent and escalate irreconcilable ambiguity. |
+| Improve architecture or language | `improve-codebase-architecture`, `codebase-design`, `domain-modeling` | Select architecture, interface, or domain vocabulary based on the question. |
+| Triage incoming work | `triage` | Use the repository's configured tracker conventions. |
+| Carry context to another session | `handoff` | Reference existing artifacts instead of copying them. |
+| Build a learning workspace | `teach` | Persist artifacts only when multi-session learning benefits from them. |
+| Configure or maintain skills | `setup-matt-pocock-skills`, `writing-great-skills` | Setup should follow existing repository conventions. |

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

@@ -0,0 +1,44 @@
+---
+name: code-review
+description: Review a Git diff against repository standards and its originating requirements. Use for pull requests, branches, work-in-progress changes, or changes since a commit, tag, or merge-base.
+---
+
+# Review code changes
+
+## Establish scope
+
+Honor a fixed point supplied by the user. Otherwise infer a sensible comparison
+from the repository state, such as the default-branch merge-base. Ask only when
+different choices would materially change the review.
+
+Verify that the ref resolves and inspect the diff and relevant commit messages.
+Report an empty or unavailable comparison instead of manufacturing findings.
+
+## Collect references
+
+Use the repository's actual standards and the originating issue, PRD, or spec
+when available. Follow repository conventions for fetching tracker context. If
+requirements cannot be found, review the standards axis and state that spec
+conformance was not verified.
+
+## Evaluate two axes
+
+- **Standards:** Does the change follow documented repository conventions and
+  avoid material design regressions?
+- **Spec:** Does it implement the requested behavior without omissions,
+  incorrect behavior, or unrelated scope?
+
+Use deterministic checks for properties tooling can decide. For qualitative
+review, load [review heuristics](references/review-heuristics.md) only when the
+diff warrants deeper design analysis.
+
+The axes are independent and may be evaluated concurrently when the diff is
+large enough to benefit. Keep a small review local, and avoid parallel work
+when coordination would cost more than it saves.
+
+## Report
+
+Lead with actionable findings, citing the affected file and evidence. Separate
+documented violations from judgment calls and keep Standards and Spec findings
+distinct so one axis cannot mask the other. State unavailable evidence and
+report when no material findings remain.

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

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

.agents/skills/code-review/references/review-heuristics.md

@@ -0,0 +1,37 @@
+# Review heuristics
+
+Use these heuristics when the diff raises design questions that repository
+standards and deterministic tools do not settle. Repository conventions take
+precedence. Label these as judgment calls, not hard violations.
+
+## Common design smells
+
+- **Mysterious name:** A name does not reveal what a value or operation means.
+- **Duplicated code:** The same logic shape appears in multiple changed sites.
+- **Feature envy:** A method depends more on another object's data than its own.
+- **Data clumps:** The same fields or parameters repeatedly travel together.
+- **Primitive obsession:** A primitive stands in for a meaningful domain type.
+- **Repeated conditionals:** Multiple sites branch on the same type or state.
+- **Shotgun surgery:** One behavior change requires scattered edits.
+- **Divergent change:** A module changes for several unrelated reasons.
+- **Speculative generality:** An abstraction serves no current requirement.
+- **Message chains:** A caller depends on a long navigation path.
+- **Middle man:** A layer mostly delegates without adding a useful boundary.
+- **Refused bequest:** An implementation inherits behavior it mostly rejects.
+
+Prefer the smallest correction that improves the changed behavior. Do not turn a
+review into an unrelated redesign, and do not repeat findings already decided by
+formatters, linters, type checkers, or tests.
+
+## Spec questions
+
+Check for:
+
+- requested behavior that is missing or only partially implemented;
+- behavior that contradicts the source requirement;
+- added scope without a clear requirement;
+- success paths that work while relevant failures or edge cases do not; and
+- implementation details that make a stated requirement untestable.
+
+Tie each finding to the source requirement when one exists. If no spec is
+available, describe the resulting limit rather than inferring requirements.

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

@@ -0,0 +1,50 @@
+# Deepening
+
+How to deepen a cluster of shallow modules safely, given its dependencies. Assumes the vocabulary in [SKILL.md](SKILL.md) — **module**, **interface**, **seam**, **adapter**.
+
+## Dependency categories
+
+When assessing a candidate for deepening, classify its dependencies. The category determines how the deepened module is tested across its seam.
+
+### 1. In-process
+
+Pure computation, in-memory state, no I/O. These are often the safest candidates
+to consolidate and test through a new interface; no adapter is usually needed.
+
+### 2. Local-substitutable
+
+Dependencies that have local test stand-ins (PGLite for Postgres, in-memory
+filesystem). Consolidation is attractive when the stand-in is representative
+enough. Keep the seam internal unless callers genuinely need to select an
+adapter.
+
+### 3. Remote but owned (Ports & Adapters)
+
+Your own services across a network boundary (microservices, internal APIs).
+Consider a **port** at the seam when transport variation or isolation repays the
+indirection. The deep module can own the policy while production and tests use
+appropriate adapters.
+
+Recommendation shape: *"Define a port at the seam, implement an HTTP adapter for production and an in-memory adapter for testing, so the logic sits in one deep module even though it's deployed across a network."*
+
+### 4. True external (Mock)
+
+Third-party services (Stripe, Twilio, etc.) you don't control. An injected port
+and test adapter often keep vendor behavior outside the module's policy.
+
+## Seam discipline
+
+- **Require a concrete reason for a seam.** Multiple adapters are strong
+  evidence, but ownership, policy, fault isolation, or an expensive dependency
+  can also justify one.
+- **Keep internal seams internal by default.** Expose them only when callers need
+  the variation, not solely because tests use it.
+
+## Testing strategy: replace, don't layer
+
+- Remove superseded unit tests when interface-level tests provide equivalent or
+  better confidence; retain focused tests that still catch distinct risks.
+- Write new tests at the deepened module's interface. The **interface is the test surface**.
+- Tests assert on observable outcomes through the interface, not internal state.
+- Prefer tests that survive internal refactors and describe behavior rather than
+  structure.

.agents/skills/codebase-design/DESIGN-IT-TWICE.md

@@ -0,0 +1,53 @@
+# Design It Twice
+
+When materially different interfaces are plausible, compare more than one
+design. Parallel agents can accelerate independent exploration, but local
+sketches are enough for a small problem.
+
+Uses the vocabulary in [SKILL.md](SKILL.md) — **module**, **interface**, **seam**, **adapter**, **leverage**.
+
+## Process
+
+### 1. Frame the problem space
+
+Before exploring alternatives, frame the problem space:
+
+- The constraints any new interface would need to satisfy
+- The dependencies it would rely on, and which category they fall into (see [DEEPENING.md](DEEPENING.md))
+- A rough illustrative code sketch to ground the constraints — not a proposal, just a way to make the constraints concrete
+
+Share the framing when user feedback would materially improve the design.
+
+### 2. Explore alternatives
+
+Produce two or more meaningfully different interfaces. Use parallel sub-agents
+when the alternatives divide cleanly and the expected insight exceeds
+coordination cost. Otherwise sketch them locally.
+
+Give each exploration the same constraints and a distinct optimization target,
+for example:
+
+- Alternative 1: "Minimize the interface — aim for 1–3 entry points max. Maximise leverage per entry point."
+- Alternative 2: "Maximise flexibility — support many use cases and extension."
+- Alternative 3: "Optimise for the most common caller — make the default case trivial."
+- Alternative 4 (if applicable): "Design around ports and adapters for
+  cross-seam dependencies."
+
+Use the project's vocabulary. The terms in [SKILL.md](SKILL.md) are lenses, not a
+required replacement for established domain language.
+
+For each alternative, capture:
+
+1. Interface (types, methods, params — plus invariants, ordering, error modes)
+2. Usage example showing how callers use it
+3. What the implementation hides behind the seam
+4. Dependency strategy and adapters (see [DEEPENING.md](DEEPENING.md))
+5. Trade-offs — where leverage is high, where it's thin
+
+### 3. Present and compare
+
+Present the designs at a level proportional to the decision. Compare **depth**,
+**locality**, **seam placement**, migration cost, and fit with existing code.
+
+Recommend the strongest design and explain its trade-offs. Propose a hybrid only
+when it is more coherent than either source design.

.agents/skills/codebase-design/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: codebase-design
+description: Design or improve module interfaces using deep-module heuristics. Use when deciding where a seam belongs, reducing caller-facing complexity, improving testability or navigability, or comparing module designs.
+---
+
+# Codebase Design
+
+Seek **deep modules**: substantial useful behavior behind a small, stable
+interface. Use the concepts below as design lenses, while matching the
+repository's established domain language.
+
+## Working vocabulary
+
+- **Module**: a coherent unit with an interface and implementation, at any scale.
+- **Interface**: everything callers must know, including invariants and failure
+  modes—not just a type signature.
+- **Seam**: a location where behavior can vary without editing its callers.
+- **Adapter**: an implementation that connects at a seam.
+- **Depth**: useful capability relative to interface complexity.
+- **Leverage**: capability gained by callers; **locality**: change and knowledge
+  concentrated for maintainers.
+
+Translate these terms to the project's vocabulary when that makes the design
+clearer. Consistency with the codebase is more valuable than enforcing a private
+lexicon.
+
+## Design workflow
+
+1. Map representative callers, responsibilities, dependencies, and existing
+   contracts.
+2. Look for coordination or policy that can move behind a smaller interface.
+3. Place seams where variation, ownership, or test isolation justifies them.
+4. Compare alternatives when the choice is consequential.
+5. Validate the candidate with representative caller code and tests.
+
+## Heuristics, not laws
+
+- Reduce methods, parameters, ordering constraints, and configuration callers
+  must understand.
+- Use the deletion test: if removing a module merely spreads its complexity
+  across callers, it was likely earning its keep.
+- Treat pass-through layers skeptically, but keep them when they provide a real
+  compatibility, ownership, policy, or navigation boundary.
+- Introduce dependency seams when actual variation or test isolation repays the
+  indirection; avoid interfaces justified only by hypothetical futures.
+- Prefer tests through observable interfaces, while allowing focused internal
+  tests when they provide cheaper or more precise feedback.
+- Favor explicit dependencies and returned results when they improve control and
+  testability; side effects and internally created dependencies can still be
+  appropriate at well-defined boundaries.
+
+Read [DEEPENING.md](DEEPENING.md) when consolidating a cluster across dependency
+boundaries. Read [DESIGN-IT-TWICE.md](DESIGN-IT-TWICE.md) when materially
+different interface designs can be explored independently.

.agents/skills/codebase-design/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Codebase Design"
+  short_description: "Vocabulary for deep-module design"

.agents/skills/diagnosing-bugs/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: diagnosing-bugs
+description: Diagnose hard bugs and performance regressions with reproducible evidence, focused hypotheses, and proportional instrumentation. Use when something is broken, failing, throwing, intermittently wrong, or unexpectedly slow.
+---
+
+# Diagnosing Bugs
+
+Start from evidence and adapt the depth of the investigation to the problem.
+Read relevant repository context and architectural decisions when they exist.
+
+## Establish a useful signal
+
+Reproduce the reported symptom with the cheapest signal that distinguishes
+broken from fixed. A focused test or script is ideal when practical; logs,
+traces, snapshots, comparisons, or measured timings may be better for other
+failures. Tighten the loop by improving speed, specificity, and determinism.
+
+If an exact reproduction is unavailable, continue with the strongest evidence
+available and state the limitation. Request an artifact, access, or temporary
+instrumentation only when it would materially improve the diagnosis.
+
+For feedback-loop options and debugging tactics, load the
+[debugging playbook](references/debugging-playbook.md) as needed. For a rare
+manual reproduction, adapt
+[`scripts/hitl-loop.template.sh`](scripts/hitl-loop.template.sh).
+
+## Narrow and explain
+
+Minimize the reproducing scenario when doing so will shrink the search space.
+Form a small ranked set of falsifiable hypotheses from the evidence, then choose
+probes that best distinguish them. Share hypotheses with the user when their
+domain knowledge could redirect the investigation; do not make routine progress
+depend on a checkpoint.
+
+Use targeted instrumentation at boundaries that separate plausible causes.
+Change as little as practical per probe. For performance regressions, establish
+a baseline and use profiling, query plans, or bisection before optimizing.
+
+## Fix and verify
+
+Add a regression test when a stable seam can represent the real failure. If it
+cannot, explain the coverage gap rather than adding a misleading test. Apply the
+smallest justified fix, then rerun both the focused signal and relevant nearby
+checks.
+
+Remove temporary instrumentation and artifacts unless the user wants to retain
+them. Report the observed cause, the evidence that supports it, what was
+verified, and any remaining uncertainty. Recommend architectural follow-up only
+when the diagnosis exposes a concrete recurring weakness.

.agents/skills/diagnosing-bugs/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Diagnosing Bugs"
+  short_description: "Diagnose hard bugs and regressions"

.agents/skills/diagnosing-bugs/references/debugging-playbook.md

@@ -0,0 +1,54 @@
+# Debugging playbook
+
+Load the sections that fit the failure. These are options, not mandatory phases.
+
+## Feedback-loop options
+
+- A focused unit, integration, or end-to-end test.
+- A CLI or HTTP invocation with fixture input and a precise assertion.
+- A browser script that observes relevant DOM, console, or network behavior.
+- Replay of a captured request, trace, event stream, or crash artifact.
+- A small harness around the affected service or function.
+- Property or fuzz testing for input-dependent failures.
+- `git bisect run` when the failure appeared between known revisions.
+- Differential execution across versions, configurations, or environments.
+- A human-assisted script when automation cannot reach the symptom directly.
+
+Prefer a signal that exercises the user's actual symptom. Improve it where
+useful by narrowing setup, pinning time or randomness, isolating external state,
+or increasing the reproduction rate of intermittent failures.
+
+## Intermittent failures
+
+Measure a baseline reproduction rate. Repetition, controlled concurrency,
+stress, or targeted timing changes can make the failure easier to observe.
+Preserve seeds, inputs, schedules, and environment details that explain a
+successful reproduction.
+
+## Hypotheses and probes
+
+Frame a hypothesis as a prediction:
+
+> If X is the cause, changing or observing Y should produce Z.
+
+Favor probes that distinguish several plausible causes. Debuggers and REPL
+inspection often provide cleaner evidence than broad logging. If temporary logs
+are appropriate, use a unique searchable prefix and remove them after use.
+
+For performance problems, compare measured baselines and inspect profiles,
+query plans, allocation patterns, or revision history before choosing a fix.
+
+## Regression coverage
+
+A useful regression test represents the real failure at a stable seam. Avoid a
+shallow test that cannot exercise the failing interaction. When no honest seam
+exists, record that architectural limitation and rely on the strongest
+available reproduction for verification.
+
+After the fix, consider:
+
+- whether the original symptom is gone;
+- whether focused and nearby regression checks pass;
+- whether temporary instrumentation and harnesses remain;
+- whether the explanation separates observation from inference; and
+- whether the same structural weakness is likely to recur.

.agents/skills/diagnosing-bugs/scripts/hitl-loop.template.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Human-in-the-loop reproduction loop.
+# Copy this file, edit the steps below, and run it.
+# The agent runs the script; the user follows prompts in their terminal.
+#
+# Usage:
+#   bash hitl-loop.template.sh
+#
+# Two helpers:
+#   step "<instruction>"          → show instruction, wait for Enter
+#   capture VAR "<question>"      → show question, read response into VAR
+#
+# At the end, captured values are printed as KEY=VALUE for the agent to parse.
+
+set -euo pipefail
+
+step() {
+  printf '\n>>> %s\n' "$1"
+  read -r -p "    [Enter when done] " _
+}
+
+capture() {
+  local var="$1" question="$2" answer
+  printf '\n>>> %s\n' "$question"
+  read -r -p "    > " answer
+  printf -v "$var" '%s' "$answer"
+}
+
+# --- edit below ---------------------------------------------------------
+
+step "Open the app at http://localhost:3000 and sign in."
+
+capture ERRORED "Click the 'Export' button. Did it throw an error? (y/n)"
+
+capture ERROR_MSG "Paste the error message (or 'none'):"
+
+# --- edit above ---------------------------------------------------------
+
+printf '\n--- Captured ---\n'
+printf 'ERRORED=%s\n' "$ERRORED"
+printf 'ERROR_MSG=%s\n' "$ERROR_MSG"

.agents/skills/domain-modeling/ADR-FORMAT.md

@@ -0,0 +1,24 @@
+# ADR format
+
+Follow the repository's existing ADR location, numbering, and status
+conventions. When none exist, a decision can be recorded minimally:
+
+```markdown
+# Short decision title
+
+Describe the context, the decision, and why this option was chosen.
+```
+
+Add sections such as status, considered options, consequences, or supersession
+only when they preserve useful information.
+
+An ADR is most valuable when the decision is:
+
+- costly to reverse;
+- surprising without historical context; and
+- the result of a real tradeoff.
+
+Good candidates include system boundaries, integration patterns, technology
+choices with meaningful lock-in, non-obvious constraints, and deliberate
+deviations from the expected design. Routine implementation choices and
+temporary priorities usually do not need an ADR.

.agents/skills/domain-modeling/CONTEXT-FORMAT.md

@@ -0,0 +1,37 @@
+# Domain context format
+
+Follow the repository's existing glossary or context-map convention. When none
+exists and a new artifact is useful, this is a compact starting point.
+
+```markdown
+# Context name
+
+One or two sentences describing the domain context and why it exists.
+
+## Language
+
+**Canonical term:** A concise, project-specific definition.
+_Avoid:_ Ambiguous or deprecated synonyms, when naming them prevents confusion.
+```
+
+Include only concepts that carry special meaning in this domain. Define what a
+term is and how it differs from nearby concepts; keep implementation details in
+specs, code, or ADRs.
+
+For repositories with several bounded contexts, a root context map may list
+each context, its location, and important relationships:
+
+```markdown
+# Context map
+
+- **Ordering:** Receives and tracks customer orders.
+- **Billing:** Generates invoices and processes payment.
+
+## Relationships
+
+- Ordering emits `OrderPlaced`; Fulfillment consumes it.
+```
+
+Create or split context files only when the model actually has distinct
+boundaries and the artifact will be maintained. Do not force a multi-context
+layout from directory structure alone.

.agents/skills/domain-modeling/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: domain-modeling
+description: Clarify domain concepts, language, boundaries, and durable architectural decisions. Use when terminology is ambiguous, the user is shaping a domain model, or a design depends on resolving what concepts mean.
+---
+
+# Model the domain
+
+Build a precise shared understanding of the concepts that matter to the current
+decision. Read existing glossaries, context maps, ADRs, code, and tests when
+they provide relevant evidence.
+
+## Sharpen the model
+
+- Identify overloaded terms, hidden distinctions, and conflicting definitions.
+- Use concrete scenarios and edge cases to test whether concepts and boundaries
+  hold.
+- Compare the stated model with behavior in the code and surface material
+  contradictions.
+- Propose clear language when ambiguity is blocking progress, while respecting
+  established repository terminology that remains accurate.
+
+Ask the user to resolve a term only when their intent cannot be inferred safely
+and the distinction affects the outcome.
+
+## Record durable knowledge proportionally
+
+Update a glossary or context map when the user requests it or when a resolved
+term is durable, project-specific, and useful beyond the current conversation.
+Follow an existing repository format first; otherwise use the
+[context format](CONTEXT-FORMAT.md) as a lightweight starting point.
+
+Record an ADR only when a decision is costly to reverse, surprising without its
+context, and based on a meaningful tradeoff. Follow existing ADR conventions or
+use the [ADR format](ADR-FORMAT.md). Do not create artifacts merely to complete
+the workflow.
+
+Keep domain definitions separate from implementation plans. Report unresolved
+ambiguity and artifact changes explicitly.

.agents/skills/domain-modeling/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Domain Modeling"
+  short_description: "Build and sharpen a domain model"

.agents/skills/grill-me/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: grill-me
+description: A relentless interview to sharpen a plan or design.
+---
+
+Run a `/grilling` session.

.agents/skills/grill-me/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Grill Me"
+  short_description: "Sharpen a plan through interview"
+policy:
+  allow_implicit_invocation: false

.agents/skills/grill-with-docs/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: grill-with-docs
+description: A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.
+---
+
+Run a `/grilling` session, using the `/domain-modeling` skill.

.agents/skills/grill-with-docs/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Grill with Docs"
+  short_description: "Grill a design and write its docs"
+policy:
+  allow_implicit_invocation: false

.agents/skills/grilling/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: grilling
+description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.
+---
+
+Interview me relentlessly about every aspect of this until we reach a shared understanding. Walk down each branch of the decision tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
+
+Ask the questions one at a time, waiting for feedback on each question before continuing. Asking multiple questions at once is bewildering.
+
+If a *fact* can be found by exploring the environment (filesystem, tools, etc.), look it up rather than asking me. The *decisions*, though, are mine — put each one to me and wait for my answer.
+
+Do not act on it until I confirm we have reached a shared understanding.

.agents/skills/grilling/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Grilling"
+  short_description: "Stress-test thinking one question at a time"

.agents/skills/handoff/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: handoff
+description: Compact the current conversation into a handoff document for another agent to pick up.
+---
+
+Write a handoff document summarising the current conversation so a fresh agent can continue the work. Save to the temporary directory of the user's OS - not the current workspace.
+
+Include a "suggested skills" section in the document, which suggests skills that the agent should invoke.
+
+Do not duplicate content already captured in other artifacts (specs, plans, ADRs, issues, commits, diffs). Reference them by path or URL instead.
+
+Redact any sensitive information, such as API keys, passwords, or personally identifiable information.
+
+If the user passed arguments, treat them as a description of what the next session will focus on and tailor the doc accordingly.

.agents/skills/handoff/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Handoff"
+  short_description: "Compact a conversation into a handoff"
+policy:
+  allow_implicit_invocation: false

.agents/skills/implement/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: implement
+description: Implement work from a spec, ticket, or agreed conversation. Use explicitly when the user wants an existing plan carried through to working code.
+---
+
+# Implement planned work
+
+Confirm the intended outcome and inspect the relevant code, tests, and
+repository conventions. Resolve ambiguity only when it would materially change
+the result; otherwise make a reasonable scoped assumption and proceed.
+
+Implement the smallest coherent change that satisfies the source requirements.
+Use test-first development when requested or when a focused failing test is the
+clearest feedback loop. Avoid speculative abstractions and unrelated cleanup.
+
+Validate the changed surface proportionally: start with focused evidence and
+expand to broader checks when risk or repository contracts justify it. Use a
+separate review when semantic risk remains or the user requests one.
+
+Report what changed, what was verified, and any remaining uncertainty. Commit,
+publish, or mutate tracker state only when requested or clearly included in the
+active workflow.

.agents/skills/implement/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Implement"
+  short_description: "Build work from a spec or tickets"
+policy:
+  allow_implicit_invocation: false

.agents/skills/improve-codebase-architecture/HTML-REPORT.md

@@ -0,0 +1,41 @@
+# Architecture report guide
+
+Use a visual report when relationships, before/after structure, or several
+candidates would be harder to compare in prose. Follow the user's requested
+destination and the environment's artifact conventions.
+
+## Suggested structure
+
+- Repository or subsystem and the scope inspected.
+- Candidate cards with evidence and affected modules.
+- A recommendation strength such as `Strong`, `Worth exploring`, or
+  `Speculative`.
+- One top recommendation with its main tradeoff.
+- Limits: relevant areas or evidence not inspected.
+
+Each candidate can include:
+
+- **Observed friction:** what is difficult today.
+- **Proposed deepening:** which responsibility moves behind which interface.
+- **Evidence:** concrete call paths, change patterns, tests, or dependencies.
+- **Benefits:** expected locality, leverage, or test improvement.
+- **Costs:** migration work, compatibility risk, or added indirection.
+- **Decision conflicts:** ADRs or constraints that would need reconsideration.
+
+## Visual choices
+
+Choose the smallest visual that makes the relationship clearer:
+
+- A dependency or call-flow graph for tangled relationships.
+- A sequence diagram for excess round trips.
+- A layered cross-section for shallow pass-through modules.
+- Interface-versus-implementation mass for module depth.
+- A before/after call-graph collapse for consolidation.
+
+Mermaid is useful for graph-shaped relationships. HTML/CSS or SVG may be better
+for editorial comparisons. Prefer self-contained output; use external CDNs only
+when the environment permits them.
+
+Keep labels close to the repository's domain and architecture language, but
+favor clarity over enforcing a special vocabulary. Diagrams should carry useful
+evidence rather than decorate the report.

.agents/skills/improve-codebase-architecture/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: improve-codebase-architecture
+description: Analyze a codebase for high-leverage architectural improvements and explain evidence, tradeoffs, and next steps. Use explicitly for architecture audits or deep-module refactoring opportunities.
+---
+
+# Improve Codebase Architecture
+
+Look for architectural friction that a focused structural change could reduce.
+Favor improvements that shrink interfaces, concentrate related complexity, and
+make important behavior easier to test and understand.
+
+## Scope the investigation
+
+Follow the user's named subsystem or pain point. Otherwise use recent changes,
+repeated maintenance friction, test difficulty, or dependency structure to
+select a useful area. Read relevant domain language and ADRs when present so
+recommendations respect intentional boundaries.
+
+Use the `codebase-design` skill when its deep-module vocabulary will sharpen the
+analysis. Explore independently in parallel only when the repository is large
+enough to benefit and the lanes do not duplicate work.
+
+## Find evidence
+
+Consider:
+
+- interfaces that expose nearly as much complexity as their implementations;
+- behavior spread across modules that change together;
+- dependency seams that leak internal details;
+- testing that bypasses the real call path because no stable seam exists; and
+- repeated wrappers or indirection that add little leverage.
+
+Treat these as prompts for investigation, not violations. Apply the deletion
+test where useful: would removing a layer concentrate complexity behind a
+better interface, or merely move it elsewhere?
+
+## Present candidates
+
+For each material candidate, cite the affected code and explain:
+
+- the observed friction;
+- the structural change being considered;
+- expected benefits and tradeoffs;
+- evidence that the seam is real rather than hypothetical;
+- test impact and migration risk; and
+- conflicts with existing decisions.
+
+Rank recommendations by evidence and likely leverage. Keep speculative ideas
+clearly labeled and avoid proposing a wide refactor solely for aesthetic
+consistency.
+
+Use prose, a compact table, or diagrams according to what best communicates the
+relationships. When a visual HTML artifact is useful and authorized, load the
+[HTML report guide](HTML-REPORT.md).
+
+Explore a selected candidate further only when the user requests it or the
+current task includes design. Update domain records or ADRs only when those
+artifacts are in scope and the decision is durable enough to justify them.

.agents/skills/improve-codebase-architecture/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Improve Codebase Architecture"
+  short_description: "Find high-leverage architecture improvements"
+policy:
+  allow_implicit_invocation: false

.agents/skills/prototype/LOGIC.md

@@ -0,0 +1,39 @@
+# Logic Prototype
+
+A logic prototype makes business rules, state transitions, or data-shape
+trade-offs concrete enough to exercise.
+
+## Workflow
+
+1. Write down the question and what evidence would answer it.
+2. Choose the cheapest useful interaction:
+   - a small terminal UI for exploratory state transitions;
+   - a script or table of cases for deterministic rules;
+   - a focused test harness for invariants or regression behavior;
+   - a notebook or REPL when rapid data-shape exploration matters.
+3. Use the project's existing runtime and tooling where practical.
+4. Keep the logic separate from the harness when that separation helps compare
+   designs or reuse the result. Do not turn a disposable experiment into a
+   premature production abstraction.
+5. Exercise representative normal, edge, and invalid cases. Surface the state,
+   transition, output, or error that answers the question.
+6. Give the user the run command and summarize what the prototype demonstrated.
+
+## Interactive terminal shape
+
+When manual state exploration is the useful feedback loop, build a lightweight
+terminal interface:
+
+- Show the current relevant state and available actions.
+- Accept one action at a time and render the resulting state.
+- Keep the frame compact and make invalid transitions visible.
+- Use native terminal capabilities or dependencies already present in the
+  project before adding a UI library.
+
+## Guardrails
+
+- Avoid real production mutations unless they are essential to the question and
+  safely isolated.
+- Avoid speculative generalization.
+- Keep harness concerns from obscuring the logic under evaluation.
+- Treat prototype code as evidence, not production-ready implementation.

.agents/skills/prototype/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: prototype
+description: Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
+---
+
+# Prototype
+
+A prototype is disposable code that answers a specific design question. Let the
+question, repository, and cheapest credible feedback loop determine its shape.
+
+## Pick a branch
+
+Infer the branch from the request and surrounding code:
+
+- **Logic or state-model uncertainty** → read [LOGIC.md](LOGIC.md).
+- **Visual or interaction uncertainty** → read [UI.md](UI.md).
+
+If both are involved, prototype the riskiest uncertainty first. State a material
+assumption instead of blocking when the choice can be reversed cheaply.
+
+## Shared guidance
+
+- Mark the artifact clearly as a prototype and follow existing project structure.
+- Keep it runnable with a simple documented command or URL.
+- Prefer in-memory or stubbed dependencies unless persistence or integration is
+  the question being tested.
+- Add only the error handling, tests, and structure needed for trustworthy
+  feedback. Avoid production polish and speculative flexibility.
+- Make the relevant state, alternatives, or outcomes easy to inspect.
+- Stop when the evidence answers the question.
+
+Report the answer, how to exercise the prototype, and its limitations. Do not
+promote, commit, branch, publish, or preserve the artifact unless the user asks.
+When preservation is useful, record the question and conclusion alongside it.

.agents/skills/prototype/UI.md

@@ -0,0 +1,44 @@
+# UI Prototype
+
+A UI prototype compares visual or interaction ideas with enough surrounding
+context to make the trade-offs visible.
+
+## Workflow
+
+1. State the design question and the constraints every option must satisfy.
+2. Choose a comparison surface:
+   - embed variants in an existing page when its real data and density are
+     important and the change is safely isolated;
+   - use a clearly marked prototype route or local artifact when isolation is
+     more valuable.
+3. Produce enough structurally different variants to expose the decision,
+   usually two or three. Vary hierarchy, layout, and primary affordance rather
+   than only color or copy.
+4. Reuse the project's component library, styles, and representative data.
+5. Make comparison easy. A URL parameter and small variant switcher are useful
+   for an in-app prototype; separate local pages or screenshots may be cheaper
+   for a narrower question.
+6. Run the prototype in its actual rendering environment and inspect the
+   relevant viewport sizes and interactions.
+7. Give the user the URL or command, label the variants, and summarize the
+   trade-offs without choosing for them unless they requested a recommendation.
+
+## Optional in-app switcher
+
+When persistent, side-by-side browser evaluation is useful:
+
+- Select variants through a shareable URL parameter.
+- Provide compact previous/next controls and a clear variant label.
+- Preserve existing data fetching outside the variant-specific rendering.
+- Avoid intercepting keyboard shortcuts while an input is focused.
+- Keep prototype controls out of production builds.
+
+## Guardrails
+
+- Do not let shared prototype code force variants into the same structure.
+- Stub destructive mutations unless the interaction with the real backend is the
+  question under test and can be exercised safely.
+- Treat a selected variant as design evidence, not automatically as
+  production-ready code.
+- Remove or preserve prototype machinery only when the user asks for that next
+  step.

.agents/skills/prototype/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Prototype"
+  short_description: "Prototype to answer a design question"

.agents/skills/research/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: research
+description: Investigate questions using high-trust primary sources and traceable citations. Use when the user asks for research, current documentation or API facts, source verification, or evidence-backed comparison.
+---
+
+# Research
+
+Clarify the decision or question the research must support. Prefer official
+documentation, source code, specifications, papers, and first-party APIs.
+Trace material claims to the source that owns them, distinguish source facts
+from inference, and account for publication and event dates when recency
+matters.
+
+Use parallel research lanes only when the question has independent source areas
+and the coordination cost is worthwhile. Keep narrow lookups local.
+
+Return findings in the form the user requested, with citations close to the
+claims they support. Create a repository artifact only when requested or when
+it clearly serves the task and is within the authorized scope.

.agents/skills/research/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Research"
+  short_description: "Research from high-trust sources"

.agents/skills/resolving-merge-conflicts/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: resolving-merge-conflicts
+description: Resolve an in-progress Git merge or rebase conflict while preserving the relevant intent of both sides. Use when conflict markers or an interrupted merge/rebase need investigation and resolution.
+---
+
+# Resolve Merge Conflicts
+
+1. Inspect the current Git state, the operation in progress, its goal, and every
+   conflicting file.
+2. Reconstruct each side's intent from the code, nearby tests, history, commit
+   messages, and linked work items that are available and useful.
+3. Resolve each hunk by preserving compatible intent. Where intents conflict,
+   prefer the merge's stated goal and current repository contracts; avoid
+   inventing unrelated behavior.
+4. Run focused checks for the affected surface, then broader checks when risk or
+   repository guidance warrants them.
+5. Unless the user requested advice or review only, stage resolved files and
+   continue the current merge or rebase when it is safe to do so. Report what was
+   resolved, what was verified, and any remaining uncertainty.
+
+Pause rather than guess when neither intent can be preserved safely. Aborting or
+restarting can be the correct recovery when the base is wrong, the operation is
+contaminated, or the user prefers a clean retry; explain the trade-off before
+taking that destructive step.

.agents/skills/resolving-merge-conflicts/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Resolving Merge Conflicts"
+  short_description: "Resolve merge and rebase conflicts"

.agents/skills/setup-matt-pocock-skills/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: setup-matt-pocock-skills
+description: Configure repository-local tracker, triage, and domain-document conventions needed by the Matt Pocock engineering skills.
+---
+
+# Configure the repository
+
+1. Inspect existing tracker conventions, remotes, domain documents, ADRs, and
+   skill configuration. Reuse established structure.
+2. Determine which configuration the installed workflows actually need:
+   issue-tracker guidance, triage labels, domain-document guidance, or a subset.
+3. Infer unambiguous choices from the repository. Ask only about choices that
+   materially change behavior, and present a recommendation with the tradeoff.
+4. Show the proposed repository-local files before writing when the choice is
+   material or the files already contain user decisions.
+5. Write the smallest idempotent configuration that satisfies the selected
+   workflows. Do not add skill inventories or workflow prose to `AGENTS.md` or
+   `CLAUDE.md`; keep those files lightweight and point workflows at dedicated
+   configuration instead.
+6. Report what was configured and what remains intentionally unconfigured.
+
+Use the existing seed files only for the selected branch:
+
+- GitHub: [issue-tracker-github.md](issue-tracker-github.md)
+- GitLab: [issue-tracker-gitlab.md](issue-tracker-gitlab.md)
+- Local Markdown: [issue-tracker-local.md](issue-tracker-local.md)
+- Triage labels: [triage-labels.md](triage-labels.md)
+- Domain documents: [domain.md](domain.md)
+
+Adapt templates to the repository; they are references, not required output
+shapes.

.agents/skills/setup-matt-pocock-skills/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: "Setup Matt Pocock Skills"
+  short_description: "Configure a repo for the skills"
+policy:
+  allow_implicit_invocation: false

.agents/skills/setup-matt-pocock-skills/domain.md

@@ -0,0 +1,51 @@
+# Domain Docs
+
+How the engineering skills should consume this repo's domain documentation when exploring the codebase.
+
+## Before exploring, read these
+
+- **`CONTEXT.md`** at the repo root, or
+- **`CONTEXT-MAP.md`** at the repo root if it exists — it points at one `CONTEXT.md` per context. Read each one relevant to the topic.
+- **`docs/adr/`** — read ADRs that touch the area you're about to work in. In multi-context repos, also check `src/<context>/docs/adr/` for context-scoped decisions.
+
+If any of these files don't exist, **proceed silently**. Don't flag their absence; don't suggest creating them upfront. The `/domain-modeling` skill (reached via `/grill-with-docs` and `/improve-codebase-architecture`) creates them lazily when terms or decisions actually get resolved.
+
+## File structure
+
+Single-context repo (most repos):
+
+```
+/
+├── CONTEXT.md
+├── docs/adr/
+│   ├── 0001-event-sourced-orders.md
+│   └── 0002-postgres-for-write-model.md
+└── src/
+```
+
+Multi-context repo (presence of `CONTEXT-MAP.md` at the root):
+
+```
+/
+├── CONTEXT-MAP.md
+├── docs/adr/                          ← system-wide decisions
+└── src/
+    ├── ordering/
+    │   ├── CONTEXT.md
+    │   └── docs/adr/                  ← context-specific decisions
+    └── billing/
+        ├── CONTEXT.md
+        └── docs/adr/
+```
+
+## Use the glossary's vocabulary
+
+When your output names a domain concept (in an issue title, a refactor proposal, a hypothesis, a test name), use the term as defined in `CONTEXT.md`. Don't drift to synonyms the glossary explicitly avoids.
+
+If the concept you need isn't in the glossary yet, that's a signal — either you're inventing language the project doesn't use (reconsider) or there's a real gap (note it for `/domain-modeling`).
+
+## Flag ADR conflicts
+
+If your output contradicts an existing ADR, surface it explicitly rather than silently overriding:
+
+> _Contradicts ADR-0007 (event-sourced orders) — but worth reopening because…_

.agents/skills/setup-matt-pocock-skills/issue-tracker-github.md

@@ -0,0 +1,45 @@
+# Issue tracker: GitHub
+
+Issues and PRDs for this repo live as GitHub issues. Use the `gh` CLI for all operations.
+
+## Conventions
+
+- **Create an issue**: `gh issue create --title "..." --body "..."`. Use a heredoc for multi-line bodies.
+- **Read an issue**: `gh issue view <number> --comments`, filtering comments by `jq` and also fetching labels.
+- **List issues**: `gh issue list --state open --json number,title,body,labels,comments --jq '[.[] | {number, title, body, labels: [.labels[].name], comments: [.comments[].body]}]'` with appropriate `--label` and `--state` filters.
+- **Comment on an issue**: `gh issue comment <number> --body "..."`
+- **Apply / remove labels**: `gh issue edit <number> --add-label "..."` / `--remove-label "..."`
+- **Close**: `gh issue close <number> --comment "..."`
+
+Infer the repo from `git remote -v` — `gh` does this automatically when run inside a clone.
+
+## Pull requests as a triage surface
+
+**PRs as a request surface: no.** _(Set to `yes` if this repo treats external PRs as feature requests; `/triage` reads this flag.)_
+
+When set to `yes`, PRs run through the same labels and states as issues, using the `gh pr` equivalents:
+
+- **Read a PR**: `gh pr view <number> --comments` and `gh pr diff <number>` for the diff.
+- **List external PRs for triage**: `gh pr list --state open --json number,title,body,labels,author,authorAssociation,comments` then keep only `authorAssociation` of `CONTRIBUTOR`, `FIRST_TIME_CONTRIBUTOR`, or `NONE` (drop `OWNER`/`MEMBER`/`COLLABORATOR`).
+- **Comment / label / close**: `gh pr comment`, `gh pr edit --add-label`/`--remove-label`, `gh pr close`.
+
+GitHub shares one number space across issues and PRs, so a bare `#42` may be either — resolve with `gh pr view 42` and fall back to `gh issue view 42`.
+
+## When a skill says "publish to the issue tracker"
+
+Create a GitHub issue.
+
+## When a skill says "fetch the relevant ticket"
+
+Run `gh issue view <number> --comments`.
+
+## Wayfinding operations
+
+Used by `/wayfinder`. The **map** is a single issue with **child** issues as tickets.
+
+- **Map**: a single issue labelled `wayfinder:map`, holding the Notes / Decisions-so-far / Fog body. `gh issue create --label wayfinder:map`.
+- **Child ticket**: an issue linked to the map as a GitHub sub-issue (`gh api` on the sub-issues endpoint). Where sub-issues aren't enabled, add the child to a task list in the map body and put `Part of #<map>` at the top of the child body. Labels: `wayfinder:<type>` (`research`/`prototype`/`grilling`/`task`). Once claimed, the ticket is assigned to the driving dev.
+- **Blocking**: GitHub's **native issue dependencies** — the canonical, UI-visible representation. Add an edge with `gh api --method POST repos/<owner>/<repo>/issues/<child>/dependencies/blocked_by -F issue_id=<blocker-db-id>`, where `<blocker-db-id>` is the blocker's numeric **database id** (`gh api repos/<owner>/<repo>/issues/<n> --jq .id`, _not_ the `#number` or `node_id`). GitHub reports `issue_dependencies_summary.blocked_by` (open blockers only — the live gate). Where dependencies aren't available, fall back to a `Blocked by: #<n>, #<n>` line at the top of the child body. A ticket is unblocked when every blocker is closed.
+- **Frontier query**: list the map's open children (`gh issue list --state open`, scoped to the map's sub-issues / task list), drop any with an open blocker (`issue_dependencies_summary.blocked_by > 0`, or an open issue in the `Blocked by` line) or an assignee; first in map order wins.
+- **Claim**: `gh issue edit <n> --add-assignee @me` — the session's first write.
+- **Resolve**: `gh issue comment <n> --body "<answer>"`, then `gh issue close <n>`, then append a context pointer (gist + link) to the map's Decisions-so-far.

.agents/skills/setup-matt-pocock-skills/issue-tracker-gitlab.md

@@ -0,0 +1,46 @@
+# Issue tracker: GitLab
+
+Issues and PRDs for this repo live as GitLab issues. Use the [`glab`](https://gitlab.com/gitlab-org/cli) CLI for all operations.
+
+## Conventions
+
+- **Create an issue**: `glab issue create --title "..." --description "..."`. Use a heredoc for multi-line descriptions. Pass `--description -` to open an editor.
+- **Read an issue**: `glab issue view <number> --comments`. Use `-F json` for machine-readable output.
+- **List issues**: `glab issue list -F json` with appropriate `--label` filters.
+- **Comment on an issue**: `glab issue note <number> --message "..."`. GitLab calls comments "notes".
+- **Apply / remove labels**: `glab issue update <number> --label "..."` / `--unlabel "..."`. Multiple labels can be comma-separated or by repeating the flag.
+- **Close**: `glab issue close <number>`. `glab issue close` does not accept a closing comment, so post the explanation first with `glab issue note <number> --message "..."`, then close.
+- **Merge requests**: GitLab calls PRs "merge requests". Use `glab mr create`, `glab mr view`, `glab mr note`, etc. — the same shape as `gh pr ...` with `mr` in place of `pr` and `note`/`--message` in place of `comment`/`--body`.
+
+Infer the repo from `git remote -v` — `glab` does this automatically when run inside a clone.
+
+## Merge requests as a triage surface
+
+**MRs as a request surface: no.** _(Set to `yes` if this repo treats external merge requests as feature requests; `/triage` reads this flag.)_
+
+When set to `yes`, MRs run through the same labels and states as issues, using the `glab mr` equivalents:
+
+- **Read an MR**: `glab mr view <number> --comments` and `glab mr diff <number>` for the diff.
+- **List external MRs for triage**: `glab mr list -F json`, then keep only MRs whose author is not a project member/owner (a contributor's MR, not a maintainer's in-flight work).
+- **Comment / label / close**: `glab mr note`, `glab mr update --label`/`--unlabel`, `glab mr close`.
+
+Unlike GitHub, GitLab numbers issues and MRs separately, so `#42` is unambiguous once you know which surface the maintainer means.
+
+## When a skill says "publish to the issue tracker"
+
+Create a GitLab issue.
+
+## When a skill says "fetch the relevant ticket"
+
+Run `glab issue view <number> --comments`.
+
+## Wayfinding operations
+
+Used by `/wayfinder`. The **map** is a single issue with **child** issues as tickets.
+
+- **Map**: a single issue labelled `wayfinder:map`, holding the Notes / Decisions-so-far / Fog body. `glab issue create --label wayfinder:map`. (On GitLab tiers with native epics, an epic may hold the map instead; a labelled issue works everywhere.)
+- **Child ticket**: an issue carrying `Part of #<map>` at the top of its description and labels `wayfinder:<type>` (`research`/`prototype`/`grilling`/`task`). Once claimed, the ticket is assigned to the driving dev.
+- **Blocking**: GitLab's **native blocking link** — the canonical, UI-visible representation. Add it with the `/blocked_by #<n>` quick action, posted as a note (`glab issue note <child> --message "/blocked_by #<blocker>"`). Native blocking links are a Premium/Ultimate feature; on the free tier (or where unavailable) fall back to a `Blocked by: #<n>, #<n>` line at the top of the description. A ticket is unblocked when every blocker is closed.
+- **Frontier query**: `glab issue list -F json` scoped to the map's children, drop any with an open blocker — a native `blocked_by` link to an open issue (`glab api projects/:id/issues/:iid/links`), or an open issue in the `Blocked by` line — or an assignee; first in map order wins.
+- **Claim**: `glab issue update <n> --assignee @me` — the session's first write.
+- **Resolve**: `glab issue note <n> --message "<answer>"`, then `glab issue close <n>`, then append a context pointer (gist + link) to the map's Decisions-so-far.

.agents/skills/setup-matt-pocock-skills/issue-tracker-local.md

@@ -0,0 +1,30 @@
+# Issue tracker: Local Markdown
+
+Issues and specs (you may know a spec as a PRD) for this repo live as markdown files in `.scratch/`.
+
+## Conventions
+
+- One feature per directory: `.scratch/<feature-slug>/`
+- The spec is `.scratch/<feature-slug>/spec.md`
+- Implementation issues are one file per ticket at `.scratch/<feature-slug>/issues/<NN>-<slug>.md`, numbered from `01` — never a single combined tickets file
+- Triage state is recorded as a `Status:` line near the top of each issue file (see `triage-labels.md` for the role strings)
+- Comments and conversation history append to the bottom of the file under a `## Comments` heading
+
+## When a skill says "publish to the issue tracker"
+
+Create a new file under `.scratch/<feature-slug>/` (creating the directory if needed).
+
+## When a skill says "fetch the relevant ticket"
+
+Read the file at the referenced path. The user will normally pass the path or the issue number directly.
+
+## Wayfinding operations
+
+Used by `/wayfinder`. The **map** is a file with one **child** file per ticket.
+
+- **Map**: `.scratch/<effort>/map.md` — the Notes / Decisions-so-far / Fog body.
+- **Child ticket**: `.scratch/<effort>/issues/NN-<slug>.md`, numbered from `01`, with the question in the body. A `Type:` line records the ticket type (`research`/`prototype`/`grilling`/`task`); a `Status:` line records `claimed`/`resolved`.
+- **Blocking**: a `Blocked by: NN, NN` line near the top. A ticket is unblocked when every file it lists is `resolved`.
+- **Frontier**: scan `.scratch/<effort>/issues/` for files that are open, unblocked, and unclaimed; first by number wins.
+- **Claim**: set `Status: claimed` and save before any work.
+- **Resolve**: append the answer under an `## Answer` heading, set `Status: resolved`, then append a context pointer (gist + link) to the map's Decisions-so-far in `map.md`.

.agents/skills/setup-matt-pocock-skills/triage-labels.md

@@ -0,0 +1,15 @@
+# Triage Labels
+
+The skills speak in terms of five canonical triage roles. This file maps those roles to the actual label strings used in this repo's issue tracker.
+
+| Label in mattpocock/skills | Label in our tracker | Meaning                                  |
+| -------------------------- | -------------------- | ---------------------------------------- |
+| `needs-triage`             | `needs-triage`       | Maintainer needs to evaluate this issue  |
+| `needs-info`               | `needs-info`         | Waiting on reporter for more information |
+| `ready-for-agent`          | `ready-for-agent`    | Fully specified, ready for an AFK agent  |
+| `ready-for-human`          | `ready-for-human`    | Requires human implementation            |
+| `wontfix`                  | `wontfix`            | Will not be actioned                     |
+
+When a skill mentions a role (e.g. "apply the AFK-ready triage label"), use the corresponding label string from this table.
+
+Edit the right-hand column to match whatever vocabulary you actually use.

.agents/skills/tdd/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: tdd
+description: Apply test-driven development with small, behavior-focused feedback loops. Use when the user asks to build or fix something test-first, mentions red-green-refactor, or wants integration tests.
+---
+
+# Test-Driven Development
+
+Use small red → green → refactor cycles when a test-first feedback loop is
+practical. Treat repository conventions, existing tests, and the requested
+behavior as authoritative.
+
+## Loop
+
+1. Identify one observable behavior and the seam through which callers see it.
+2. Write the smallest meaningful test and confirm that it fails for the expected
+   reason.
+3. Add only enough implementation to make the test pass.
+4. Refactor when doing so improves clarity or design; keep the suite green.
+5. Repeat with the next vertical slice.
+
+Infer seams from public interfaces and nearby tests. Ask the user only when
+choosing a seam would materially change the product contract, cost, or scope.
+
+## Judgment
+
+- Prefer behavior-focused tests that survive internal refactors.
+- Derive expected results from a specification, worked example, or other
+  independent source rather than duplicating the implementation.
+- Mock external or nondeterministic boundaries when useful; follow established
+  repository patterns where they provide an adequate feedback loop.
+- Prefer vertical slices over a speculative batch of tests. Batch closely
+  related mechanical cases when that is clearer and faster.
+- If a failing-first cycle is impractical—for example in legacy code with no
+  usable seam—state the limitation and establish the nearest reliable
+  characterization or integration test.
+
+Read [tests.md](tests.md) for examples and [mocking.md](mocking.md) when deciding
+whether and where to use test doubles.

.agents/skills/tdd/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "TDD"
+  short_description: "Test-driven red-green-refactor"