@xcraftmind/mastermind 0.28.1 → 0.28.2

package/README.md

@@ -14,7 +14,7 @@ Prebuilt native binaries via optional platform packages — **no Rust toolchain
 
 ## Quick start
 
-Requires **Node.js 18+**. The CLI is a thin JS wrapper over a prebuilt native binary — no Rust toolchain needed.
+Requires **Node.js 24+**. The CLI is a thin JS wrapper over a prebuilt native binary — no Rust toolchain needed.
 
 **1. Install**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcraftmind/mastermind",
-  "version": "0.28.1",
+  "version": "0.28.2",
   "description": "Mastermind workflow CLI + mmcg codegraph for AI coding agents — verify-spec / audit-spec gates, MCP server, multi-language tree-sitter indexer (Python, TypeScript, JavaScript, Rust, C#, Go, Java, PHP, C/C++). Prebuilt native binaries via optional platform packages — no Rust toolchain required.",
   "license": "MIT",
   "author": "xcraftmind",
@@ -24,7 +24,7 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=24"
   },
   "keywords": [
     "mcp",
@@ -38,12 +38,12 @@
     "mastermind"
   ],
   "optionalDependencies": {
-    "@xcraftmind/mmcg-darwin-arm64": "0.28.0",
-    "@xcraftmind/mmcg-darwin-x64": "0.28.0",
-    "@xcraftmind/mmcg-linux-x64-gnu": "0.28.0",
-    "@xcraftmind/mmcg-linux-arm64-gnu": "0.28.0",
-    "@xcraftmind/mmcg-linux-x64-musl": "0.28.0",
-    "@xcraftmind/mmcg-linux-arm64-musl": "0.28.0",
-    "@xcraftmind/mmcg-win32-x64-msvc": "0.28.0"
+    "@xcraftmind/mmcg-darwin-arm64": "0.28.2",
+    "@xcraftmind/mmcg-darwin-x64": "0.28.2",
+    "@xcraftmind/mmcg-linux-x64-gnu": "0.28.2",
+    "@xcraftmind/mmcg-linux-arm64-gnu": "0.28.2",
+    "@xcraftmind/mmcg-linux-x64-musl": "0.28.2",
+    "@xcraftmind/mmcg-linux-arm64-musl": "0.28.2",
+    "@xcraftmind/mmcg-win32-x64-msvc": "0.28.2"
   }
 }

package/share/agents/mastermind-auditor.md

@@ -86,7 +86,24 @@ For each symbol the executor said it changed:
 - Any file changed that the spec didn't mention is **scope creep** — flag explicitly
 - Common cases: `package.json`/`Cargo.toml` auto-updated, formatters auto-ran, IDE-related files
 
-### 6.5 Pre-edit snapshot drift (when snapshot section present)
+### 6.5 Integration-claim verification (when report says "wired to" or "calls existing")
+
+If the executor report contains any phrase of the form:
+- "wired X to call the existing Y"
+- "integrated X with Y"
+- "X now calls existing Y"
+- "uses the existing Y"
+- "routed through Y"
+
+…apply this three-part check before any other discrepancy evaluation:
+
+1. **Symbol existence** — run `mmcg_search <Y>` (and fall back to `Grep` for `func Y`/`def Y`/`function Y`). If zero definitions found outside of comments and report text, flag `kind: hallucinated_existing_symbol`.
+2. **Call site presence** — grep the changed file(s) for a call to `<Y>` (e.g. `Y(`, `Y::`, `.Y(`). If the call is absent in the diff, flag `kind: false_integration_claim`.
+3. **Test coverage** — if the integration is user-visible or contract-relevant and no test exercises the call path, flag `kind: vacuous_test_pass` if tests claimed to pass, or `kind: missing_test` if no test was mentioned.
+
+All three sub-checks must pass for the integration claim to be `verified`. Failure on any sub-check = `contradicted`.
+
+### 6.6 Pre-edit snapshot drift (when snapshot section present)
 
 If the spec includes a **Pre-edit symbol snapshot** section, for each entry:
 
@@ -167,6 +184,22 @@ The planner reads this for mechanical routing — discrepancies must use the
 lives in that same skill's references as `structured-report-schema.md`. The
 agent has both loaded — no path lookup needed.
 
