@rune-kit/rune 2.14.0 → 2.16.0

package/skills/adversary/SKILL.md

@@ -3,11 +3,13 @@ name: adversary
 description: "Pre-implementation red-team analysis. Use when a plan is high-risk, critical path, or expensive to reverse. Challenges plans before code is written — finds edge cases, security holes, scalability bottlenecks, error propagation risks, and integration conflicts. Catches flaws at plan time (10x cheaper than post-implementation)."
 metadata:
   author: runedev
-  version: "0.1.0"
+  version: "0.2.0"
   layer: L2
   model: opus
   group: quality
   tools: "Read, Glob, Grep"
+  emit: oracle.dispatched, oracle.response, oracle.failed
+  listen: agent.stuck, context.preview
 ---
 
 # adversary
@@ -37,12 +39,16 @@ Every finding MUST reference the specific plan section, file, or assumption it c
 - `scout` (L2): find existing code that might conflict with planned changes
 - `docs-seeker` (L3): verify framework/API assumptions in the plan are correct and current
 - `hallucination-guard` (L3): verify that APIs, packages, or patterns referenced in the plan actually exist
+- `context-engine` (L3): (oracle-mode) emit `context.preview` before bundle build to gate token cost
+- `session-bridge` (L3): (oracle-mode) detach protocol when target model is opus-class for non-blocking dispatch
 
 ## Called By (inbound)
 
 - `cook` (L1): Phase 2.5 — after plan approval, before TDD
 - `plan` (L2): optional post-step for critical features
 - `team` (L1): when decomposing large tasks, adversary validates the decomposition
+- `debug` (L2): (oracle-mode) listens to `agent.stuck` from debug after 3 disproved hypotheses
+- `fix` (L2): (oracle-mode) listens to `agent.stuck` from fix after 2+ failed attempts
 - User: `/rune adversary` direct invocation
 
 ## Cross-Hub Connections
@@ -229,6 +235,54 @@ Trigger: plan modifies < 3 files AND no auth/payment/data logic.
 Steps 2 and 5 only (security + integration). Used when `sentinel` requests adversarial pre-analysis.
 Trigger: plan involves auth, crypto, payment, or user data handling.
 
+### Mode: oracle (v0.2.0)
+
+**Triggered by**: `agent.stuck` signal — emitted by `debug` (after 3 disproved hypotheses) or `fix` (after 2+ failed attempts on the same file).
+
+**Purpose**: Break confirmation-bias loops. The same agent that read `auth.ts` 3 times has formed a theory it cannot un-form. Oracle-mode dispatches a stateless second-model pass with explicit "no prior context" framing, breaking the semantic loop that `scout`'s zoom-out mode (structural pivot) cannot.
+
+**When NOT to use**:
+- Single hypothesis cycle — escalate only after 3 cycles in `debug` or 2 attempts in `fix`
+- Trivial single-file bugs — overhead exceeds value
+- When the user already knows the answer — they're trying to validate, not diagnose
+
+**Protocol**:
+
+1. **Pre-bundle gate** — emit `context.preview` to `context-engine` first; abort if action=block
+2. **Build context bundle** — see `references/context-bundle-format.md` for exact format
+3. **Dispatch** — emit `oracle.dispatched` signal; route via `session-bridge` detach if target model is opus-class (non-blocking)
+4. **Wait for response** — synchronous if model is sonnet-class, polled via `.rune/oracle-pending/<id>.json` if opus-class
+5. **Validate response** — every claim MUST cite file:line. Strip + warn on uncited claims (`oracle.failed` if all claims uncited)
+6. **Emit response** — `oracle.response` carries the validated diagnosis, consumed by `debug`/`fix` to override or refine their current hypothesis
+
+**Bundle format** (mandatory regex-validated):
+
+```
+[SYSTEM] You are Oracle, a focused one-shot problem solver. You have NO prior context — assume zero project knowledge. Cite file:line for every claim. Reject any claim you cannot ground in the provided files.
+
+[USER] <agent stuck after N hypothesis cycles. What is the most likely root cause not yet considered?>
+
+### File 1: <relative/path/to/file.ts>
+<file content, normalized whitespace, max 4k chars per file>
+
+### File 2: <...>
+<...>
+```
+
+**Hard caps**:
+- Bundle ≤ 100k tokens (estimated via char count × 0.25)
+- Per-file ≤ 4k chars (truncate with explicit `... [truncated]` marker)
+- Max 12 files per bundle (force caller to prune larger sets)
+
+**Response contract** — Oracle reply MUST contain:
+- A primary diagnosis (1-3 sentences)
+- At least 1 file:line citation per claim
+- An action recommendation (specific edit, additional file to read, hypothesis to test)
+
+Replies failing this contract are rejected — `oracle.failed` emitted, primary agent continues without second opinion.
+
+See `references/oracle-mode.md` for the full protocol and integration with `debug`/`fix`.
+
 ## Constraints
 
 1. MUST challenge every plan — no rubber-stamping. At minimum, one finding per analyzed dimension
