voidmachine 5.0.8 → 7.0.0

package/core-assets/skills/void-orchestrate/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: void-orchestrate
-description: Delegate independent research and substantial implementation through native agents; choose context, isolation and bounded concurrency, collect results and preserve review evidence. Use the supported session host.
+description: Delegate independent research and substantial implementation through native agents; choose context, isolation and bounded concurrency, collect results and preserve review evidence. Publish observed worker lifecycle events.
 ---
 
 # Orchestrate
@@ -17,16 +17,10 @@ context, permissions, completion and resume capabilities. Use the best supported
 capabilities for the task in the current session; an installed executable or an
 environment hint alone does not validate a host, identity or permission.
 
-Herdr is optional for consumers, not discretionary inside a validated Herdr session.
-When fresh discovery validates the coordinator in Herdr, use its adapter below for
-durable terminal workers and mission visibility. Short agents remain native; never
-duplicate an agent to give it a pane. Outside Herdr, use the current supported host
-(such as tmux) when its required capabilities and ownership can be verified. This
-policy adds no tmux transport and never relaunches through the legacy kernel.
-Without supported presentation, retain native delegation and report the limitation;
-do not claim durability from a pane or unsupported API. Failed or ambiguous host
-discovery blocks the affected host action: diagnose it, never silently switch hosts
-or act on an unrelated project. Native work independent of that action may continue.
+Use native execution independently of presentation. The harness publishes worker
+observations; external plugins own windows, tabs and panes. Never discover or call
+a multiplexer to delegate, and never duplicate an agent to make it visible.
+An absent display cannot change execution permissions or invalidate real evidence.
 
 - Work directly for a tiny targeted change, a single tool call, mechanical processing,
   or tightly coupled work where delegation adds no useful separation.
@@ -40,21 +34,35 @@ or act on an unrelated project. Native work independent of that action may conti
   mandatory independent review or required isolation remains a blocker; do not
   replace it with self-review or silently weaken its requirement.
 
-## First ticket and optional worker tabs
-
-SessionStart discovers Herdr even before central mission files exist. Its advice
-requires a fresh caller pane at the canonical checkout and process ownership;
-environment variables alone never authorize a host action. Revalidate before launch.
-On a new implementation ticket, reuse the assigned writer if one exists. Otherwise,
-in a validated Herdr session, register the mission and planned worker first, then
-create one background tab in the resolved coordinator workspace with the assigned
-worktree as cwd. Read the installed `herdr tab` schema, preserve focus with
-`--no-focus`, and use the returned root pane for the single agent start below.
-Reattach a matching existing worker instead of opening another tab. The coordinator
-stays in its existing pane. Hooks only discover and advise; they never create tabs,
-launch agents or write central files. Without Herdr, use native delegation normally.
-An invalid host or explicit mission selection refuses only that host action;
-independent native work may continue with the limitation stated.
+## Native model choice
+
+Use the current runtime's declared model/effort controls and project-configured identifiers.
+An explicit user choice wins; do not infer availability, price or capability from a product name.
+Without an explicit choice, match the bounded task to an available native configuration:
+
+| Work | Selection |
+| --- | --- |
+| Mechanical lookup, extraction, formatting | An economical model when supported and sufficient |
+| Domain advice or implementation | Enough capability for the actual contract and uncertainty |
+| Sensitive architecture/security, independent review, failed-proof adjudication | Retain judgment capability; never downgrade just for cost |
+
+Keep the assigned writer and reuse valid specialist advice. Do not restart a retained context
+merely to change its model; the writer's whole quality cycle stays intact. A cheaper explicit
+choice never waives acceptance or independent review: report insufficient capability as a
+conflict, rather than silently upgrading or claiming the quality requirement is met.
+
+- Discover supported identifiers and controls before dispatch; pass only supported options.
+  Respect native constraints between model overrides, effort and context/fork modes.
+- An unavailable explicit choice stops the dependent launch with its cause and next action.
+  If no explicit choice exists and selection is unsupported, inherit/default transparently;
+  do not claim that a particular model or lower price was selected.
+- Diagnose an unsupported optional setting instead of passing it anyway. Do not silently
+  change provider, credentials, permissions or the user's choice to make a launch work.
+- Reconcile an uncertain launch before retrying the same work. At most one retry for a
+  confirmed transient failure; otherwise report the limitation. Never cascade across models.
+- Requested and observed models differ: retain the requested option in the ordinary brief,
+  and report the effective model only when the runtime supplies it; otherwise it is unknown.
+  Use existing evidence/reporting, not a new registry. Report cost/time only when observed.
 
 ## Brief and bound the delegation
 
