create-yss-spec 3.0.0 → 3.0.1

package/template/.hermes/skills/archify/test/workflow-semantic-contract.test.mjs

@@ -1,131 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-
-import { compileWorkflow } from '../renderers/workflow/workflow-compiler.mjs';
-
-function document(semanticChecks) {
-  return {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: {
-      title: 'Workflow semantic contract fixture',
-      legend: { mode: 'hidden' },
-    },
-    lanes: [
-      { id: 'main', label: 'Main' },
-      { id: 'recovery', label: 'Recovery' },
-    ],
-    nodes: [
-      { id: 'input', lane: 'main', col: 0, type: 'external', label: 'Input' },
-      { id: 'process', lane: 'main', col: 2, type: 'backend', label: 'Process' },
-      { id: 'result', lane: 'main', col: 4, type: 'frontend', label: 'Result' },
-      { id: 'ledger', lane: 'recovery', col: 4, type: 'database', label: 'Ledger' },
-      { id: 'resume', lane: 'recovery', col: 1, type: 'backend', label: 'Resume' },
-    ],
-    edges: [
-      { id: 'start', from: 'input', to: 'process' },
-      { id: 'finish', from: 'process', to: 'result' },
-      { id: 'record', from: 'process', to: 'ledger' },
-    ],
-    ...(semanticChecks ? { semanticChecks } : {}),
-  };
-}
-
-test('semanticChecks rejects an undeclared root instead of accepting an orphan recovery node', () => {
-  const workflow = document({
-    allowedRoots: ['input'],
-  });
-
-  const result = compileWorkflow({ workflow, qualityProfile: 'standard' });
-
-  assert.equal(result.ok, false);
-  assert.ok(
-    result.diagnostics.some((diagnostic) => (
-      diagnostic.code === 'workflow/unexpected-root'
-      && diagnostic.subject?.node === 'resume'
-    )),
-    JSON.stringify(result.diagnostics, null, 2),
-  );
-});
-
-test('semanticChecks rejects a missing required edge with its exact endpoints', () => {
-  const workflow = document({
-    requiredEdges: [{ from: 'ledger', to: 'resume' }],
-  });
-
-  const result = compileWorkflow({ workflow, qualityProfile: 'standard' });
-
-  assert.equal(result.ok, false);
-  assert.ok(
-    result.diagnostics.some((diagnostic) => (
-      diagnostic.code === 'workflow/required-edge'
-      && diagnostic.subject?.from === 'ledger'
-      && diagnostic.subject?.to === 'resume'
-    )),
-    JSON.stringify(result.diagnostics, null, 2),
-  );
-});
-
-test('semanticChecks accepts required reachability through intermediate nodes without changing SVG bytes', () => {
-  const baseline = document();
-  const constrained = document({
-    allowedRoots: ['input', 'resume'],
-    allowedTerminals: ['result', 'ledger', 'resume'],
-    requiredEdges: [{ from: 'process', to: 'ledger' }],
-    requiredPaths: [{ from: 'input', to: 'result' }],
-  });
-
-  const baselineResult = compileWorkflow({ workflow: baseline, qualityProfile: 'standard' });
-  const constrainedResult = compileWorkflow({ workflow: constrained, qualityProfile: 'standard' });
-
-  assert.equal(baselineResult.ok, true, JSON.stringify(baselineResult.diagnostics, null, 2));
-  assert.equal(constrainedResult.ok, true, JSON.stringify(constrainedResult.diagnostics, null, 2));
-  assert.equal(constrainedResult.svg, baselineResult.svg);
-  assert.deepEqual(constrainedResult.receipt, baselineResult.receipt);
-});
-
-test('semanticChecks rejects a required path that is not reachable in authored direction', () => {
-  const workflow = document({
-    requiredPaths: [{ from: 'ledger', to: 'resume' }],
-  });
-
-  const result = compileWorkflow({ workflow, qualityProfile: 'standard' });
-
-  assert.equal(result.ok, false);
-  assert.ok(
-    result.diagnostics.some((diagnostic) => diagnostic.code === 'workflow/required-path'),
-    JSON.stringify(result.diagnostics, null, 2),
-  );
-});
-
-test('semanticChecks rejects an undeclared terminal', () => {
-  const workflow = document({
-    allowedTerminals: ['result', 'ledger'],
-  });
-
-  const result = compileWorkflow({ workflow, qualityProfile: 'standard' });
-
-  assert.equal(result.ok, false);
-  assert.ok(
-    result.diagnostics.some((diagnostic) => (
-      diagnostic.code === 'workflow/unexpected-terminal'
-      && diagnostic.subject?.node === 'resume'
-    )),
-    JSON.stringify(result.diagnostics, null, 2),
-  );
-});
-
-test('semanticChecks reports unknown contract node ids before graph analysis', () => {
-  const workflow = document({
-    requiredEdges: [{ from: 'missing', to: 'resume' }],
-  });
-
-  const result = compileWorkflow({ workflow, qualityProfile: 'standard' });
-
-  assert.equal(result.ok, false);
-  assert.deepEqual(
-    result.diagnostics.map(({ code }) => code),
-    ['workflow/semantic-node-reference'],
-  );
-  assert.equal(result.diagnostics[0].subject.path, '/semanticChecks/requiredEdges/0/from');
-});

