@hecer/yoke 1.12.0 → 1.14.0

package/dist/review/command.js

@@ -1,3 +1,4 @@
+import { AGENT_LIST } from '../agents/catalog.js';
 import { agentInvocation, buildStandaloneReviewPrompt, buildWatchdogInvocation, runCapturedAgent, repositoryFingerprint, isAgentAvailable, } from '../loop/runner.js';
 import { parseProviderResult } from '../agents/telemetry.js';
 import { resolveIdleMs } from '../loop/run-command.js';
@@ -5,14 +6,14 @@ import { loadConfig } from '../retrofit/config.js';
 import { parseReviewVerdict } from './verdict.js';
 // Resolve to the first available agent, preferring a *second* model so the review
 // is genuinely cross-model. claude last => a Claude-only box degrades to self-review.
-const RESOLUTION_ORDER = ['codex', 'gemini', 'qwen', 'claude'];
+const RESOLUTION_ORDER = ['codex', 'gemini', 'qwen', 'claude', 'opencode', 'kilo', 'pi'];
 export function runReview(targetDir, opts = {}) {
     const available = opts.isAvailable ?? isAgentAvailable;
     const implementer = opts.implementer ?? loadConfig(targetDir)?.agents[0] ?? 'claude';
     let reviewer = opts.reviewer;
     if (reviewer) {
         if (!available(reviewer)) {
-            console.error(`Reviewer agent CLI "${reviewer}" was not found on PATH. Install it, or pick another with --reviewer=<claude|codex|gemini>.`);
+            console.error(`Reviewer agent CLI "${reviewer}" was not found on PATH. Install it, or pick another with --reviewer=<${AGENT_LIST}>.`);
             return 2;
         }
         if (reviewer === implementer && !opts.allowSelfReview) {

package/dist/review/verdict.js

@@ -70,7 +70,7 @@ export function formatReviewContract(path, provider) {
     return [
         `Write your final verdict to this absolute path: ${path}`,
         'The file must contain exactly one JSON object with this contract:',
-        `{"schemaVersion":1,"approved":boolean,"summary":"non-empty string","findings":[{"id":"optional id","severity":"blocking|warning|info","message":"non-empty string","file":"optional path","line":1,"actionable":true,"suggestedFix":"optional repair","evidence":["optional evidence reference"]}],"provenance":{"provider":"${provider ?? 'claude|codex|gemini'}","model":"provider-reported model","role":"review","promptVersion":1,"permissions":"safe"}}`,
+        `{"schemaVersion":1,"approved":boolean,"summary":"non-empty string","findings":[{"id":"optional id","severity":"blocking|warning|info","message":"non-empty string","file":"optional path","line":1,"actionable":true,"suggestedFix":"optional repair","evidence":["optional evidence reference"]}],"provenance":{"provider":"${provider ?? 'claude|codex|gemini|qwen|opencode|kilo|pi'}","model":"provider-reported model","role":"review","promptVersion":1,"permissions":"safe"}}`,
         'Set approved=false when any blocking finding exists. Create the file even when the process also exits non-zero.',
     ].join('\n');
 }

package/dist/routing/capability.js

@@ -57,7 +57,7 @@ export function chooseCapability(input) {
     const candidates = input.workers.filter(w => w.tier && tiers.indexOf(w.tier) >= level && (!input.maxTier || tiers.indexOf(w.tier) <= tiers.indexOf(input.maxTier)) && (!w.roles || w.roles.includes(role)) && (!input.story.agent || w.agent === input.story.agent) && (input.available?.(w.agent) ?? true));
     const history = readRoutingObservations().filter(e => e.projectHash === projectHash(input.root) && e.taskClass === input.assessment.taskClass && e.requiredTier === baseTier && e.role === role && e.failureKind !== 'infrastructure' && Date.now() - Date.parse(e.recordedAt) < 30 * 86400000);
     const evidence = (w) => {
-        const matching = history.filter(e => e.provider === w.agent && e.requestedModel === w.model && e.requestedReasoningEffort === w.reasoningEffort && e.actualModel);
+        const matching = history.filter(e => e.provider === w.agent && e.requestedProvider === w.provider && e.requestedModel === w.model && e.requestedReasoningEffort === w.reasoningEffort && e.requestedVariant === w.variant && e.actualModel);
         const actual = matching.at(-1)?.actualModel;
         return actual ? matching.filter(e => e.actualModel === actual) : [];
     };
@@ -68,7 +68,7 @@ export function chooseCapability(input) {
     const worker = reliable[0];
     const blocked = !worker && (input.fallback === 'block' || input.maxTier !== undefined);
     const provider = worker?.agent ?? input.story.agent ?? input.parent;
-    const selection = worker ? { model: worker.model, reasoningEffort: worker.reasoningEffort, nativeMultiAgent: false, ...(provider !== 'gemini' && provider !== 'qwen' && input.parentSelection?.bare !== undefined ? { bare: input.parentSelection.bare } : {}) }
+    const selection = worker ? { provider: worker.provider, model: worker.model, reasoningEffort: worker.reasoningEffort, variant: worker.variant, nativeMultiAgent: false, ...(provider !== 'gemini' && provider !== 'qwen' && provider !== 'pi' && input.parentSelection?.bare !== undefined ? { bare: input.parentSelection.bare } : {}) }
         : { ...(provider === input.parent ? input.parentSelection : {}), nativeMultiAgent: false };
     const reason = `${role}: ${tiers[level]}; ${input.assessment.reason}${failures.length ? `; ${failures.length} verified failure(s), ${failures.length === 1 ? 'one targeted repair' : 'escalated'}` : ''}${worker ? '' : '; no eligible profile, parent/provider fallback'}`;
     return { worker, provider, selection, reason: blocked ? `${role}: no eligible profile within routing limits; execution blocked` : reason, blocked, requiredTier: baseTier, selectedTier: tiers[level], failures: failures.length, exhausted, next: input.maxTier && level >= tiers.indexOf(input.maxTier) ? 'stop at configured tier limit' : level < 3 ? tiers[level + 1] : 'stop after bounded attempts' };

package/dist/routing/planning.js

@@ -4,8 +4,10 @@ export function resolvePlanner(config, start, selection = {}, override) {
     const inherited = agent === start ? selection : {};
     const planning = !override || override === (config?.planning?.agent ?? start) ? config?.planning : undefined;
     return { agent, selection: {
+            provider: planning?.provider ?? inherited.provider,
             model: planning?.model ?? inherited.model,
             reasoningEffort: planning?.reasoningEffort ?? inherited.reasoningEffort,
+            variant: planning?.variant ?? inherited.variant,
             bare: inherited.bare,
             nativeMultiAgent: false,
         } };

package/dist/routing/registry.js

@@ -68,8 +68,10 @@ export function historyForWorkers(workers) {
         // Capability evidence belongs to the provider/model that produced it. This
         // prevents a reused worker id from inheriting scores from a retired model.
         if (event.provider !== worker.agent
+            || event.requestedProvider !== worker.provider
             || event.requestedModel !== worker.model
-            || event.requestedReasoningEffort !== worker.reasoningEffort)
+            || event.requestedReasoningEffort !== worker.reasoningEffort
+            || event.requestedVariant !== worker.variant)
             continue;
         if (typeof event.verificationSuccess !== 'boolean')
             continue;

package/dist/routing/router.js

@@ -101,8 +101,10 @@ function callUsage(role, provider, selection, tokens, durationMs, profile) {
         role,
         provider,
         ...(profile ? { profile } : {}),
+        ...(selection.provider ? { requestedProvider: selection.provider } : {}),
         ...(selection.model ? { requestedModel: selection.model } : {}),
         ...(selection.reasoningEffort ? { requestedReasoningEffort: selection.reasoningEffort } : {}),
+        ...(selection.variant ? { requestedVariant: selection.variant } : {}),
         ...(tokens?.model ? { actualModel: tokens.model } : {}),
         inputTokens: tokens?.inputTokens ?? 0,
         ...(tokens?.cachedInputTokens !== undefined ? { cachedInputTokens: tokens.cachedInputTokens } : {}),
@@ -191,7 +193,7 @@ function routingSteps(options) {
             if (!assessment)
                 return { success: false, summary: 'Routing assessment unavailable or invalid; implementation was not started', tokens: aggregateCalls(calls), routing: { recordOutcome: () => undefined, blocked: true } };
             const choice = chooseCapability({ root, story: ctx.story, assessment, workers: eligibleWorkers, parent: options.parent, parentSelection: options.parentSelection, maxAttempts: options.maxAttempts, fallback: options.fallback, maxTier: options.maxTier });
-            options.onDecision?.(ctx.story.id, { profile: choice.worker?.id ?? 'SELF', provider: choice.provider, model: choice.selection.model, reasoningEffort: choice.selection.reasoningEffort, reason: choice.reason, next: choice.next, assessment });
+            options.onDecision?.(ctx.story.id, { profile: choice.worker?.id ?? 'SELF', provider: choice.provider, model: choice.selection.model, reasoningEffort: choice.selection.reasoningEffort, variant: choice.selection.variant, providerModel: choice.selection.provider, reason: choice.reason, next: choice.next, assessment });
             if (choice.blocked)
                 return { ...blocked(choice.reason), tokens: aggregateCalls(calls) };
             if (choice.exhausted)
@@ -209,7 +211,7 @@ function routingSteps(options) {
                             return;
                         recorded = true;
                         recordRoutingObservation({ projectHash: projectHash(root), storyHash: storyHash(projectHash(root), ctx.story.id), assessmentKey: routingAssessmentKey(root, ctx.story), taskClass: assessment.taskClass, requiredTier: choice.requiredTier,
-                            role: 'implementation', strategy: 'capability', selected: choice.worker?.id ?? 'SELF', provider: choice.provider, requestedModel: choice.selection.model, requestedReasoningEffort: choice.selection.reasoningEffort,
+                            role: 'implementation', strategy: 'capability', selected: choice.worker?.id ?? 'SELF', provider: choice.provider, requestedProvider: choice.selection.provider, requestedModel: choice.selection.model, requestedReasoningEffort: choice.selection.reasoningEffort, requestedVariant: choice.selection.variant,
                             actualModel: result.tokens?.model, orchestratorProvider: options.planner?.agent ?? options.parent, orchestratorModel: (options.planner?.selection ?? options.parentSelection)?.model, orchestratorDurationMs: calls.filter(c => c.role === 'orchestrator').reduce((s, c) => s + c.durationMs, 0), workerDurationMs: calls[calls.length - 1].durationMs,
                             processSuccess: result.success, verificationSuccess: infrastructureFailure ? false : verified, failureKind: infrastructureFailure ? 'infrastructure' : failureKind ?? 'implementation', usageAvailable: result.tokens !== undefined && result.tokens.measurementComplete !== false,
                             inputTokens: result.tokens?.inputTokens ?? 0, outputTokens: result.tokens?.outputTokens ?? 0, totalCostUsd: result.tokens?.totalCostUsd });
@@ -247,7 +249,7 @@ function routingSteps(options) {
             return blocked('Selected routing profile exceeds configured limits; execution blocked');
         const provider = worker?.agent ?? options.parent;
         const selection = worker
-            ? { model: worker.model, reasoningEffort: worker.reasoningEffort, nativeMultiAgent: false, ...(provider !== 'gemini' && provider !== 'qwen' ? { bare: options.parentSelection?.bare } : {}) }
+            ? { provider: worker.provider, model: worker.model, reasoningEffort: worker.reasoningEffort, variant: worker.variant, nativeMultiAgent: false, ...(provider !== 'gemini' && provider !== 'qwen' && provider !== 'pi' ? { bare: options.parentSelection?.bare } : {}) }
             : { ...(options.parentSelection ?? {}), nativeMultiAgent: false };
         const workerStarted = now();
         const result = yield () => makeWorker(provider, selection)(ctx);
@@ -296,6 +298,8 @@ function routingSteps(options) {
                 provider,
                 ...(selection.model ? { requestedModel: selection.model } : {}),
                 ...(selection.reasoningEffort ? { requestedReasoningEffort: selection.reasoningEffort } : {}),
+                ...(selection.provider ? { requestedProvider: selection.provider } : {}),
+                ...(selection.variant ? { requestedVariant: selection.variant } : {}),
                 ...(result.tokens?.model ? { actualModel: result.tokens.model } : {}),
                 orchestratorProvider: options.parent,
                 ...(orchestratorSelection.model ? { orchestratorModel: orchestratorSelection.model } : {}),

package/dist/setup/command.js

@@ -7,7 +7,8 @@ import { applyActions } from '../retrofit/apply.js';
 import { join } from 'node:path';
 import { modelPresetWorkers, planModelPresets } from './model-presets.js';
 import { runRetrofit } from '../retrofit/command.js';
-const ALL_AGENTS = ['claude', 'codex', 'gemini', 'qwen'];
+import { SUPPORTED_AGENTS } from '../agents/catalog.js';
+const ALL_AGENTS = [...SUPPORTED_AGENTS];
 export function defaultRoutingWorkers(agents) {
     const workers = {
         claude: [
@@ -32,6 +33,15 @@ export function defaultRoutingWorkers(agents) {
             // Respect the user's Qwen Code account/model. API presets are opt-in.
             { id: 'qwen-standard', agent: 'qwen', tier: 'standard', costTier: 'medium', capabilities: ['implementation'] },
         ],
+        opencode: [
+            { id: 'opencode-standard', agent: 'opencode', tier: 'standard', costTier: 'medium', capabilities: ['implementation'] },
+        ],
+        kilo: [
+            { id: 'kilo-standard', agent: 'kilo', tier: 'standard', costTier: 'medium', capabilities: ['implementation'] },
+        ],
+        pi: [
+            { id: 'pi-standard', agent: 'pi', tier: 'standard', costTier: 'medium', capabilities: ['implementation'] },
+        ],
     };
     return agents.flatMap(agent => workers[agent]);
 }
@@ -85,12 +95,12 @@ export async function runSetup(targetDir, opts = {}) {
         let decisionPolicy = defaultPolicy;
         let routing = defaultRouting;
         if (interactive && ask) {
-            agents = parseAgents(await ask(`Agents [${defaultAgents.join(',')}] (claude,codex,gemini,qwen|all): `), defaultAgents);
+            agents = parseAgents(await ask(`Agents [${defaultAgents.join(',')}] (${SUPPORTED_AGENTS.join(',')}|all): `), defaultAgents);
             const graphAnswer = (await ask(`Code graph [${defaultGraph}] (graphify|serena): `)).trim().toLowerCase();
             if (graphAnswer === 'graphify' || graphAnswer === 'serena')
                 codeGraph = graphAnswer;
             loop = yes(await ask(`Enable autonomous loop? [${defaultLoop ? 'yes' : 'no'}]: `), defaultLoop);
-            const runnerAnswer = (await ask(`Default runner [${runner}] (claude|codex|gemini|qwen): `)).trim().toLowerCase();
+            const runnerAnswer = (await ask(`Default runner [${runner}] (${SUPPORTED_AGENTS.join('|')}): `)).trim().toLowerCase();
             if (ALL_AGENTS.includes(runnerAnswer))
                 runner = runnerAnswer;
             const policyAnswer = (await ask(`Decision mode [${decisionPolicy}] (auto|critical): `)).trim().toLowerCase();

package/docs/DASHBOARD-EVOLUTION.md

@@ -1,6 +1,6 @@
 # Dashboard evolution
 
-The local dashboard is an actionable workspace for registered Yoke projects. It reads the same saved project, loop, goal, acceptance, and measurement data as the CLI. Project-controlled text is rendered through `textContent`, and the server remains bound to the loopback interface with same-origin authorization for pause requests.
+The local dashboard is an actionable control room for registered Yoke projects. It reads the same saved project, loop, goal, acceptance, and measurement data as the CLI. Project-controlled text is rendered through `textContent`, and the server remains bound to the loopback interface with same-origin session authorization for typed controls. The full feature contract is in [DASHBOARD-OVERHAUL.md](DASHBOARD-OVERHAUL.md).
 
 ## Overview
 
@@ -10,14 +10,28 @@ Cards also show the reported current task and saved blocker reason when availabl
 
 An active loop report more than 20 minutes old is labeled **unconfirmed**. This means Yoke has an old active report, not evidence that the process is still live. The overview can be searched by project name, canonical path, or goal objective and filtered to All, Active, or Needs attention. A no-match state explains the result and provides a clear action that resets both search and filter.
 
+## Workspace control room
+
+The overview ranks projects by attention, last activity, recorded tokens, reported cost, accepted work, or name. Search and status filters compose with the ranking, and the validated URL hash preserves the selected screen and time scope. A project row opens the live view without losing the operator’s navigation context.
+
+The project live view shows goal and loop state independently, freshness, current worker metadata, objective progress, last successful sync, pause/resume actions at the existing safe boundary, an operator-note form, a queued-change form, and a bounded expandable event timeline. Notes are append-only events. Changes become pending inbox requests and are consumed by the existing planning boundary; the browser cannot run arbitrary commands.
+
+## Measurement coverage
+
+The dashboard labels recorded, partial, unknown, stale, corrupt, unavailable, and empty data separately. **Measurement coverage** is always shown alongside analytics: missing provider usage or price is not reconstructed, and a missing bucket means no recorded activity rather than a measured zero. A stale active report is shown as unconfirmed, not healthy.
+
 ## Durable navigation
 
-The URL hash stores the current screen, project, project tab, period, UTC grouping, and complete custom date range. Supported screens are the overview, workspace comparison, and project detail. Supported project tabs are Now, Usage & time, and Results; periods are 1, 7, 30, 90, or 365 days; groupings are day, week, or month. Custom dates must be real ISO calendar dates in chronological order and cover at most 366 inclusive days.
+The URL hash stores the current screen, project, project tab, period, UTC grouping, ranking/filter state, and complete custom date range. Supported screens are the overview, workspace analytics, and project detail. Supported project tabs are Now, Usage & time, Results, and History; periods are 1, 7, 30, 90, or 365 days; groupings are day, week, or month. Custom dates must be real ISO calendar dates in chronological order and cover at most 366 inclusive days.
 
 Invalid hash state returns to the overview with the 30-day/day defaults. Browser back and forward, a page reload, and Refresh restore the validated state. Refresh reloads data without resetting the selected view or controls. Starting any navigation aborts earlier fetches and changes a request generation, so an older response cannot replace the current screen.
 
 The workspace comparison schedules at most three project analytics requests at once. If navigation changes, in-flight fetches are aborted and no additional obsolete project requests are scheduled. All projects and individual project links remain available in the navigation while viewing the comparison.
 
+## Analytics and history
+
+Workspace and project analytics expose time-bucketed recorded tokens, calls, duration, outcomes, cost state, and rankings by agent, provider, model, variant, role, phase, project, and run. The history explorer exposes at most 100 events in chronological order and identifies run, story, phase, agent/provider/model metadata, local time, and UTC time when recorded. Unknown values remain unknown; no chart or comparison converts missing measurements to zero.
+
 ## Usage comparisons
 
 Usage & time compares the selected period with the immediately preceding period of exactly the same duration. A single time boundary is captured before either analytics request is made. The comparison covers recorded input plus output tokens, recorded acceptance events, and reported cost.

package/docs/DASHBOARD-OVERHAUL.md

@@ -0,0 +1,146 @@
+# Dashboard Overhaul: Feature Contract
+
+Status: approved implementation scope
+Date: 2026-09-08
+
+This document turns the dashboard request into executable product definitions.
+Each feature below has a bounded behavior, source of truth, safety rule, and
+acceptance proof. It is an implementation contract, not a list of future ideas.
+
+## North star
+
+Yoke Dashboard is a local-first operations console for autonomous work. A user
+can move from workspace-level ranking to one run, understand what happened,
+intervene safely at a loop boundary, and leave a durable note or change request
+without interrupting the worker or inventing a second execution path.
+
+## Feature definitions
+
+### F1 — Unified workspace control room
+
+The overview loads all registered projects into one ranked workspace. Each row
+shows project identity, current state, freshness, objective, last activity,
+latest run, token totals, cost coverage, accepted/failed outcome, and the next
+available safe action. A project can be sorted by attention, active state, last
+activity, token usage, cost, acceptance, or name. Search and status filters are
+composable and persist in navigation state.
+
+Source: registry, goal/loop snapshots, events, history measurements, and checks.
+
+Rule: missing projects and partial telemetry remain visible; an unknown metric
+never becomes zero.
+
+### F2 — Historical telemetry and rankings
+
+The dashboard exposes a selectable date range and bucket (day, week, month) for
+workspace and project views. It aggregates input, output, cached, cache-write,
+reasoning, total tokens, measured/unknown calls, attempts, accepted runs,
+repairs, escalations, elapsed time, and reported cost. It ranks projects,
+agents, providers, models, roles, phases, and runs, with measurement coverage
+shown alongside every aggregate.
+
+Source: durable history archives plus bounded live events.
+
+Rule: aggregation is deterministic and bounded; corrupt archives are reported
+as coverage gaps, not silently discarded or counted as zero.
+
+### F3 — Run explorer and event timeline
+
+A project detail view provides a run list and a chronological timeline. Users can
+expand an event to inspect run/attempt/story/phase identifiers, agent metadata,
+token fields, outcome, and source timestamp. The view supports the same date
+range and an explicit “live” scope.
+
+Source: event stream and history records, joined by run ID where available.
+
+Rule: show UTC and local time clearly; bound event and archive reads; stale live
+data is labeled unconfirmed.
+
+### F4 — Safe live controls
+
+The selected project has pause and resume controls. Pause uses Yoke’s existing
+`.yoke/loop.pause` and `.yoke/goal.pause` safe-boundary mechanisms. Resume calls
+the existing loop/goal runner with one guarded invocation and respects the loop
+lock; it never starts a duplicate worker. The UI reports requested, running,
+paused, blocked, and failed-to-start states separately.
+
+Rule: all writes require loopback same-origin plus the dashboard session token.
+No action accepts a filesystem path or shell string from the browser.
+
+### F5 — Operator notes and queued changes
+
+While work runs, a user can append a short operator note or queue a typed change
+request. Notes are append-only and displayed in the timeline. Change requests
+reuse Yoke’s existing append-only change inbox and are processed at its normal
+safe planning boundary. The UI shows pending/applied state and the request ID.
+
+Rule: notes and changes are never executed as shell commands. Input is bounded,
+validated, escaped on render, and retained as project-local operational history.
+
+### F6 — Theme, density, and responsive access
+
+Dark and light themes use the design tokens in `DESIGN.md`; first load respects
+system preference, then remembers the user’s choice. The shell works at desktop,
+tablet, and narrow widths. Tables remain scannable through column priorities,
+horizontal overflow where necessary, and accessible labels.
+
+Rule: contrast, focus, reduced motion, keyboard navigation, and non-color status
+signals are tested; visual polish cannot hide loading, empty, error, or stale
+states.
+
+### F7 — Honest operational states
+
+Every live panel shows last successful sync, source scope, and data coverage.
+Active-but-stale work becomes “unconfirmed”; unavailable costs/tokens are
+explicit. Corrupt project files produce an actionable per-project error without
+breaking the workspace view.
+
+Rule: the dashboard never claims process health merely because a status file says
+running; freshness and source errors are part of the displayed state.
+
+### F8 — Stable local API contract
+
+The server provides bounded, same-origin JSON for workspace overview, project
+snapshot, project history/events, and typed controls. Responses are safe to
+render as untrusted project text. Query ranges, limits, sort keys, and action
+payloads are schema-validated.
+
+Rule: preserve existing routes where possible, keep the server loopback-only,
+and add tests for authorization, path safety, malformed input, concurrency, and
+partial history.
+
+## Delivery slices
+
+The Yoke loop executes these slices in dependency order:
+
+1. Contract, design tokens, shared telemetry/control types, and API helpers.
+2. Historical aggregation, run/event projections, and workspace endpoints.
+3. Typed operator controls, append-only notes, and guarded resume.
+4. New shell, theme system, workspace ranking, and responsive state components.
+5. Project live view, controls, timeline, notes, and queued changes.
+6. Analytics/history explorer with all rankings and coverage explanations.
+7. Accessibility, loading/error/empty/stale states, performance bounds, and
+   focused regression tests.
+8. README/docs synchronization and final integrated verification.
+
+## Non-goals for this release
+
+- Remote multi-user access, accounts, or cloud storage.
+- Arbitrary shell execution from the browser.
+- Replacing the loop, goal runner, provider routing, or lock protocol.
+- Fabricating historical metrics that were not recorded.
+- A second real-time transport dependency; polling with freshness indicators is
+  sufficient for the local-first release.
+
+## Acceptance checklist
+
+- A workspace user can rank projects by attention, activity, tokens, cost, and
+  name and open a project without losing filters.
+- A project user can inspect a bounded historical run/event view and identify
+  agent/provider/model/role/phase/time when recorded.
+- A project user can pause at the existing safe boundary, resume without a
+  duplicate loop, add a note, and queue a change request from the UI.
+- Dark/light themes, keyboard focus, responsive layout, and reduced motion work.
+- Partial, unknown, stale, corrupt, and missing data are explicit and isolated.
+- Existing dashboard security and tests remain green; new behavior has focused
+  tests plus build/lint coverage.

package/docs/HARNESSES.md

@@ -0,0 +1,81 @@
+# OpenCode, Kilo and Pi
+
+Yoke 1.13.0 adds first-class adapters for OpenCode, Kilo and Pi coding agent. The adapters share Yoke's invocation, routing, review, quality, telemetry and retrofit contracts, while preserving the controls each harness actually provides.
+
+This is a CLI integration, not an authentication bundle. Install the selected harness, log in or configure its API provider, and verify it independently before starting a Yoke loop.
+
+## Setup and retrofit
+
+Select one of the new harnesses explicitly:
+
+```sh
+yoke setup . --yes --agent=opencode --runner=opencode
+yoke setup . --yes --agent=kilo --runner=kilo
+yoke setup . --yes --agent=pi --runner=pi
+```
+
+To add one to an existing project without changing the other generated artifacts:
+
+```sh
+yoke retrofit . --agent=opencode
+yoke retrofit . --agent=kilo
+yoke retrofit . --agent=pi
+```
+
+`--agent=all` now includes all seven supported harnesses. Retrofit is merge-aware for the native config files and backs up Yoke-managed overwrites under `.yoke/backup/`.
+
+## Native artifacts
+
+| Harness | Generated project artifacts | Native capabilities used by Yoke |
+|---|---|---|
+| OpenCode | `AGENTS.md`, `.opencode/skills/`, `opencode.json`, `.opencode/agents/yoke-reviewer.md` | `run --format json`, provider/model selection, variants, plan agent, local MCP servers |
+| Kilo | `AGENTS.md`, `.kilo/skills/`, `kilo.jsonc`, `.kilo/agents/yoke-reviewer.md` | OpenCode-compatible `run --format json`, provider/model selection, variants, plan agent, local MCP servers |
+| Pi | `AGENTS.md`, `.pi/skills/`, `.pi/settings.json` | JSONL mode, provider/model selection, thinking level, explicit tool allowlists |
+
+All three consume the shared `AGENTS.md` and `.yoke/context/*.md` context. OpenCode and Kilo also receive the configured local MCP servers from the Yoke code-graph choice. Pi has no native MCP or sub-agent layer, so its integration intentionally uses the portable skills and Yoke's own loop rather than pretending those features exist.
+
+## Provider, model and variant selection
+
+Yoke keeps the harness (`agent`) separate from the model provider (`provider`) and model identifier (`model`):
+
+```yaml
+runner:
+  agent: opencode
+  provider: openrouter
+  model: openai/gpt-5.6
+  variant: high
+```
+
+For OpenCode and Kilo this becomes `--model openrouter/openai/gpt-5.6 --variant high`. If no explicit provider is configured, a model string already in the harness's `provider/model` form is passed through unchanged. For Pi the equivalent is:
+
+```yaml
+runner:
+  agent: pi
+  provider: openai
+  model: gpt-5.6
+  reasoningEffort: high
+```
+
+This becomes `--provider openai --model gpt-5.6 --thinking high`. Pi calls `variant` and `reasoningEffort` the same underlying thinking-level selection; configuring both with different values is rejected.
+
+The same fields are available on routing workers and quality critic/repair roles. Routing evidence is keyed by harness, provider, model, reasoning effort and variant, so a model profile does not inherit another profile's success history.
+
+## Permission profiles and honest limits
+
+| Yoke profile | OpenCode / Kilo | Pi |
+|---|---|---|
+| `safe` | Headless `--auto` run; Yoke still verifies the resulting tree and gates the commit | `read,bash,edit,write` tool allowlist so the implementer can test and modify the project |
+| `read-only` | `--agent plan` plus JSON output | `read,grep,find,ls` only |
+| `unsafe` | Explicit `--dangerously-skip-permissions` | Harness default tool set; no Yoke-added allowlist |
+
+OpenCode, Kilo and Pi do not provide the same OS-level sandbox boundary as Codex or Gemini. The Yoke `safe` label therefore describes the selected harness controls and Yoke's mechanical gates, not a universal filesystem sandbox. Use `read-only` for review and do not use `unsafe` unless the project owner accepts the boundary.
+
+The Yoke loop disables native delegation where the harness exposes it, so Yoke's worker budget remains the authority. OpenCode and Kilo native agents are installed as a read-only reviewer artifact; Yoke's review runner still validates the structured verdict itself. Pi has no native sub-agent or plan mode by design.
+
+## Telemetry and validation limits
+
+Yoke parses OpenCode/Kilo JSON text events and `step_finish` token/cost events, and Pi `message_end` plus `message_update.usage` events. Missing provider events produce partial or unknown measurements; they are never reported as zero-cost success. Provider-reported model and usage remain provider claims.
+
+The release test suite covers argument construction, provider/variant propagation, routing and quality configuration, retrofit plans, host detection, JSON result parsing, and representative telemetry fixtures. It does not authenticate against every provider or claim equal model quality. Run a small project-specific smoke task after installing a harness and configuring credentials.
+
+Official CLI references: [OpenCode CLI](https://dev.opencode.ai/docs/cli), [OpenCode configuration](https://opencode.ai/docs/config), [OpenCode skills](https://opencode.ai/docs/skills), [Kilo CLI reference](https://github.com/Kilo-Org/kilocode/blob/main/packages/kilo-docs/pages/code-with-ai/platforms/cli-reference.md), and [Pi coding agent](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/README.md).

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "yoke",
-  "version": "1.12.0",
-  "description": "Cross-agent coding harness: curated skill canon, mechanical safety gates, autonomous loop with proof artifacts. CLI: npm i -g @hecer/yoke",
+  "version": "1.14.0",
+  "description": "Cross-agent coding harness for seven supported CLIs: curated skill canon, mechanical safety gates, autonomous loop with proof artifacts. CLI: npm i -g @hecer/yoke",
   "contextFileName": "GEMINI-EXTENSION.md"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hecer/yoke",
-  "version": "1.12.0",
-  "description": "One harness, four agents, zero trust in \"done\" — cross-agent coding harness for Claude Code, Codex CLI, Gemini CLI, and Qwen Code: one skill canon, mechanical safety gates, an autonomous loop with screenshot/video proofs.",
+  "version": "1.14.0",
+  "description": "One harness, seven agents, zero trust in \"done\" — cross-agent coding harness for Claude Code, Codex CLI, Gemini CLI, Qwen Code, OpenCode, Kilo and Pi: one skill canon, mechanical safety gates, an autonomous loop with screenshot/video proofs.",
   "type": "module",
   "bin": {
     "yoke": "dist/cli.js"
@@ -45,6 +45,10 @@
     "claude-code",
     "codex",
     "gemini-cli",
+    "qwen-code",
+    "opencode",
+    "kilo",
+    "pi-coding-agent",
     "agents",
     "agentic-coding",
     "harness",