@@ -68,7 +76,7 @@ Formal specialist envelopes and evidence follow the independent contract below.
 
 Count writer, research and review children together against observed available runtime slots
 and the coordinator's bounded dispatch; queue work when full. Preserve tighter caller
-limits, including Autopilot's ticket cap and the central schema's four-worker limit.
+limits, including Autopilot's ticket cap.
 This is no machine-wide quota. Do not create recursive child coordinators or redispatch
 the same complete workflow. Required formal specialists remain dispatched by their
 designated owner within the shared available capacity. Do not duplicate a child's work
@@ -97,6 +105,18 @@ Never invent a durable inbox. Preserve formal receipts separately from working n
 
 ## Short native specialists
 
+`void-implement` owns domain detection and the required primary domain consultation before coding.
+Dispatch that smallest relevant expert set once, collect actual advice and reuse it while its
+inputs hold. This skill owns transport and provenance, not a second applicability policy or
+an all-specialist preparation quorum. Extra experts need a distinct uncovered risk.
+
+For a lightweight consultation outside formal dispatch, after the native call actually succeeds
+and returns a context ID, the coordinator may record `void-machine mission advisory-start --id
+<mission> --specialist core:<role> --runtime claude|codex --context <actual-native-context>`.
+This is a coordinator-observed usage receipt, not `specialist-event`, completion or review proof.
+Never record a planned/failed start, reconstruct past receipts, or block delivery on missing
+telemetry. Repeated submission of the same context is idempotent; a different role conflicts.
+
 Pass the returned specialist envelope unchanged: runtime, agentName, missionId,
 contextPack and, when present, reviewSubject and reviewScope. Invoke the runtime's
 native fresh-context primitive; native Agent calls are not intercepted. Keep the
@@ -108,206 +128,56 @@ Preserve the complete result; incomplete results go back to the same agent.
 With `panel.provider: orchestrator`, only ORCH launches and collects this panel.
 Missing required native capability is reported with cause and next action.
 
