@hecer/yoke 1.12.0 → 1.13.0

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/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.13.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.13.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",