@hecer/yoke 1.6.1 → 1.7.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.1",
+  "version": "1.7.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.1",
+  "version": "1.7.0",
   "description": "Cross-agent coding discipline, mechanical gates, and release workflows",
   "skills": "./canon/skills/",
   "hooks": "./hooks/hooks.json"

package/CHANGELOG.md

@@ -2,11 +2,40 @@
 
 ## Unreleased
 
+## 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
+- GitHub Releases can now publish `@hecer/yoke` through npm trusted publishing with short-lived OIDC credentials and automatic provenance, without a long-lived npm token.
+
+### Fixed
+- Codex safe-mode invocations now use the supported `workspace-write` sandbox with `--approve-for-me`; the removed `--full-auto` flag no longer blocks current Codex CLI releases.
+- Windows provider cleanup rechecks termination after process close and accepts an already-absent process as successfully cleaned up, avoiding stale ownership records and unnecessary watchdog waits.
+- Successful stale-loop cleanup removes obsolete runtime status, so `yoke loop status` no longer reports a dead run as `RUNNING`.
+
 ## 1.6.1 — 2026-08-21
 
 ### Fixed
-- Release metadata now counts platform-conditional tests consistently on Windows and Ubuntu, so `docs:check` no longer fails after an otherwise green cross-platform test matrix.
-- Provider cleanup now rechecks termination after the child closes, preventing stale ownership records when Windows reports process exit asynchronously.
+- Release metadata counts platform-conditional tests consistently on Windows and Ubuntu.
+- Provider cleanup confirms termination after child close, preventing stale ownership records when Windows reports process exit asynchronously.
 
 ## 1.6.0 — 2026-08-20
 

package/README.md

@@ -2,14 +2,14 @@
 
 # 🐂 Yoke
 