package/template/.hermes/skills/archify/test/yss-safe-deliver.test.mjs

@@ -1,153 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const skillRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const wrapper = path.join(skillRoot, 'scripts', 'yss-safe-deliver.mjs');
-const example = path.join(skillRoot, 'examples', 'web-app.architecture.json');
-
-function repository(mode = 'project-instance') {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'yss-archify-safe-'));
-  fs.writeFileSync(path.join(root, 'yss-project.yaml'), `schema_version: 1\nrepository_mode: ${mode}\n`);
-  return root;
-}
-
-function run(root, input, output, extra = []) {
-  return spawnSync(process.execPath, [wrapper, 'architecture', input, output, ...extra], {
-    cwd: root,
-    encoding: 'utf8',
-  });
-}
-
-test('rejects stable output outside the repository-mode allowlist', () => {
-  const root = repository();
-  const input = path.join(root, 'diagram.archify.json');
-  fs.copyFileSync(example, input);
-  const result = run(root, input, path.join(root, 'docs', 'architecture', 'diagram.html'));
-  assert.notEqual(result.status, 0);
-  assert.match(result.stderr, /输出目录必须先随配对的 JSON 源建立|稳定图必须位于/);
-});
-
-test('refuses to overwrite an unrelated file inside the allowlist', () => {
-  const root = repository();
-  const directory = path.join(root, 'docs', 'architecture', 'diagrams', 'runtime-map');
-  fs.mkdirSync(directory, { recursive: true });
-  const input = path.join(directory, 'runtime-map.archify.json');
-  const output = path.join(directory, 'runtime-map.html');
-  fs.copyFileSync(example, input);
-  fs.writeFileSync(output, 'do-not-overwrite');
-  const result = run(root, input, output);
-  assert.notEqual(result.status, 0);
-  assert.match(result.stderr, /拒绝覆盖非 Archify 产物/);
-  assert.equal(fs.readFileSync(output, 'utf8'), 'do-not-overwrite');
-});
-
-test('refuses to overwrite an unrelated receipt inside the allowlist', () => {
-  const root = repository();
-  const directory = path.join(root, 'docs', 'architecture', 'diagrams', 'runtime-map');
-  fs.mkdirSync(directory, { recursive: true });
-  const input = path.join(directory, 'runtime-map.archify.json');
-  const output = path.join(directory, 'runtime-map.html');
-  const receipt = path.join(directory, 'runtime-map.receipt.json');
-  fs.copyFileSync(example, input);
-  fs.writeFileSync(receipt, '{"owner":"human"}\n');
-  const result = run(root, input, output);
-  assert.notEqual(result.status, 0);
-  assert.match(result.stderr, /拒绝覆盖非 YSS Archify receipt/);
-  assert.equal(fs.readFileSync(receipt, 'utf8'), '{"owner":"human"}\n');
-});
-
-test('rejects an allowlisted path that escapes through a symlink', () => {
-  const root = repository();
-  const base = path.join(root, 'docs', 'architecture', 'diagrams');
-  const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'yss-archify-escape-'));
-  fs.mkdirSync(base, { recursive: true });
-  fs.symlinkSync(outside, path.join(base, 'runtime-map'));
-  const input = path.join(outside, 'runtime-map.archify.json');
-  fs.copyFileSync(example, input);
-  const output = path.join(base, 'runtime-map', 'runtime-map.html');
-  const result = run(root, input, output);
-  assert.notEqual(result.status, 0);
-  assert.match(result.stderr, /稳定图必须位于|输出目录越过允许根|符号链接/);
-  assert.equal(fs.existsSync(path.join(outside, 'runtime-map.html')), false);
-});
-
-test('rejects interactive --open delivery in the YSS wrapper', () => {
-  const root = repository();
-  const directory = path.join(root, 'docs', 'architecture', 'diagrams', 'runtime-map');
-  fs.mkdirSync(directory, { recursive: true });
-  const input = path.join(directory, 'runtime-map.archify.json');
-  const output = path.join(directory, 'runtime-map.html');
-  fs.copyFileSync(example, input);
-  const result = run(root, input, output, ['--open']);
-  assert.notEqual(result.status, 0);
-  assert.match(result.stderr, /不允许 --open/);
-});
-
-test('delivers a paired project artifact and an auditable receipt', () => {
-  const root = repository();
-  const directory = path.join(root, 'docs', 'architecture', 'diagrams', 'runtime-map');
-  fs.mkdirSync(directory, { recursive: true });
-  const input = path.join(directory, 'runtime-map.archify.json');
-  const output = path.join(directory, 'runtime-map.html');
-  fs.copyFileSync(example, input);
-  const result = run(root, input, output);
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(fs.readFileSync(output, 'utf8').slice(0, 2048), /meta name="generator" content="archify 2\.16\.0"/);
-  const receipt = JSON.parse(fs.readFileSync(path.join(directory, 'runtime-map.receipt.json'), 'utf8'));
-  assert.equal(receipt.yssArchifyReceipt, true);
-  assert.equal(receipt.archify.validation.checkCount, 9);
-  assert.equal(receipt.archify.validation.warnings, 0);
-});
-
-test('uses the template-source evidence root for stable maintenance diagrams', () => {
-  const root = repository('template-source');
-  const directory = path.join(root, '.template-source', 'evidence', 'maintenance', 'diagrams', 'workflow-map');
-  fs.mkdirSync(directory, { recursive: true });
-  const input = path.join(directory, 'workflow-map.archify.json');
-  const output = path.join(directory, 'workflow-map.html');
-  fs.copyFileSync(example, input);
-  const result = run(root, input, output);
-  assert.equal(result.status, 0, result.stderr);
-  assert.ok(fs.existsSync(path.join(directory, 'workflow-map.receipt.json')));
-});
-
-test('uses an exclusive unpredictable staging directory for the receipt', () => {
-  const source = fs.readFileSync(wrapper, 'utf8');
-  assert.match(source, /fs\.mkdtempSync\(/);
-  assert.match(source, /flag: 'wx'/);
-  assert.doesNotMatch(source, /receipt}\.tmp-\$\{process\.pid\}/);
-
-  const root = repository();
-  const directory = path.join(root, 'docs', 'architecture', 'diagrams', 'runtime-map');
-  fs.mkdirSync(directory, { recursive: true });
-  const input = path.join(directory, 'runtime-map.archify.json');
-  const output = path.join(directory, 'runtime-map.html');
-  const unrelated = path.join(root, 'unrelated.txt');
-  const legacySymlink = path.join(directory, 'runtime-map.receipt.json.tmp-12345');
-  const legacyFile = path.join(directory, 'runtime-map.receipt.json.tmp-67890');
-  fs.copyFileSync(example, input);
-  fs.writeFileSync(unrelated, 'preserve-me');
-  fs.symlinkSync(unrelated, legacySymlink);
-  fs.writeFileSync(legacyFile, 'preserve-this-too');
-
-  const result = run(root, input, output);
-  assert.equal(result.status, 0, result.stderr);
-  assert.equal(fs.readFileSync(unrelated, 'utf8'), 'preserve-me');
-  assert.equal(fs.readFileSync(legacyFile, 'utf8'), 'preserve-this-too');
-  assert.equal(fs.readlinkSync(legacySymlink), unrelated);
-  assert.deepEqual(
-    fs.readdirSync(directory).filter((entry) => entry.startsWith('.runtime-map.receipt.json.tmp-')),
-    [],
-  );
-});
-
-test('YSS override disables the upstream update checker', () => {
-  const skill = fs.readFileSync(path.join(skillRoot, 'SKILL.md'), 'utf8');
-  assert.match(skill, /Do not run `scripts\/check-update\.mjs`/);
-  assert.match(skill, /yss-safe-deliver\.mjs/);
-});

