@azure-id/orc 0.55.0

package/templates/skills/orc-fast/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: orc-fast
+description: >
+  Fastest ORC lane — knowledge-gated single-executor implementation. Use for
+  "use orc-fast to implement X" or "/orc-fast". Requires TWO prerequisites:
+  a fresh project wiki (orc-wiki) AND a cached code-pattern for the request's
+  language — the precomputed knowledge replaces the analyst/planner entirely.
+  Either missing → falls back to orc-mini (never stops the chat). One
+  Sonnet 4.6 high executor, a build+test smoke gate, one repair round, ship.
+  Orchestrator runs fine at Sonnet medium. The orchestrator never implements —
+  it spawns.
+---
+
+# ORC-FAST
+
+The speed lane: precomputed knowledge instead of pipeline phases — the wiki
+supplies grounding, the pattern cache supplies house style, so fast pays for
+neither an analyst nor a planner. That trade only holds when both exist and
+the wiki is fresh, so the two prerequisite gates below are hard: fail either →
+**fall back to orc-mini** carrying whatever intake was done. Fallback is the
+router — orc-fast is always safe to try.
+
+Runs fine with the orchestrator at **Sonnet 4.6 / Sonnet 5, medium effort** —
+no scoring, no planning judgment (the effort guard only gates the full `orc`
+skill). **You never implement — you spawn.**
+
+## What fast deliberately does NOT have
+
+No analyst, planner, scoring, waves, reviewer, verifier, test-author, or
+summary. One executor, one smoke gate, one repair round. More than that → the
+fit gate hands it to orc-mini.
+
+## Phase F0 — Preflight (the two prerequisite gates; no spawn)
+
+Emit a `GATE` trace line per check when logging.
+
+**a. Wiki gate.** Decide existence with `orc wiki status` — the deterministic
+probe in `../_shared/detecting-artifacts.md`, never an ad-hoc `find` (`.claude`
+is hidden). `none` = gate FAILED → fallback; else wiki present → compute the
+tier from `.claude/orc/wiki-meta.json` per `../orc-wiki/references/staleness.md`:
+`git rev-list --count <scan_commit>..HEAD` → FRESH / AGING / STALE (manifest
+absent but docs present = STALE; wiki absent/empty = gate FAILED → fallback).
+- **FRESH** → proceed silently. **AGING** → one-line notice, proceed.
+- **STALE** → the user judges. Ask with exactly these options:
+  1. **Refresh wiki, then continue fast** *(recommended)* — run orc-wiki's
+     incremental refresh (diff since `scan_commit`, re-scan only affected
+     docs), then re-enter this preflight.
+  2. **Drop to orc-mini** *(preferable if in a hurry — mini grounds itself)*.
+  3. **Continue fast anyway** *(not recommended — the executor may follow
+     stale claims)* — proceed and stamp `wiki_stale_override: true` in the
+     checkpoint so /orc-retro can correlate outcomes with overrides.
+
+**b. Pattern gate.** Detect the request's language (file extensions / repo
+deps, same signals as the full lane's tagging) and confirm the cache with
+`orc pattern status <lang>` (exit 0 = cached — the deterministic probe in
+`../_shared/detecting-artifacts.md`, never an ad-hoc `find`). Absent for the
+language in play → gate FAILED → fallback. (A request touching no FE/BE language — pure docs/
+config — passes this gate as N/A.) The cross-cutting `postgres` pattern is
+NEVER a gate prerequisite — it is bonus-only (injected at F2 on a cache HIT),
+so a missing `postgres-pattern.md` never fails the gate or forces a fallback.
+
+**Any gate FAILED** → announce which prerequisite failed in one line, then
+hand off to orc-mini via the fallback contract below. Never stop the chat.
+
+**c. Gotchas — NOT a gate.** Two prerequisites stay two: a missing
+`.claude/orc/gotchas.md` never forces a fallback. Fast READS repair memory
+(`orc gotcha status`, then inject the SCOPE-MATCHING entries into the F2 slice,
+cap 3) and never WRITES it — `../_shared/gotchas.md` §10.
+
+## Phase F1 — Fit gate + micro-intake (one pass, ONE user round-trip)
+
+Draft a 3–5 line intent spec + 2–3 acceptance bullets. Judge fit: more than
+one real task, ~5+ files, or core/security-sensitive surface → fallback to
+orc-mini WITH the intent spec attached (no rework); emit a `GATE` line for the
+verdict. Then the lane's ONLY pre-spawn ask — one combined confirmation:
+preflight result + intent spec + acceptance bullets + "proceed?" (soft
+sign-off; never split into multiple questions). Create the run folder
+(`.claude/orc/run/{run-slug}/` — shared format, so fallback needs no
+migration) and write the intent-spec + a minimal checkpoint.
+
+## Phase F2 — Slice build + dispatch (ONE executor)
+
+Build one slice for `orc-executor-sonnet-4-6-high` (dispatch BY NAME; model
+pinned in the agent file). **Under `opus5_only` it is `orc-executor-opus-5-low`** — forced, and while that mode is on this lane needs an Opus 5 main session, so the "runs fine at Sonnet medium" premise applies only with it off (`../_shared/opus5-only.md`).
+
+**Extra (`extra_enabled`, `../_shared/extra-dispatch.md`):** the same slice may run off Claude. **This lane has no score at all, so it holds a POSITION, not a band:** resolve `orc extra resolve --slot fast-executor --json` (set with `orc extra role set fast-executor <profile>/<model>`). No row on that slot = Claude, and that is an answer, not a gap. The `extra:` line joins the F0 preflight (P0, printed whenever the gate is on) and NAMES the agent it displaces — `orc-executor-sonnet-4-6-high`; dispatch through `orc extra dispatch --task <file> --json` with `slot: "fast-executor"` and **no `score`** (both is refused by name); validate with `return-validation.md` **§2b, not §2**; a failure runs `orc extra reconcile <task_id>` FIRST — a worktree that moved is RESUMED, never re-done — then falls back to that same pinned agent BY NAME, announced. Extra is orthogonal to the knowledge gate — a fresh wiki and a cached pattern are still required, and a foreign worker gets the same pointers-not-content slice.
+
+- the task (intent spec) + acceptance bullets as definition-of-done
+- **wiki pointers, not content** (fast's lane-delta in
+  `../orc/references/wiki-consult.md`): the PATHS of 1–3 relevant pages
+  selected from `wiki/INDEX.md` by keyword match — prefer the cross-cutting
+  maps (`orc-reference-api-surface` etc.) when the domain matches. Instruct
+  the executor to READ them first, and include the precedence line verbatim:
+  `code > fresh wiki > stale wiki (hints) > model priors`. Never paste wiki
+  bodies into the slice (a Sonnet-medium orchestrator curating wiki prose
+  defeats the lane). **Emit `WIKI-CONSULT <tier> :: docs=<the selected pointer
+  paths>`** (tier from the F0 gate; `docs=none` if no pages fit) — the F0
+  `GATE` line captured the gate *decision*; this captures which pages grounded
+  the run.
+- the cached pattern injected LITERALLY (same `pattern` slice contract as
+  full; the pattern file is small by design)
+- **crosslink (cross-repo, advisory):** a task touching a boundary in
+  `.claude/orc/crosslink/needs.json` gets the cached linked contract injected
+  as `crosslink` ("hints, not verified") — advisory, never blocks, never
+  outranks local code.
+- **`db:postgres` bonus:** a data-access task with
+  `.claude/orc/patterns/postgres-pattern.md` CACHED merges it into the same
+  `pattern` slice (query invariants). Cache MISS → skip silently — fast never
+  codifies and never falls back on this.
+- **the read ladder** (`../_shared/read-ladder.md`): read only as far up as the
+  question needs — a file the task will EDIT is read in full first. Precomputed
+  knowledge REPLACING exploration is this lane; a directory sweep is not.
+- the standing `house_rules` card (`../orc/references/house-rules.md`,
+  injected literally, same as full/mini)
+- constraints from the intent spec
+- **terse-return rule:** standard contract fields, NO narrative prose — files
+  changed, one-line diff summary, smoke-relevant notes only.
+
+Validate the return per `../_shared/return-validation.md` — `unmet[]`
+honesty, `pattern_version` + `invariants_checked` attestation, `actual_model`
+/ `actual_effort` downgrade check (emit the `VERIFY` trace line), and §6's worktree delta (`git status --short` before/after; a path changed outside `declared_files` is a violation whatever the return said). Malformed
+return = failure (one re-dispatch, then fallback offer).
+
+## Phase F3 — Smoke gate (build + test; blocks ship on red)
+
+Run the gate per `../_shared/smoke-gate.md`, sourcing commands **from
+`wiki-meta.json`'s `commands` block** (recorded at wiki scan — don't
+rediscover tooling; manifest lacks them → detect once and say so). **GREEN**
+→ ship. **RED** → one repair round; second red → STOP and offer: escalate to
+orc-mini (reason `smoke-red-escalation`) / switch to full `/orc` / stop.
+Docs-only → gate N/A, say so.
+
+## Phase F3.5 — Mock example (config `mock_example`, default ask)
+
+Canonical: `../_shared/drift-recovery.md` — load on fire. Only after a GREEN
+F3, before ship: `ask` → MANDATORY offer · `on` → build · `off` → skip.
+Deliverable `mock-examples/<change-slug>/` at project root — **never
+committed/staged**. Drift answer → `DRIFT-FROM` recovery (cap 2 loops, honest
+report on cap). Trace: `PHASE mock-example`, `DRIFT loop=<n>`.
+
+## Phase F4 — Ship
+
+Offer commit (push if asked; never stage `mock-examples/`). Append the final markers to the checkpoint, emit
+`OUTCOME task=… band=fast model=… retries=… unmet=…` + `FINISH`, show the
+dispatch line (model/effort actually used) + the `/usage` reminder. Fast never
+triggers the post-ship wiki refresh ask (preflight polices freshness on the
+way in) — the passive stale-flag note still applies to touched covered files.
+
+## Fallback contract (orc-fast → orc-mini)
+
+Follow the writer side of `../_shared/fallback-handoff.md`: announce the
+failed gate in one line, write the `FALLBACK-FROM` block into the run folder
+(REASON: wiki-absent | wiki-stale-user-choice | pattern-absent | fit-gate |
+smoke-red-escalation), and invoke orc-mini pointing at it. The run folder is
+already in the shared format — no migration.
+
+## Behavior trace (PERMANENT — same rule as every lane; always on)
+
+Follow `../orc/references/trace-protocol.md`: at run start write
+`log_dir/.current` = `run-fast-<slug>-<DDMMYY>-<HHMMSS>.txt`, `touch the trace file`
+of that name in the SAME step, + store `trace_path`. Narration is **dispatched, never remembered**: record each event
+with its REAL timestamp into a packet (F0–F4 `PHASE`, `GATE` at the preflight/
+fit/smoke verdicts, `DISPATCH`/`VERIFY` — `actual_model`/`actual_effort` vs
+expected — `OUTCOME`, `FINISH`, plus `decisions` = the WHY), then dispatch
+`orc-trace-writer-haiku-4-5` PAIRED with the next dispatch; fast batches to
+**2 packets** (preflight+dispatch, gate+ship). A phase ending with
+zero new trace lines is a protocol violation — dispatch its packet NOW. The
+`FINISH` packet returns BEFORE you delete `log_dir/.current`.
+
+## Config
+
+Resolve at run start (`../orc/config.md` ← `.claude/orc.config.yaml`):
+`wiki_fresh_max` / `wiki_aging_max` (tier edges) + `log_dir`. Fast has no
+config key of its own — command-entry only; wave/scoring/review keys never
+apply.
+
+## Checkpoint (minimal, append-only)
+
+One `fast-checkpoint.md` in the run folder: GATE results (+ any
+`wiki_stale_override`), the dispatch, smoke verdicts, OUTCOME — enough for
+/orc-retro mining and fresh-session resume, nothing more.
+
+## What fast still enforces (from the main hard rules)
+
+Never implement yourself (smoke gate = read-only build+test) · all artifacts
+in the run subfolder, never project root · validate the subagent return
+(malformed = failure) · never offer commit on a red build · report the
+dispatch + remind the user to run `/usage` (never invoke it programmatically).