-<!-- yoke:version:start -->1.6.1<!-- yoke:version:end -->
-<!-- yoke:tests:start -->1019<!-- yoke:tests:end -->
+<!-- yoke:version:start -->1.7.0<!-- yoke:version:end -->
+<!-- yoke:tests:start -->1100<!-- 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-1019%20passing-brightgreen.svg)
+![Tests](https://img.shields.io/badge/tests-1100%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,6 +27,36 @@
 
 > **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.7.0:** [verified project goals, recovery and one local dashboard for all your registered projects](docs/VERIFIED-PROJECTS.md). Check an existing project, continue a bounded goal with Codex, Claude or Gemini, and inspect tasks, acceptance evidence, recorded consumption and estimated timing in one place.
+
+### 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
@@ -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 — 1019 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,6 +187,10 @@ Yoke's CLI is deterministic and chainable by design: an agent (or a shell `&&`)
 
 | Command | What it does | Exit codes |
 |---|---|---|
+| `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; adaptive routing is always an explicit opt-in | `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 |
@@ -856,7 +890,7 @@ release provenance.
 ## 🧪 Development
 
 ```bash
-npm test          # vitest (1019 tests)
+npm test          # vitest (1100 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.1
+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/process.js

@@ -81,6 +81,8 @@ export function startProviderProcess(agent, invocation, options = {}) {
         telemetry: telemetry.finish(),
     });
     const finalize = (exitCode) => {
+        // Windows can emit close before taskkill's process-tree state is observable.
+        // Reconfirm here so successful termination does not leave a stale ownership record.
         if (termination && pid !== undefined && !terminationConfirmed) {
             terminationConfirmed = terminateProcessTree(pid, true);
         }

package/dist/agents/providers.js

@@ -13,16 +13,37 @@ const argsFor = (agent, permissions) => {
             return ['exec', '--dangerously-bypass-approvals-and-sandbox', '--json'];
         if (permissions === 'read-only')
             return ['exec', '--sandbox', 'read-only', '--json'];
-        return ['exec', '--full-auto', '--json'];
+        return ['exec', '--sandbox', 'workspace-write', '--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 !== undefined)
+        throw new Error('Gemini does not support 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) {

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 } : {}) };
 }

package/dist/check/command.js

@@ -0,0 +1,114 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { parse } from 'yaml';
+import { z } from 'zod';
+import { defaultConfig, loadConfig, resolveVerifyCommand } from '../retrofit/config.js';
+import { commandVerifier } from '../loop/verify.js';
+import { workspaceFingerprint } from '../workspace/fingerprint.js';
+import { statePath } from '../workspace/state.js';
+const Criterion = z.object({ id: z.string().min(1).max(120), text: z.string().min(1).max(8000), commands: z.array(z.string().min(1).max(8000)).max(30) }).strict();
+const Acceptance = z.object({ version: z.literal(1), criteria: z.array(Criterion).max(200), protected: z.array(z.string().min(1)).max(500).default([]) }).strict().superRefine((value, ctx) => {
+    if (new Set(value.criteria.map(c => c.id)).size !== value.criteria.length)
+        ctx.addIssue({ code: 'custom', message: 'Duplicate acceptance criterion id' });
+});
+export function loadAcceptance(root) {
+    const file = statePath(root, 'acceptance.yaml');
+    return existsSync(file) ? Acceptance.parse(parse(readFileSync(file, 'utf8'))) : null;
+}
+function protectedPath(root, path) {
+    if (isAbsolute(path))
+        throw new Error('Protected path must be relative');
+    const full = realpathSync(resolve(root, path));
+    const rel = relative(realpathSync(root), full);
+    if (rel === '..' || rel.startsWith('..\\') || rel.startsWith('../') || isAbsolute(rel))
+        throw new Error('Protected path escapes project');
+    return full;
+}
+function baselinePath(root) {
+    const id = createHash('sha256').update(realpathSync(root)).digest('hex');
+    return join(process.env.YOKE_STATE_DIR ?? join(homedir(), '.yoke', 'state'), 'acceptance', `${id}.json`);
+}
+function protectedHashes(root, paths) {
+    return Object.fromEntries(paths.map(path => [path, createHash('sha256').update(readFileSync(protectedPath(root, path))).digest('hex')]));
+}
+/** Explicitly pin acceptance outside the worker workspace. Never refreshed by check. */
+export function protectAcceptance(root, refresh = false) {
+    const manifest = loadAcceptance(root);
+    if (!manifest)
+        throw new Error('Create .yoke/acceptance.yaml before protecting acceptance');
+    const paths = [...new Set(['.yoke/acceptance.yaml', ...manifest.protected, ...['package.json', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock'].filter(p => existsSync(join(root, p)))])];
+    const file = baselinePath(root);
+    const hashes = protectedHashes(root, paths);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify({ version: 1, hashes }), { flag: refresh ? 'w' : 'wx', mode: 0o600 });
+    return file;
+}
+export function acceptanceProtectionProblem(root, baselineRoot = root) {
+    const file = baselinePath(baselineRoot);
+    if (!existsSync(file))
+        return null;
+    try {
+        const baseline = z.object({ version: z.literal(1), hashes: z.record(z.string().regex(/^[a-f0-9]{64}$/)) }).strict().parse(JSON.parse(readFileSync(file, 'utf8')));
+        if (!Object.keys(baseline.hashes).includes('.yoke/acceptance.yaml'))
+            return 'Invalid protected acceptance baseline';
+        const actual = protectedHashes(root, Object.keys(baseline.hashes));
+        const changed = Object.keys(actual).filter(path => actual[path] !== baseline.hashes[path]);
+        return changed.length ? `Protected acceptance changed: ${changed.join(', ')}` : null;
+    }
+    catch (error) {
+        return `Protected acceptance cannot be verified: ${error.message}`;
+    }
+}
+export function checkProject(directory, options = {}) {
+    const root = realpathSync(directory);
+    const started = Date.now();
+    const before = workspaceFingerprint(root);
+    const problem = acceptanceProtectionProblem(root);
+    const criteria = [];
+    const execute = options.execute ?? ((command, cwd) => commandVerifier(command, { phase: 'verify' })(cwd));
+    if (problem)
+        criteria.push({ id: 'protected-acceptance', text: 'Acceptance infrastructure unchanged', commands: [], status: 'failed', summary: problem });
+    else {
+        const manifest = loadAcceptance(root);
+        for (const criterion of manifest?.criteria ?? []) {
+            const results = criterion.commands.map(command => {
+                try {
+                    return execute(command, root);
+                }
+                catch (error) {
+                    return { passed: false, summary: error.message };
+                }
+            });
+            criteria.push({ ...criterion, status: results.length === 0 ? 'unverified' : results.every(r => r.passed) ? 'passed' : 'failed', summary: results.map(r => r.summary).join('\n') || 'No executable acceptance mapped' });
+        }
+        const command = resolveVerifyCommand(root, loadConfig(root) ?? defaultConfig('1.6.2'));
+        if (command) {
+            let result;
+            try {
+                result = execute(command, root);
+            }
+            catch (error) {
+                result = { passed: false, summary: error.message };
+            }
+            criteria.push({ id: 'project-suite', text: 'Configured project verification', commands: [command], status: result.passed ? 'passed' : 'failed', summary: result.summary });
+        }
+        if (options.requirement)
+            criteria.push({ id: 'requested-outcome', text: options.requirement, commands: [], status: 'unverified', summary: 'Map this outcome to executable criteria in .yoke/acceptance.yaml; a green suite alone is not proof of this requirement.' });
+        if (criteria.length === 0)
+            criteria.push({ id: 'acceptance', text: 'Project acceptance', commands: [], status: 'unverified', summary: 'No acceptance manifest or project verification command found' });
+    }
+    const changed = workspaceFingerprint(root) !== before;
+    const afterProblem = acceptanceProtectionProblem(root);
+    if (changed || afterProblem)
+        criteria.push({ id: 'source-integrity', text: 'Checked source remained stable', commands: [], status: 'failed', summary: afterProblem ?? 'Source changed during verification; run check again on a stable tree' });
+    const status = criteria.some(c => c.status === 'failed') ? 'failed' : criteria.some(c => c.status === 'unverified') ? 'unverified' : 'passed';
+    const id = randomUUID();
+    const evidencePath = statePath(root, 'checks', `${id}.json`);
+    const report = { version: 1, id, generatedAt: new Date().toISOString(), fingerprint: before, status, summary: changed ? 'Source changed during verification' : `${criteria.filter(c => c.status === 'passed').length}/${criteria.length} checks passed; ${status}`, criteria, durationMs: Date.now() - started, evidencePath };
+    mkdirSync(dirname(evidencePath), { recursive: true });
+    writeFileSync(evidencePath, JSON.stringify(report, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+    return report;
+}
+export function checkExitCode(report) { return report.status === 'passed' ? 0 : report.status === 'failed' ? 1 : 2; }