ennodia 0.1.1 → 0.2.0

package/docs/concepts/how-ennodia-works.md

@@ -1,30 +1,32 @@
 ---
 title: How Ennodia Works
-description: A visible orchestration pipeline for routing, budget checks, task watching, recovery, Compare, and final synthesis.
+description: A visible orchestration pipeline for optional plan advice, routing, budget checks, task watching, recovery, Judge, and Result Advisor passes.
 ---
 
-When an MCP client starts a high-level run, Ennodia turns one request into a
-visible orchestration. The normal entrypoint is `ennodia_run`; lower-level task
-and Compare tools stay available for debugging and manual control.
+When a Model Context Protocol (MCP) client starts a high-level run, Ennodia
+turns one request into a visible orchestration. The normal entrypoint is
+`ennodia_run`. Lower-level task and Compare tools stay available for debugging
+and manual control.
 
 ## Pipeline at a Glance
 
 | Stage | What happens | Main tools |
 | --- | --- | --- |
-| Discover | Ennodia finds installed agent CLIs and reports whether each harness is runnable. | `ennodia_list_harnesses` |
+| Discover | Ennodia finds installed agent command-line interface (CLI) programs and reports the runnable state of each harness. | `ennodia_list_harnesses` |
 | Plan | The router uses a caller-provided category when supplied, otherwise a keyword fallback, then chooses candidate harnesses. | `ennodia_plan`, `ennodia_run` |
+| Advise (optional) | A Plan Advisor proposes a bounded set of harness, model, and skill assignments as inert data. Ennodia validates it but does not launch it. | `ennodia_start_plan_advice`, `ennodia_get_plan_advice` |
 | Budget | Ennodia estimates preflight input tokens and checks optional local limits on that estimate. | `ennodia_estimate_budget`, `ennodia_run` |
 | Execute | Thin adapters start the selected local agent CLI commands. Each child has a default 5-minute timeout and a 1-hour maximum accepted by the public tools. | `ennodia_start`, `ennodia_run` |
 | Watch | Child task status, stdout, stderr, timing, and failures stay inspectable. | `ennodia_get_task`, `ennodia_get_run` |
-| Recover | Timeouts, cancellations, and failed children are reported instead of hidden. | `ennodia_cancel_task`, `ennodia_cancel_run` |
-| Compare | A model judges and synthesizes successful outputs when comparison is requested. Compare adds two serial model passes after child agents finish. | `ennodia_start_compare`, `ennodia_get_compare` |
+| Recover | Ennodia reports timeouts, cancellations, and failed children without hiding them. | `ennodia_cancel_task`, `ennodia_cancel_run` |
+| Compare | The Judge maps successful outputs. The Result Advisor uses those findings to recommend an answer. Compare adds two serial model passes after child agents finish. | `ennodia_start_compare`, `ennodia_get_compare` |
 | Return | The MCP client receives one final answer plus an inspectable run record and durable terminal receipt. | `ennodia_get_run`, `ennodia_history` |
 
 ## Discover
 
 Ennodia maintains a registry of execution backends. Each adapter is intentionally
-thin: it reports whether the tool is available, identifies the installed
-version, and starts the tool through its supported command-line surface.
+thin. It reports tool availability, identifies the installed version, and starts
+the tool through its supported command-line surface.
 
 See [Supported Harnesses](/docs/reference/supported-harnesses/) for current
 adapter IDs and setup notes.
@@ -33,23 +35,44 @@ adapter IDs and setup notes.
 
 The router combines the currently available harnesses with either a
 caller-provided category (`code`, `research`, `browser`, `image`, or `general`)
-or a small keyword fallback. Agent callers should pass `category` when they
-already know what kind of work they are asking for; the fallback is a convenience
+or a small keyword fallback. Pass `category` when you know the work type. The
+fallback is a convenience
 path, not a claim of deep intent understanding.
 
