@hecer/yoke 1.11.0 → 1.13.0

package/dist/retrofit/planners/kilo.js

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadManifest } from '../../canon/manifest.js';
+import { openCodeMcpServers, rtkInstruction } from '../tools.js';
+import { PRESERVE_SCAFFOLD } from '../preserve.js';
+import { skillPackageActions } from '../skill-actions.js';
+const reviewerAgent = `---
+description: Read-only Yoke reviewer for correctness and acceptance criteria
+mode: primary
+permission:
+  edit: deny
+  write: deny
+  bash: deny
+---
+
+Review the observed diff and test evidence. Do not modify files. Return only actionable findings grounded in evidence.
+`;
+export function planKilo(canonDir, _targetDir, codeGraph = 'graphify') {
+    const manifest = loadManifest(join(canonDir, 'manifest.yaml'));
+    const baseline = readFileSync(join(canonDir, 'AGENTS.md'), 'utf8');
+    const actions = manifest.skills.flatMap(skill => skillPackageActions(canonDir, skill, 'kilo'));
+    actions.push({
+        kind: 'write',
+        target: 'AGENTS.md',
+        content: `${baseline.trimEnd()}\n\n${rtkInstruction()}\n\n${PRESERVE_SCAFFOLD}\n`,
+        reason: 'baseline instructions (Kilo reads AGENTS.md natively)',
+    }, {
+        kind: 'write',
+        target: 'kilo.jsonc',
+        merge: true,
+        content: JSON.stringify({
+            $schema: 'https://app.kilo.ai/config.json',
+            instructions: ['AGENTS.md', '.yoke/context/*.md'],
+            mcp: openCodeMcpServers(codeGraph),
+        }, null, 2) + '\n',
+        reason: 'Kilo instructions + MCP servers',
+    }, {
+        kind: 'write',
+        target: '.kilo/agents/yoke-reviewer.md',
+        content: reviewerAgent,
+        reason: 'Kilo read-only reviewer agent',
+    });
+    return actions;
+}

package/dist/retrofit/planners/opencode.js

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadManifest } from '../../canon/manifest.js';
+import { openCodeMcpServers, rtkInstruction } from '../tools.js';
+import { PRESERVE_SCAFFOLD } from '../preserve.js';
+import { skillPackageActions } from '../skill-actions.js';
+const reviewerAgent = `---
+description: Read-only Yoke reviewer for correctness and acceptance criteria
+mode: primary
+tools:
+  edit: false
+  write: false
+  bash: false
+---
+
+Review the observed diff and test evidence. Do not modify files. Return only actionable findings grounded in evidence.
+`;
+export function planOpenCode(canonDir, _targetDir, codeGraph = 'graphify') {
+    const manifest = loadManifest(join(canonDir, 'manifest.yaml'));
+    const baseline = readFileSync(join(canonDir, 'AGENTS.md'), 'utf8');
+    const actions = manifest.skills.flatMap(skill => skillPackageActions(canonDir, skill, 'opencode'));
+    actions.push({
+        kind: 'write',
+        target: 'AGENTS.md',
+        content: `${baseline.trimEnd()}\n\n${rtkInstruction()}\n\n${PRESERVE_SCAFFOLD}\n`,
+        reason: 'baseline instructions (OpenCode reads AGENTS.md natively)',
+    }, {
+        kind: 'write',
+        target: 'opencode.json',
+        merge: true,
+        content: JSON.stringify({
+            $schema: 'https://opencode.ai/config.json',
+            instructions: ['AGENTS.md', '.yoke/context/*.md'],
+            mcp: openCodeMcpServers(codeGraph),
+        }, null, 2) + '\n',
+        reason: 'OpenCode instructions + MCP servers',
+    }, {
+        kind: 'write',
+        target: '.opencode/agents/yoke-reviewer.md',
+        content: reviewerAgent,
+        reason: 'OpenCode read-only reviewer agent',
+    });
+    return actions;
+}

package/dist/retrofit/planners/pi.js

