@agentshouse/kit 0.1.0-alpha.25 → 0.1.0-alpha.26

package/README.md

@@ -4,12 +4,15 @@ House Kit is a public package repository. Product development is planned and
 coordinated in the [Agents House repository](https://github.com/trof3039/agents.house);
 this repository contains only the package source and its operator documentation.
 
+The Skill set Kit installs is Matt Pocock's
+[`mattpocock/skills`](https://github.com/mattpocock/skills); thank you, Matt.
+
 ## Connect a Linux computer
 
 On Linux `amd64` or `arm64`, run the published, versioned bootstrap once:
 
 ```sh
-bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.25/connect-linux.sh)
+bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.26/connect-linux.sh)
 ```
 
 The bootstrap first establishes Docker Engine from what it observes on the
@@ -40,7 +43,10 @@ and starts the container with Docker's `unless-stopped` lifecycle. Pass
 `--workspace /absolute/path` for one other workspace root or `--manual` for
 the existing URL and one-time-code login route. `--house <origin>` selects
 another House and is retained in Kit home. A repeated invocation reuses the
-same container, credential and Environment.
+same container, credential and Environment. Every invocation that is not a
+forwarded command also sets `skills` in Kit's configuration: `--no-skills`
+declines [the Skill set](#the-skill-set) and an invocation without it accepts
+the set again.
 
 Running a newer release's bootstrap the same way is the only update. When the
 installed container runs another image, the bootstrap pulls this release's
@@ -227,7 +233,8 @@ never printed by Kit.
       "settings": "/home/ada/.claude/settings.json"
     }
   ],
-  "host": null
+  "host": null,
+  "skills": true
 }
 ```
 
@@ -254,6 +261,11 @@ service owns the command that produces it.
 no capacity; the section is required like the others, so a host is measured only
 where the Environment owner says so.
 
+`skills` is this Environment's choice of [the Skill set](#the-skill-set):
+`true` accepts it and `false` declines it. A configuration that omits it
+accepts the set. The bootstrap writes it on every invocation that is not a
+forwarded command.
+
 `clients` is the local Agent client catalogue and never leaves the installation.
 Each entry names one client whose lifecycle hook configuration this Kit
 reconciles: `kind` is `claude-code`, the one client this Kit installs a hook
@@ -395,7 +407,8 @@ them all, and no instance can read another's provider credential.
     }
   ],
   "clients": [],
-  "host": null
+  "host": null,
+  "skills": false
 }
 ```
 
@@ -653,27 +666,12 @@ inside `/agents/house` is somebody else's default or an owner's own workspace,
 never this Agent's. Every path that is not this exact equality, one deeper
 inside `/agents/house` included, must
 already exist in this Environment as a directory the installation can enter;