+## Plan Advisor
+
+Plan Advisor is an optional suggestion path, not a more powerful router. It sees
+a frozen, bounded inventory and proposes explicit worker slices with harness,
+model, and skill assignments. Its response is untrusted plan data: it cannot set
+working directories, environment variables, commands, permissions, timeouts,
+or budgets. The Plan Advisor task itself runs in a separate empty temporary working
+directory rather than inheriting the target project directory.
+
+Ennodia parses the complete response as strict JSON and validates every
+assignment. A valid result is still inert. The Plan Advisor never starts worker
+tasks, retries them, or changes the plan after validation. The caller must make
+a separate `ennodia_start_advised_plan` call with the exact plan digest. Each
+advice result can authorize one launch.
+
+Immediately before the first launch, Ennodia checks the digest, current
+inventory, skills, caller model allowlists, and budget again. Any mismatch fails
+closed with zero worker launches. Provider model availability remains
+unverified until its harness runs.
+
 ![A request is classified, routed to available harnesses, watched, recovered when needed, compared, and returned with a trace.](../assets/orchestration-pipeline.svg)
 
 ## Budget
 
 Before a high-level run starts child tasks, Ennodia can estimate the input-token
 budget. The estimate includes selected child task count, prompt input, planned
-Compare input, and the effective candidate bound used in the judge prompt.
+Compare input, and the effective candidate bound used in the Judge prompt.
 
 Budget checks are intentionally honest. Ennodia can enforce local preflight
 limits such as `maxChildTasks` and `maxEstimatedInputTokens` on that estimate.
 Child-task estimates exclude harness system prompts, file reads, tool loops, and
 provider-side context, so real usage can be higher. Ennodia only reports
-subscription quota as known when a supported local CLI/API surface exposes it.
+subscription quota as known when a supported local CLI or application
+programming interface (API) surface exposes it.
 
 See [Budgets and Limits](/docs/guides/budgets-and-limits/) for request shapes.
 
@@ -70,21 +93,24 @@ the child process exits and captured output has drained.
 
 ## Recover
 
-Failure handling is part of the execution plan. Nodes can time out, fail, be
-cancelled, or return partial output without hiding what happened.
+Failure handling is part of the execution plan. Nodes can time out, fail, enter
+the `cancelled` state, or return partial output without hiding the result.
 
 ## Compare
 
-When several agents produce answers, Ennodia does not concatenate them. A judge
+When multiple agents produce answers, Ennodia does not concatenate them. A Judge
 can produce a structured comparison: agreements, contradictions, unique
-insights, blind spots, and risks. A synthesizer then uses that comparison and
-the original outputs to create the final result.
+insights, blind spots, and risks. The Result Advisor then uses that comparison
+and the original outputs to create the recommended result.
 
-Compare is model-led synthesis, not formal voting or consensus.
+Compare uses model judgment. It does not use formal voting or consensus.
 
-Compare is also serial: a judge task runs first, then a synthesizer task runs
-after the judge completes. For a parallel run with N child agents, budget and
-latency should be understood as N child runs plus those two Compare passes.
+Compare is also serial: the Judge task runs first, then the Result Advisor task
+runs after it completes. If the Judge fails or returns unusable structured
+analysis, the Result Advisor can continue directly from the candidate outputs.
+The result records `basis: "candidates-only"` so the degraded path stays
+visible. For a parallel run with N child agents, count N child runs plus the two
+Compare passes when estimating budget and latency.
 
 ## Return
 

package/docs/concepts/interfaces-and-core.md

@@ -1,10 +1,12 @@
 ---
 title: Interfaces and Core
-description: How Ennodia's MCP interface and shared core behavior relate to each other.
+description: How Ennodia's Model Context Protocol (MCP) interface and shared core behavior relate to each other.
 ---
 
 ## Current Shape
 
+Ennodia has a Model Context Protocol (MCP) interface and a shared Core.
+
 | Name | Status | What it means |
 | --- | --- | --- |
 | <span class="agent-logo agent-logo--mcp" aria-hidden="true"></span>Ennodia MCP | Available | The shipped MCP tool interface for agents. Use this today. |
@@ -14,10 +16,12 @@ description: How Ennodia's MCP interface and shared core behavior relate to each
 
 Ennodia MCP is the supported public surface in the current release. It exposes
 tools such as `ennodia_list_harnesses`, `ennodia_estimate_budget`,
-`ennodia_run`, `ennodia_get_run`, and `ennodia_start_compare`. Each tool is a
-schema plus one Core call — nothing more.
+`ennodia_run`, `ennodia_start_plan_advice`, `ennodia_get_run`, and
+`ennodia_start_compare`. Each tool is a schema plus one Core call — nothing
+more.
 
-Use MCP when a primary agent should ask installed local agent CLIs for help.
+Use MCP when a primary agent needs help from installed local agent
+command-line interface (CLI) programs.
 
 ## Ennodia Core
 
