@hecer/yoke 1.2.1 → 1.3.0

package/canon/skills/authoring-prd/SKILL.md

@@ -1,38 +1,27 @@
 ---
 name: authoring-prd
-description: Use when turning a product idea into a loop-ready .yoke/prd.yaml — slice the idea into small, independently shippable stories with testable behavioral acceptance criteria; greenfield STORY-1 scaffolds the project and wires verify.command.
+description: Use when turning a product idea or change into a loop-ready continuous backlog with small stories and executable behavioral evidence.
 ---
 
 # Authoring a PRD
 
-The Yoke loop is only as good as its stories. Bad stories ("build the app") stall it;
-good stories (small, testable, ordered) let it run overnight.
+The Yoke loop is only as good as its stories. Keep the backlog continuous: new requests become
+new stories; they do not require a release object.
 
 ## Story rules
 
-1. **One iteration per story.** If you can't imagine an agent finishing it in one sitting,
-   split it. Prefer 5-12 stories over 3 epics.
-2. **Independently shippable.** After any story, the project builds and tests pass.
-3. **Acceptance = observable behavior**, never implementation:
-   - Good: "GET /health returns 200", "the CLI prints the sum of its arguments"
-   - Bad: "create a HealthController class", "use express"
-   2-5 criteria per story. Each must be checkable by a test or a command.
-4. **Dense priorities from 1**; lower runs first. Order by dependency, then by risk.
-5. **Greenfield: STORY-1 scaffolds.** Project skeleton + runnable test suite + a criterion
-   that the verify command (`verify.command` in `.yoke/config.yaml`) exits 0. Every later
-   story stands on a green pipeline.
-6. **Performance requirements are acceptance criteria — with numbers.** "Should be fast" is
-   a vibe the loop cannot gate; "imports 1M rows in < 2s (asserted by the bench test)" is a
-   criterion. If the whole project has a budget, wire `perf.command` in `.yoke/config.yaml`
-   (see the `performance` skill) instead of repeating it per story.
-7. **Ask everything now.** Clarifying questions belong in this planning round — a loop run
-   is unattended. A criterion that still contains `TBD` or another placeholder is not
-   loop-ready, and `yoke prd check` rejects it. During implementation,
-   `loop.decisionPolicy: auto` resolves routine ambiguity; `critical` pauses only for
-   high-impact choices and resumes after `yoke loop answer` records the answer.
-8. **Model real dependencies.** Add `needs` only for hard prerequisites, `area` for files or
-   subsystems that must not be edited concurrently, and `agent` only as an affinity hint.
-   Dependency IDs must exist; self-dependencies and cycles are invalid.
+1. One iteration per story. Prefer 5–12 small stories over a few epics.
+2. Each story leaves the project buildable and testable.
+3. Acceptance describes observable behavior, never implementation. Give each of 2–5 criteria
+   a stable `id`, behavioral `text`, and `verify` list with one or more real commands proving
+   that exact outcome.
+4. Use dense priorities from 1; order by dependency, then risk.
+5. Greenfield `STORY-1` creates the skeleton, runnable suite, and `verify.command`.
+6. Express performance with numbers and executable benchmarks, not words such as “fast”.
+7. Resolve planning questions before unattended execution. `yoke prd check` rejects unresolved
+   placeholders; critical irreversible choices use the structured decision channel.
+8. Use `needs` only for hard prerequisites, `area` for collision domains, and `agent` only as
+   a Claude/Codex/Gemini affinity hint.
 
 ## Format (`.yoke/prd.yaml`)
 
@@ -41,8 +30,12 @@ good stories (small, testable, ordered) let it run overnight.
   title: scaffold a TypeScript CLI with vitest
   priority: 1
   acceptance:
-    - "npm test exits 0 with at least one passing test"
-    - "verify.command is set in .yoke/config.yaml"
+    - id: cli-help-runs
+      text: the CLI help command exits 0 and prints usage
+      verify: [npm run test:cli-help-runs]
+    - id: test-runner-starts
+      text: the project test runner starts and reports at least one passing test
+      verify: [npm run test:test-runner-starts]
   passes: false
 - id: STORY-2
   title: add the sum command
