@hecer/yoke 1.2.0 → 1.3.0

package/dist/loop/loop.js

@@ -1,10 +1,11 @@
 import { existsSync, unlinkSync, readFileSync } from 'node:fs';
 import { join, relative } from 'node:path';
-import { loadPrd, savePrd, selectNextStory, allPass, progress } from './prd.js';
+import { isAcceptanceCriterion, loadPrd, savePrd, selectNextStory, allPass, progress, storyPathSegment } from './prd.js';
 import { stopTheLineGate, preDispatchGate } from './gates.js';
 import { appendDecision, contextDir } from '../context/context.js';
 import { noopReporter } from './reporter.js';
 import { consumeDecisionRequest } from './decision.js';
+import { writeCriterionEvidence } from './evidence.js';
 function blockReason(base, targetDir, git) {
     let dirty = false;
     try {
@@ -58,26 +59,72 @@ function consumeAmbiguity(dir) {
     const compact = content.replace(/\s+/g, ' ').trim().slice(0, 500);
     return compact || 'agent reported ambiguous acceptance criteria without details';
 }
+function runCompletionGate(opts, stories) {
+    if (!opts.completion)
+        return null;
+    const previous = process.env.YOKE_PHASE;
+    process.env.YOKE_PHASE = 'completion';
+    let verdict;
+    try {
+        verdict = opts.completion(opts.targetDir);
+    }
+    catch (error) {
+        const reason = `integrated completion gate failed: ${error.message}`;
+        (opts.reporter ?? noopReporter).blocked(reason);
+        return { status: 'blocked', iterations: 0, reason, finalProgress: progress(stories) };
+    }
+    finally {
+        if (previous === undefined)
+            delete process.env.YOKE_PHASE;
+        else
+            process.env.YOKE_PHASE = previous;
+    }
+    if (verdict.passed)
+        return null;
+    const reason = `integrated system did not verify: ${verdict.summary}`;
+    (opts.reporter ?? noopReporter).blocked(reason);
+    return { status: 'blocked', iterations: 0, reason, finalProgress: progress(stories) };
+}
+function runCriterionGates(opts, executionDir, story) {
+    const criteria = story.acceptance.filter(isAcceptanceCriterion);
+    if (criteria.length === 0) {
+        return opts.requireCriterionEvidence
+            ? { passed: false, summary: `story ${story.id} lacks executable criterion evidence` }
+            : { passed: true, summary: 'legacy acceptance criteria' };
+    }
+    if (!opts.verifyCriterion)
+        return { passed: false, summary: `story ${story.id} has criteria but no criterion verifier` };
+    const evidence = criteria.map(criterion => ({
+        criterion,
+        result: opts.verifyCriterion(executionDir, story, criterion),
+    }));
+    try {
+        writeCriterionEvidence(opts.targetDir, story, evidence);
+    }
+    catch (error) {
+        return { passed: false, summary: `could not persist criterion evidence: ${error.message}` };
+    }
+    const failed = evidence.find(item => !item.result.passed);
+    return failed
+        ? { passed: false, summary: `${failed.criterion.id}: ${failed.result.summary}` }
+        : { passed: true, summary: `${evidence.length} acceptance criteria verified` };
+}
 export function runLoop(opts) {
     let iterations = 0;
     const reporter = opts.reporter ?? noopReporter;
-    const initial = loadPrd(opts.prdPath);
-    if (initial.length === 0) {
-        reporter.blocked('PRD has no stories');
-        return { status: 'blocked', iterations: 0, reason: 'PRD has no stories', finalProgress: { passed: 0, total: 0 } };
-    }
     for (;;) {
-        const stories = loadPrd(opts.prdPath);
-        if (allPass(stories)) {
-            reporter.complete(progress(stories));
-            return { status: 'complete', iterations, finalProgress: progress(stories) };
+        let stories = loadPrd(opts.prdPath);
+        if (stories.length === 0) {
+            reporter.blocked('PRD has no stories');
+            return { status: 'blocked', iterations, reason: 'PRD has no stories', finalProgress: { passed: 0, total: 0 } };
         }
-        if (iterations >= opts.maxIterations) {
+        const capReached = iterations >= opts.maxIterations;
+        if (capReached && !allPass(stories)) {
             reporter.capReached(progress(stories));
             return { status: 'cap-reached', iterations, finalProgress: progress(stories) };
         }
-        // Story boundary: honour a pause signal before selecting the next story.
-        // complete/cap-reached above still win — pausing an already-finished loop is meaningless.
+        // Intake is work at a story boundary. Cap, pause, and clean-tree safety must
+        // win before a planner is allowed to edit and commit the PRD.
         const pauseFile = pauseFilePath(opts.targetDir);
         if (existsSync(pauseFile)) {
             try {
@@ -89,22 +136,71 @@ export function runLoop(opts) {
         }
         const pre = preDispatchGate(opts.targetDir, opts.git);
         if (!pre.ok) {
-            reporter.blocked(pre.reason ?? 'pre-dispatch gate failed');
-            return { status: 'blocked', iterations, reason: pre.reason, finalProgress: progress(stories) };
+            const reason = opts.intake ? `change intake blocked by dirty worktree: ${pre.reason ?? 'pre-dispatch gate failed'}` : pre.reason;
+            reporter.blocked(reason ?? 'pre-dispatch gate failed');
+            return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+        }
+        // A bounded run that finished its final story may report completion, but it
+        // must not plan additional queued work after the requested cap.
+        if (capReached) {
+            const completionFailure = runCompletionGate(opts, stories);
+            if (completionFailure)
+                return { ...completionFailure, iterations };
+            reporter.complete(progress(stories));
+            return { status: 'complete', iterations, finalProgress: progress(stories) };
+        }
+        if (opts.intake) {
+            let intake;
+            try {
+                intake = opts.intake();
+            }
+            catch (error) {
+                const stories = loadPrd(opts.prdPath);
+                const reason = `change intake failed: ${error.message}`;
+                reporter.blocked(reason);
+                return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+            }
+            if (!intake.ok) {
+                const stories = loadPrd(opts.prdPath);
+                const reason = `change intake failed: ${intake.summary}`;
+                reporter.blocked(reason);
+                return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+            }
+            if (intake.added > 0) {
+                const afterIntake = preDispatchGate(opts.targetDir, opts.git);
+                if (!afterIntake.ok) {
+                    const stories = loadPrd(opts.prdPath);
+                    const reason = `change intake left a dirty worktree: ${afterIntake.reason ?? 'pre-dispatch gate failed'}`;
+                    reporter.blocked(reason);
+                    return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+                }
+            }
+        }
+        stories = loadPrd(opts.prdPath);
+        if (stories.length === 0) {
+            reporter.blocked('PRD has no stories');
+            return { status: 'blocked', iterations, reason: 'PRD has no stories', finalProgress: { passed: 0, total: 0 } };
+        }
+        if (allPass(stories)) {
+            const completionFailure = runCompletionGate(opts, stories);
+            if (completionFailure)
+                return { ...completionFailure, iterations };
+            reporter.complete(progress(stories));
+            return { status: 'complete', iterations, finalProgress: progress(stories) };
         }
         const story = selectNextStory(stories);
         if (!story) {
             reporter.complete(progress(stories));
             return { status: 'complete', iterations, finalProgress: progress(stories) };
         }
-        const stl = stopTheLineGate(story);
+        const stl = stopTheLineGate(story, opts.requireCriterionEvidence);
         if (!stl.ok) {
             reporter.blocked(stl.reason ?? 'stop-the-line gate failed');
             return { status: 'blocked', iterations, reason: stl.reason, finalProgress: progress(stories) };
         }
         reporter.storyStart({ id: story.id, title: story.title }, iterations + 1, progress(stories));
         if (opts.isolate) {
-            const wt = join(opts.targetDir, '.yoke', 'worktrees', story.id);
+            const wt = join(opts.targetDir, '.yoke', 'worktrees', storyPathSegment(story.id));
             const wtPrd = join(wt, relative(opts.targetDir, opts.prdPath));
             let landed = null;
             try {
@@ -133,6 +229,13 @@ export function runLoop(opts) {
                     reporter.blocked(reason);
                     return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
                 }
+                const criteriaVerdict = runCriterionGates(opts, wt, story);
+                if (!criteriaVerdict.passed) {
+                    result.routing?.recordOutcome(false);
+                    const reason = blockReason(`story ${story.id} lacks acceptance evidence: ${criteriaVerdict.summary}`, opts.targetDir, opts.git);
+                    reporter.blocked(reason);
+                    return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+                }
                 // Verify is the source of truth — NOT the runner's exit code. A spurious non-zero
                 // exit (e.g. a Windows .cmd wrapper ghost) must not block a story whose tests are green.
                 reporter.phase('verifying');
@@ -234,6 +337,13 @@ export function runLoop(opts) {
             reporter.blocked(reason);
             return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
         }
+        const criteriaVerdict = runCriterionGates(opts, opts.targetDir, story);
+        if (!criteriaVerdict.passed) {
+            result.routing?.recordOutcome(false);
+            const reason = blockReason(`story ${story.id} lacks acceptance evidence: ${criteriaVerdict.summary}`, opts.targetDir, opts.git);
+            reporter.blocked(reason);
+            return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+        }
         // Verify is the source of truth — NOT the runner's exit code. A spurious non-zero
         // exit (e.g. a Windows .cmd wrapper ghost) must not block a story whose tests are green.
         reporter.phase('verifying');

package/dist/loop/prd.js

@@ -1,19 +1,77 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { parse, stringify } from 'yaml';
 import { z } from 'zod';
+export const AcceptanceCriterionSchema = z.object({
+    id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
+    text: z.string().min(1),
+    verify: z.array(z.string().min(1)).min(1),
+});
+export function criterionCommandProblem(criterion) {
+    const normalizedId = criterion.id.toLowerCase().replace(/[^a-z0-9]/g, '');
+    for (const raw of criterion.verify) {
+        const command = raw.trim();
+        if (/(?:[&;|<>`\r\n]|\$\()/.test(command)) {
+            return `criterion ${criterion.id} must use one single test command without shell control operators`;
+        }
+        const isTestCommand = /^(?:(?:npm|pnpm|yarn|bun)(?:\s+run)?\s+(?:test|check|verify)(?::[A-Za-z0-9._-]+)?|npx\s+(?:vitest|jest|playwright|cypress)|(?:vitest|jest|pytest|phpunit)|python\s+-m\s+pytest|cargo\s+test|go\s+test|dotnet\s+test|mvn(?:w)?\s+test|gradle(?:w)?\s+test|bundle\s+exec\s+(?:rspec|rails\s+test)|bin\/rails\s+test|vendor\/bin\/phpunit|mix\s+test|swift\s+test|xcodebuild\s+test)(?:\s|$)/i.test(command);
+        if (!isTestCommand)
+            return `criterion ${criterion.id} must use an approved test command`;
+        const normalizedCommand = command.toLowerCase().replace(/[^a-z0-9]/g, '');
+        if (!normalizedCommand.includes(normalizedId)) {
+            return `criterion ${criterion.id} must target its criterion id in every verify command`;
+        }
+    }
+    return null;
+}
 export const StorySchema = z.object({
+    // Existing projects may already use human-readable IDs. Keep loading them;
+    // every filesystem use goes through storyPathSegment instead.
     id: z.string().min(1),
     title: z.string().min(1),
     priority: z.number(),
-    acceptance: z.array(z.string().min(1)),
+    // String criteria remain readable for existing projects. New strict projects
+    // use structured criteria so Yoke can execute proof for each outcome instead
+    // of trusting an unrelated green test suite.
+    acceptance: z.array(z.union([z.string().min(1), AcceptanceCriterionSchema])),
     passes: z.boolean(),
     needs: z.array(z.string().min(1)).optional(),
     area: z.string().min(1).optional(),
     agent: z.enum(['claude', 'codex', 'gemini']).optional(),
+    /** Inbox request that created this story. Used for idempotent append-only intake. */
+    sourceChange: z.string().min(1).optional(),
+}).superRefine((story, ctx) => {
+    const structured = story.acceptance.filter(isAcceptanceCriterion);
+    const ids = structured.map(criterion => criterion.id);
+    if (structured.length > 0 && (structured.length < 2 || structured.length > 5)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['acceptance'],
+            message: 'structured stories must have 2-5 structured acceptance criteria',
+        });
+    }
+    if (new Set(ids).size !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['acceptance'],
+            message: 'structured criterion ids must be unique within a story',
+        });
+    }
 });
+export function storyPathSegment(id) {
+    return `story-${Buffer.from(id, 'utf8').toString('base64url')}`;
+}
+export function isAcceptanceCriterion(value) {
+    return typeof value !== 'string';
+}
+export function acceptanceText(value) {
+    return typeof value === 'string' ? value : value.text;
+}
 const PrdSchema = z.array(StorySchema);
+export function parsePrd(file) {
+    return PrdSchema.parse(parse(readFileSync(file, 'utf8')));
+}
 export function loadPrd(file) {
-    const stories = PrdSchema.parse(parse(readFileSync(file, 'utf8')));
+    const stories = parsePrd(file);
     const issues = validateDependencies(stories);
     if (issues.length)
         throw new Error(`Invalid PRD dependency graph:\n${issues.join('\n')}`);

package/dist/loop/run-command.js

@@ -3,9 +3,9 @@ import { existsSync } from 'node:fs';
 import { loadConfig, saveConfig, defaultConfig, resolveVerifyCommand } from '../retrofit/config.js';
 import { loadPrd, progress } from './prd.js';
 import { runLoop } from './loop.js';
-import { realGitOps } from './git.js';
+import { commitPaths, realGitOps } from './git.js';
 import { makeRunner, makeReviewRunner, isAgentAvailable } from './runner.js';
-import { commandVerifier, retryingVerifier } from './verify.js';
+import { commandVerifier, commandsVerifier, retryingVerifier } from './verify.js';
 import { readStatus, makeReporter, fmtDuration } from './reporter.js';
 import { acquireLock, releaseLock } from './lock.js';
 import { maybeAutoUpgrade } from '../update/upgrade.js';
@@ -14,6 +14,7 @@ import { runAudit } from '../audit/command.js';
 import { detectHostAgent, resolveRunnerAgent } from '../agents/host.js';
 import { clearDecisionResume, decisionProcessingExists, decisionRequestId, formatPendingDecision, readPendingDecision, writeDecisionResume, } from './decision.js';
 import { makeAdaptiveRunner } from '../routing/router.js';
+import { runChangeApply } from '../change/inbox.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) {
@@ -114,6 +115,9 @@ export function runLoopCommand(targetDir, opts) {
     if (!perf && config.perf?.command) {
         perf = retryingVerifier(commandVerifier(config.perf.command), config.perf.retries ?? 1);
     }
+    const completion = config.completion?.command
+        ? retryingVerifier(commandVerifier(config.completion.command), config.completion.retries ?? 1)
+        : undefined;
     // Opt-in self-update, loop START only — this run keeps executing the version
     // it started with; a fetched upgrade applies from the next invocation.
     maybeAutoUpgrade(config.update?.auto);
@@ -148,6 +152,19 @@ export function runLoopCommand(targetDir, opts) {
         console.error('Adaptive routing was requested, but no worker profiles are configured. Run yoke setup . --routing or add routing.workers to .yoke/config.yaml.');
         return 2;
     }
+    const intake = opts.intake ?? (() => runChangeApply(targetDir, {
+        runner: runnerAgent,
+        reviewer: opts.reviewer ?? runnerAgent,
+        timeoutMs: idleMs,
+        isAvailable: available,
+        permissions,
+        selection: {
+            model: config.runner?.model,
+            reasoningEffort: config.runner?.reasoningEffort,
+            bare: config.runner?.bare,
+        },
+        commit: (_path, request) => commitPaths(targetDir, ['.yoke/prd.yaml'], `yoke: plan change ${request.id}`, commitIdentity),
+    }));
     let runner = opts.runner;
     if (!runner) {
         if (!available(runnerAgent)) {
@@ -230,6 +247,10 @@ export function runLoopCommand(targetDir, opts) {
             git,
             commitIdentity,
             verify,
+            verifyCriterion: (dir, _story, criterion) => commandsVerifier(criterion.verify)(dir),
+            requireCriterionEvidence: config.verify?.requireCriteria ?? false,
+            completion,
+            intake,
             perf,
             audit,
             maxIterations,

package/dist/loop/runner.js

@@ -1,3 +1,4 @@
+import { isAcceptanceCriterion } from './prd.js';
 import { execFileSync, execSync } from 'node:child_process';
 import { existsSync, mkdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
@@ -9,8 +10,15 @@ import { formatReviewContract, readReviewVerdict, reviewVerdictPath } from '../r
 export function contextBlockFor(targetDir) {
     return formatForPrompt(loadContext(contextDir(targetDir)));
 }
+function formatAcceptance(story) {
+    return story.acceptance.map(criterion => {
+        if (!isAcceptanceCriterion(criterion))
+            return `- ${criterion}`;
+        return `- [${criterion.id}] ${criterion.text}\n  Proof: ${criterion.verify.join(' && ')}`;
+    }).join('\n');
+}
 export function buildClaudePrompt(story, context, onAmbiguity = 'resolve', perfCommand) {
-    const criteria = story.acceptance.map(a => `- ${a}`).join('\n');
+    const criteria = formatAcceptance(story);
     const lines = [
         'You are an autonomous coding agent running inside the Yoke loop.',
         'Implement ONLY this story and nothing else. Follow test-driven development.',
@@ -33,7 +41,7 @@ export function buildClaudePrompt(story, context, onAmbiguity = 'resolve', perfC
     return lines.join('\n');
 }
 export function buildReviewPrompt(story, context, verdictPath) {
-    const criteria = story.acceptance.map(a => `- ${a}`).join('\n');
+    const criteria = formatAcceptance(story);
     const lines = [
         'You are an independent reviewer inside the Yoke loop. You did NOT implement this change.',
         'Review the current uncommitted working-tree changes against the story below.',

package/dist/loop/verify.js

@@ -16,6 +16,17 @@ export function commandVerifier(command) {
         }
     };
 }
+/** Execute the proof commands attached to one acceptance criterion. */
+export function commandsVerifier(commands) {
+    return (targetDir) => {
+        for (const command of commands) {
+            const result = commandVerifier(command)(targetDir);
+            if (!result.passed)
+                return result;
+        }
+        return { passed: true, summary: `${commands.length} criterion command${commands.length === 1 ? '' : 's'} passed` };
+    };
+}
 // Re-run a failing verifier up to `retries` times; the first pass wins. Lets a
 // transient flake (e.g. a load-induced async timeout) self-heal while a real
 // failure still fails (it stays red across every attempt).

package/dist/prd/command.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadConfig } from '../retrofit/config.js';
-import { loadPrd, progress } from '../loop/prd.js';
+import { acceptanceText, criterionCommandProblem, isAcceptanceCriterion, loadPrd, progress } from '../loop/prd.js';
 import { agentInvocation, buildWatchdogInvocation, runAgent, isAgentAvailable, } from '../loop/runner.js';
 import { resolveIdleMs } from '../loop/run-command.js';
 import { detectHostAgent, resolveRunnerAgent } from '../agents/host.js';
@@ -14,8 +14,12 @@ export const PRD_TEMPLATE = `# Yoke PRD — the loop picks the lowest-priority o
 #   area: foundation      # optional collision domain for parallel runs
 #   agent: codex          # optional claude|codex|gemini affinity
 #   acceptance:
-#     - "the verify command exits 0"
-#     - "a placeholder test exists and passes"
+#     - id: suite-runs
+#       text: "the project test suite can run"
+#       verify: ["npm run test:suite-runs"]
+#     - id: scaffold-starts
+#       text: "the scaffolded application starts"
+#       verify: ["npm run test:scaffold-starts"]
 #   passes: false
 []
 `;
@@ -30,7 +34,7 @@ export function buildPrdDraftPrompt(idea, planningBrief) {
     if (planningBrief?.trim()) {
         lines.push('', '## Approved planning brief (treat these decisions as settled)', planningBrief.trim(), '', 'Do not reopen settled choices or invent alternatives that contradict this brief.');
     }
-    lines.push('', 'Break the idea into 5-12 small, independently shippable stories; each must fit one loop iteration.', 'Each story needs:', '- id: STORY-1, STORY-2, ... (unique)', '- title: one imperative sentence', '- priority: dense integers from 1 (lower = built first)', '- needs: optional list of story IDs that must pass first; the graph must be acyclic', '- area: optional collision domain for safe parallel scheduling', '- agent: optional claude|codex|gemini affinity', '- acceptance: 2-5 testable, behavioral criteria (observable outcomes, never implementation steps)', '- passes: false', '', 'If the project has no source code yet, STORY-1 must scaffold the project skeleton with a runnable', 'test suite, and its acceptance must include that the verify command (verify.command in', '.yoke/config.yaml) exits 0.', '', 'Write ONLY the file .yoke/prd.yaml as a YAML array of stories in exactly that shape.', 'Do not modify any other file. Do not commit.');
+    lines.push('', 'Break the idea into 5-12 small, independently shippable stories; each must fit one loop iteration.', 'Each story needs:', '- id: STORY-1, STORY-2, ... (unique)', '- title: one imperative sentence', '- priority: dense integers from 1 (lower = built first)', '- needs: optional list of story IDs that must pass first; the graph must be acyclic', '- area: optional collision domain for safe parallel scheduling', '- agent: optional claude|codex|gemini affinity', '- acceptance: 2-5 testable, behavioral criteria (observable outcomes, never implementation steps)', '  Each criterion is an object with a stable id, behavioral text, and verify: [one or more approved test commands].', '  Every criterion id must appear in every verify command; use one test command without shell control operators.', '- passes: false', '', 'If the project has no source code yet, STORY-1 must scaffold the project skeleton with a runnable', 'test suite, and its acceptance must include that the verify command (verify.command in', '.yoke/config.yaml) exits 0.', '', 'Write ONLY the file .yoke/prd.yaml as a YAML array of stories in exactly that shape.', 'Do not modify any other file. Do not commit.');
     return lines.join('\n');
 }
 export function prdFile(targetDir) {
@@ -113,6 +117,7 @@ export function runPrdCheck(targetDir) {
         return 1;
     }
     const errors = [];
+    const requireCriteria = loadConfig(targetDir)?.verify?.requireCriteria ?? false;
     if (stories.length === 0)
         errors.push('PRD has no stories');
     const seen = new Set();
@@ -123,7 +128,15 @@ export function runPrdCheck(targetDir) {
         // the schema allows [], but the loop's stop-the-line gate blocks it — fail fast here
         if (s.acceptance.length === 0)
             errors.push(`story ${s.id} has no acceptance criteria`);
-        if (s.acceptance.some(criterion => /\b(?:TBD|TODO|TO BE DECIDED|DECIDE LATER)\b|\?\?\?/i.test(criterion))) {
+        if (requireCriteria && s.acceptance.some(criterion => !isAcceptanceCriterion(criterion))) {
+            errors.push(`story ${s.id} lacks executable criterion evidence`);
+        }
+        for (const criterion of s.acceptance.filter(isAcceptanceCriterion)) {
+            const problem = criterionCommandProblem(criterion);
+            if (problem)
+                errors.push(problem);
+        }
+        if (s.acceptance.some(criterion => /\b(?:TBD|TODO|TO BE DECIDED|DECIDE LATER)\b|\?\?\?/i.test(acceptanceText(criterion)))) {
             errors.push(`story ${s.id} has unresolved planning decisions in acceptance criteria`);
         }
     }

package/dist/retrofit/config.js

@@ -53,7 +53,14 @@ export const YokeConfigSchema = z.object({
         suppressionsVersion: z.literal(1).optional(),
         suppressions: z.array(z.object({ ruleId: z.string().min(1), file: z.string().min(1).optional(), reason: z.string(), expires: z.string().optional() })).optional(),
     }).optional(),
-    verify: z.object({ command: z.string().min(1), retries: z.number().int().nonnegative().optional() }).optional(),
+    verify: z.object({
+        command: z.string().min(1).optional(),
+        retries: z.number().int().nonnegative().optional(),
+        requireCriteria: z.boolean().optional(),
+    }).optional(),
+    // Runs only when no open stories remain. This proves the current integrated
+    // system, without introducing release objects or a persistent stale graph.
+    completion: z.object({ command: z.string().min(1), retries: z.number().int().nonnegative().optional() }).optional(),
     // Optional performance budget gate: a benchmark command that must exit 0 for a
     // story to land (runs after verify). Benchmarks are noisy → retried like verify.
     perf: z.object({ command: z.string().min(1), retries: z.number().int().nonnegative().optional() }).optional(),
@@ -63,7 +70,7 @@ export const YokeConfigSchema = z.object({
     update: z.object({ auto: z.boolean() }).optional(),
 });
 export function defaultConfig(canonVersion) {
-    return { canonVersion, agents: [], loop: { enabled: false } };
+    return { canonVersion, agents: [], loop: { enabled: false }, verify: { requireCriteria: true } };
 }
 export function configPath(targetDir) {
     return join(targetDir, '.yoke', 'config.yaml');

package/dist/retrofit/gitignore.js

@@ -19,6 +19,7 @@ export const YOKE_IGNORE_LINES = [
     '.yoke/decision-*.yaml.*.tmp',
     '.yoke/story-durations.json',
     '.yoke/proof/',
+    '.yoke/changes/',
 ];
 const HEADER = '# Yoke runtime artifacts (managed by yoke retrofit)';
 // Idempotently ensure each Yoke runtime path is gitignored. Appends only the

package/dist/routing/router.js

@@ -1,4 +1,5 @@
 import { buildWatchdogInvocation, makeRunner, runCapturedAgent, runnerInvocation, } from '../loop/runner.js';
+import { isAcceptanceCriterion } from '../loop/prd.js';
 import { historyForWorkers, projectHash, recordRoutingObservation, storyHash } from './registry.js';
 const costRank = { low: 0, medium: 1, high: 2 };
 export function rankWorkers(workers, strategy, maxCandidates) {
@@ -40,7 +41,9 @@ export function buildRoutingPrompt(ctx, workers, strategy) {
         '',
         `Story ${ctx.story.id}: ${ctx.story.title}`,
         'Acceptance criteria:',
-        ...ctx.story.acceptance.map(item => `- ${item}`),
+        ...ctx.story.acceptance.map(item => isAcceptanceCriterion(item)
+            ? `- [${item.id}] ${item.text} (proof: ${item.verify.join(' && ')})`
+            : `- ${item}`),
         '',
         'Allowed candidates:',
         '- SELF: strong parent; highest confidence; highest expected cost',

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "yoke",
-  "version": "1.2.0",
+  "version": "1.3.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.2.0",
+  "version": "1.3.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": {
@@ -16,11 +16,11 @@
     "hooks",
     "bench/README.md",
     "bench/RESULTS.md",
-    "bench/result-schema.mjs",
-    "bench/run.mjs",
-    "bench/run-large.mjs",
-    "bench/run-matrix.mjs",
-    "bench/analyze-routing-study.mjs",
+    "bench/result-schema.mjs",
+    "bench/run.mjs",
+    "bench/run-large.mjs",
+    "bench/run-matrix.mjs",
+    "bench/analyze-routing-study.mjs",
     "bench/fixtures",
     "bench/results",
     "docs",