-Kit never creates or seeds it.
-
-When the Agent's own default directory is absent, Kit builds the starter set in
-a temporary directory beneath the base and renames it into place as one atomic
-step, so a partly seeded directory is never visible at the default path. Two
-concurrent first launches race that rename; the loser discards its temporary
-directory and uses the directory the winner put there, so the pair still leaves
-one complete directory and nothing partial. A present default directory -
-including one whose starter files the owner edited or removed - launches
-exactly as it is, and a deleted default directory is recreated with a fresh
-starter set on its next launch.
-
-The starter set is `AGENTS.md` with the single line ``The agents.house `house`
-CLI is available: run `house --help`.``, `CLAUDE.md` as a relative symbolic link to it, `.agents/skills/grilling/`
-vendored from [`mattpocock/skills`](https://github.com/mattpocock/skills)
-`skills/productivity/grilling` at a pinned commit with its MIT license and a
-provenance header naming that commit, and `.claude/skills` as a relative
-symbolic link to `.agents/skills`. Once seeded the files belong to the owner:
-Kit never syncs, refreshes, or restores them, and refreshing the vendored skill
-for new Agents is an ordinary Kit release that never touches an already seeded
-directory.
+Kit never creates it.
+
+When the Agent's own default directory is absent, Kit creates it empty; two
+concurrent first launches create the same directory. A present default
+directory launches exactly as it is, and a deleted one is created empty again
+on its next launch. Kit writes no file into any working directory.
 
 A relative, missing, inaccessible, or non-directory working directory refuses
 with `kit_launch_directory_unavailable` before any provider process starts. Kit falls back to no other location - not the
@@ -681,6 +679,52 @@ base, not `$HOUSE_KIT_HOME`, and not its own current directory - and neither
 connecting an installation nor launching a session moves, copies, overwrites,
 or removes anything a working directory holds.
 
+## The Skill set
+
+The Skill set is every skill the `mattpocock/skills` plugin manifest names at
+one pinned commit but `setup-matt-pocock-skills`, `triage` and `wizard`. Each
+is vendored under `src/skill-set/<name>/` with every file it ships, the
+upstream MIT `LICENSE` and a provenance header in `SKILL.md` naming the commit
+and upstream path. Nothing else is edited but two lines: a
+`disable-model-invocation: true` frontmatter line in `SKILL.md` and an
+`allow_implicit_invocation: false` line in `agents/openai.yaml` are removed, so
+an agent reaches every skill without being told its name.
+
+Kit installs the Skill set once for the Environment, for every Agent whatever
+its working directory, under the home it launches agent CLIs with: each skill
+as the directory `$HOME/.agents/skills/<name>`, which Codex and Grok Build
+read, and a relative symbolic link `$HOME/.claude/skills/<name>` to it, which
+Claude Code reads; when `$HOME/.claude/skills` already resolves to
+`$HOME/.agents/skills`, Claude Code reads the directory there and Kit makes no
+link. In a container that home is Kit home, so the set survives
+container recreation; on a native host it is the host user's home.
+
+`$HOUSE_KIT_HOME/state/skill-set.json` records the names Kit installed and the
+Kit version that installed them, and Kit owns exactly those names: the
+directory and the link of each. At start and on every resident pass, when
+the set is accepted and the record names another version or none, Kit deletes
+every recorded name, installs the current Skill set and rewrites the record. A
+name whose directory or link exists without being recorded is the owner's: Kit
+leaves it untouched and installs nothing under it. Kit never compares, merges
+or restores a file, so an edit to an installed skill is lost at the next
+release and a copy under another name is kept. When `skills` is `false`, Kit
+deletes every recorded name and the record and installs nothing.
+
+After Kit first installs the Skill set, the first Session it launches whose
+Profile ceiling lets it write the owner's How-we-work document
+`/private/library/how-we-work.md` creates it, when it is absent, with the text
+Kit ships in `src/how-we-work.md`, over the Session's own bridge before its
+first prompt is built. Kit then notes in `$HOUSE_KIT_HOME/state/how-we-work`,
+apart from the record, that the document exists, and a present document is
+noted the same way without being touched. Nothing ever creates it again: a
+release, a declined Skill set and a later acceptance leave the note, so an
+owner's edit stands and a deleted document stays deleted. A Session whose
+ceiling cannot write the document launches without it and leaves it for the
+next one; any other refused creation refuses the attempt as
+`kit_how_we_work_unwritable` with House's answer before a prompt is sent. A
+Skill set Kit cannot install or remove refuses the pass as
+`kit_skill_set_unavailable` and names the path.
+
 ## The declared agent CLIs
 
 The Environment owner installs no adapter binary by hand. `kit agents update`
@@ -1708,6 +1752,8 @@ $HOUSE_KIT_HOME/
   state/conversation-originals/<attachment identity>.json
   state/sessions/<tmux session>.json
   state/update-drain
+  state/skill-set.json
+  state/how-we-work
   state/continuations/<run identity>.json
   state/<instance>/credentials/google.json
   state/<instance>/checkpoints/<service>.json

package/bin/connect-linux.sh

@@ -6,6 +6,7 @@ NAME='house-kit'
 HOUSE='https://agents.house'
 WORKSPACE="$HOME/AgentsHouse"
 MANUAL=0
+SKILLS=true
 WORKSPACE_SELECTED=0
 HOUSE_SELECTED=0
 FORWARDING=0
@@ -160,6 +161,10 @@ while (($#)); do
       MANUAL=1
       shift
       ;;
+    --no-skills)
+      SKILLS=false
+      shift
+      ;;
     *) refuse "unknown argument $1" ;;
   esac
 done
@@ -208,6 +213,16 @@ if [[ -f "$KIT_HOME/house" ]]; then
   HOUSE="$BOUND_HOUSE"
 fi
 [[ "$HOUSE" == https://* || "$HOUSE" == http://127.0.0.1:* || "$HOUSE" == http://localhost:* ]] || refuse 'House origin must use HTTPS or local loopback HTTP'
+if ((FORWARDING == 0)); then
+  if [[ ! -f "$KIT_HOME/kit.json" ]]; then
+    printf '{"availability":"intermittent","execution_authority":"allow","migrators":[],"instances":[],"clients":[],"host":null,"skills":%s}\n' "$SKILLS" > "$KIT_HOME/kit.json"
+  elif grep -Eq '"skills"[[:space:]]*:' "$KIT_HOME/kit.json"; then
+    sed -E -i "s/(\"skills\"[[:space:]]*:[[:space:]]*)(true|false)/\\1$SKILLS/" "$KIT_HOME/kit.json" || refuse 'kit.json could not be updated'
+  else
+    sed -E -i "1s/^([[:space:]]*)\\{/\\1{\"skills\":$SKILLS,/" "$KIT_HOME/kit.json" || refuse 'kit.json could not be updated'
+  fi
+  grep -Eq "\"skills\"[[:space:]]*:[[:space:]]*$SKILLS" "$KIT_HOME/kit.json" || refuse 'kit.json could not be updated'
+fi
 DOCKER_RUN=(docker run --rm --network host --user "$(id -u):$(id -g)" --mount "$KIT_HOME_MOUNT" --mount "$WORKSPACE_MOUNT" --env HOME=/kit-home --env HOUSE_KIT_HOME=/kit-home --env HOUSE_KIT_CONTAINER=1 --env "HOUSE_KIT_HOSTNAME=$(hostname)" "$IMAGE")
 
 if docker container inspect "$NAME" >/dev/null 2>&1; then
@@ -271,10 +286,6 @@ fi
 
 docker pull --quiet --platform "linux/$ARCH" "$IMAGE" >/dev/null
 
-if [[ ! -f "$KIT_HOME/kit.json" ]]; then
-  printf '{"availability":"intermittent","execution_authority":"allow","migrators":[],"instances":[],"clients":[],"host":null}\n' > "$KIT_HOME/kit.json"
-fi
-
 if [[ -f "$KIT_HOME/credential" ]]; then
   "${DOCKER_RUN[@]}" credential check
 else

package/bootstrap.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "version": "0.1.0-alpha.25",
+  "version": "0.1.0-alpha.26",
   "hosts": {
     "linux": {
-      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.25/connect-linux.sh)",
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.26/connect-linux.sh)",
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.25/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.26/connect-linux.sh"
       },
       "workspace": {
         "argument": "--workspace",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.1.0-alpha.25",
+  "version": "0.1.0-alpha.26",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/adapter-mcp.js

@@ -1,12 +1,15 @@
+import { readFileSync } from "node:fs";
 import {
   COMMAND_ADAPTER_INITIALIZE_TIMEOUT_MS,
   HOW_WE_WORK_PATH,
   MCP_PROTOCOL_VERSION,
   SHELL_RENDER,
 } from "./contract.js";
-import { answerText, bridgeCall } from "./mcp.js";
+import { answerText, bridgeCall, editRefusal } from "./mcp.js";
 import { KitRefusal } from "./refusal.js";
 
+const HOW_WE_WORK_TEXT = readFileSync(new URL("how-we-work.md", import.meta.url), "utf8");
+
 function readableDiscovery(discovery) {
   const identity = discovery?._meta?.["io.modelcontextprotocol/serverInfo"];
   return Array.isArray(discovery?.supportedVersions) &&
@@ -84,3 +87,22 @@ export async function commandHouseHowWeWork(bridge) {
   } while (cursor !== null);
   return pages.join("\n");
 }
+
+export async function commandHouseCreateHowWeWork(bridge) {
+  const frame = await bridgeCall(bridge, {
+    method: "tools/call",
+    params: {
+      name: "edit",
+      arguments: { changes: [{ op: "create", path: HOW_WE_WORK_PATH, content: HOW_WE_WORK_TEXT }] },
+    },
+  });
+  if (frame.error !== undefined) {
+    throw new KitRefusal("kit_how_we_work_unwritable", frame.error.message ?? null);
+  }
+  if (frame.result?.isError !== true) return true;
+  const text = answerText(frame.result);
+  const { code, conflicts } = editRefusal(text);
+  if (code === "room_not_found" || code === "operation_denied") return false;
+  if (code === "edit_conflict" && conflicts?.some((conflict) => conflict.code === "path_exists")) return true;
+  throw new KitRefusal("kit_how_we_work_unwritable", text);
+}

package/src/bridge.js

@@ -228,6 +228,10 @@ export async function openBridge(options) {
       else void Promise.resolve(reported).finally(() => state.interrupts.delete(frame.interrupt));
       return;
     }
+    if (frame.type === "how_we_work") {
+      void options.howWeWork?.();
+      return;
+    }
     if (frame.type === "turn_ended") {
       state.stop = {
         providerContinuation: frame.provider_continuation === true,

package/src/configuration.js

@@ -388,6 +388,7 @@ export function parseConfiguration(document) {
       "migrators",
       "clients",
       "host",
+      "skills",
     ],
     "configuration",
   );
@@ -397,6 +398,8 @@ export function parseConfiguration(document) {
   if (!EXECUTION_AUTHORITIES.includes(declared.execution_authority)) {
     refuse("execution_authority");
   }
+  const skills = declared.skills === undefined ? true : declared.skills;
+  if (typeof skills !== "boolean") refuse("skills");
   if (!Array.isArray(declared.instances)) refuse("instances");
   if (!Array.isArray(declared.migrators)) refuse("migrators");
   const instances = declared.instances.map((instance, position) =>
@@ -428,6 +431,7 @@ export function parseConfiguration(document) {
     migrators,
     clients,
     host: hostOf(declared.host, "host"),
+    skills,
   };
 }
 

package/src/directory.js

@@ -1,10 +1,8 @@
 import { constants } from "node:fs";
-import { access, mkdir, realpath, rename, rm, stat } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { access, mkdir, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { LAUNCH_DIRECTORY_BASE } from "./contract.js";
 import { KitRefusal } from "./refusal.js";
-import { seedStarterSet } from "./starter-set.js";
 
 export function launchBase(dependencies = {}) {
   return dependencies.launchBase ?? LAUNCH_DIRECTORY_BASE;
@@ -39,25 +37,9 @@ function unavailable(path, cause) {
   return new KitRefusal("kit_launch_directory_unavailable", `${path} ${cause}`);
 }
 
-async function isDirectory(path) {
-  try {
-    return (await stat(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-async function seedDefaultDirectory(selected, base, path) {
-  const staging = join(base, `.${randomUUID()}.staging`);
-  try {
-    await seedStarterSet(staging);
-    await rename(staging, path);
-  } catch (error) {
-    await rm(staging, { recursive: true, force: true }).catch(() => undefined);
-    if (!(await isDirectory(path))) {
-      throw unavailable(selected, `could not be prepared (${error.code ?? "unknown"})`);
-    }
-  }
+async function createDefaultDirectory(selected, path) {
+  const refused = await made(path);
+  if (refused !== null) throw unavailable(selected, `could not be created (${refused})`);
 }
 
 function within(base, selected) {
@@ -73,9 +55,7 @@ export async function readyLaunchDirectory(selected, base, agentId = null, optio
   if (options.container && !within(resolve(base), path)) {
     throw unavailable(selected, `resolves outside ${base}`);
   }
-  if (path === defaultDirectory(base, agentId) && !(await isDirectory(path))) {
-    await seedDefaultDirectory(selected, base, path);
-  }
+  if (path === defaultDirectory(base, agentId)) await createDefaultDirectory(selected, path);
   let described;
   try {
     described = await stat(path);

package/src/how-we-work.md

@@ -0,0 +1,25 @@
+# How we work
+
+A Room is where information people share is kept; it is not the place for
+private information. Work goes into the Room it belongs to, or the First Room
+when none is named. Read and write Rooms with the `house` CLI.
+
+The skills are already set up; never run `setup-matt-pocock-skills`.
+
+## Where skill output goes
+
+- Glossary (`CONTEXT.md`): `library/glossary.md`
+- Decisions (ADRs): `library/decisions/NNNN-<slug>.md`
+- Plan (spec): `library/projects/<name>/plan.md`
+- Tasks (tickets): `library/projects/<name>/tasks/NN-<slug>.md`, with a
+  `Status:` line (`needs-triage`, `needs-info`, `ready-for-agent`,
+  `ready-for-human`, `wontfix`), a `Blocked by:` line and comments under
+  `## Comments`
+- Map (Wayfinding): `library/projects/<name>/map.md`, its tasks under
+  `tasks/` with `Type:`, `Status: claimed|resolved` and `Blocked by:` lines
+- Research: `library/research/<slug>.md`
+- Questionnaires: `library/questionnaires/<slug>.md`
+- Learning: `library/learning/<topic>/`
+- Files a person should open, such as HTML pages, are uploaded to the Room and
+  linked from the document they belong to; a prototype is one HTML file with
+  every variant on one page.

package/src/launcher.js

@@ -1,5 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { commandHouseHowWeWork, commandHouseInstructions } from "./adapter-mcp.js";
+import {
+  commandHouseCreateHowWeWork,
+  commandHouseHowWeWork,
+  commandHouseInstructions,
+} from "./adapter-mcp.js";
 import {
   compiledContract,
   initializeCommandAdapter,
@@ -129,8 +133,11 @@ async function configureSession(acp, contract, sessionId, adapter) {
   }
 }
 
-async function sessionOpening(bridge, baseInstructions) {
-  const parts = [HOUSE_CLI_LINE, baseInstructions, await commandHouseHowWeWork(bridge)];
+async function sessionOpening(channel, bridge, start) {
+  if (start.create_how_we_work === true && (await commandHouseCreateHowWeWork(bridge))) {
+    channel.send({ type: "how_we_work" });
+  }
+  const parts = [HOUSE_CLI_LINE, start.base_instructions, await commandHouseHowWeWork(bridge)];
   return [{ type: "text", text: parts.filter((part) => part.trim() !== "").join("\n\n") }];
 }
 
@@ -185,7 +192,7 @@ async function runTurn(channel, start, bridge, turn) {
     const instructions = await commandHouseInstructions(bridge);
     let providerSessionId = start.provider_session ?? null;
     const opening =
-      providerSessionId === null ? await sessionOpening(bridge, start.base_instructions) : [];
+      providerSessionId === null ? await sessionOpening(channel, bridge, start) : [];
     const setup = { cwd: start.working_directory, mcpServers: [] };
     if (providerSessionId === null) {
       providerSessionId = openedSession(await acp.request("session/new", setup));

package/src/mcp.js

@@ -82,3 +82,8 @@ export function answerYaml(text) {
     return null;
   }
 }
+
+export function editRefusal(text) {
+  const conflicts = answerYaml(text.slice(text.indexOf("\n") + 1))?.conflicts;
+  return { code: text.split(":")[0].trim(), conflicts: Array.isArray(conflicts) ? conflicts : null };
+}

package/src/skill-set/ask-matt/PHASE-BOUNDARIES.md

@@ -0,0 +1,55 @@
+# Phase boundaries
+
+A **phase** is a chunk of work inside a session: the grilling, the implementation, the QA. The definition is fuzzy on purpose: a phase ends when you think *"ok, we're done with that"*.
+
+The **phase boundary** is the gap between two phases, and it is the only place this decision belongs. Mid-phase there is no decision to make: continue, or split the work that's left into subagents. Compacting mid-phase makes the agent lose the thread.
+
+## The five options
+
+| Option       | What it does                                                    |
+| ------------ | --------------------------------------------------------------- |
+| **Continue** | Stay in the session. No context switch at all.                    |
+| **`/clear`** | Empty the context window and start from nothing.                  |
+| **`/handoff`** | Write a portable markdown file and seed a session anywhere with it. |
+| **Subagent** | Send the task to its own context window and get a report back.     |
+| **`/compact`** | Compress this context and seed a fresh session with the summary.  |
+
+## The tree
+
+Work top to bottom at the boundary. The first **yes** wins.
+
+**1. Can you continue in this session?** Two things make the answer yes: the next phase needs this phase as a **primary source**, or you have enough [smart zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone) left (~150k tokens) for the next phase to fit. Grilling → implementation is the standard yes: the implementation wants the reasoning verbatim, not a summary of it. Continue costs nothing and loses nothing, so rule it out before anything else.
+
+**2. Is the context irrelevant to what comes next?** Is everything in this session (the exploration, the decisions, the dead ends) disposable? If so, **`/clear`**. It is the cheapest move on the board: it takes no time and hands back the whole window. `/clear` also isn't terminal: the old session stays resumable.
+
+The cost of getting this wrong is one-way. Clear a *relevant* context and you lose the **why** behind what you built, and no amount of reading the diff back gets it returned.
+
+**3. Do you need to hand off?** `/handoff` is narrow. You need it only when you are:
+
+- swapping to a **new harness** (Claude → Codex),
+- moving to a **new directory** or repo,
+- sending the work to a **colleague**,
+- or forking a side task you found **mid-phase** without derailing what you're doing.
+
+That list is the whole clause. What `/handoff` buys is **portability**: a file that travels. If nothing is travelling, you don't need it.
+
+**4. Can the task be done AFK?** Is it scoped tightly enough to run with you away from the keyboard, no steering? Then send it to a **subagent** and leave this session untouched. Automated review is the standard case: the agent reads the diff and reports, and you aren't needed while it does.
+
+**5. Otherwise, `/compact`.** Relevant context, same harness, same directory, and you need to stay in the loop: this is where the tree lands, and it lands here often. Pass it an instruction (`/compact we're going to QA this area`) so the summary keeps what the next phase needs.
+
+`/compact` is the **default, not the first reach**. It sits at the bottom because the four questions above it are all cheaper or more precise. The failure mode when people start here is a fresh session that is confidently wrong about a decision the summary flattened.
+
+## Primary and secondary sources
+
+Every move except **Continue** turns a **primary source** into a **secondary source**: the session as it happened, replaced by a summary of it. The trade is always the same shape:
+
+| Source                            | Information | Noise | Room to move |
+| --------------------------------- | ----------- | ----- | ------------ |
+| Primary (Continue)                | Full        | Lots  | Little       |
+| Secondary (`/compact`, `/handoff`) | Lossy       | Less  | Lots         |
+
+This is why question 1 comes first. You only pay the lossiness when staying costs more than it saves.
+
+## These are judgement calls
+
+The questions are not objective: each has taste in it, and the same boundary can go two ways on two days. The value is in asking them **in order**, at the boundary rather than in the middle of the work.

package/src/skill-set/ask-matt/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ask-matt
+description: Ask which skill or flow fits your situation. A router over the skills in this repo.
+---
+
+<!-- Vendored from mattpocock/skills at commit c55ee46073ed923f86ce59a5eb3b6d895095d1b7 (skills/engineering/ask-matt). MIT licensed — see LICENSE in this directory. -->
+
+# Ask Matt
+
+You don't remember every skill, so ask.
+
+A **flow** is a path through the skills. Most paths run along one **main flow**, and two **on-ramps** merge onto it. Everything else is standalone, or a vocabulary layer that runs underneath.
+
+## The main flow: idea → ship
+
+The route most work travels. You have an idea and want it built.
+
+1. **`/grill-with-docs`** sharpens the idea by interview. Start here whenever you are **working in a working directory**: it's stateful, retaining what it learns in `CONTEXT.md` and ADRs. (No working directory? Use `/grill-me` instead, covered under Standalone. Both run the same `/grilling` primitive; `grill-with-docs` is the one that leaves a paper trail, which makes it the better of the two whenever a repo is there to leave it in.)
+2. **Branch: can you settle every question in conversation?** If a question needs a runnable answer (state, business logic, a UI you have to see), detour through a prototype, bridged by **`/handoff`** in both directions (a prototype lives in its own directory, which is exactly what `/handoff` is for; see Phase boundaries):
+   - **`/handoff`** out, then open a fresh session against that file,
+   - **`/prototype`** to answer the question with throwaway code,
+   - **`/handoff`** back what you learned, and reference it from the original idea thread.
+3. **Branch: is this a multi-session build?**
+   - **Yes** → **`/to-spec`** (turn the thread into a spec), then **`/to-tickets`** to split it into tracer-bullet tickets, each declaring its **blocking edges**. On a local tracker that's one file per ticket under `.scratch/<feature>/issues/`, worked blockers-first by hand; on a real tracker the edges become native blocking links, so any ticket whose blockers are done can be grabbed: kick off **`/implement`** per ticket, **`/clear`ing context between each one**. Each ticket is self-contained, so the last one's context is disposable.
+   - **No** → **`/implement`** right here, in the same context window.
+
+   Either way, **`/implement`** builds each issue by driving **`/tdd`** internally (one red-green slice at a time), then closes out by running **`/code-review`**, a two-axis review (Standards + Spec) of the diff, before committing. Reach for **`/tdd`** on its own when you just want to build a concrete behaviour test-first without a full spec, and **`/code-review`** on its own whenever you want to review a branch or PR against a fixed point.
+
+### Context hygiene
+
+Keep steps 1–3 in **one unbroken context window** (don't compact or clear until after `/to-tickets`) so the grilling, spec, and tickets all build on the same thinking. Each `/implement` then starts fresh, working from the ticket.
+
+The limit on this is the **[smart zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone)**: the window (~150k tokens on state-of-the-art models) within which the model still reasons sharply. If a session approaches it before `/to-tickets`, don't push on degraded; `/compact` at the nearest phase boundary and carry on (see Phase boundaries).
+
+## On-ramps
+
+A starting situation that generates work, then merges onto the main flow.
+
+- **Bugs and requests piling up** → **`/triage`**. It moves issues through triage roles and produces agent-ready issues, which **`/implement`** later picks up.
+
+  Triage is only for issues **you didn't create**: bug reports, incoming feature requests, anything that arrives raw. Tickets that `/to-tickets` produced are already agent-ready, so **don't triage them**.
+
+- **Something's broken** → **`/diagnosing-bugs`**. For the hard ones: the bug that resists a first glance, the intermittent flake, the regression that crept in between two known-good states. It refuses to theorise until it has a **tight feedback loop** (one command that already goes red on *this* bug), then fixes with a regression test. Its post-mortem hands off to **`/improve-codebase-architecture`** when the real finding is that there's no good seam to lock the bug down.
+
+- **A huge, foggy effort: a greenfield project or a huge feature build, too big for one session** → **`/wayfinder`**, the most cognitively demanding flow here. When the way from here to the destination isn't visible yet, it charts a **shared map** of **decision tickets** on the issue tracker and resolves them one at a time, producing **decisions, not deliverables**, until the fog is pushed back and the way is clear. Where **`/grill-with-docs`** sharpens an idea you can hold in one session, wayfinder is for the idea you can't, and it's slower and denser, so save it for exactly that, never a well-scoped feature.
+
+  When the map clears, **it hands off, it doesn't build**: merge onto the main flow at **`/to-spec`**, which collapses the map's linked decisions into a buildable plan, then `/to-tickets` and `/implement` as usual. Looping the map straight into `/implement` skips that collapse and throws the linked detail away, so go straight to `/implement` only when the effort turned out genuinely small.
+
+## Codebase health
+
+Not feature work, just upkeep.
+
+- **`/improve-codebase-architecture`** runs whenever you have a spare moment to keep the codebase good for agents to operate in. It surfaces **deepening opportunities**; picking one _generates an idea_ you can take into the main flow at `/grill-with-docs`. It's the survey that finds the candidates; **`/codebase-design`** (below) is the bench you design the chosen one on.
+
+## Vocabulary underneath
+
+Two model-invoked references that run *beneath* the other skills, each the single source of truth for its vocabulary. Reach for them directly when the **words**, not the process, are the problem; or let the skills above pull them in.
+
+- **`/domain-modeling`**: sharpen the project's *domain* language: challenge a fuzzy term, resolve an overloaded word ("account" doing three jobs), record a hard-to-reverse decision as an ADR. It's the active discipline `/grill-with-docs` drives to keep `CONTEXT.md` a clean glossary.
+- **`/codebase-design`** is the deep-module vocabulary (module, interface, depth, seam, adapter, leverage, locality) for designing a module's *shape*: a lot of behaviour behind a small interface at a clean seam. `/tdd` and `/improve-codebase-architecture` both speak it.
+
+## Phase boundaries
+
+A **phase** is a chunk of work inside a session: the grilling, the implementation, the QA. At the **boundary** between two of them you have five options, and picking between them is the fuzziest decision in this whole map:
+
+- **Continue**: stay put. Costs nothing, loses nothing.
+- **`/clear`**: empty the window, when nothing here matters to what's next.
+- **`/handoff`** writes a portable markdown file. Narrow: only for a **new harness**, a **new directory**, a **colleague**, or forking a side task **mid-phase**. What it buys is portability.
+- **Subagent**: send a tightly-scoped task to its own window and get a report back.
+- **`/compact`** compresses this context and seeds a fresh session with it. The **default**, at the bottom of the tree rather than the first reach.
+
+Read [PHASE-BOUNDARIES.md](PHASE-BOUNDARIES.md) for the ordered tree: the five questions, the reasoning behind each branch, and why the primary-source cost makes **Continue** the one to rule out first. Make the decision **at** a boundary; mid-phase, continue or split the rest into subagents.
+
+## Standalone
+
+Off the main flow entirely.
+
+- **`/grill-me`**: the same relentless interview as `/grill-with-docs`, but **stateless**: it saves nothing locally and builds no `CONTEXT.md`. Reach for it when you are **not working in a working directory** (sharpening a plan, a design, a piece of writing, anything with no repo under it). If you are in a working directory, use `/grill-with-docs` instead: it runs the same interview and leaves a paper trail, so it is strictly the better one.
+- **`/grilling`** is the interview primitive itself: rounds, the frontier, facts are the agent's job and decisions are yours. `/grill-me` and `/grill-with-docs` are the two named ways in, and `/triage`, `/wayfinder` and `/improve-codebase-architecture` all run it internally. Reach for it directly only when you want the interview with no wrapper around it.
+- **`/resolving-merge-conflicts`** works an in-progress merge or rebase conflict hunk by hunk, resolving by **intent** traced to each side's primary source rather than by picking lines, then finishes the operation. It never runs `--abort`. Standalone and off every flow: reach for it when you are already mid-conflict.
+- **`/prototype`** is a small, throwaway program that answers one design question: does this state model feel right, or what should this UI look like. Throwaway is a constraint on how the code is written, not a promise to destroy it: the answer folds into the real code, and the prototype itself is kept as a **primary source** on a `prototype/<name>` branch out of main, pointed at from the implementation issue. It's the detour in step 2 of the main flow, but reach for it any time a design question is hard to settle on paper.
+- **`/research`**: delegate reading legwork to a **background agent**: it investigates a question against **primary sources**, then leaves a cited Markdown file in the repo. Keep working while it reads. The file it produces is something to take *into* the main flow at `/grill-with-docs`, since research feeds the thinking rather than replacing it.
+- **`/to-questionnaire`** comes in when the thing blocking you isn't in your head or the codebase but in **someone else's**, and it writes them a questionnaire to fill in. It's the inverse of `/grill-me`: instead of interviewing you about the subject, it interviews you about the **send** (who it's going to, what you need back) and aims the questions at the gap. What comes back is material for `/grill-with-docs` or `/to-spec`.
+- **`/wizard`** is for the steps only a **human** can take: provisioning infrastructure, setting up credentials or CI secrets, clicking through an unfamiliar third-party dashboard, running a one-off migration or cutover. It generates an interactive bash script that opens each URL, captures each value, and writes it into `.env` and GitHub secrets, so the procedure stops being something you re-explain to an agent every time. Model-invoked, so the agent reaches for it the moment it hits a wall only you can pass. If the agent could just do it itself, it should; this is for where a human is genuinely in the loop.
+- **`/wait-what`** is the corrective for a message that didn't land. Use it mid-conversation, inside any other skill, and the agent re-pitches what it just said with the context you were missing, in plain English, using the `CONTEXT.md` vocabulary. It works after the fact; `/grill-with-docs` is the upfront cure, because a shared language agreed early is what stops the jargon arriving at all.
+- **`/teach`**: learn a concept over multiple sessions, using the current directory as a stateful workspace.
+- **`/writing-for-agents`** is the reference for writing documents agents consume: skills, AGENTS.md, pointed-at docs.
+
+## Precondition
+
+**`/setup-matt-pocock-skills`**: run before your first engineering flow to configure the issue tracker, triage labels, and doc layout the other skills assume. Custom issue trackers also work.

package/src/skill-set/ask-matt/agents/openai.yaml

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

package/src/skill-set/code-review/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.