@long.dg/le-restaurant 0.1.0

package/dist/cli-BDBD_kfX.d.ts

@@ -0,0 +1,160 @@
+import { Command } from 'commander';
+
+/**
+ * Core domain types shared across the registry, adapters, and writer.
+ * These are the foundational shared surfaces — every later ticket builds on them.
+ */
+/** A normalized source skill, parsed from a `SKILL.md` (frontmatter + body). */
+interface Skill {
+    /** Skill identifier, e.g. "chef-de-rang" (from frontmatter, falls back to dir name). */
+    name: string;
+    /** One-line description from frontmatter. */
+    description: string;
+    /** Full parsed frontmatter as a key/value map. */
+    frontmatter: Record<string, unknown>;
+    /** The markdown body after the frontmatter, verbatim. */
+    body: string;
+    /** Optional relative paths to bundled assets that ship with the skill. */
+    assets?: string[];
+}
+/** A coding agent we can translate skills for. */
+interface Agent {
+    id: "claude" | "codex" | "gemini";
+    label: string;
+}
+/** How a single emitted file should be written to the target tree. */
+type WriteMode = "create" | "overwrite" | "merge";
+/** One file an adapter wants written to the target project. */
+interface FileOutput {
+    /** Path relative to `InstallContext.targetDir`. */
+    path: string;
+    /** Full file contents to write. */
+    contents: string;
+    /** Write strategy the writer should apply. */
+    mode: WriteMode;
+}
+/** How the writer resolves a collision with an existing file. */
+type ConflictPolicy = "skip" | "overwrite" | "merge";
+/** Everything an adapter needs to know to translate a set of skills. */
+interface InstallContext {
+    /** Absolute path to the target project root. */
+    targetDir: string;
+    /** The skills the user chose to install. */
+    selectedSkills: Skill[];
+    /** What to do when an output file already exists. */
+    conflictPolicy: ConflictPolicy;
+}
+
+/**
+ * The single contract every agent adapter implements.
+ *
+ * An adapter is a pure transform: given the normalized skills and an install
+ * context, it returns the list of files to write — it does no I/O itself.
+ * The writer is responsible for putting `FileOutput`s on disk.
+ *
+ * Pulled forward into Order 01 (rather than Phase 1) so the Claude passthrough
+ * adapter implements the same interface every later adapter (Codex, Gemini) will.
+ */
+interface Adapter {
+    /** The agent this adapter targets. */
+    readonly id: "claude" | "codex" | "gemini";
+    /** Human-readable label for summaries/prompts. */
+    readonly label: string;
+    /** Translate skills into the files this agent expects. */
+    translate(skills: Skill[], ctx: InstallContext): FileOutput[];
+}
+
+/** What the writer did with a single output file. */
+type WriteAction = "created" | "overwritten" | "merged" | "skipped";
+/** A file the writer processed, for the post-install summary. */
+interface WriteResult {
+    /** Path relative to the target dir (as the adapter emitted it). */
+    path: string;
+    /** The action the conflict policy resolved to. */
+    action: WriteAction;
+}
+/**
+ * Write a set of adapter outputs into the install target.
+ *
+ * Each `FileOutput.path` is resolved relative to `ctx.targetDir` and written
+ * atomically. When a target file already exists, the `conflictPolicy` decides:
+ * - `skip` — leave the existing file untouched;
+ * - `overwrite` — replace it with the emitted contents;
+ * - `merge` — for `mode: "merge"` outputs, fold the managed block into the
+ *   existing file (preserving user content outside the markers); for other
+ *   outputs, fall back to overwrite.
+ *
+ * A file that does not yet exist is always created regardless of policy.
+ */
+declare function writeOutputs(outputs: FileOutput[], ctx: InstallContext): WriteResult[];
+
+/** The agents we can install for. */
+type AgentId = "claude" | "codex" | "gemini";
+/** Valid agent ids, for validation + help text. */
+declare const AGENT_IDS: AgentId[];
+/**
+ * Map a chosen agent id to its adapter.
+ *
+ * Throws a clear error on an unknown id so both the CLI (non-zero exit) and
+ * library callers fail loudly rather than silently installing the wrong thing.
+ */
+declare function selectAdapter(agentId: string): Adapter;
+/**
+ * The conflict policy to use for an agent by default.
+ *
+ * Claude's passthrough files are fully tool-owned, so they overwrite. The
+ * Codex/Gemini marker targets (`AGENTS.md`, `GEMINI.md`) merge so user content
+ * outside the managed markers is preserved on re-runs.
+ */
+declare function defaultConflictPolicy(agentId: string): ConflictPolicy;
+/**
+ * Resolve a `--skills` value into the concrete list of skills to install.
+ *
+ * Accepts the literal `all` (every available skill) or a comma-separated list
+ * of skill names (order/whitespace tolerant). Throws clearly on an empty
+ * selection or any unknown name.
+ */
+declare function resolveSkillSelection(spec: string, available: Skill[]): Skill[];
+/** A resolved, ready-to-run install request. */
+interface InstallRequest {
+    agentId: AgentId;
+    skills: Skill[];
+    targetDir: string;
+    conflictPolicy?: ConflictPolicy;
+}
+/**
+ * Translate the selected skills with the chosen adapter and write them to the
+ * target dir. The single install primitive shared by the flag and wizard paths.
+ */
+declare function runInstall(req: InstallRequest): {
+    adapter: Adapter;
+    results: WriteResult[];
+};
+/** Options collected from the non-interactive flags. */
+interface InstallFlags {
+    agent?: string;
+    skills?: string;
+    yes?: boolean;
+}
+/**
+ * Resolve raw `--agent`/`--skills` flags into a validated install request.
+ * Throws clearly (non-zero exit upstream) on any invalid value.
+ */
+declare function resolveFlags(flags: InstallFlags, targetDir: string, available: Skill[]): InstallRequest;
+/**
+ * Build the commander program. Factored out so tests can introspect the
+ * wired-up commands/options without spawning a process.
+ */
+declare function buildProgram(): Command;
+/**
+ * Parse argv, run the CLI, and resolve to the process exit code.
+ *
+ * commander is put in `exitOverride` mode so it throws instead of calling
+ * `process.exit`, letting us (and tests) observe the exit code. Help/version
+ * exit 0; parse/validation errors exit non-zero.
+ */
+declare function runCli(argv?: string[]): Promise<number>;
+/** Convenience entry: run and let the process adopt the resolved exit code. */
+declare function run(argv?: string[]): Promise<number>;
+
+export { type Adapter as A, type ConflictPolicy as C, type FileOutput as F, type InstallContext as I, type Skill as S, type WriteResult as W, AGENT_IDS as a, type Agent as b, type AgentId as c, type InstallRequest as d, type WriteAction as e, type WriteMode as f, buildProgram as g, defaultConflictPolicy as h, resolveSkillSelection as i, run as j, runCli as k, runInstall as l, resolveFlags as r, selectAdapter as s, writeOutputs as w };

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+import 'commander';
+export { a as AGENT_IDS, c as AgentId, d as InstallRequest, g as buildProgram, h as defaultConflictPolicy, r as resolveFlags, i as resolveSkillSelection, j as run, k as runCli, l as runInstall, s as selectAdapter } from './cli-BDBD_kfX.js';