-## Herdr adapter: recovery
-
-The following Herdr sections apply when the session-host policy selects this adapter.
-Native delegation without it does not require these central files or pane discovery.
-
-Read project instructions, the approved task and the current Git status. Preserve
-other writers' changes. Resolve the canonical Git common directory, SHA-256 its
-absolute real path as UTF-8, and inspect
-`~/.local/state/orchestra/<project>/<mission>/`. Never use an inherited workspace
-variable or a stale pane ID as authority. Read mission.md, the applicable
-workers/<label>/brief.md and report.md. Re-read `herdr pane list` before every
-identity decision. Match **label + worktree**, using the canonical worktree path.
-Refuse multiple matches, incomplete discovery, symlinks, traversal and invalid data.
-After reattachment/restart, ORCH atomically updates pane_id and coordinator.workspace
-from that validated fresh inventory. Hooks and workers never write these hints.
-A missing unrelated historical worktree does not invalidate a current identity.
-
-The coordinator is the existing ORCH session, never a second agent opened for display.
-Resolve its own label + worktree before selecting its workspace. Keep each writer
-in its assigned worktree. Do not affect any other project, workspace or pane.
-An uncertain launch or prompt acknowledgement requires reconciliation of that same
-worker before retrying. A timeout proves neither launch failure nor prompt loss.
-
-## Herdr adapter: explicit coordinator context
-
-If unique discovery refuses multiple compatible missions, ORCH reads the target
-mission and reports, then atomically replaces its local, unversioned
-`<canonical worktree>/.void/machine/orchestra-selection.json`. Schema 1 is strict
-JSON, at most 4096 UTF-8 bytes: `{ "schema": 1, "project": "<project-sha256>",
-"mission": "<existing-id>", "coordinator": { "label": "ORCH", "worktree":
-"/absolute/canonical/worktree" } }`. ORCH alone writes it; hooks never repair it.
-No unknown or duplicate keys, YAML, traversal, symlinks or partial writes.
-
-This selects context only, never execution state or permissions. Full bounded
-central discovery still runs; malformed unrelated missions or limits refuse.
-A stale/invalid binding never falls back. Verify selected coordinator label and
-canonical worktree against the current worktree and a fresh `herdr pane list`;
-missing or duplicate live matches refuse. Never prefer timestamps, running status
-or pane tokens to decide intent. Without a binding, preserve unique discovery.
-Clear/compact/resume re-read selection and central state without launching workers.
-Separate worker worktrees retain their own mission, attempt and report discovery.
-A selected terminal mission retains the guarded cleanup below: never clear tokens
-belonging to another mission. No binding belongs in the programme descriptor.
-
-## Herdr adapter: central files and ownership
-
-Use schema: 1 YAML frontmatter, strict string keys and one document, followed by
-Markdown. Reject duplicate keys, tags, anchors, aliases and unknown fields. Bound
-mission/report to 64 KiB, brief to 256 KiB, discovery to 64 entries and 1 MiB of
-mission bytes; exceeding a bound is incomplete, never a unique match.
-See the shipped technical contract `docs/ORCHESTRA.md` in the harness source for
-schemas; the operational fields are listed here so an installed skill is sufficient.
-
-- mission.md: schema, mission, project, status, updated_at
-  (ISO with `Z` or `+HH:MM`/`-HH:MM`; prefer UTC `Z`), repository
-  (canonical Git common path), coordinator {label, worktree, workspace?}, workers.
-- Worker entries: label, agent (codex or claude), worktree, branch, ticket, status,
-  attempt; optional pane_id and session are hints only. At most four workers.
-- Coordinator status and worker status: planned, running, blocked, done, failed.
-- report.md: schema, mission, attempt, worker, branch, status (running, blocked,
-  done, failed), commits (full SHAs), tests (passed, failed, not_run), updated_at.
-  Body: actual commands/results, proof locations, risks, questions and remaining work.
-- brief.md: absolute paths, exact base, footprint, acceptance criteria, ownership,
-  permissions, forbidden effects and current attempt. No secrets. Explicitly warn
-  that other writers exist and their changes must be preserved.
-
-ORCH alone writes mission and briefs; each worker alone writes its report. Use an
-atomic replacement: write an exclusive temporary sibling, then rename. Hooks never
-write these files. A new work turn gets a new attempt; resume keeps its attempt.
-A valid report for the current mission/attempt overrides workers[].status at every
-event. An absent report falls back to the manifest. Malformed, foreign, partial or
-unrecognized stale reports refuse usage; never turn a parse failure into absence.
-The files carry coordination state, not independent review proof.
-
-## Herdr adapter: copyable starting files
-
-Replace the example project hash with SHA-256 of the canonical common Git path.
-Replace every path, branch, ticket and timestamp from actual observations. These
-three files are authored by their owner, never by the hook.
-
-mission.md:
-
-```yaml
----
-schema: 1
-mission: dev-42
-project: "<project-sha256>"
-status: planned
-updated_at: "2026-10-08T10:00:00.000Z"
-repository: /absolute/repository/.git
-coordinator:
-  label: ORCH
-  worktree: /absolute/repository
-  workspace: wA
-workers:
-  - label: WORK-1
-    agent: codex
-    worktree: /absolute/worktrees/dev-42
-    branch: work/dev-42
-    ticket: DEV-42
-    status: planned
-    attempt: implementation-1
----
-# Mission
-Scope, acceptance criteria, canonical mission journal and proof locations.
-```
-
-workers/WORK-1/brief.md:
-
-```yaml
----
-schema: 1
-mission: dev-42
-attempt: implementation-1
-worker: WORK-1
----
-# Work
-Worktree: /absolute/worktrees/dev-42. Branch: work/dev-42.
-Base: <verified full commit SHA>. Ticket: DEV-42.
-Footprint: <exact owned files/directories>; preserve every other writer's edits.
-Acceptance: <complete observable criteria and verification commands>.
-Limits: <role permissions, forbidden effects, human gates>.
-Report: /absolute/mission/workers/WORK-1/report.md, owned only by this worker.
-Resume: <actual runtime session and the recipe from the table below>.
-```
-
-workers/WORK-1/report.md:
-
-```yaml
----
-schema: 1
-mission: dev-42
-attempt: implementation-1
-worker: WORK-1
-branch: work/dev-42
-status: running
-commits: []
-tests: not_run
-updated_at: "2026-10-08T10:00:00.000Z"
----
-# Checkpoint
-Completed: <actual changes>. Verification: <commands, results and proof paths>.
-Remaining: <work and exact next action>. Risks/questions: <observed limitations>.
-```
-
-## Herdr adapter: durable workers
-
-Read installed `herdr --help`, `herdr agent --help` and the live schema before
-issuing commands. Use structured argv, exact acknowledged identities and bounded
-waits/output. The launch recipes for the selected worktree are:
+## Publish worker observations
 