@@ -238,6 +292,8 @@ Trigger: plan involves auth, crypto, payment, or user data handling.
 5. MUST use concrete attack scenarios, not vague warnings ("could be a problem" is NOT a finding)
 6. MUST NOT block on MEDIUM/LOW findings — only CRITICAL and HIGH trigger REVISE verdict
 7. MUST include Strength Notes — adversary finds weaknesses AND acknowledges what's well-designed
+8. (oracle-mode) MUST emit `context.preview` BEFORE building the bundle — abort if context-engine action=block
+9. (oracle-mode) MUST validate every Oracle reply citation against the provided files — reject uncited claims as `oracle.failed`
 
 ## Mesh Gates
 
@@ -256,6 +312,9 @@ Trigger: plan involves auth, crypto, payment, or user data handling.
 | Missing context — challenging plan without understanding existing codebase | HIGH | Step 0 MUST load existing code context via scout before challenging |
 | Scope creep — reviewing existing code quality instead of plan quality | MEDIUM | Adversary reviews THE PLAN, not the codebase. Existing code is context only |
 | Redundancy with review/preflight — duplicating post-implementation checks | MEDIUM | Adversary operates PRE-implementation only. Never run adversary on existing code |
+| (oracle-mode) Bundle exceeds token cap — caller didn't prune | HIGH | Caller MUST run `context.preview` first; adversary fails fast with `oracle.failed` instead of silently truncating signal |
+| (oracle-mode) Oracle reply has no citations — model improvised | CRITICAL | Reject reply with `oracle.failed`. Primary agent continues without second opinion (better than acting on hallucination) |
+| (oracle-mode) Loop: oracle reply triggers another `agent.stuck` | HIGH | Cap at 1 oracle dispatch per primary-agent stuck cycle. Subsequent stucks must escalate to user |
 
 ## Done When
 
@@ -265,6 +324,7 @@ Trigger: plan involves auth, crypto, payment, or user data handling.
 - Verdict rendered: REVISE, HARDEN, or PROCEED
 - Findings formatted for consumption by cook Phase 3 (if PROCEED) or plan (if REVISE)
 - Strength Notes section acknowledges well-designed aspects of the plan
+- (oracle-mode) If dispatched: response cited file:line for each claim, or `oracle.failed` emitted with rejection reason
 
 ## Returns
 

package/skills/adversary/evals.md

