@hecer/yoke 1.8.0 → 1.10.0

package/dist/routing/router.js

@@ -1,6 +1,9 @@
-import { buildWatchdogInvocation, makeRunner, runCapturedAgent, runnerInvocation, } from '../loop/runner.js';
-import { isAcceptanceCriterion } from '../loop/prd.js';
+import { buildWatchdogInvocation, makeRunner, runCapturedAgent, runnerInvocation, contextBlockFor, } from '../loop/runner.js';
+import { isAcceptanceCriterion, criterionCommandProblem } from '../loop/prd.js';
 import { historyForWorkers, projectHash, readRoutingObservations, recordRoutingObservation, storyHash } from './registry.js';
+import { assessmentInstructions, parseAssessment, tiers } from './assessment.js';
+import { chooseCapability, readAssessment, saveAssessment, routingAssessmentKey, knownInfrastructureFailure } from './capability.js';
+import { readPlanningFile } from './contracts.js';
 const costRank = { low: 0, medium: 1, high: 2 };
 export function rankWorkers(workers, strategy, maxCandidates) {
     const history = historyForWorkers(workers);
@@ -142,6 +145,76 @@ function routingSteps(options) {
         selection,
     }));
     return function* (ctx) {
+        const blocked = (summary) => ({ success: false, summary, routing: { blocked: true, recordOutcome: () => undefined } });
+        if (options.strategy === 'capability' && options.assessmentPolicy === 'prepared') {
+            try {
+                const criteria = ctx.story.acceptance;
+                if (criteria.length < 2 || criteria.length > 5 || criteria.some(c => !isAcceptanceCriterion(c) || criterionCommandProblem(c)))
+                    return blocked('Prepared routing requires 2-5 executable acceptance criteria');
+                if (!readAssessment(options.projectRoot ?? ctx.targetDir, ctx.story, true))
+                    return blocked('Task assessment is missing or stale. Run yoke prd assess before execution.');
+            }
+            catch (error) {
+                return blocked(`Cannot read prepared assessment: ${error.message}`);
+            }
+        }
+        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;
+            try {
+                assessment = readAssessment(root, ctx.story, options.assessmentPolicy === 'prepared');
+            }
+            catch (error) {
+                return blocked(`Cannot read assessment: ${error.message}`);
+            }
+            let planning;
+            const calls = [];
+            if (!assessment) {
+                const inputKey = routingAssessmentKey(root, ctx.story);
+                const prompt = [assessmentInstructions, 'Use the supplied task contract and project context to produce a bounded plan. Do not implement or change files.',
+                    'Approved planning brief:', readPlanningFile(root, '.yoke/plan.md', 80_000) ?? '',
+                    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 planner = options.planner?.agent ?? options.parent;
+                if (!available(planner))
+                    return blocked('Configured planning provider is unavailable');
+                const selection = { ...(options.planner?.selection ?? options.parentSelection), nativeMultiAgent: false };
+                const started = now();
+                planning = yield () => options.captureRoute ? options.captureRoute(planner, ctx, prompt, selection)
+                    : runCapturedAgent(planner, buildWatchdogInvocation(runnerInvocation(planner, prompt, ctx.targetDir, true, 'read-only', selection), options.idleTimeoutMs ?? 0));
+                calls.push(callUsage('orchestrator', planner, selection, planning.tokens, now() - started));
+                if (routingAssessmentKey(root, ctx.story) !== inputKey)
+                    return { ...blocked('Planning inputs changed during assessment; retry planning with the current contract'), tokens: aggregateCalls(calls) };
+                assessment = planning.success ? parseAssessment(planning.output) : undefined;
+                if (assessment)
+                    saveAssessment(root, ctx.story, assessment, { provider: planner, 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, 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 });
+            if (choice.blocked)
+                return { ...blocked(choice.reason), tokens: aggregateCalls(calls) };
+            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, attempt: choice.failures + 1, 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;
+            const infrastructureFailure = result.infrastructureFailure || (!result.success && knownInfrastructureFailure(result.summary));
+            return { ...result, summary: `route=${choice.worker?.id ?? 'SELF'} (${choice.reason}); ${result.summary}`,
+                ...(infrastructureFailure ? { success: false, infrastructureFailure: true } : {}),
+                tokens: { ...aggregateCalls(calls), storyId: ctx.story.id, escalated: choice.failures > 1 },
+                routing: { blocked: infrastructureFailure || undefined, canRetry: !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: 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,
+                            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 });
+                    } } };
+        }
         // 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));
