@hecer/yoke 1.6.2 → 1.8.0

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "yoke",
   "displayName": "Yoke",
-  "version": "1.6.2",
+  "version": "1.8.0",
   "description": "Cross-agent coding harness: one curated skill canon (TDD, brainstorming, plans, reviews, shipping, design verification) plus mechanical safety gates and an autonomous loop via the yoke CLI.",
   "author": { "name": "HECer", "url": "https://github.com/HECer" },
   "homepage": "https://github.com/HECer/yoke#readme",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "yoke",
-  "version": "1.6.2",
+  "version": "1.8.0",
   "description": "Cross-agent coding discipline, mechanical gates, and release workflows",
   "skills": "./canon/skills/",
   "hooks": "./hooks/hooks.json"

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## Unreleased
 
+## 1.8.0 — 2026-09-06
+
+### Added
+- Add persistent local measurement history and dashboard views for current work, usage/time and results, including UTC day/week/month filters, model history, project comparisons and consumption charts.
+- Display current tasks, worker phases, integration progress and status age, with automatic refresh of the current-work view.
+- Record explicit acceptances and show measured tokens and time per acceptance. Attribute available reviewer, critic and repair usage; distinguish actual reported models, unknown calls and partial costs.
+
+### Changed
+- Enable routing in new setups and automatically select up to three parallel workers when all pending tasks declare write scopes. Dependencies and overlapping scopes still constrain dispatch. Preserve explicit opt-outs and use isolated worktrees by default.
+- Share routing decisions between synchronous and asynchronous runners; support routed parallel workers, stable recovery history and explicit provider affinity.
+- Reserve execution capacity through integration and disable native delegation for loop providers; preserve Gemini system policy in a temporary bounded-execution configuration.
+- Require a dated changelog entry, synchronized version metadata and verified release checks for every new version in the project instructions.
+
+### Fixed
+- Avoid conflicting Codex sandbox arguments and prevent Codex-only options from leaking into Gemini workers.
+- Keep compact measurement history after recent activity expires, deduplicate archived events, and report incomplete history instead of treating missing usage as zero.
+- Preserve reviewer telemetry and worker/model attribution across parallel execution and recovery.
+
+### Migration and validation limits
+- Use `--parallel=N` to choose a worker limit, `--parallel=auto` for automatic selection, `--no-routing` to opt out of routing, and `--no-isolate` to opt out of default isolation. Explicit existing configuration remains authoritative. Unknown write scopes, tool actions and worktree recovery select serial execution in auto mode.
+- Automatic routing needs configured profiles; otherwise it keeps the selected parent provider. Explicit `--routing` without profiles reports a configuration error.
+- Missing historical usage cannot be reconstructed. Tokens per minute describe interval or summed call consumption, not measured generation speed. Live authenticated provider benchmarks, resource-adaptive concurrency and calibrated time/cost predictions are not established by this release.
+
+## 1.7.0 — 2026-09-05
+
+### Added
+- Independent `yoke check` with executable acceptance mapping, protected test infrastructure and content-bound evidence.
+- Durable project goals, provider handoff, checkpoint budgets, interruption accounting and project-scoped recovery.
+- Local project registry and loopback dashboard with goals, task estimates, evidence, consumption and pause controls.
+- Explicit routing rules with persisted gate-driven escalation; bounded tool actions without model calls.
+- Task-aware context packets, advisory write scopes, dependency-depth scheduling and empirical time ranges with prediction error records.
+
+### Fixed
+- Failed serial isolated worktrees are retained and can be explicitly resumed against their original target and PRD.
+- Reviewer fingerprints include untracked contents and acceptance inputs; unsupported nested repository identity fails closed.
+- Gemini always emits streaming telemetry, preserves model identity, honors aggregate token aliases and rejects unsupported selections. Its RTK hook merges native settings without a shell dependency.
+- Runtime evidence is excluded from Git gates and commits in existing projects. Partial usage and costs remain visibly incomplete.
+- Protected acceptance is checked after verification and repair, and linked goal state cannot overwrite unrelated files through pause.
+
+### Validation limits
+- Live authenticated provider comparisons and calibrated development-time/cost estimates are not established by the automated tests. Browser proof and independent model review still require explicit configuration.
+
 ## 1.6.2 — 2026-09-02
 
 ### Added