@@ -26,14 +30,23 @@ Core is responsible for:
 - discovering supported local harnesses
 - planning routes with caller-provided categories or keyword fallback
 - estimating preflight budgets and enforcing local caps on that estimate
+- running the optional Plan Advisor against a bounded inventory, validating its
+  inert proposal, and requiring a separate digest-bound call before execution
 - starting child tasks through thin adapters
 - capturing status, output, failures, and timing
 - resolving compositional slices and reporting Compare readiness
-- comparing successful outputs when requested
+- running the Judge and Result Advisor over successful outputs when Compare is
+  requested
+
+The roles do not own runtime policy. Plan Advisor proposes harness, model, and
+skill assignments but never executes them. Result Advisor combines Judge
+findings after Compare. If Judge analysis is unavailable, its candidates-only
+basis is exposed rather than hidden.
 
 ## Ennodia IO
 
-Ennodia IO is a local app interface. Start the HTTP server with:
+Ennodia IO is a local app interface. Start the Hypertext Transfer Protocol
+(HTTP) server with:
 
 ```sh
 npx -y @cherninlab/ennodia-io

package/docs/concepts/second-opinions.md

@@ -1,21 +1,21 @@
 ---
 title: Second Opinions as Infrastructure
-description: How to use Ennodia for independent AI panels, decomposed reviews, and red-team prompts.
+description: How to use Ennodia for independent artificial intelligence (AI) panels, decomposed reviews, and red-team prompts.
 ---
 
-Ennodia convenes independent AI panels for judgments too important for one model
-and shows you exactly where they disagree.
+Ennodia convenes independent artificial intelligence (AI) panels for judgments
+that are too important for one model. It shows you exactly where they disagree.
 
 Code review is the first strong use case, not the category. The core pattern is
-delegating a question to installed local agents, keeping the trace visible, and
-using Compare to turn multiple answers into a disagreement map and one usable
-result.
+delegation to installed local agents with a visible trace. Compare turns
+multiple answers into a disagreement map and one usable result. The Judge maps
+the evidence, and the Result Advisor recommends the answer.
 
 ## Three Patterns
 
 ### Replicate
 
-Ask the same question of several agents, then compare the answers.
+Send the same question to multiple agents, then compare the answers.
 
 ```json
 {
@@ -37,7 +37,7 @@ issue is high.
 
 ### Decompose
 
-Split a broad review into focused slices, then synthesize the useful completed
+Split a broad review into focused slices, then combine the useful completed
 outputs.
 
 ```json
@@ -76,7 +76,7 @@ Fan out prompts that argue against a proposal from different angles.
 }
 ```
 
-Use this when the primary agent already has a plausible plan and you want
+Use this when the primary agent has a plausible plan and you want
 independent pressure before committing.
 
 ## Staging Pattern
@@ -84,7 +84,7 @@ independent pressure before committing.
 For larger reviews, have the primary agent stage a folder containing the case
 file: relevant paths, screenshots, dataset summaries, contracts, or decision
 criteria. Then pass `cwd` to Ennodia so child agents can inspect the same local
-context independently. Keep staged material deliberate; do not hand every agent
+context independently. Keep staged material deliberate. Do not give every agent
 an unbounded workspace when a smaller evidence bundle will do.
 
 ## Skills Carry Expertise
@@ -92,7 +92,7 @@ an unbounded workspace when a smaller evidence bundle will do.
 Use Agent Skills as reusable rubrics. A skill can define the review standard,
 expected evidence, output shape, and escalation rules. Ennodia installs bundled
 skills as harness-visible `SKILL.md` folders, then passes skill IDs through a
-run instead of inlining the full instructions into every prompt.
+run without inlining the full instructions into every prompt.
 
 ## Examples
 
@@ -101,19 +101,19 @@ run instead of inlining the full instructions into every prompt.
 - Contract comparison: decompose obligations, termination, liability, and data
   handling into focused slices.
 - Pre-mortems: red-team a roadmap, launch, or migration plan before work starts.
-- Exam or rubric QA: ask several agents to grade an answer against the same
-  staged rubric, then compare where their grading differs.
+- Exam or rubric QA: send the same staged rubric to multiple agents. Compare
+  where their grading differs.
 
 ## Honest Constraints
 
-Ennodia is deliberation-class infrastructure. A run usually takes minutes, not
-seconds. Compare adds two serial model passes after the child agents finish, so
-parallel review with Compare costs roughly N child runs plus a judge and a
-synthesizer.
+Ennodia supports careful review. A run usually takes minutes, not seconds.
+Compare adds two serial model passes after the child agents finish.
+Parallel review with Compare costs roughly N child runs, a Judge, and a Result
+Advisor.
 
-The substrate is installed agent CLIs and local tools, not domain-tuned
-specialist models. Ennodia supports decision-making by surfacing evidence,
-disagreements, and uncertainty; it does not make regulated, legal, financial,
+Ennodia uses installed agent CLIs and local tools. It does not use specialist
+models for one domain. Ennodia supports decisions by showing evidence,
+disagreements, and uncertainty. It does not make regulated, legal, financial,
 medical, or operational decisions for the user.
 
 For storage and data movement boundaries, read

package/docs/getting-started.md

@@ -1,18 +1,20 @@
 ---
 title: Quickstart
-description: Set up Ennodia by hand, run the first checks, and know where to go next.
+description: Install Ennodia manually, perform the first checks, and find the next documentation page.
 ---
 
-This page is for humans setting up Ennodia by hand. If you would rather have an
-agent install and configure Ennodia for you, use
-[Installation for Agents](/docs/install/) instead.
+This page gives manual installation instructions for a Model Context Protocol
+(MCP) client. To use an agent for installation and configuration, see
+[Installation for Agents](/docs/install/).
 
 ## Requirements
 
 - Bun `1.3.14` or newer
-- An MCP client that can launch a stdio server
-- At least one supported AI command-line tool, if you want real agent
-  execution; see [Supported Harnesses](/docs/reference/supported-harnesses/)
+- An MCP client that can launch a standard input/output (stdio) server
+- At least one supported artificial intelligence (AI) command-line tool for
+  real agent execution
+
+See [Supported Harnesses](/docs/reference/supported-harnesses/).
 
 ## Install from npm
 
@@ -22,15 +24,15 @@ Install the stable release from npm:
 npx -y ennodia
 ```
 
-Requires Bun `1.3.14` or newer. `npx` downloads Ennodia; Bun runs it. Prefer
-Bun directly? Use `bunx ennodia`.
+Ennodia requires Bun `1.3.14` or newer. `npx` downloads Ennodia. Bun runs it.
+To use Bun directly, run `bunx ennodia`.
 
 The JSR package `@cherninlab/ennodia` exposes TypeScript modules for import.
 Use the npm package for the stdio MCP executable.
 
 ## Local Checkout
 
-Use a checkout when you are changing Ennodia itself:
+Use a checkout to modify Ennodia:
 
 ```sh
 git clone https://github.com/cherninlab/ennodia
@@ -52,7 +54,7 @@ bun run verify
 }
 ```
 
-For a local checkout, point at the source file instead:
+For a local checkout, use the source file:
 
 ```json
 {
@@ -65,11 +67,11 @@ For a local checkout, point at the source file instead:
 }
 ```
 
-Replace `/absolute/path/to/ennodia` with your local repo path.
+Replace `/absolute/path/to/ennodia` with your local repository path.
 
 ## First Checks
 
-From the repo:
+From the repository:
 
 ```bash
 bun install
