@azure-id/orc 0.55.0

package/templates/skills/orc-analyze/references/thin-input.md

@@ -0,0 +1,77 @@
+# Reference — Thin input and the `/orc-grill` reverse trigger
+
+Load at Phase A″ when the analyzable gate fails, or at Phase F when a returned
+report is mostly tagged. Both are the SAME signal — the input was never sharp
+enough to check against code — arriving at two different moments.
+
+## Why a scan is the wrong instrument here
+
+`/orc-analyze` answers *"does the repo really do that?"*. It cannot answer
+*"what do I actually want?"*. Pointed at a fuzzy intent it still produces
+questions — but it produces them after paying for a scan (deep mode adds scouts
+at `max_scouts` in parallel), and it produces them as twenty tags in one batch
+rather than as a conversation with a frontier.
+
+The planner already refuses this shape rather than absorbing it
+(`../../orc/subskills/orc-planner/SKILL.md`: *plannable ⇔ an observable outcome
+AND an identifiable area*). This is the analyst's mirror of that rule.
+
+## Branch 1 — the gate fails up front (Phase A″)
+
+Print exactly this, then wait:
+
+```
+This is too thin to check against the code — I would spend the scan asking you
+questions instead of reading files.
+
+→ Switch to /orc-grill first (a conversation, no scan, no scout tokens).
+  When it is sharp, it comes straight back here and I analyze it.
+  [switch / analyze anyway]
+```
+
+- **`switch`** → run `../../orc-grill/SKILL.md`. Its exit 2 **auto-consumes back
+  into THIS invocation**: the written `orc-grill/<slug>/grill-context.md` becomes
+  the analyze input and Phase A restarts with it. The user retypes nothing and
+  re-explains nothing. Say so in one line when handing over, so the round trip is
+  visible rather than feeling like a lane change.
+- **`analyze anyway`** → proceed exactly as today. The user's override stands and
+  is not re-litigated later in the run; record it in the report's decisions so a
+  later reader knows the tags were expected.
+
+**It is an OFFER.** Never switch lanes without the answer, and never refuse to
+analyze — this gate changes what is RECOMMENDED, never what is permitted.
+
+## Branch 2 — the same signal arriving late (after the analyst returns)
+
+A report can pass the up-front gate and still come back mostly unanchored. That
+is this gate firing after the fact, and it deserves the same offer rather than a
+twenty-question relay.
+
+**Use numbers already in hand — add no probe.** `references/analyst-gates.md`
+already recomputes coverage on return; compare the count of rows tagged
+`ASSUMPTION`/`UNVERIFIED` against the total requirement rows. When the tagged
+rows are the majority, offer:
+
+```
+The analysis came back mostly unverified — <k> of <n> requirements could not be
+anchored to code. That is usually the intent still being open, not the repo
+being unreadable.
+
+→ /orc-grill to settle the intent (minutes, no scan), then re-analyze
+   the sharpened version — cheaper than answering <k> questions here.
+   [grill / answer the questions here]
+```
+
+`answer the questions here` runs the ordinary Phase D challenge relay. Nothing is
+withheld either way.
+
+## What this gate never does
+
+- Never blocks. Both branches proceed on the user's word.
+- Never re-scores an already-approved analysis, and never fires twice in one run
+  for the same input — if the user chose "analyze anyway", branch 2 is skipped.
+- Never invents its own idea of thin. The definition is the spine's sentence,
+  stated once and registered as a contract token:
+  **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.** Nothing here may widen it.

package/templates/skills/orc-analyze/schemas/report-audit.md