package/template/.hermes/skills/ask-matt/PHASE-BOUNDARIES.md

@@ -1,55 +0,0 @@
-# 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/template/.hermes/skills/ask-matt/SKILL.md

@@ -1,95 +0,0 @@
----
-name: ask-matt
-description: Ask which skill or flow fits your situation. A router over the skills in this repo.
-disable-model-invocation: true
----
-
-# Ask Matt
-
-You don't remember every skill, so ask.
-
-## YSS default (read this first)
-
-In this template, **`yss-product-lifecycle` is the default orchestrator**. Native work-units own Spec, tickets, implementation authorization, and gates.
-
-This skill is a **Matt compatibility map**. Use `/grill-with-docs`, `/to-spec`, `/to-tickets`, and `/implement` only when the user **explicitly** names them. Do not treat the idea→ship list below as the YSS default. `/implement` does not grant git commit/push. Spec drafts from `/to-spec` stay `ready-for-human` until a human approves the Spec baseline.
-
-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.
-
-## Matt compatibility flow: idea → ship
-
-The route most work travels. You have an idea and want it built.
-
-1. **`/grill-with-docs`** — sharpen 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` — see 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 `docs/.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`** (Standards + Spec, plus UI fidelity when UI is in scope). Do not commit or push from `/implement`. 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 — go straight to `/implement` only when the effort turned out genuinely small.
-
-## Codebase health
-
-Not feature work — upkeep.
-
-- **`/improve-codebase-architecture`** — run 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`** — 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`** — write 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`** — compress this context and seed 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`** — 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`** — work 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 finish the operation. It never runs `--abort`. Standalone and off every flow: reach for it when you are already mid-conflict.
-- **`/prototype`** — 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.
-- **`/yss-research`** — investigate technical or strategy evidence using `technical-evidence` / `strategy-evidence` and `quick` / `evidence-audited` modes. Use a background agent when the runtime supports it and parallel reading is useful; delegation is not a trust guarantee. The old `/research` name is a deprecated alias. Research feeds `/grill-with-docs` and lifecycle decisions; it does not approve them.
-- **`/to-questionnaire`** — when the thing blocking you isn't in your head or the codebase but in **someone else's**, this 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`.
-- **`/wait-what`** — 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`** — 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/template/.hermes/skills/ask-matt/agents/openai.yaml

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