-| Kind | Launch argv | Resume argv | Short contexts | ctx capability |
-| --- | --- | --- | --- | --- |
-| codex | `--no-daemon --add-dir <absolute-mission>` | `resume <actual-session> --no-daemon --add-dir <absolute-mission>` | Native fresh context | Unmeasurable without a supported usage source |
-| claude | `--add-dir <absolute-mission>` | `--resume <actual-session> --add-dir <absolute-mission>` | Native Agent, no interception | Fresh transcript usage plus required context.windowTokens |
+For each mission worker or reviewer, keep one `run_<opaque-id>` for its assignment.
+Reuse the unit's open canonical mission; if it has none, create it with
+`void-machine mission start --title <unit> --json` and retain its returned ID.
+Do not recreate a mission to evade a refusal. This publication never substitutes
+for the mission's implementation, verification or independent review receipts.
 
-Use the selected kind's executable and preserve these options on every launch/resume:
+After an actual successful native dispatch acknowledgement, publish:
 
 ```sh
-herdr agent start <unique-mission-worker-name> --kind <kind> --pane <resolved-pane> -- <argv-from-table>
+void-machine agents record --mission <mis_id> --event-file <observation.json>
 ```
 
-The arguments after `--` belong to the selected runtime. The name is unique within
-the mission; it is not an invented native session ID. Resolve the pane first and
-keep the session ID actually returned by the runtime.
-
-Apply the role's existing permission/read-only policy; `--add-dir` only grants the
-specified directory, never disables a sandbox or an approval. Unsupported kind or
-option: diagnose and stop that launch. Do not update or restart Herdr to make it fit.
-Register planned worker before creating its owned surface. Keep the returned pane
-ID as a hint, launch once, submit the brief once, then reconcile by label + worktree.
-Use `herdr agent wait` in bounded slices and read the report after every turn.
-Idle/done is a turn ending, never proof the task passed. Request a missing report
-from the same session. Follow up in that session; never create a duplicate worker.
-After /clear read the same mission; after a killed process resume its actual session
-in the same worktree. Missing session: retain the mission and expose the loss.
-
-`resume_argv` is absent from Herdr 0.9.0 and 0.9.1, present from 0.9.2. Publish it
-only after the installed schema proves support. Otherwise retain the complete resume
-recipe in the brief. Never claim restart restoration was tested without doing it.
-
-## Herdr adapter: projection and closure
-
-The hook publishes source void-machine on SessionStart startup/resume/clear/compact
-and Stop after re-reading central state and fresh Herdr identities. Pane tokens:
-mission, worker, ticket, wstatus; coordinator-only workspace: mission, wstatus, workers.
-These are file status, never agent state. ctx requires the selected kind's measured capability from the table; unavailable measurement stays unavailable. Clear
-removes ctx before fresh measurement. State TTL is 86400000 ms, ctx TTL 7200000 ms.
-Sequences are exact nanosecond decimal BigInts captured before discovery. Old or
-equal seq is ignored by Herdr. Tokens are global keys, not source namespaces: another
-source may overwrite them; null clears globally. Never reconfigure cockpit to win.
-
-Terminal mission cleanup explicitly clears keys on all still-resolved owned panes,
-only where the currently projected mission still matches. Only the resolved
-coordinator clears workspace keys, again after verifying the displayed mission.
-A late closure of A must not clear B. A worker SessionEnd never cleans the workspace.
-When no mission is active, recover the verified displayed terminal mission; do not
-choose arbitrary history. Discovery/transport errors never trigger a purge.
-After collection and acceptance ORCH may close its owned surfaces; retain worktrees,
-branches and evidence according to their own lifecycle. Do not close the coordinator.
+The file contains `observationId`, `kind` and `payload`. Use a stable observation ID
+and exactly the same content on a retry. The payload always carries `schemaVersion: 1`
+and `runId`. Publish these three kinds at their real boundaries:
+
+- `worker.dispatched`: add `missionId`, `ticket` (or `unknown`), `role` (`work` or
+  `review`), `runtime` (`claude` or `codex`), the verified absolute `worktree`,
+  `branch` (`detached` requires `headSha`), and `attachCommand` (verified argv or
+  `unknown`). Never invent an attachment recipe or use presentation hints as identity.
+- `worker.state`: add `state` (`running`, `blocked`, `done`, `failed`) and the UTC
+  `observedAt`; optional `reason` explains a wait. Publish the initial running state
+  and subsequent observed changes. A turn ending while awaiting the coordinator
+  is blocked, not done. No observation means unknown, never inferred failure.
+- `worker.finished`: add `outcome` (`succeeded`, `failed`, `stopped`) after final
+  collection or confirmed terminal failure/stop, preceded by done for succeeded,
+  failed otherwise. Finish before closing the mission. It does not mean merged.
+
+Keep the same assignment through corrections and resume. Repeated running states
+across distinct turns need distinct observation IDs. A finished assignment is closed;
+new work afterwards gets a new run ID. Keep real native identities in the existing
+brief/evidence; the observation ID is not a fabricated native receipt.
+
+A publication error is visible and retried with the same identity/content after its
+cause is resolved; it never authorizes another launch. No brief, transcript, secret
+or result content belongs in these metadata. Native calls outside this procedure are
+not automatically captured, including unsupported Codex observation paths.
+
+`void-machine agents status --json` reads all project mission journals and reports
+active assignments, their last observed state and coverage issues. It does not poll
+runtimes or control presentation. Partial coverage is explicit and exits nonzero;
+never treat an unreadable history as no workers. External tools consume this public
+contract; the harness does not open or close their surfaces.
+
+Existing legacy runs retain their session and journal. Their mutating CLI commands
+publish the same events; `void-machine agents publish <runId>` retries publication
+from saved transitions without re-executing or stopping the runtime. This does not
+make the legacy launcher mandatory for new work.
 
 ## Independent review
 