package/templates/skills/orc-grill/SKILL.md

@@ -0,0 +1,207 @@
+---
+name: orc-grill
+description: >
+  Standalone idea-sharpening lane — start from one vague sentence and leave with
+  a settled idea written down. Use for "/orc-grill", "help me think this
+  through", "I want X but I do not know what I want yet", "something is wrong
+  with Y". It asks you rounds of questions (every question that is ready, in the
+  same round), looks facts up itself instead of making you recite your own
+  codebase, and stops only when YOU say the idea matches what you meant. Three
+  exits: save it, carry it straight into /orc-analyze, or drop it. No scan, no
+  plan, no build, no run folder, no code written. The orchestrator never answers
+  its own questions.
+---
+
+# ORC-GRILL
+
+The lane you use **before** you know what you want. One short sentence is a
+complete input:
+
+> "I want notifications for merchants."
+> "Something is wrong with our refunds."
+
+**Vagueness is the input here, not a reason to refuse.** Every other lane
+punishes a thin request — the planner refuses it, the analyst absorbs it into
+`ASSUMPTION` tags and then asks you the questions anyway, at scan prices. This
+lane asks them at conversation prices, and hands the result to those lanes
+already sharp.
+
+## What this lane is NOT
+
+- **Not `/orc-analyze`.** Analyze checks a requirement **against the code**. It
+  answers "does the repo really do that?". Grill answers "what do I actually
+  want?". Grill first, analyze second — that order is the whole point.
+- **Not `/orc-plan` or `/orc`.** No tasks, no waves, no scoring, no build. It
+  never writes code and never touches a file outside its own context doc.
+- **Not `/orc-learn`.** Learn teaches you an existing feature. Grill shapes one
+  that does not exist yet.
+- **Not `/orc-quick`.** Quick DOES something now. Grill decides what should be
+  done at all.
+- **Not `/orc-brainstorm`.** Brainstorm GENERATES options when you have none —
+  it proposes and you judge. Grill sharpens the one you have — it asks and you
+  answer. Brainstorm picks which mountain; grill picks the path up it.
+
+## Nothing to configure
+
+Standalone and command-entry only. It reads `log_dir` and nothing else. No
+dispatch-forcing key applies, because it has no scored dispatch to force.
+
+---
+
+## G0 — Preflight (ONE time, silent, nothing here can stop the run)
+
+1. **Config.** Read `log_dir`. Read no other key.
+2. **Trace.** Write `log_dir/.current` = `run-grill-<slug>-<DDMMYY>-<HHMMSS>.txt`
+   AND `touch the trace file` of that name in the SAME step. Both, or neither.
+   The slug comes from the user's opening sentence; if it is too vague to slug,
+   use `idea` plus the next free number.
+3. **Knowledge probes.** Follow `../_shared/detecting-artifacts.md` — never a raw
+   `find`, because `.claude` is hidden. `orc wiki status` · `orc pattern status
+   <lang>` · `orc gotcha status`. **All three are helpful extras.** Missing
+   knowledge never gates this lane, never triggers a scan, and never causes a
+   fallback — it only means more of the frontier is a question instead of a
+   lookup. Print ONE line each, then move on.
+
+---
+
+## G1 — The interview (the whole lane)
+
+**Follow `../_shared/interview.md` exactly.** It is the canonical mechanic and
+this lane does not get a private version of it. In short, and in that file's
+words:
+
+- Build a **design tree** of open questions from the opening sentence. Draw the
+  dependencies — "which queue?" sits under "is this async at all?".
+- Ask the **whole frontier** each round: every open question whose prerequisites
+  are settled, and nothing that depends on an answer you do not have yet.
+- Use the fixed shape, so a round can be answered by number:
+  `❓ **Q1** — **<title>**: <body>`, then the recommendation alone on a `➡️` line.
+- **Facts are yours to find; decisions are the user's to make.** Resolve facts up
+  the ladder — wiki status, wiki pages, cached pattern, `orc gotcha list`, and a
+  read-only ad-hoc dispatch **last**. Never block a round on a running fact-find;
+  only the questions genuinely downstream of it wait. And never soften the other
+  half: **a lane that answers its own interview question has broken this
+  contract.**
+- Tag every settled decision `intent` or `constraint` as it settles. The
+  constraints are what later become `spec_invariants[]` — this is the step that
+  makes the conversation load-bearing instead of merely pleasant.
+
+**Fact-finding dispatches.** Read-only recon is an **ad-hoc dispatch by model +
+effort** (the `/orc-quick` recon precedent), never a pinned agent — so no agent
+file ships for this lane and the hook writes no `SPAWN`/`RETURN` for it. Announce
+it on one line before it goes out (`recon: claude-sonnet-4-6 / medium — where
+refunds are written`) so the spend is never silent, but do NOT stop the round
+waiting for permission. Emit `DISPATCH … adhoc=true` and `VERIFY` yourself; the
+agent reports its own `actual_model` / `actual_effort`.
+
+**No question cap.** Some ideas settle in three questions and some need fifty. A
+cap would truncate exactly the case this lane exists for. The controls are the
+user's own words ("stop asking, just save it") and `/orc-explain` when a round
+gets dense.
+
+**"I do not even know what the options are" is a different lane, not a worse
+answer.** When a round comes back that way — the user cannot choose because
+nobody has generated anything to choose between — OFFER `/orc-brainstorm`, which
+proposes candidates on purpose and hands the chosen direction back here. Use
+`../_shared/lane-suspend.md` (`RETURN-TO`) so the trip returns to this same
+invocation. This does not soften the rule above: handing the user a lane whose job
+is generating options is not answering their question for them. It is an offer —
+"answer it roughly and I will keep going" stays on the menu.
+
+**Ungrillable questions get named, not talked around.** "How should this feel?"
+cannot be settled by talking — say so and point at ORC's `mock_example` phase
+(`mock-examples/<slug>/`). "Does the code really do that?" is `/orc-analyze`.
+Carrying an open question with the right instrument named is a finished answer.
+
+**The confirmation gate ends the lane, not an empty frontier.** Play the idea
+back in plain words and ask whether it matches what they meant. Only a yes ends
+it.
+
+---
+
+## G2 — Exit (ONE question, three answers)
+
+Ask once, after the confirmation gate:
+
+```
+The idea is sharp now. What next?
+
+1  Stop here — save it        → writes orc-grill/<slug>/grill-context.md
+2  Continue into /orc-analyze → checks it against the real code
+3  Save the constraints to the pact → they outlive this run  (/orc-pact)
+4  Write it up as a document  → /orc-doc, so other people can act on it
+5  Stop, save nothing
+```
+
+**Exit 3 (v0.46.0)** is present only when at least one decision settled here was
+tagged `constraint`. It writes the doc first, then hands those rows — quoted
+VERBATIM, with `origin: {lane: orc-grill, run: <this run>}` — to `/orc-pact`,
+which is the only thing that writes the ledger. Without it, every constraint this
+lane settles evaporates when the run ends, which is exactly the failure `/orc-pact`
+exists for. No constraints settled → the option is **absent with the reason
+printed**, never a dead number.
+
+**Exit 4 (v0.48.0)** writes the doc first, then enters `/orc-doc` with it as the
+D1 context. The interview has already produced exactly what D1 and D4 ask for, so
+those gates are **pre-answered from the artifact and the user only confirms** —
+which is the whole point of not re-asking a frozen question. Settled decisions
+travel with their `intent`/`constraint` tags, and any `spec_invariants[]` lands
+in `context.md`'s decision table. Exits 2 and 4 are different questions: 2 asks
+*is this buildable*, 4 asks *can somebody who was not here act on it*.
+
+**When is it sharp enough?** Exit 2 exists to clear the analyst's own entry
+floor, so use that floor as the bar:
+**analyzable ⇔ the input names (a) a subject the repo could plausibly contain —
+a feature, a flow, a file, or a document — AND (b) at least one thing that should
+be true when the work is done.** Below it, exit 2 just bounces straight back.
+
+**One extra exit, present ONLY when this run was entered with a `RETURN-TO`
+marker** (`../_shared/lane-suspend.md`): `Return to /<sender-lane> — carry these
+decisions back`, and it is the recommended option in that state. It is added to
+the menu, never a replacement: a user who picks "stop, save nothing" simply does
+not return, and the sender's snapshot is still on disk. Decisions travel back with
+their `intent`/`constraint` tags intact plus `source: /orc-grill`, and the
+**Facts looked up** rows go with them.
+
+- **1 — save.** Write the doc (below) and end the run.
+- **2 — hand off.** Write the doc first, then enter `/orc-analyze` with that file
+  as the input. The analyst receives an already-scoped requirement and spends its
+  tokens **grounding it in code** instead of re-asking scope. From there it is an
+  ordinary analyze run — same phases, same gates, same `requirement-spec.md`.
+  When this lane was entered FROM `/orc-analyze` (its reverse trigger), exit 2
+  returns to that same invocation and the user retypes nothing.
+- **5 — drop it.** Write nothing. Still close the trace properly.
+
+---
+
+## The doc it writes
+
+```
+<projectRoot>/orc-grill/<slug>/grill-context.md
+```
+
+Project root, visible — **never inside `.claude/`**, never inside a run folder,
+for the same reason `/orc-quick` puts its doc there: a document a human reads and
+reuses belongs where the human can find it. One `.md` per slug, ever; the same
+slug re-opens and extends the same file. **Never staged for commit by ORC.**
+
+Shape, and what each part is for: `references/grill-doc.md`. The top carries a
+delimited `<!-- orc-grill:context -->` block so a later session reads the summary
+without reading the whole file.
+
+## Behavior trace (always on — same as every lane)
+
+Follow `../orc/references/trace-protocol.md`. Lane name `grill`. This is a
+**single-dispatch** lane: **exactly ONE end-of-run packet**, dispatched solo to
+`orc-trace-writer-haiku-4-5` after the exit choice and BEFORE you delete
+`log_dir/.current`. It carries `run_meta`, the round-by-round event list, the
+settled decisions as `decisions` (the WHY layer), the exit taken, and `FINISH`. A
+run that ends with `zero new trace lines is a protocol violation`.
+
+## Rules this lane always keeps
+
+Never answer your own question · never write code or edit a project file · never
+scan the repo · never force a lane on the user (exit 2 is an offer) · look facts
+up before asking for them · announce every dispatch · tag every decision `intent`
+or `constraint` · never stage `orc-grill/**` · tell the user to run `/usage`
+(never run it yourself).