package/README.md

@@ -2,14 +2,14 @@
 
 # 🐂 Yoke
 
-<!-- yoke:version:start -->1.6.2<!-- yoke:version:end -->
-<!-- yoke:tests:start -->1021<!-- yoke:tests:end -->
+<!-- yoke:version:start -->1.8.0<!-- yoke:version:end -->
+<!-- yoke:tests:start -->1117<!-- yoke:tests:end -->
 <!-- yoke:skills:start -->34<!-- yoke:skills:end -->
 <!-- yoke:agents:start -->Claude | Codex | Gemini<!-- yoke:agents:end -->
 
 ### One harness, three agents — and zero trust in "done."
 
-**Yoke** installs one curated canon of skills, **mechanical safety gates**, and tool wiring into any project — natively for **Claude Code, OpenAI Codex CLI, and Gemini CLI**. Then, when you want it, an opt-in autonomous loop ships your spec story-by-story: tested, cross-model-reviewed, committed — **with a screenshot to prove every story and a video for every failure**.
+**Yoke** installs one curated canon of skills, **mechanical safety gates**, and tool wiring into any project — natively for **Claude Code, OpenAI Codex CLI, and Gemini CLI**. Its opt-in loop implements and verifies stories before committing. Independent review and browser proofs run when configured; screenshots and videos require the browser smoke gate.
 
 [![npm](https://img.shields.io/npm/v/%40hecer%2Fyoke?logo=npm&color=CB3837)](https://www.npmjs.com/package/@hecer/yoke)
 [![npm downloads](https://img.shields.io/npm/dm/%40hecer%2Fyoke?logo=npm)](https://www.npmjs.com/package/@hecer/yoke)
@@ -17,7 +17,7 @@
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](#-license)
 ![Node](https://img.shields.io/badge/node-%E2%89%A520-339933?logo=node.js&logoColor=white)
 ![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=white)
-![Tests](https://img.shields.io/badge/tests-1021%20passing-brightgreen.svg)
+![Tests](https://img.shields.io/badge/tests-1117%20defined-blue.svg)
 ![Agents](https://img.shields.io/badge/agents-Claude%20%7C%20Codex%20%7C%20Gemini-8A2BE2)
 ![Built with TDD](https://img.shields.io/badge/built%20with-TDD%20%2B%20review-ff69b4.svg)
 
@@ -27,13 +27,43 @@
 
 > **TL;DR** — `yoke setup .` asks six questions and installs the native harness for your agent. `yoke new my-app --idea="..."` bootstraps a project and drafts its story backlog. `yoke loop run my-app --isolate --review` then implements it behind hard gates: **clean tree → acceptance criteria → your real tests green → an independent model approves → commit**. Add `--parallel=N` for dependency-aware workers, or declare a reference and add `--quality` for a bounded critic/repair gauntlet. If any blocking gate is red, nothing is committed. Proof lives in `.yoke/proof/<story>/`.
 
+**New in 1.8.0:** [automatic routing, up to three parallel workers and expanded project dashboards](docs/VERIFIED-PROJECTS.md). Inspect current work, compare recorded consumption across projects and models by day, week or month, and track measured effort per accepted change. New setups enable routing and isolated execution by default; explicit overrides remain available.
+
+### One dashboard, multiple projects
+
+```sh
+npm install -g @hecer/yoke@latest
+yoke projects add /path/to/frontend
+yoke projects add /path/to/backend
+yoke dashboard --no-register
+```
+
+Open the printed `http://127.0.0.1:...` URL. Each registered project has its own goals, tasks and evidence. The dashboard shows available worker state, per-task duration estimates, planned start offsets, input/output tokens, costs and unknown measurements. You can request a goal pause at a safe boundary.
+
+Projects are registered explicitly; this version does not automatically discover every process or aggregate other computers. Start/resume and budget changes use the CLI. Missing history appears as unknown; time ranges are empirical estimates, not exact deadlines.
+
+### Verified goals and efficient execution
+
+```sh
+yoke check /path/to/project --json
+# First define executable criteria and protected tests in .yoke/acceptance.yaml.
+yoke goal set /path/to/project --objective="Complete guest checkout" --attempts=3 --minutes=30
+yoke goal run /path/to/project --runner=codex
+yoke goal resume /path/to/project --runner=claude
+yoke goal handoff /path/to/project
+```
+
+Goals persist their objective, attempts and check evidence across runs. Changed protected tests block acceptance; failed work is retained. Explicit routing rules bypass controller calls, configured tool actions use no model, and failed rule-based attempts can escalate to a stronger worker. Context selection stays within a character budget; declared write scopes and dependencies guide parallel scheduling.
+
+See the [1.7 workflow guide](docs/VERIFIED-PROJECTS.md) for setup, Gemini selection, recovery and budgets. Provider contracts do not establish equal model quality; live comparative savings and calibrated time predictions remain unmeasured. Token budgets apply between provider calls, and browser proofs still require a configured smoke gate.
+
 Yoke 1.5 keeps failed gate output compact without throwing evidence away: deterministic previews
 retain actionable failures and final summaries, while large complete stdout/stderr remains available
 in private, content-addressed local artifacts. Existing projects keep their serial behavior and use
 safe 2 KiB preview / 8 KiB artifact defaults unless configured otherwise.
 
-Yoke 1.4 adds opt-in parallel workers and a bounded, reference-driven quality gauntlet without
-changing existing serial loop defaults. See [the 1.4 migration guide](docs/MIGRATING-TO-1.4.md)
+Yoke 1.4 introduced opt-in parallel workers and a bounded, reference-driven quality gauntlet.
+Yoke 1.8.0 uses automatic parallelism for tasks with declared write scopes. See [the 1.4 migration guide](docs/MIGRATING-TO-1.4.md)
 for the new flags, configuration, cleanup behavior, and review-verdict contract.
 
 Yoke 1.1 is safe-by-default: provider CLIs use autonomous sandbox profiles unless `--unsafe`
@@ -50,7 +80,7 @@ Agentic coding in 2026 fails in four well-documented ways. Yoke answers each one
 
 | The pain | What actually happens | What Yoke does about it |
 |---|---|---|
-| 🎭 **The verification gap** — *"agent says done, but it isn't"* | Agents submit confidently on 100% of runs while resolving far fewer; "all tests pass" when they were never run ([silent-failures research](https://arxiv.org/pdf/2603.25764)) | The loop trusts **your verify command's exit code**, never the agent's word. A story is `passes: true` only after tests are green, the reviewer approved, and the commit landed — atomically. Plus: **screenshot proofs** per story. |
+| 🎭 **The verification gap** — *"agent says done, but it isn't"* | A success message can omit untested acceptance criteria. | The loop executes acceptance and project checks. Enabled review and browser gates must pass before a story lands. `yoke check` exposes unmapped outcomes as unverified. |
 | 🔀 **Three agents, three configs** | Teams hand-maintain `CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, skills, and MCP wiring separately — copy-paste drift everywhere | **One canon → `yoke retrofit`** generates the idiomatic native artifacts for each agent. Change the canon once, re-retrofit everywhere. |
 | 🌀 **Overnight loops going off the rails** | Raw Ralph-loop users "wake up to broken codebases that don't compile" | Yoke is **"Ralph, but with gates"**: clean-worktree gate, acceptance-criteria gate, green-tests gate, review gate, per-story worktree isolation, idle-timeout watchdog, single-flight lock, commit integrity. |
 | 😵 **Review fatigue** | AI adoption nearly doubles PR volume and review time; humans start skimming | **`yoke review`**: a second model writes a schema-validated pass/fail verdict — chainable into verify, pre-push, or CI. Cross-model review catches what self-review misses. |
@@ -59,7 +89,7 @@ Agentic coding in 2026 fails in four well-documented ways. Yoke answers each one
 
 **Who it's not for:** if you want a chat pair-programmer with no process, you don't need a harness. Yoke is for shipping with discipline.
 
-## ⏱️ 60 seconds: idea → tested, photographed software
+## Example: idea → verified implementation
 
 ```console
 $ yoke new reading-app --idea="a web app that tracks my reading list"
@@ -78,10 +108,10 @@ $ yoke loop run reading-app --isolate --review --max=10
                                               # nothing was committed. fix, then re-run.
 
 $ ls reading-app/.yoke/proof/STORY-2/
-home.png  list.png                            # photographic evidence, labelled per story
+home.png  list.png                            # example when browser smoke is configured
 ```
 
-Every claim in that transcript is enforced by code paths with tests behind them — 1021 of them, and this repo was built by its own loop and gates ([how it was built](#-why--how-it-was-built)).
+This is an illustrative transcript. Actual durations depend on the project, provider, retries and enabled gates; browser proof requires a configured smoke flow. See [how it was built](#-why--how-it-was-built).
 
 ## 🚀 Quickstart
 
@@ -157,7 +187,11 @@ Yoke's CLI is deterministic and chainable by design: an agent (or a shell `&&`)
 
 | Command | What it does | Exit codes |
 |---|---|---|
-| `yoke setup [dir] [--yes] [--host=] [--agent=] [--runner=] [--code-graph=] [--decision-policy=] [--loop\|--no-loop] [--routing\|--no-routing]` | Shared six-question setup for Claude, Codex, and Gemini; adaptive routing is always an explicit opt-in | `0` · `1` invalid setup |
+| `yoke dashboard [dir] [--no-register] [--port=N]` | Local overview for every registered project; optionally register `dir` first | `0` stopped normally · `1` shutdown failure · `2` unavailable |
+| `yoke projects add\|list\|remove` | Register a project, list registrations or remove a reference by ID | `0` · `2` invalid/unavailable |
+| `yoke check [dir] [--json] [--requirement=] [--protect [--refresh]]` | Execute acceptance checks or explicitly pin their infrastructure | `0` passed/pinned · `1` failed · `2` unverified/unavailable |
+| `yoke goal set\|run\|resume\|pause\|status\|handoff\|budget [dir]` | Durable objectives, provider handoff, protected checks and checkpoint budgets | run/resume: `0` complete · `1` unfinished · `2` unavailable |
+| `yoke setup [dir] [--yes] [--host=] [--agent=] [--runner=] [--code-graph=] [--decision-policy=] [--loop\|--no-loop] [--routing\|--no-routing]` | Shared six-question setup for Claude, Codex, and Gemini; routing defaults on for new setups and preserves explicit opt-outs | `0` · `1` invalid setup |
 | `yoke validate [canonDir]` | Validate the canon (schema, frontmatter, templates) | `0` valid · `1` errors |
 | `yoke new <dir> [--idea=] [--agent=] [--runner=] [--loop]` | Greenfield bootstrap: git init → scaffold → retrofit → context → PRD (drafted from `--idea`) → committed | `0` · `1` usage / non-empty dir / draft failed (scaffold survives) · `2` draft agent unavailable |
 | `yoke retrofit [dir] [--agent=claude,codex,gemini\|all] [--code-graph=graphify\|serena] [--loop]` | Install/update the harness, non-destructively | `0` |
@@ -529,14 +563,16 @@ use `yoke loop resume . --discard`; pending decisions are never deleted by that
 `loop.onAmbiguity: resolve|abort` and `--on-ambiguity=` remain supported as compatibility aliases;
 new projects should use `decisionPolicy: auto|critical`.
 
-### Adaptive model routing (explicit opt-in)
+### Adaptive model routing
 
-`yoke setup` asks before enabling routing; the default is **off**. When enabled, the selected
+`yoke setup` enables routing by default and preserves explicit opt-outs. Without configured
+worker profiles, automatic execution keeps the selected parent. When enabled, the selected
 parent remains the strong planner/controller. Before each bounded story it receives only the
 story, acceptance criteria, and at most three eligible worker profiles, then returns one
 machine-readable choice. The worker can be a cheaper/faster Claude, Codex, or Gemini profile;
-`SELF` keeps difficult work on the parent. Provider-native subagents are disabled for these
-runs so Yoke does not pay for two orchestration layers.
+`SELF` keeps difficult work on the parent. Explicit project rules skip the controller.
+Loop runners disable native delegation in Codex, Claude and Gemini so it cannot multiply
+the Yoke worker budget. Integration retains its execution slot until the candidate lands.
 
 **Provider support:** adaptive routing uses Yoke's shared provider adapter and works with Claude
 Code, Codex CLI, and Gemini CLI, including mixed-provider worker lists. Internal contract tests
@@ -550,7 +586,7 @@ runner:
   model: gpt-5.6-sol       # optional; provider model strings stay opaque to Yoke
   reasoningEffort: high
 routing:
-  enabled: true            # setup defaults false; setup --routing opts in
+  enabled: true            # new setup default; false preserves an explicit opt-out
   strategy: balanced       # balanced | cost | speed | quality
   maxCandidates: 3
   workers:
@@ -571,7 +607,7 @@ routing:
       capabilities: [large-context, implementation]
 ```
 
-Use `yoke loop run . --routing` for a one-run opt-in or `--no-routing` for a controlled
+Use `yoke loop run . --routing` to explicitly require configured routing or `--no-routing` for a controlled
 baseline. Routing control calls are read-only and deliberately tiny; malformed output or no
 eligible worker falls back to `SELF`. Yoke does not ship a universal, fast-aging
 "intelligence score". Candidate model IDs come from project configuration while setup defaults
@@ -581,9 +617,12 @@ after 30 days. It stores no prompts, source, or project paths—only a project h
 time/token/outcome evidence. Writes are immutable one-event files, so concurrent Yoke instances
 cannot overwrite a shared registry file.
 
-Routing is not free: it adds one controller call per story. It is most promising when a bounded
-worker saves more than that call costs; tiny stories may be slower. Keep it opt-in and measure it
-on your own backlog rather than assuming a win.
+Routing is not free: stories without a matching rule can add a controller call. Measure it
+on your own backlog rather than assuming a win. Routing now also runs within asynchronous
+parallel workers. Automatic parallelism starts at up to three workers when pending tasks declare
+write scopes; unknown scopes and configured tool actions keep execution serial. Isolation is
+on by default. Explicit `--parallel=N`, `--no-routing` and `--no-isolate` remain available.
+See [execution defaults and dashboard measurement details](docs/VERIFIED-PROJECTS.md#execution-defaults-in-180).
 
 ### Performance budgets: efficiency as a gate, not a style
 
@@ -807,7 +846,7 @@ the routed median used **33.8% less wall time, 11.0% less fresh input, 49.5% few
 and 78.2% fewer reasoning tokens**. All three pairs improved wall time and fresh input.
 
 The boundary matters: an earlier architecture/privacy task correctly stayed on `SELF` and paid
-controller overhead, so routing is an explicit opt-in rather than a universal win. Codex did not
+controller overhead, so the routing default is not evidence of universal savings. Codex did not
 emit dollar cost for these plan-backed runs; Yoke reports the measured token breakdown instead of
 inventing a price. Method, ranges, controller cost, caveats, analyzer, and six raw JSON rows are in
 [`bench/RESULTS.md`](bench/RESULTS.md#codex-only-full-repository-routing-study-2026-08-02).
@@ -856,7 +895,7 @@ release provenance.
 ## 🧪 Development
 
 ```bash
-npm test          # vitest (1021 tests)
+npm test          # vitest (1117 tests)
 npm run build     # tsc, no emit errors
 npm run yoke -- validate canon
 ```

package/canon/manifest.yaml

@@ -1,5 +1,5 @@
 name: yoke-canon
-version: 1.6.2
+version: 1.7.0
 agents: [claude, codex, gemini]
 skills:
   - { id: tdd, path: skills/tdd, kind: methodology, invocation: auto }

package/canon/tools/gemini-rtk-hook.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// Pure BeforeTool argument adapter. Never evaluates or executes tool commands.
+import { readFileSync } from 'node:fs'
+
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+try {
+  const event = JSON.parse(readFileSync(0, 'utf8'))
+  if (!record(event) || typeof event.tool_name !== 'string' ||
+      (event.hook_event_name !== undefined && event.hook_event_name !== 'BeforeTool')) throw new Error('event')
+  let response = {}
+  if (event.tool_name === 'run_shell_command') {
+    if (!record(event.tool_input) || typeof event.tool_input.command !== 'string' || !event.tool_input.command.trim() || event.tool_input.command.includes('\0')) throw new Error('command')
+    const command = event.tool_input.command
+    // Restrict rewriting to simple supported invocations. Leave shell syntax,
+    // quoted executables, assignments and existing RTK wrappers untouched.
+    if (!/[;&|<>`$\r\n()]/u.test(command) && /^\s*(?:git|rg|npm|npx|cargo|pytest|go|docker|kubectl)\s/u.test(command)) {
+      const rewritten = command.trimStart().replace(/^rg\s/u, 'grep ')
+      response = { hookSpecificOutput: { tool_input: { ...event.tool_input, command: `rtk ${rewritten}` } } }
+    }
+  }
+  process.stdout.write(JSON.stringify(response) + '\n')
+} catch {
+  process.stderr.write('Invalid Gemini BeforeTool hook input\n')
+  process.exitCode = 2
+}

package/dist/agents/contracts.js

@@ -25,6 +25,8 @@ const ProviderTokenUsageSchema = z.object({
 export const ProviderTelemetrySchema = z.object({
     usageAvailable: z.boolean(),
     tokens: ProviderTokenUsageSchema.optional(),
+    partialUsage: ProviderTokenUsageSchema.partial().optional(),
+    reportedModels: z.array(z.string().min(1)).optional(),
 }).superRefine((telemetry, ctx) => {
     if (telemetry.usageAvailable && !telemetry.tokens) {
         ctx.addIssue({ code: 'custom', path: ['tokens'], message: 'usageAvailable telemetry requires token totals' });

package/dist/agents/process-streams.js

@@ -19,10 +19,19 @@ export function createBoundedOutput(limitBytes) {
 export function createTelemetryAccumulator(agent) {
     let trailing = '';
     let telemetry = { usageAvailable: false };
+    let reportedModels = [];
     const update = (lines) => {
-        const next = parseProviderTelemetry(agent, [...lines]);
-        if (next.usageAvailable)
-            telemetry = next;
+        for (const line of lines) {
+            const next = parseProviderTelemetry(agent, [line]);
+            if (next.reportedModels)
+                reportedModels = next.reportedModels;
+            else if (next.tokens?.model)
+                reportedModels = [next.tokens.model];
+            // Provider result usage is cumulative: replace the latest measurement,
+            // never add it to earlier results or to assistant-message snapshots.
+            if (next.tokens || next.partialUsage)
+                telemetry = next;
+        }
     };
     return {
         append(text) {
@@ -34,7 +43,12 @@ export function createTelemetryAccumulator(agent) {
             if (trailing)
                 update([trailing]);
             trailing = '';
-            return telemetry;
+            if (telemetry.tokens) {
+                const { model: _model, ...tokens } = telemetry.tokens;
+                return { usageAvailable: telemetry.usageAvailable, tokens: { ...tokens, ...(reportedModels.length === 1 ? { model: reportedModels[0] } : {}) },
+                    ...(reportedModels.length > 1 ? { reportedModels } : {}) };
+            }
+            return { ...telemetry, ...(reportedModels.length ? { reportedModels } : {}) };
         },
     };
 }

package/dist/agents/providers.js

@@ -1,4 +1,5 @@
 import { ModelSelectionSchema } from './contracts.js';
+import { fileURLToPath } from 'node:url';
 export { providerSpawnOptions, startProviderProcess, } from './process.js';
 const argsFor = (agent, permissions) => {
     if (agent === 'claude') {
@@ -13,16 +14,38 @@ const argsFor = (agent, permissions) => {
             return ['exec', '--dangerously-bypass-approvals-and-sandbox', '--json'];
         if (permissions === 'read-only')
             return ['exec', '--sandbox', 'read-only', '--json'];
-        return ['exec', '--sandbox', 'workspace-write', '--approve-for-me', '--json'];
+        // Automatic review already selects workspace-write and conflicts with --sandbox.
+        return ['exec', '--approve-for-me', '--json'];
     }
     if (permissions === 'unsafe')
-        return ['--yolo'];
+        return ['--yolo', '--output-format', 'stream-json'];
     const approval = permissions === 'read-only' ? 'plan' : 'auto_edit';
-    return ['--approval-mode', approval, '--sandbox'];
+    return ['--approval-mode', approval, '--sandbox', '--output-format', 'stream-json'];
 };
-export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe', selection = {}) {
+export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe', selection = {}, output = {}) {
     const parsedSelection = ModelSelectionSchema.parse(selection);
+    if (agent === 'gemini' && parsedSelection.bare)
+        throw new Error('Gemini does not support the bare startup selection');
+    if (agent === 'gemini' && parsedSelection.reasoningEffort)
+        throw new Error('Gemini does not support the reasoningEffort selection');
+    if (agent === 'gemini' && parsedSelection.nativeMultiAgent === true)
+        throw new Error('Gemini does not support enabling the nativeMultiAgent selection');
     const args = argsFor(agent, permissions);
+    if (output.schemaFile !== undefined || output.jsonSchema !== undefined) {
+        if (agent === 'codex' && output.schemaFile && output.jsonSchema === undefined) {
+            if (/[\0\r\n]/u.test(output.schemaFile) || (process.platform === 'win32' && !/^[A-Za-z0-9_./:\\-]+$/u.test(output.schemaFile)))
+                throw new Error('Invalid output schema file path');
+            args.push('--output-schema', output.schemaFile);
+        }
+        else if (agent === 'claude' && output.jsonSchema && output.schemaFile === undefined) {
+            const schema = JSON.stringify(output.jsonSchema);
+            if (process.platform === 'win32')
+                throw new Error('Inline structured output is unsupported by the Windows provider shell shim');
+            args.push('--json-schema', schema);
+        }
+        else
+            throw new Error(`${agent} structured output schema requires ${agent === 'codex' ? 'schemaFile' : agent === 'claude' ? 'jsonSchema' : 'a supported native schema option (unavailable)'}`);
+    }
     if (parsedSelection.model)
         args.push('--model', parsedSelection.model);
     if (parsedSelection.reasoningEffort) {
@@ -33,11 +56,16 @@ export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe'
     }
     if (agent === 'codex' && parsedSelection.nativeMultiAgent === false)
         args.push('--disable', 'multi_agent');
+    if (agent === 'claude' && parsedSelection.nativeMultiAgent === false)
+        args.push('--disallowedTools', 'Agent', 'Task', 'TeamCreate', 'SendMessage');
     if (parsedSelection.bare) {
         if (agent === 'codex')
             args.push('--ignore-user-config');
         else if (agent === 'claude')
             args.push('--bare');
     }
+    if (agent === 'gemini' && parsedSelection.nativeMultiAgent === false) {
+        return { command: process.execPath, args: [fileURLToPath(new URL('../../hooks/bounded-gemini.mjs', import.meta.url)), ...args], input: prompt, cwd };
+    }
     return { command: agent, args, input: prompt, cwd };
 }

package/dist/agents/telemetry.js

@@ -1,4 +1,4 @@
-const finite = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+const finite = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
 function parseJson(value) {
     try {
         return { ok: true, value: JSON.parse(value) };
@@ -30,6 +30,8 @@ export function parseProviderResult(agent, output) {
         const event = parsed.value;
         switch (agent) {
             case 'claude':
+                if (event.type === 'result' && directMachineResult(event.structured_output) !== undefined)
+                    return event.structured_output;
                 if (event.type === 'result' && typeof event.result === 'string')
                     fragments.push(event.result);
                 break;
@@ -69,6 +71,7 @@ export function parseProviderTelemetry(agent, lines) {
     let reasoningOutputTokens;
     let totalCostUsd;
     let model;
+    let reportedModels = [];
     for (const line of lines) {
         let parsed;
         try {
@@ -89,11 +92,44 @@ export function parseProviderTelemetry(agent, lines) {
                 : stats?.usage && typeof stats.usage === 'object'
                     ? stats.usage
                     : stats);
-        const models = stats?.models && typeof stats.models === 'object' ? stats.models : undefined;
-        const firstModel = models ? Object.entries(models)[0] : undefined;
+        const models = isRecord(stats?.models) ? stats.models : undefined;
+        const modelEntries = models ? Object.entries(models) : [];
+        const firstModel = modelEntries.length === 1 ? modelEntries[0] : undefined;
         const modelUsage = firstModel?.[1] && typeof firstModel[1] === 'object' ? firstModel[1] : undefined;
         const nestedModelTokens = modelUsage?.tokens && typeof modelUsage.tokens === 'object' ? modelUsage.tokens : undefined;
-        const source = nestedModelTokens ?? modelUsage ?? usage;
+        // Streaming stats report aggregate input_tokens (including cached input).
+        // Older JSON stats only provide model-local token objects. Sum a field
+        // only when every model measured it; a missing measurement is not zero.
+        let source = usage ?? nestedModelTokens ?? modelUsage;
+        if (agent === 'gemini' && modelEntries.length > 0) {
+            reportedModels = modelEntries.map(([name]) => name);
+            model = firstModel?.[0];
+            const fields = {
+                input_tokens: ['input_tokens', 'inputTokens', 'promptTokenCount', 'input'],
+                output_tokens: ['output_tokens', 'outputTokens', 'candidatesTokenCount', 'output'],
+                cached_input_tokens: ['cached_input_tokens', 'cachedInputTokens', 'cachedContentTokenCount', 'cached'],
+                reasoning_output_tokens: ['reasoning_output_tokens', 'reasoningOutputTokens', 'thoughtsTokenCount', 'thoughts'],
+            };
+            const totals = {};
+            for (const [field, aliases] of Object.entries(fields)) {
+                const aggregate = aliases.map(key => finite(usage?.[key])).find(value => value !== undefined);
+                if (aggregate !== undefined) {
+                    totals[field] = aggregate;
+                    continue;
+                }
+                const values = modelEntries.map(([, value]) => {
+                    const entry = isRecord(value) ? value : {};
+                    const tokens = isRecord(entry.tokens) ? entry.tokens : entry;
+                    return aliases.map(key => finite(tokens[key])).find(value => value !== undefined);
+                });
+                if (values.every(value => value !== undefined))
+                    totals[field] = values.reduce((sum, value) => sum + value, 0);
+            }
+            source = { ...totals, ...usage };
+            const aggregateCached = finite(usage?.cached_input_tokens ?? usage?.cached);
+            if (aggregateCached !== undefined)
+                source.cached_input_tokens = aggregateCached;
+        }
         const inValue = finite(source?.input_tokens ?? source?.inputTokens ?? source?.prompt_tokens ?? source?.promptTokenCount ?? source?.input);
         const cachedValue = finite(source?.cached_input_tokens ?? source?.cache_read_input_tokens ?? source?.cachedInputTokens ?? source?.cachedContentTokenCount ?? source?.cached);
         const cacheWriteValue = finite(source?.cache_write_input_tokens ?? source?.cache_creation_input_tokens ?? source?.cacheWriteInputTokens ?? source?.cacheWrite);
@@ -113,19 +149,31 @@ export function parseProviderTelemetry(agent, lines) {
         if (costValue !== undefined)
             totalCostUsd = costValue;
         const eventModel = event.model ?? message?.model ?? firstModel?.[0];
-        if (typeof eventModel === 'string' && eventModel)
+        if (typeof eventModel === 'string' && eventModel && reportedModels.length <= 1)
             model = eventModel;
     }
-    if (inputTokens === undefined && outputTokens === undefined)
-        return { usageAvailable: false };
+    if (inputTokens === undefined || outputTokens === undefined) {
+        const partialUsage = {
+            ...(inputTokens !== undefined ? { inputTokens } : {}),
+            ...(outputTokens !== undefined ? { outputTokens } : {}),
+            ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+            ...(cacheWriteInputTokens !== undefined ? { cacheWriteInputTokens } : {}),
+            ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+            ...(totalCostUsd !== undefined ? { totalCostUsd } : {}),
+        };
+        return { usageAvailable: false,
+            ...(Object.keys(partialUsage).length ? { partialUsage } : {}),
+            ...(reportedModels.length ? { reportedModels } : model ? { reportedModels: [model] } : {}),
+        };
+    }
     const tokens = {
-        inputTokens: inputTokens ?? 0,
+        inputTokens,
         ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
         ...(cacheWriteInputTokens !== undefined ? { cacheWriteInputTokens } : {}),
-        outputTokens: outputTokens ?? 0,
+        outputTokens,
         ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
         ...(totalCostUsd !== undefined ? { totalCostUsd } : {}),
         ...(model ? { model } : {}),
     };
-    return { usageAvailable: true, tokens };
+    return { usageAvailable: true, tokens, ...(reportedModels.length > 1 ? { reportedModels } : {}) };
 }