package/core-assets/skills/void-plan/SKILL.md

@@ -20,11 +20,11 @@ do not independently approve plans or start implementation.
 
 ## When to invoke
 
-Invoke immediately after `void-brainstorm` approves a spec. The plan is the next deliverable before any code.
+Use when approved work has dependencies, several units or continuity needs worth recording. A bounded request with clear acceptance criteria can go directly to `void-implement`; a plan is not required merely because code will change.
 
 **A `source: forge` spec is a ready spec.** When `docs/specs/YYYY-MM-DD-<slug>.md` carries `source: forge` in its frontmatter (the forge→harness artifact contract), consume it **directly** — it already holds the 18 recon variables, the winning design, and the critique verdict, so `void-brainstorm` need not have run. Plan from it as-is; if it is partial (missing critique, or a field absent in an older `forge_version`), plan around the holes and flag them as the first open decisions rather than re-deriving the whole thing.
 
-Do NOT invoke without an approved spec. If you find yourself wanting to plan without a spec, that means brainstorm was skipped — go back.
+Use the approved spec or explicit user request as the source. If a material design choice is missing, resolve that choice with `void-brainstorm`; do not restart settled discovery.
 
 ---
 
@@ -64,9 +64,7 @@ Each implementation step has this shape:
 - **Depends on**: [step-3, step-5] (or "none")
 - **TDD mode**: strict | souple | exploratory
 - **Verification gate**: <what must pass before moving to step N+1>