@@ -0,0 +1,24 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadManifest } from '../../canon/manifest.js';
+import { rtkInstruction } from '../tools.js';
+import { PRESERVE_SCAFFOLD } from '../preserve.js';
+import { skillPackageActions } from '../skill-actions.js';
+export function planPi(canonDir, _targetDir, _codeGraph = 'graphify') {
+    const manifest = loadManifest(join(canonDir, 'manifest.yaml'));
+    const baseline = readFileSync(join(canonDir, 'AGENTS.md'), 'utf8');
+    const actions = manifest.skills.flatMap(skill => skillPackageActions(canonDir, skill, 'pi'));
+    actions.push({
+        kind: 'write',
+        target: 'AGENTS.md',
+        content: `${baseline.trimEnd()}\n\n${rtkInstruction()}\n\n## Pi integration\n\nPi has no MCP or native sub-agent layer; use the installed Yoke skills and the explicit Yoke loop for orchestration.\n\n${PRESERVE_SCAFFOLD}\n`,
+        reason: 'baseline instructions (Pi reads AGENTS.md natively)',
+    }, {
+        kind: 'write',
+        target: '.pi/settings.json',
+        merge: true,
+        content: JSON.stringify({ skills: ['.pi/skills'] }, null, 2) + '\n',
+        reason: 'Pi project skill discovery',
+    });
+    return actions;
+}

package/dist/retrofit/planners/qwen.js

