@hecer/yoke 1.6.1 → 1.7.0

package/dist/loop/run-command.js

@@ -14,12 +14,14 @@ import { runAudit } from '../audit/command.js';
 import { detectHostAgent, resolveRunnerAgent } from '../agents/host.js';
 import { buildTrustedDecisionResumeState, clearDecisionResume, decisionProcessingExists, decisionRequestId, formatPendingDecision, readPendingDecision, writeDecisionResume, } from './decision.js';
 import { makeAdaptiveRunner } from '../routing/router.js';
+import { makeActionRunner } from '../execution/actions.js';
 import { runChangeApply } from '../change/inbox.js';
 import { createQualityCommandHooks } from '../quality/command.js';
 import { resolveQualityPolicy } from '../quality/types.js';
 import { runParallelLoopCommand } from './parallel-command.js';
 import { detectUiProject } from '../retrofit/ui-detect.js';
 import { designVerifier } from '../scan/gate.js';
+import { prepareIsolatedWorktree } from './recovery.js';
 export const DEFAULT_IDLE_MINUTES = 20;
 const STALE_MINUTES = 20; // a running status older than this likely means the loop died
 export function relativeTime(fromIso, now) {
@@ -97,6 +99,10 @@ export function resolveIdleMs(flagMinutes, configMinutes) {
 export function runLoopCommand(targetDir, opts) {
     const parallel = opts.parallel ?? 1;
     const candidates = opts.candidates ?? 1;
+    if (opts.resumeWorktree && (!opts.isolate || parallel !== 1 || candidates !== 1)) {
+        console.error('--resume-worktree requires --isolate --parallel=1 --candidates=1');
+        return 2;
+    }
     if (!Number.isInteger(parallel) || parallel < 1) {
         console.error('--parallel must be a positive integer');
         return 2;
@@ -177,7 +183,10 @@ export function runLoopCommand(targetDir, opts) {
     maybeAutoUpgrade(config.update?.auto);
     const available = opts.isAvailable ?? isAgentAvailable;
     const runnerAgent = resolveRunnerAgent(config, opts.agent, detectHostAgent());
-    const git = opts.git ?? realGitOps;
+    const git = opts.git ?? {
+        ...realGitOps,
+        addWorktree: (repo, worktree) => prepareIsolatedWorktree(repo, worktree, opts.resumeWorktree === true),
+    };
     let commitIdentity = opts.commitIdentity;
     if (!commitIdentity && !opts.git) {
         try {
@@ -242,7 +251,7 @@ export function runLoopCommand(targetDir, opts) {
         model: config.runner?.model,
         reasoningEffort: config.runner?.reasoningEffort,
         bare: config.runner?.bare,
-        ...((routingEnabled || opts.routing === false) ? { nativeMultiAgent: false } : {}),
+        ...((runnerAgent === 'codex' && (routingEnabled || opts.routing === false)) ? { nativeMultiAgent: false } : {}),
     };
     if ((parallel > 1 || candidates > 1) && routingEnabled) {
         console.error('Adaptive routing is not available with parallel workers or quality candidates. Run with --parallel=1 --candidates=1 or disable routing.');
@@ -303,7 +312,7 @@ export function runLoopCommand(targetDir, opts) {
     if (!runner) {
         const requiredProviders = parallel > 1 || candidates > 1
             ? [...new Set(loadPrd(path).filter(story => !story.passes).map(story => story.agent ?? runnerAgent))]
-            : [runnerAgent];
+            : loadPrd(path).filter(story => !story.passes).every(story => config.actions?.some(action => action.storyId === story.id)) ? [] : [runnerAgent];
         const unavailableProvider = requiredProviders.find(agent => !available(agent));
         if (unavailableProvider) {
             console.error(`Agent CLI "${unavailableProvider}" was not found on PATH. Install it, or pick another with --runner=<claude|codex|gemini>.`);
@@ -324,6 +333,7 @@ export function runLoopCommand(targetDir, opts) {
                 parentSelection: runnerOpts.selection,
                 orchestratorSelection: config.routing.orchestrator ?? runnerOpts.selection,
                 workers: config.routing.workers,
+                rules: config.routing.rules,
                 strategy: config.routing.strategy,
                 maxCandidates: config.routing.maxCandidates,
                 idleTimeoutMs: idleMs,
@@ -335,6 +345,13 @@ export function runLoopCommand(targetDir, opts) {
         const announce = opts.json ? console.error : console.log;
         announce(`Runner: ${runnerAgent} · permissions: ${permissions} · routing: ${routingEnabled ? 'on' : 'off'} · cwd: ${targetDir}`);
     }
+    if (config.actions?.length) {
+        if (parallel > 1 || candidates > 1) {
+            console.error('Configured tool actions currently require --parallel=1 --candidates=1');
+            return 2;
+        }
+        runner = makeActionRunner(config.actions, runner);
+    }
     let review = opts.reviewRunner;
     if (!review && (opts.review || opts.reviewer)) {
         const reviewerAgent = opts.reviewer ?? ['codex', 'gemini', 'claude'].find(agent => agent !== runnerAgent && available(agent));

package/dist/loop/runner.js

@@ -1,15 +1,18 @@
 import { isAcceptanceCriterion } from './prd.js';
+import { workspaceFingerprint } from '../workspace/fingerprint.js';
 import { execFileSync, execSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { loadContext, formatForPrompt, contextDir } from '../context/context.js';
+import { contextPacket } from '../context/packet.js';
 import { buildProviderInvocation, startProviderProcess } from '../agents/providers.js';
 import { parseProviderResult, parseProviderTelemetry } from '../agents/telemetry.js';
 import { formatReviewContract, formatReviewStdoutContract, parseReviewVerdict } from '../review/verdict.js';
-export function contextBlockFor(targetDir) {
-    return formatForPrompt(loadContext(contextDir(targetDir)));
+export function contextBlockFor(targetDir, story) {
+    const context = loadContext(contextDir(targetDir));
+    return story ? contextPacket(context, `${story.title} ${story.area ?? ''} ${story.acceptance.map(c => typeof c === 'string' ? c : c.text).join(' ')}`) : formatForPrompt(context);
 }
 function formatAcceptance(story) {
     return story.acceptance.map(criterion => {
@@ -300,7 +303,7 @@ export function runReviewAgent(inv) {
     }
 }
 export function makeAsyncRunner(agent, opts = {}) {
-    return (ctx) => startProviderProcess(agent, runnerInvocation(agent, buildClaudePrompt(ctx.story, contextBlockFor(ctx.targetDir), opts.onAmbiguity, opts.perfCommand), ctx.targetDir, true, opts.permissions ?? 'safe', opts.selection), opts.process);
+    return (ctx) => startProviderProcess(agent, runnerInvocation(agent, buildClaudePrompt(ctx.story, contextBlockFor(ctx.targetDir, ctx.story), opts.onAmbiguity, opts.perfCommand), ctx.targetDir, true, opts.permissions ?? 'safe', opts.selection), opts.process);
 }
 export function makeRunner(agent, idleTimeoutMs = 0, opts = {}) {
     // Claude always streams (see runnerInvocation) — capture the stream so tokens are
@@ -308,7 +311,7 @@ export function makeRunner(agent, idleTimeoutMs = 0, opts = {}) {
     // redundant for claude and meaningless elsewhere; kept for caller compatibility.
     const captureTokens = true;
     return (ctx) => {
-        const base = runnerInvocation(agent, buildClaudePrompt(ctx.story, contextBlockFor(ctx.targetDir), opts.onAmbiguity, opts.perfCommand), ctx.targetDir, captureTokens, opts.permissions ?? 'safe', opts.selection);
+        const base = runnerInvocation(agent, buildClaudePrompt(ctx.story, contextBlockFor(ctx.targetDir, ctx.story), opts.onAmbiguity, opts.perfCommand), ctx.targetDir, captureTokens, opts.permissions ?? 'safe', opts.selection);
         const inv = buildWatchdogInvocation(base, idleTimeoutMs);
         if (captureTokens) {
             const capture = opts.execCapture ?? runCliCapture;
@@ -340,7 +343,7 @@ export const claudeRunner = makeRunner('claude');
 export function makeReviewRunner(agent, idleTimeoutMs = 0, exec) {
     return (ctx) => {
         const before = repositoryFingerprint(ctx.targetDir);
-        const base = agentInvocation(agent, buildReviewPrompt(ctx.story, contextBlockFor(ctx.targetDir), undefined, agent), ctx.targetDir, 'read-only');
+        const base = agentInvocation(agent, buildReviewPrompt(ctx.story, contextBlockFor(ctx.targetDir, ctx.story), undefined, agent), ctx.targetDir, 'read-only');
         const inv = buildWatchdogInvocation(base, idleTimeoutMs);
         let processFailure;
         let actualModel;
@@ -380,13 +383,7 @@ export function makeReviewRunner(agent, idleTimeoutMs = 0, exec) {
     };
 }
 export function repositoryFingerprint(targetDir) {
-    try {
-        return execFileSync('git', ['diff', '--binary', 'HEAD'], { cwd: targetDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
-            + execFileSync('git', ['status', '--porcelain=v1', '-z'], { cwd: targetDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-    }
-    catch {
-        return '';
-    }
+    return workspaceFingerprint(targetDir);
 }
 function reviewResult(agent, storyId, verdict, reviewOutcome) {
     return verdict.approved

package/dist/loop/scheduler.js

@@ -1,8 +1,45 @@
+export function validWriteScope(scope) {
+    const normalized = scope.replace(/\\/gu, '/').replace(/\/$/u, '');
+    return Boolean(normalized) && scope === scope.trim() && !/[\0\r\n:*?<>|\[\]{}]/u.test(normalized) && normalized.split('/').every(part => part !== '' && part !== '.' && part !== '..');
+}
+/** Advisory declarations: unknown scopes preserve existing scheduler behavior. */
+export function writeScopesOverlap(left = [], right = []) {
+    const normalize = (value) => value.replace(/\\/gu, '/').replace(/\/$/u, '').toLowerCase();
+    return left.some(a => right.some(b => {
+        const first = normalize(a), second = normalize(b);
+        return first === second || first.startsWith(`${second}/`) || second.startsWith(`${first}/`);
+    }));
+}
+/** Remaining dependency depth provides a deterministic critical-path tie-break. */
+export function criticalPathRanks(stories) {
+    const children = new Map();
+    for (const story of stories.filter(story => !story.passes))
+        for (const need of story.needs ?? [])
+            children.set(need, [...(children.get(need) ?? []), story.id]);
+    const ranks = new Map();
+    const visiting = new Set();
+    const rank = (id) => {
+        if (ranks.has(id))
+            return ranks.get(id);
+        if (visiting.has(id))
+            return 0;
+        visiting.add(id);
+        const value = 1 + Math.max(0, ...(children.get(id) ?? []).map(rank));
+        visiting.delete(id);
+        ranks.set(id, value);
+        return value;
+    };
+    for (const story of stories)
+        rank(story.id);
+    return ranks;
+}
 export function readyStories(stories, opts = {}) {
     const passed = new Set(stories.filter(story => story.passes).map(story => story.id));
+    const ranks = criticalPathRanks(stories);
     return stories
         .filter(story => !story.passes)
         .filter(story => (story.needs ?? []).every(id => passed.has(id)))
         .filter(story => !story.area || !opts.activeAreas?.has(story.area))
-        .sort((a, b) => a.priority - b.priority || Number(b.agent === opts.agent) - Number(a.agent === opts.agent) || a.id.localeCompare(b.id));
+        .filter(story => !opts.activeWrites?.some(scopes => writeScopesOverlap(story.writes, scopes)))
+        .sort((a, b) => a.priority - b.priority || (ranks.get(b.id) ?? 0) - (ranks.get(a.id) ?? 0) || Number(b.agent === opts.agent) - Number(a.agent === opts.agent) || a.id.localeCompare(b.id));
 }

package/dist/loop/watchdog.js

@@ -62,6 +62,8 @@ export function killProcessTreeForCleanup(pid, platform = process.platform, runT
     }
 }) {
     if (platform === 'win32') {
+        // taskkill reports a non-zero status when the process disappeared between
+        // observation and cleanup; that is already the desired terminal state.
         if (runTaskkill('taskkill', ['/PID', String(pid), '/T', '/F']) !== 0)
             return !isProcessAlive(pid);
         return confirmProcessStopped(pid, isProcessAlive);

package/dist/observability/events.js

@@ -0,0 +1,67 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readdirSync, lstatSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+export const EVENT_CAP = 1000;
+export const EVENT_MAX_BYTES = 64 * 1024;
+const namePattern = /^\d{13}-[a-f0-9-]{36}\.json$/u;
+let lastStamp = 0;
+function directory(root, create) {
+    const parent = join(root, '.yoke');
+    if (create)
+        mkdirSync(parent, { recursive: true });
+    if (lstatSync(parent).isSymbolicLink())
+        throw new Error('Event parent is a symbolic link');
+    const dir = join(parent, 'events');
+    if (create)
+        mkdirSync(dir, { recursive: true });
+    if (!lstatSync(dir).isDirectory() || lstatSync(dir).isSymbolicLink())
+        throw new Error('Invalid event directory');
+    return dir;
+}
+/** Files are created once, never rewritten. Retention removes oldest whole events. */
+export function appendEvent(root, event) {
+    try {
+        const dir = directory(root, true);
+        const id = randomUUID();
+        let content = JSON.stringify({ ...event, schemaVersion: 1, id });
+        if (Buffer.byteLength(content) > EVENT_MAX_BYTES)
+            content = JSON.stringify({ ...event, data: { truncated: true }, schemaVersion: 1, id });
+        if (Buffer.byteLength(content) > EVENT_MAX_BYTES)
+            return;
+        lastStamp = Math.max(Date.now(), lastStamp + 1);
+        writeFileSync(join(dir, `${String(lastStamp).padStart(13, '0')}-${id}.json`), content, { flag: 'wx' });
+        const names = readdirSync(dir).filter(name => namePattern.test(name)).sort();
+        for (const name of names.slice(0, Math.max(0, names.length - EVENT_CAP)))
+            unlinkSync(join(dir, name));
+    }
+    catch { /* Local observability must never abort work. */ }
+}
+/** Bounded, chronological reads; malformed, oversized and linked files are ignored. */
+export function readEvents(root, limit = 200) {
+    if (!Number.isFinite(limit) || limit <= 0)
+        return [];
+    try {
+        const dir = directory(root, false);
+        const names = readdirSync(dir).filter(name => namePattern.test(name)).sort().slice(-Math.min(EVENT_CAP, Math.floor(limit)));
+        return names.flatMap(name => {
+            try {
+                const file = join(dir, name);
+                const stat = lstatSync(file);
+                if (!stat.isFile() || stat.isSymbolicLink() || stat.size > EVENT_MAX_BYTES)
+                    return [];
+                const value = JSON.parse(readFileSync(file, 'utf8'));
+                if (value?.schemaVersion !== 1 || typeof value.id !== 'string' || typeof value.runId !== 'string' || typeof value.timestamp !== 'string' || !Number.isFinite(Date.parse(value.timestamp)) || !['status', 'tokens', 'phase-ended', 'attempt-ended'].includes(value.type))
+                    return [];
+                if (value.durationMs !== undefined && (!Number.isFinite(value.durationMs) || value.durationMs < 0))
+                    return [];
+                return [value];
+            }
+            catch {
+                return [];
+            }
+        }).sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/retrofit/config.js

@@ -5,6 +5,7 @@ import { z } from 'zod';
 import { AgentSchema, PermissionProfileSchema } from '../agents/contracts.js';
 import { ProjectQualityDefaultsSchema } from '../quality/types.js';
 import { DEFAULT_OUTPUT_POLICY } from '../output/types.js';
+import { ToolActionSchema } from '../execution/actions.js';
 const CodeGraphSchema = z.enum(['graphify', 'serena']);
 const SmokeFlowSchema = z.object({ name: z.string().min(1), path: z.string().min(1), landmark: z.string().optional() });
 const SmokeSchema = z.object({ baseUrl: z.string().min(1), flows: z.array(SmokeFlowSchema).min(1) });
@@ -30,8 +31,15 @@ const RoutingWorkerSchema = z.object({
     costTier: z.enum(['low', 'medium', 'high']).default('medium'),
     capabilities: z.array(z.string().min(1)).default([]),
 });
+const RoutingRuleSchema = z.object({
+    area: z.string().min(1).optional(),
+    storyId: z.string().min(1).optional(),
+    worker: z.string().min(1),
+    escalateTo: z.string().min(1).optional(),
+}).strict().refine(rule => rule.area || rule.storyId, 'A routing rule needs area or storyId');
 export const YokeConfigSchema = z.object({
     canonVersion: z.string().min(1),
+    actions: z.array(ToolActionSchema).max(100).optional(),
     agents: z.array(AgentSchema),
     loop: z.object({
         enabled: z.boolean(),
@@ -57,6 +65,7 @@ export const YokeConfigSchema = z.object({
             reasoningEffort: z.string().min(1).optional(),
         }).optional(),
         workers: z.array(RoutingWorkerSchema).max(12).default([]),
+        rules: z.array(RoutingRuleSchema).max(100).optional(),
     }).optional(),
     commit: z.object({
         authorName: z.string().min(1).optional(),

package/dist/retrofit/gitignore.js

@@ -24,6 +24,11 @@ export const YOKE_IGNORE_LINES = [
     '.yoke/references/',
     '.yoke/changes/',
     '.yoke/artifacts/',
+    '.yoke/checks/',
+    '.yoke/events/',
+    '.yoke/goal.json',
+    '.yoke/goal.json.*.tmp',
+    '.yoke/goal.pause',
 ];
 const HEADER = '# Yoke runtime artifacts (managed by yoke retrofit)';
 // Idempotently ensure each Yoke runtime path is gitignored. Appends only the

package/dist/retrofit/planners/gemini.js

@@ -11,7 +11,7 @@ function tomlString(s) {
 export function planGemini(canonDir, _targetDir, codeGraph = 'graphify') {
     const manifest = loadManifest(join(canonDir, 'manifest.yaml'));
     const actions = [];
-    // GEMINI.md: baseline + rtk instruction (Gemini has no rewrite hook).
+    // GEMINI.md: baseline + instruction for commands outside the rewrite hook.
     const baseline = readFileSync(join(canonDir, 'AGENTS.md'), 'utf8');
     const autoSkillIndex = manifest.skills
         .filter(skill => skill.invocation === 'auto')
@@ -25,7 +25,7 @@ export function planGemini(canonDir, _targetDir, codeGraph = 'graphify') {
         kind: 'write',
         target: 'GEMINI.md',
         content: `${baseline}\n${rtkInstruction()}\n\n## Yoke automatic skills\n\nUse the matching command when its capability is relevant:\n\n${autoSkillIndex}\n\n${PRESERVE_SCAFFOLD}\n`,
-        reason: 'baseline + rtk instruction (no hook on Gemini)',
+        reason: 'baseline + rtk instruction',
     });
     // One TOML slash command per skill.
     for (const skill of manifest.skills) {
@@ -44,13 +44,21 @@ export function planGemini(canonDir, _targetDir, codeGraph = 'graphify') {
         });
         actions.push(...skillPackageActions(canonDir, skill, 'gemini'));
     }
-    // settings.json: MCP servers + read AGENTS.md as context.
+    actions.push({
+        kind: 'write',
+        target: '.gemini/hooks/gemini-rtk-hook.mjs',
+        content: readFileSync(join(canonDir, 'tools/gemini-rtk-hook.mjs'), 'utf8'),
+        reason: 'portable RTK BeforeTool argument adapter',
+    });
+    // Merge to preserve user MCP servers, context and unrelated hooks.
     actions.push({
         kind: 'write',
         target: '.gemini/settings.json',
+        merge: true,
         content: JSON.stringify({
             mcpServers: mcpServers(codeGraph),
             context: { fileName: ['AGENTS.md', 'GEMINI.md'] },
+            hooks: { BeforeTool: [{ matcher: '^run_shell_command$', hooks: [{ name: 'yoke-rtk', type: 'command', command: 'node .gemini/hooks/gemini-rtk-hook.mjs' }] }] },
         }, null, 2) + '\n',
         reason: 'MCP servers + AGENTS.md context',
     });

package/dist/routing/router.js

@@ -1,6 +1,6 @@
 import { buildWatchdogInvocation, makeRunner, runCapturedAgent, runnerInvocation, } from '../loop/runner.js';
 import { isAcceptanceCriterion } from '../loop/prd.js';
-import { historyForWorkers, projectHash, recordRoutingObservation, storyHash } from './registry.js';
+import { historyForWorkers, projectHash, readRoutingObservations, recordRoutingObservation, storyHash } from './registry.js';
 const costRank = { low: 0, medium: 1, high: 2 };
 export function rankWorkers(workers, strategy, maxCandidates) {
     const history = historyForWorkers(workers);
@@ -105,6 +105,7 @@ function callUsage(role, provider, selection, tokens, durationMs, profile) {
         ...(tokens?.cachedInputTokens !== undefined ? { cachedInputTokens: tokens.cachedInputTokens } : {}),
         ...(tokens?.cacheWriteInputTokens !== undefined ? { cacheWriteInputTokens: tokens.cacheWriteInputTokens } : {}),
         outputTokens: tokens?.outputTokens ?? 0,
+        usageAvailable: tokens !== undefined && tokens.measurementComplete !== false,
         ...(tokens?.reasoningOutputTokens !== undefined ? { reasoningOutputTokens: tokens.reasoningOutputTokens } : {}),
         ...(tokens?.totalCostUsd !== undefined ? { totalCostUsd: tokens.totalCostUsd } : {}),
         durationMs,
@@ -114,6 +115,7 @@ export function makeAdaptiveRunner(options) {
     const now = options.now ?? Date.now;
     const available = options.isAvailable ?? (() => true);
     const eligibleWorkers = options.workers.filter(worker => available(worker.agent));
+    const failedStories = new Set();
     const makeWorker = options.makeWorker ?? ((agent, selection) => makeRunner(agent, options.idleTimeoutMs ?? 0, {
         ...options.runnerOpts,
         permissions: options.permissions ?? 'safe',
@@ -122,29 +124,39 @@ export function makeAdaptiveRunner(options) {
     return (ctx) => {
         // Re-rank per story so a long-running loop can use gate outcomes learned by
         // earlier stories without rebuilding the runner.
-        const candidates = rankWorkers(eligibleWorkers, options.strategy, options.maxCandidates);
+        const rule = options.rules?.find(rule => (!rule.area || rule.area === ctx.story.area) && (!rule.storyId || rule.storyId === ctx.story.id) && (rule.area || rule.storyId));
+        if (rule) {
+            const project = projectHash(ctx.targetDir);
+            const prior = readRoutingObservations().reverse().find(event => event.projectHash === project && event.storyHash === storyHash(project, ctx.story.id) && typeof event.verificationSuccess === 'boolean');
+            if (prior?.verificationSuccess === false)
+                failedStories.add(ctx.story.id);
+        }
+        const ruleWorker = rule && failedStories.has(ctx.story.id) ? rule.escalateTo ?? 'SELF' : rule?.worker;
+        const candidates = rule ? eligibleWorkers : rankWorkers(eligibleWorkers, options.strategy, options.maxCandidates);
         if (candidates.length === 0) {
             return makeWorker(options.parent, options.parentSelection ?? {})(ctx);
         }
         const prompt = buildRoutingPrompt(ctx, candidates, options.strategy);
-        const orchestratorSelection = { ...(options.parentSelection ?? {}), ...(options.orchestratorSelection ?? {}), nativeMultiAgent: false };
+        const orchestratorSelection = { ...(options.parentSelection ?? {}), ...(options.orchestratorSelection ?? {}), ...(options.parent === 'codex' ? { nativeMultiAgent: false } : {}) };
         const orchestratorStarted = now();
-        const routeRun = options.captureRoute
+        const routeRun = rule ? { success: true, summary: 'Explicit rule', output: '', tokens: { inputTokens: 0, outputTokens: 0 } } : options.captureRoute
             ? options.captureRoute(options.parent, ctx, prompt, orchestratorSelection)
             : runCapturedAgent(options.parent, buildWatchdogInvocation(runnerInvocation(options.parent, prompt, ctx.targetDir, true, 'read-only', orchestratorSelection), options.idleTimeoutMs ?? 0));
         const orchestratorDurationMs = Math.max(0, now() - orchestratorStarted);
-        const decision = routeRun.success ? parseRouteDecision(routeRun.output, candidates.map(worker => worker.id)) : null;
+        const decision = rule
+            ? { worker: ruleWorker === 'SELF' || candidates.some(w => w.id === ruleWorker) ? ruleWorker : 'SELF', reason: failedStories.has(ctx.story.id) ? 'gate failure escalated by project rule' : 'explicit project routing rule' }
+            : 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);
         const provider = worker?.agent ?? options.parent;
         const selection = worker
-            ? { model: worker.model, reasoningEffort: worker.reasoningEffort, nativeMultiAgent: false, bare: options.parentSelection?.bare }
-            : { ...(options.parentSelection ?? {}), nativeMultiAgent: false };
+            ? { model: worker.model, reasoningEffort: worker.reasoningEffort, ...(provider === 'codex' ? { nativeMultiAgent: false } : {}), ...(provider !== 'gemini' ? { bare: options.parentSelection?.bare } : {}) }
+            : { ...(options.parentSelection ?? {}), ...(provider === 'codex' ? { nativeMultiAgent: false } : {}) };
         const workerStarted = now();
         const result = makeWorker(provider, selection)(ctx);
         const workerDurationMs = Math.max(0, now() - workerStarted);
         const calls = [
-            callUsage('orchestrator', options.parent, orchestratorSelection, routeRun.tokens, orchestratorDurationMs),
+            ...(!rule ? [callUsage('orchestrator', options.parent, orchestratorSelection, routeRun.tokens, orchestratorDurationMs)] : []),
             callUsage(worker ? 'worker' : 'parent', provider, selection, result.tokens, workerDurationMs, selected),
         ];
         const tokens = {
@@ -164,12 +176,18 @@ export function makeAdaptiveRunner(options) {
                 : {}),
             ...(result.tokens?.model ? { model: result.tokens.model } : routeRun.tokens?.model ? { model: routeRun.tokens.model } : {}),
             calls,
+            measurementComplete: calls.every(call => call.usageAvailable),
+            costMeasurementComplete: calls.every(call => call.totalCostUsd !== undefined),
         };
         let recorded = false;
         const recordOutcome = (verificationSuccess) => {
             if (recorded)
                 return;
             recorded = true;
+            if (!verificationSuccess)
+                failedStories.add(ctx.story.id);
+            else
+                failedStories.delete(ctx.story.id);
             const project = projectHash(ctx.targetDir);
             recordRoutingObservation({
                 projectHash: project,

package/dist/workspace/fingerprint.js

@@ -0,0 +1,66 @@
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { lstatSync, readFileSync, readdirSync, readlinkSync, realpathSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+/** Content identity, including new files. Symlinks are identified, never followed. */
+export function workspaceFingerprint(directory) {
+    const root = realpathSync(directory);
+    const hash = createHash('sha256');
+    let names;
+    const git = (args) => execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 32 * 1024 * 1024 });
+    try {
+        git(['rev-parse', '--show-toplevel']);
+    }
+    catch (error) {
+        // Plain directories are supported for review fixtures and standalone checks;
+        // permission/corruption errors in actual repositories must never become success.
+        if (!String(error.stderr).includes('not a git repository'))
+            throw error;
+        const walk = (dir) => readdirSync(dir).sort().flatMap(name => {
+            if (['.git', 'node_modules', '.yoke'].includes(name))
+                return [];
+            const path = join(dir, name);
+            return lstatSync(path).isDirectory() ? walk(path) : [relative(root, path)];
+        });
+        names = walk(root);
+        return digest(names);
+    }
+    hash.update(git(['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.', ':(exclude).yoke/**']));
+    hash.update(git(['ls-files', '--stage', '-z', '--', '.', ':(exclude).yoke/**']));
+    names = [...new Set(git(['ls-files', '--cached', '--others', '--exclude-standard', '-z', '--', '.', ':(exclude).yoke/**']).split('\0').filter(Boolean))].sort();
+    return digest(names);
+    function digest(files) {
+        // Runtime status and evidence change during checks. Executable project policy
+        // must still belong to the identity, even when globally ignored by Git.
+        for (const name of [...new Set([...files, '.yoke/acceptance.yaml', '.yoke/config.yaml', '.yoke/prd.json', '.yoke/prd.yaml'])].sort()) {
+            const full = resolve(root, name);
+            const rel = relative(root, full);
+            if (isAbsolute(rel) || rel === '..' || rel.startsWith('..\\') || rel.startsWith('../'))
+                throw new Error('Fingerprint path escapes workspace');
+            hash.update(JSON.stringify(name));
+            let stat;
+            try {
+                stat = lstatSync(full);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    hash.update('missing');
+                    continue;
+                }
+                throw error;
+            }
+            if (stat.isSymbolicLink())
+                hash.update(`link:${readlinkSync(full)}`);
+            else if (stat.isFile()) {
+                if (stat.size > 64 * 1024 * 1024)
+                    throw new Error(`File too large to fingerprint safely: ${name}`);
+                hash.update(`file:${stat.mode}:${stat.size}:`).update(readFileSync(full));
+            }
+            else if (stat.isDirectory())
+                throw new Error(`Cannot safely fingerprint a nested repository or directory entry: ${name}`);
+            else
+                throw new Error(`Unsupported workspace entry: ${name}`);
+        }
+        return hash.digest('hex');
+    }
+}

package/dist/workspace/state.js

@@ -0,0 +1,20 @@
+import { lstatSync } from 'node:fs';
+import { join } from 'node:path';
+/** Fixed internal runtime paths only. Never follow project-controlled state links. */
+export function statePath(root, ...parts) {
+    let path = root;
+    for (const part of ['.yoke', ...parts]) {
+        if (!part || /[\\/]/u.test(part) || part === '.' || part === '..')
+            throw new Error('Invalid state path component');
+        path = join(path, part);
+        try {
+            if (lstatSync(path).isSymbolicLink())
+                throw new Error(`Linked Yoke state is not supported: ${part}`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    return path;
+}