@alexeiled/pi-fusion 0.5.2 → 0.6.0

package/README.md

@@ -8,8 +8,8 @@
 > Parallel models. One judge. Better answers.
 
 `pi-fusion` is a Pi extension for hard technical questions.
-It uses `pi-subagents` to send the same prompt through a small parallel model panel,
-then asks a judge agent to compare the outputs and return the best realistic answer.
+It sends one prompt to a small panel of models that run in parallel.
+A judge agent then compares the answers and returns the best realistic one.
 
 CI covers lint, typecheck, unit tests, integration tests, package smoke tests,
 and `npm pack --dry-run`.
@@ -122,7 +122,7 @@ synthesize the best realistic answer.
 
 Use it for questions like:
 
-- Which design should we choose?
+- Which design do we choose?
 - What will break if I change this?
 - Is this PR or release flow safe?
 - What did I miss?
@@ -136,6 +136,7 @@ Do not use it for trivial edits, formatting, or obvious one-step fixes.
 /fusion
 /fusion <prompt>
 /fusion --profile <name> <prompt>
+/fusion --panel <models> <prompt>
 /fusion -p <name> <prompt>
 /fusion status
 /fusion stop
@@ -155,11 +156,11 @@ Other Pi extensions can control Fusion through the versioned event-bus contract
 Methods:
 
 - `ping` — return the RPC version and supported methods
-- `start` — requires `prompt` and a non-empty `operationId`; accepts optional `profile`. Reusing an operation ID returns the original run instead of starting another, including after Fusion restores the Pi session history.
+- `start` — requires `prompt` and a non-empty `operationId`. It accepts an optional `profile`. Reusing an operation ID returns the original run instead of starting another, including after Fusion restores the Pi session history.
 - `status` — return structured run state by `operationId`, `runId`, or the current/last run
-- `result` — return a terminal run and report; active runs return `not_ready`
+- `result` — return a terminal run and report. An active run returns `not_ready`
 - `cancel` — cancel the selected active run, or report that the selected terminal run was not cancelled
-- `adopt` — confirm and return a run from restored session history by `runId`
+- `adopt` — verify and return a run from restored session history by `runId`
 
 `start` returns `{ operationId, replayed, run }`. `status` and `result`
 return `{ run }`. `cancel` returns `{ cancelled, run? }`. `adopt` returns
@@ -183,6 +184,13 @@ pi install npm:pi-subagents
 pi install npm:@alexeiled/pi-fusion
 ```
 
+Optional. Only needed if a panel member uses the `fusion-panelist-web` or
+`fusion-panelist-full` agent:
+
+```bash
+pi install npm:pi-web-providers
+```
+
 Then reload Pi:
 
 ```text