@@ -0,0 +1,83 @@
+# Template — Analyst Report (AUDIT mode)
+
+Human-readable source of truth. You review and confirm this; the machine spec
+is derived from it. Written to analyst_report/{analysis-name}/report.md.
+
+```markdown
+# Analysis Report — {analysis-name}
+mode: audit
+depth: standard | deep
+source_doc: <path or "pasted">
+scope: <X — the requested scope only>
+analyzed_at: DDMMYY HH:MM:SS
+model: opus-5-high        # the RESOLVED model of the agent that produced this
+                          #   (mini writes sonnet-5-high) — never copied from here
+grounding: repo-read | repo-read+scouts   # scouts only in deep mode
+
+## In-scope rows (X only)
+
+Each row = one audit line that belongs to scope X, reconciled against code. Every
+"Code reality" cell carries quote-anchored file:line evidence
+(`file:line — "verbatim snippet"`, never paraphrased; a ref with no quote
+auto-downgrades to UNVERIFIED), OR the row is tagged ASSUMPTION/UNVERIFIED (and
+appears below as an open question). A row whose code reality is a claim of
+ABSENCE ("no retry exists") instead carries `searched:` — the concrete
+globs/greps run. In deep mode EVERY row is verified, not just the load-bearing
+ones.
+
+| # | Claim (result + notes) | Code reality | Evidence (file:line + quote / searched:) | Files/modules | Status | Resolution |
+|---|------------------------|--------------|------------------------------------------|---------------|--------|------------|
+| 1 | PASS — "UUID validated" | present | auth/uuid.x:8 — "validateUuid(id)" | auth/uuid.x | verified | — |
+| 2 | PASS — notes: "consider adding retry" | no retry | searched: `retry`, `backoff` in svc/ — no hits | svc/x | diverged | user: retry OUT of scope |
+| 3 | FAIL — "missing UUID check" | field renamed to ref_id | models/user.x:20 — "ref_id:" | models/x | diverged | user: update premise; check ref_id |
+
+Status: verified | diverged | resolved
+- verified: claim matches code (with evidence), nothing to challenge.
+- diverged: claim vs code mismatch → was challenged.
+- resolved: a diverged row the user decided on (Resolution column holds the call).
+
+## Assumptions & Open Questions
+- UNVERIFIED (resolved): row 7 cited a "legacy flag" not found in code — user
+  confirmed it was removed; row dropped.
+
+## Additional context (do not build)
+Anchored, non-actionable context pulled from an ADJACENT scope because an in-scope
+row depends on it. Read for understanding; never a task. Each item names the
+in-scope row it serves + why. Omit this whole section if none survived.
+| Anchor (in-scope #) | From scope | Dependency | Touchpoint to respect | Evidence (file:line) |
+|---------------------|-----------|------------|-----------------------|----------------------|
+| Row 3 (ref_id check) | models (Y) | consumes-output | ref_id is set by the user loader before validation | models/user.x:20 |
+
+## Alternatives & risks   (DEEP mode only — omit in standard)
+- Row 3 fix: add ref_id check in the model (recommended) vs at the API edge —
+  edge version duplicates validation across 3 handlers.
+
+## Challenges raised & answers
+- Row 2: notes suggested retry — user confirmed OUT of scope X.
+- Row 3: audit says missing UUID check, code renamed field to ref_id — user
+  confirmed implement the check against ref_id.
+
+## Row numbering — `R#` is the SPEC's namespace, never the report's
+Refer to report rows as **"row N"** only. Labelling a report row `R1` collides
+with the spec's own `R#` ids, and the derivation lint compares the two id sets:
+report-`R1` (a build item) vs spec-`R1` (audit row 1) either false-passes or
+false-bounces. A row that legitimately duplicates another's `files[]` (e.g. a
+doc's closing `Recommendation:` line) carries `yields_build_work: false` in the
+spec rather than a prose qualifier.
+
+## Excluded scopes (recognized, not detailed)
+- Recognized Y, Z in the source doc; excluded from this report per scope = X.
+
+## Handoff readiness (checklist — all five or handoff_ready is false)
+The first three are checkable IN this report. The last two can only become true
+AFTER this report is confirmed and frozen, so on a correct run they stay
+unticked here and are satisfied in the spec — a reader of report.md alone must
+not read that as a failed checklist.
+- [ ] all BLOCKING challenges resolved (every diverged row decided)
+- [ ] zero open UNVERIFIED on any in-scope row
+- [ ] every row has status + evidence-or-resolution
+- [ ] spec derived AFTER the user confirmed this report  (satisfied
+      post-confirmation — see the spec)
+- [ ] scope_closed: true written into the spec  (satisfied post-confirmation —
+      see the spec)
+```

package/templates/skills/orc-analyze/schemas/report-prose.md

@@ -0,0 +1,63 @@
+# Template — Analyst Report (PROSE mode)
+
+Human-readable source of truth. Written to analyst_report/{analysis-name}/report.md.
+
+```markdown
+# Analysis Report — {analysis-name}
+mode: prose
+depth: standard | deep
+source_doc: <path or "pasted">
+scope: <X — the requested scope only>
+analyzed_at: DDMMYY HH:MM:SS
+model: opus-5-high        # the RESOLVED model of the agent that produced this
+                          #   (mini writes sonnet-5-high) — never copied from here
+grounding: repo-read | repo-read+scouts   # scouts only in deep mode
+
+## In-scope requirements (X only)
+
+Every "Code reality" cell carries quote-anchored file:line evidence
+(`file:line — "verbatim snippet"`, never paraphrased; a ref with no quote
+auto-downgrades to UNVERIFIED), OR the row is tagged ASSUMPTION/UNVERIFIED (and
+appears below as an open question). Absence claims (status missing) instead
+carry `searched:` — the concrete globs/greps run.
+
+| # | Requirement (from doc) | Code reality | Evidence (file:line + quote / searched:) | Files/modules | Status | Resolution |
+|---|------------------------|--------------|------------------------------------------|---------------|--------|------------|
+| 1 | "notifications must paginate" | list is unbounded | searched: `paginate`, `cursor`, `limit` in api/notifications — no hits | api/notifications/x | missing | implement pagination |
+| 2 | "respect existing auth" | auth middleware present | auth/mw.x:10 — "app.use(requireAuth)" | auth/mw.x | exists | reuse, no change |
+
+Status: exists | missing | conflict | resolved
+
+## Assumptions & Open Questions
+Anything not grounded to code, plus every ambiguity — each was raised as a
+recommended-option challenge and resolved (or is still open).
+- ASSUMPTION (resolved): "paginate" = cursor-based (recommended) — user confirmed.
+- UNVERIFIED (open): whether a rate-limit already exists — evidence not found.
+
+## Additional context (do not build)
+Anchored, non-actionable context pulled from an ADJACENT scope because an in-scope
+requirement depends on it. Read for understanding; never a task. Each item names
+the in-scope requirement it serves + why. Omit this whole section if none survived.
+| Anchor (in-scope #) | From scope | Dependency | Touchpoint to respect | Evidence (file:line) |
+|---------------------|-----------|------------|-----------------------|----------------------|
+| Req 1 (pagination) | listing (Y) | guards-invariant | shared list serializer caps a page at 100 | api/serializers/list.x:31 |
+
+## Alternatives & risks   (DEEP mode only — omit in standard)
+- Approach A (recommended): reuse existing cursor helper — low blast radius, 3 files.
+- Approach B: new offset paginator — simpler read, breaks existing cursor clients.
+- Risk: pagination touches the shared list serializer (dependents: 4 call sites).
+
+## Challenges raised & answers
+- Req 3 appeared to require an admin panel (belongs to scope Z) — user confirmed
+  OUT of scope X.
+
+## Excluded scopes (recognized, not detailed)
+- Recognized Y, Z; excluded per scope = X.
+
+## Handoff readiness (checklist — all five or handoff_ready is false)
+- [ ] all BLOCKING challenges resolved
+- [ ] zero open UNVERIFIED on any in-scope requirement
+- [ ] every requirement has status + evidence-or-resolution
+- [ ] spec derived AFTER the user confirmed this report
+- [ ] scope_closed: true written into the spec
+```

package/templates/skills/orc-analyze/schemas/report-requirement.md

@@ -0,0 +1,78 @@
+# Template — Analyst Report (REQUIREMENT mode — no document)
+
+Used when there is NO source document: the user's plain-language request IS the
+requirement, reconciled against the existing code. Human-readable source of
+truth. Written to `<analyzer_dir>/{analysis-name}/report.md` (config
+`analyzer_dir` — the internal artifact dir); it is COPIED to
+`<report_out_dir>/{analysis-name}/report.md` only on the report-only /
+stop-here branch. The old "written to analyst_report/…" wording described the
+copy target as if it were the write target.
+
+```markdown
+# Analysis Report — {analysis-name}
+mode: requirement
+depth: standard | deep
+source: "pasted request"        # the user's own words, verbatim
+scope: <X — the requested scope only>
+analyzed_at: DDMMYY HH:MM:SS
+model: opus-5-high        # the RESOLVED model of the agent that produced this
+                          #   (mini writes sonnet-5-high) — never copied from here
+grounding: repo-read | repo-read+scouts   # scouts only in deep mode
+
+## Restated requirement (analyst's words)
+One or two sentences restating the request — restating is what surfaces
+misreadings. If the restatement rests on any assumption, tag it and ask.
+
+## In-scope requirement parts (X only)
+
+Each part of the request, reconciled against code. Every "Code reality" cell
+carries quote-anchored file:line evidence (`file:line — "verbatim snippet"`,
+never paraphrased; a ref with no quote auto-downgrades to UNVERIFIED), OR the
+part is tagged ASSUMPTION/UNVERIFIED (and appears below as an open question).
+Absence claims (status missing/buildable) instead carry `searched:` — the
+concrete globs/greps run. In deep mode EVERY part is verified.
+
+| # | Requirement part (from request) | Code reality | Evidence (file:line + quote / searched:) | Files/modules | Status | Resolution |
+|---|---------------------------------|--------------|------------------------------------------|---------------|--------|------------|
+| 1 | "add CSV export to reports" | reports render HTML only | searched: `export*`, `csv`, `download` — no hits | web/reports/x | missing | new export path |
+| 2 | "reuse current auth" | auth guard on report routes | web/reports/routes.x:12 — "requireAuth(" | web/reports/x | exists | reuse, no change |
+
+Status: buildable | exists | conflict | resolved
+- buildable: not present, but consistent with the code — safe to build.
+- exists: already implemented — flag so the planner doesn't duplicate.
+- conflict: request contradicts existing behavior → challenged.
+- resolved: a challenged part the user decided on.
+
+## Assumptions & Open Questions
+Every ambiguity in the request + anything not grounded to code. Each raised as a
+recommended-option challenge and resolved (or still open).
+- ASSUMPTION (resolved): "export" = download file (recommended) vs email — user
+  confirmed download.
+- UNVERIFIED (open): whether a reports permission gate exists — evidence not found.
+
+## Additional context (do not build)
+Anchored, non-actionable context pulled from an ADJACENT scope because an in-scope
+request part depends on it. Read for understanding; never a task. Each item names
+the in-scope part it serves + why. Omit this whole section if none survived.
+| Anchor (in-scope #) | From scope | Dependency | Touchpoint to respect | Evidence (file:line) |
+|---------------------|-----------|------------|-----------------------|----------------------|
+| Part 1 (CSV export) | reporting (Y) | consumes-output | report query already paginates; export must page too | web/reports/query.x:44 |
+
+## Alternatives & risks   (DEEP mode only — omit in standard)
+- Approach A (recommended): stream CSV from the existing query — low blast radius.
+- Approach B: precompute + cache — faster reads, adds a cache dependency.
+- Risk: export reuses the report query (dependents: 2 schedulers).
+
+## Challenges raised & answers
+- Part 3 ("admin-only export") looked like scope Z (admin) — user confirmed OUT.
+
+## Excluded scopes (recognized, not detailed)
+- Recognized Y, Z implied by the request; excluded per scope = X.
+
+## Handoff readiness (checklist — all five or handoff_ready is false)
+- [ ] all BLOCKING challenges resolved
+- [ ] zero open UNVERIFIED on any in-scope part
+- [ ] every part has status + evidence-or-resolution
+- [ ] spec derived AFTER the user confirmed this report
+- [ ] scope_closed: true written into the spec
+```

package/templates/skills/orc-analyze/schemas/requirement-spec.md

@@ -0,0 +1,77 @@
+# Schema — Requirement Spec (DERIVED from the confirmed report)
+
+Machine-oriented projection of report.md. The planner consumes THIS; the human
+report travels alongside as the audit trail. Generated as the last Analyst step,
+so it cannot drift from what the user approved. Written to
+orc/analyzer/{analysis-name}/requirement-spec.md.
+
+```yaml
+analysis_name: string
+mode: audit | prose | requirement
+depth: standard | deep
+source_doc: string | null      # null in requirement mode (no doc)
+scope: string                  # X only
+grounding: repo-read | repo-read+scouts | from-system-analyst
+derived_from: report.md
+created_at: timestamp
+git_head: string | null        # `git rev-parse HEAD` at analysis time (null if not a repo)
+dirty: bool                    # uncommitted changes present at analysis time
+# Staleness valve: at plan time, git_head ≠ current HEAD → the orchestrator
+# re-runs the evidence spot-check (paths + quotes) before dispatching the
+# planner; misses → offer re-analyze vs proceed-with-flagged. Same-session
+# chains (HEAD matches) skip this — zero cost on the happy path.
+
+requirements:                  # in-scope only; Y/Z absent by construction
+  - id: R1
+    statement: string          # the requirement / audit-row / request-part, resolved
+    code_reality: string       # what the code currently shows
+    evidence: [string]         # quote-anchored refs backing code_reality:
+                               # 'file:line — "verbatim snippet"' (≤1 line, quoted
+                               # not paraphrased). A ref with no quote auto-downgrades
+                               # to UNVERIFIED. Empty only if the item was an
+                               # ASSUMPTION resolved by the user.
+                               # status missing|buildable (claims of ABSENCE)
+                               # instead carry 'searched: <the concrete
+                               # globs/greps run>' — an absence claim with no
+                               # searched: note is UNVERIFIED.
+    files: [string]            # specific files/modules — grounds declared_files
+    status: exists | missing | conflict | verified | buildable | resolved
+    resolution: string|null    # the user's decision if it was challenged
+
+assumptions_resolved:          # every ASSUMPTION/UNVERIFIED tag the user decided
+  - item: string
+    decision: string
+
+alternatives:                  # deep mode only; [] in standard
+  - for: R#                    # which requirement this concerns
+    recommended: string
+    options: [string]
+    risk: string
+
+context:                       # anchored, NON-ACTIONABLE adjacent-scope context; [] if none
+  - anchor: R#                 # the in-scope requirement this serves (REQUIRED — no anchor, no entry)
+    from_scope: string         # the adjacent scope Y/Z it was pulled from
+    dependency: string         # consumes-output | guards-invariant | shares-file | doc-references
+    note: string               # the touchpoint (field/function/invariant) the build must respect
+    evidence: [string]         # file:line — touchpoint-bounded, never all of the adjacent scope
+# Read-for-understanding ONLY. The planner/executor honor these invariants but
+# NEVER turn a context item into a task or a declared_files entry. Every item is
+# anchored to an in-scope requirement or it was dropped (Phase E anchor-validation).
+
+# Everything here is confirmed. The planner does NOT re-question scope/accuracy;
+# it only turns these into tasks (breakdown/approach).
+scope_closed: true
+```
+
+The `files` arrays are the planner's grounding when chained from SA — it trusts
+these and does not re-read the repo. The `evidence` refs let the planner (and a
+later reviewer) spot-check any claim without re-deriving it.
+
+## Validity (the orchestrator refuses an invalid spec)
+
+A spec is take-into-build valid only when: `scope_closed: true`, zero open
+`UNVERIFIED` on any in-scope requirement, and every requirement carries status +
+evidence-or-resolution. The orchestrator also lints DERIVATION on analyst
+return: the R# id set, per-R# status, and context-anchor set must match
+report.md exactly — a mismatch (or a context `anchor` that isn't an in-scope
+R#) bounces the spec back to the analyst (one retry, then escalate).

package/templates/skills/orc-analyze-mini/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: orc-analyze-mini
+description: >
+  Fast-lane System Analyst for ORC-MINI (Sonnet 5, high effort). Turns a
+  requirement — a document (PDF by path or pasted) OR a plain-language request —
+  into a scope-bounded, code-grounded requirement report + derived spec: bounds
+  the deliverable to exactly the asked scope (other scopes never become tasks),
+  maps each requirement to real files with quote-anchored file:line evidence —
+  or marks it an ASSUMPTION and turns it into a question — and challenges the
+  user with recommended options. Use for "/orc-analyze-mini", "quickly analyze
+  this doc", "fast doc analysis", "quick requirement check", "fast requirement
+  analysis", or when orc-mini meets a document or an ambiguous requirement.
+  Distinct from /orc-analyze: ALWAYS single-pass — NO deep mode, NO scouts —
+  trading depth for speed and tokens; switch to /orc-analyze (deep) when you
+  need a wider code sweep, verify-every-claim, or alternatives with trade-offs.
+  The orchestrator dispatches this to a subagent — it never analyzes itself.
+---
+
+# ORC-ANALYZE-MINI
+
+The fast variant of the System Analyst, dispatched by orc-mini as a Sonnet 5
+high subagent. Produces the SAME artifacts and follows the SAME output contract
+as the full analyst (`../orc-analyze/`) — read its schemas
+(report-audit.md, report-prose.md, report-requirement.md, requirement-spec.md)
+for the formats; this skill does not duplicate them.
+
+**Worked example** (orient only — never execute from it): `examples/quick-analysis-mock.md`.
+
+## What's trimmed vs the full analyst
+
+- **Shallower code grounding — but the FLOOR is the same.** The mini analyst
+  MUST still verify (a) every row that emits a `files[]` entry and (b) every
+  `status: exists|conflict` claim; it may skip exhaustively tracing peripheral
+  references. Trimmed depth never means a lower floor.
+- **Fewer challenge rounds via triage, not omission.** Blocking issues (scope
+  changes, code-vs-doc conflicts, anything changing `files[]` or a status) are
+  asked one at a time; everything else is DEMOTED to the single batched
+  advisory round — recorded in the report with its recommended default, never
+  silently dropped.
+- **No deep mode, no scouts.** Always single-pass.
+- **Concrete escalation thresholds** (recommend the full `/orc-analyze`, Opus
+  4.8 high, and let the user choose — the boundary is not self-assessed vibes):
+  source doc > ~10 pages, OR > 12 in-scope requirements, OR > 3 conflict rows,
+  OR audit mode with > 5 stale-premise rows.
+- **Model:** Sonnet 5, high effort.
+
+## What's identical
+
+- **Doc-optional intake:** auto-detect + confirm mode — prose / audit
+  (documents) or **requirement** (NO doc; the user's request is the source of
+  truth, reconciled against code).
+- **Evidence-or-mark, quote-anchored:** every code claim / interpretation is
+  grounded with `file:line — "verbatim snippet"` (a ref with no quote
+  auto-downgrades to `UNVERIFIED`), OR tagged `ASSUMPTION`/`UNVERIFIED` and
+  turned into a question — never a silent guess. **Absence claims**
+  (missing/buildable) carry `searched:` — the concrete globs/greps run.
+- **The read ladder:** locate → outline → range → full, escalating only as far as
+  the question needs (`../_shared/read-ladder.md`). Trimmed depth is not a lower
+  evidence floor — it is fewer wasted full reads reaching the same anchors.
+- **Recommended-option challenges:** each challenge is a 2–3 option set with one
+  flagged recommended option + reason (blocking one at a time, advisory batched).
+- Two perimeters: the deliverable stays scope X (Y/Z never become tasks), but
+  anchored, non-actionable adjacent context is gathered when an in-scope item
+  depends on it — touchpoint-bounded, self-read (no scouts), each item anchored to
+  the requirement it serves + labeled "do not build". Same **Additional context
+  (do not build)** section in report + spec. Unanchored context is dropped.
+- Two artifacts, spec derived from the confirmed report, same folder
+  `orc/analyzer/{analysis-name}/` (internal; copied out only on report-only),
+  including the Evidence column and Assumptions & Open Questions section. The
+  spec is stamped with `git_head` + `dirty` for plan-time staleness detection.
+- Same branch: report-only, or take into build (hand both files to orc-mini,
+  which continues with the mini planner) — orc-mini runs the same evidence
+  spot-check + derivation lint gates as the full lane before building.
+
+## Behavior trace (PERMANENT — every ORC entry point traces; always on)
+
+Same rule as the full analyst: standalone `/orc-analyze-mini` resolves
+`log_dir` at start and follows
+`../orc/references/trace-protocol.md` — write `log_dir/.current` =
+`run-analyze-<slug>-<DDMMYY>-<HHMMSS>.txt` and `touch the trace file` of that
+name in the SAME step, before the first dispatch; collect
+`PHASE`/`DISPATCH`/`VERIFY`/`GATE`/`FINISH` events with their REAL timestamps
+plus `decisions` (the WHY) and dispatch the trace writer ONCE at run end (the
+single-dispatch-lane packet), then delete `.current` (the hook bootstraps
+`.current` + the skeleton on the first dispatch regardless). Inside an orc-mini
+run, the mini orchestrator's trace already covers this — never open a second one.
+
+## Workflow checkpoint (gate before deriving the spec)
+
+Confirm the report with the user — scope bounded, blocking challenges resolved —
+BEFORE deriving requirement-spec.md. The spec is derived from the CONFIRMED report,
+never from an unconfirmed draft.
+
+## Return contract (inlined — do not reconstruct from the full analyst)
+
+Write `report.md` (mode template) + derived `requirement-spec.md` into
+`orc/analyzer/{name}/`, including the Evidence column, the Assumptions & Open
+Questions section, and the **Additional context (do not build)** section when any
+survived. Return exactly:
+
+- `report_path`, `spec_path` — the two artifacts.
+- `mode` — prose | audit | requirement.
+- `scope` — the confirmed scope-X one-liner.
+- `handoff_ready` — a CHECKLIST, not a feeling: true only when all blocking
+  challenges are resolved, zero open `UNVERIFIED` on in-scope items, every
+  requirement has status + evidence-or-resolution, the spec was derived after
+  the user confirmed the report, and `scope_closed: true` is written.
+- `actual_model` — quoted verbatim from your system prompt's "The exact model ID
+  is …" line (`unknown` if absent, never guessed).
+- `actual_effort` — `$CLAUDE_EFFORT`.
+
+Never build or spawn.

package/templates/skills/orc-analyze-mini/examples/quick-analysis-mock.md

@@ -0,0 +1,31 @@
+# Example — Annotated Fast-Lane Analysis (dry run)
+
+A: = mini analyst (Sonnet 5, high) · U: = user. Nothing real. Same artifacts and
+contract as /orc-analyze, ALWAYS single-pass — NO deep mode, NO scouts. The
+orchestrator dispatches this — it never analyzes itself.
+
+U: /orc-analyze-mini  add a "resend invite" action — no doc, just this request
+
+## Mode + scope (doc-optional)
+A: No document → REQUIREMENT mode (your request is the source of truth, reconciled
+   against code). Scope X = resend-invite. Nothing else in play.
+
+## Ground the CLEAR links + HIGH-SIGNAL divergences (evidence-or-mark)
+A: Maps to invites/service.py (create path at :40) + invites/routes.py (:12).
+   The obvious reuse: resend = re-issue the existing token, not mint a new invite.
+   ⚠ ASSUMPTION: resend should NOT reset the 72h expiry → turning into a question
+   (couldn't confirm from code alone). Shallower grounding: I confirm the obvious
+   file map, not every downstream reference.
+
+## Challenge (recommended options, one at a time)
+A: On expiry: (a) keep original expiry — RECOMMENDED (least surprise; matches how
+   create issues once). (b) refresh to a new 72h window on resend.
+U: (a)
+
+## Artifacts + branch (+ escalation door)
+A: Writes orc/analyzer/resend-invite/report.md + requirement-spec.md
+   (Evidence column + Assumptions & Open Questions). handoff_ready: true.
+A: This stayed simple, so single-pass was enough. If it had needed a wider sweep or
+   verify-every-claim, I'd have flagged that it may warrant /orc-analyze (deep).
+   Take into build?
+U: take into build   → hands the spec to orc-mini, which continues with the mini planner.