@@ -51,9 +44,15 @@ good stories (small, testable, ordered) let it run overnight.
   area: cli
   agent: codex
   acceptance:
-    - "cli sum 1 2 prints 3"
-    - "non-numeric input exits 1 with an error message"
+    - id: sum-valid
+      text: cli sum 1 2 prints 3
+      verify: [npm run test:sum-valid]
+    - id: sum-invalid
+      text: non-numeric input exits 1 with an error message
+      verify: [npm run test:sum-invalid]
   passes: false
 ```
 
-`passes` is owned by the loop — always start `false`. Validate with `yoke prd check`.
+Every story has 2–5 structured criteria. Each `verify` entry is one approved test command whose
+normalized text contains its criterion ID; never use shell operators or a broad unrelated suite.
+`passes` is owned by the loop and always starts false. Validate with `yoke prd check`.

package/dist/change/inbox.js

@@ -0,0 +1,279 @@
+import { randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { z } from 'zod';
+import { criterionCommandProblem, isAcceptanceCriterion, loadPrd, parsePrd, savePrd, validateDependencies } from '../loop/prd.js';
+import { agentInvocation, buildWatchdogInvocation, isAgentAvailable, runAgent, } from '../loop/runner.js';
+import { commitPaths } from '../loop/git.js';
+const ChangeRequestSchema = z.object({
+    version: z.literal(1),
+    id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
+    createdAt: z.string().datetime(),
+    request: z.string().min(1),
+});
+const ChangeReviewSchema = z.object({
+    version: z.literal(1),
+    changeId: z.string().min(1),
+    approved: z.boolean(),
+    summary: z.string().min(1),
+    uncovered: z.array(z.string().min(1)),
+}).superRefine((review, ctx) => {
+    if (review.approved && review.uncovered.length > 0) {
+        ctx.addIssue({ code: 'custom', path: ['approved'], message: 'approved review cannot list uncovered requirements' });
+    }
+});
+const NewStoryId = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function changesDir(targetDir) { return join(targetDir, '.yoke', 'changes'); }
+function pendingDir(targetDir) { return join(changesDir(targetDir), 'pending'); }
+function appliedDir(targetDir) { return join(changesDir(targetDir), 'applied'); }
+function requestFile(targetDir, id) { return join(pendingDir(targetDir), `${id}.json`); }
+export function proposalFile(targetDir, id) { return resolve(changesDir(targetDir), `proposal-${id}.yaml`); }
+export function reviewFile(targetDir, id) { return resolve(changesDir(targetDir), `review-${id}.json`); }
+function ensureLocalIgnore(targetDir) {
+    let exclude;
+    try {
+        const gitPath = execFileSync('git', ['rev-parse', '--git-path', 'info/exclude'], { cwd: targetDir, stdio: 'pipe' }).toString().trim();
+        exclude = isAbsolute(gitPath) ? gitPath : resolve(targetDir, gitPath);
+    }
+    catch {
+        return;
+    }
+    mkdirSync(dirname(exclude), { recursive: true });
+    const current = existsSync(exclude) ? readFileSync(exclude, 'utf8') : '';
+    if (current.split(/\r?\n/).some(line => line.trim() === '.yoke/changes/'))
+        return;
+    const prefix = current.length === 0 || current.endsWith('\n') ? '' : '\n';
+    writeFileSync(exclude, `${current}${prefix}.yoke/changes/\n`);
+}
+function prdIsCommitted(targetDir) {
+    try {
+        execFileSync('git', ['ls-files', '--error-unmatch', '--', '.yoke/prd.yaml'], { cwd: targetDir, stdio: 'pipe' });
+        return execFileSync('git', ['status', '--porcelain', '--untracked-files=no', '--', '.yoke/prd.yaml'], {
+            cwd: targetDir,
+            stdio: 'pipe',
+        }).toString().trim() === '';
+    }
+    catch {
+        return false;
+    }
+}
+export function queueChange(targetDir, request, opts = {}) {
+    const text = request.trim();
+    if (!text)
+        throw new Error('change request must not be empty');
+    const change = ChangeRequestSchema.parse({
+        version: 1,
+        id: opts.id ?? randomUUID(),
+        createdAt: (opts.now ?? (() => new Date()))().toISOString(),
+        request: text,
+    });
+    ensureLocalIgnore(targetDir);
+    mkdirSync(pendingDir(targetDir), { recursive: true });
+    const path = requestFile(targetDir, change.id);
+    if (existsSync(path))
+        throw new Error(`change ${change.id} already exists`);
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(change, null, 2)}\n`, { flag: 'wx' });
+    renameSync(temporary, path);
+    return change;
+}
+export function pendingChanges(targetDir) {
+    const dir = pendingDir(targetDir);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter(name => name.endsWith('.json'))
+        .map(name => ChangeRequestSchema.parse(JSON.parse(readFileSync(join(dir, name), 'utf8'))))
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+}
+export function buildChangePrompt(request, proposalPath, stories) {
+    return [
+        'You are planning one newly requested product change for the Yoke autonomous loop.',
+        `Change request ${request.id}: ${request.request}`,
+        '',
+        'Create an append-only proposal: add small new stories; never rewrite or delete existing stories.',
+        `Existing story IDs: ${stories.map(story => story.id).join(', ') || '(none)'}`,
+        'Every proposed story must have passes: false and 2-5 structured acceptance criteria.',
+        'Every criterion must have a stable id, behavioral text, and one or more executable verify commands.',
+        'Each criterion id must appear in every verify command; each entry must be one approved test command without shell control operators.',
+        'Use only claude, codex, or gemini if an optional agent affinity is useful.',
+        '',
+        `Write ONLY a YAML array of the NEW stories to this exact file: ${proposalPath}`,
+        'Do not edit .yoke/prd.yaml or any source file. Do not commit.',
+    ].join('\n');
+}
+export function buildChangeReviewPrompt(request, reviewPath, proposed) {
+    return [
+        'Independently review whether a proposed append-only plan fully covers one product change.',
+        `Change request ${request.id}: ${request.request}`,
+        '',
+        'Check every distinct requested outcome, edge case, and state transition against the proposed stories and their criteria.',
+        'Approve only when every distinct requested outcome has a behavioral criterion and a criterion-specific verify command.',
+        'Do not assume a broad test suite proves an outcome. List every omission in uncovered.',
+        '',
+        `Proposed stories: ${JSON.stringify(proposed, null, 2)}`,
+        '',
+        `Write ONLY JSON to this exact file: ${reviewPath}`,
+        '{"version":1,"changeId":"<exact change id>","approved":true|false,"summary":"<reason>","uncovered":["<missing outcome>"]}',
+        'Do not edit .yoke/prd.yaml, the proposal, or any source file. Do not commit.',
+    ].join('\n');
+}
+function archiveRequest(targetDir, request) {
+    mkdirSync(appliedDir(targetDir), { recursive: true });
+    renameSync(requestFile(targetDir, request.id), join(appliedDir(targetDir), `${request.id}.json`));
+    rmSync(proposalFile(targetDir, request.id), { force: true });
+    rmSync(reviewFile(targetDir, request.id), { force: true });
+}
+export function runChangeApply(targetDir, opts) {
+    let requests;
+    try {
+        requests = pendingChanges(targetDir);
+    }
+    catch (error) {
+        return { ok: false, added: 0, summary: `invalid pending request: ${error.message}` };
+    }
+    const request = requests[0];
+    if (!request)
+        return { ok: true, added: 0, summary: 'inbox empty' };
+    const prdPath = join(targetDir, '.yoke', 'prd.yaml');
+    const existingText = readFileSync(prdPath, 'utf8');
+    const existing = loadPrd(prdPath);
+    if (existing.some(story => story.sourceChange === request.id)) {
+        if (!prdIsCommitted(targetDir)) {
+            return {
+                ok: false,
+                added: 0,
+                summary: `PRD contains change ${request.id} only as uncommitted recovery state; keeping the request pending`,
+                changeId: request.id,
+            };
+        }
+        try {
+            ;
+            (opts.archive ?? archiveRequest)(targetDir, request);
+        }
+        catch (error) {
+            return {
+                ok: false, added: 0,
+                summary: `committed change ${request.id} could not be archived; keeping it pending for recovery: ${error.message}`,
+                changeId: request.id,
+            };
+        }
+        return { ok: true, added: 0, summary: `recovered applied change ${request.id}`, changeId: request.id };
+    }
+    const available = opts.isAvailable ?? isAgentAvailable;
+    if (!available(opts.runner))
+        return { ok: false, added: 0, summary: `planner CLI "${opts.runner}" is unavailable`, changeId: request.id };
+    const reviewer = opts.reviewer ?? opts.runner;
+    if (!available(reviewer))
+        return { ok: false, added: 0, summary: `reviewer CLI "${reviewer}" is unavailable`, changeId: request.id };
+    const proposal = proposalFile(targetDir, request.id);
+    const plannerDir = changesDir(targetDir);
+    mkdirSync(plannerDir, { recursive: true });
+    rmSync(proposal, { force: true });
+    const base = agentInvocation(opts.runner, buildChangePrompt(request, proposal, existing), plannerDir, opts.permissions ?? 'safe', opts.selection);
+    const invocation = buildWatchdogInvocation(base, opts.timeoutMs ?? 0);
+    const result = (opts.run ?? runAgent)(invocation);
+    if (!result.success)
+        return { ok: false, added: 0, summary: `planner failed: ${result.summary}`, changeId: request.id };
+    if (readFileSync(prdPath, 'utf8') !== existingText) {
+        return {
+            ok: false,
+            added: 0,
+            summary: 'PRD changed while the planner was running; refusing to overwrite concurrent or out-of-contract edits',
+            changeId: request.id,
+        };
+    }
+    if (!existsSync(proposal))
+        return { ok: false, added: 0, summary: `planner did not write ${basename(proposal)}`, changeId: request.id };
+    let proposed;
+    try {
+        proposed = parsePrd(proposal);
+    }
+    catch (error) {
+        return { ok: false, added: 0, summary: `invalid story proposal: ${error.message}`, changeId: request.id };
+    }
+    if (proposed.length === 0)
+        return { ok: false, added: 0, summary: 'planner proposed no stories', changeId: request.id };
+    const existingIds = new Set(existing.map(story => story.id));
+    const proposedIds = new Set();
+    for (const story of proposed) {
+        if (!NewStoryId.test(story.id)) {
+            return { ok: false, added: 0, summary: `proposed story id must be one safe path segment: ${story.id}`, changeId: request.id };
+        }
+        if (story.passes)
+            return { ok: false, added: 0, summary: `proposed story ${story.id} is already marked passed`, changeId: request.id };
+        if (existingIds.has(story.id) || proposedIds.has(story.id)) {
+            return { ok: false, added: 0, summary: `duplicate proposed story id: ${story.id}`, changeId: request.id };
+        }
+        if (story.acceptance.length < 2 || story.acceptance.length > 5) {
+            return { ok: false, added: 0, summary: `proposed story ${story.id} must have 2-5 acceptance criteria`, changeId: request.id };
+        }
+        if (story.acceptance.some(criterion => !isAcceptanceCriterion(criterion))) {
+            return { ok: false, added: 0, summary: `proposed story ${story.id} lacks executable criterion evidence`, changeId: request.id };
+        }
+        for (const criterion of story.acceptance.filter(isAcceptanceCriterion)) {
+            const problem = criterionCommandProblem(criterion);
+            if (problem)
+                return { ok: false, added: 0, summary: problem, changeId: request.id };
+        }
+        proposedIds.add(story.id);
+    }
+    const appended = proposed.map(story => ({ ...story, sourceChange: request.id }));
+    const dependencyIssues = validateDependencies([...existing, ...appended]);
+    if (dependencyIssues.length > 0) {
+        return { ok: false, added: 0, summary: `invalid combined dependency graph: ${dependencyIssues.join('; ')}`, changeId: request.id };
+    }
+    const reviewPath = reviewFile(targetDir, request.id);
+    rmSync(reviewPath, { force: true });
+    const reviewBase = agentInvocation(reviewer, buildChangeReviewPrompt(request, reviewPath, appended), plannerDir, opts.permissions ?? 'safe', reviewer === opts.runner ? opts.selection : undefined);
+    const reviewInvocation = buildWatchdogInvocation(reviewBase, opts.timeoutMs ?? 0);
+    const reviewResult = (opts.review ?? runAgent)(reviewInvocation);
+    if (!reviewResult.success) {
+        return { ok: false, added: 0, summary: `coverage review failed: ${reviewResult.summary}`, changeId: request.id };
+    }
+    if (readFileSync(prdPath, 'utf8') !== existingText) {
+        return {
+            ok: false, added: 0,
+            summary: 'PRD changed while the coverage reviewer was running; refusing to overwrite concurrent or out-of-contract edits',
+            changeId: request.id,
+        };
+    }
+    if (!existsSync(reviewPath)) {
+        return { ok: false, added: 0, summary: `coverage reviewer did not write ${basename(reviewPath)}`, changeId: request.id };
+    }
+    let coverageReview;
+    try {
+        coverageReview = ChangeReviewSchema.parse(JSON.parse(readFileSync(reviewPath, 'utf8')));
+    }
+    catch (error) {
+        return { ok: false, added: 0, summary: `invalid coverage review: ${error.message}`, changeId: request.id };
+    }
+    if (coverageReview.changeId !== request.id) {
+        return { ok: false, added: 0, summary: `coverage review targets ${coverageReview.changeId}, expected ${request.id}`, changeId: request.id };
+    }
+    if (!coverageReview.approved || coverageReview.uncovered.length > 0) {
+        const missing = coverageReview.uncovered.length > 0 ? `: ${coverageReview.uncovered.join('; ')}` : '';
+        return { ok: false, added: 0, summary: `coverage review rejected the proposal: ${coverageReview.summary}${missing}`, changeId: request.id };
+    }
+    try {
+        savePrd(prdPath, [...existing, ...appended]);
+        (opts.commit ?? ((path, change) => commitPaths(targetDir, [path], `yoke: plan change ${change.id}`)))(prdPath, request);
+    }
+    catch (error) {
+        writeFileSync(prdPath, existingText);
+        return { ok: false, added: 0, summary: `could not persist change: ${error.message}`, changeId: request.id };
+    }
+    try {
+        ;
+        (opts.archive ?? archiveRequest)(targetDir, request);
+    }
+    catch (error) {
+        return {
+            ok: false, added: appended.length,
+            summary: `planned change ${request.id} was committed but could not be archived; keeping it pending for recovery: ${error.message}`,
+            changeId: request.id,
+        };
+    }
+    return { ok: true, added: appended.length, summary: `added ${appended.length} stories from ${request.id}`, changeId: request.id };
+}