@@ -47,8 +47,8 @@ export function planQwen(canonDir, _targetDir, codeGraph = 'graphify') {
     actions.push({
         kind: 'write',
         target: '.qwen/hooks/qwen-rtk-hook.mjs',
-        content: readFileSync(join(canonDir, 'tools/gemini-rtk-hook.mjs'), 'utf8'),
-        reason: 'portable RTK BeforeTool argument adapter',
+        content: readFileSync(join(canonDir, 'tools/qwen-rtk-hook.mjs'), 'utf8'),
+        reason: 'portable RTK PreToolUse retry guard',
     });
     // Merge to preserve user MCP servers, context and unrelated hooks.
     actions.push({
@@ -58,7 +58,7 @@ export function planQwen(canonDir, _targetDir, codeGraph = 'graphify') {
         content: JSON.stringify({
             mcpServers: mcpServers(codeGraph),
             context: { fileName: ['AGENTS.md', 'QWEN.md'] },
-            hooks: { BeforeTool: [{ matcher: '^run_shell_command$', hooks: [{ name: 'yoke-rtk', type: 'command', command: 'node .qwen/hooks/qwen-rtk-hook.mjs' }] }] },
+            hooks: { PreToolUse: [{ matcher: '^run_shell_command$', hooks: [{ name: 'yoke-rtk', type: 'command', command: 'node .qwen/hooks/qwen-rtk-hook.mjs' }] }] },
         }, null, 2) + '\n',
         reason: 'MCP servers + AGENTS.md context',
     });

package/dist/retrofit/preserve.js

@@ -1,7 +1,7 @@
 export const PRESERVE_START = '<!-- yoke:preserve:start -->';
 export const PRESERVE_END = '<!-- yoke:preserve:end -->';
-export const PRESERVE_SCAFFOLD = `${PRESERVE_START}
-<!-- Project-specific instructions go here. Yoke keeps this block across retrofits. -->
+export const PRESERVE_SCAFFOLD = `${PRESERVE_START}
+<!-- Project-specific instructions go here. Yoke keeps this block across retrofits. -->
 ${PRESERVE_END}`;
 /**
  * Extract the inner content of every balanced preserve-marker pair, in order.

package/dist/retrofit/qwen-settings.js

@@ -0,0 +1,17 @@
+import { mergeJson } from './merge-json.js';
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/** Remove only Yoke 1.11's inert Gemini-shaped hook, preserving unrelated hooks. */
+export function mergeQwenSettings(current, incoming) {
+    if (!record(current) || !record(current.hooks) || !Array.isArray(current.hooks.BeforeTool))
+        return mergeJson(current, incoming);
+    const beforeTool = current.hooks.BeforeTool.flatMap(group => {
+        if (!record(group) || group.matcher !== '^run_shell_command$' || !Array.isArray(group.hooks))
+            return [group];
+        const hooks = group.hooks.filter(hook => !(record(hook) && hook.name === 'yoke-rtk' && hook.type === 'command' && hook.command === 'node .qwen/hooks/qwen-rtk-hook.mjs'));
+        return hooks.length ? [{ ...group, hooks }] : [];
+    });
+    const hooks = { ...current.hooks, BeforeTool: beforeTool };
+    if (!beforeTool.length)
+        delete hooks.BeforeTool;
+    return mergeJson({ ...current, hooks }, incoming);
+}

package/dist/retrofit/skill-actions.js

@@ -5,6 +5,9 @@ const roots = {
     codex: '.agents/skills',
     gemini: '.gemini/skills',
     qwen: '.qwen/skills',
+    opencode: '.opencode/skills',
+    kilo: '.kilo/skills',
+    pi: '.pi/skills',
 };
 function manualClaudeSkill(content, skill) {
     const source = content.toString('utf8');
@@ -49,7 +52,7 @@ export function skillPackageActions(canonDir, skill, provider) {
         .map(file => ({
         kind: 'write',
         target: `${roots[provider]}/${skill.id}/${file.relativePath}`,
-        content: provider === 'claude' && skill.invocation === 'manual' && file.relativePath === 'SKILL.md'
+        content: (provider === 'claude' || provider === 'qwen') && skill.invocation === 'manual' && file.relativePath === 'SKILL.md'
             ? manualClaudeSkill(file.content, skill)
             : portableContent(file),
         executable: file.executable,

package/dist/retrofit/tools.js

@@ -14,6 +14,14 @@ export function mcpServers(codeGraph = 'graphify') {
         playwright: { command: 'npx', args: ['@playwright/mcp@latest'] },
     };
 }
+/** OpenCode-family CLIs use an object with a local command array, not Claude's mcpServers shape. */
+export function openCodeMcpServers(codeGraph = 'graphify') {
+    return Object.fromEntries(Object.entries(mcpServers(codeGraph)).map(([name, server]) => [name, {
+            type: 'local',
+            command: [server.command, ...server.args],
+            enabled: true,
+        }]));
+}
 // rtk has no transparent-rewrite hook on Codex/Gemini; those agents get this
 // instruction instead. On Claude (Windows) it is also the WSL-less fallback.
 export function rtkInstruction() {

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

@@ -1,10 +1,14 @@
 import { createInterface } from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { detectHostAgent } from '../agents/host.js';
-import { loadConfig, saveConfig } from '../retrofit/config.js';
+import { loadConfig, saveConfig, YokeConfigSchema } from '../retrofit/config.js';
 import { detectProject } from '../retrofit/detect.js';
+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: [
@@ -26,10 +30,17 @@ export function defaultRoutingWorkers(agents) {
             { id: 'gemini-frontier', agent: 'gemini', model: 'gemini-2.5-pro', tier: 'frontier', costTier: 'high', capabilities: ['architecture'] },
         ],
         qwen: [
-            { id: 'qwen-light', agent: 'qwen', model: 'qwen-turbo-latest', tier: 'light', costTier: 'low', capabilities: ['mechanical', 'tests'] },
-            { id: 'qwen-standard', agent: 'qwen', model: 'qwen3-coder-plus', tier: 'standard', costTier: 'medium', capabilities: ['implementation'] },
-            { id: 'qwen-strong', agent: 'qwen', model: 'qwen3-coder-plus', tier: 'strong', costTier: 'medium', capabilities: ['debugging'] },
-            { id: 'qwen-frontier', agent: 'qwen', model: 'qwen3-235b-a22b', tier: 'frontier', costTier: 'high', capabilities: ['architecture'] },
+            // 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]);
@@ -50,6 +61,9 @@ function yes(value, fallback) {
 }
 export async function runSetup(targetDir, opts = {}) {
     const existing = loadConfig(targetDir);
+    const modelProviders = opts.modelProviders ?? [];
+    const presetActions = planModelPresets(targetDir, modelProviders);
+    const presetWorkers = modelPresetWorkers(modelProviders);
     const detected = detectProject(targetDir);
     const host = opts.host ?? detectHostAgent();
     const configuredAgents = existing?.agents.filter(a => ALL_AGENTS.includes(a)) ?? [];
@@ -59,7 +73,7 @@ export async function runSetup(targetDir, opts = {}) {
             ? configuredAgents
             : detected.agents.length > 0
                 ? detected.agents
-                : [host ?? 'claude'];
+                : modelProviders.length ? ['qwen'] : [host ?? 'claude'];
     const defaultGraph = opts.codeGraph ?? existing?.codeGraph ?? 'graphify';
     const defaultLoop = opts.loop ?? existing?.loop.enabled ?? true;
     const defaultRunner = opts.runner ?? existing?.runner?.agent ?? (host && defaultAgents.includes(host) ? host : defaultAgents[0] ?? host ?? 'claude');
@@ -81,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();
@@ -94,17 +108,26 @@ export async function runSetup(targetDir, opts = {}) {
                 decisionPolicy = policyAnswer;
             routing = yes(await ask(`Enable adaptive multi-model routing? [${defaultRouting ? 'yes' : 'no'}]: `), defaultRouting);
         }
+        if (modelProviders.length && !agents.includes('qwen'))
+            agents = [...agents, 'qwen'];
         if (!agents.includes(runner))
             agents = [...agents, runner];
         const code = runRetrofit(targetDir, { loop, agents, codeGraph, host });
         if (code !== 0)
             return code;
+        applyActions(presetActions, targetDir, { backupDir: join(targetDir, '.yoke', 'backups', `model-presets-${Date.now()}`) });
         const config = loadConfig(targetDir);
         if (!config)
             return 1;
         config.loop = { parallel: 'auto', isolate: true, ...config.loop, enabled: loop, decisionPolicy };
-        config.runner = { ...config.runner, agent: runner };
+        const priorRunner = existing?.runner?.agent ?? existing?.agents[0];
+        const selectPresetModel = presetWorkers.length > 0 && runner === 'qwen' && (!existing || (priorRunner !== undefined && priorRunner !== runner));
+        if (selectPresetModel && priorRunner !== 'qwen')
+            config.runner = { permissions: config.runner?.permissions };
+        config.runner = { ...config.runner, agent: runner, ...(selectPresetModel && !config.runner?.model ? { model: presetWorkers[0].model } : {}) };
         const existingWorkers = config.routing?.workers ?? [];
+        const baseWorkers = existingWorkers.length > 0 && !opts.routingPreset ? existingWorkers : defaultRoutingWorkers(agents).filter(worker => !modelProviders.length || worker.agent !== 'qwen');
+        const workers = [...baseWorkers, ...presetWorkers.filter(worker => !baseWorkers.some(existing => existing.id === worker.id))];
         config.routing = {
             ...config.routing,
             enabled: routing,
@@ -113,8 +136,9 @@ export async function runSetup(targetDir, opts = {}) {
             assessmentPolicy: existing?.routing?.assessmentPolicy ?? (existing ? 'on-demand' : 'prepared'),
             fallback: existing?.routing?.fallback ?? (existing ? 'parent' : 'block'),
             ...(config.routing?.orchestrator ? { orchestrator: config.routing.orchestrator } : {}),
-            workers: existingWorkers.length > 0 && !opts.routingPreset ? existingWorkers : defaultRoutingWorkers(agents),
+            workers,
         };
+        YokeConfigSchema.parse(config);
         saveConfig(targetDir, config);
         console.log(`Yoke setup complete: agents=${agents.join(',')} · runner=${runner} · loop=${loop ? 'on' : 'off'} · routing=${routing ? 'on' : 'off'} · decisions=${decisionPolicy}`);
         return 0;

package/dist/setup/model-presets.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const MODEL_PROVIDERS = ['deepseek', 'kimi'];
+const PRESETS = {
+    deepseek: {
+        baseUrl: 'https://api.deepseek.com/v1', envKey: 'DEEPSEEK_API_KEY',
+        models: [
+            { id: 'deepseek-v4-flash', workerId: 'deepseek-standard', tier: 'standard', costTier: 'low', contextWindowSize: 1_000_000 },
+            { id: 'deepseek-v4-pro', workerId: 'deepseek-strong', tier: 'strong', costTier: 'medium', contextWindowSize: 1_000_000 },
+        ],
+    },
+    kimi: {
+        baseUrl: 'https://api.moonshot.ai/v1', envKey: 'MOONSHOT_API_KEY',
+        models: [
+            { id: 'kimi-k2.6', workerId: 'kimi-standard', tier: 'standard', costTier: 'medium', contextWindowSize: 262_144 },
+            { id: 'kimi-k2.7-code', workerId: 'kimi-strong', tier: 'strong', costTier: 'medium', contextWindowSize: 262_144 },
+            { id: 'kimi-k3', workerId: 'kimi-frontier', tier: 'frontier', costTier: 'high', contextWindowSize: 1_000_000 },
+        ],
+    },
+};
+export function modelPresetWorkers(providers) {
+    return [...new Set(providers)].flatMap(provider => PRESETS[provider].models.map(model => ({
+        id: model.workerId, agent: 'qwen', model: `openai::${model.id}`, tier: model.tier,
+        costTier: model.costTier, capabilities: ['implementation'],
+    })));
+}
+/** Explicit opt-in only. Keep user routes intact; new entries contain only environment key references. */
+export function planModelPresets(targetDir, providers) {
+    if (!providers.length)
+        return [];
+    const file = join(targetDir, '.qwen/settings.json');
+    const settings = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {};
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings))
+        throw Error('Qwen settings must be an object');
+    if (settings.modelProviders !== undefined && (!settings.modelProviders || typeof settings.modelProviders !== 'object' || Array.isArray(settings.modelProviders)))
+        throw Error('Qwen modelProviders must be an object');
+    const existing = settings.modelProviders?.openai ?? [];
+    if (!Array.isArray(existing) || existing.some(model => !model || typeof model.id !== 'string'))
+        throw Error('Qwen modelProviders.openai must be an array of models with ids');
+    const entries = [...new Set(providers)].flatMap(provider => {
+        const preset = PRESETS[provider];
+        return preset.models.filter(model => !existing.some(entry => entry.id === model.id)).map(model => ({
+            id: model.id, baseUrl: preset.baseUrl, envKey: preset.envKey,
+            generationConfig: { contextWindowSize: model.contextWindowSize },
+        }));
+    });
+    return [{ kind: 'write', target: '.qwen/settings.json', merge: true, content: JSON.stringify({ modelProviders: { openai: entries } }, null, 2) + '\n', reason: 'explicit DeepSeek/Kimi API model presets (environment key references only)' }];
+}

package/docs/CAPABILITY-ROUTING.md

@@ -1,17 +1,17 @@
-# Routing by task requirements
-
+# Routing by task requirements
+
 Capability routing is available in Yoke 1.9.0. Batch preparation, separate planning settings and routing limits described below are local, unreleased additions.
-
-New setups use `routing.strategy: capability`. Existing explicit strategies and profiles remain unchanged. To opt an existing project into capability routing with its current profiles:
-
-```sh
-yoke setup . --yes --routing --routing-strategy=capability
-```
-
-Give each existing worker a `tier: light|standard|strong|frontier`. Profiles without a tier remain usable with legacy strategies but are not candidates for capability selection. To explicitly replace worker profiles with the supplied provider presets, add `--routing-preset`. This replaces customized worker profiles; omit it to retain them.
-
-## Planning and selection
-
+
+New setups use `routing.strategy: capability`. Existing explicit strategies and profiles remain unchanged. To opt an existing project into capability routing with its current profiles:
+
+```sh
+yoke setup . --yes --routing --routing-strategy=capability
+```
+
+Give each existing worker a `tier: light|standard|strong|frontier`. Profiles without a tier remain usable with legacy strategies but are not candidates for capability selection. To explicitly replace worker profiles with the supplied provider presets, add `--routing-preset`. This replaces customized worker profiles; omit it to retain them.
+
+## Planning and selection
+
 The start provider/model remains the planning default. Optional `planning.agent`, `planning.model` and `planning.reasoningEffort` select a separate planner without changing the execution model. Draft and change-inbox planning request complete assessments in the same pass that creates the tasks. The inbox still performs its separate coverage review.
 
 New setups use `routing.assessmentPolicy: prepared` and `routing.fallback: block`. Before dispatch, each unfinished task must have 2–5 executable criteria and a current assessment. No per-task planning call runs in this mode. Existing configurations retain `on-demand` and `parent` unless explicitly changed; on-demand routing makes a read-only planning call for an unassessed task and caches its result.
@@ -41,42 +41,42 @@ routing:
 ```
 
 `maxTier` limits automatic execution and escalation, including routing-rule selections. If a task needs frontier while the ceiling is strong, it blocks; Yoke does not lower the required capability. Planning itself may still use Astra. Explicit quality-role model overrides retain precedence. Goal execution retains its own protected manifest and budgets, uses the configured planner on demand, and honors routing fallback/tier limits; PRD preparation policy does not apply to synthetic goal tasks.
-
-An assessment is a planning judgment, not a measured success probability. High testability means executable checks can detect an incorrect implementation. High uncertainty, architecture work or high risk require the frontier tier; difficult or broadly coupled work requires strong; routine implementation requires standard. Light is reserved for clear, low-risk mechanical work with strong checks. Weak testability raises the minimum tier. Reviews and critics have a standard minimum even for light tasks.
-
-```yaml
-assessment:
-  taskClass: implementation
-  difficulty: medium
-  uncertainty: low
-  risk: low
-  scope: low
-  testability: high
-  reason: Existing handler pattern and executable contract tests
-  approach: Extend the handler, cover the boundary cases, run contract tests
-```
-
+
+An assessment is a planning judgment, not a measured success probability. High testability means executable checks can detect an incorrect implementation. High uncertainty, architecture work or high risk require the frontier tier; difficult or broadly coupled work requires strong; routine implementation requires standard. Light is reserved for clear, low-risk mechanical work with strong checks. Weak testability raises the minimum tier. Reviews and critics have a standard minimum even for light tasks.
+
+```yaml
+assessment:
+  taskClass: implementation
+  difficulty: medium
+  uncertainty: low
+  risk: low
+  scope: low
+  testability: high
+  reason: Existing handler pattern and executable contract tests
+  approach: Extend the handler, cover the boundary cases, run contract tests
+```
+
 Yoke chooses an eligible profile at or above the required tier, then compares declared cost tiers. Optional `roles: [implementation, reviewer, critic, repair]` limits a profile's uses. Task `agent` affinity restricts implementation to that provider. Explicit routing rules and explicit quality role models retain precedence. With legacy `fallback: parent` and no tier ceiling, a missing suitable profile falls back to the start model (or the explicitly bound provider's default) and labels the fallback; it does not prove sufficient capability. `fallback: block` or a configured tier ceiling prevents that fallback. An invalid assessment blocks implementation.
-
-## Initial profiles
-
-| Tier | Codex | Claude | Gemini |
-| --- | --- | --- | --- |
-| light | gpt-5.6-luna, low | haiku | gemini-2.5-flash |
-| standard | gpt-5.6-terra, medium | sonnet | gemini-2.5-pro |
-| strong | gpt-5.6-sol, high | sonnet, high effort | gemini-2.5-pro |
-| frontier | gpt-6-astra, high | opus | gemini-2.5-pro |
-
-These are editable starting hypotheses, not measured equivalences or price claims. The Codex names follow the requested profile family. Account access is not established by finding an installed CLI. Gemini uses documented explicit model IDs and receives no unsupported reasoning-effort parameter. Several Gemini tiers deliberately share Pro; moving between those tiers alone is not a stronger-model transition. Adjust the presets to the models available to your account. Claude aliases can resolve to different concrete models over time. Provider-reported model identity remains separate from requested identity.
-
-Provider references: [Claude model configuration](https://code.claude.com/docs/en/model-config), [Gemini model selection](https://geminicli.com/docs/cli/model/).
-
-## Repair, escalation and evidence
-
-After an independent mechanical failure, capability routing permits one targeted repair at the initial tier, then raises the required tier on further failures. Attempts retain the current worktree and receive the previous gate findings. Every returned candidate still passes the normal acceptance, protection, quality, review and integration gates. Critical decisions, pause/cancellation and protected-acceptance violations stop retries. Provider process failures are classified conservatively as infrastructure; they do not count as evidence that a stronger model is needed.
-
-`routing.maxAttempts` limits implementation calls per unchanged task contract (default 5, configurable 1–8). The initial tier imposes an additional bound: light at most 5, standard 4, strong 3, frontier 2. An exhausted task blocks and requires a revised plan. These are inner implementation attempts; the outer loop's iteration count still counts task dispatches. Existing quality repair rounds and time limits remain separate bounds, and quality repairs can raise their profile tier by round. Goal execution keeps its existing global attempt, time and token budgets.
-
-Routing observations record task class, required tier, requested and reported models, effort, independent result, duration and available consumption. Selection considers matching project/task-class/tier history from the last 30 days within the bounded registry read. At least ten matching observations are required before an observed success rate below 80% excludes a profile. History is scoped to the concrete reported model to avoid mixing changed aliases. This is a conservative exclusion rule; it does not lower the planner's safety floor or claim calibrated probabilities. Missing usage remains unknown. Financial optimization and cross-provider performance require authenticated benchmarks.
-
-The dashboard's Now view shows the last recorded implementation profile, requested model/effort, rationale and next escalation tier. Usage & time retains reported model and role consumption, including assessment calls. Cached planning has no new model-call charge. Routing state is local runtime data and excluded from Yoke story commits.
+
+## Initial profiles
+
+| Tier | Codex | Claude | Gemini |
+| --- | --- | --- | --- |
+| light | gpt-5.6-luna, low | haiku | gemini-2.5-flash |
+| standard | gpt-5.6-terra, medium | sonnet | gemini-2.5-pro |
+| strong | gpt-5.6-sol, high | sonnet, high effort | gemini-2.5-pro |
+| frontier | gpt-6-astra, high | opus | gemini-2.5-pro |
+
+These are editable starting hypotheses, not measured equivalences or price claims. The Codex names follow the requested profile family. Account access is not established by finding an installed CLI. Gemini uses documented explicit model IDs and receives no unsupported reasoning-effort parameter. Several Gemini tiers deliberately share Pro; moving between those tiers alone is not a stronger-model transition. Adjust the presets to the models available to your account. Claude aliases can resolve to different concrete models over time. Provider-reported model identity remains separate from requested identity.
+
+Provider references: [Claude model configuration](https://code.claude.com/docs/en/model-config), [Gemini model selection](https://geminicli.com/docs/cli/model/).
+
+## Repair, escalation and evidence
+
+After an independent mechanical failure, capability routing permits one targeted repair at the initial tier, then raises the required tier on further failures. Attempts retain the current worktree and receive the previous gate findings. Every returned candidate still passes the normal acceptance, protection, quality, review and integration gates. Critical decisions, pause/cancellation and protected-acceptance violations stop retries. Provider process failures are classified conservatively as infrastructure; they do not count as evidence that a stronger model is needed.
+
+`routing.maxAttempts` limits implementation calls per unchanged task contract (default 5, configurable 1–8). The initial tier imposes an additional bound: light at most 5, standard 4, strong 3, frontier 2. An exhausted task blocks and requires a revised plan. These are inner implementation attempts; the outer loop's iteration count still counts task dispatches. Existing quality repair rounds and time limits remain separate bounds, and quality repairs can raise their profile tier by round. Goal execution keeps its existing global attempt, time and token budgets.
+
+Routing observations record task class, required tier, requested and reported models, effort, independent result, duration and available consumption. Selection considers matching project/task-class/tier history from the last 30 days within the bounded registry read. At least ten matching observations are required before an observed success rate below 80% excludes a profile. History is scoped to the concrete reported model to avoid mixing changed aliases. This is a conservative exclusion rule; it does not lower the planner's safety floor or claim calibrated probabilities. Missing usage remains unknown. Financial optimization and cross-provider performance require authenticated benchmarks.
+
+The dashboard's Now view shows the last recorded implementation profile, requested model/effort, rationale and next escalation tier. Usage & time retains reported model and role consumption, including assessment calls. Cached planning has no new model-call charge. Routing state is local runtime data and excluded from Yoke story commits.