package/templates/skills/orc-grill/references/grill-doc.md

@@ -0,0 +1,105 @@
+# The grill context doc — shape and rules
+
+This is the file `/orc-grill` writes when the user picks exit 1 or exit 2. It is
+written for a HUMAN to read later, and for `/orc-analyze` to consume as an input
+instead of re-asking scope.
+
+## Where it goes
+
+```
+<projectRoot>/orc-grill/<slug>/grill-context.md
+```
+
+- `<slug>` comes from the **first** grill on this idea. No date in the folder
+  name, so re-running with the same slug re-opens the same thread.
+- **One file per folder. Never a second `.md`.**
+- Project root, next to `orc-quick/`, `test-generator/` and `learning-docs/` —
+  never inside `.claude/`, never inside a run folder.
+- **Never staged for commit by ORC.** Do not edit `.gitignore`.
+
+## Rules
+
+1. **Write it before the exit completes.** Exit 2 writes the doc FIRST, then
+   hands off — the analyst reads a file, not a memory of a conversation.
+2. **Re-opening extends, never replaces.** A second grill on the same slug adds
+   a new dated round section and updates the context block. Earlier decisions
+   stay, with the date they were made. A decision that was later reversed is
+   struck through with its reason, not deleted — the reversal is the useful part.
+3. **Only what was settled.** A question the user never answered belongs in
+   "still open", never in "decided" with a guessed value.
+4. **Quote the user.** Their own words for what the thing is; your paraphrase is
+   how intent drifts.
+
+## The context block
+
+The top of the file carries a delimited summary:
+
+```markdown
+<!-- orc-grill:context -->
+**merchant-notifications** · last grilled 08-08-2026 · 11 decisions · 2 open
+Merchants get told when a payout fails. Email only, no in-app, no SMS.
+Batched hourly, not per-event. Existing `notifications` table is reused.
+Open: what the email actually says (needs a mock) · whether the retry
+worker already has a hook (needs code).
+<!-- /orc-grill:context -->
+```
+
+**Why the markers matter.** A later session — or `/orc-analyze` deciding whether
+this input is worth consuming — reads ONLY this block. It is small and cheap. The
+body below is for a human.
+
+## Body shape
+
+```markdown
+## What this is
+<the user's own words, quoted, then one paragraph of plain-language summary>
+
+## Decided
+| # | decision | tag | why it was settled this way |
+|---|---|---|---|
+| 1 | email only, no in-app | intent | in-app needs a socket layer that does not exist yet |
+| 2 | no new dependencies | constraint | the user said "no new deps" — verbatim |
+| 3 | batch hourly | intent | per-event was rejected: payout retries fire in bursts |
+
+`tag` is `intent` (what to build) or `constraint` (a boundary the build must not
+cross). Every `constraint` row becomes a `spec_invariants[]` entry downstream and
+is appended VERBATIM to every executor slice — so word it as an instruction, not
+as a note.
+
+## Ruled out of scope
+- SMS — "later, not now"
+- backfilling old failed payouts — the user said the data is not worth it
+
+Say why, in the user's terms. A scope boundary with no reason gets re-litigated.
+
+## Facts looked up (not asked)
+| fact | source | value |
+|---|---|---|
+| is there a notifications table | wiki FRESH · wiki/orc-feature-notifications.md | yes, `notifications(id, kind, payload)` |
+| does this project retry payouts | recon dispatch (sonnet-4-6/medium) | yes, `src/jobs/payout-retry.js:88` |
+
+This table is what stops the next lane re-deriving the same things.
+
+## Still open — each with the instrument that settles it
+| question | why talking cannot settle it | instrument |
+|---|---|---|
+| what the email says | taste — needs something to look at | `mock_example` phase → `mock-examples/<slug>/` |
+| does the retry worker expose a hook | a claim about the repo | `/orc-analyze` |
+
+An open question with the right instrument named is a finished answer. An open
+question with no instrument is unfinished work.
+
+## Rounds
+A short log: round number, what was asked, what came back. One line per question.
+This is what makes a re-opened thread cheap to resume.
+```
+
+## Writing style
+
+Write for the person who comes back in three weeks having forgotten everything —
+and for the analyst who will read this instead of interviewing them again.
+
+- Plain words, short sentences.
+- Name real files and line numbers wherever a fact came from the repo.
+- Always record **why** an option lost. A rejected idea with its reason is what
+  stops the next session proposing it again.