package/dist/cli.js

@@ -15,6 +15,7 @@ import { maybeNotifyUpdate, currentYokeVersion } from './update/check.js';
 import { runUpgrade } from './update/upgrade.js';
 import { printAudit, runAudit } from './audit/command.js';
 import { runSetup } from './setup/command.js';
+import { pendingChanges, queueChange } from './change/inbox.js';
 import { answerPendingDecision, answeredDecisionResumeIsValid, clearDecisionResume, decisionProcessingExists, decisionResumeMatchesCurrent, finalizeCommittedDecisionResume, formatPendingDecision, readDecisionResume, readPendingDecision, writeDecisionResume, } from './loop/decision.js';
 export { runRetrofit } from './retrofit/command.js';
 export function runValidate(canonDir) {
@@ -115,6 +116,39 @@ export function main(argv) {
             }
             return runRetrofit(targetDir, { loop, agents, codeGraph });
         }
+        case 'change': {
+            const sub = rest[0];
+            const targetDir = rest.slice(1).find(a => !a.startsWith('-')) ?? '.';
+            if (sub === 'add') {
+                const idea = rest.find(a => a.startsWith('--idea='))?.slice('--idea='.length);
+                if (!idea?.trim()) {
+                    console.error('usage: yoke change add [dir] --idea="..."');
+                    return 1;
+                }
+                try {
+                    const request = queueChange(targetDir, idea);
+                    console.log(`Queued change ${request.id}. A running loop will turn it into new stories at the next story boundary.`);
+                    return 0;
+                }
+                catch (error) {
+                    console.error(`Could not queue change: ${error.message}`);
+                    return 1;
+                }
+            }
+            if (sub === 'status') {
+                try {
+                    const requests = pendingChanges(targetDir);
+                    console.log(requests.length === 0 ? 'No pending changes.' : requests.map(item => `${item.id}  ${item.request}`).join('\n'));
+                    return 0;
+                }
+                catch (error) {
+                    console.error(`Could not read change inbox: ${error.message}`);
+                    return 1;
+                }
+            }
+            console.log('usage: yoke change <add|status> [dir] [--idea="..."]');
+            return 1;
+        }
         case 'loop': {
             const sub = rest[0];
             const targetDir = rest.slice(1).find(a => !a.startsWith('-')) ?? '.';
@@ -430,7 +464,7 @@ export function main(argv) {
         case 'upgrade':
             return runUpgrade();
         default:
-            console.log('usage: yoke <setup [dir] | new <dir> [--idea="..."] | validate [canonDir] | retrofit [targetDir] [--agent=claude,codex,gemini|all] [--code-graph=graphify|serena] [--loop] | prd <draft|check> [dir] | loop <on|off|status|decision|answer|resume|run|cleanup> | context <init|status> | review [dir] [--reviewer=<claude|codex|gemini>] [--base=<ref>] [--focus="..."] | design-scan [dir] [--max=N] [--report] | flow-smoke [dir] [--url=<baseUrl>] [--label=<name>] | upgrade>');
+            console.log('usage: yoke <setup [dir] | new <dir> [--idea="..."] | validate [canonDir] | retrofit [targetDir] [--agent=claude,codex,gemini|all] [--code-graph=graphify|serena] [--loop] | change <add|status> [dir] | prd <draft|check> [dir] | loop <on|off|status|decision|answer|resume|run|cleanup> | context <init|status> | review [dir] [--reviewer=<claude|codex|gemini>] [--base=<ref>] [--focus="..."] | design-scan [dir] [--max=N] [--report] | flow-smoke [dir] [--url=<baseUrl>] [--label=<name>] | upgrade>');
             return cmd ? 1 : 0;
     }
 }

