@hecer/yoke 1.11.0 → 1.12.0

package/dist/prd/command.js

@@ -10,23 +10,23 @@ import { acquireLock, releaseLock } from '../loop/lock.js';
 import { agentInvocation, buildWatchdogInvocation, runAgent, isAgentAvailable, } from '../loop/runner.js';
 import { resolveIdleMs } from '../loop/run-command.js';
 import { detectHostAgent, resolveRunnerAgent } from '../agents/host.js';
-export const PRD_TEMPLATE = `# Yoke PRD — the loop picks the lowest-priority open story each iteration.
-# Story format (see canon/loop/prd.schema.md):
-# - id: STORY-1
-#   title: scaffold the project with a runnable test suite
-#   priority: 1
-#   needs: []             # optional story IDs that must pass first
-#   area: foundation      # optional collision domain for parallel runs
-#   agent: codex          # optional claude|codex|gemini affinity
-#   acceptance:
-#     - id: suite-runs
-#       text: "the project test suite can run"
-#       verify: ["npm run test:suite-runs"]
-#     - id: scaffold-starts
-#       text: "the scaffolded application starts"
-#       verify: ["npm run test:scaffold-starts"]
-#   passes: false
-[]
+export const PRD_TEMPLATE = `# Yoke PRD — the loop picks the lowest-priority open story each iteration.
+# Story format (see canon/loop/prd.schema.md):
+# - id: STORY-1
+#   title: scaffold the project with a runnable test suite
+#   priority: 1
+#   needs: []             # optional story IDs that must pass first
+#   area: foundation      # optional collision domain for parallel runs
+#   agent: codex          # optional claude|codex|gemini affinity
+#   acceptance:
+#     - id: suite-runs
+#       text: "the project test suite can run"
+#       verify: ["npm run test:suite-runs"]
+#     - id: scaffold-starts
+#       text: "the scaffolded application starts"
+#       verify: ["npm run test:scaffold-starts"]
+#   passes: false
+[]
 `;
 export const MAX_PLANNING_BRIEF_CHARS = 20_000;
 export const MAX_PLANNING_BRIEF_BYTES = MAX_PLANNING_BRIEF_CHARS * 4;

package/dist/retrofit/apply.js

@@ -1,5 +1,6 @@
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { mergeQwenSettings } from './qwen-settings.js';
 import { mergeJson } from './merge-json.js';
 import { carryPreserved } from './preserve.js';
 export function applyActions(actions, targetDir, opts) {
@@ -28,7 +29,7 @@ export function applyActions(actions, targetDir, opts) {
                 catch {
                     throw new Error(`yoke: cannot merge ${action.target} — existing file is not valid JSON. Fix or delete it and re-run.`);
                 }
-                const merged = JSON.stringify(mergeJson(parsedCurrent, JSON.parse(action.content)), null, 2) + '\n';
+                const merged = JSON.stringify((action.target === '.qwen/settings.json' ? mergeQwenSettings : mergeJson)(parsedCurrent, JSON.parse(action.content)), null, 2) + '\n';
                 if (merged === current) {
                     results.push({ target: action.target, status: 'unchanged', reason: action.reason });
                     continue;
@@ -43,6 +44,12 @@ export function applyActions(actions, targetDir, opts) {
             }
             if (typeof action.content === 'string') {
                 const current = currentBytes.toString('utf8');
+                // Exact matches need no preservation pass. In particular, skill examples
+                // may contain literal preserve markers which must not be reinterpreted.
+                if (current === action.content) {
+                    results.push({ target: action.target, status: 'unchanged', reason: action.reason });
+                    continue;
+                }
                 // Carry user content marked with yoke preserve markers into the new file.
                 content = carryPreserved(current, action.content);
                 if (content !== action.content)

package/dist/retrofit/config.js

@@ -80,7 +80,7 @@ export const YokeConfigSchema = z.object({
             model: z.string().min(1).optional(),
             reasoningEffort: z.string().min(1).optional(),
         }).optional(),
-        workers: z.array(RoutingWorkerSchema).max(12).default([]),
+        workers: z.array(RoutingWorkerSchema).max(32).default([]),
         rules: z.array(RoutingRuleSchema).max(100).optional(),
     }).optional(),
     commit: z.object({

package/dist/retrofit/detect.js

@@ -10,6 +10,8 @@ export function detectProject(targetDir) {
         agents.push('codex');
     if (has('.gemini') || has('GEMINI.md'))
         agents.push('gemini');
+    if (has('.qwen') || has('QWEN.md'))
+        agents.push('qwen');
     return {
         agents,
         hasAgentsMd: has('AGENTS.md'),

package/dist/retrofit/planners/claude.js

@@ -6,21 +6,21 @@ import { hasWsl } from '../wsl.js';
 import { detectGstack } from '../gstack.js';
 import { PRESERVE_SCAFFOLD } from '../preserve.js';
 import { skillPackageActions } from '../skill-actions.js';
-const GSTACK_COMPOSE = `## Composed tools (gstack detected)
-
-This project also has [gstack](https://github.com/garrytan/gstack) installed. For capabilities Yoke does not ship, prefer gstack's skills:
-
-- Live-browser QA → \`/qa\`
-- Security audit → \`/cso\`
-- Ship / deploy → \`/ship\`, \`/land-and-deploy\`
+const GSTACK_COMPOSE = `## Composed tools (gstack detected)
+
+This project also has [gstack](https://github.com/garrytan/gstack) installed. For capabilities Yoke does not ship, prefer gstack's skills:
+
+- Live-browser QA → \`/qa\`
+- Security audit → \`/cso\`
+- Ship / deploy → \`/ship\`, \`/land-and-deploy\`
 `;
-const claudeMd = (rtkNote, composeNote) => `# Project Instructions
-
-This project uses the Yoke harness. Baseline instructions:
-
-@AGENTS.md
-${rtkNote ? `\n${rtkNote}\n` : ''}${composeNote ? `\n${composeNote}\n` : ''}
-${PRESERVE_SCAFFOLD}
+const claudeMd = (rtkNote, composeNote) => `# Project Instructions
+
+This project uses the Yoke harness. Baseline instructions:
+
+@AGENTS.md
+${rtkNote ? `\n${rtkNote}\n` : ''}${composeNote ? `\n${composeNote}\n` : ''}
+${PRESERVE_SCAFFOLD}
 `;
 export function planClaude(canonDir, targetDir, wslAvailable = hasWsl(), codeGraph = 'graphify', gstackDetected = detectGstack(targetDir)) {
     const manifest = loadManifest(join(canonDir, 'manifest.yaml'));

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

@@ -49,7 +49,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/setup/command.js

@@ -1,8 +1,11 @@
 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'];
 export function defaultRoutingWorkers(agents) {
@@ -26,10 +29,8 @@ 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'] },
         ],
     };
     return agents.flatMap(agent => workers[agent]);
@@ -50,6 +51,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 +63,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');
@@ -94,17 +98,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 +126,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.

package/docs/DASHBOARD-EVOLUTION.md

@@ -1,33 +1,33 @@
-# 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.
-
-## Overview
-
-Project status is derived from both the saved goal and the latest loop report. A blocked or running loop is not hidden by a completed goal. When goal and loop states differ, the card displays both. Blocked, failed, paused, unavailable, and stale active reports need attention; those projects are ordered before active projects, followed by the remaining projects.
-
-Cards also show the reported current task and saved blocker reason when available, so the overview explains why a project needs attention before opening it.
-
-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.
-
-## 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.
-
-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.
-
-## 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.
-
-When the preceding value is zero, the dashboard describes no change or new recorded activity instead of calculating an infinite percentage. A cost percentage is shown only when both periods have fully measured cost. Otherwise the dashboard says the percentage is unavailable. Current and previous missing-usage coverage is displayed from calls with unknown usage and unmeasured attempts. Recorded portions remain recorded portions; missing tokens or charges are not estimated as zero.
-
-Charts and their tables include periods that contain recorded events. Empty UTC calendar buckets are omitted and the chart explains that a gap means no recorded activity, not a measured zero. Detailed provider/model/role, model timeline, task, and phase tables remain below the comparison.
-
-## Design findings and limitations
-
-Goal state and loop state describe different durable facts and need independent presentation. Freshness is also separate from state: a saved `running` value can become unconfirmed without being rewritten. Navigation state belongs in the URL because the dashboard has several independently useful views and time controls. Analytics fan-out needs cancellation as well as a concurrency bound because registered workspaces may contain many projects.
-
-The dashboard combines local saved evidence with process-identity checks for supervised providers (see [Windows runner validation](WINDOWS-RUNNER-VALIDATION.md)). Unverified process identity remains unknown. It does not reconstruct activity that predates retained measurements, estimate missing provider usage or prices, or turn requested model names into proof of models used. Parallel call durations can overlap, so summed call time is consumption intensity rather than generation speed. The 20-minute freshness threshold is a presentation rule, not a process-health guarantee. No provider performance benchmark is implied by these views.
+# 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.
+
+## Overview
+
+Project status is derived from both the saved goal and the latest loop report. A blocked or running loop is not hidden by a completed goal. When goal and loop states differ, the card displays both. Blocked, failed, paused, unavailable, and stale active reports need attention; those projects are ordered before active projects, followed by the remaining projects.
+
+Cards also show the reported current task and saved blocker reason when available, so the overview explains why a project needs attention before opening it.
+
+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.
+
+## 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.
+
+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.
+
+## 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.
+
+When the preceding value is zero, the dashboard describes no change or new recorded activity instead of calculating an infinite percentage. A cost percentage is shown only when both periods have fully measured cost. Otherwise the dashboard says the percentage is unavailable. Current and previous missing-usage coverage is displayed from calls with unknown usage and unmeasured attempts. Recorded portions remain recorded portions; missing tokens or charges are not estimated as zero.
+
+Charts and their tables include periods that contain recorded events. Empty UTC calendar buckets are omitted and the chart explains that a gap means no recorded activity, not a measured zero. Detailed provider/model/role, model timeline, task, and phase tables remain below the comparison.
+
+## Design findings and limitations
+
+Goal state and loop state describe different durable facts and need independent presentation. Freshness is also separate from state: a saved `running` value can become unconfirmed without being rewritten. Navigation state belongs in the URL because the dashboard has several independently useful views and time controls. Analytics fan-out needs cancellation as well as a concurrency bound because registered workspaces may contain many projects.
+
+The dashboard combines local saved evidence with process-identity checks for supervised providers (see [Windows runner validation](WINDOWS-RUNNER-VALIDATION.md)). Unverified process identity remains unknown. It does not reconstruct activity that predates retained measurements, estimate missing provider usage or prices, or turn requested model names into proof of models used. Parallel call durations can overlap, so summed call time is consumption intensity rather than generation speed. The 20-minute freshness threshold is a presentation rule, not a process-health guarantee. No provider performance benchmark is implied by these views.

package/docs/MIGRATING-TO-1.0.md

@@ -1,33 +1,33 @@
-# Migrating to Yoke 1.0
-
-Yoke 1.0 changes unsafe implicit behavior into explicit policy.
-
-## Runner permissions
-
-The default is `runner.permissions: safe`. Automation that intentionally requires a full
-sandbox bypass must pass `--unsafe` or configure `runner.permissions: unsafe`. Use
-`read-only` for planning and probing.
-
-## Reviews
-
-Reviewers write `.yoke/review-verdict.json`; Yoke validates and consumes it. The reviewer must
-differ from the implementer unless `--allow-self-review` is explicit. CI can add `--json`.
-
-## Commit ownership
-
-Yoke resolves identity before implementation. Configure it when Git has no identity:
-
-```yaml
-commit:
-  authorName: HECer
-  authorEmail: hec_er@web.de
-  allowCoAuthors: false
-```
-
-## PRDs, audit, and cleanup
-
-Existing PRDs remain valid. Optional `needs`, `area`, and `agent` fields add dependencies,
-collision domains, and affinity. Enable the story audit gate with `audit.enabled: true` and
-version suppressions with `suppressionsVersion: 1`.
-
-`yoke loop cleanup` now reports retained worktrees. Add `--remove-worktrees` for deletion.
+# Migrating to Yoke 1.0
+
+Yoke 1.0 changes unsafe implicit behavior into explicit policy.
+
+## Runner permissions
+
+The default is `runner.permissions: safe`. Automation that intentionally requires a full
+sandbox bypass must pass `--unsafe` or configure `runner.permissions: unsafe`. Use
+`read-only` for planning and probing.
+
+## Reviews
+
+Reviewers write `.yoke/review-verdict.json`; Yoke validates and consumes it. The reviewer must
+differ from the implementer unless `--allow-self-review` is explicit. CI can add `--json`.
+
+## Commit ownership
+
+Yoke resolves identity before implementation. Configure it when Git has no identity:
+
+```yaml
+commit:
+  authorName: HECer
+  authorEmail: hec_er@web.de
+  allowCoAuthors: false
+```
+
+## PRDs, audit, and cleanup
+
+Existing PRDs remain valid. Optional `needs`, `area`, and `agent` fields add dependencies,
+collision domains, and affinity. Enable the story audit gate with `audit.enabled: true` and
+version suppressions with `suppressionsVersion: 1`.
+
+`yoke loop cleanup` now reports retained worktrees. Add `--remove-worktrees` for deletion.