@hecer/yoke 1.7.0 → 1.9.0

package/dist/routing/router.js

@@ -1,6 +1,8 @@
-import { buildWatchdogInvocation, makeRunner, runCapturedAgent, runnerInvocation, } from '../loop/runner.js';
+import { buildWatchdogInvocation, makeRunner, runCapturedAgent, runnerInvocation, contextBlockFor, } from '../loop/runner.js';
 import { isAcceptanceCriterion } from '../loop/prd.js';
 import { historyForWorkers, projectHash, readRoutingObservations, recordRoutingObservation, storyHash } from './registry.js';
+import { assessmentInstructions, assessmentKey, parseAssessment } from './assessment.js';
+import { chooseCapability, readAssessment, saveAssessment } from './capability.js';
 const costRank = { low: 0, medium: 1, high: 2 };
 export function rankWorkers(workers, strategy, maxCandidates) {
     const history = historyForWorkers(workers);
@@ -112,6 +114,26 @@ function callUsage(role, provider, selection, tokens, durationMs, profile) {
     };
 }
 export function makeAdaptiveRunner(options) {
+    const run = routingSteps(options);
+    return ctx => {
+        const steps = run(ctx);
+        let next = steps.next();
+        while (!next.done)
+            next = steps.next(next.value());
+        return next.value;
+    };
+}
+export function makeAsyncAdaptiveRunner(options) {
+    const run = routingSteps(options);
+    return async (ctx) => {
+        const steps = run(ctx);
+        let next = steps.next();
+        while (!next.done)
+            next = steps.next(await next.value());
+        return next.value;
+    };
+}
+function routingSteps(options) {
     const now = options.now ?? Date.now;
     const available = options.isAvailable ?? (() => true);
     const eligibleWorkers = options.workers.filter(worker => available(worker.agent));
@@ -121,12 +143,52 @@ export function makeAdaptiveRunner(options) {
         permissions: options.permissions ?? 'safe',
         selection,
     }));