package/dist/loop/evidence.js

@@ -0,0 +1,31 @@
+import { mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { storyPathSegment } from './prd.js';
+export function writeCriterionEvidence(targetDir, story, evidence) {
+    const storySegment = storyPathSegment(story.id);
+    const dir = join(targetDir, '.yoke', 'proof', storySegment);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, 'evidence.json');
+    const temporary = `${path}.${process.pid}.tmp`;
+    const contents = JSON.stringify({
+        version: 1,
+        storyId: story.id,
+        generatedAt: new Date().toISOString(),
+        criteria: evidence.map(({ criterion, result }) => ({
+            id: criterion.id,
+            text: criterion.text,
+            verify: criterion.verify,
+            passed: result.passed,
+            summary: result.summary,
+        })),
+    }, null, 2) + '\n';
+    try {
+        writeFileSync(temporary, contents, { flag: 'wx' });
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw error;
+    }
+    return path;
+}

package/dist/loop/gates.js

@@ -1,7 +1,16 @@
-export function stopTheLineGate(story) {
+import { criterionCommandProblem, isAcceptanceCriterion } from './prd.js';
+export function stopTheLineGate(story, requireCriterionEvidence = false) {
     if (story.acceptance.length === 0) {
         return { ok: false, reason: `story ${story.id} has no acceptance criteria (Stop-the-Line)` };
     }
+    if (requireCriterionEvidence && story.acceptance.some(criterion => !isAcceptanceCriterion(criterion))) {
+        return { ok: false, reason: `story ${story.id} lacks executable criterion evidence (Stop-the-Line)` };
+    }
+    for (const criterion of story.acceptance.filter(isAcceptanceCriterion)) {
+        const problem = criterionCommandProblem(criterion);
+        if (problem)
+            return { ok: false, reason: `${problem} (Stop-the-Line)` };
+    }
     return { ok: true };
 }
 export function preDispatchGate(targetDir, git) {