package/dist/cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  AGENT_IDS,
+  buildProgram,
+  defaultConflictPolicy,
+  resolveFlags,
+  resolveSkillSelection,
+  run,
+  runCli,
+  runInstall,
+  selectAdapter
+} from "./chunk-5DTTVPAO.js";
+export {
+  AGENT_IDS,
+  buildProgram,
+  defaultConflictPolicy,
+  resolveFlags,
+  resolveSkillSelection,
+  run,
+  runCli,
+  runInstall,
+  selectAdapter
+};
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,95 @@
+import { A as Adapter, S as Skill, W as WriteResult } from './cli-BDBD_kfX.js';
+export { a as AGENT_IDS, b as Agent, c as AgentId, C as ConflictPolicy, F as FileOutput, I as InstallContext, d as InstallRequest, e as WriteAction, f as WriteMode, g as buildProgram, h as defaultConflictPolicy, r as resolveFlags, i as resolveSkillSelection, j as run, k as runCli, l as runInstall, s as selectAdapter, w as writeOutputs } from './cli-BDBD_kfX.js';
+import 'commander';
+
+/**
+ * Claude Code — passthrough strategy.
+ *
+ * Claude Code natively supports on-demand skills, so we copy each source
+ * `SKILL.md` verbatim to `.claude/skills/<name>/SKILL.md`. To guarantee
+ * byte-for-byte fidelity we read the original vendored file rather than
+ * re-serialize the normalized `Skill` (which would lose exact formatting).
+ */
+declare const claudeAdapter: Adapter;
+
+/**
+ * Codex — merge strategy.
+ *
+ * Codex reads a single monolithic `AGENTS.md` per directory with no named or
+ * on-demand skills, so every selected skill is folded into one `AGENTS.md` as
+ * a delimited `## Skill: <name>` section. The whole set lives inside managed
+ * markers, so the writer's merge mode updates only that span on re-runs and
+ * never disturbs surrounding user content. Triggering degrades to always-on
+ * guidance (flagged to the user elsewhere).
+ */
+declare const codexAdapter: Adapter;
+
+/**
+ * Gemini — import strategy.
+ *
+ * Gemini concatenates `GEMINI.md` hierarchically and supports `@file.md`
+ * imports, so each skill is written to its own modular
+ * `.gemini/skills/<name>.md` and referenced by an `@./.gemini/skills/<name>.md`
+ * import line. The import lines live inside managed markers in `GEMINI.md`, so
+ * re-runs update only that span; the modular skill files are fully tool-owned
+ * (overwrite). Skills are always-on — no on-demand triggering.
+ */
+declare const geminiAdapter: Adapter;
+
+/**
+ * Managed-marker helper, shared by the merge-style adapters (Codex, Gemini).
+ *
+ * Tool-owned content inside files a user may also edit (`AGENTS.md`,
+ * `GEMINI.md`) is bounded by managed markers. Only the span between the
+ * markers is ever rewritten on a re-run; everything outside is the user's and
+ * is preserved verbatim.
+ */
+declare const MARKER_START = "<!-- le-restaurant:start -->";
+declare const MARKER_END = "<!-- le-restaurant:end -->";
+/** Notice rendered as the first line inside every managed block. */
+declare const MANAGED_NOTICE = "<!-- Managed by le-restaurant. Do not edit between these markers; re-run the installer to update. -->";
+/** Wrap `inner` content in managed markers, returning a complete block. */
+declare function renderManagedBlock(inner: string): string;
+/** Does `content` already contain a managed block? */
+declare function hasManagedBlock(content: string): boolean;
+/**
+ * Merge a freshly rendered managed `block` into `existing` file content.
+ *
+ * If `existing` already contains a managed span, that span (markers included)
+ * is replaced in place. Otherwise the block is appended, separated from any
+ * prior content by a blank line. User content outside the markers is never
+ * touched, so repeated merges are idempotent for a stable block.
+ */
+declare function mergeManagedBlock(existing: string, block: string): string;
+
+/**
+ * Absolute path to the vendored source skills.
+ *
+ * This module lives at `src/registry.ts` in dev and `dist/registry.js` once
+ * built; in both cases the vendored `skills/` directory sits one level up.
+ */
+declare const skillsDir: string;
+/** Absolute path to a vendored skill's source `SKILL.md`. */
+declare function skillSourcePath(name: string): string;
+/** Read one vendored `SKILL.md` and normalize it into a `Skill`. */
+declare function loadSkill(name: string): Skill;
+/** Discover and load every vendored source skill. */
+declare function loadSkills(): Skill[];
+
+/** Everything the post-install summary needs to render. */
+interface SummaryInput {
+    /** The agent the skills were installed for. */
+    agentId: "claude" | "codex" | "gemini";
+    /** Human-readable agent label (e.g. "Claude Code"). */
+    agentLabel: string;
+    /** What the writer did with each file. */
+    results: WriteResult[];
+}
+/**
+ * Render the post-install summary: the target agent, every file written (with
+ * the action taken), and how to use the installed skills — including the
+ * always-on caveat for Codex/Gemini.
+ */
+declare function renderSummary(input: SummaryInput): string;
+
+export { Adapter, MANAGED_NOTICE, MARKER_END, MARKER_START, Skill, type SummaryInput, WriteResult, claudeAdapter, codexAdapter, geminiAdapter, hasManagedBlock, loadSkill, loadSkills, mergeManagedBlock, renderManagedBlock, renderSummary, skillSourcePath, skillsDir };

