From 4027ea6afdd329aefb6671ab9f2bc12482fb6d76 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Wed, 1 Jul 2026 19:46:37 +0100 Subject: [PATCH 01/13] refactor(decision-mapping): rename to wayfinding MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reframe the planning skill around the Wayfinder persona — chart a route through a foggy problem, resolving tickets one at a time until the way to the goal is clear. "Decision map" was jargony and inaccurate (only 1 of 4 ticket types is a decision). Rename the folder and skill name, rewrite the description and framing, and prune: unify node->ticket, bind "frontier" to the unblocked set, drop the duplicated "one question at a time" (owned by /grilling), trim intro no-ops. Co-Authored-By: Claude Opus 4.8 --- .changeset/wayfinding-rename.md | 9 +++++ skills/in-progress/README.md | 2 +- .../{decision-mapping => wayfinding}/SKILL.md | 34 +++++++++---------- 3 files changed, 27 insertions(+), 18 deletions(-) create mode 100644 .changeset/wayfinding-rename.md rename skills/in-progress/{decision-mapping => wayfinding}/SKILL.md (68%) diff --git a/.changeset/wayfinding-rename.md b/.changeset/wayfinding-rename.md new file mode 100644 index 0000000..50623bc --- /dev/null +++ b/.changeset/wayfinding-rename.md @@ -0,0 +1,9 @@ +--- +"mattpocock-skills": minor +--- + +Rename the **`decision-mapping`** skill to **`wayfinding`**, invoked as `/wayfinding`. + +"Decision map" was jargony and inaccurate — only one of the skill's four ticket types (Grilling) is actually a decision. The skill is reframed around the **Wayfinder**: you chart a route through a foggy problem, resolving investigation tickets one at a time until the way to the goal is clear. This makes one coherent leading-word frame (fog of war / frontier / the map) instead of mixing an invented term on top of it. + +Also a pruning pass: unified `node`→`ticket`, bound "the frontier" to the unblocked tickets, dropped the duplicated "one question at a time" (owned by `/grilling`), and trimmed intro no-ops. diff --git a/skills/in-progress/README.md b/skills/in-progress/README.md index a0b9b1f..21dd028 100644 --- a/skills/in-progress/README.md +++ b/skills/in-progress/README.md @@ -2,7 +2,7 @@ Skills that are still being developed. They're not ready to ship — expect rough edges, breaking changes, and abandoned experiments. They're excluded from the plugin and the top-level README until they graduate to a stable bucket. -- **[decision-mapping](./decision-mapping/SKILL.md)** — Turn a loose idea into a sequenced map of investigation tickets, then drive them to resolution one at a time. User-invoked. +- **[wayfinding](./wayfinding/SKILL.md)** — As the Wayfinder, chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. User-invoked. - **[loop-me](./loop-me/SKILL.md)** — Grill yourself into implementable workflow specs over multiple sessions, using the current directory as a stateful workspace. User-invoked. - **[wizard](./wizard/SKILL.md)** — Generate an interactive bash wizard that walks a human through a manual procedure (setup, a one-off migration, a state transition) — opening URLs, capturing values, writing `.env` and GitHub Actions secrets. User-invoked. - **[writing-beats](./writing-beats/SKILL.md)** — Shape an article as a journey of beats, choose-your-own-adventure style. Pick a starting beat, write only that beat, then pivot to the next, until the article reaches a natural end. diff --git a/skills/in-progress/decision-mapping/SKILL.md b/skills/in-progress/wayfinding/SKILL.md similarity index 68% rename from skills/in-progress/decision-mapping/SKILL.md rename to skills/in-progress/wayfinding/SKILL.md index cc89297..6b1e5bc 100644 --- a/skills/in-progress/decision-mapping/SKILL.md +++ b/skills/in-progress/wayfinding/SKILL.md @@ -1,14 +1,14 @@ --- -name: decision-mapping -description: Turn a loose idea into a sequenced map of investigation tickets, then drive them to resolution one at a time. +name: wayfinding +description: As the Wayfinder, chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. disable-model-invocation: true --- -This skill is invoked when a loose idea requires more than one agent session to turn into a plan. It creates a stateful decision map in a markdown file, and drives the user through a sequence of tickets to resolve the open questions - which may require either prototyping, research or grilling. The map is domain-agnostic: it plans engineering work, course content, or anything else that fits the same shape. +You are the **Wayfinder**. A loose idea has arrived — too big for one agent session, and wrapped in fog: you can't yet see the route from here to a plan. Chart it: stand up a map, then work its tickets one at a time. The map is domain-agnostic — engineering work, course content, whatever fits the shape. -## The Decision Map +## The Map -The decision map is a single compact Markdown file, one per planning effort, git-tracked alongside the project. It is the canonical artifact — the **whole map is loaded as context into every session**, so it must stay compact. +The map is a single compact Markdown file, one per wayfinding effort, git-tracked alongside the project. It is the canonical artifact — the **whole map is loaded as context into every session**, so it must stay compact. Assets created during tickets should be linked to from the map, not duplicated within it. @@ -53,19 +53,19 @@ There are four types of tickets: ## Fog of war -The map is _deliberately_ incomplete beyond the frontier. Your job is to investigate the frontier, and to resolve tickets in order to push the frontier forward. Push back the fog of war, one node at a time — until the path to the finish line is clear and no tickets remain. +The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. The frontier is the unblocked tickets at the edge of the known; resolve them to push it forward. Push back the fog of war one ticket at a time, until the way to the goal is clear and no tickets remain. ## Invocation Two branches. Either way, **every session ends with a [Handoff](#handoff)** — never resolve more than one ticket per session. -### Create the map +### Chart the map User invokes with a loose idea. -1. Run a `/grilling` and `/domain-modeling` session to surface the open decisions. Ask one question at a time. -2. Write a new decision map — mostly fog, frontier identified, trivially-decidable entries resolved inline. -3. Handoff. Map-building is one session's work; do not also resolve tickets. +1. Run a `/grilling` and `/domain-modeling` session to surface the open decisions. +2. Write a new map — mostly fog, frontier identified, trivially-decidable entries resolved inline. +3. Handoff. Charting the map is one session's work; do not also resolve tickets. ### Work through the map @@ -75,7 +75,7 @@ User invokes with a path to an existing map. A ticket slug is **optional** — w 2. Choose the ticket. If the user named one, use it. Otherwise pick the first `open` ticket in document order that is [unblocked](#structure). [Claim it](#structure): set `Status: in-progress` and save before any work. 3. Resolve it, invoking skills as needed — including any the `## Notes` block names. If in doubt, use `/grilling` and `/domain-modeling`. 4. Record the answer in the ticket's body and set `Status: resolved`. -5. Add newly-discovered tickets with correct `Blocked by` edges. If the decisions made invalidate other parts of the map, update or delete those nodes. +5. Add newly-discovered tickets with correct `Blocked by` edges. If the decisions made invalidate other parts of the map, update or delete those tickets. 6. Handoff. The user may run unblocked tickets in parallel, so expect other agents to be editing the map in their own sessions. @@ -91,18 +91,18 @@ End every session by clearing the context and opening one or more fresh sessions > > **One session** — resolves the next unblocked ticket: > ``` -> Invoke /decision-mapping with the map at . +> Invoke /wayfinding with the map at . > ``` > > **Parallel** — paste one line per window, up to all 3: > ``` -> Invoke /decision-mapping with the map at , ticket auth-strategy. -> Invoke /decision-mapping with the map at , ticket cache-layer. -> Invoke /decision-mapping with the map at , ticket rate-limits. +> Invoke /wayfinding with the map at , ticket auth-strategy. +> Invoke /wayfinding with the map at , ticket cache-layer. +> Invoke /wayfinding with the map at , ticket rate-limits. > ``` -**No open tickets remain.** The fog is pushed back far enough that the path to the finish line is clear — the map is done. (The initial grilling may also surface no fog at all, in which case there was never a map to build.) Recommend implementing directly, or using `/to-prd` to schedule a multi-session implementation. +**No open tickets remain.** The fog is pushed back far enough that the way to the goal is clear — the map is done. (The initial grilling may also surface no fog at all, in which case there was never a map to chart.) Recommend implementing directly, or using `/to-prd` to schedule a multi-session implementation. ## Notes -An optional block declaring the **domain**, any skills every session should `consult`, and freeform standing preferences the planning surfaces. +An optional block declaring the **domain**, any skills every session should `consult`, and freeform standing preferences for this effort. From 01f0b7e11ac48b40dda92a5497e8d8ada33d39c5 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Wed, 1 Jul 2026 19:48:33 +0100 Subject: [PATCH 02/13] refactor(wayfinder): invoke as /wayfinder, not /wayfinding The persona is the Wayfinder; the invocation should match. Rename the folder and skill name to wayfinder and update the invocation examples, README link, and changeset. "wayfinding" stays only as the activity noun. Co-Authored-By: Claude Opus 4.8 --- .changeset/wayfinding-rename.md | 2 +- skills/in-progress/README.md | 2 +- skills/in-progress/{wayfinding => wayfinder}/SKILL.md | 10 +++++----- 3 files changed, 7 insertions(+), 7 deletions(-) rename skills/in-progress/{wayfinding => wayfinder}/SKILL.md (95%) diff --git a/.changeset/wayfinding-rename.md b/.changeset/wayfinding-rename.md index 50623bc..bed84be 100644 --- a/.changeset/wayfinding-rename.md +++ b/.changeset/wayfinding-rename.md @@ -2,7 +2,7 @@ "mattpocock-skills": minor --- -Rename the **`decision-mapping`** skill to **`wayfinding`**, invoked as `/wayfinding`. +Rename the **`decision-mapping`** skill to **`wayfinder`**, invoked as `/wayfinder`. "Decision map" was jargony and inaccurate — only one of the skill's four ticket types (Grilling) is actually a decision. The skill is reframed around the **Wayfinder**: you chart a route through a foggy problem, resolving investigation tickets one at a time until the way to the goal is clear. This makes one coherent leading-word frame (fog of war / frontier / the map) instead of mixing an invented term on top of it. diff --git a/skills/in-progress/README.md b/skills/in-progress/README.md index 21dd028..495b4c1 100644 --- a/skills/in-progress/README.md +++ b/skills/in-progress/README.md @@ -2,7 +2,7 @@ Skills that are still being developed. They're not ready to ship — expect rough edges, breaking changes, and abandoned experiments. They're excluded from the plugin and the top-level README until they graduate to a stable bucket. -- **[wayfinding](./wayfinding/SKILL.md)** — As the Wayfinder, chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. User-invoked. +- **[wayfinder](./wayfinder/SKILL.md)** — As the Wayfinder, chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. User-invoked. - **[loop-me](./loop-me/SKILL.md)** — Grill yourself into implementable workflow specs over multiple sessions, using the current directory as a stateful workspace. User-invoked. - **[wizard](./wizard/SKILL.md)** — Generate an interactive bash wizard that walks a human through a manual procedure (setup, a one-off migration, a state transition) — opening URLs, capturing values, writing `.env` and GitHub Actions secrets. User-invoked. - **[writing-beats](./writing-beats/SKILL.md)** — Shape an article as a journey of beats, choose-your-own-adventure style. Pick a starting beat, write only that beat, then pivot to the next, until the article reaches a natural end. diff --git a/skills/in-progress/wayfinding/SKILL.md b/skills/in-progress/wayfinder/SKILL.md similarity index 95% rename from skills/in-progress/wayfinding/SKILL.md rename to skills/in-progress/wayfinder/SKILL.md index 6b1e5bc..fd01a3c 100644 --- a/skills/in-progress/wayfinding/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -1,5 +1,5 @@ --- -name: wayfinding +name: wayfinder description: As the Wayfinder, chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. disable-model-invocation: true --- @@ -91,14 +91,14 @@ End every session by clearing the context and opening one or more fresh sessions > > **One session** — resolves the next unblocked ticket: > ``` -> Invoke /wayfinding with the map at . +> Invoke /wayfinder with the map at . > ``` > > **Parallel** — paste one line per window, up to all 3: > ``` -> Invoke /wayfinding with the map at , ticket auth-strategy. -> Invoke /wayfinding with the map at , ticket cache-layer. -> Invoke /wayfinding with the map at , ticket rate-limits. +> Invoke /wayfinder with the map at , ticket auth-strategy. +> Invoke /wayfinder with the map at , ticket cache-layer. +> Invoke /wayfinder with the map at , ticket rate-limits. > ``` **No open tickets remain.** The fog is pushed back far enough that the way to the goal is clear — the map is done. (The initial grilling may also surface no fog at all, in which case there was never a map to chart.) Recommend implementing directly, or using `/to-prd` to schedule a multi-session implementation. From de7f02e2b1d01e76ae1be2af79175beecd60a8fe Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Wed, 1 Jul 2026 19:51:05 +0100 Subject: [PATCH 03/13] refactor(wayfinder): neutralize intro, drop persona framing Remove the "You are the Wayfinder" second-person persona from the intro, description, and README so the agent doesn't adopt a persona. Keep the leading-word frame (chart / fog / frontier / map); wayfinder stays only as the skill/invocation name. Co-Authored-By: Claude Opus 4.8 --- .changeset/wayfinding-rename.md | 2 +- skills/in-progress/README.md | 2 +- skills/in-progress/wayfinder/SKILL.md | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.changeset/wayfinding-rename.md b/.changeset/wayfinding-rename.md index bed84be..c6c0d7b 100644 --- a/.changeset/wayfinding-rename.md +++ b/.changeset/wayfinding-rename.md @@ -4,6 +4,6 @@ Rename the **`decision-mapping`** skill to **`wayfinder`**, invoked as `/wayfinder`. -"Decision map" was jargony and inaccurate — only one of the skill's four ticket types (Grilling) is actually a decision. The skill is reframed around the **Wayfinder**: you chart a route through a foggy problem, resolving investigation tickets one at a time until the way to the goal is clear. This makes one coherent leading-word frame (fog of war / frontier / the map) instead of mixing an invented term on top of it. +"Decision map" was jargony and inaccurate — only one of the skill's four ticket types (Grilling) is actually a decision. The reframe charts a route through a foggy problem, resolving investigation tickets one at a time until the way to the goal is clear. This makes one coherent leading-word frame (fog of war / frontier / the map) instead of mixing an invented term on top of it. Also a pruning pass: unified `node`→`ticket`, bound "the frontier" to the unblocked tickets, dropped the duplicated "one question at a time" (owned by `/grilling`), and trimmed intro no-ops. diff --git a/skills/in-progress/README.md b/skills/in-progress/README.md index 495b4c1..b283f5b 100644 --- a/skills/in-progress/README.md +++ b/skills/in-progress/README.md @@ -2,7 +2,7 @@ Skills that are still being developed. They're not ready to ship — expect rough edges, breaking changes, and abandoned experiments. They're excluded from the plugin and the top-level README until they graduate to a stable bucket. -- **[wayfinder](./wayfinder/SKILL.md)** — As the Wayfinder, chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. User-invoked. +- **[wayfinder](./wayfinder/SKILL.md)** — Chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. User-invoked. - **[loop-me](./loop-me/SKILL.md)** — Grill yourself into implementable workflow specs over multiple sessions, using the current directory as a stateful workspace. User-invoked. - **[wizard](./wizard/SKILL.md)** — Generate an interactive bash wizard that walks a human through a manual procedure (setup, a one-off migration, a state transition) — opening URLs, capturing values, writing `.env` and GitHub Actions secrets. User-invoked. - **[writing-beats](./writing-beats/SKILL.md)** — Shape an article as a journey of beats, choose-your-own-adventure style. Pick a starting beat, write only that beat, then pivot to the next, until the article reaches a natural end. diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index fd01a3c..3492c97 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -1,10 +1,10 @@ --- name: wayfinder -description: As the Wayfinder, chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. +description: Chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. disable-model-invocation: true --- -You are the **Wayfinder**. A loose idea has arrived — too big for one agent session, and wrapped in fog: you can't yet see the route from here to a plan. Chart it: stand up a map, then work its tickets one at a time. The map is domain-agnostic — engineering work, course content, whatever fits the shape. +A loose idea has arrived — too big for one agent session, and wrapped in fog: the route from here to a plan isn't visible yet. This skill charts it: stand up a map, then work its tickets one at a time until the way to the goal is clear. The map is domain-agnostic — engineering work, course content, whatever fits the shape. ## The Map From 5c3c49df1a6c24019ea56690088810961cd3370c Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Wed, 1 Jul 2026 20:28:48 +0100 Subject: [PATCH 04/13] feat(wayfinder): make the map collaborative via the issue tracker MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Move the map off a local Markdown file and onto the repo's configured issue tracker. The map is a single wayfinder:map issue whose tickets are its child issues — one shared URL the team can watch and comment on. Blocking, claiming (wayfinder:claimed), and the frontier query use native tracker semantics; a session loads the map at low resolution (Notes + per-closed-ticket context pointers + Fog prose) and zooms into tickets on demand. Per-tracker mechanics live behind the docs/agents/issue-tracker.md pointer, so setup-matt-pocock-skills seeds a "Wayfinding operations" section for GitHub, GitLab, and local-markdown; absent that doc, Wayfinder defaults to local-markdown. Co-Authored-By: Claude Opus 4.8 (1M context) --- .changeset/wayfinder-collaborative-tracker.md | 9 ++ .../issue-tracker-github.md | 11 +++ .../issue-tracker-gitlab.md | 11 +++ .../issue-tracker-local.md | 11 +++ skills/in-progress/wayfinder/SKILL.md | 88 ++++++++----------- 5 files changed, 79 insertions(+), 51 deletions(-) create mode 100644 .changeset/wayfinder-collaborative-tracker.md diff --git a/.changeset/wayfinder-collaborative-tracker.md b/.changeset/wayfinder-collaborative-tracker.md new file mode 100644 index 0000000..df96ae0 --- /dev/null +++ b/.changeset/wayfinder-collaborative-tracker.md @@ -0,0 +1,9 @@ +--- +"mattpocock-skills": minor +--- + +Make **`wayfinder`** collaborative by moving the map off a local Markdown file and onto the repo's issue tracker. + +The map is now a single `wayfinder:map` issue whose tickets are its child issues — one shared URL the whole team can watch and comment on. Blocking, claiming (`wayfinder:claimed`), and the frontier query all use native tracker semantics, so a session loads the map at low resolution (Notes + one context pointer per closed ticket + Fog prose) and zooms into individual tickets on demand, instead of loading the whole map every time. + +Wayfinder stays tracker-agnostic: the per-tracker mechanics live behind a pointer in `docs/agents/issue-tracker.md`, so `setup-matt-pocock-skills` now seeds a "Wayfinding operations" section for GitHub, GitLab, and local-markdown. Absent that doc, Wayfinder defaults to local-markdown. diff --git a/skills/engineering/setup-matt-pocock-skills/issue-tracker-github.md b/skills/engineering/setup-matt-pocock-skills/issue-tracker-github.md index 53ad3ec..bd4baa5 100644 --- a/skills/engineering/setup-matt-pocock-skills/issue-tracker-github.md +++ b/skills/engineering/setup-matt-pocock-skills/issue-tracker-github.md @@ -32,3 +32,14 @@ Create a GitHub issue. ## When a skill says "fetch the relevant ticket" Run `gh issue view --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 #` at the top of the child body. Labels: `wayfinder:` (`research`/`prototype`/`grilling`/`task`), plus `wayfinder:claimed` once claimed. +- **Blocking**: native issue relationships where available; otherwise a `Blocked by: #, #` line at the top of the child body. A ticket is unblocked when every issue it lists 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 `Blocked by` issue or the `wayfinder:claimed` label; first in map order wins. +- **Claim**: `gh issue edit --add-label wayfinder:claimed` — the session's first write. +- **Resolve**: `gh issue comment --body ""`, then `gh issue close `, then append a context pointer (gist + link) to the map's Decisions-so-far. diff --git a/skills/engineering/setup-matt-pocock-skills/issue-tracker-gitlab.md b/skills/engineering/setup-matt-pocock-skills/issue-tracker-gitlab.md index 2c6cf58..792f5d6 100644 --- a/skills/engineering/setup-matt-pocock-skills/issue-tracker-gitlab.md +++ b/skills/engineering/setup-matt-pocock-skills/issue-tracker-gitlab.md @@ -33,3 +33,14 @@ Create a GitLab issue. ## When a skill says "fetch the relevant ticket" Run `glab issue view --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 #` at the top of its description and labels `wayfinder:` (`research`/`prototype`/`grilling`/`task`), plus `wayfinder:claimed` once claimed. +- **Blocking**: GitLab's native `/blocked_by #` quick action (or a `Blocked by: #, #` line in the description as fallback). A ticket is unblocked when every issue it lists is closed. +- **Frontier query**: `glab issue list -F json` scoped to the map's children, drop any with an open blocker or the `wayfinder:claimed` label; first in map order wins. +- **Claim**: `glab issue update --label wayfinder:claimed` — the session's first write. +- **Resolve**: `glab issue note --message ""`, then `glab issue close `, then append a context pointer (gist + link) to the map's Decisions-so-far. diff --git a/skills/engineering/setup-matt-pocock-skills/issue-tracker-local.md b/skills/engineering/setup-matt-pocock-skills/issue-tracker-local.md index a2f08fb..5f09fde 100644 --- a/skills/engineering/setup-matt-pocock-skills/issue-tracker-local.md +++ b/skills/engineering/setup-matt-pocock-skills/issue-tracker-local.md @@ -17,3 +17,14 @@ Create a new file under `.scratch//` (creating the directory if ne ## 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//map.md` — the Notes / Decisions-so-far / Fog body. +- **Child ticket**: `.scratch//issues/NN-.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//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`. diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 3492c97..0881e39 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -1,59 +1,48 @@ --- name: wayfinder -description: Chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear. +description: Chart a route through a foggy problem — turn a loose idea into a shared map of investigation tickets on your issue tracker, and resolve them one at a time until the way to the goal is clear. disable-model-invocation: true --- -A loose idea has arrived — too big for one agent session, and wrapped in fog: the route from here to a plan isn't visible yet. This skill charts it: stand up a map, then work its tickets one at a time until the way to the goal is clear. The map is domain-agnostic — engineering work, course content, whatever fits the shape. +A loose idea has arrived — too big for one agent session, and wrapped in fog: the route from here to a plan isn't visible yet. This skill charts it as a **shared map** on the repo's issue tracker, then works its tickets one at a time until the way to the goal is clear. Because the map lives on the tracker, multiple people can watch it, comment on tickets, and pick up the frontier — the chart is a shared artifact, not a private file. The map is domain-agnostic — engineering work, course content, whatever fits the shape. ## The Map -The map is a single compact Markdown file, one per wayfinding effort, git-tracked alongside the project. It is the canonical artifact — the **whole map is loaded as context into every session**, so it must stay compact. +The map is a single issue on this repo's issue tracker: one shared object — one URL — that the whole team reads and comments on. It is labelled `wayfinder:map`, and it is the canonical artifact. Its tickets are child issues of the map. -Assets created during tickets should be linked to from the map, not duplicated within it. +**Where the map, its child tickets, blocking, and frontier queries physically live is tracker-specific.** Consult `docs/agents/issue-tracker.md` (the "Wayfinding operations" section) for how *this* repo expresses them. If that doc is absent, default to the local-markdown tracker. -### Structure +### The map body -Entries ("tickets"), each its own section keyed by a short dash-case slug that -reads as a mini-title (e.g. `relational-db`, `auth-strategy`, `cache-layer`) — -terse enough to stay token-efficient, and unique within the map. +Three compact zones — this is the whole map at low resolution, loaded once per session: -```markdown -## relational-db: Relational Or Non-Relational Database? +- **Notes** — the domain, any skills every session should consult, and freeform standing preferences for this effort. +- **Decisions so far** — one *context pointer* per closed ticket: a short gist plus a link to the closed issue where the full answer lives. Enough to judge relevance; zoom through the link for detail. +- **Fog** — terse prose naming what's dimly visible beyond the frontier. Not tickets yet. -Blocked by: , -Status: open | in-progress | resolved -Type: Research | Prototype | Grilling | Task +Open tickets are **not** listed here — they are open child issues, found by query. -### Question +### Tickets - +Each ticket is a **child issue** of the map; the tracker's issue id is its identity. Its body holds the **question**. Two label families: -### Answer +- `wayfinder:` — one of `research`, `prototype`, `grilling`, `task` (see [Ticket Types](#ticket-types)). +- `wayfinder:claimed` — a session sets this **first**, before any work, so concurrent sessions skip it. - -``` +Blocking uses the tracker's native semantics. A ticket is **unblocked** when every ticket blocking it is closed. The **frontier** is the open, unblocked, unclaimed children — the edge of the known. -The slug is the canonical id, used in every `Blocked by` edge and prose -reference; the title after the colon is optional. A ticket -is **unblocked** when every ticket in its `Blocked by` list is `resolved`. A -session **claims** its ticket by setting `Status: in-progress` and saving the map -before any work, so concurrent sessions skip it. - -Each ticket must be sized to one 100K token agent session. +Each ticket must be sized to one 100K token agent session. Assets created while resolving a ticket are linked from the issue, not pasted into it. ## Ticket Types -There are four types of tickets: - -- **Research**: Reading documentation, third-party API's, or local resources like knowledge bases. Creates a markdown summary as an asset. Use this when knowledge outside the current working directory is required. -- **Prototype**: Raise the fidelity of the discussion by making a cheap, rough, concrete artifact to react to — an outline, a rough take, a stub, or UI/logic code via the /prototype skill. Creates the prototype as an asset. Use this when "how should it look" or "how should it behave" is the key question. +- **Research**: Reading documentation, third-party APIs, or local resources like knowledge bases. Creates a markdown summary as a linked asset. Use when knowledge outside the current working directory is required. +- **Prototype**: Raise the fidelity of the discussion by making a cheap, rough, concrete artifact to react to — an outline, a rough take, a stub, or UI/logic code via the /prototype skill. Links the prototype as an asset. Use when "how should it look" or "how should it behave" is the key question. - **Grilling**: Conversation with the agent. Uses the /grilling and /domain-modeling skills. Asks one question at a time. The default case. -- **Task**: Literal manual work that must be done before the discussion can move forward — nothing to decide, prototype, or research. Moving data from one place to another, signing up for a third-party service, provisioning access. The agent automates it where it can; otherwise it hands the human a precise checklist to do by hand. Resolved when the work is done; the answer records what was done and any resulting facts (credentials location, new URLs, row counts) later tickets depend on. +- **Task**: Literal manual work that must be done before the discussion can move forward — nothing to decide, prototype, or research. Moving data, signing up for a service, provisioning access. The agent automates it where it can; otherwise it hands the human a precise checklist. Resolved when the work is done; the answer records what was done and any resulting facts (credentials location, new URLs, row counts) later tickets depend on. ## Fog of war -The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. The frontier is the unblocked tickets at the edge of the known; resolve them to push it forward. Push back the fog of war one ticket at a time, until the way to the goal is clear and no tickets remain. +The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. What is dimly visible but not yet actionable lives as **Fog** prose in the map body, never as speculative tickets; only the frontier becomes real issues. The frontier is the unblocked tickets at the edge of the known; resolve them to push it forward, graduating fog into fresh tickets as it comes into focus. Push back the fog of war one ticket at a time, until the way to the goal is clear and no tickets remain. ## Invocation @@ -64,45 +53,42 @@ Two branches. Either way, **every session ends with a [Handoff](#handoff)** — User invokes with a loose idea. 1. Run a `/grilling` and `/domain-modeling` session to surface the open decisions. -2. Write a new map — mostly fog, frontier identified, trivially-decidable entries resolved inline. -3. Handoff. Charting the map is one session's work; do not also resolve tickets. +2. **Create the map** (label `wayfinder:map`): Notes filled in, Decisions-so-far empty, Fog sketched. +3. **Create the frontier tickets** as child issues of the map — then wire blocking edges in a **second pass** (issues need ids before they can reference each other). +4. Leave everything past the frontier as fog — don't chart what you can't see. +5. Handoff. Charting the map is one session's work; do not also resolve tickets. ### Work through the map -User invokes with a path to an existing map. A ticket slug is **optional** — without one, you pick the next decision, not the user. +User invokes with a map (URL or number). A ticket is **optional** — without one, you pick the next decision, not the user. -1. Load the **whole map** as context. -2. Choose the ticket. If the user named one, use it. Otherwise pick the first `open` ticket in document order that is [unblocked](#structure). [Claim it](#structure): set `Status: in-progress` and save before any work. -3. Resolve it, invoking skills as needed — including any the `## Notes` block names. If in doubt, use `/grilling` and `/domain-modeling`. -4. Record the answer in the ticket's body and set `Status: resolved`. -5. Add newly-discovered tickets with correct `Blocked by` edges. If the decisions made invalidate other parts of the map, update or delete those tickets. +1. Load the **map** — the low-res view (Notes, decision pointers, fog). Not every ticket body. +2. Choose the ticket. If the user named one, use it. Otherwise query the frontier and take the first open, unblocked, unclaimed child in order. **Claim it**: set `wayfinder:claimed` and save before any work. +3. Resolve it — **zoom as needed**: fetch the full body of any related or closed ticket on demand; invoke the skills the `## Notes` block names. If in doubt, use `/grilling` and `/domain-modeling`. +4. Record the resolution: post the answer as a **resolution comment**, **close** the issue, and **append a context pointer** to the map's Decisions-so-far. +5. Add newly-surfaced frontier tickets (create-then-wire); graduate fog that's now actionable. If the decision invalidates other parts of the map, update or delete those tickets. 6. Handoff. -The user may run unblocked tickets in parallel, so expect other agents to be editing the map in their own sessions. +The user may run unblocked tickets in parallel, so expect other sessions to be editing the tracker concurrently. ## Handoff End every session by clearing the context and opening one or more fresh sessions. Close with a **Next steps** block the user can copy-paste. Two cases: -**Open tickets remain.** List the currently-unblocked tickets, then give two copy-paste options: a bare command for one session (you pick the next ticket), and one pinned command per unblocked ticket for running them in parallel. Paste one line per fresh window — opening one, some, or all of them. +**Open tickets remain.** Query the map for the currently-unblocked children, then give two copy-paste options: a bare command for one session (you pick the next ticket), and one pinned command per unblocked ticket for running them in parallel. Paste one line per fresh window — opening one, some, or all of them. -> **Next steps** — 3 tickets unblocked: `auth-strategy`, `cache-layer`, `rate-limits`. -> Clear the context, then open fresh sessions. +> **Next steps** — 3 tickets unblocked. Clear the context, then open fresh sessions. > > **One session** — resolves the next unblocked ticket: > ``` -> Invoke /wayfinder with the map at . +> Invoke /wayfinder with the map . > ``` > > **Parallel** — paste one line per window, up to all 3: > ``` -> Invoke /wayfinder with the map at , ticket auth-strategy. -> Invoke /wayfinder with the map at , ticket cache-layer. -> Invoke /wayfinder with the map at , ticket rate-limits. +> Invoke /wayfinder with the map , ticket . +> Invoke /wayfinder with the map , ticket . +> Invoke /wayfinder with the map , ticket . > ``` **No open tickets remain.** The fog is pushed back far enough that the way to the goal is clear — the map is done. (The initial grilling may also surface no fog at all, in which case there was never a map to chart.) Recommend implementing directly, or using `/to-prd` to schedule a multi-session implementation. - -## Notes - -An optional block declaring the **domain**, any skills every session should `consult`, and freeform standing preferences for this effort. From 1e5074a1e237c9dc6727f84872cdf4f4106458df Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:18:54 +0100 Subject: [PATCH 05/13] =?UTF-8?q?refactor(wayfinder):=20pruning=20pass=20?= =?UTF-8?q?=E2=80=94=20cut=20no-ops=20and=20duplication?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Drop the "shared artifact, not a private file" sentence and the "one URL the whole team reads" restatement (no-ops the agent obeys by default). Fold Chart step 4 into step 3 — "don't chart what you can't see" already lives in the Fog of war section (single source of truth). Co-Authored-By: Claude Opus 4.8 (1M context) --- skills/in-progress/wayfinder/SKILL.md | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 0881e39..7227f12 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -4,11 +4,11 @@ description: Chart a route through a foggy problem — turn a loose idea into a disable-model-invocation: true --- -A loose idea has arrived — too big for one agent session, and wrapped in fog: the route from here to a plan isn't visible yet. This skill charts it as a **shared map** on the repo's issue tracker, then works its tickets one at a time until the way to the goal is clear. Because the map lives on the tracker, multiple people can watch it, comment on tickets, and pick up the frontier — the chart is a shared artifact, not a private file. The map is domain-agnostic — engineering work, course content, whatever fits the shape. +A loose idea has arrived — too big for one agent session, and wrapped in fog: the route from here to a plan isn't visible yet. This skill charts it as a **shared map** on the repo's issue tracker, then works its tickets one at a time until the way to the goal is clear. The map is domain-agnostic — engineering work, course content, whatever fits the shape. ## The Map -The map is a single issue on this repo's issue tracker: one shared object — one URL — that the whole team reads and comments on. It is labelled `wayfinder:map`, and it is the canonical artifact. Its tickets are child issues of the map. +The map is a single issue on this repo's issue tracker, labelled `wayfinder:map` — the canonical artifact. Its tickets are child issues of the map. **Where the map, its child tickets, blocking, and frontier queries physically live is tracker-specific.** Consult `docs/agents/issue-tracker.md` (the "Wayfinding operations" section) for how *this* repo expresses them. If that doc is absent, default to the local-markdown tracker. @@ -54,9 +54,8 @@ User invokes with a loose idea. 1. Run a `/grilling` and `/domain-modeling` session to surface the open decisions. 2. **Create the map** (label `wayfinder:map`): Notes filled in, Decisions-so-far empty, Fog sketched. -3. **Create the frontier tickets** as child issues of the map — then wire blocking edges in a **second pass** (issues need ids before they can reference each other). -4. Leave everything past the frontier as fog — don't chart what you can't see. -5. Handoff. Charting the map is one session's work; do not also resolve tickets. +3. **Create the frontier tickets** as child issues of the map — then wire blocking edges in a **second pass** (issues need ids before they can reference each other). Everything past the frontier stays fog. +4. Handoff. Charting the map is one session's work; do not also resolve tickets. ### Work through the map From e2d606b9fcdd0eae1f92f6c3d1804d3a4557fad7 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:22:47 +0100 Subject: [PATCH 06/13] refactor(wayfinder): aggressive duplication pass Single-source the frontier and fog definitions. The Tickets section owns "frontier"; Fog-of-war owns the loop and terminal condition. Remove the frontier re-definition and fog-nature restatement from Fog-of-war, the duplicated frontier criteria from the work sequence, the repeated "way to the goal is clear" from the intro, the "low resolution" restatement, and the clear-context prose that its own example already shows. Co-Authored-By: Claude Opus 4.8 (1M context) --- skills/in-progress/wayfinder/SKILL.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 7227f12..9d19d54 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -4,7 +4,7 @@ description: Chart a route through a foggy problem — turn a loose idea into a disable-model-invocation: true --- -A loose idea has arrived — too big for one agent session, and wrapped in fog: the route from here to a plan isn't visible yet. This skill charts it as a **shared map** on the repo's issue tracker, then works its tickets one at a time until the way to the goal is clear. The map is domain-agnostic — engineering work, course content, whatever fits the shape. +A loose idea has arrived — too big for one agent session, and wrapped in fog: the route from here to a plan isn't visible yet. This skill charts it as a **shared map** on the repo's issue tracker, then works its tickets one at a time. The map is domain-agnostic — engineering work, course content, whatever fits the shape. ## The Map @@ -42,7 +42,7 @@ Each ticket must be sized to one 100K token agent session. Assets created while ## Fog of war -The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. What is dimly visible but not yet actionable lives as **Fog** prose in the map body, never as speculative tickets; only the frontier becomes real issues. The frontier is the unblocked tickets at the edge of the known; resolve them to push it forward, graduating fog into fresh tickets as it comes into focus. Push back the fog of war one ticket at a time, until the way to the goal is clear and no tickets remain. +The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. Only the frontier becomes real tickets; everything dimmer stays fog until it comes into focus. Resolving a frontier ticket pushes the frontier forward, graduating fog into fresh tickets. Push back the fog of war one ticket at a time, until the way to the goal is clear and no tickets remain. ## Invocation @@ -54,15 +54,15 @@ User invokes with a loose idea. 1. Run a `/grilling` and `/domain-modeling` session to surface the open decisions. 2. **Create the map** (label `wayfinder:map`): Notes filled in, Decisions-so-far empty, Fog sketched. -3. **Create the frontier tickets** as child issues of the map — then wire blocking edges in a **second pass** (issues need ids before they can reference each other). Everything past the frontier stays fog. +3. **Create the frontier tickets** as child issues of the map — then wire blocking edges in a **second pass** (issues need ids before they can reference each other). 4. Handoff. Charting the map is one session's work; do not also resolve tickets. ### Work through the map User invokes with a map (URL or number). A ticket is **optional** — without one, you pick the next decision, not the user. -1. Load the **map** — the low-res view (Notes, decision pointers, fog). Not every ticket body. -2. Choose the ticket. If the user named one, use it. Otherwise query the frontier and take the first open, unblocked, unclaimed child in order. **Claim it**: set `wayfinder:claimed` and save before any work. +1. Load the **map** — the low-res view, not every ticket body. +2. Choose the ticket. If the user named one, use it. Otherwise take the first frontier ticket in order. **Claim it**: set `wayfinder:claimed` and save before any work. 3. Resolve it — **zoom as needed**: fetch the full body of any related or closed ticket on demand; invoke the skills the `## Notes` block names. If in doubt, use `/grilling` and `/domain-modeling`. 4. Record the resolution: post the answer as a **resolution comment**, **close** the issue, and **append a context pointer** to the map's Decisions-so-far. 5. Add newly-surfaced frontier tickets (create-then-wire); graduate fog that's now actionable. If the decision invalidates other parts of the map, update or delete those tickets. @@ -72,7 +72,7 @@ The user may run unblocked tickets in parallel, so expect other sessions to be e ## Handoff -End every session by clearing the context and opening one or more fresh sessions. Close with a **Next steps** block the user can copy-paste. Two cases: +End every session with a **Next steps** block the user can copy-paste. Two cases: **Open tickets remain.** Query the map for the currently-unblocked children, then give two copy-paste options: a bare command for one session (you pick the next ticket), and one pinned command per unblocked ticket for running them in parallel. Paste one line per fresh window — opening one, some, or all of them. From 46be3d60a0fca970f615ccced239803c759335df Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:27:46 +0100 Subject: [PATCH 07/13] feat(wayfinder): add explicit map and ticket body templates Show the map body (Notes / Decisions so far / Fog) and the ticket body (Question) as literal markdown templates instead of describing them in prose, so a charting session reproduces the same shape every run. The template carries the structure; surrounding prose trimmed to avoid restating the zone list. Co-Authored-By: Claude Opus 4.8 (1M context) --- skills/in-progress/wayfinder/SKILL.md | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 9d19d54..2bba5a2 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -14,24 +14,37 @@ The map is a single issue on this repo's issue tracker, labelled `wayfinder:map` ### The map body -Three compact zones — this is the whole map at low resolution, loaded once per session: +The whole map at low resolution, loaded once per session. Open tickets are **not** listed — they are open child issues, found by query. -- **Notes** — the domain, any skills every session should consult, and freeform standing preferences for this effort. -- **Decisions so far** — one *context pointer* per closed ticket: a short gist plus a link to the closed issue where the full answer lives. Enough to judge relevance; zoom through the link for detail. -- **Fog** — terse prose naming what's dimly visible beyond the frontier. Not tickets yet. +```markdown +## Notes + -Open tickets are **not** listed here — they are open child issues, found by query. +## Decisions so far + +- []() — + +## Fog + +``` ### Tickets -Each ticket is a **child issue** of the map; the tracker's issue id is its identity. Its body holds the **question**. Two label families: +Each ticket is a **child issue** of the map; the tracker's issue id is its identity. Its body is the question, sized to one 100K token agent session: + +```markdown +## Question + +``` + +Two label families: - `wayfinder:` — one of `research`, `prototype`, `grilling`, `task` (see [Ticket Types](#ticket-types)). - `wayfinder:claimed` — a session sets this **first**, before any work, so concurrent sessions skip it. Blocking uses the tracker's native semantics. A ticket is **unblocked** when every ticket blocking it is closed. The **frontier** is the open, unblocked, unclaimed children — the edge of the known. -Each ticket must be sized to one 100K token agent session. Assets created while resolving a ticket are linked from the issue, not pasted into it. +The answer isn't part of the body — it's recorded on resolution (see [Work through the map](#work-through-the-map)). Assets created while resolving a ticket are linked from the issue, not pasted in. ## Ticket Types From d49cd08a11923b85f72abb86c72732d66458661c Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:30:26 +0100 Subject: [PATCH 08/13] docs(wayfinder): spell out what goes in the map's Fog section MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Fog-of-war section explained the loop but not the content. Add explicit inclusion/exclusion guidance: dim decisions/investigations coming but not yet specifiable, as rough one-liners — not what's already decided (Decisions so far) or actionable now (a ticket). Co-Authored-By: Claude Opus 4.8 (1M context) --- skills/in-progress/wayfinder/SKILL.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 2bba5a2..15b881c 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -55,7 +55,9 @@ The answer isn't part of the body — it's recorded on resolution (see [Work thr ## Fog of war -The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. Only the frontier becomes real tickets; everything dimmer stays fog until it comes into focus. Resolving a frontier ticket pushes the frontier forward, graduating fog into fresh tickets. Push back the fog of war one ticket at a time, until the way to the goal is clear and no tickets remain. +The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. Only the frontier becomes real tickets; everything dimmer stays fog until it comes into focus. Resolving a frontier ticket pushes the frontier forward, graduating fog into fresh tickets — one ticket at a time, until the way to the goal is clear and no tickets remain. + +The map's **Fog** section is where that dim view is written down: decisions and investigations you can already tell are coming but can't specify yet, because they hang on questions the frontier hasn't answered. Write each as a rough one-liner — the suspected question, the area to revisit later, the risk you're deferring — not a ticket. It doubles as a signpost for collaborators reading where the effort is headed. Keep out what's already decided (that belongs in Decisions so far) and what's actionable now (that becomes a ticket). ## Invocation From 039820a47d06903ea047e459a4409afcb28557b5 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:32:17 +0100 Subject: [PATCH 09/13] refactor(wayfinder): loosen fog length, dedup fog guidance MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Drop the "one-liner" constraint — fog entries can be as loose or full as the view allows. Point the map template's Fog comment at the Fog-of-war section instead of restating it, and remove the duplicated "not a ticket" now that the keep-out clause covers it. Co-Authored-By: Claude Opus 4.8 (1M context) --- skills/in-progress/wayfinder/SKILL.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 15b881c..2c4cef3 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -25,7 +25,7 @@ The whole map at low resolution, loaded once per session. Open tickets are **not - []() — ## Fog - + ``` ### Tickets @@ -57,7 +57,7 @@ The answer isn't part of the body — it's recorded on resolution (see [Work thr The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. Only the frontier becomes real tickets; everything dimmer stays fog until it comes into focus. Resolving a frontier ticket pushes the frontier forward, graduating fog into fresh tickets — one ticket at a time, until the way to the goal is clear and no tickets remain. -The map's **Fog** section is where that dim view is written down: decisions and investigations you can already tell are coming but can't specify yet, because they hang on questions the frontier hasn't answered. Write each as a rough one-liner — the suspected question, the area to revisit later, the risk you're deferring — not a ticket. It doubles as a signpost for collaborators reading where the effort is headed. Keep out what's already decided (that belongs in Decisions so far) and what's actionable now (that becomes a ticket). +The map's **Fog** section is where that dim view is written down: decisions and investigations you can already tell are coming but can't specify yet, because they hang on questions the frontier hasn't answered — the suspected question, the area to revisit later, the risk you're deferring. Write as loosely or as fully as the view allows; it doubles as a signpost for collaborators reading where the effort is headed. Keep out what's already decided (that belongs in Decisions so far) and what's actionable now (that becomes a ticket). ## Invocation From 198efb19583a0167933c1ed4a224ef9a29608f66 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:36:40 +0100 Subject: [PATCH 10/13] refactor(wayfinder): clarify fog-vs-ticket boundary Co-Authored-By: Claude Opus 4.8 --- skills/in-progress/wayfinder/SKILL.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 2c4cef3..e49acef 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -55,9 +55,11 @@ The answer isn't part of the body — it's recorded on resolution (see [Work thr ## Fog of war -The map is _deliberately_ incomplete beyond the frontier — don't chart what you can't yet see. Only the frontier becomes real tickets; everything dimmer stays fog until it comes into focus. Resolving a frontier ticket pushes the frontier forward, graduating fog into fresh tickets — one ticket at a time, until the way to the goal is clear and no tickets remain. +The map is _deliberately_ incomplete: don't chart what you can't yet see. Beyond the tickets lies fog — the dim view of decisions and investigations you can tell are coming but can't yet pin down, because they hang on questions still open. Resolving a ticket clears the fog ahead of it, graduating whatever's now specifiable into fresh tickets — one at a time, until the way to the goal is clear and no tickets remain. -The map's **Fog** section is where that dim view is written down: decisions and investigations you can already tell are coming but can't specify yet, because they hang on questions the frontier hasn't answered — the suspected question, the area to revisit later, the risk you're deferring. Write as loosely or as fully as the view allows; it doubles as a signpost for collaborators reading where the effort is headed. Keep out what's already decided (that belongs in Decisions so far) and what's actionable now (that becomes a ticket). +The map's **Fog** section is where that dim view is written down: the suspected question, the area to revisit later, the risk you're deferring. Write as loosely or as fully as the view allows; it doubles as a signpost for collaborators reading where the effort is headed. + +**Fog or ticket?** The test is whether you can state the question precisely now — _not_ whether you can answer it now. A blocked ticket you can't act on yet is still a ticket, because its question is already sharp; fog is what you can't yet phrase that sharply. So don't pre-slice fog into ticket-sized pieces — it's coarser than a ticket, and one patch may graduate into several tickets, or none, once the frontier reaches it. Fog excludes only what's already decided (that's Decisions so far) and what's already a ticket. ## Invocation @@ -69,7 +71,7 @@ User invokes with a loose idea. 1. Run a `/grilling` and `/domain-modeling` session to surface the open decisions. 2. **Create the map** (label `wayfinder:map`): Notes filled in, Decisions-so-far empty, Fog sketched. -3. **Create the frontier tickets** as child issues of the map — then wire blocking edges in a **second pass** (issues need ids before they can reference each other). +3. **Create the tickets you can specify now** as child issues of the map — then wire blocking edges in a **second pass** (issues need ids before they can reference each other). Wiring sorts them into the frontier and the blocked; everything you can't yet specify stays in the Fog. 4. Handoff. Charting the map is one session's work; do not also resolve tickets. ### Work through the map @@ -80,7 +82,7 @@ User invokes with a map (URL or number). A ticket is **optional** — without on 2. Choose the ticket. If the user named one, use it. Otherwise take the first frontier ticket in order. **Claim it**: set `wayfinder:claimed` and save before any work. 3. Resolve it — **zoom as needed**: fetch the full body of any related or closed ticket on demand; invoke the skills the `## Notes` block names. If in doubt, use `/grilling` and `/domain-modeling`. 4. Record the resolution: post the answer as a **resolution comment**, **close** the issue, and **append a context pointer** to the map's Decisions-so-far. -5. Add newly-surfaced frontier tickets (create-then-wire); graduate fog that's now actionable. If the decision invalidates other parts of the map, update or delete those tickets. +5. Add newly-surfaced tickets (create-then-wire); graduate any fog the answer has made specifiable. If the decision invalidates other parts of the map, update or delete those tickets. 6. Handoff. The user may run unblocked tickets in parallel, so expect other sessions to be editing the tracker concurrently. From 2ba3bd848fb9bd461ec0d2491fe343789877bd13 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:38:48 +0100 Subject: [PATCH 11/13] refactor(wayfinder): fog-vs-ticket test as a list Co-Authored-By: Claude Opus 4.8 --- skills/in-progress/wayfinder/SKILL.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index e49acef..4a210e9 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -59,7 +59,12 @@ The map is _deliberately_ incomplete: don't chart what you can't yet see. Beyond The map's **Fog** section is where that dim view is written down: the suspected question, the area to revisit later, the risk you're deferring. Write as loosely or as fully as the view allows; it doubles as a signpost for collaborators reading where the effort is headed. -**Fog or ticket?** The test is whether you can state the question precisely now — _not_ whether you can answer it now. A blocked ticket you can't act on yet is still a ticket, because its question is already sharp; fog is what you can't yet phrase that sharply. So don't pre-slice fog into ticket-sized pieces — it's coarser than a ticket, and one patch may graduate into several tickets, or none, once the frontier reaches it. Fog excludes only what's already decided (that's Decisions so far) and what's already a ticket. +**Fog or ticket?** The test is whether you can state the question precisely now — _not_ whether you can answer it now. + +- **Ticket when** the question is already sharp — even if it's blocked and you can't act on it yet. +- **Fog when** you can't yet phrase it that sharply. Don't pre-slice fog into ticket-sized pieces: it's coarser than a ticket, and one patch may graduate into several tickets, or none, once the frontier reaches it. + +Fog excludes only what's already decided (that's Decisions so far) and what's already a ticket. ## Invocation From 927293589bc009b2ef42db7c04e788baebbe47c7 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:45:58 +0100 Subject: [PATCH 12/13] refactor(wayfinder): make the map an index, not a store MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit State the no-duplication contract up front with a leading word: the map indexes decisions and points at the tickets that hold them; a decision lives in exactly one place — its ticket — so the map only gists and links. Also close a fog-vs-ticket duplication: graduating fog into a ticket now clears the graduated patch from the Fog. Co-Authored-By: Claude Opus 4.8 (1M context) --- .changeset/wayfinder-map-index.md | 7 +++++++ skills/in-progress/wayfinder/SKILL.md | 6 ++++-- 2 files changed, 11 insertions(+), 2 deletions(-) create mode 100644 .changeset/wayfinder-map-index.md diff --git a/.changeset/wayfinder-map-index.md b/.changeset/wayfinder-map-index.md new file mode 100644 index 0000000..f026c8d --- /dev/null +++ b/.changeset/wayfinder-map-index.md @@ -0,0 +1,7 @@ +--- +"mattpocock-skills": minor +--- + +Make **`wayfinder`**'s no-duplication contract explicit: the map is an **index**, not a store. + +Adopting "index" as the leading word for the map's role fixes two duplication risks. The map now states up front that a decision lives in exactly one place — its ticket — so it only ever gists and links, never restates the answer (previously this rule was implied inside an HTML comment in the map-body template). And graduating fog into a ticket now clears the graduated patch from the Fog, so a suspected question can't linger in both places at once. diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 4a210e9..0456c4c 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -10,6 +10,8 @@ A loose idea has arrived — too big for one agent session, and wrapped in fog: The map is a single issue on this repo's issue tracker, labelled `wayfinder:map` — the canonical artifact. Its tickets are child issues of the map. +The map is an **index**, not a store. It lists the decisions made and points at the tickets that hold their detail; a decision lives in exactly one place — its ticket — so the map never restates it, only gists it and links. + **Where the map, its child tickets, blocking, and frontier queries physically live is tracker-specific.** Consult `docs/agents/issue-tracker.md` (the "Wayfinding operations" section) for how *this* repo expresses them. If that doc is absent, default to the local-markdown tracker. ### The map body @@ -21,7 +23,7 @@ The whole map at low resolution, loaded once per session. Open tickets are **not ## Decisions so far - + - []() — ## Fog @@ -87,7 +89,7 @@ User invokes with a map (URL or number). A ticket is **optional** — without on 2. Choose the ticket. If the user named one, use it. Otherwise take the first frontier ticket in order. **Claim it**: set `wayfinder:claimed` and save before any work. 3. Resolve it — **zoom as needed**: fetch the full body of any related or closed ticket on demand; invoke the skills the `## Notes` block names. If in doubt, use `/grilling` and `/domain-modeling`. 4. Record the resolution: post the answer as a **resolution comment**, **close** the issue, and **append a context pointer** to the map's Decisions-so-far. -5. Add newly-surfaced tickets (create-then-wire); graduate any fog the answer has made specifiable. If the decision invalidates other parts of the map, update or delete those tickets. +5. Add newly-surfaced tickets (create-then-wire); graduate any fog the answer has made specifiable, clearing each graduated patch from the Fog so it lives only as its new ticket. If the decision invalidates other parts of the map, update or delete those tickets. 6. Handoff. The user may run unblocked tickets in parallel, so expect other sessions to be editing the tracker concurrently. From cb51924fbefc450405ff3ac63f6e4806d6a9d9d7 Mon Sep 17 00:00:00 2001 From: Matt Pocock Date: Thu, 2 Jul 2026 09:51:01 +0100 Subject: [PATCH 13/13] fix(wayfinder): rename "Two branches" to "Two modes" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The word "branch" in the Invocation section primes git-aware agents (Sonnet, GPT-5.5) to create git branches when running the skill, littering established environments with per-session branches that then have to be merged. Nothing here refers to git — the two "branches" are the two invocation modes (chart the map / work through it). Rename to "modes" to remove the false cue. Fixes #418 Co-Authored-By: Claude Opus 4.8 (1M context) --- skills/in-progress/wayfinder/SKILL.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/skills/in-progress/wayfinder/SKILL.md b/skills/in-progress/wayfinder/SKILL.md index 0456c4c..158a731 100644 --- a/skills/in-progress/wayfinder/SKILL.md +++ b/skills/in-progress/wayfinder/SKILL.md @@ -70,7 +70,7 @@ Fog excludes only what's already decided (that's Decisions so far) and what's al ## Invocation -Two branches. Either way, **every session ends with a [Handoff](#handoff)** — never resolve more than one ticket per session. +Two modes. Either way, **every session ends with a [Handoff](#handoff)** — never resolve more than one ticket per session. ### Chart the map