@@ -0,0 +1,79 @@
+# Adversary — Evaluation Scenarios
+
+Synthetic scenarios for verifying adversary skill behavior. Each eval has setup, expected behavior, and pass/fail criteria.
+
+## E01: Full red-team on payment plan (happy path)
+
+**Setup**: User provides plan to add Stripe checkout flow with webhook handlers.
+
+**Expected**:
+- All 5 dimensions analyzed
+- Security findings include: webhook signature verification, idempotency keys, amount tampering
+- Integration findings include: existing user-account schema, order state machine
+- Verdict: HARDEN (specific remediations applied to plan)
+- Strength Notes acknowledges any well-specified parts
+
+**Pass criteria**: Report has ≥1 finding per dimension, ≥3 CRITICAL/HIGH findings on auth/payment specifics, sentinel called for crypto verification.
+
+## E02: Quick Challenge mode
+
+**Setup**: Plan modifies 2 files, no auth/payment logic.
+
+**Expected**:
+- Steps 3-4 (scalability, error propagation) skipped
+- Edge cases + security + integration analyzed
+- Report explicitly states "Quick Challenge mode used — scale/error analysis skipped"
+
+**Pass criteria**: 3-dimension analysis only; report header notes mode.
+
+## E03: Rubber-stamp resistance
+
+**Setup**: User says "this plan is approved by the team, just confirm it's fine."
+
+**Expected**:
+- Adversary STILL produces ≥1 finding per analyzed dimension
+- Does NOT skip dimensions because user is confident
+- Does NOT downgrade severity because user is confident
+- Strength Notes can acknowledge team review, but findings remain unchanged
+
+**Pass criteria**: Report has same finding count as if user said nothing.
+
+## E04: Oracle-mode happy path (v0.2.0)
+
+**Setup**: `debug` emits `agent.stuck` after 3 disproved hypotheses on `src/auth/login.ts:127` (intermittent 401). Bundle contains: login.ts, middleware/auth.ts, session.ts, error log excerpt.
+
+**Expected**:
+- Adversary listens to `agent.stuck`, dispatches oracle-mode
+- `context.preview` emitted FIRST → context-engine returns action=proceed
+- Bundle built per `context-bundle-format.md` (regex-validated)
+- `oracle.dispatched` emitted with `{sessionId, sourceSkill: debug, targetModel}`
+- Reply received and validated — every claim has file:line citation
+- `oracle.response` emitted with diagnosis + recommendation + confidence
+- `debug` Phase 4 consumes the response, treats as new hypothesis H_oracle
+
+**Pass criteria**: All 4 signals fire in order (`context.preview` → `oracle.dispatched` → `oracle.response`); reply citations all reference files present in the bundle.
+
+## E05: Oracle-mode bundle overflow
+
+**Setup**: `debug` emits `agent.stuck` with 25 files in scope (totaling 600k chars).
+
+**Expected**:
+- `context.preview` emitted, returns action=block (>100k token estimate)
+- Adversary aborts with `oracle.failed` reason=`context_budget_exceeded`
+- Primary `debug` agent continues without second opinion
+- User sees clear advisory: "Bundle too large — prune file scope and retry"
+
+**Pass criteria**: No `oracle.dispatched` emitted; `oracle.failed` carries the budget reason.
+
+## E06: Oracle-mode jailbreak (uncited reply)
+
+**Setup**: Oracle reply ignores citation requirement, returns 4 plausible-sounding diagnoses with zero file:line references.
+
+**Expected**:
+- Adversary validates reply per `context-bundle-format.md` reply contract
+- Every claim found uncited → reply rejected
+- `oracle.failed` emitted with reason=`no_citations`
+- Primary agent continues without second opinion (better than acting on hallucination)
+- User sees advisory: "Oracle reply lacked citations — discarded"
+
+**Pass criteria**: No `oracle.response` emitted; `oracle.failed` carries `no_citations` reason; downstream `debug`/`fix` does not consume the rejected reply.

package/skills/adversary/references/context-bundle-format.md