package/template/.hermes/skills/code-review/SKILL.md

@@ -1,122 +0,0 @@
----
-name: code-review
-description: Use when the user wants to review a branch, PR, committed candidate, uncommitted work-in-progress changes, or changes since a fixed point. For YSS implementation, Standards must load Slice contract required_skills plus specialist check inputs such as alibaba-java-code-style and yss-ui; do not add a second generic review skill.
----
-
-Review of a pinned candidate against a fixed point on two core axes, plus UI fidelity when UI is in scope:
-
-- **Standards** — does the code conform to this repo's documented coding standards **and**, for YSS slices, the specialist check inputs compiled in [yss-review-standards.md](references/yss-review-standards.md)?
-- **Spec** — does the code faithfully implement the originating issue / spec?
-- **UI fidelity** (only when the change has UI impact) — does the candidate match the confirmed prototype and `yss-design-system` / `yss-ui`? Type-check or claiming "already aligned" is not a pass. Invoke those skills' verification notes; do not collapse this axis into Standards or Spec. YSS page-module conventions stay on Standards.
-
-Standards and Spec run as **parallel sub-agents** so they don't pollute each other's context, then this skill aggregates their findings. When UI is in scope, add a separate UI fidelity pass after those two reports (do not merge it into either axis).
-
-If `docs/agents/issue-tracker.md` is missing, tell the user to run `/setup-matt-pocock-skills`; do not invoke another user-invoked skill yourself.
-
-## Process
-
-### 1. Pin the fixed point and candidate
-
-Whatever the user said is the fixed point — a commit SHA, branch name, tag, `main`, `HEAD~5`, etc. If they didn't specify one, ask for it.
-
-Choose one candidate mode from the request or an upstream review contract:
-
-- **Committed candidate** — review committed branch/PR state. Capture `git diff <fixed-point>...HEAD` and `git log <fixed-point>..HEAD --oneline`.
-- **Worktree candidate** — review work in progress without requiring a commit. Resolve `<merge-base>` with `git merge-base <fixed-point> HEAD`, then capture:
-  - `git diff --no-ext-diff --binary --full-index <merge-base>` for committed, staged and unstaged tracked content as it exists in the working tree;
-  - `git ls-files -z --others --exclude-standard` for NUL-delimited raw untracked paths;
-  - each untracked file's content, using `git diff --no-index --no-ext-diff --binary --full-index -- /dev/null <path>` when a diff representation is useful. Exit code `1` from this command means a difference was found, not that review failed;
-  - `git log <fixed-point>..HEAD --oneline` for the committed portion of the candidate.
-
-Record one **candidate manifest** before spawning reviewers:
-
-```yaml
-review_mode: committed # or worktree
-review_base_ref: <fixed-point>
-merge_base: <resolved-sha>
-implementation_candidate_ref: HEAD # or working-tree
-candidate_snapshot_ref: <immutable-commit-or-captured-snapshot>
-candidate_digest: <sha256-or-immutable-tree-id>
-tracked_diff_command: <command>
-untracked_inventory_command: <command-or-null>
-untracked_files: []
-commit_list_command: <command>
-```
-
-For a Committed candidate, resolve `HEAD` to an immutable commit and tree before review. Its manifest must include `merge_base`, `tracked_diff_command` and `commit_list_command`. For a Worktree candidate, the manifest must additionally include `untracked_inventory_command`, `untracked_diff_command` and the exact `untracked_files` inventory.
-
-For a Worktree candidate, capture the tracked binary diff and every untracked file's bytes once into an immutable snapshot, compute `candidate_digest`, and make that **captured candidate** available to both reviewers. The following is normative, not illustrative: use the `yss-worktree-candidate-v1` byte stream. Start with ASCII `YSS-WORKTREE-CANDIDATE-V1` followed by one NUL byte. Append one tracked record: byte `0x54`, unsigned 64-bit big-endian binary-diff byte length, then the exact stdout bytes from `git diff --no-ext-diff --binary --full-index <merge-base>`. Then append one untracked record for each NUL-delimited raw path from `git ls-files -z --others --exclude-standard`, sorted bytewise by the raw path: byte `0x55`, unsigned 64-bit big-endian path length, raw path bytes, unsigned 32-bit big-endian `lstat` mode, entry-kind byte (`0x52` regular or `0x4c` symlink), unsigned 64-bit big-endian content length, then raw regular-file bytes or raw symlink-target bytes. Other entry kinds block capture. This is the sole length-prefixed framing and bytewise path order for the digest. SHA-256 is calculated over exactly this stream. New captures use a previously nonexistent directory under `.template-source/evidence/maintenance/`, land atomically, and store exactly `candidate-manifest.yaml`, `candidate.bin` and `tracked.diff`; `candidate.bin` already contains every untracked byte, so do not duplicate hundreds of `untracked-content/000xxx` files. Explicit exclusions are fail-closed to `.template-source/evidence/maintenance/` evidence and cannot exclude implementation or authority assets. Historical per-file snapshots remain readable. Both reviewers must consume the captured stream and must not independently treat a live worktree as the reviewed candidate.
-
-Before going further, confirm the fixed point and merge-base resolve. A committed candidate must have a non-empty committed diff. A Worktree candidate is non-empty when either its tracked diff or untracked inventory is non-empty. A bad ref, missing candidate part or empty candidate should fail here — not inside two parallel sub-agents. Do not silently downgrade Worktree review to `HEAD`-only review.
-
-### 2. Identify the spec source
-
-Look for the originating spec, in this order:
-
-1. A spec/Ticket/contract reference supplied by the user or an upstream lifecycle review input.
-2. Issue references in the commit messages (`#123`, `Closes #45`, GitLab `!67`, etc.) — fetch via the workflow in `docs/agents/issue-tracker.md`.
-3. A spec file under `docs/`, `specs/`, or `docs/.scratch/` matching the branch name or feature.
-4. If nothing is found, ask the user where the spec is. If they say there isn't one, the **Spec** sub-agent will skip and report "no spec available".
-
-### 3. Identify the standards sources
-
-Compile sources **before** spawning reviewers. For YSS implementation candidates follow [yss-review-standards.md](references/yss-review-standards.md): run machine checks that exist in the implementation repo; then collect repo docs (`CODING_STANDARDS.md` / `CONTRIBUTING.md` if present), every Slice `required_skills` skill file, the impact-conditioned specialist inputs (`alibaba-java-code-style`, `yss-ui`, `yss-domain`, …), and `docs/templates/review-report-template.md`. Missing applicable coverage is `missing_evidence`, not a pass.
-
-Anything in the repo that documents how code should be written, such as `CODING_STANDARDS.md` or `CONTRIBUTING.md`, remains a source. It does **not** replace YSS or Alibaba specialist inputs.
-
-On top of whatever the repo documents, the Standards axis always carries the **smell baseline** below — a fixed set of Fowler code smells (_Refactoring_, ch.3) that applies even when a repo documents nothing. Two rules bind it:
-
-- **The repo overrides.** A documented repo standard always wins; where it endorses something the baseline would flag, suppress the smell.
-- **Always a judgement call.** Each smell is a labelled heuristic ("possible Feature Envy"), never a hard violation — and, like any standard here, skip anything tooling already enforces.
-
-Each smell reads *what it is* → *how to fix*; match it against the diff:
-
-- **Mysterious Name** — a function, variable, or type whose name doesn't reveal what it does or holds. → rename it; if no honest name comes, the design's murky.
-- **Duplicated Code** — the same logic shape appears in more than one hunk or file in the change. → extract the shared shape, call it from both.
-- **Feature Envy** — a method that reaches into another object's data more than its own. → move the method onto the data it envies.
-- **Data Clumps** — the same few fields or params keep travelling together (a type wanting to be born). → bundle them into one type, pass that.
-- **Primitive Obsession** — a primitive or string standing in for a domain concept that deserves its own type. → give the concept its own small type.
-- **Repeated Switches** — the same `switch`/`if`-cascade on the same type recurs across the change. → replace with polymorphism, or one map both sites share.
-- **Shotgun Surgery** — one logical change forces scattered edits across many files in the diff. → gather what changes together into one module.
-- **Divergent Change** — one file or module is edited for several unrelated reasons. → split so each module changes for one reason.
-- **Speculative Generality** — abstraction, parameters, or hooks added for needs the spec doesn't have. → delete it; inline back until a real need shows.
-- **Message Chains** — long `a.b().c().d()` navigation the caller shouldn't depend on. → hide the walk behind one method on the first object.
-- **Middle Man** — a class or function that mostly just delegates onward. → cut it, call the real target direct.
-- **Refused Bequest** — a subclass or implementer that ignores or overrides most of what it inherits. → drop the inheritance, use composition.
-
-### 4. Spawn both sub-agents in parallel
-
-**Standards sub-agent prompt** — include:
-
-- The full candidate manifest, captured candidate, `candidate_digest`, diff/inventory commands and commit list. For Worktree candidates, explicitly include every untracked file.
-- The list of standards-source files you found in step 3, **plus the smell baseline from step 3** pasted in full. Paste Fowler smells in full. For YSS specialist inputs, pass the exact skill file paths; the reviewer must read them and cite `skill + rule + location`. Do not summarise away mandatory Alibaba or YSS violations to fit a word cap. The 400-word cap applies only to the Fowler smell section.
-- Machine-check commands, exit codes and evidence from step 3. Tooling failure is a hard Standards violation.
-- The brief: "Report — per file/hunk where relevant — (a) every place the diff violates a documented standard or a required YSS / Alibaba specialist rule: cite the skill or file and the rule; (b) any baseline smell you spot: name it and quote the hunk. Distinguish hard violations from judgement calls — documented-standard and mandatory specialist breaches can be hard, but baseline smells are always judgement calls, and a documented repo standard overrides the baseline. Skip anything the machine checks already enforced. Smell section under 400 words; specialist findings have no word cap."
-
-**Spec sub-agent prompt** — include:
-
-- The same candidate manifest, captured candidate, `candidate_digest`, diff/inventory commands and commit list.
-- The path or fetched contents of the spec.
-- The brief: "Report: (a) requirements the spec asked for that are missing or partial; (b) behaviour in the diff that wasn't asked for (scope creep); (c) requirements that look implemented but where the implementation looks wrong. Quote the spec line for each finding. Under 400 words."
-
-If the spec is missing, skip the Spec sub-agent and note this in the final report.
-
-### 5. Aggregate
-
-For template-maintenance task packages carrying `review_round`, preserve the frozen scope and apply the two-round convergence contract. A hard requirement added during review must cite a rule that already applied when the candidate was frozen; otherwise report it as `judgement-call` for the backlog. Round 1 blocking findings return to the implementer and require a new digest plus all review axes. If Round 2 still has an open `violation`, `drift`, or `new_impacts`, return `needs-human` and stop; do not silently start Round 3. Candidate byte changes invalidate every earlier axis report.
-
-Present the reports under `## Standards` and `## Spec` headings, verbatim or lightly cleaned. If UI is in scope, add `## UI fidelity` from the separate pass. Fill `docs/templates/review-report-template.md` specialist tables as part of Standards evidence, not a fourth axis. Do **not** merge or rerank findings — the axes are deliberately separate (see _Why separate axes_). A YSS candidate with blank applicable specialist rows, skipped `required_skills`, or unaddressed mandatory violations is `blocked`, not `completed`. Do not close findings by writing implementation in the review session. `violation` / machine-check failure / blank applicable rows go back to the implementer on the original contract path, then recapture the candidate and rerun every axis. `drift` / `new_impacts` / `required_skills` mismatch mark the contract `stale` and return to Router; do not keep coding on the old contract. `not-applicable` is only for untriggered impacts; mandatory gates have no waiver, only repair or a complete `seam-deferred` record.
-
-For Worktree mode, recapture the candidate digest after both reports return. If it differs from `candidate_digest`, mark both reports as reviewing a **stale candidate** and return `blocked`; the caller may start a new review against a new capture, but this invocation must not aggregate findings from different bytes. Recheck the same digest again at the completion/checkpoint boundary.
-
-State the reviewed `review_mode`, fixed point, candidate digest and coverage before the two reports. End with a one-line summary: total findings per axis, and the worst issue _within each axis_ (if any). Don't pick a single winner across axes — that's the reranking the separation exists to prevent.
-
-## Why separate axes
-
-A change can pass one axis and fail the other:
-
-- Code that follows every standard but implements the wrong thing → **Standards pass, Spec fail.**
-- Code that does exactly what the issue asked but breaks the project's conventions → **Spec pass, Standards fail.**
-- Code that implements the spec but diverges from the confirmed prototype or design system → **Spec pass, UI fidelity fail.**
-
-Reporting them separately stops one axis from masking the other.