-- **Expected commits**:
-  - `test: <reproducing or new behavior>`
-  - `feat: <implementation>` (or `fix:` / `refactor:` per `void-commit-discipline`)
+- **Expected change**: one logical, bisectable commit or dependency-ordered commits; RED/GREEN evidence is retained independently of commit boundaries
 - **Notes**: <constraints, gotchas, hook implications>
 ```
 
@@ -86,7 +84,7 @@ Each step's gate states which checks must pass before moving on. Examples:
 
 - `tsc --noEmit && vitest run --filter checkoutCart`
 - `pre-commit hooks dry-run on staged set` (composes with `tdd-guard`, `tigerstyle-check`, `no-any-grep`, etc.)
-- `mutation testing score ≥ 90%` (strict mode steps with critical surface)
+- the configured mutation threshold, when the project has a mutation runner
 
 The gate is observable. The user sees the output before the next step begins.
 
@@ -165,7 +163,7 @@ After writing the plan, scan for:
 3. **Missing TDD mode** — every implementation step declares one? Fix.
 4. **Unrealistic dependencies** — does step N actually need step N-1, or could they parallelize?
 5. **Missing execution handoff** — a standalone plan has a correct resume point; a tracker-backed program has the complete stable order/dependency table?
-6. **Frontmatter `spec:`** — links back to the approved spec?
+6. **Source of authority** — links to the approved spec when present, otherwise records the explicit request?
 7. **Executability gate** (vendored from gstack `/spec`) — could an *unfamiliar* implementer or agent execute this plan with **zero follow-up questions**? Walk one step as if you'd never seen the codebase: is every file named, every metric quantified, every acceptance criterion observable? Any "figure it out at implementation time" is an ambiguity to resolve now.
 
 Fix inline. Then user-review gate.
@@ -174,12 +172,9 @@ Fix inline. Then user-review gate.
 
 ## User-review gate
 
-Ask the user to review the plan before execution begins:
-
-> "Plan written and committed to `docs/plans/<file>.md`. Please review and let me know if you want changes before we start executing."
-
-Wait for response. If changes requested, make them and re-run self-review.
-
+For already authorized scope, do not request approval again for the plan's formatting or routine
+sequencing. Link the plan and proceed. Ask only for a new consequential choice, expanded scope
+or declared human gate; continue independent authorized work while it is unresolved.
 ---
 
 ## Transition to execution
@@ -213,7 +208,7 @@ Set `high_risk: true` when the plan touches:
 
 ## Composition with other skills
 
-- **Upstream — `void-brainstorm`**: the approved spec is the input.
+- **Upstream**: the approved `void-brainstorm` spec or explicit complete user request supplies scope.
 - **Downstream — `void-ticket`**: converts a multi-ticket plan into native tracker items and installs its active handoff.
 - **Downstream — `void-implement`**: executes one complete ticket and maintains its tracker lifecycle.
 - **With `void-autopilot`**: drains independent ready tickets only through its attended flow.
@@ -227,11 +222,11 @@ Set `high_risk: true` when the plan touches:
 
 ## Anti-rules
 
-- MUST NOT plan without an approved spec.
+- MUST NOT invent scope beyond the approved spec or explicit request.
 - MUST NOT skip TDD mode declaration per implementation step.
 - MUST NOT skip verification gates per step.
 - MUST NOT omit the applicable execution handoff: resume point for standalone work, tracker table for a multi-ticket program.
-- MUST NOT skip the spec link in frontmatter.
+- MUST NOT omit the source of authority: link the spec when present, otherwise record the explicit request.
 - MUST NOT execute the plan (downstream skills do that).
 
 ---
@@ -239,7 +234,7 @@ Set `high_risk: true` when the plan touches:
 ## Final rule
 
 ```
-Approved spec → plan written → self-review → user approves → ticket or implement.
+Approved scope → useful sequence → self-review → resolve only new decisions → ticket or implement.
 Otherwise → it is not voidcorp plan.
 ```
 

package/core-assets/skills/void-qa/SKILL.md

@@ -5,7 +5,7 @@ description: "Live browser QA of a running web app via the claude-in-chrome MCP:
 
 # qa — voidcorp craftsman edition
 
-You are a QA engineer AND a bug-fix engineer. Test a running web app like a real user — click everything, fill every form, check every state — using the **claude-in-chrome MCP** to drive the browser. When you find a bug, fix it in source with an atomic commit, then re-verify. Produce a structured report with before/after evidence.
+You are a QA engineer AND a bug-fix engineer. Test a running web app like a real user within the selected scope, exercising its controls, forms and relevant states, using the **claude-in-chrome MCP** to drive the browser. When you find a bug, fix it in source with an atomic commit, then re-verify. Produce a structured report with before/after evidence.
 
 This tests the *shipped, running app* through a real browser. It is not unit/E2E authoring (`void-tdd` + `void-testing` own that), and it does not judge visual craft from code (`void-ui-review` owns that — this skill composes it for the live visual pass).
 
@@ -52,10 +52,10 @@ Command mapping from the old gstack browse (`$B`) to the MCP:
 
 ## Modes
 
-- **Diff-aware** (default on a feature branch with no URL) — read the branch diff, map changed files to affected pages/routes, detect the local dev server, test only those pages plus a homepage smoke. The common case.
-- **Full** (a URL is given) — systematic exploration of every reachable page; 5-10 well-evidenced issues; health score.
+- **Diff-aware** (default for change verification, including when its URL is supplied) — read the diff, map the changed contract to affected pages, controls, states and viewports. Test the homepage only when it is affected or is a required entry path to that contract. Preserve mobile/desktop and keyboard/touch verification of the affected surface.
+- **Full** (explicitly requested audit) — systematic exploration across the requested site scope, evidence-backed issues and health score. A URL alone identifies the target; it does not select a full audit.
 - **Quick** (`--quick`) — 30-second smoke: homepage + top 5 nav targets, load + console + broken links only.
-- **Regression** (`--regression <baseline.json>`) — run full, then diff against a prior baseline: fixed vs new vs score delta.
+- **Regression** (`--regression <baseline.json>`) — run the explicitly requested baseline scope, then compare fixed/new issues and applicable score changes.
 - **Report-only** (`--report-only`, the old `/qa-only`) — phases through Report, then STOP. No fix loop, no commits.
 
 ## Precondition: clean working tree
@@ -65,18 +65,18 @@ Each fix must be its own atomic commit, so before fixing, `git status --porcelai
 ## Workflow
 
 1. **Orient** — `tabs_context_mcp`, open the target in a new tab, screenshot, read the page, check console. Detect the framework (Next.js `__next` / `_next/data`; Rails `csrf-token`; SPA = client routing) and note it. For an SPA, map nav from `read_page` (client routes, not raw links).