-    return (ctx) => {
+    return function* (ctx) {
+        if (options.strategy === 'capability' && !options.rules?.some(rule => (!rule.area || rule.area === ctx.story.area) && (!rule.storyId || rule.storyId === ctx.story.id))) {
+            const root = options.projectRoot ?? ctx.targetDir;
+            let assessment = readAssessment(root, ctx.story);
+            let planning;
+            const calls = [];
+            if (!assessment) {
+                const prompt = [assessmentInstructions, 'Use the supplied task contract and project context to produce a bounded plan. Do not implement or change files.',
+                    contextBlockFor(ctx.targetDir, ctx.story), JSON.stringify(ctx.story), 'Return exactly one line: YOKE_ASSESS {"taskClass":"implementation","difficulty":"medium","uncertainty":"low","risk":"low","scope":"low","testability":"high","reason":"evidence","approach":"steps and tests"}'].join('\n');
+                const selection = { ...options.parentSelection, nativeMultiAgent: false };
+                const started = now();
+                planning = yield () => options.captureRoute ? options.captureRoute(options.parent, ctx, prompt, selection)
+                    : runCapturedAgent(options.parent, buildWatchdogInvocation(runnerInvocation(options.parent, prompt, ctx.targetDir, true, 'read-only', selection), options.idleTimeoutMs ?? 0));
+                calls.push(callUsage('orchestrator', options.parent, selection, planning.tokens, now() - started));
+                assessment = planning.success ? parseAssessment(planning.output) : undefined;
+                if (assessment)
+                    saveAssessment(root, ctx.story, assessment, { provider: options.parent, model: planning.tokens?.model ?? selection.model });
+            }
+            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 });
+            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 });
+            if (choice.exhausted)
+                return { success: false, summary: 'Routing attempt budget exhausted; replan this task before retrying', tokens: aggregateCalls(calls), routing: { recordOutcome: () => undefined, blocked: true } };
+            const started = now();
+            const result = yield () => makeWorker(choice.provider, choice.selection)({ ...ctx, story: { ...ctx.story, assessment } });
+            calls.push(callUsage(choice.worker ? 'worker' : 'parent', choice.provider, choice.selection, result.tokens, now() - started, choice.worker?.id ?? 'SELF'));
+            let recorded = false;
+            return { ...result, summary: `route=${choice.worker?.id ?? 'SELF'} (${choice.reason}); ${result.summary}`,
+                tokens: { ...aggregateCalls(calls), storyId: ctx.story.id, escalated: choice.failures > 1 },
+                routing: { canRetry: !result.infrastructureFailure && choice.failures + 1 < (options.maxAttempts ?? 5), recordOutcome: (verified, failureKind) => {
+                        if (recorded)
+                            return;
+                        recorded = true;
+                        recordRoutingObservation({ projectHash: projectHash(root), storyHash: storyHash(projectHash(root), ctx.story.id), assessmentKey: assessmentKey(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,
+                            actualModel: result.tokens?.model, orchestratorProvider: options.parent, orchestratorModel: 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: verified, failureKind: failureKind ?? (result.infrastructureFailure ? 'infrastructure' : 'implementation'), usageAvailable: result.tokens !== undefined && result.tokens.measurementComplete !== false,
+                            inputTokens: result.tokens?.inputTokens ?? 0, outputTokens: result.tokens?.outputTokens ?? 0, totalCostUsd: result.tokens?.totalCostUsd });
+                    } } };
+        }
         // Re-rank per story so a long-running loop can use gate outcomes learned by
         // earlier stories without rebuilding the runner.
         const rule = options.rules?.find(rule => (!rule.area || rule.area === ctx.story.area) && (!rule.storyId || rule.storyId === ctx.story.id) && (rule.area || rule.storyId));
         if (rule) {
-            const project = projectHash(ctx.targetDir);
+            const project = projectHash(options.projectRoot ?? ctx.targetDir);
             const prior = readRoutingObservations().reverse().find(event => event.projectHash === project && event.storyHash === storyHash(project, ctx.story.id) && typeof event.verificationSuccess === 'boolean');
             if (prior?.verificationSuccess === false)
                 failedStories.add(ctx.story.id);
@@ -134,12 +196,12 @@ export function makeAdaptiveRunner(options) {
         const ruleWorker = rule && failedStories.has(ctx.story.id) ? rule.escalateTo ?? 'SELF' : rule?.worker;
         const candidates = rule ? eligibleWorkers : rankWorkers(eligibleWorkers, options.strategy, options.maxCandidates);
         if (candidates.length === 0) {
-            return makeWorker(options.parent, options.parentSelection ?? {})(ctx);
+            return yield () => makeWorker(options.parent, options.parentSelection ?? {})(ctx);
         }
         const prompt = buildRoutingPrompt(ctx, candidates, options.strategy);
-        const orchestratorSelection = { ...(options.parentSelection ?? {}), ...(options.orchestratorSelection ?? {}), ...(options.parent === 'codex' ? { nativeMultiAgent: false } : {}) };
+        const orchestratorSelection = { ...(options.parentSelection ?? {}), ...(options.orchestratorSelection ?? {}), nativeMultiAgent: false };
         const orchestratorStarted = now();
-        const routeRun = rule ? { success: true, summary: 'Explicit rule', output: '', tokens: { inputTokens: 0, outputTokens: 0 } } : options.captureRoute
+        const routeRun = rule ? { success: true, summary: 'Explicit rule', output: '', tokens: { inputTokens: 0, outputTokens: 0 } } : yield () => options.captureRoute
             ? options.captureRoute(options.parent, ctx, prompt, orchestratorSelection)
             : runCapturedAgent(options.parent, buildWatchdogInvocation(runnerInvocation(options.parent, prompt, ctx.targetDir, true, 'read-only', orchestratorSelection), options.idleTimeoutMs ?? 0));
         const orchestratorDurationMs = Math.max(0, now() - orchestratorStarted);
@@ -150,16 +212,18 @@ export function makeAdaptiveRunner(options) {
         const worker = selected === 'SELF' ? undefined : candidates.find(candidate => candidate.id === selected);
         const provider = worker?.agent ?? options.parent;
         const selection = worker
-            ? { model: worker.model, reasoningEffort: worker.reasoningEffort, ...(provider === 'codex' ? { nativeMultiAgent: false } : {}), ...(provider !== 'gemini' ? { bare: options.parentSelection?.bare } : {}) }
-            : { ...(options.parentSelection ?? {}), ...(provider === 'codex' ? { nativeMultiAgent: false } : {}) };
+            ? { model: worker.model, reasoningEffort: worker.reasoningEffort, nativeMultiAgent: false, ...(provider !== 'gemini' ? { bare: options.parentSelection?.bare } : {}) }
+            : { ...(options.parentSelection ?? {}), nativeMultiAgent: false };
         const workerStarted = now();
-        const result = makeWorker(provider, selection)(ctx);
+        const result = yield () => makeWorker(provider, selection)(ctx);
         const workerDurationMs = Math.max(0, now() - workerStarted);
         const calls = [
             ...(!rule ? [callUsage('orchestrator', options.parent, orchestratorSelection, routeRun.tokens, orchestratorDurationMs)] : []),
             callUsage(worker ? 'worker' : 'parent', provider, selection, result.tokens, workerDurationMs, selected),
         ];
         const tokens = {
+            storyId: ctx.story.id,
+            escalated: Boolean(rule && failedStories.has(ctx.story.id)),
             inputTokens: (routeRun.tokens?.inputTokens ?? 0) + (result.tokens?.inputTokens ?? 0),
             ...((routeRun.tokens?.cachedInputTokens !== undefined || result.tokens?.cachedInputTokens !== undefined)
                 ? { cachedInputTokens: (routeRun.tokens?.cachedInputTokens ?? 0) + (result.tokens?.cachedInputTokens ?? 0) }
@@ -188,7 +252,7 @@ export function makeAdaptiveRunner(options) {
                 failedStories.add(ctx.story.id);
             else
                 failedStories.delete(ctx.story.id);
-            const project = projectHash(ctx.targetDir);
+            const project = projectHash(options.projectRoot ?? ctx.targetDir);
             recordRoutingObservation({
                 projectHash: project,
                 storyHash: storyHash(project, ctx.story.id),
@@ -214,3 +278,9 @@ export function makeAdaptiveRunner(options) {
         return { ...result, summary: `${routeSummary}; ${result.summary}`, tokens, routing: { recordOutcome } };
     };
 }
+function aggregateCalls(calls) {
+    return { inputTokens: calls.reduce((n, c) => n + c.inputTokens, 0), outputTokens: calls.reduce((n, c) => n + c.outputTokens, 0),
+        cachedInputTokens: calls.reduce((n, c) => n + (c.cachedInputTokens ?? 0), 0), cacheWriteInputTokens: calls.reduce((n, c) => n + (c.cacheWriteInputTokens ?? 0), 0),
+        ...(calls.some(c => c.totalCostUsd !== undefined) ? { totalCostUsd: calls.reduce((n, c) => n + (c.totalCostUsd ?? 0), 0) } : {}),
+        calls, measurementComplete: calls.every(c => c.usageAvailable), costMeasurementComplete: calls.every(c => c.totalCostUsd !== undefined) };
+}

package/dist/setup/command.js

@@ -7,14 +7,26 @@ import { runRetrofit } from '../retrofit/command.js';
 const ALL_AGENTS = ['claude', 'codex', 'gemini'];
 export function defaultRoutingWorkers(agents) {
     const workers = {
-        claude: { id: 'claude-fast', agent: 'claude', model: 'haiku', costTier: 'low', capabilities: ['exploration', 'mechanical-edits', 'tests'] },
-        // Inherit the account's current Codex model and lower only its supported effort.
-        // This avoids pinning a model id that will age out of the provider catalog.
-        codex: { id: 'codex-light', agent: 'codex', reasoningEffort: 'low', costTier: 'medium', capabilities: ['exploration', 'mechanical-edits', 'tests'] },
-        // Gemini CLI's default/Auto route tracks the models available to the active account.
-        gemini: { id: 'gemini-auto', agent: 'gemini', costTier: 'low', capabilities: ['large-context', 'exploration', 'implementation'] },
+        claude: [
+            { id: 'claude-fast', agent: 'claude', model: 'haiku', tier: 'light', costTier: 'low', capabilities: ['mechanical', 'tests'] },
+            { id: 'claude-standard', agent: 'claude', model: 'sonnet', tier: 'standard', costTier: 'medium', capabilities: ['implementation'] },
+            { id: 'claude-strong', agent: 'claude', model: 'sonnet', reasoningEffort: 'high', tier: 'strong', costTier: 'medium', capabilities: ['debugging'] },
+            { id: 'claude-frontier', agent: 'claude', model: 'opus', tier: 'frontier', costTier: 'high', capabilities: ['architecture'] },
+        ],
+        codex: [
+            { id: 'codex-light', agent: 'codex', model: 'gpt-5.6-luna', reasoningEffort: 'low', tier: 'light', costTier: 'low', capabilities: ['mechanical', 'tests'] },
+            { id: 'codex-standard', agent: 'codex', model: 'gpt-5.6-terra', reasoningEffort: 'medium', tier: 'standard', costTier: 'low', capabilities: ['implementation'] },
+            { id: 'codex-strong', agent: 'codex', model: 'gpt-5.6-sol', reasoningEffort: 'high', tier: 'strong', costTier: 'medium', capabilities: ['debugging'] },
+            { id: 'codex-frontier', agent: 'codex', model: 'gpt-6-astra', reasoningEffort: 'high', tier: 'frontier', costTier: 'high', capabilities: ['architecture'] },
+        ],
+        gemini: [
+            { id: 'gemini-light', agent: 'gemini', model: 'gemini-2.5-flash', tier: 'light', costTier: 'low', capabilities: ['mechanical', 'tests'] },
+            { id: 'gemini-standard', agent: 'gemini', model: 'gemini-2.5-pro', tier: 'standard', costTier: 'medium', capabilities: ['implementation'] },
+            { id: 'gemini-strong', agent: 'gemini', model: 'gemini-2.5-pro', tier: 'strong', costTier: 'medium', capabilities: ['debugging'] },
+            { id: 'gemini-frontier', agent: 'gemini', model: 'gemini-2.5-pro', tier: 'frontier', costTier: 'high', capabilities: ['architecture'] },
+        ],
     };
-    return agents.map(agent => workers[agent]).filter((worker) => worker !== undefined);
+    return agents.flatMap(agent => workers[agent]);
 }
 function parseAgents(value, fallback) {
     if (value.trim().toLowerCase() === 'all')
@@ -46,7 +58,7 @@ export async function runSetup(targetDir, opts = {}) {
     const defaultLoop = opts.loop ?? existing?.loop.enabled ?? true;
     const defaultRunner = opts.runner ?? existing?.runner?.agent ?? (host && defaultAgents.includes(host) ? host : defaultAgents[0] ?? host ?? 'claude');
     const defaultPolicy = opts.decisionPolicy ?? existing?.loop.decisionPolicy ?? (existing?.loop.onAmbiguity === 'abort' ? 'critical' : 'auto');
-    const defaultRouting = opts.routing ?? existing?.routing?.enabled ?? false;
+    const defaultRouting = opts.routing ?? existing?.routing?.enabled ?? true;
     const interactive = opts.interactive ?? (process.stdin.isTTY === true && process.stdout.isTTY === true);
     let close;
     let ask = opts.ask;
@@ -84,15 +96,16 @@ export async function runSetup(targetDir, opts = {}) {
         const config = loadConfig(targetDir);
         if (!config)
             return 1;
-        config.loop = { ...config.loop, enabled: loop, decisionPolicy };
+        config.loop = { parallel: 'auto', isolate: true, ...config.loop, enabled: loop, decisionPolicy };
         config.runner = { ...config.runner, agent: runner };
         const existingWorkers = config.routing?.workers ?? [];
         config.routing = {
+            ...config.routing,
             enabled: routing,
-            strategy: config.routing?.strategy ?? 'balanced',
+            strategy: opts.routingStrategy ?? config.routing?.strategy ?? 'capability',
             maxCandidates: config.routing?.maxCandidates ?? 3,
             ...(config.routing?.orchestrator ? { orchestrator: config.routing.orchestrator } : {}),
-            workers: existingWorkers.length > 0 ? existingWorkers : defaultRoutingWorkers(agents),
+            workers: existingWorkers.length > 0 && !opts.routingPreset ? existingWorkers : defaultRoutingWorkers(agents),
         };
         saveConfig(targetDir, config);
         console.log(`Yoke setup complete: agents=${agents.join(',')} · runner=${runner} · loop=${loop ? 'on' : 'off'} · routing=${routing ? 'on' : 'off'} · decisions=${decisionPolicy}`);

package/docs/CAPABILITY-ROUTING.md

@@ -0,0 +1,54 @@
+# Routing by task requirements
+
+Available in Yoke 1.9.0.
+
+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 configured start provider/model plans new change requests. The planner supplies an `assessment` with the task class, difficulty, uncertainty, risk, scope, testability, rationale and implementation approach. Existing tasks without an assessment receive one read-only assessment call using the start model. This call does not use a cheaper orchestration override. Its result is cached under `.yoke/routing/`, keyed by the task contract. Changing the contract invalidates the cached assessment; toggling `passes` does not.
+
+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. 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 that the fallback has sufficient capability. 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.

package/docs/PRODUCT-DIRECTION-2026-09-05.md

@@ -181,3 +181,29 @@ Am 2026-09-05 gelesene Primärquellen; vor konkreten Versions-/Preisentscheidung
 - https://github.com/open-gsd/gsd-core
 
 Provenienz der ursprünglichen README-Prüfung: kein C2PA gefunden, unterstützter Scan vollständig, Verifikation/Vertrauen/Metadatenprivatsphäre unbekannt. Unicode-Befund: Emoji-Variationszeichen, kein Nachweis eines KI-Wasserzeichens. Proprietäre Wasserzeichen nicht überprüfbar. Dieses Gesprächsdokument wurde vom KI-Assistenten aus der Sitzung zusammengefasst; es enthält keine unabhängige Bestätigung der Produktthesen.
+
+
+## Fortsetzung am 2026-09-06: Defaults und Dashboard
+
+Der Nutzer hat die kombinierte Umsetzung von automatischem Routing/Parallelismus und den drei Dashboardansichten Jetzt, Verbrauch & Zeit sowie Ergebnisse beauftragt. Die Änderungen liegen lokal als unveröffentlichter Ausbau vor; Paketversion und zuletzt veröffentlichtes Release bleiben 1.7.0.
+
+Umgesetzt: Routing im asynchronen Workerpfad; neue Setups mit Routing an, Parallelität auto und Isolation an; konservativ höchstens zwei Yoke-Worker bei deklarierten Schreibbereichen; Respektierung expliziter Einstellungen; dauerhafte Messhistorie getrennt von der kurzen Aktivitätsliste; Tages-/Wochen-/Monatsauswertung in UTC; Modell- und Projektvergleich; Verbrauchsdiagramm; aktuelle Aufgaben und Phasen; Abnahmen und Aufwand pro Abnahme. Verfügbare Reviewer-, Kritiker- und Reparaturnutzung wird mit erfasst. Details und Grenzen stehen in VERIFIED-PROJECTS.md.
+
+Weiterhin keine behaupteten Fähigkeiten: dynamische gemeinsame Nutzung von Slots durch native Subagenten (native Delegation ist für Loop-Aufrufe bei allen drei Anbietern deaktiviert), exakte Generierungsgeschwindigkeit, vollständige Rekonstruktion alter Verbrauchsdaten, automatische monatliche Archivverdichtung oder kalibrierte Zeitprognosen. Bestehende Quality-Reparaturlimits bleiben erhalten; konkurrierende Kandidaten bleiben optional.
+
+Die Umsetzung wurde mit Tests und einer lokalen Browserprüfung geprüft; authentifizierte Modellbenchmarks und Veröffentlichung waren kein Bestandteil dieser Fortsetzung. Dieses Update wurde vom KI-Assistenten aus der laufenden Umsetzung festgehalten.
+
+
+### Releaseauftrag am 2026-09-06
+
+Der Nutzer hat anschließend maximal drei Worker im Automatikmodus und die Veröffentlichung der Weiterentwicklung beauftragt. Releaseziel ist 1.8.0; der frühere lokale Zwischenstand mit zwei Workern ist damit überholt. Jede neue Version muss vor Veröffentlichung einen datierten Changelogeintrag erhalten; die verbindliche Regel steht in AGENTS.md. Der tatsächliche Veröffentlichungsstatus wird über GitHub Release und npm geprüft.
+
+
+## Aufgabenbezogene Modellauswahl nach Release 1.8.0
+
+Der Nutzer hat die Umsetzung der vorgeschlagenen Fähigkeitsauswahl ausdrücklich beauftragt: Planung mit dem Startmodell, gespeicherte Aufgabenbewertung, Modell-/Effort-Profile für Codex, Claude und Gemini, begrenzte Reparatur/Eskalation sowie nachvollziehbare Dashboardanzeige. Die Implementierung wird lokal nach 1.8.0 entwickelt. Verhalten, Migration und Grenzen stehen in CAPABILITY-ROUTING.md; die veröffentlichten 1.8.0-Defaults dürfen damit nicht verwechselt werden.
+
+
+### Releaseauftrag 1.9.0
+
+Der Nutzer hat die Veröffentlichung des Capability-Routing-Ausbaus ausdrücklich beauftragt. Releaseziel ist 1.9.0. Der datierte Changelog und CAPABILITY-ROUTING.md beschreiben Verhalten, Migration und Grenzen; frühere Hinweise auf den lokalen Zwischenstand bleiben historische Sitzungsnotizen.

package/docs/VERIFIED-PROJECTS.md

@@ -130,6 +130,26 @@ Versioned local events record status, phase duration, attempts and available usa
 
 ## Local project dashboard
 
+### Execution defaults in 1.8.0
+
+New setups enable routing, `loop.parallel: auto` and `loop.isolate: true`. Existing explicit settings remain authoritative. At execution time, automatic routing uses configured profiles; without profiles it keeps the selected parent. Explicit `--routing` without profiles still reports a configuration error. Routing rules bypass the controller and can escalate following failed independent gates, including across worktrees and restarts. Routing now also runs asynchronously inside parallel workers. An explicit task provider affinity takes precedence over routing.
+
+Automatic parallelism allows at most three Yoke workers when every pending task declares nonempty write scopes. Dependencies and overlapping scopes still constrain dispatch. Unknown scopes, configured tool actions and worktree recovery select serial execution. Use `--parallel=N`, `--parallel=auto`, `--no-routing` or `--no-isolate` to override defaults. Serial worktrees retain failed work and require deliberate recovery; the default does not discard an existing recovery tree. Quality repair budgets and opt-in competing candidates retain their existing policies.
+
+Integration retains an execution slot until its candidate lands. Yoke loop runners disable native delegation so it cannot multiply the default worker budget: Codex disables multi_agent; Claude disallows Agent, Task, TeamCreate and SendMessage; Gemini uses a separate temporary system-settings copy that disables experimental agents and its always-on investigator/help overrides. Existing Gemini system policy and system-default paths are preserved; unreadable or malformed policy blocks launch. Original settings are never overwritten. The temporary copy is removed on normal exit; forced process termination may leave a private temporary directory. Explicit competing candidate counts remain a separate opt-in workload.
+
+### Dashboard views
+
+- **Now:** reported task and worker activity, requested provider/model, elapsed worker time, phase, integration, blockers, status age, backlog and empirical remaining-time ranges. The view refreshes every five seconds while visible and not being operated with keyboard focus. A stale status is marked rather than asserted to be live.
+- **Usage & time:** last 24 hours, 7/30/90/365 days or custom dates, grouped by UTC day, Monday-based week or month. Displays reported input/output and cache categories, cost coverage, consumption charts, per-model time buckets, per-task usage and summed phase/call durations. The overview also compares projects for the same period.
+- **Results:** recorded acceptances, ended attempts, explicitly successful outcomes, repair phases, rule-driven escalations and recorded tokens/time per acceptance. Saved acceptance evidence and goal attempts remain available; their timestamps may fall outside the statistics period.
+
+The short activity list still retains at most 1,000 events. Compact measurements now also persist under `.yoke/history/YYYY-MM-DD/` independently of that retention and across runs. They contain identifiers, model/provider evidence and measurements, not prompts or full status snapshots. Runtime history is excluded from Yoke commits and added to new project ignore rules. Available reviewer, quality critic and repair usage is recorded separately; absent usage is counted as unknown. Recent and archived records are deduplicated by event ID.
+
+Dates and buckets use UTC. The custom end date is inclusive; the API uses an exclusive upper timestamp. Usage belongs to the time the provider reports it, and durations to their end time. Tokens per elapsed minute divide recorded input/output by the full selected interval. Tokens per call minute use summed reported call duration, which can overlap across workers. Neither is measured generation speed. Cache categories are shown separately without adding them to input again.
+
+Historical activity that was never recorded or already expired cannot be reconstructed. Queue/human waiting time that lacks measurements remains unknown; phase and attempt durations are summed worker time, not automatically elapsed project time. Queries allow at most 366 days and bounded reads (8 MiB per shard, 32 MiB overall, 50,000 records); skipped, malformed or oversized history is reported as incomplete. History currently requires local disk retention rather than automatic monthly compaction. Unknown model identity is never replaced by a requested model, and missing charges are not estimated from token counts.
+
 ```sh
 yoke projects add /path/to/project
 yoke projects list

package/gemini-extension.json

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

package/hooks/bounded-gemini.mjs

@@ -0,0 +1,70 @@
+import { spawn } from 'node:child_process'
+import { readFileSync, statSync, mkdtempSync, writeFileSync, unlinkSync, rmdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+// Match Gemini's JSON-with-comments reader without interpreting executable content.
+export function parseSettings(source) {
+  let clean = '', quoted = false, escaped = false, line = false, block = false
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i], next = source[i + 1]
+    if (line) { if (c === '\n' || c === '\r') { line = false; clean += c } else clean += ' '; continue }
+    if (block) { if (c === '*' && next === '/') { block = false; clean += '  '; i++ } else clean += c === '\n' ? '\n' : ' '; continue }
+    if (quoted) { clean += c; if (escaped) escaped = false; else if (c === '\\') escaped = true; else if (c === '"') quoted = false; continue }
+    if (c === '"') quoted = true
+    else if (c === '/' && next === '/') { line = true; clean += '  '; i++; continue }
+    else if (c === '/' && next === '*') { block = true; clean += '  '; i++; continue }
+    clean += c
+  }
+  if (block) throw Error('Invalid settings comment')
+  const value = JSON.parse(clean)
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw Error('Settings must be an object')
+  return value
+}
+
+export function prepareGeminiEnvironment(environment = process.env, platform = process.platform) {
+  const original = environment.GEMINI_CLI_SYSTEM_SETTINGS_PATH ?? (platform === 'win32' ? 'C:\\ProgramData\\gemini-cli\\settings.json' : platform === 'darwin' ? '/Library/Application Support/GeminiCli/settings.json' : '/etc/gemini-cli/settings.json')
+  let settings = {}
+  try {
+    if (statSync(original).size > 1048576) throw Error('Settings too large')
+    settings = parseSettings(readFileSync(original, 'utf8'))
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw Error('Cannot safely preserve existing Gemini system settings')
+  }
+  if (settings.experimental !== undefined && (!settings.experimental || typeof settings.experimental !== 'object' || Array.isArray(settings.experimental))) throw Error('Invalid Gemini experimental settings')
+  if (settings.agents !== undefined && (!settings.agents || typeof settings.agents !== 'object' || Array.isArray(settings.agents))) throw Error('Invalid Gemini agent settings')
+  if (settings.agents?.overrides !== undefined && (!settings.agents.overrides || typeof settings.agents.overrides !== 'object' || Array.isArray(settings.agents.overrides))) throw Error('Invalid Gemini agent overrides')
+  const dir = mkdtempSync(join(tmpdir(), 'yoke-gemini-'))
+  const file = join(dir, 'settings.json')
+  const cleanup = () => { try { unlinkSync(file) } catch {} try { rmdirSync(dir) } catch {} }
+  const overrides = { ...settings.agents?.overrides }
+  // Gemini exposes these built-ins even when experimental agents are disabled.
+  for (const name of ['codebase_investigator', 'cli_help']) overrides[name] = { ...overrides[name], enabled: false }
+  try { writeFileSync(file, JSON.stringify({ ...settings, experimental: { ...settings.experimental, enableAgents: false }, agents: { ...settings.agents, overrides } }), { mode: 0o600, flag: 'wx' }) }
+  catch (error) { cleanup(); throw error }
+  return {
+    env: { ...environment, GEMINI_CLI_SYSTEM_SETTINGS_PATH: file,
+      GEMINI_CLI_SYSTEM_DEFAULTS_PATH: environment.GEMINI_CLI_SYSTEM_DEFAULTS_PATH ?? join(dirname(original), 'system-defaults.json') },
+    cleanup,
+  }
+}
+
+if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  let prepared
+  try {
+    prepared = prepareGeminiEnvironment()
+    // Keep Windows shim arguments shell-inert. Prompts use inherited stdin only.
+    const args = process.argv.slice(2)
+    const windows = process.platform === 'win32'
+    if (windows && args.some(arg => !/^[A-Za-z0-9_./:=+-]+$/u.test(arg))) throw Error('Unsafe Gemini argument')
+    const child = spawn(windows ? 'cmd.exe' : 'gemini', windows ? ['/d', '/s', '/c', ['gemini', ...args].join(' ')] : args, { stdio: 'inherit', shell: false, env: prepared.env })
+    process.once('exit', prepared.cleanup)
+    child.once('error', () => { process.stderr.write('Could not start the Gemini CLI\n'); process.exitCode = 127; prepared.cleanup() })
+    child.once('close', code => { process.exitCode ??= code === null || code < 0 ? 1 : code; prepared.cleanup() })
+  } catch {
+    prepared?.cleanup()
+    process.stderr.write('Could not establish bounded Gemini execution while preserving system settings\n')
+    process.exitCode = 1
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hecer/yoke",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "One harness, three agents, zero trust in \"done\" — cross-agent coding harness for Claude Code, Codex CLI, and Gemini CLI: one skill canon, mechanical safety gates, an autonomous loop with screenshot/video proofs.",
   "type": "module",
   "bin": {