@@ -154,6 +227,8 @@ function routingSteps(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) {
+            if (options.fallback === 'block' || options.maxTier)
+                return blocked('No eligible routing profiles; parent fallback is disabled');
             return yield () => makeWorker(options.parent, options.parentSelection ?? {})(ctx);
         }
         const prompt = buildRoutingPrompt(ctx, candidates, options.strategy);
@@ -168,6 +243,8 @@ function routingSteps(options) {
             : routeRun.success ? parseRouteDecision(routeRun.output, candidates.map(worker => worker.id)) : null;
         const selected = decision?.worker ?? 'SELF';
         const worker = selected === 'SELF' ? undefined : candidates.find(candidate => candidate.id === selected);
+        if ((!worker && (options.fallback === 'block' || options.maxTier)) || (options.maxTier && (!worker?.tier || tiers.indexOf(worker.tier) > tiers.indexOf(options.maxTier))))
+            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' ? { bare: options.parentSelection?.bare } : {}) }
@@ -236,3 +313,9 @@ function routingSteps(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')
@@ -90,10 +102,12 @@ export async function runSetup(targetDir, opts = {}) {
         config.routing = {
             ...config.routing,
             enabled: routing,
-            strategy: config.routing?.strategy ?? 'balanced',
+            strategy: opts.routingStrategy ?? config.routing?.strategy ?? 'capability',
             maxCandidates: config.routing?.maxCandidates ?? 3,
+            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 ? 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/BATCH-PLANNING-VALIDATION.md

@@ -0,0 +1,67 @@
+# Batch planning validation — 2026-09-06
+
+AI-assisted implementation record for the local development build after 1.9.0.
+No new version has been published by this task.
+
+## Implemented
+
+- One bounded assessment call for a selected package, with exact output IDs,
+  executable-criteria checks, project locking and atomic PRD replacement.
+- Separate planning provider/model/effort, complete draft/inbox assessments,
+  stale-contract detection including upstream requirements and the approved brief.
+- Prepared routing and blocked fallback in new setups; existing settings remain
+  compatible. Automatic tier ceilings block insufficient configurations.
+- Capability routing recognizes reported Windows process-creation/authentication
+  failures and failed gate evidence as infrastructure, stopping repair without
+  adding model-quality failures.
+
+## Actual Yoke run
+
+The current compiled development CLI ran in a separate `Yoke-batch` checkout with
+capability routing, prepared assessment, blocked fallback, a strong tier ceiling
+and one serial worker. The assigned task was limited to batch-command tests.
+Yoke chose `codex-standard`, requested `gpt-5.6-terra` at medium effort, verified
+the criterion tests and committed the result. The main checkout received only
+the reviewed test file; one assertion was strengthened during review.
+
+Recorded start: 2026-09-06T17:45:54.729Z. Terminal state: complete at
+17:50:41.108Z, one backlog task accepted. One measured worker call and no
+orchestrator/assessment call were recorded. Input: 546,591 tokens, including
+496,384 cached input tokens; output: 6,294 tokens. Reported monetary cost and
+actual model identity are unknown. This is no cost benchmark or measured saving.
+
+This run explicitly used unsafe permissions. It does not validate the Windows
+safe-mode execution reported in issue #5.
+
+## Issue #5 boundary
+
+**Follow-up:** the user subsequently requested completion of the runner correction.
+The reproduction, safe-mode end-to-end result and supervision changes are recorded
+in [WINDOWS-RUNNER-VALIDATION.md](WINDOWS-RUNNER-VALIDATION.md). The following paragraph
+describes the earlier batch-planning checkpoint.
+
+The user-provided runner handoff and [issue #5](https://github.com/HECer/yoke/issues/5)
+were read. The infrastructure-classification correction is partial. The original
+safe-mode shell failure has not been reproduced or diagnosed here. In particular,
+a preflight under the actual sandbox identity, streamed tool-error handling when
+a provider exits zero, separate heartbeat/useful-progress reporting, total process
+budgets and argument-safe Windows launch regressions remain open. Optional MCP
+startup warnings alone are not treated as proof of a task failure. No affected
+DeviceLane worktree was restarted or cleaned, and the issue was not closed.
+
+## Evidence scope
+
+Automated tests cover batch call suppression, invalid/partial/duplicate output,
+concurrent PRD edits, contract invalidation, planner/worker separation, prepared
+dispatch, tier limits and infrastructure repair suppression. Injected planner
+responses establish command behavior; they are not authenticated provider parity
+benchmarks. The full suite executed 1,166 tests in 127 files: 1,163 passed, two
+were skipped and one new test fixture lacked a required configuration field.
+After correcting that fixture, all 11 tests in its file passed. Subsequent
+focused routing checks cover the final input-freshness guard. Planning hashes
+establish input freshness, not provenance or correctness.
+
+Read-only provenance scan: no C2PA located, supported scan complete, verification,
+signer trust and Markdown metadata privacy unknown. The audit's limits are:
+"No conforming verifier was supplied." and "Keyed model-level watermarks cannot
+be checked without the provider's key." No authorship inference or mark removal.

package/docs/CAPABILITY-ROUTING.md

@@ -0,0 +1,82 @@
+# 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
+
+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.
+
+Run `yoke prd assess .` to assess all missing or stale unfinished tasks together. One invocation makes at most one read-only planner call, with exact task IDs and validated output, then atomically replaces the PRD. Invalid, incomplete or duplicate output leaves the PRD unchanged; concurrent input edits are preserved and the result is rejected. A current package uses zero model calls. `--story=ID` selects one unfinished task; `--reassess` also includes already-current assessments. The default package limit is 20 tasks (`planning.maxTasks`, range 1–50) and the prompt limit is 60,000 characters; oversized input is rejected before calling the provider.
+
+Yoke writes `assessmentFor` bindings over requirements, declared write scope/provider, transitive dependency contracts and `.yoke/plan.md`. Changes invalidate affected unfinished tasks; progress or priority changes do not. A changed brief invalidates all unfinished tasks. These hashes detect stale input, not authorship or semantic correctness. Source-code changes outside these contracts require explicit reassessment when relevant.
+
+Example settings alongside the project's existing worker profiles:
+
+```yaml
+runner:
+  agent: codex
+  model: gpt-5.6-terra
+planning:
+  agent: codex
+  model: gpt-6-astra
+  reasoningEffort: high
+  maxTasks: 20
+routing:
+  enabled: true
+  strategy: capability
+  assessmentPolicy: prepared
+  fallback: block
+  maxTier: strong
+  # Keep the existing workers list here.
+```
+
+`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
+```
+
+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.

package/docs/DASHBOARD-EVOLUTION.md

@@ -0,0 +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.

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

@@ -197,3 +197,31 @@ Die Umsetzung wurde mit Tests und einer lokalen Browserprüfung geprüft; authen
 ### 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.
+
+## Dashboard-Eigengebrauch am 2026-09-06 nach Release 1.9.0
+
+Der Nutzer hat eine vollständige Weiterentwicklung des Dashboards durch tatsächlichen Einsatz der neuesten Yoke-Version mit Routing beauftragt. Die global installierte Version 1.9.0 wurde verifiziert und im separaten Checkout `G:/NN-Developed/Yoke-dashboard` mit Capability-Routing eingesetzt; die zusammenhängende UI-Aufgabe wurde anhand ihrer gespeicherten Bewertung auf `codex-strong` / `gpt-5.6-sol` mit hoher Denktiefe geroutet. Ein einzelner serieller Auftrag vermeidet konkurrierende Änderungen an derselben Frontend-Navigation; das allgemeine Automatikmaximum bleibt drei Worker.
+
+Der lokale Ausbau ergänzt Statusvorrang für blockierte/laufende Loops trotz abgeschlossenem Ziel, Kennzeichnung veralteter Meldungen, Projektsuche und Statusfilter, aktuelle Aufgabe und Blocker auf Projektkarten, wiederherstellbare URL-Ansichten und UTC-Zeiträume, abbrechbare Projektvergleiche mit maximal drei gleichzeitigen Anfragen sowie Vorperiodenvergleiche mit sichtbaren Messlücken. Der Eigengebrauch deckte außerdem Fehler beim Umgang mit Git-Laufzeitdateien auf; Status/Sperren werden ausgeschlossen und Implementierungsdateien auch bei ignorierten Historienordnern sicher gestagt. Bedienung und Grenzen: [DASHBOARD-EVOLUTION.md](DASHBOARD-EVOLUTION.md).
+
+Unabhängige Browserprüfungen verwendeten synthetische Projekte gegen den echten lokalen HTTP-Server, einschließlich mobiler Darstellung, History-Navigation und verzögerter Antworten. Dieser Auftrag umfasst lokale Entwicklung; eine neue Paketversion oder Veröffentlichung wurde dabei nicht beauftragt. Kein behaupteter Modellbenchmark, keine berechnete Kostenersparnis und keine Rekonstruktion unbekannter Verbrauchsdaten. Diese Sitzungsnotiz wurde vom KI-Assistenten erstellt.
+
+## Batch-Planung nach 1.9.0 am 2026-09-06
+
+Der Nutzer hat den nächsten Ausbau beauftragt: vollständig vorbereitete Aufgabenpakete, getrennte Planungs-/Ausführungsmodelle, begrenzter Fallback und gezielte Neubewertung geänderter Verträge. Lokal implementiert sind prd assess, assessmentFor-Bindungen einschließlich Abhängigkeiten/Plan, planning-Einstellungen und Routing-Grenzen. Neue Setups verlangen vorbereitete Assessments und blockieren fehlende Profile; bestehende Konfigurationen bleiben kompatibel. Ein tatsächlicher Yoke-Lauf prüfte die Batch-Befehle mit einem auf Terra gerouteten Worker. Details, Messwerte und Grenzen: [BATCH-PLANNING-VALIDATION.md](BATCH-PLANNING-VALIDATION.md).
+
+Der zusätzliche Windows-Runner-Handoff wurde gelesen, Issue #5 geprüft und eine Teilkorrektur der Infrastrukturklassifikation samt begrenztem Abbruch ergänzt. Sandbox-Preflight und weitergehende Prozessaufsicht bleiben ausdrücklich offen; keine Reproduktion oder Behebung der ursprünglichen Windows-Ursache wird behauptet. Keine neue Version veröffentlicht. Diese Notiz wurde vom KI-Assistenten erstellt.
+
+## Vollständiger Runner-Folgeauftrag am 2026-09-06
+
+Auf ausdrücklichen Nutzerauftrag wurde Issue #5 weiterbearbeitet. Der Store-PowerShell-Fehler wurde modellfrei mit dem exakten Fehlercode reproduziert; native PowerShell bestand denselben Sandbox-Test. Der lokale Ausbau prüft den Shell-Start vor dem Modell, entfernt ungeeignete Store-Aliase nur aus der Provider-Umgebung, nutzt argv-sichere Windows-Starts und überwacht Laufzeit, Ausgabe, erfolgreichen Tool-Fortschritt und Prozessidentität getrennt. Ein echter Yoke-Lauf mit Luna, Routing und sicherer Isolation endete nach 3m8s erfolgreich einschließlich Abnahmetests und Commit-Integration. Protokoll, Grenzen und Konfiguration: [WINDOWS-RUNNER-VALIDATION.md](WINDOWS-RUNNER-VALIDATION.md). Die alte DeviceLane-Instanz wurde nicht verändert; Veröffentlichung oder rückwirkende Instrumentierung wird nicht behauptet. Diese Notiz wurde vom KI-Assistenten erstellt.

package/docs/WINDOWS-RUNNER-VALIDATION.md

@@ -0,0 +1,104 @@
+# Windows runner correction — 2026-09-06
+
+AI-assisted implementation and validation record for issue #5. These changes are
+included in 1.10.0; installed 1.9.0 packages and existing processes must be updated/restarted to use them.
+
+## Reproduction and correction
+
+On this machine, Codex 0.153.4 running the Microsoft Store PowerShell executable
+under `codex sandbox -P :workspace` reproduced `CreateProcessAsUserW failed:
+-1073283067`. The System32 Windows PowerShell executable succeeded under the
+same sandbox profile. A first end-to-end probe exposed a second entry point:
+the WindowsApps `pwsh.exe` app-execution alias failed with access denied.
+
+Yoke now filters Store PowerShell directories and their aliases from the provider's
+own PATH, prefers an available native PowerShell executable and tests it in the
+actual isolated working directory before starting the model. The same PATH is
+passed to Codex and its shell environment. This changes neither machine/user PATH
+nor sandbox privileges. Native PowerShell 7 is preferred; Windows PowerShell is
+the fallback when no native `pwsh.exe` is available. Projects requiring PowerShell
+7 should install a native distribution and make it available on PATH.
+
+The preflight uses the installed CLI's built-in `:workspace` or `:read-only`
+permission profile. An unsupported CLI/profile or failing shell blocks execution
+with an actionable message. No permission escalation or unsandboxed retry occurs.
+The preflight itself has a 30-second execution deadline, followed by bounded
+process-tree cleanup; an outer 90-second guard bounds an unresponsive supervisor.
+Environment values, prompts and raw authentication diagnostics are not stored in
+the supervision record.
+
+Windows npm launchers are resolved to their JavaScript entry point and invoked
+with a native Node argv array; executable providers are launched directly. Unknown
+batch launcher formats are rejected. This removes the provider/watchdog use of
+`shell: true` and preserves spaces, quotes, percent signs and shell metacharacters
+as literal arguments.
+
+## Supervision and failure behavior
+
+Both serial and parallel implementation providers have independent output,
+successful-tool/edit progress and overall timers. Defaults:
+
+```yaml
+loop:
+  timeoutMinutes: 20          # output inactivity; existing setting
+  progressTimeoutMinutes: 20 # no observed successful tool result or edit
+  maxCallMinutes: 30         # overall provider call
+```
+
+The two new settings accept positive values up to 1,440 minutes. Disabling the
+old output timeout does not disable the other bounds. Successful tool/edit events
+are evidence of activity, not proof that the product requirement has been met.
+
+Codex structured failed-tool events and its actual `exec_command failed:
+CreateProcess` stderr diagnostic stop the worker immediately. Terminal provider
+authentication errors are separate from optional MCP startup warnings; the latter
+alone do not fail the task. Failed infrastructure cannot produce a candidate or
+story success merely because existing tests happen to pass, and does not train
+capability escalation. Explicit `bare` startup settings now survive capability
+profile selection.
+
+Process records under `.yoke/supervision/` expose PID, process identity, supervisor
+heartbeat, current attempt, last output, last successful tool/edit and terminal reason. Status CLI
+and dashboard show these separately. Backlog ratios are labeled as backlog, not
+overall product completion. Live identity checks distinguish an existing PID from
+the recorded process. Tree termination checks that identity before reaping;
+unconfirmed termination retains ownership/evidence and blocks a subsequent worker.
+No retry/restart is triggered merely by an observer timing out. Failed worktrees
+remain available for inspection.
+
+## Validation
+
+- Model-free reproduction: Store executable failed with the reported code;
+  native System32 PowerShell passed in the same permission profile.
+- Both safe and read-only preflights passed with a 30,707 UTF-16-character inherited
+  environment in a path containing spaces. This simulates a large environment;
+  it does not reconstruct every variable in the original Visual Studio session.
+- Actual Yoke isolated safe-mode run: `codex-light`, requested `gpt-5.6-luna` at low
+  effort; task started 18:49:44 UTC and completed 18:52:52 UTC. Real shell commands,
+  file creation, two independent acceptance commands, verification and commit
+  integration succeeded. One model call, no assessment call. Recorded input
+  345,821 tokens (321,024 cached subset), output 2,353; monetary cost and actual
+  reported model identity remain unknown.
+- Regression tests cover literal argv, packaged aliases, streaming failure,
+  optional MCP diagnostics, total timeout despite heartbeat output, retained
+  redacted proof, no new worker after unconfirmed termination, and an actual
+  child failure propagated through capability routing and the worker gate.
+- Full suite: 1,170 passed, two skipped across 128 files at the recorded full-run
+  checkpoint. Final focused validation: 119 passed across five files, plus a
+  successful build and documentation consistency check.
+
+The original DeviceLane process was observed alive. It was not restarted or
+terminated, its retained worktree was not modified, and its application task was
+not claimed complete. Issue #5 was not closed or externally commented on. The fix
+must be installed before it can supervise a newly started DeviceLane run; it cannot
+retrofit supervision into an already running old process.
+
+Primary implementation reference consulted:
+[OpenAI shell detection](https://github.com/openai/codex/blob/main/codex-rs/shell-command/src/shell_detect.rs).
+The local executable probes above, rather than assumptions about upstream release
+contents, establish the behavior observed here.
+
+Read-only provenance audit: supported scan complete, no C2PA located; verification,
+signer trust and Markdown metadata privacy unknown. The audit states: "No conforming
+verifier was supplied." and "Keyed model-level watermarks cannot be checked without
+the provider's key." No authorship inference or watermark removal was performed.

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "yoke",
-  "version": "1.8.0",
+  "version": "1.10.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hecer/yoke",
-  "version": "1.8.0",
+  "version": "1.10.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": {