@hecer/yoke 1.9.0 → 1.10.0

package/dist/routing/capability.js

@@ -2,8 +2,9 @@ import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from 'n
 import { join } from 'node:path';
 import { AssessmentSchema, assessmentKey, requiredTier, tiers } from './assessment.js';
 import { projectHash, readRoutingObservations } from './registry.js';
+import { currentContractKey } from './contracts.js';
 export function knownInfrastructureFailure(summary) {
-    return /\bENOENT\b|\bECONNREFUSED\b|\bETIMEDOUT\b|command not found|is not recognized as|Missing script:|rate limit exceeded|authentication failed|invalid api key|credentials (?:missing|not found)|quota exceeded/i.test(summary);
+    return /\bENOENT\b|\bECONNREFUSED\b|\bETIMEDOUT\b|CreateProcess(?:AsUserW|W)? failed|Failed to create unified exec process|command not found|is not recognized as|Missing script:|rate limit exceeded|authentication failed|AuthRequired|No access token was provided|invalid api key|credentials (?:missing|not found)|quota exceeded/i.test(summary);
 }
 function statePath(root, key, create = false) {
     let dir = root;
@@ -19,16 +20,20 @@ function statePath(root, key, create = false) {
         throw new Error('Invalid routing state');
     return file;
 }
-export function readAssessment(root, story) {
-    if (story.assessment)
+export function routingAssessmentKey(root, story) {
+    return assessmentKey({ ...story, assessmentFor: currentContractKey(root, story) });
+}
+export function readAssessment(root, story, requireBound = false) {
+    const contract = currentContractKey(root, story);
+    if (story.assessment && (story.assessmentFor === contract || (!requireBound && !story.assessmentFor)))
         return story.assessment;
-    const file = statePath(root, assessmentKey(story));
+    const file = statePath(root, routingAssessmentKey(root, story));
     if (!existsSync(file))
         return undefined;
     return AssessmentSchema.parse(JSON.parse(readFileSync(file, 'utf8')).assessment);
 }
 export function saveAssessment(root, story, assessment, planner) {
-    const file = statePath(root, assessmentKey(story), true);
+    const file = statePath(root, routingAssessmentKey(root, story), true);
     const value = { version: 1, assessment: AssessmentSchema.parse(assessment), planner, createdAt: new Date().toISOString() };
     try {
         writeFileSync(file, JSON.stringify(value), { flag: 'wx', mode: 0o600 });
@@ -39,7 +44,7 @@ export function saveAssessment(root, story, assessment, planner) {
     }
 }
 export function taskOutcomes(root, story) {
-    return readRoutingObservations().filter(e => e.projectHash === projectHash(root) && e.assessmentKey === assessmentKey(story) && e.role === 'implementation' && e.failureKind !== 'infrastructure');
+    return readRoutingObservations().filter(e => e.projectHash === projectHash(root) && e.assessmentKey === routingAssessmentKey(root, story) && e.role === 'implementation' && e.failureKind !== 'infrastructure');
 }
 export function chooseCapability(input) {
     const role = input.role ?? 'implementation';
@@ -49,7 +54,7 @@ export function chooseCapability(input) {
     const baseTier = requiredTier(input.assessment, role);
     const level = Math.min(3, tiers.indexOf(baseTier) + Math.max(0, failures.length - 1, (input.repairRound ?? 1) - 1));
     const exhausted = failures.length >= Math.min(input.maxAttempts ?? 5, 5 - tiers.indexOf(baseTier));
-    const candidates = input.workers.filter(w => w.tier && tiers.indexOf(w.tier) >= level && (!w.roles || w.roles.includes(role)) && (!input.story.agent || w.agent === input.story.agent) && (input.available?.(w.agent) ?? true));
+    const candidates = input.workers.filter(w => w.tier && tiers.indexOf(w.tier) >= level && (!input.maxTier || tiers.indexOf(w.tier) <= tiers.indexOf(input.maxTier)) && (!w.roles || w.roles.includes(role)) && (!input.story.agent || w.agent === input.story.agent) && (input.available?.(w.agent) ?? true));
     const history = readRoutingObservations().filter(e => e.projectHash === projectHash(input.root) && e.taskClass === input.assessment.taskClass && e.requiredTier === baseTier && e.role === role && e.failureKind !== 'infrastructure' && Date.now() - Date.parse(e.recordedAt) < 30 * 86400000);
     const evidence = (w) => {
         const matching = history.filter(e => e.provider === w.agent && e.requestedModel === w.model && e.requestedReasoningEffort === w.reasoningEffort && e.actualModel);
@@ -61,19 +66,26 @@ export function chooseCapability(input) {
     const cost = { low: 0, medium: 1, high: 2 };
     reliable.sort((a, b) => tiers.indexOf(a.tier) - tiers.indexOf(b.tier) || cost[a.costTier] - cost[b.costTier] || a.id.localeCompare(b.id));
     const worker = reliable[0];
+    const blocked = !worker && (input.fallback === 'block' || input.maxTier !== undefined);
     const provider = worker?.agent ?? input.story.agent ?? input.parent;
-    const selection = worker ? { model: worker.model, reasoningEffort: worker.reasoningEffort, nativeMultiAgent: false }
+    const selection = worker ? { model: worker.model, reasoningEffort: worker.reasoningEffort, nativeMultiAgent: false, ...(provider !== 'gemini' && input.parentSelection?.bare !== undefined ? { bare: input.parentSelection.bare } : {}) }
         : { ...(provider === input.parent ? input.parentSelection : {}), nativeMultiAgent: false };
     const reason = `${role}: ${tiers[level]}; ${input.assessment.reason}${failures.length ? `; ${failures.length} verified failure(s), ${failures.length === 1 ? 'one targeted repair' : 'escalated'}` : ''}${worker ? '' : '; no eligible profile, parent/provider fallback'}`;
-    return { worker, provider, selection, reason, requiredTier: baseTier, selectedTier: tiers[level], failures: failures.length, exhausted, next: level < 3 ? tiers[level + 1] : 'stop after bounded attempts' };
+    return { worker, provider, selection, reason: blocked ? `${role}: no eligible profile within routing limits; execution blocked` : reason, blocked, requiredTier: baseTier, selectedTier: tiers[level], failures: failures.length, exhausted, next: input.maxTier && level >= tiers.indexOf(input.maxTier) ? 'stop at configured tier limit' : level < 3 ? tiers[level + 1] : 'stop after bounded attempts' };
 }
 /** Explicit role models are resolved by callers before consulting this fallback. */
 export function roleSelection(root, config, story, provider, role, repairRound = 1) {
     if (!config.routing?.enabled || config.routing.strategy !== 'capability')
         return undefined;
-    const assessment = readAssessment(root, story);
-    if (!assessment)
+    const assessment = readAssessment(root, story, config.routing.assessmentPolicy === 'prepared');
+    if (!assessment) {
+        if (config.routing.assessmentPolicy === 'prepared')
+            throw Error('Prepare current task assessments before role execution');
         return undefined;
-    return chooseCapability({ root, story: { ...story, agent: provider }, assessment, workers: config.routing.workers, parent: provider,
-        parentSelection: provider === config.runner?.agent ? config.runner : undefined, role, repairRound, maxAttempts: config.routing.maxAttempts }).selection;
+    }
+    const choice = chooseCapability({ root, story: { ...story, agent: provider }, assessment, workers: config.routing.workers, parent: provider,
+        parentSelection: provider === config.runner?.agent ? config.runner : undefined, role, repairRound, maxAttempts: config.routing.maxAttempts, fallback: config.routing.fallback, maxTier: config.routing.maxTier });
+    if (choice.blocked)
+        throw Error(choice.reason);
+    return choice.selection;
 }

package/dist/routing/contracts.js

@@ -0,0 +1,60 @@
+import { createHash } from 'node:crypto';
+import { lstatSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+export function readPlanningFile(root, relative, maxBytes = 1_048_576) {
+    let file = root;
+    for (const part of relative.split('/')) {
+        file = join(file, part);
+        let stat;
+        try {
+            stat = lstatSync(file);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+        if (stat.isSymbolicLink())
+            throw Error('Linked planning state is unavailable');
+    }
+    const stat = lstatSync(file);
+    if (!stat.isFile() || stat.size > maxBytes)
+        throw Error('Planning state exceeds its file limit');
+    return readFileSync(file, 'utf8');
+}
+const hash = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+/** Progress, priority and model output do not change a task's requirements. */
+export function contractKeys(stories, brief = '') {
+    const byId = new Map(stories.map(story => [story.id, story]));
+    if (byId.size !== stories.length || stories.length > 2000)
+        throw Error('Invalid planning task set');
+    const keys = new Map(), visiting = new Set();
+    const plan = hash(brief);
+    const visit = (id) => {
+        if (keys.has(id))
+            return keys.get(id);
+        const s = byId.get(id);
+        if (!s || visiting.has(id))
+            throw Error('Invalid planning dependency graph');
+        visiting.add(id);
+        const upstream = [...(s.needs ?? [])].sort().map(need => [need, visit(need)]);
+        const key = hash({ version: 1, plan, id: s.id, title: s.title, acceptance: s.acceptance, writes: s.writes, area: s.area, agent: s.agent, upstream });
+        visiting.delete(id);
+        keys.set(id, key);
+        return key;
+    };
+    for (const story of stories)
+        visit(story.id);
+    return keys;
+}
+export function currentContractKey(root, story) {
+    const source = readPlanningFile(root, '.yoke/prd.yaml');
+    const parsed = source === undefined ? [] : parse(source, { maxAliasCount: 10 });
+    if (!Array.isArray(parsed))
+        throw Error('Invalid planning task set');
+    // Use the supplied dispatch contract, while obtaining upstream contracts from
+    // the stable project root rather than a worker's mutable worktree copy.
+    const stories = [...parsed.filter(s => s.id !== story.id), story];
+    return contractKeys(stories, readPlanningFile(root, '.yoke/plan.md', 80_000) ?? '').get(story.id);
+}

package/dist/routing/planning.js

@@ -0,0 +1,12 @@
+/** Planning settings never replace the execution model or provider. */
+export function resolvePlanner(config, start, selection = {}, override) {
+    const agent = override ?? config?.planning?.agent ?? start;
+    const inherited = agent === start ? selection : {};
+    const planning = !override || override === (config?.planning?.agent ?? start) ? config?.planning : undefined;
+    return { agent, selection: {
+            model: planning?.model ?? inherited.model,
+            reasoningEffort: planning?.reasoningEffort ?? inherited.reasoningEffort,
+            bare: inherited.bare,
+            nativeMultiAgent: false,
+        } };
+}

package/dist/routing/router.js

@@ -1,8 +1,9 @@
 import { buildWatchdogInvocation, makeRunner, runCapturedAgent, runnerInvocation, contextBlockFor, } from '../loop/runner.js';
-import { isAcceptanceCriterion } from '../loop/prd.js';
+import { isAcceptanceCriterion, criterionCommandProblem } 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';
+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);
@@ -144,43 +145,73 @@ 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 = readAssessment(root, ctx.story);
+            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 selection = { ...options.parentSelection, nativeMultiAgent: false };
+                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(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));
+                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: options.parent, model: planning.tokens?.model ?? selection.model });
+                    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 });
+            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, story: { ...ctx.story, assessment } });
+            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: { canRetry: !result.infrastructureFailure && choice.failures + 1 < (options.maxAttempts ?? 5), recordOutcome: (verified, failureKind) => {
+                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: assessmentKey(ctx.story), taskClass: assessment.taskClass, requiredTier: choice.requiredTier,
+                        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.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,
+                            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 });
                     } } };
         }
@@ -196,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);
@@ -210,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 } : {}) }

package/dist/setup/command.js

@@ -104,6 +104,8 @@ export async function runSetup(targetDir, opts = {}) {
             enabled: routing,
             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 && !opts.routingPreset ? existingWorkers : defaultRoutingWorkers(agents),
         };

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

@@ -1,6 +1,6 @@
 # Routing by task requirements
 
-Available in Yoke 1.9.0.
+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:
 
@@ -12,7 +12,35 @@ Give each existing worker a `tier: light|standard|strong|frontier`. Profiles wit
 
 ## 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.
+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.
 
@@ -28,7 +56,7 @@ assessment:
   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.
+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
 

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

@@ -207,3 +207,21 @@ Der Nutzer hat die Umsetzung der vorgeschlagenen Fähigkeitsauswahl ausdrücklic
 ### 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.9.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.9.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": {