package/template/.hermes/skills/code-review/agents/openai.yaml

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

package/template/.hermes/skills/code-review/references/yss-review-standards.md

@@ -1,54 +0,0 @@
-# YSS 审查标准源与机器检查
-
-本文件只服务唯一默认审查技能 `code-review`。Alibaba Java、YSS 前端 / 后端 skill 是 **Standards 轴的专项检查输入**，不是第二个通用审查 skill。
-
-权威接线：`yss-product-lifecycle/references/orchestration-contract.yaml` 的 `work-unit.code-review.review_standards_route` 与 `review_input`。报告形状：`docs/templates/review-report-template.md`。
-
-## 1. 编译标准源
-
-按顺序收集，缺项写 `not-applicable` 及原因，不得省略适用项：
-
-1. 仓库文档：`CODING_STANDARDS.md`、`CONTRIBUTING.md` 或实现仓等价文件（若存在）。
-2. Slice Implementation Contract 的 `required_skills`：对每个技能读取 `.agents/skills/<id>/SKILL.md` 及该 skill 指明的 references。
-3. 影响面专项检查输入（与合同并集，不得互相替代）：
-   - 后端：`alibaba-java-code-style`、`yss-domain`、`yss-application`、`yss-repository`、`yss-web-controller`、`yss-dto`、`mapstruct`、`lombok`
-   - UI：`yss-ui`、`yss-design-system`、`yss-ui-business-page-generation`、`yss-page-module-development`
-4. 报告模板中的后端 / 前端门禁表。空着的适用行视为 `missing_evidence`。
-
-YSS 页面模块约定（YTable、YFormily、页面骨架等）走 Standards，不并入 UI fidelity。UI fidelity 只核原型与状态矩阵。
-
-审查者只读这些 skill，不得用它们写实现路径。`role.test-engineer` 任务包禁止 `implement` 与脚手架生成器。
-
-## 2. 机器检查
-
-在派发 Standards / Spec 子审查之前，对实现仓**已登记且当前可执行**的命令实际跑一遍：
-
-- 后端优先：切片合同里的 `./mvnw` 验证；若工程已配置 Checkstyle / P3C / Spotless / `validate`，一并执行。
-- 前端优先：切片合同里的 `pnpm` 验证；若存在 `pnpm lint` / `pnpm type-check`，一并执行。
-
-记录命令、退出码、时间和证据引用。退出码非 0 记为 Standards **hard violation**。
-
-仓库没有对应工具时，该工具行写 `not-applicable` 加原因。可被工具检查的 Alibaba / ESLint 规则若工具没跑、LLM 也没按原文引用规则，不得记 `pass`。无法 lint 的分层、页面骨架、Formily 约定由 LLM 按 skill 原文引用。
-
-## 3. 完成阻断
-
-出现以下任一情况时，`work-unit.code-review` 不得 `completed`：
-
-- 未消费合同 `required_skills` 或漏掉命中影响面的专项检查输入
-- 报告模板适用行空白或只写“符合 YSS / 符合阿里规范”
-- mandatory Alibaba 或 YSS 门禁 `violation` 未关闭
-- 机器检查失败，或可检查规则既无工具结果也无原文引用
-- 用第二个通用审查 skill 代替 `code-review`
-
-## 4. Finding 分流与豁免
-
-产品切片与模板维护使用**同一闭环**；只是强度不同：切片绑定当前 Slice Implementation Contract，模板维护绑定 L1 / L2 / L3。权威字段：`review_standards_route.finding_disposition`。
-
-审查者只记录 finding，不得当场改实现代码。
-
-| 类型 | 动作 |
-|---|---|
-| `violation`、机器检查失败、适用行空白、`missing_evidence` | 实现者在**原合同允许路径**内修复；任何修复使候选失效，必须重新捕获并重跑 Standards、Spec、UI fidelity（若命中）和 fresh verification |
-| `drift`、`new_impacts`、`required_skills` 与真实影响不一致 | 合同标 `stale`，回 Router 或更早生命周期阶段；禁止在旧合同上继续编码 |
-
-`not-applicable` 仅当影响面未命中。命中后的 mandatory 不得豁免；只允许修复，或写完整 `seam-deferred`（风险、责任人、后续 Ticket、验证计划、目标版本或发布日期）。禁止为日常 Alibaba / YSS 新增生物人豁免门禁；安全 / 公共 API 仍走既有 `TODO-HUMAN-REVIEW` 与生物人门禁。