@@ -0,0 +1,122 @@
+# Oracle Context Bundle Format
+
+## Purpose
+
+Define the exact, regex-validated format for context bundles dispatched by adversary oracle-mode. Strict format ensures the second model receives consistent input regardless of which primary agent (debug/fix/manual) triggered the dispatch.
+
+## Bundle Structure
+
+```
+[SYSTEM] You are Oracle, a focused one-shot problem solver. You have NO prior context — assume zero project knowledge. Cite file:line for every claim. Reject any claim you cannot ground in the provided files.
+
+[USER] <problem statement — see USER section spec below>
+
+### File 1: <relative/path/to/file>
+<file content, normalized whitespace, max 4k chars per file>
+
+### File 2: <relative/path/to/file>
+<...>
+
+### File N: <relative/path/to/file>
+<...>
+```
+
+## Section Specs
+
+### `[SYSTEM]` line
+
+**Required**, **exact text**:
+
+```
+[SYSTEM] You are Oracle, a focused one-shot problem solver. You have NO prior context — assume zero project knowledge. Cite file:line for every claim. Reject any claim you cannot ground in the provided files.
+```
+
+Validation regex: `^\[SYSTEM\] You are Oracle, a focused one-shot problem solver\.`
+
+The framing is invariant. Do not attempt to "improve" it per-call — the second model must receive the same role-priming every time.
+
+### `[USER]` line
+
+**Required**, **template-driven** based on trigger source:
+
+| Source | Template |
+|--------|----------|
+| `debug` agent.stuck | `[USER] Agent stuck after <N> hypothesis cycles. Disproved: <H1>; <H2>; <H3>. Error: <error_summary>. What is the most likely root cause not yet considered?` |
+| `fix` agent.stuck | `[USER] Agent stuck after <N> failed fix attempts on <file>. Each attempt's tests failed with: <test_failure_summary>. What is the most likely cause of the test failure?` |
+| Manual | `[USER] <free-form problem statement, max 500 chars>` |
+
+Validation regex: `^\[USER\] .{20,2000}$`
+
+### `### File <N>` blocks
+
+**Optional** (zero files allowed for purely conceptual questions, but typical: 3-12 files).
+
+Format per block:
+- Header: `### File <N>: <relative-path>` — N starts at 1, increments by 1
+- Body: file content, normalized whitespace (collapse 3+ blank lines to 2, trim trailing whitespace per line)
+- Body cap: 4000 characters. If file exceeds, truncate at the most recent line boundary before 4000 chars and append `... [truncated]` on its own line
+
+Validation regex per header: `^### File \d+: [^\n]+$`
+
+## Hard Caps
+
+| Cap | Limit | Behavior on exceed |
+|-----|-------|---------------------|
+| Total bundle (chars) | 400,000 (~100k tokens) | Reject before dispatch — `oracle.failed` reason=`bundle_too_large` |
+| Per file (chars) | 4,000 | Truncate with `... [truncated]` marker |
+| File count | 12 | Reject before dispatch — caller MUST prune via `context.preview` first |
+| `[USER]` length | 2,000 chars | Truncate at sentence boundary |
+
+## Whitespace Normalization
+
+Applied to every file body:
+
+1. Replace `\r\n` with `\n`
+2. Collapse 3+ consecutive newlines into 2 (`\n\n\n+` → `\n\n`)
+3. Trim trailing whitespace on each line (preserve indentation)
+4. Remove tab characters from line ends only (preserve leading tabs)
+
+Code blocks (lines between matching ` ``` ` fences) are exempt from collapse — preserve internal blank lines exactly.
+
+## Forbidden Content
+
+The following content MUST be stripped before bundle build:
+
+- Lines matching `process\.env\.[A-Z_]+\s*=\s*["'][^"']+["']` (env-var assignments with secrets)
+- Lines matching `(api[_-]?key|secret|password|token)\s*[:=]\s*["'][^"']{8,}["']` (hardcoded creds)
+- Lines matching `Authorization:\s*Bearer\s+\S{20,}` (auth headers in test fixtures)
+
+If any match found: replace value with `<REDACTED>` and continue. Do not abort dispatch — bundle still useful for diagnosis with credentials redacted.
+
+## Reply Contract (validation post-dispatch)
+
+The Oracle reply MUST satisfy:
+
+1. **Diagnosis present** — at least one paragraph stating primary cause
+2. **Citations present** — at least 1 `<file>:<line>` reference per non-trivial claim
+3. **Citations valid** — every cited file appears in the bundle's `### File N` blocks
+4. **Recommendation present** — concrete next action (specific edit, file to read, hypothesis to test)
+5. **No "I am unable to" responses** — if Oracle truly cannot diagnose, it MUST say "Insufficient context" + name what additional file/info would help
+
+Failures of (1)-(4) emit `oracle.failed` with the corresponding reason.
+Failure of (5) accepted but downgrades `oracle.response.confidence` to `low`.
+
+## Example (compact)
+
+```
+[SYSTEM] You are Oracle, a focused one-shot problem solver. You have NO prior context — assume zero project knowledge. Cite file:line for every claim. Reject any claim you cannot ground in the provided files.
+
+[USER] Agent stuck after 3 hypothesis cycles. Disproved: race condition on user.session; stale cache in middleware; bad type cast in handler. Error: 401 Unauthorized intermittent on POST /api/orders. What is the most likely root cause not yet considered?
+
+### File 1: src/api/orders.ts
+import { auth } from './middleware/auth';
+... [content] ...
+
+### File 2: src/middleware/auth.ts
+... [content] ...
+
+### File 3: src/services/session.ts
+... [content] ...
+```
+
+The reply, post-validation, becomes the payload of `oracle.response`.

package/skills/adversary/references/oracle-mode.md

@@ -0,0 +1,116 @@
+# Adversary Oracle-Mode
+
+## Purpose
+
+Break the confirmation-bias loop that traps a single agent reading the same files repeatedly. After 3 disproved hypotheses in `debug` or 2+ failed attempts in `fix`, the agent has read the same files multiple times and formed a theory it cannot un-form. Oracle-mode dispatches a stateless second-model pass with explicit "no prior context" framing.
+
+This is a **semantic** pivot. `scout`'s zoom-out mode is the **structural** pivot (look at adjacent modules). Both fire on the same `agent.stuck` signal; both run; the agent receives both perspectives.
+
+## When to Dispatch
+
+| Trigger | Source | Threshold |
+|---------|--------|-----------|
+| 3 hypothesis cycles disproved | `debug` | After 3rd disproved hypothesis emits `agent.stuck` |
+| 2 fix attempts on same file failed | `fix` | After 2nd attempt's tests fail emits `agent.stuck` |
+
+Oracle-mode listens to `agent.stuck` and starts the dispatch flow automatically. Manual invocation: `/rune adversary --mode=oracle`.
+
+## When NOT to Dispatch
+
+- Single hypothesis cycle — escalate only after threshold reached
+- Trivial single-file bugs — overhead exceeds value
+- Recurring loop on the same `agent.stuck` from the same root cause — cap at 1 oracle dispatch per stuck cycle
+
+## Protocol (6 steps)
+
+### 1. Pre-bundle gate
+
+Emit `context.preview` to `context-engine` with the planned file list and prompt. If `context-engine` returns `action: block` (>100k token estimate), abort with `oracle.failed` reason=`context_budget_exceeded` and let primary agent continue without escalation.
+
+### 2. Build the bundle
+
+See `context-bundle-format.md` for the regex-validated format. Hard caps:
+- Bundle ≤ 100k tokens (estimated via char count × 0.25)
+- Per-file ≤ 4k chars (truncate with explicit `... [truncated]` marker)
+- Max 12 files per bundle (force caller to prune larger sets)
+
+### 3. Dispatch
+
+Emit `oracle.dispatched` carrying `{sessionId, triggerSignal, sourceSkill, targetModel, bundleHash}`. If `targetModel` is opus-class (or non-Anthropic equivalent), route via `session-bridge` detach so primary agent can continue adjacent work.
+
+### 4. Wait for response
+
+| Target model | Protocol |
+|--------------|----------|
+| sonnet-class (gpt-5, gemini-3-flash, claude-sonnet) | Synchronous — block until reply or 60s timeout |
+| opus-class (gpt-5-pro, gemini-3-pro, claude-opus-4-7) | Async — primary agent continues; poll `.rune/oracle-pending/<sessionId>.json` between phases |
+
+### 5. Validate response
+
+Every claim in the Oracle reply MUST cite file:line. Specifically:
+- Reject reply if **all** claims are uncited → emit `oracle.failed` reason=`no_citations`
+- Strip and warn on individual uncited claims if at least 1 is cited (best-effort acceptance)
+- Verify cited file:line exists in the bundle (no hallucinated paths) → emit `oracle.failed` reason=`hallucinated_citation` if violated
+
+### 6. Emit response
+
+Emit `oracle.response` carrying:
+- `diagnosis` — primary cause (1-3 sentences)
+- `citations` — list of `{file, line, claim}` triples
+- `recommendation` — next action (specific edit, additional file to read, hypothesis to test)
+- `confidence` — `high | medium | low`
+
+Consumed by:
+- `debug` Phase 4 — overrides current hypothesis, re-runs from new starting point
+- `fix` Phase 3 — applies the recommended edit (still routes through normal validation gates)
+
+## Integration with debug
+
+```
+debug Phase 1-3: form + test hypotheses
+debug Phase 3 (3rd disproved):
+  emit agent.stuck
+  ↓
+adversary oracle-mode (this skill):
+  emit context.preview → context-engine
+  emit oracle.dispatched → session-bridge (if opus)
+  ... reply ...
+  emit oracle.response
+  ↓
+debug Phase 4:
+  consume oracle.response
+  treat as new hypothesis H_oracle
+  test H_oracle directly (skip 3-cycle gate since it's externally validated)
+```
+
+## Integration with fix
+
+```
+fix Phase 2-3: apply edit + verify
+fix Phase 3 (2nd attempt fails):
+  emit agent.stuck
+  ↓
+adversary oracle-mode:
+  bundle: error output + last 2 attempt diffs + target file
+  ... reply ...
+  emit oracle.response
+  ↓
+fix Phase 4:
+  consume oracle.response.recommendation
+  apply the recommended edit (if confidence=high)
+  or hand back to debug if recommendation=needs_more_diagnosis
+```
+
+## Failure Modes
+
+| Symptom | Reason | Action |
+|---------|--------|--------|
+| Bundle exceeds 100k tokens | Caller didn't prune | `oracle.failed` reason=`bundle_too_large`; suggest user reduce file scope |
+| Reply has zero citations | Model improvised | `oracle.failed` reason=`no_citations`; primary agent continues without second opinion |
+| Reply cites a file not in bundle | Hallucination | `oracle.failed` reason=`hallucinated_citation`; reply discarded |
+| Reply triggers another `agent.stuck` | Recursive loop | Cap at 1 dispatch per stuck cycle; subsequent stucks escalate to user |
+| Network timeout | Detach mode failure | Cleanup `oracle-pending/<id>.json` after 10min; emit `oracle.failed` reason=`timeout` |
+
+## Cost Profile
+
+Bundle build: ~200 tokens overhead per file (header + truncation markers). Reply parsing: ~100 tokens. Net cost per dispatch is dominated by the second-model invocation itself (4k-100k tokens), justified only when `agent.stuck` threshold is hit — confirming the loop is real, not a noise event.

package/skills/asset-creator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: asset-creator
-description: Creates code-based visual assets — SVG icons, OG image HTML templates, social banners, and icon sets. Outputs files with usage instructions.
+description: "Creates code-based visual assets — SVG icons, OG image HTML templates, social banners, and icon sets. Outputs files with usage instructions."
 metadata:
   author: runedev
   version: "0.2.0"

package/skills/audit/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: audit
-description: Comprehensive project audit — security, dependencies, code quality, architecture, performance, infra, docs, and mesh analytics. Delegates to specialist skills and generates an 8-dimension health score.
+description: "Comprehensive project audit — security, dependencies, code quality, architecture, performance, infra, docs, and mesh analytics. Delegates to specialist skills and generates an 8-dimension health score."
 metadata:
   author: runedev
   version: "0.4.0"
@@ -9,6 +9,7 @@ metadata:
   group: quality
   tools: "Read, Bash, Glob, Grep"
   emit: audit.complete
+  listen: context.preview
 ---
 
 # audit

package/skills/autopsy/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: autopsy
-description: Full codebase health assessment. Use when diagnosing project health or starting a rescue workflow on legacy code. Analyzes complexity, dependencies, dead code, tech debt, and git hotspots. Produces a health score and rescue plan.
+description: "Full codebase health assessment. Use when diagnosing project health or starting a rescue workflow on legacy code. Analyzes complexity, dependencies, dead code, tech debt, and git hotspots. Produces a health score and rescue plan."
 metadata:
   author: runedev
   version: "0.4.0"

package/skills/ba/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: ba
-description: Business Analyst agent. Deeply understands user requirements before any planning or coding begins. Asks probing questions, identifies hidden requirements, maps stakeholders, defines scope boundaries, and produces a structured Requirements Document that plan and cook consume.
+description: "Business Analyst agent. Use when starting a new feature requiring requirements elicitation BEFORE plan or cook. Asks probing questions, identifies hidden requirements, maps stakeholders, defines scope boundaries, and produces a structured Requirements Document that plan and cook consume."
 metadata:
   author: runedev
-  version: "0.11.0"
+  version: "0.13.0"
   layer: L2
   model: opus
   group: creation
-  tools: "Read, Glob, Grep"
-  emit: outofscope.match
+  tools: "Read, Write, Glob, Grep"
+  emit: outofscope.match, outofscope.recorded
 ---
 
 # ba
@@ -73,7 +73,26 @@ If Refactor → light version (Step 1 + Step 4 only). Skip Steps 2, 2.5, 3, 5, 6
 
 If existing codebase → invoke `rune:scout` for context before proceeding.
 
-### Step 1.5 — Out-of-Scope Match Check
+### Step 1.4 — Synthesis Trigger Check
+<MUST-READ path="references/synthesis-mode.md" trigger="when prior conversation already contains rich requirement context (pasted spec, > 1000 words discussion, continuation session, filled issue template)"/>
+
+Before proceeding to elicitation, check whether the requirements are **already in context**. Re-asking what the user already told you is the second-most expensive bug.
+
+Activate **Synthesis Mode** instead of standard elicitation if ANY of:
+
+| Signal | Threshold |
+|--------|-----------|
+| User pasted a spec / PRD / brief | > 200 words describing the feature |
+| Conversation has > 1000 words on this feature | Sufficient context already gathered |
+| User said "synthesize" / "I already explained" / "just write the spec" | Explicit synthesis request |
+| Continuation — `.rune/features/<name>/requirements.md` exists with prior answers | Re-elicitation would duplicate |
+| Issue tracker has filled-in template (problem, story, acceptance criteria) | Source already structured |
+
+In Synthesis Mode: extract answers from existing context, draft the Requirements Document with **source citations** for every section, then **confirm** rather than re-interview. Ask follow-ups ONLY on the 1-2 dimensions with genuine gaps. Skip steps 2, 2.5 if all 5 dimensions are filled or partial-but-acceptable.
+
+Workflow detail + anti-patterns: [references/synthesis-mode.md](references/synthesis-mode.md).
+
+### Step 1.5 — Out-of-Scope Match Check (READ)
 
 Before any elicitation, check whether the request matches a concept previously rejected.
 
@@ -99,6 +118,50 @@ If verdict is exact-match AND user accepts the prior rejection → end the BA se
 
 Format reference: [references/out-of-scope-format.md](references/out-of-scope-format.md).
 
+### Step 1.6 — Mid-Elicitation Reject WRITE Path
+
+If the user **explicitly rejects** the feature at any point during elicitation (Steps 2-3) — common phrases: "scrap it", "actually nah, don't build this", "we won't do this", "kill the feature", "drop it" — STOP elicitation and **write a `.out-of-scope/<slug>.md` record** before ending the session.
+
+Without this WRITE path, oral rejections vanish — the next session re-asks the same questions and the user has to re-reject. Step 1.5 (READ) only catches matches against existing files; Step 1.6 (WRITE) is what produces those files in the first place.
+
+<HARD-GATE>
+Mid-elicitation rejection MUST produce a `.out-of-scope/<slug>.md` file before session end.
+A rejection without a written record is a rejection that didn't happen.
+</HARD-GATE>
+
+**Procedure**:
+
+1. **Confirm rejection is durable, not deferral**. Ask one clarifier:
+   > "Just to record this correctly: is this **out of scope** (project doesn't want this), or **deferred** (not now but maybe later)? Out-of-scope gets recorded so we don't re-litigate; deferred goes to backlog instead."
+
+   - If **deferred** → route to backlog (no `.out-of-scope/` write), end session with a one-line note
+   - If **out-of-scope** → continue to step 2
+
+2. **Capture the durable reason**. Ask:
+   > "What's the reason this is out of scope? (project scope, technical constraint, strategic decision — not a temporary circumstance)"
+
+   If the user gives a temporary reason ("we're busy"), reframe: "That's a deferral — should I route to backlog instead?"
+
+3. **Generate slug** (kebab-case, ≤40 chars, recognizable without opening the file).
+
+4. **Lexical-similarity check**: `Glob` `.out-of-scope/*.md`, parse each frontmatter's `concept` + `aliases`, compute overlap. If any existing concept has ≥0.7 overlap → APPEND to that file's `prior_requests` list and mark `rejected_by: ba` for this round. Do NOT create a duplicate.
+
+5. **Write the file** using the format in [`references/out-of-scope-format.md`](references/out-of-scope-format.md):
+   - YAML frontmatter (`concept`, `aliases`, `decision: rejected`, `rejected_at`, `rejected_by: ba`, `prior_requests`, optional `revisit_if`)
+   - Markdown body: concept name, "Why out of scope" (substantive reasoning from step 2), "What would change our mind" (if user volunteered signals)
+
+6. **Emit `outofscope.recorded`** signal carrying `{slug, rejected_by: ba, prior_requests_count}` so downstream skills know a new rejection landed.
+
+7. **End BA session** with one-line summary:
+   > "Recorded as out of scope in `.out-of-scope/<slug>.md`. Future similar requests will surface this. Override anytime by editing the file."
+
+**When NOT to write**:
+
+- User merely defers ("not now") → backlog, not `.out-of-scope/`
+- User rejects a single requirement within a larger feature → adjust requirements doc Boundaries section, don't write a whole rejection file (the feature is still in scope)
+- Bug rejections (already fixed, not reproducible) → not BA's job; route to incident or close the issue
+- The match was already exact (≥0.8) and Step 1.5 surfaced it — user accepting the prior rejection just appends to `prior_requests` of the existing file (handled in Step 1.5 path)
+
 ### Step 2.0 — Explore-First Pre-Check (HARD-GATE)
 
 Before emitting ANY of the 5 elicitation questions, run the 4-item pre-check on each intended question:
@@ -663,6 +726,11 @@ Known failure modes for this skill. Check these before declaring done.
 | User asserts behavior; agent records user's version without grep verification | HIGH | Step 2.6 HARD-GATE: every "the system does X" assertion gets grep'd; conflicts surface to user before recording |
 | Silently re-defining an existing CONTEXT.md term | HIGH | Step 7.5 conflict gate: ≥0.7 overlap → user chooses merge/rename/keep-distinct |
 | Auto-creating an empty CONTEXT.md when no terms emerged | LOW | Lazy creation rule: only write when there's a non-trivial term to record |
+| Mid-elicitation rejection ("scrap it") that ends the session without writing `.out-of-scope/` | CRITICAL | Step 1.6 HARD-GATE: explicit rejection MUST produce `.out-of-scope/<slug>.md` before session end — oral rejections vanish, force re-litigation next session |
+| Writing `.out-of-scope/` for a deferral instead of routing to backlog | MEDIUM | Step 1.6 procedure step 1: confirm "out of scope" vs "deferred" — temporary reasons go to backlog, not the rejection KB |
+| Running 5-question elicitation when conversation already contains rich context | HIGH | Step 1.4: synthesis-trigger check fires before Step 2 — pasted spec / >1000 words / continuation / explicit "synthesize" → switch to Synthesis Mode (extract + cite + confirm), don't re-interview |
+| Synthesizing requirements without source citations | HIGH | Synthesis Mode requires citing source for every dimension (user message N, pasted doc, continuation file). User cannot verify interpretation without citations |
+| Auto-handoff to plan after synthesis without explicit user "go"/"locked" confirmation | HIGH | Synthesis is interpretation, not transcription. Without explicit confirmation, drift becomes a downstream bug |
 | Asking inferable questions ("what stack are you using?") without first checking package.json | HIGH | Step 2.0 HARD-GATE — every question requires prior tool-call evidence (Read/Glob/Grep) or explicit unavailability declaration |
 | Re-asking a question already answered earlier in the conversation | MEDIUM | Step 2.0 check 4 — cache and reuse, never re-ask |