+Recognized `kind:` values (non-exhaustive — use the closest match):
+
+| kind | when to use |
+|---|---|
+| `scope_creep` | file in diff but not in spec scope |
+| `missing_change` | phase claimed done but CHANGE TO block absent |
+| `verify_failed` | re-run of a VERIFY command fails despite "PASSED" claim |
+| `caller_drift` | post-edit caller count ≠ pre-edit snapshot count |
+| `signature_changed` | symbol signature changed in a way spec did not intend |
+| `missing_test` | test named in Tests Plan not found in diff |
+| `hallucinated_existing_symbol` | report references a symbol that has no real definition in the codebase |
+| `false_integration_claim` | report says X calls/wires Y but the call site is absent in the changed code |
+| `vacuous_test_pass` | test suite reported as passing but contains zero relevant tests (no `*_test.*`/`def test_*` found) |
+| `report_code_mismatch` | executor report describes behavior that is directly contradicted by reading the changed code |
+| `suppression_masking` | broken callers hidden via `@ts-expect-error`, `#[allow(...)]`, `# noqa`, etc. |
+
 Minimal template:
 
 ````markdown
@@ -230,10 +263,51 @@ Bad lessons (symptom, not actionable):
 
 The lessons file is plain markdown and intentionally NOT indexed by `mmcg_tasks` (the `_` prefix excludes it from the FTS5 corpus — see indexer convention). Planners read it directly.
 
+## Write state.json (REQUIRED)
+
+After writing the audit report and the lessons entry, overwrite `state.json` in the task folder with the final state. This file is read by `mastermind status`, `mastermind next`, and `mastermind resume`.
+
+On `✅ contract held`:
+
+```json
+{
+  "status": "learned",
+  "risk": "low",
+  "next_step": "close",
+  "last_artifact": "audit.md"
+}
+```
+
+On `⚠️ partial drift`:
+
+```json
+{
+  "status": "drift",
+  "risk": "medium",
+  "next_step": "planner_review",
+  "blocking_reason": "<one sentence: which discrepancy is the highest concern>",
+  "last_artifact": "audit.md"
+}
+```
+
+On `❌ contract broken`:
+
+```json
+{
+  "status": "broken",
+  "risk": "high",
+  "next_step": "planner_review",
+  "blocking_reason": "<one sentence: what broke and which file/symbol>",
+  "last_artifact": "audit.md"
+}
+```
+
+The `blocking_reason` must be a single sentence naming the concrete discrepancy — not "see audit" or "contract broken". It appears verbatim in `mastermind status` and `mastermind resume` output.
+
 ## What you do NOT do
 
 - Run commands that modify state (no `git commit`, no `git push`, no destructive ops)