-2. **Explore** — visit pages systematically. Per page: visual scan of the screenshot; click interactive elements; fill + submit forms (empty, invalid, edge, overflow); walk navigation in and out; exercise **the states a user actually hits — empty, loading, error, overflow**; check console after every interaction; for responsive, `resize_window` then **verify the screenshot dimensions actually changed** — on some setups it resizes the window without re-rendering to a true mobile viewport, so confirm before trusting a "mobile" shot (else note responsive as unverified). Depth over breadth: more time on core flows (auth, checkout, search), less on static pages.
+2. **Explore** — visit only the selected mode's pages and affected states. Per page: visual scan of the screenshot; click interactive elements; fill + submit forms (empty, invalid, edge, overflow); walk navigation in and out; exercise **the states a user actually hits — empty, loading, error, overflow**; check console after every interaction; for responsive, `resize_window` then **verify the screenshot dimensions actually changed** — on some setups it resizes the window without re-rendering to a true mobile viewport, so confirm before trusting a "mobile" shot (else note responsive as unverified). Depth over breadth: more time on core flows (auth, checkout, search), less on static pages.
 3. **Document** — write each issue the moment you find it, never batch. Two evidence tiers: an **interactive** bug gets a before-screenshot, the action, an after-screenshot (a `gif_creator` repro for a flow); a **static** bug gets one annotated screenshot. Verify a bug reproduces once before writing it. For a UI quality pass, capture mobile and desktop for every applicable state and bind each capture to the current diff hash; a later CSS/UI diff makes it stale. Redact credentials (`[REDACTED]`). Surface every screenshot to the user (Read the file) — otherwise it is invisible.