@@ -77,37 +79,63 @@ bun run mcp:smoke
 bun run verify
 ```
 
-From an MCP client, call these tools in order: `ennodia_list_harnesses`,
-`ennodia_estimate_budget`, `ennodia_plan`, `ennodia_run`, then
-`ennodia_get_run`. `ennodia_run` is the main end-to-end entrypoint — it plans
-the route, starts the selected task or tasks, optionally compares successful
-outputs, and returns a run ID. Poll `ennodia_get_run` with that ID until the
-run reaches `succeeded`, `failed`, or `cancelled`.
+From an MCP client, call `ennodia_list_harnesses`. Then call
+`ennodia_estimate_budget`. To inspect the route, call `ennodia_plan`.
+
+Start the work with `ennodia_run`. This tool plans the route and starts the
+selected tasks. It can also compare successful outputs. It returns a run
+identifier (ID).
+
+Poll `ennodia_get_run` with that ID. Stop when the status is `succeeded`,
+`failed`, or `cancelled`.
+
+Expect real runs to take minutes. Compare adds a Judge pass and a Result
+Advisor pass after child agents finish.
+
+## Optional Team Advice
+
+For a proposed work split, call `ennodia_start_plan_advice`. The Plan Advisor
+proposes explicit harness, model, and skill assignments. It cannot execute them.
+
+Poll `ennodia_get_plan_advice`. Stop when the status is `ready`, `consumed`,
+`invalid`, `failed`, or `cancelled`.
+
+Ennodia parses the response as strict plan data. It validates the data against
+the frozen harness, model, and skill inventory.
+
+To start a ready plan once, call `ennodia_start_advised_plan`. Pass the returned
+`planDigest` as `expectedPlanDigest`. Ennodia validates the current inventory
+and budget again before authorizing the plan. A mismatch stops the operation
+before any worker task starts. Authorization consumes the advice, so a second
+launch with the same advice fails before any worker task starts.
+
+Compare is a separate operation after worker completion. The Judge maps the
+completed answers. Then the Result Advisor recommends one answer.
 
-Expect real runs to take minutes. Compare adds a judge pass and a synthesizer
-pass after child agents finish.
+If Judge analysis is not available, the Result Advisor can use only the
+candidate outputs. The Compare result shows this condition.
 
 ## Next Pages
 
 - [Budgets and Limits](/docs/guides/budgets-and-limits/) explains
   `ennodia_estimate_budget` and run limits.
-- [Using Agent Skills](/docs/guides/agent-skills/) explains `skillIds` and
+- [Agent Skills](/docs/guides/agent-skills/) explains `skillIds` and
   native `SKILL.md` installation.
 - [Supported Harnesses](/docs/reference/supported-harnesses/) lists adapter IDs
-  and setup notes.
+  and installation notes.
 - [MCP Tools](/docs/reference/mcp-tools/) is the full parameter reference.
 
 ## Expected Behavior
 
-An Ennodia run is meant to be visible. You should be able to inspect:
+An Ennodia run is visible. You can inspect:
 
 - selected harnesses
 - child task IDs
 - task status
-- stdout and stderr previews
+- standard output (stdout) and standard error (stderr) previews
 - elapsed time and per-task timeout
 - Compare state, if Compare was used
 - final answer or explicit failure reason
 
-If a child tool times out or fails, Ennodia should report that state instead of
-hiding it.
+If a child tool times out or fails, Ennodia must report that state. It must not
+conceal the failure.

package/docs/guides/agent-skills.md

@@ -1,14 +1,16 @@
 ---
-title: Using Agent Skills
-description: Install bundled Ennodia skills into native harness locations and ask child agents to use them during a run.
+title: Agent Skills
+description: Install bundled Ennodia skills in native harness locations and tell child agents to use them during a run.
 ---
 
-Ennodia uses native Agent Skills. A skill is a folder containing `SKILL.md`
-installed where each harness already knows how to find skills.
+Ennodia uses native Agent Skills. A skill is a folder that contains `SKILL.md`.
+Install it where each harness can find skills.
 
-Ennodia does not invent a private skill format and does not inline full skill
-instructions into every delegated prompt. It installs or discovers the native
-skill folder, then passes the selected `skillIds` into the run.
+Ennodia does not use a private skill format. It does not put the full skill
+instructions in each delegated prompt.
+
+Ennodia installs or discovers the native skill folder. It then passes the
+selected `skillIds` into the run.
 
 ## List Available Skills
 
@@ -26,8 +28,8 @@ directories, and load warnings.
 
 ## Preview Installation
 
-Bundled skills default to dry-run installation so the caller can inspect planned
-writes before anything changes:
+Bundled skills use dry-run installation by default. The caller can inspect the
+planned writes before any change:
 
 ```json
 {
@@ -50,7 +52,7 @@ Review the planned paths. If they are correct, repeat with `dryRun: false`.
 {
   "tool": "ennodia_run",
   "arguments": {
-    "prompt": "Audit these docs against the linked sources and recommend exact edits.",
+    "prompt": "Audit this documentation against the linked sources and recommend exact edits.",
     "mode": "parallel",
     "compare": true,
     "skillIds": ["source-grounded-audit"]
@@ -65,8 +67,8 @@ Bundled skills include:
 
 | Skill | Use it for |
 | --- | --- |
-| `source-grounded-audit` | Checking claims against repository files, standards, or product docs. |
-| `compositional-audit` | Keeping one shard of a larger review focused and easy to synthesize. |
+| `source-grounded-audit` | Check claims against repository files, standards, or product documentation. |
+| `compositional-audit` | Limit one shard of a large review to one clear scope. |
 | `rigorous-review` | General correctness and risk review. |
 | `release-readiness` | Public release candidate checks. |
 | `benchmark-critic` | Benchmark credibility and reproducibility review. |
@@ -80,4 +82,5 @@ Bundled skills include:
 | OpenCode | `.opencode/skills` | `~/.config/opencode/skills` |
 | Antigravity | `.agent/skills` | `~/.gemini/antigravity/skills` |
 
-See [MCP Tools](/docs/reference/mcp-tools/) for the exact tool parameters.
+See [Model Context Protocol (MCP) Tools](/docs/reference/mcp-tools/) for the
+exact tool parameters.

package/docs/guides/budgets-and-limits.md

@@ -1,23 +1,25 @@
 ---
 title: Budgets and Limits
-description: How Ennodia estimates preflight input-token budgets and enforces local run limits before starting child agents.
+description: How Ennodia estimates preflight input-token budgets and enforces local run limits before child agents start.
 ---
 
 Ennodia can estimate the input-token budget before a costly run starts. The
-estimate is a planning guardrail, not a provider invoice, and child-task
-estimates are lower bounds because harness system prompts, file reads, tool
-calls, and provider-side context are not visible before the run.
+estimate is a budget limit check, not a provider invoice. Child-task estimates
+are lower bounds.
 
-Use it before parallel work, long reviews, or any run where the user cares about
-cost, subscription pressure, or the number of child agents started.
+Harness system prompts, file reads, tool calls, and provider-side context are
+not visible before the run.
+
+Use it before parallel work or long reviews. Also use it when the user limits
+cost, subscription use, or child-task count.
 
 ## What the Estimate Includes
 
 `ennodia_estimate_budget` reports:
 
 - selected harness count
-- selected harness IDs
-- whether Compare is planned
+- selected harness identifiers (IDs)
+- if Compare is planned
 - prompt input estimate
 - potential Compare input from bounded candidate outputs, capped by the same
   24,000-character per-candidate truncation used in the judge prompt
@@ -27,7 +29,7 @@ cost, subscription pressure, or the number of child agents started.
 The estimate does not claim to know provider billing, output tokens, tool-call
 cost, cache behavior, harness-internal context, or private subscription quota.
 
-## Estimate Before Running
+## Estimate Before a Run
 
 ```json
 {
@@ -45,8 +47,12 @@ cost, cache behavior, harness-internal context, or private subscription quota.
 }
 ```
 
-If the estimate is too high, reduce the selected harnesses, shorten the prompt,
-lower `maxOutputChars`, or run a narrower first pass.
+If the estimate is too high, use one or more of these changes:
+
+- Select fewer harnesses.
+- Make the prompt shorter.
+- Decrease `maxOutputChars`.
+- Use a narrower first pass.
 
 ## Enforce Limits on a Run
 
@@ -68,16 +74,19 @@ The same budget object can be passed to `ennodia_run`:
 }
 ```
 
-Ennodia checks these local limits before starting child tasks. If the estimated
-input tokens or selected child-task count exceeds the cap, the run fails early
-instead of silently launching more model work.
+Ennodia checks these local limits before child tasks start. The run fails early
+if estimated input tokens or the child-task count exceed a cap. Ennodia does
+not start the excess model work.
 
 ## Subscription Limits
 
-Subscription quota checks are intentionally conservative. Ennodia only uses
-supported local CLI/API surfaces. If a provider does not expose account quota
-through a supported surface, Ennodia reports the limit as unknown instead of
-scraping private account pages or inventing a number.
+Subscription quota checks are conservative by design. Ennodia uses only
+supported local command-line interface (CLI) and application programming
+interface (API) surfaces.
+
+If a provider does not expose account quota through a supported surface,
+Ennodia reports the limit as unknown. It does not inspect private account pages
+or create an unsupported value.
 
 Today every built-in harness reports subscription quota as unknown because no
 supported local surface exposes a reliable account limit. An older fail-closed
@@ -86,10 +95,11 @@ supported quota surface.
 
 ## Practical Defaults
 
-- For a first docs or code audit, start with two or three harnesses.
+- For a first documentation or code audit, start with two or three harnesses.
 - Use `maxOutputChars` to keep Compare input bounded.
 - Keep `maxChildTasks` set when the prompt may route to many adapters.
 - Treat unknown subscription-limit status as a transparency signal, not proof
   that a run is cheap or expensive.
 
-See the exact tool schema in [MCP Tools](/docs/reference/mcp-tools/).
+See the exact tool schema in
+[Model Context Protocol (MCP) Tools](/docs/reference/mcp-tools/).