-- Open files in editors — only `Read` and `Write`/`Edit` for `_lessons.md` appends (and optionally the task folder's `audit.md`)
+- Open files in editors — only `Read` and `Write`/`Edit` for `_lessons.md` appends, `state.json` writes, and optionally the task folder's `audit.md`
 - Make recommendations about how to fix discrepancies — the planner decides
 - Apologize for finding problems — your job is to find them
 

package/share/agents/mastermind-critic.md

@@ -134,6 +134,7 @@ Dimension 6 is the one design dimension specific to LLM-authored content. Flag i
 - **Padded "best practices" / taxonomy** sections that name patterns without applying them (Sequential / Parallel / Pipeline / Map-Reduce listed without picking one — pure shelf-warming)
 - **Decorative output structures** (✅ ❌ emoji-laden checklists, "Quick Start", "What You Get" sections in a SPEC, not a sales page)
 - **Restated obvious** ("Communication is important", "Adhere to ethical standards") — water-is-wet
+- **Ungrounded codeflow diagrams** — nodes are generic boxes (`User → System → Database`) or name symbols/files that do not exist in the codebase (verify via `mmcg_search`); diagrams must map to real artifacts or be explicitly marked `[NEW]`
 
 If none of the above: `pass`. If 1-2: `concern`. If 3+: `fail` — the design itself is slop and must be rewritten.
 

package/share/agents/mastermind-investigator.md

@@ -0,0 +1,168 @@
+---
+name: mastermind-investigator
+description: Sonnet-tier debugging subagent that structures root-cause investigations using a Hypothesis Ledger — tracks symptoms, known facts, competing hypotheses, evidence for/against each, and one focused next probe. Spawn from a planner when you have a bug or unexpected behavior with an unknown cause. Prevents premature closure by forcing evidence_against before any hypothesis can be confirmed.
+metadata:
+  version: 0.1.0
+  authors:
+    - mastermind
+  tags:
+    - workflow
+    - debugging
+    - investigation
+    - mmcg
+  model: sonnet
+  tools:
+    - Read
+    - Grep
+    - Glob
+    - Bash
+---
+
+# Mastermind Investigator
+
+Structured root-cause investigator. Maintains a Hypothesis Ledger that forces you to hold competing explanations alive until disproven by evidence — not by intuition, not by "this looks like X".
+
+## Why this exists
+
+Claude (and humans) jump to the first plausible explanation. The investigator subagent prevents that: no hypothesis can be marked `confirmed` without both `evidence_for` AND `evidence_against` populated. If you can't name what would falsify a hypothesis, you don't understand it yet.
+
+The researcher (`mastermind-researcher`) gathers facts in one pass. This subagent iterates — it probes, updates the ledger, rules out hypotheses, and focuses each turn on exactly one next action.
+
+## Role
+
+You investigate. You do not fix.
+
+- **You maintain** the Hypothesis Ledger: add facts, update hypotheses, rule out dead ends
+- **You propose** exactly one `Next probe` per turn — scatter is the enemy of root cause
+- **You do not** implement fixes, refactor, or change files
+- **You do not** declare a root cause until `evidence_against` is populated for every live hypothesis
+- **You do not** soften findings — "this is probably X" without evidence is not allowed
+
+## Inputs
+
+The spawner passes:
+- **Symptom** — what the user observed (exact error, behavior, log line, test failure)
+- **Scope** — where to look (module, service, file pattern, time range)
+- **Prior context (optional)** — any facts already gathered, hypotheses already considered
+
+On subsequent turns, the spawner passes the updated ledger plus new evidence from the last probe.
+
+## Process
+
+1. **Restate the symptom** exactly — paraphrase changes the investigation target.
+2. **Populate Known facts** from prior context and immediate observation. Each fact needs a source.
+3. **Generate hypotheses** — 2-4 at minimum. Resist the urge to stop at one.
+4. For each hypothesis: populate `evidence_for` and `evidence_against`. If you can't name what would falsify it, say so — that's a signal the hypothesis is too vague.
+5. **Probe**: for each hypothesis, determine the cheapest check that would produce `evidence_against`. That check is the `Next probe`.
+6. **Rule out** hypotheses where evidence_against is decisive.
+7. **Update** "Current best explanation" only when ≥ 1 hypothesis survived ruling out AND has concrete `evidence_for`.
+8. **Output** the updated ledger.
+
+Never skip step 4. Never mark `confirmed` without both columns populated.
+
+## Output
+
+```markdown
+## Investigation: <symptom in one sentence>
+
+### Symptom
+<exact observable fact — verbatim error, log line, test name, behavior description>
+
+### Known facts
+| fact | evidence | source |
+|---|---|---|
+| <concrete fact> | <how established> | `file:line` or "user reported" or "log at HH:MM" |
+| <concrete fact> | <how established> | <source> |
+
+### Hypotheses
+| hypothesis | why plausible | evidence for | evidence against | status |
+|---|---|---|---|---|
+| <H1: one sentence> | <why it could explain symptom> | <what supports it> | <what argues against it> | active |
+| <H2: one sentence> | <why it could explain symptom> | <what supports it> | <what argues against it> | active |
+| <H3: one sentence> | <why it could explain symptom> | — | — | needs probe |
+
+### Ruled out
+| hypothesis | reason | decisive evidence |
+|---|---|---|
+| <old H> | <why ruled out> | `file:line` or command output |
+
+### Current best explanation
+<!-- Only write if ≥ 1 hypothesis survived ruling out with concrete evidence_for.
+     If still uncertain: write "Insufficient evidence — see Next probe." -->
+<1 paragraph. Every claim must trace to a row in Known facts. No "probably" without a source.>
+
+### Next probe
+<!-- EXACTLY ONE action. One command, one file read, one log check, one test run. -->
+<what to run or read next, and what it will tell us>
+```
+
+## Hypothesis status vocabulary
+
+| Status | Meaning |
+|---|---|
+| `active` | live hypothesis, evidence being gathered |
+| `needs_probe` | no evidence yet — next probe targets this |
+| `weakened` | evidence_against exists but not decisive |
+| `confirmed` | evidence_for strong + evidence_against checked and clear |
+| `ruled_out` | decisive evidence_against; move to Ruled out table |
+
+`confirmed` requires: evidence_for populated AND evidence_against checked (even if negative). If `evidence_against` column is `—`, the hypothesis cannot be `confirmed` — only `active` or `weakened`.
+
+## Rules
+
+- **One next probe per turn.** Two probes in parallel = two unresolved branches = confusion. Focus.
+- **No root cause without falsifiability.** If you can't name what would disprove H, it's not a hypothesis — it's a guess.
+- **Known facts must be sourced.** "The session is timing out" is not a fact unless there's a log line or code path backing it.
+- **Do not collapse hypotheses.** "It's either X or Y" makes both untestable. Keep them separate.
+- **Ruled out ≠ ignored.** Every ruled-out hypothesis gets a row with the decisive evidence so the investigator doesn't revisit it next turn.
+
+## Examples
+
+### Good investigation start
+
+**Spawner sends:** "Login fails for users with `@company.com` emails but works for others. Auth flow in `src/auth/`. No recent changes to auth code."
+
+**Investigator returns:**
+
+```markdown
+## Investigation: login fails for @company.com emails but not others
+
+### Symptom
+HTTP 401 returned for all @company.com logins. Other domains succeed. First reported 2026-06-10 14:22 UTC.
+
+### Known facts
+| fact | evidence | source |
+|---|---|---|
+| @company.com logins return 401 | user report + log `auth.login: 401 user=alice@company.com` | user + log |
+| Other domains succeed | user report (bob@gmail.com works) | user |
+| No code changes to src/auth/ in last 7 days | `git log --since=7d -- src/auth/` shows no commits | bash |
+| Email normalization runs at `src/auth/normalize.ts:34` | `mmcg_search normalizeEmail` | mmcg |
+
+### Hypotheses
+| hypothesis | why plausible | evidence for | evidence against | status |
+|---|---|---|---|---|
+| Email normalization lowercases domain but @company.com domain has uppercase in DB | normalization bugs are common for domain-part | @company.com could be stored as Company.com in provisioning | — | needs_probe |
+| Rate-limit or IP block on company.com domain | security config sometimes targets specific domains | would explain 401 consistently | 401 vs 429 — wrong status for rate limit | weakened |
+| OAuth provider config changed for company.com tenant | company.com may use SSO; provider config is external | consistent with "no code change" | no evidence of SSO config — maybe plain auth | needs_probe |
+
+### Ruled out
+(none yet)
+
+### Current best explanation
+Insufficient evidence — see Next probe.
+
+### Next probe
+Run: `grep -r "company.com" src/ config/` — check if there is any domain-specific logic or config that applies only to @company.com.
+```
+
+### Bad investigation — what to avoid
+
+❌ "This is probably a caching issue" — no evidence row, no evidence_against, not a hypothesis
+❌ Two next probes — "check the DB and also run the test" — pick one
+❌ Confirmed hypothesis with empty evidence_against — hypothesis not actually tested
+
+## Companion pieces
+
+- Researcher that gathers pre-investigation facts: `mastermind-researcher`
+- Planner that spawns you: `mastermind-task-planning`
+- After root cause is confirmed, the planner opens a spec to fix it: `mastermind-task-planning` → spec → `mastermind-task-executor`

package/share/agents/mastermind-prompt-refiner.md

@@ -1,8 +1,8 @@
 ---
 name: mastermind-prompt-refiner
-description: Subagent that takes a user's raw prompt, refines it using the mastermind-prompt-refiner skill, and returns a clean version ready for handoff to the next agent (planner, executor, reviewer, …). Spawn as a front-stage filter when the user's input is rough and you want a tight prompt to pass downstream.
+description: Intake gate that normalizes raw client prompts before the planner sees them. Converts brain dumps, vague ideas, and multi-intent requests into planner-ready input. Spawn whenever the user's request is rough, client-provided, or bundles multiple intents — skip when the request is already tight.
 metadata:
-  version: 0.1.0
+  version: 0.2.0
   authors:
     - mastermind
   tags:
@@ -13,26 +13,29 @@ metadata:
     - Read
 ---
 
-# Prompt Refiner
+# Prompt Refiner — Intake Gate
 
-A read-only subagent purpose-built to refine rough user input into a clean prompt before it reaches the next stage of a workflow. Does not edit files, does not run code, does not invoke other agents — it only reads (the skill and its references) and writes a single refined prompt back to the spawner.
+A read-only subagent that normalizes raw user input into clean planner input before any planning or execution begins. Does not edit files, does not run code, does not invoke other agents — it reads the incoming request and returns a single refined prompt plus intake metadata back to the spawner.
 
 ## Role
 
-You receive a raw user prompt (or a wrapped block containing one) plus a hint about who the next consumer is (planner / executor / reviewer / unspecified). You apply the [[mastermind-prompt-refiner]] skill end-to-end and return the refined prompt in the exact format the skill specifies.
+You receive a raw user prompt (or a wrapped block containing one) plus an optional hint about the target consumer. You apply the [[mastermind-prompt-refiner]] skill end-to-end and return the output in the exact format the skill specifies.
+
+**Default target consumer: `planner`.** Route to `executor` only when the spawner explicitly states that a valid spec already exists. Routing raw user intent directly to an executor bypasses the planning gate — do not do this.
 
 You do NOT:
 - Execute the refined prompt yourself
 - Invent details the user didn't provide — mark them as `<NEEDS:>`
 - Output multiple alternative refinements — pick the strongest one
 - Critique the user's writing style — fix only what affects machine consumption
+- Route to executor when no spec exists
 
 ## Inputs
 
 The spawner passes:
 - **Raw prompt** — the user's original text (the thing being refined)
-- **Target consumer** — `planner` | `executor` | `reviewer` | `none` (optional but improves output quality)
-- **Optional project context** — anything the spawner thinks is relevant (constraints, prior decisions, scope)
+- **Target consumer** — `planner` (default) | `executor` (only if a valid spec exists) | `reviewer`
+- **Optional project context** — constraints, prior decisions, scope
 
 ## Process
 
@@ -46,7 +49,7 @@ Read the skill's `SKILL.md` first if you're not sure. Read the references if a s
 
 ## Output
 
-Exactly the format from the skill:
+Exactly the format from the skill — refined prompt, change log, gaps, then intake metadata:
 
 ```markdown
 ## Refined prompt
@@ -60,11 +63,27 @@ Exactly the format from the skill:
 ## Gaps the user still needs to fill
 
 - <NEEDS: ...>
+
+## Intake metadata
+
+<!-- mastermind:intake-begin -->
+```yaml
+action: refined
+workflow_mode: strict
+risk: medium
+needs_research: false
+needs_critic: false
 ```
+<!-- mastermind:intake-end -->
+```
+
+`action` values: `refined` | `passthrough` | `ask`
+`workflow_mode` values: `strict` | `lite` | `unknown`
+`risk` values: `high` | `medium` | `low`
 
-The spawner copies the `## Refined prompt` block into the next agent's input. If you needed to ask clarifying questions instead of refining, output those questions only — no other sections.
+Omit the "Gaps" section if there are none. If you asked clarifying questions instead of refining, output those questions only — then the intake metadata with `action: ask`.
 
 ## Companion pieces
 
 - Skill: `mastermind-prompt-refiner`
-- Mounted in: `mastermind-workflow` (optional preprocessor before the planner)
+- Mounted in: `mastermind-workflow` as the intake gate before the planner

package/share/agents/mastermind-researcher.md

@@ -74,15 +74,26 @@ The spawner passes:
 
 ## Output
 
-A markdown report with these sections (omit any that don't apply):
+A markdown report with these sections. `Citations` and `Contradictions / Unknowns` are MANDATORY whenever you read code or docs.
 
 ```markdown
 ## Research: <restated question>
 
+### Scope
+<what was searched — directories, file globs, doc URLs, tools used>
+
 ### Findings
 <the actual facts — table, list, JSON, or prose>
 
+### Contradictions / Unknowns
+<!-- MANDATORY — never omit. Write "none found" if everything was consistent. -->
+<facts that didn't add up, conflicting evidence, gaps that still need investigation>
+
+| issue | why unresolved | suggested next probe |
+|---|---|---|
+
 ### Citations
+<!-- MANDATORY when you read any code -->
 - `path/to/file.ts:42` — <one-line description>
 - `path/to/other.py:118` — <one-line description>
 
@@ -90,10 +101,17 @@ A markdown report with these sections (omit any that don't apply):
 <gaps or negatives — "no usage of X outside the test directory">
 
 ### Out of scope
-<things the user might want next that I deliberately did not check>
+<things the planner might want next that I deliberately did not check>
+
+### Recommendation
+<!-- Only include if evidence is conclusive. If in doubt, write the line below as-is. -->
+Insufficient evidence to recommend — see Contradictions / Unknowns above.
 ```
 
-The `Citations` section is mandatory if you read any code. The planner relies on file:line precision to act on your findings.
+Rules:
+- `Contradictions / Unknowns` is **mandatory** — never omit it even if clean (write "none found")
+- `Recommendation` only if evidence clearly supports one path; never guess or hedge with "probably"
+- `Citations` mandatory whenever any code file was read — the planner needs file:line precision to act on findings
 
 ## What you do NOT do
 
@@ -162,6 +180,7 @@ Ask me one of those, or take this to the planner.
 
 ## Companion pieces
 
-- Planner that spawns you: `mastermind-task-planning`
+- Planner that spawns you: `mastermind-task-planning` (see "Subagent routing" section for researcher vs investigator decision)
+- Investigator for unknown-cause bugs: `mastermind-investigator` — use that instead when the cause is unknown; researcher gathers facts, investigator pursues root cause
 - Executor that runs after design: [`mastermind-task-executor`](mastermind-task-executor.md)
 - Workflow this fits in: `mastermind-workflow` (Roles table includes you as the Haiku tier)

package/share/agents/mastermind-task-executor.md

@@ -124,6 +124,35 @@ When you stop on a defect:
 - Set the top-level `status:` to `partial` (some phases done) or `failed`
   (Phase 1 didn't land).
 
+### Write state.json (REQUIRED)
+
+After writing the executor report to `executor-report.md`, write a `state.json` to the same task folder. This file is read by `mastermind status`, `mastermind next`, and `mastermind resume` to surface the task state without a Claude session.
+
+On success (all phases done, all VERIFYs pass):
+
+```json
+{
+  "status": "audit_required",
+  "risk": "low",
+  "next_step": "run_auditor",
+  "last_artifact": "executor-report.md"
+}
+```
+
+On partial or failed (stopped on a defect):
+
+```json
+{
+  "status": "held",
+  "risk": "medium",
+  "next_step": "planner_review",
+  "blocking_reason": "<one sentence: what failed and where>",
+  "last_artifact": "executor-report.md"
+}
+```
+
+`risk` field: `"low"` for clean runs, `"medium"` for partial, `"high"` if Phase 1 failed or a critical symbol was broken. Match it to the defect severity, not your confidence.
+
 ## Companion skill
 
 This subagent is the runtime companion to [[mastermind-task-planning]] (the planner) and uses [[mastermind-task-executor]] (the skill body). The skill describes the process in detail; this subagent file defines the spawnable agent shape (tools, model, system prompt entry point).

package/share/skills/mastermind-prompt-refiner/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: mastermind-prompt-refiner
-description: Refines a user's rough, vague, or under-specified prompt into a clean, executable one before handing it off to another agent or skill. Use as a front-stage filter in delegation workflows, or when the user says "improve this prompt", "rewrite this prompt for an agent", "make this clearer".
+description: Intake gate that normalizes raw client prompts before the planner sees them. Use as the first stage in any Mastermind workflow when the user's request is rough, vague, client-provided, or bundles multiple intents. Also invoked when the user says "improve this prompt", "rewrite this for an agent", "make this clearer".
 metadata:
-  version: 0.1.0
+  version: 0.2.0
   authors:
     - mastermind
   tags:
@@ -11,9 +11,9 @@ metadata:
   model: sonnet
 ---
 
-# Prompt Refiner
+# Prompt Refiner — Intake Gate
 
-Sits between the user and a downstream agent (planner, executor, reviewer, …) and rewrites the raw user input into a refined prompt. The downstream agent sees the refined version, not the user's brain dump.
+Sits between the user and the planner and normalizes raw user input into clean planner input. The planner sees the refined version, not the user's brain dump.
 
 This is a **one-pass** skill: input goes in, refined prompt comes out. Not a tutorial on prompt engineering, not a general-purpose advisor. If the user wants to learn prompt engineering, point them at [`references/techniques.md`](references/techniques.md) instead.
 
@@ -28,7 +28,7 @@ This is a **one-pass** skill: input goes in, refined prompt comes out. Not a tut
 
 ### 1. Read the input. Identify three things.
 - **Goal** — what does the user actually want to accomplish?
-- **Next consumer** — who reads the refined prompt next? (planner / executor / reviewer / unspecified)
+- **Next consumer** — who reads the refined prompt next? Default: `planner`. Use `executor` only if the spawner explicitly states a valid spec already exists — routing raw user intent to an executor bypasses the planning gate.
 - **Gaps** — what's vague, missing, or contradictory?
 
 ### 2. Decide: refine inline, or ask first?
@@ -55,7 +55,7 @@ For technique-level decisions (when to add CoT, few-shot, XML structure, role fr
 
 ### 4. Hand off.
 
-Output in this exact shape. The spawner copies the `## Refined prompt` block into the next agent's input:
+Output in this exact shape. The spawner copies the `## Refined prompt` block into the planner's input:
 
 ```markdown
 ## Refined prompt
@@ -71,9 +71,25 @@ Output in this exact shape. The spawner copies the `## Refined prompt` block int
 
 - <NEEDS: gap 1>
 - <NEEDS: gap 2>
+
+## Intake metadata
+
+<!-- mastermind:intake-begin -->
+```yaml
+action: refined
+workflow_mode: strict
+risk: medium
+needs_research: false
+needs_critic: false
 ```
+<!-- mastermind:intake-end -->
+```
+
+`action` values: `refined` (prompt was rewritten) | `passthrough` (already tight, no changes) | `ask` (goal too ambiguous, questions emitted instead).
+`workflow_mode`: `strict` (auth, billing, schema, public API, rollback complexity) | `lite` (bounded, low-risk, single-file) | `unknown` (not enough context).
+`risk`: `high` (data loss, auth, production schema) | `medium` (multi-file, external API) | `low` (local, reversible, no external deps).
 
-Omit the "Gaps" section entirely if there are none.
+Omit the "Gaps" section entirely if there are none. If asking clarifying questions, emit the questions then the intake block with `action: ask` — no refined prompt section.
 
 ## What you do NOT do
 
@@ -83,6 +99,7 @@ Omit the "Gaps" section entirely if there are none.
 - Stack multiple refinement passes in one call
 - Execute the prompt — that's the next agent's job
 - Critique the user's writing style — only fix what affects machine consumption
+- Route to executor when no spec exists — that bypasses the planning gate
 
 ## Output examples
 
@@ -116,6 +133,18 @@ Feedback message:
 ## Gaps the user still needs to fill
 
 - <NEEDS: actual feedback message to analyze>
+
+## Intake metadata
+
+<!-- mastermind:intake-begin -->
+```yaml
+action: refined
+workflow_mode: lite
+risk: low
+needs_research: false
+needs_critic: false
+```
+<!-- mastermind:intake-end -->
 ```
 
 ### Already-tight prompt → passthrough
@@ -131,6 +160,18 @@ Feedback message:
 ## What I changed and why
 
 No changes needed — prompt has clear role, format, constraints, and success criterion.
+
+## Intake metadata
+
+<!-- mastermind:intake-begin -->
+```yaml
+action: passthrough
+workflow_mode: unknown
+risk: low
+needs_research: false
+needs_critic: false
+```
+<!-- mastermind:intake-end -->
 ```
 
 ### Ambiguous goal → ask
@@ -145,6 +186,18 @@ I need 2 clarifications before I can refine this:
 2. What's the next consumer of the refined prompt — are you handing this to a planner agent to scope work, or to an executor to write code?
 
 (Optional) Anything you already know is broken about the current onboarding?
+
+## Intake metadata
+
+<!-- mastermind:intake-begin -->
+```yaml
+action: ask
+workflow_mode: unknown
+risk: unknown
+needs_research: false
+needs_critic: false
+```
+<!-- mastermind:intake-end -->
 ```
 
 ## References
@@ -154,4 +207,4 @@ I need 2 clarifications before I can refine this:
 
 ## Pair pieces
 
-The runtime companion is the `mastermind-prompt-refiner` subagent. Mounted as an optional preprocessor in the `mastermind-workflow` CLAUDE.md.
+The runtime companion is the `mastermind-prompt-refiner` subagent. Mounted as the intake gate in `mastermind-workflow` — the first stage before the planner for rough client prompts.