-4. **Health score** — per-category 0-100 (Console, Links, Visual, Functional, UX, Performance, Content, Accessibility) minus severity deductions (critical -25 / high -15 / medium -8 / low -3), weighted average. Record it as the baseline.
-5. **Visual pass** — for visual/interaction judgment on the live screenshots, compose `void-ui-review`, then hand the current-diff evidence to `core:visual-craft-director` in fresh context. This skill drives the browser; `void-ui-review` supplies the craft bar; the specialist owns the independent verdict. If the browser or required captures are unavailable, report the UI pass blocked rather than certifying from prose.
-6. **Triage** — sort by severity; fix per tier: `--quick` critical+high · standard (default) +medium · `--exhaustive` +low. Mark unfixable-from-source (third-party, infra) as deferred.
-7. **Fix loop** (skipped in report-only) — per issue in severity order: locate source (grep/glob — only now do you read code); make the **minimal** fix (no refactor, no scope creep); commit one fix `fix(qa): <issue> — <desc>`; re-test the page with a before/after pair + console + a regression test that reproduces the bug (compose `void-tdd`/`void-testing` — assert behavior, not "it renders"); classify **verified / best-effort / reverted** (`git revert` on a regression → defer).
-8. **Self-regulation** — every 5 fixes or after any revert, stop and evaluate: reverts, fixes touching many files, all-low-severity remaining, and unrelated-file edits all raise the "this is going wrong" signal. Above the threshold, or past a hard cap of ~50 fixes, STOP and show the user before continuing.
-9. **Report** — issues with severity + evidence + fix status (verified/best-effort/reverted/deferred) + commit SHA; health-score delta baseline → final; a one-line PR summary ("QA found N, fixed M, health X → Y"). If the final score is worse than baseline, warn prominently. Write it under the project's report location, not `~/.gstack`.
+4. **Health score** (only for an explicitly requested full audit or scored baseline) — per-category 0-100 (Console, Links, Visual, Functional, UX, Performance, Content, Accessibility) minus severity deductions (critical -25 / high -15 / medium -8 / low -3), weighted average. Record it as the baseline.
+5. **Visual pass** (only for an explicitly requested visual audit, a new or materially redesigned journey, or an unresolved in-scope usability defect) — compose `void-ui-review` and hand the relevant current-diff screenshots to `core:visual-craft-director` in fresh context. Routine diff-aware verification retains its affected screenshots and functional/accessibility checks without a full visual audit or another specialist invocation. This skill drives the browser; `void-ui-review` supplies the craft bar; the specialist owns the independent verdict. If the browser or required captures are unavailable, report the UI pass blocked rather than certifying from prose.
+6. **Triage** — Diff-aware verification fixes only demonstrated in-scope blocking defects in the changed contract. Findings outside that scope are reported as limits or separate decisions; do not enter the fix loop for them or for optional improvements. For explicitly requested broad audits, the authorized tiers remain `--quick` critical+high, full critical+high+medium, `--exhaustive` all severities. Severity alone never expands the authorized scope. Mark unfixable-from-source issues as deferred.
+7. **Fix loop** (skipped in report-only) — for an authorized defect, locate its source, write and observe the failing regression before implementation (`void-tdd`/`void-testing`), make the minimal correction, then verify the affected behavior, screenshots and console. Commit the logical fix `fix(qa): <issue>` with its cause and actual proof. Classify verified / best-effort / reverted; a regression must be resolved or reverted without claiming success. In diff-aware delivery, reuse `void-implement`'s existing bounded correction cycle and stop once the affected contract is proven; no extra QA improvement loop.
+8. **Self-regulation** (explicit broad audit) — every 5 fixes or after any revert, stop and evaluate: reverts, fixes touching many files, all-low-severity remaining, and unrelated-file edits all raise the "this is going wrong" signal. Above the threshold, or past a hard cap of ~50 fixes, STOP and show the user before continuing.
+9. **Report** — state the scope, affected states/viewports verified, real defects, proof, fix status and material limits. Include a health-score delta only when that mode requested a score. A local change needs no whole-site score or unrelated N/A rows. Write under the project's report location, not `~/.gstack`.
 
 ## Composition & boundaries
 
-- **With `void-ui-review`** — this skill owns driving the browser and the functional/fix loop; `void-ui-review` owns the visual-craft judgment applied to the live screenshots (step 5). No restated design rules here.
+- **With `void-ui-review`** — this skill owns driving the browser and the functional/fix loop; `void-ui-review` owns the visual-craft judgment when step 5 applies; local diff-aware verification does not automatically invoke a full audit. No restated design rules here.
 - **With `void-tdd` / `void-testing`** — the regression test in the fix loop is authored per their discipline. This skill finds bugs in a running app; they own how the test that locks the fix is written.
 - **Not `void-devex-audit`** — that audits a developer-facing surface (API/CLI/SDK/docs journey, TTHW); this QAs an end-user web app in a browser. Different surface.
 - **Not E2E authoring** — Playwright suites are `void-testing`'s output; this is exploratory human-style QA of the deployed thing.
@@ -95,8 +95,9 @@ Each fix must be its own atomic commit, so before fixing, `git status --porcelai
 ## Final rule
 
 ```
-Running app → load claude-in-chrome (tabs_context first) → orient → explore every state → document with
-evidence → score → triage → atomic fix + regression test + re-verify → self-regulate → report.
+Running app → select authorized scope → load browser → verify affected states/viewports →
+record evidence → fix only in-scope defects with RED/GREEN → stop when proven → report.
+Scoring and broad visual exploration apply only to the modes that request them.
 Report-only stops before the fix loop. Otherwise → it is not voidcorp qa.
 ```