package/dist/index.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import {
+  AGENT_IDS,
+  MANAGED_NOTICE,
+  MARKER_END,
+  MARKER_START,
+  buildProgram,
+  claudeAdapter,
+  codexAdapter,
+  defaultConflictPolicy,
+  geminiAdapter,
+  hasManagedBlock,
+  loadSkill,
+  loadSkills,
+  mergeManagedBlock,
+  renderManagedBlock,
+  renderSummary,
+  resolveFlags,
+  resolveSkillSelection,
+  run,
+  runCli,
+  runInstall,
+  selectAdapter,
+  skillSourcePath,
+  skillsDir,
+  writeOutputs
+} from "./chunk-5DTTVPAO.js";
+export {
+  AGENT_IDS,
+  MANAGED_NOTICE,
+  MARKER_END,
+  MARKER_START,
+  buildProgram,
+  claudeAdapter,
+  codexAdapter,
+  defaultConflictPolicy,
+  geminiAdapter,
+  hasManagedBlock,
+  loadSkill,
+  loadSkills,
+  mergeManagedBlock,
+  renderManagedBlock,
+  renderSummary,
+  resolveFlags,
+  resolveSkillSelection,
+  run,
+  runCli,
+  runInstall,
+  selectAdapter,
+  skillSourcePath,
+  skillsDir,
+  writeOutputs
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/wizard-4VNJ64P6.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+// src/wizard.ts
+import {
+  cancel,
+  intro,
+  isCancel,
+  multiselect,
+  outro,
+  select
+} from "@clack/prompts";
+var AGENT_CHOICES = [
+  { value: "claude", label: "Claude Code", hint: "native on-demand skills" },
+  { value: "codex", label: "Codex", hint: "merged into AGENTS.md (always-on)" },
+  { value: "gemini", label: "Gemini", hint: "@import into GEMINI.md (always-on)" }
+];
+async function runWizard(available) {
+  intro("le-restaurant \u2014 install the brigade of agent skills");
+  const agentId = await select({
+    message: "Which coding agent are you installing for?",
+    options: AGENT_CHOICES.map((c) => ({
+      value: c.value,
+      label: c.label,
+      hint: c.hint
+    }))
+  });
+  if (isCancel(agentId)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const picked = await multiselect({
+    message: "Which skills do you want? (space to toggle, enter to confirm)",
+    options: available.map((s) => ({
+      value: s.name,
+      label: s.name,
+      hint: s.description
+    })),
+    required: true
+  });
+  if (isCancel(picked)) {
+    cancel("Cancelled.");
+    return null;
+  }
+  const names = picked;
+  const skills = available.filter((s) => names.includes(s.name));
+  outro(`Installing ${skills.length} skill(s) for ${agentId}\u2026`);
+  return { agentId, skills };
+}
+export {
+  runWizard
+};
+//# sourceMappingURL=wizard-4VNJ64P6.js.map

package/dist/wizard-4VNJ64P6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/wizard.ts"],"sourcesContent":["import {\n  cancel,\n  intro,\n  isCancel,\n  multiselect,\n  outro,\n  select,\n} from \"@clack/prompts\";\nimport type { Skill } from \"./types.js\";\n\n/** Agents offered in the interactive picker. */\nconst AGENT_CHOICES = [\n  { value: \"claude\", label: \"Claude Code\", hint: \"native on-demand skills\" },\n  { value: \"codex\", label: \"Codex\", hint: \"merged into AGENTS.md (always-on)\" },\n  { value: \"gemini\", label: \"Gemini\", hint: \"@import into GEMINI.md (always-on)\" },\n] as const;\n\n/** The user's choices from the wizard, or null if they cancelled. */\nexport interface WizardResult {\n  agentId: \"claude\" | \"codex\" | \"gemini\";\n  skills: Skill[];\n}\n\n/**\n * Walk the user through pick-agent → multiselect-skills.\n *\n * This is intentionally thin: all the testable logic (dispatch, validation,\n * summary) lives in pure functions elsewhere. The wizard only orchestrates the\n * interactive prompts and hands back the resolved selection.\n */\nexport async function runWizard(\n  available: Skill[],\n): Promise<WizardResult | null> {\n  intro(\"le-restaurant — install the brigade of agent skills\");\n\n  const agentId = await select({\n    message: \"Which coding agent are you installing for?\",\n    options: AGENT_CHOICES.map((c) => ({\n      value: c.value,\n      label: c.label,\n      hint: c.hint,\n    })),\n  });\n  if (isCancel(agentId)) {\n    cancel(\"Cancelled.\");\n    return null;\n  }\n\n  const picked = await multiselect({\n    message: \"Which skills do you want? (space to toggle, enter to confirm)\",\n    options: available.map((s) => ({\n      value: s.name,\n      label: s.name,\n      hint: s.description,\n    })),\n    required: true,\n  });\n  if (isCancel(picked)) {\n    cancel(\"Cancelled.\");\n    return null;\n  }\n\n  const names = picked as string[];\n  const skills = available.filter((s) => names.includes(s.name));\n  outro(`Installing ${skills.length} skill(s) for ${agentId}…`);\n\n  return { agentId: agentId as WizardResult[\"agentId\"], skills };\n}\n"],"mappings":";;;AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAIP,IAAM,gBAAgB;AAAA,EACpB,EAAE,OAAO,UAAU,OAAO,eAAe,MAAM,0BAA0B;AAAA,EACzE,EAAE,OAAO,SAAS,OAAO,SAAS,MAAM,oCAAoC;AAAA,EAC5E,EAAE,OAAO,UAAU,OAAO,UAAU,MAAM,qCAAqC;AACjF;AAeA,eAAsB,UACpB,WAC8B;AAC9B,QAAM,0DAAqD;AAE3D,QAAM,UAAU,MAAM,OAAO;AAAA,IAC3B,SAAS;AAAA,IACT,SAAS,cAAc,IAAI,CAAC,OAAO;AAAA,MACjC,OAAO,EAAE;AAAA,MACT,OAAO,EAAE;AAAA,MACT,MAAM,EAAE;AAAA,IACV,EAAE;AAAA,EACJ,CAAC;AACD,MAAI,SAAS,OAAO,GAAG;AACrB,WAAO,YAAY;AACnB,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,MAAM,YAAY;AAAA,IAC/B,SAAS;AAAA,IACT,SAAS,UAAU,IAAI,CAAC,OAAO;AAAA,MAC7B,OAAO,EAAE;AAAA,MACT,OAAO,EAAE;AAAA,MACT,MAAM,EAAE;AAAA,IACV,EAAE;AAAA,IACF,UAAU;AAAA,EACZ,CAAC;AACD,MAAI,SAAS,MAAM,GAAG;AACpB,WAAO,YAAY;AACnB,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ;AACd,QAAM,SAAS,UAAU,OAAO,CAAC,MAAM,MAAM,SAAS,EAAE,IAAI,CAAC;AAC7D,QAAM,cAAc,OAAO,MAAM,iBAAiB,OAAO,QAAG;AAE5D,SAAO,EAAE,SAA6C,OAAO;AAC/D;","names":[]}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@long.dg/le-restaurant",
+  "version": "0.1.0",
+  "description": "Install the brigade of agent skills into your project, translated for your coding agent.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "le-restaurant": "dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "check:sync": "vitest run test/check-skills-sync.test.ts"
+  },
+  "keywords": [
+    "claude",
+    "codex",
+    "gemini",
+    "skills",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dglong/le-restaurant.git"
+  },
+  "homepage": "https://github.com/dglong/le-restaurant#readme",
+  "bugs": {
+    "url": "https://github.com/dglong/le-restaurant/issues"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^1.6.0",
+    "commander": "^14.0.1",
+    "gray-matter": "^4.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}

package/skills/chef-de-rang/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: chef-de-rang
+description: Builds one feature to completion from a single order ticket. Loads the ticket as its whole memory — scope, acceptance criteria, files to touch, decisions, and progress so far — implements the feature test-first (red-green-refactor), writes its progress back to the ticket, and hands the plate to the pass. Resumable by design — a fresh run reads the ticket and picks up exactly where the last shift left off. Use this skill when the user wants to implement or resume one specific feature or ticket — "build order 3," "work on the auth feature," "resume that ticket," "continue where the last shift left off" — or when a Maître D' dispatches one. Trigger whenever a single tracked feature needs to move from plan to working code.
+---
+
+# Chef de Rang
+
+The station waiter who owns one table — a single feature — and serves it from order to the pass. **The order ticket is your memory.** You don't own the feature; the *ticket* does. Anything not written to it is forgotten the moment you clock out, so the ticket, not your context, is the source of truth. Serious engineering content; keep the floor flavor to a pinch.
+
+Done well = the feature works, its acceptance criteria pass, and the ticket reflects reality closely enough that anyone could take over the table on the next read.
+
+## Load the table first
+
+Read the order ticket named in the request (in `<docs-root>/<idea-slug>/service/order-NN-<slug>.md`). Start from its **Current WIP / next action** and **Progress log**, not from a blank slate. Then read the plan pages it points to — `Architecture`, the relevant `Development-Plan` tasks, and the test strategy — so you build in the project's real stack and conventions.
+
+## Check the order is ready
+
+Before cooking, confirm the **Definition of Ready**: acceptance criteria and touches are present, and there's no blocking unknown. If the order is vague or under-specified, don't guess scope into existence — note what's missing on the ticket and kick it back to the Maître D'. A bad order cooked confidently is worse than one sent back.
+
+## Stay at your table
+
+Work only within the ticket's **Touches**. Shared surfaces the plan foresaw — routing, shared services/types, the component library, build config — have already been resolved by the Maître D' at seating, so use them as given. If you hit a shared surface that *wasn't* foreseen and genuinely needs changing, don't quietly do it: record it as an escalation on the ticket and flag the Maître D'. Keeping the dining room coherent is the manager's job, and a stray shared-surface edit produces drift the manager can't see.
+
+## Serve the course
+
+1. **Set your station.** Turn the ticket into a short, ordered list of slices, each mapping to one or more **Done when** criteria. Use Plan Mode if it's available. Confirm the test runner exists — if the repo has none yet (an early course), stand one up *now*, before any cooking, and note it on the ticket. No runner, no service.
+2. **Red — write the failing test first.** For the next slice, write a test that asserts its acceptance criterion, run it, and watch it fail for the right reason. The taste comes *before* the dish. **Don't write implementation before a failing test exists** — if you catch yourself having cooked first, delete that code and start from the test. A failing test is the only kind of progress that counts here.
+3. **Green — cook the minimum to pass.** Write the smallest change that makes the test pass, in the plan's stack and conventions. Run the test; watch it go green. Don't gold-plate beyond what the test demands.
+4. **Refactor — tidy with the tests green.** Clean up names, duplication, and shape while the suite stays green. Re-run after.
+5. **Loop.** Repeat red → green → refactor for each slice until every **Done when** criterion is covered by a passing test. Never mark something passing you haven't actually run.
+6. **Write the ticket back.** Append to the **Progress log**, update **Current WIP / next action**, record any **Decisions**, list **Tests**. This is the step that survives a crash — do it as you go, not "later."
+
+## Hand off to the pass
+
+When the criteria are met and tests are green, summarize what changed and hand back to the Maître D' for the pass — it verifies **Done when**, a clean whole-app build, and no regressions. **You don't mark your own plate Served**; the pass does. If you run out of road before finishing, leave **Current WIP / next action** precise enough that the next chef de rang resumes in a single read.
+
+## Resuming is the normal case
+
+A re-run isn't an exception — it's the expected path. Read the ticket, trust **Current WIP / next action**, then verify the log against the actual code. If they disagree, the code wins — note the correction on the ticket and continue. Don't restart work the log says is already done without checking it.
+
+## Tempo
+
+Same toggle as the suite: "service mode" for terse, "prep" / "normal" to relax. Never skip writing the ticket back to save words — that's the one step that can't be regenerated.
+
+## Anti-patterns
+
+- Working from the request alone without loading the ticket.
+- Cooking a vague order instead of kicking it back to the Maître D'.
+- Touching shared surfaces outside the ticket without escalating.
+- Cooking before the taste — writing implementation before a failing test exists. Delete it and start from the test.
+- Marking tests passing without running them.
+- Finishing a shift without writing progress back — the next shift loses everything.
+- Marking your own plate Served — that's the pass's call.
+- Gold-plating past the ticket's acceptance criteria.

package/skills/maitre-d/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: maitre-d
+description: Front-of-house orchestrator for building a planned project. Reads a mise-en-place plan wiki, cuts it into per-feature "order tickets," and runs service one course at a time — fires the next ready ticket, sends a chef-de-rang to build it, then works the pass to verify the feature is done before moving on. The natural follow-up once a build plan exists. Use this skill whenever the user wants to start or continue implementing a planned project — "let's build this," "start development," "what's next to build," "continue the build," "run the implementation," "work through the plan" — or hands over a plan folder and asks to execute it. Trigger it even without the word "build" when the user is moving from a finished plan toward shipping code.
+---
+
+# Maître D'
+
+Front-of-house manager for the build. The kitchen (`sous-chef`, `mise-en-place`) settled *what* and *how*; the Maître D' runs **service** — turning the plan into features served one course at a time, and checking every plate at the pass before it leaves the floor. Serious engineering content; keep the floor flavor to a pinch.
+
+Done well = features ship from the plan in dependency order, each verified against its acceptance criteria, with state that survives any interruption.
+
+## Default: one course at a time
+
+Fire a single ticket, see it through the pass, mark it **Served**, then fire the next. Sequential service is slower but precise — no parallel writes to trip over, every plate checked before the next is started, and the whole floor resumable from disk. Parallel brigade service is intentionally out of scope for now; don't fake it.
+
+## Check the kitchen first
+
+Find the plan: scan the docs root for a `<slug>/plan/` wiki (`mise-en-place` output).
+- **No plan, or only a `recipe.md`** → don't improvise service. Send it back to the kitchen — suggest `mise-en-place` to plan the build first.
+- **Plan exists but the fundamentals are still `Draft`** (no real scope or stack) → flag it and offer to firm those up via `mise-en-place` before firing anything.
+
+## The service layer
+
+Everything lives in `<docs-root>/<idea-slug>/service/`, beside `plan/` and `recipe.md`, so one idea stays in one folder:
+- `Board.md` — the floor at a glance: every ticket, its status, and the course order.
+- `order-NN-<slug>.md` — one ticket per feature/phase. The unit of work **and** its memory.
+
+## Flow
+
+### 1. Seat the room (first run)
+From `Phases.md` and `Development-Plan.md`, cut the work into tickets — usually one per phase or coherent feature. Seed each ticket straight from the plan: its tasks, their **Done when** criteria, and **Touches** list. Write `Board.md` with the course order, respecting dependencies.
+
+**Resolve shared surfaces up front.** Scan every ticket's **Touches** for shared surfaces the plan already names — routing, shared services/types, the component library, build config. Don't leave these to be discovered mid-cook: pre-own or pre-stub them now (e.g. register a route placeholder, declare a shared interface) so a chef-de-rang is never blocked halfway through a course by something the plan already foresaw. Only genuinely *unforeseen* shared needs should surface as a mid-cook escalation.
+
+Show the breakdown — tickets, course order, and the shared surfaces you're holding — and confirm before firing.
+
+### 2. Own the dining room
+Some surfaces are shared — routing, shared services/types, the component library, build config. The Maître D' holds these. When a ticket needs a cross-cutting change, it's made deliberately (at seating or at the pass), not buried inside one feature. Note shared touches on the ticket so nothing collides. When a shared decision is non-obvious, log it in the plan's `Decisions & Glossary` (ADR log) so the *why* outlives the build — a ticket's local **Decisions** are fine for feature-scoped choices, but cross-cutting ones graduate to the plan.
+
+### 3. Fire the next ticket
+Pick the next ticket whose dependencies are **Served** and whose **Definition of Ready** is met (criteria + touches present, no blocking unknown). If it isn't ready, fix the ticket first — never fire a vague order. Set Status → **Firing**, then send a `chef-de-rang` with the ticket path and the plan pages it points to.
+
+### 4. Work the pass
+When the chef-de-rang hands back, check the plate before it ships. **Proof, not claims** — a plate is passed on shown command output, never on a "tests pass" assertion. For each check, *run the command yourself*, read the actual output, and only then judge:
+- Every **Done when** criterion on the ticket is verifiably met.
+- The tests the plan's test strategy names for this work pass — run them, don't take it on faith.
+- The whole app still builds and the existing suite stays green — no regressions.
+- Lint is clean.
+
+Record the verification on the ticket's **Tests** section: the commands run and their result (e.g. `vitest run → 12 passed`, `tsc --noEmit → clean`). An "I'm done" with no command output behind it is not done.
+
+A plate that fails goes back to the same ticket with notes; Status stays **Firing**, it does not ship. Only when the output proves it: Status → **Served**, update `Board.md`, fire the next.
+
+### 5. Last orders
+When every ticket is Served, say so plainly and point at what the plan parked under "beyond MVP." Don't invent new courses.
+
+## The order ticket
+
+One per feature, at `service/order-NN-<slug>.md`. This is the durable memory — a chef-de-rang owns the *ticket*, not the feature, so anything not written here is lost between shifts.
+
+```markdown
+# Order NN · <feature name> · Status: To fire
+**Covers:** <plan phase / tasks this ticket delivers>
+**Depends on:** <other tickets, or none>
+
+## Done when  (acceptance — checked at the pass)
+- [ ] <criterion, observable>
+
+## Touches
+- <files / areas> · shared surfaces: <routing / services / types, or none>
+
+## Progress log  (append-only, newest last)
+- <date> — <what was done>
+
+## Current WIP / next action
+- <the single resume pointer: exactly what to do next>
+
+## Decisions
+- <choice · why>
+
+## Blockers / escalations
+- <anything needing the Maître D' or the user; or none>
+
+## Tests
+- <which tests written / passing>
+```
+
+## Board.md
+
+```markdown
+# <Idea name> — Service Board
+**Plan:** ../plan/Home.md
+
+## Course order
+1. [[order-01-<slug>]] — <feature>
+2. [[order-02-<slug>]] — <feature> (depends on 01)
+
+| # | Feature | Status | Depends on |
+|---|---------|--------|------------|
+| 01 | <feature> | To fire | — |
+
+Status flow: To fire → Firing → At the pass → Served   ( 86'd = dropped )
+```
+
+## Resuming
+
+A re-run is normal. Don't re-decompose — read `Board.md` for where service stands, read the in-flight ticket's **Current WIP / next action**, and continue from there.
+
+## Re-seat when the plan moves
+
+Tickets copy **Done when** and **Touches** from the plan at seating, so a later `mise-en-place` refine can leave them stale. Before firing on a resumed build, check whether `plan/` changed since the tickets were cut. If it did, **reconcile**: update the not-yet-Served tickets to match the new plan (criteria, touches, course order), leave **Served** tickets alone but note any drift they now carry, and confirm the reconciled board before firing. Never fire a ticket you know contradicts the current plan.
+
+## Tempo
+
+Same toggle as the rest of the suite: "service mode" / "in the weeds" for terse, "prep" / "family meal" / "normal" to relax. It trims the talk, never the pass checks.
+
+## Right-size
+
+A weekend tool might be two or three tickets with no shared-surface ceremony. A multi-feature app earns the full floor. Don't seat twelve tables for a one-course meal.
+
+## Anti-patterns
+
+- Improvising service with no plan — send it to `mise-en-place`.
+- Firing more than one ticket at a time (not supported yet — keep it sequential).
+- Passing a plate that fails its **Done when** or breaks the app build.
+- Marking a plate Served on a claim of green instead of shown command output.
+- Letting a feature rewrite shared routing/services/types on its own.
+- Tickets without acceptance criteria — a vague order can't be cooked or checked.
+- Leaving a plan-named shared surface to be discovered mid-cook instead of resolving it at seating.
+- Firing tickets that contradict a plan that changed under you — reconcile first.
+- Re-decomposing from scratch on resume instead of reading the board.