@@ -199,10 +207,15 @@ For commands, config, and troubleshooting details, see [`docs/user-guide.md`](./
 - Output appears as a Pi custom message. Active progress also uses the `fusion` status key.
 - Active runs are reconciled from `pi-subagents` lifecycle artifacts, not only completion events.
 - `pi-fusion` does not own the footer.
-- Prompts and inspected snippets may be sent to every configured panel provider and to the judge through `pi-subagents`.
-- Reports include available per-panel and judge time, aggregate model time, usage, estimated cost, and model failure details. Missing provider usage is shown as unknown; `$0.0000` remains a known zero-cost value.
-- `Model` is lifecycle metadata. `Configured model` is the profile request; both appear when execution differs from the request.
+- Fusion sends your prompt and any inspected snippets to every panel model, and to the judge, through `pi-subagents`.
+- Reports include available per-panel and judge time, aggregate model time, usage, estimated cost, and model failure details. Missing provider usage is shown as unknown. `$0.0000` is a known zero cost.
+- `Model` is lifecycle metadata. `Configured model` is the profile request. Both appear when the run differs from the request.
 - `stopWhenPanelAgrees` is an opt-in profile setting. It requires matching high-confidence decision records with no request for more evidence, stops only unfinished panelists, and still runs the judge.
+- Panel answers reach the judge in an order seeded from the run id, not in config order. A fixed order advantages the same member on every run, because judges favour whichever candidate they see first or last.
+- Panelists can search the web by opting in to the `fusion-panelist-web` agent, which requires `pi-web-providers`. Defaults stay local-only on purpose: tool names are a strict allowlist, so an agent declaring a tool whose extension is missing fails every task that uses it.
+- `synthesis: "merge"` switches from picking the best answer to merging answers that covered different facets, using the `fusion-composer` agent. Panel members get facets through their optional `question` field. See the user guide.
+- `blindPanelLabels` hides member names, roles, agents, and artifact paths from the judge, so role labels stop acting as authority cues. Your report still shows real names.
+- `fusion-panelist-full` grants `bash`, `edit`, and `write`. It is opt-in, it voids the read-only property the other agents have, and it is unsafe at `concurrency > 1` because panelists share one working directory.
 
 ## Read more
 

package/agents/fusion-composer.md

@@ -0,0 +1,49 @@
+---
+name: fusion-composer
+package: pi-fusion
+description: Merges panel answers that covered different facets of one task.
+tools: read, grep, find, ls
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+defaultContext: fresh
+completionGuard: false
+---
+
+You are the pi-fusion composer.
+
+The panelists did not answer the same question. Each was assigned a different
+facet of one task. Your job is to **merge** their answers into one, not to pick
+a winner.
+
+- Do not rank the panelists. They were not competing.
+- Do not drop material because it is long. Coverage is the point.
+- Only report a conflict where two facets genuinely overlap and disagree.
+  Different subject matter is not disagreement.
+- Name the facets nobody covered, or covered only in passing. A gap is a
+  finding, not a formatting problem.
+- Where panelists state conflicting facts about the codebase, check the claim
+  yourself and cite `file:line` instead of choosing the more confident wording.
+
+Read-only synthesis. Do not edit files. Do not ask other agents. Do not run
+subagents.
+
+Return final Markdown with these sections:
+
+# Fusion Report
+
+## Summary
+
+## Coverage Map
+
+## Combined Answer
+
+## Gaps
+
+## Conflicts At Seams
+
+## Agent Status
+
+## Risks
+
+## Next Step

package/agents/fusion-judge.md

@@ -15,6 +15,11 @@ You are the pi-fusion judge.
 Compare panel outputs. Do not invent consensus. Preserve disagreements. Prefer the smallest realistic recommendation.
 Do not edit files. Do not ask other agents. Do not run subagents.
 
+When panelists state conflicting facts about the codebase, check the claim
+yourself rather than choosing the more confident wording. You have read tools;
+a factual conflict is settled by looking, not by weighing prose. Cite `file:line`
+for what you find, and say plainly when a claim could not be verified.
+
 Return final Markdown with these sections:
 
 # Fusion Report
@@ -27,6 +32,8 @@ Return final Markdown with these sections:
 
 ## Disagreements
 
+## Contested Claims
+
 ## Unique Insights
 
 ## Blind Spots

package/agents/fusion-panelist-full.md

@@ -0,0 +1,53 @@
+---
+name: fusion-panelist-full
+package: pi-fusion
+description: Panel member with write and shell access. Opt-in; unsafe at concurrency > 1.
+tools: read, grep, find, ls, bash, edit, write, web_search, web_contents, web_answer, web_research
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+defaultContext: fresh
+completionGuard: false
+---
+
+You are a pi-fusion panelist with full tool access.
+
+Requires `pi-web-providers`. Tool names are a strict allowlist, not a loader, so
+without that extension **every** task using this agent fails with "requested
+unavailable child tools" — including tasks that only need `bash` or `edit`.
+Install it, or use `fusion-panelist`.
+
+Read this before acting. Unlike the other Fusion panelists you can run commands
+and modify the workspace, and Fusion may be running other panelists against the
+same working directory at the same time.
+
+- Prefer inspection. Reach for `bash`, `edit`, or `write` only when the task
+  genuinely cannot be answered by reading.
+- Never mutate tracked files, git state, or anything another panelist may be
+  reading. Treat the workspace as shared.
+- Scratch work goes in a temporary directory, not the repository.
+- Long or open-ended commands are a hazard: another panelist is waiting.
+- `web_research` is slow and expensive. Use `web_search` or `web_answer` unless
+  the task truly needs a deep report.
+
+Work independently. Do not ask other agents. Do not run subagents.
+
+Return concise Markdown with these sections.
+
+When the task includes a decision-record contract:
+
+- Append exactly one `<fusion-panel-decision>{...}</fusion-panel-decision>` JSON record as the final line.
+- Do not write any text after it.
+- Fusion uses the record only for early-stop orchestration; users receive the preceding Markdown answer.
+
+## Summary
+
+## Recommendation
+
+## Evidence
+
+## Risks
+
+## Confidence
+
+## Open Questions

package/agents/fusion-panelist-web.md

@@ -0,0 +1,41 @@
+---
+name: fusion-panelist-web
+package: pi-fusion
+description: Panel member with web access. Requires the pi-web-providers extension.
+tools: read, grep, find, ls, web_search, web_contents, web_answer
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+defaultContext: fresh
+completionGuard: false
+---
+
+You are a pi-fusion panelist with web access.
+
+Requires `pi-web-providers`. Without it every task using this agent fails with
+"requested unavailable child tools" — install it, or use `fusion-panelist`.
+
+Work independently. Inspect relevant local files when the task needs code evidence.
+Search the web when the task turns on external facts: library behaviour, version
+differences, standards, or anything you would otherwise have to guess. Cite what
+you retrieved. Do not edit files. Do not ask other agents. Do not run subagents.
+
+Return concise Markdown with these sections.
+
+When the task includes a decision-record contract:
+
+- Append exactly one `<fusion-panel-decision>{...}</fusion-panel-decision>` JSON record as the final line.
+- Do not write any text after it.
+- Fusion uses the record only for early-stop orchestration; users receive the preceding Markdown answer.
+
+## Summary
+
+## Recommendation
+
+## Evidence
+
+## Risks
+
+## Confidence
+
+## Open Questions

package/agents/fusion-panelist.md

@@ -13,6 +13,8 @@ completionGuard: false
 You are a pi-fusion panelist.
 
 Work independently. Inspect relevant local files when the task needs code evidence.
+You have no web access: answer from the repository and your own knowledge, and say
+so plainly when a question turns on external facts you cannot retrieve.
 Do not edit files. Do not ask other agents. Do not run subagents.
 
 Return concise Markdown with these sections.

package/docs/user-guide.md

@@ -7,12 +7,29 @@ README covers the why. This guide covers commands, config, and troubleshooting.
 `pi-fusion` turns one hard question into a small parallel panel:
 
 ```text
-prompt → parallel panel → judge synthesis → final report
+prompt → parallel panel → judge picks the best answer → report
 ```
 
-Fusion keeps the command simple: one prompt starts the panel, then the judge turns the collected evidence into a human-readable Markdown report. Older runs created as a single `pi-subagents` chain remain supported when restored.
+The command stays simple. One prompt starts the panel. One synthesis step then
+turns the collected evidence into a Markdown report.
 
-Panel diversity can come from different model choices, different perspective prompts, or both. In practice, mixing models is usually the main lever.
+There is a second shape. Give panel members a `question` and they answer
+*different facets* instead of the same question, and a composer merges their
+answers rather than picking between them:
+
+```text
+prompt → panel, one facet each → composer merges → report
+```
+
+You do not select between these. Facets decide: a panel with `question` fields
+merges, a panel without them selects.
+
+Panel diversity comes from different model choices, different perspective
+prompts, or both. **Mixing models is the main lever.** The config that
+`/fusion init` writes sets no `model`. By default you therefore get one model in
+three roles. Give each member its own `model` to get the real benefit.
+
+Older runs created as a single `pi-subagents` chain remain supported when restored.
 
 The base Pi session stays in control. Fusion is a tool for decisions, not a replacement for normal coding.
 
@@ -25,6 +42,7 @@ Preferred command shape:
 /fusion <prompt>
 /fusion --profile <name> <prompt>
 /fusion -p <name> <prompt>
+/fusion --panel <entries> <prompt>
 /fusion status
 /fusion stop
 /fusion init
@@ -38,7 +56,36 @@ Notes:
 - `/fusion init` writes `.pi/fusion.json` for the current trusted project.
 - Exact one-word prompts `init`, `status`, and `stop` are reserved as `/fusion` subcommands.
 
-## Configuration files
+### `--panel`
+
+Builds a one-off panel without editing config, for trying a composition before
+committing to it. The resolved profile still supplies the judge and every other
+setting. Only the panel changes.
+
+```text
+/fusion --panel opus,openai/gpt-5.5 Which design should we pick?
+/fusion --panel=opus,openai/gpt-5.5 Which design should we pick?
+/fusion --profile audit --panel opus,gemini-pro What did we miss?
+```
+
+Each comma-separated entry is `<model>` or `<agent>:<model>`:
+
+```text
+--panel opus,gpt-5.5                                     # both use the default panelist
+--panel pi-fusion.fusion-panelist-web:gpt-5.5,opus       # first member gets web access
+```
+
+An entry counts as agent-qualified only when the part before the first `:`
+contains a `.` and the part after it is not a thinking level. That keeps both
+`opus:high` and `gpt-4.1:high` models rather than agent references.
+
+The thinking levels are `off`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
+A word that is not one of them is read as a model, so `gpt-4.1:ultra` asks for
+the agent `gpt-4.1`, and the run fails with an unknown-agent error. Use a real
+level, or write the agent in full.
+Claude alias shorthand works inline: `--panel claude-work/opus-4.8`.
+
+## Config files
 
 Config lookup order:
 
@@ -105,17 +152,143 @@ Profile:
 - `concurrency`: max parallel panelists
 - `timeoutMs`: async subagent timeout in milliseconds
 - `context`: `fresh` or `fork`
-- `stopWhenPanelAgrees`: optional boolean, default `false`. When enabled, Fusion may stop unfinished panelists only when at least two completed panelists have the same normalized recommendation, every successful panelist reports `high` confidence, none requests more evidence, and work remains. The judge still runs over the collected answers. The policy is intentionally fixed; there are no agreement threshold knobs.
+- `stopWhenPanelAgrees`: optional boolean, default `false`. When it is on, Fusion can stop the panelists that have not finished yet. All four conditions must hold: two or more finished panelists give the same normalized recommendation, every one of them reports `high` confidence, none of them asks for more evidence, and work remains. The judge still runs over the answers already collected. This policy is fixed on purpose. There is no threshold to tune.
+- `synthesis`: rarely needed. Inferred from the panel — any member with a `question` means `merge`, otherwise `select`. Set it only to override that. See [Synthesis modes](#synthesis-modes).
+- `blindPanelLabels`: optional boolean, default `false`. When it is on, the judge sees `Candidate A`, `Candidate B`, and so on, instead of the configured labels. Fusion also withholds agent names and artifact paths, because they contain the member id. A role label reads as an authority cue before the judge compares any content. Your report always shows the real names.
+- `judgeToolBudget`: optional `{ "soft": n, "hard": n }`. It caps the tool calls the judge can spend to verify contested claims. `soft` is a nudge. After `hard`, Fusion blocks further tool use, so the judge still produces a report. Both numbers must be positive integers, and `soft` must not be larger than `hard`.
 
 Panel member:
 
 - `id`: stable machine name
-- `label`: human-readable report label
-- `agent`: subagent name
-- `model`: optional model override; often the main source of panel diversity. Supports normal Pi model ids, and if `pi-claude-alias` is configured, Claude alias shorthand like `claude-work/opus-4.8`
-- Claude alias handles must be unique across global and project alias files; duplicate handles are rejected.
+- `label`: optional report label. It defaults to `id`
+- `agent`: subagent name. This is where a member's tool access comes from — see [Panel agents and tools](#panel-agents-and-tools).
+- `model`: optional model override, and usually the main source of panel diversity. It accepts normal Pi model ids. If `pi-claude-alias` is installed, it also accepts Claude alias shorthand like `claude-work/opus-4.8`
+- A Claude alias handle must be unique across the global and project alias files. Fusion rejects a duplicate handle.
 - `thinking`: optional `off`, `minimal`, `low`, `medium`, `high`, or `xhigh`
 - `role`: optional perspective hint layered on top of the model
+- `question`: optional facet prompt sent **instead of** the raw task. `{task}` is substituted with the original prompt. Use with `synthesis: "merge"` to divide the work rather than duplicate it. If the template omits `{task}`, the original task is still appended so the panelist keeps its context.
+
+## Panel agents and tools
+
+A panel member's tools come from its **agent definition**, not from `fusion.json`.
+`pi-subagents` has no per-task tool override, so `agent` is the knob.
+
+Fusion ships five:
+
+| Agent                            | Tools                                                        | Use for                                                        |
+| -------------------------------- | ------------------------------------------------------------ | -------------------------------------------------------------- |
+| `pi-fusion.fusion-panelist` | `read, grep, find, ls` | Default. Local inspection only. It needs no extra extension. |
+| `pi-fusion.fusion-panelist-web` | above plus `web_search, web_contents, web_answer` | Opt-in. **Requires `pi-web-providers`.** |
+| `pi-fusion.fusion-panelist-full` | above plus `bash, edit, write, web_research` | Opt-in. Requires `pi-web-providers`. **See the warning below.** |
+| `pi-fusion.fusion-judge` | `read, grep, find, ls` | Judge. The read tools let it verify contested claims. |
+| `pi-fusion.fusion-composer` | `read, grep, find, ls` | Synthesis under `synthesis: "merge"`. |
+
+> **Tool names are a strict allowlist, not a loader.** If an agent declares a tool
+> whose provider extension is not installed, every task using that agent fails
+> with `requested unavailable child tools`. That is why the default agents stay on
+> Pi core tools: `pi-web-providers` is optional, so depending on it by default
+> breaks every run for anyone without it. Install it before you use the `-web`
+> or `-full` variant:
+>
+> ```bash
+> pi install npm:pi-web-providers
+> ```
+
+Mix them per member:
+
+```json
+{
+  "panel": [
+    {
+      "id": "arch",
+      "label": "Architect",
+      "agent": "pi-fusion.fusion-panelist"
+    },
+    {
+      "id": "local",
+      "label": "Local",
+      "agent": "pi-fusion.fusion-panelist-web"
+    },
+    { "id": "mine", "label": "Custom", "agent": "my-package.my-panelist" }
+  ]
+}
+```
+
+For any other combination, write your own agent markdown file with the `tools:`
+frontmatter you want and point `agent` at it. Valid tool names are the Pi core
+tools `read, bash, edit, write, grep, find, ls` and, when `pi-web-providers` is
+installed, `web_search, web_contents, web_answer, web_research`. A name outside
+that set resolves to nothing and the run fails with a missing-tool error.
+
+`web_research` is excluded from the default panelist on purpose: it routes to a
+deep-research model that takes minutes. A panel runs it for every member at the
+same time.
+
+> **`fusion-panelist-full` voids the read-only guarantee.** It grants `edit`,
+> `write`, and `bash`. Fusion runs panelists **in parallel in the same working
+> directory**, so at `concurrency > 1` two members can mutate the same files or
+> git state at once. The prompt asks them not to, but nothing enforces this.
+> Use it with `"concurrency": 1`, or do not use it at all.
+
+## Synthesis modes
+
+`select` (default) — every panelist answers the whole question and
+`fusion-judge` compares them, reporting consensus, disagreements, contested
+claims, unique insights, and blind spots. Use it for decision questions, where
+the failure mode is one model's bad reasoning path and redundancy is the fix.
+
+`merge` — panelists answer **different facets** and `fusion-composer` unions
+them, reporting a coverage map, the combined answer, gaps, and conflicts only
+where facets genuinely overlap. **To get this, give the members a `question`.**
+You do not also have to set `synthesis`. Use merge for breadth questions such as
+audits, "what did we miss", and release sweeps. There the failure mode is
+incomplete coverage, and redundant panelists all miss the same things.
+
+Merge mode swaps the synthesis agent, not the run lifecycle. It reuses the judge
+run slot, so a `fusion:rpc:v1` consumer sees no new phase.
+
+**If you set a custom `judge.agent`, Fusion uses it in both modes.** The merge
+contract then becomes your responsibility. Fusion substitutes `fusion-composer`
+only when `judge.agent` is still the bundled `pi-fusion.fusion-judge`. Explicit
+config always wins.
+
+Under `synthesis: "merge"` your agent gets the composer instructions. It must
+emit `Coverage Map`, `Combined Answer`, `Gaps`, and `Conflicts At Seams`. For a
+section it does not produce, Fusion writes "Not specified by the composer". The
+run does not fail, so a mismatch appears as an empty report, not as an error.
+
+```json
+{
+  "defaultProfile": "audit",
+  "profiles": {
+    "audit": {
+      "panel": [
+        {
+          "id": "security",
+          "agent": "pi-fusion.fusion-panelist",
+          "question": "Cover ONLY the security and data-exposure surface of: {task}"
+        },
+        {
+          "id": "perf",
+          "agent": "pi-fusion.fusion-panelist",
+          "question": "Cover ONLY throughput, latency, and resource use of: {task}"
+        },
+        {
+          "id": "ops",
+          "agent": "pi-fusion.fusion-panelist",
+          "question": "Cover ONLY rollout, rollback, and observability of: {task}"
+        }
+      ],
+      "judge": { "agent": "pi-fusion.fusion-judge", "thinking": "high" },
+      "concurrency": 3
+    }
+  }
+}
+```
+
+Under `merge`, one surviving panelist still goes to the composer. Fusion does
+not return that answer directly. One facet is not the answer, and the report must
+name what is missing.
 
 Judge:
 
@@ -193,7 +366,7 @@ Deliberate review:
 
 ## Output
 
-When agreement stopping is enabled, panelists append a final tagged JSON decision record containing a short recommendation, confidence, and whether more evidence is needed. Fusion uses it only to decide whether an unfinished panel may stop early; malformed, missing, or non-final records disable early stopping. Users see the preceding human-readable Markdown answer, not the record.
+When agreement stopping is on, each panelist appends one tagged JSON decision record. The record holds a short recommendation, a confidence level, and whether the panelist needs more evidence. Fusion uses it only to decide whether an unfinished panel can stop early. A record that is malformed, missing, or not final turns early stopping off. You see the Markdown answer above the record, not the record itself.
 
 The judge returns:
 
@@ -207,7 +380,7 @@ The judge returns:
 - risks
 - next step
 
-When lifecycle data is available, the final report also includes per-panel and judge time, aggregate model time, token usage, estimated cost, and concise model/provider failure summaries. Aggregate model time sums agent durations and is not wall-clock latency when panelists overlap. Missing usage is shown as unknown; local zero-cost usage remains zero. `Model` comes from lifecycle metadata; `Configured model` is the profile request. Both appear when a provider reports a different executed model.
+When lifecycle data is available, the report gives more. It adds per-panel and judge time, total model time, token usage, and estimated cost. It also adds a short failure summary per model and provider. Total model time is the sum of the agent durations. It is not wall-clock latency, because panelists overlap. Missing usage is shown as unknown, and local zero-cost usage stays zero. `Model` comes from lifecycle metadata. `Configured model` is what the profile asked for. Both appear when a provider reports a different model.
 
 ## Status and footer integration
 
@@ -219,18 +392,26 @@ It does not own the footer. If you use a footer extension, configure it to read
 
 Fusion uses model providers the same way normal Pi work does. The difference is fan-out:
 
-- normal work usually sends a prompt and tool results to one selected model;
-- Fusion sends the prompt to every configured panel model;
-- local file snippets read by a panelist go to that panelist's model;
-- the judge receives the original prompt plus successful panel answers and failure summaries.
+- normal work usually sends a prompt and tool results to one model
+- Fusion sends the prompt to every panel model
+- a local file snippet that a panelist reads goes to the model of that panelist
+- the judge gets the original prompt, the successful panel answers, and the failure summaries
+
+**Panelists can reach the web, but only if you opt in.** The default panelist,
+judge, and composer are local-only. A member that uses `fusion-panelist-web` or
+`fusion-panelist-full` can search. Your prompt, and any query that the member
+derives from your code, then go to the provider set in
+`~/.pi/agent/web-providers.json`. That provider is a third party, separate from
+your model provider. Keep every member on the default agent to hold a run
+entirely off the web.
 
-This is not an extra privacy guarantee. A mixed-provider panel can send copies of the work to several providers. An all-local panel can keep those model calls local, depending on your Pi model configuration. Bundled Fusion agents are read-only, but providers still receive the context needed to answer.
+This is not an extra privacy guarantee. A panel with several providers sends copies of the work to each of them. An all-local panel keeps those model calls local, if your Pi model config allows it. Every bundled Fusion agent except `fusion-panelist-full` is read-only. Each provider still gets the context it needs to answer. `fusion-panelist-full` is not read-only. See [Panel agents and tools](#panel-agents-and-tools).
 
 Fusion does not currently inspect or rewrite the final provider payload. Configure provider privacy and local-model routing in Pi.
 
 ## Small and economical profiles
 
-These are configuration examples, not built-in provider presets. Omit `model` to inherit the model selected in Pi, or set any model IDs supported by your Pi `models.json` configuration.
+These are config examples, not built-in provider presets. Omit `model` to inherit the model that Pi has selected. You can also set any model id that your Pi `models.json` config supports.
 
 Small local-style panel:
 
@@ -276,8 +457,8 @@ For an economical mixed panel, give each member a fast or inexpensive frontier,
 
 `Unknown fusion profile`
 
-- check `defaultProfile`
-- check the requested `--profile` name
+- verify `defaultProfile`
+- verify the requested `--profile` name
 - run `/fusion init` to regenerate a known-good template
 
 Run is stuck or no longer useful:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexeiled/pi-fusion",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Stronger answers for hard Pi questions via a parallel model panel + judge, built on pi-subagents",
   "type": "module",
   "main": "./src/index.ts",