@aviaratech/ai-delivery 0.3.3 → 0.3.4

package/dist/lifecycle.test.js

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
-import { execFileSync, spawn } from 'node:child_process';
+import { execFileSync, spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { cpSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, readdirSync, realpathSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { cpSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, readdirSync, realpathSync, rmSync, symlinkSync, unlinkSync, utimesSync, writeFileSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { test, vi } from 'vitest';
@@ -16,12 +16,13 @@ import { digestValue } from './delivery/index.js';
 import { executeTool, resumedIssueUpdate, startTrackedIssue } from './dispatch.js';
 import { defaultBaseRef, gitCommonDir } from './git.js';
 import * as githubClient from './github/client.js';
+import * as atomicJson from './utils/atomicJson.js';
 import { createIssue, developIssue, listIssueSubissues, readyCheck, resumeCreatedIssue, updateIssue, } from './issue.js';
 import { checkoutPr, finishIssue, listPrs, mergePr, prChecks, prInfo, publishPr, submitFormalReview } from './pr.js';
-import { updateIssueWorktreeDelivery } from './services/worktreeRegistry.js';
+import { addWorktreeEntry, removeWorktreeEntry, updateIssueWorktreeDelivery } from './services/worktreeRegistry.js';
 import { assertDeliveryRuntimeAdmitted } from './services/deliveryAdmission.js';
 import { getDeliveryRecords } from './services/deliveryRecordService.js';
-import { createIssuePhaseEvidence, verifyIssue } from './verification.js';
+import { createIssuePhaseEvidence, loadVerifiedRun, verifyIssue } from './verification.js';
 import { cleanupNonIssueWorktree, prepareIssueWorktree, preparePrWorktree, prepareStandaloneWorktree, } from './worktree.js';
 const personalRoute = vi.hoisted(() => ({
     active: false,
@@ -29,6 +30,10 @@ const personalRoute = vi.hoisted(() => ({
     headSha: '',
     reviews: [],
     submitted: 0,
+    created: false,
+    failCreate: false,
+    ready: false,
+    readyPromotions: 0,
 }));
 vi.mock('./github/client.js', async (importOriginal) => {
     const actual = await importOriginal();
@@ -43,7 +48,7 @@ vi.mock('./github/client.js', async (importOriginal) => {
                     head: { sha: personalRoute.headSha, ref: 'issue/17' },
                     base: { sha: personalRoute.baseSha, ref: 'main' },
                     state: 'open',
-                    draft: true,
+                    draft: !personalRoute.ready,
                     user: { login: 'host-user' },
                 });
                 if (input.role === 'reviewer') {
@@ -101,6 +106,11 @@ vi.mock('./github/client.js', async (importOriginal) => {
                                     },
                                 };
                             }
+                            if (query.includes('DeliveryDiscovery') ||
+                                query.includes('DeliveryRepository') ||
+                                query.includes('ProjectDeliveryConfiguration')) {
+                                throw Object.assign(new Error('Reviewer cannot discover author routing metadata'), { status: 403 });
+                            }
                             return syntheticDiscoveryClients().graphql(query, variables);
                         },
                     };
@@ -112,14 +122,29 @@ vi.mock('./github/client.js', async (importOriginal) => {
                 });
                 Object.assign(clients, {
                     authenticatedAuthor: async () => ({ actorLogin: 'host-user', credentialIdentity: 'user:37' }),
-                    graphql: syntheticDiscoveryClients().graphql,
+                    graphql: async (query, variables) => {
+                        if (query.includes('markPullRequestReadyForReview')) {
+                            personalRoute.ready = true;
+                            personalRoute.readyPromotions += 1;
+                            return { markPullRequestReadyForReview: { pullRequest: { id: 'PR-23', isDraft: false } } };
+                        }
+                        return syntheticDiscoveryClients().graphql(query, variables);
+                    },
                     rest: {
                         issues: { get: async () => ({ data: { title: 'Synthetic issue' } }) },
                         git: { getRef: async () => ({ data: { object: { sha: personalRoute.baseSha } } }) },
                         pulls: {
-                            list: async () => ({ data: [] }),
-                            create: async () => ({ data: pr() }),
+                            list: async () => ({ data: personalRoute.created ? [pr()] : [] }),
+                            create: async () => {
+                                if (personalRoute.failCreate) {
+                                    personalRoute.failCreate = false;
+                                    throw new Error('Synthetic response lost after branch push');
+                                }
+                                personalRoute.created = true;
+                                return { data: pr() };
+                            },
                             get: async () => ({ data: pr() }),
+                            listReviews: async () => ({ data: personalRoute.reviews }),
                         },
                         request: async () => Promise.reject(Object.assign(new Error('Rules unreadable'), { status: 403 })),
                     },
@@ -194,6 +219,8 @@ async function fixture(options = {}) {
         git(root, 'remote', 'add', remoteName, join(root, '.git', 'remote.git'));
         writeFileSync(join(root, '.gitignore'), '.issue-cli/\n.worktrees/\n');
         writeFileSync(join(root, 'artifact.txt'), 'synthetic proof\n');
+        if (options.componentPolicy)
+            writeFileSync(join(root, 'component.txt'), 'second component\n');
         const config = {
             commandPolicy: {
                 checks: { format: 'REQUIRED', gitClean: 'REQUIRED', lint: 'REQUIRED', test: 'REQUIRED', typecheck: 'REQUIRED' },
@@ -251,7 +278,7 @@ const bytes = value => 'sha256:' + createHash('sha256').update(value).digest('he
 const policyDigest = bytes(readFileSync(fileURLToPath(import.meta.url)));
 export const deliverySettings = ${JSON.stringify({ roles: config.roles, commandPolicy: config.commandPolicy })};
 export default {
-  schemaVersion: 'RepositoryDeliveryPolicy@1',
+  schemaVersion: '${options.componentPolicy ? 'RepositoryDeliveryPolicy@2' : 'RepositoryDeliveryPolicy@1'}',
   classifyExactRange(input) {
     const content = { artifacts: [{ digest: bytes(readFileSync(new URL('./artifact.txt', import.meta.url))),
       path: 'artifact.txt', producer: 'synthetic' }],
@@ -261,9 +288,11 @@ export default {
       schemaVersion: 'ai-delivery.policy-evidence@1' };
     return { policyDigest, policyEvidence: { ...content, evidenceId: digest(content) },
       requiredStages: [{ id: 'check', dependsOn: [], semanticInputKeys: ['source'],
+        ${options.componentPolicy ? "semanticInputs: [{ key: 'source', digest: bytes(readFileSync(new URL('./artifact.txt', import.meta.url))) }]," : ''}
         resourceClass: 'source_only', commands: [{ label: 'count', argv: [process.execPath, '-e',
           ${JSON.stringify(options.firstStageScript ?? `const fs=require('fs');const p=${JSON.stringify(counter)};fs.writeFileSync(p,String(Number(fs.existsSync(p)?fs.readFileSync(p,'utf8'):0)+1));`)}] }] }${options.twoStages
             ? `, { id: 'second', dependsOn: ['check'], semanticInputKeys: ['source'],
+        ${options.componentPolicy ? "semanticInputs: [{ key: 'source', digest: bytes(readFileSync(new URL('./component.txt', import.meta.url))) }]," : ''}
         resourceClass: 'source_only', commands: [{ label: 'retry', argv: [process.execPath, '-e',
           ${JSON.stringify(options.secondStageScript ?? `const fs=require('fs');const p=${JSON.stringify(secondCounter)};fs.writeFileSync(p,String(Number(fs.existsSync(p)?fs.readFileSync(p,'utf8'):0)+1));if(fs.existsSync(${JSON.stringify(failSecond)}))process.exit(7);`)}] }] }`
             : ''}],
@@ -647,6 +676,443 @@ test('synthetic cutover restores exact pre-write state and resumes an incomplete
         rmSync(root, { recursive: true, force: true });
     }
 });
+test('immediate successful commands establish ownership and remain reusable', async () => {
+    const { root } = await fixture();
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const policyPath = join(row.path, 'policy.mjs');
+        writeFileSync(policyPath, readFileSync(policyPath, 'utf8').replace("argv: [process.execPath, '-e',", "argv: ['/usr/bin/true',"));
+        git(row.path, 'add', 'policy.mjs');
+        git(row.path, 'commit', '-qm', 'immediate stage');
+        const first = await verifyIssue({ issueNumber: 17, repoRoot: row.path });
+        const reused = await verifyIssue({ issueNumber: 17, repoRoot: row.path });
+        assert.equal(first.stageReceipts[0].receiptId, reused.stageReceipts[0].receiptId);
+        const bounded = await verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
+        });
+        assert.equal(bounded.aggregate.result, 'passed');
+        assert.ok(bounded.resources.sampleCount > 0);
+        assert.deepEqual(readdirSync(join(root, '.git/ai-delivery/writers@1')), []);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('component verification recomposes current-source aggregates with only affected stage execution', async () => {
+    const { root, counter, secondCounter } = await fixture({ twoStages: true, componentPolicy: true });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const resourceBounds = { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 };
+        const original = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds });
+        writeFileSync(join(row.path, 'unrelated.txt'), 'documentation');
+        git(row.path, 'add', '.');
+        git(row.path, 'commit', '-qm', 'unrelated source');
+        const current = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds });
+        assert.notEqual(current.classification.receiptId, original.classification.receiptId);
+        assert.deepEqual(current.stageReceipts.map((r) => r.receiptId), original.stageReceipts.map((r) => r.receiptId));
+        assert.equal(current.aggregate.classificationReceiptId, current.classification.receiptId);
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '1');
+        writeFileSync(join(row.path, 'component.txt'), 'changed second component');
+        git(row.path, 'add', '.');
+        git(row.path, 'commit', '-qm', 'second component');
+        const secondChanged = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds });
+        assert.equal(secondChanged.stageReceipts[0].receiptId, original.stageReceipts[0].receiptId);
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '2');
+        writeFileSync(join(row.path, 'artifact.txt'), 'changed upstream component');
+        git(row.path, 'add', '.');
+        git(row.path, 'commit', '-qm', 'upstream component');
+        await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds });
+        assert.equal(readFileSync(counter, 'utf8'), '2');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '3');
+        await createIssuePhaseEvidence({ issueNumber: 17, repoRoot: row.path, phase: 'verify' });
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('quiet verification reports completion-based progress and remains cancellable', { timeout: 12_000 }, async () => {
+    const { root } = await fixture({ firstStageScript: 'setInterval(()=>{},1000);' });
+    const controller = new AbortController();
+    const progress = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    let running;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        running = verifyIssue({ issueNumber: 17, repoRoot: row.path, signal: controller.signal });
+        void running.catch(() => undefined);
+        let status;
+        for (let attempt = 0; attempt < 350; attempt++) {
+            const latest = progress.mock.calls
+                .map(([chunk]) => String(chunk))
+                .filter((line) => line.startsWith('ai-delivery.verify '))
+                .at(-1);
+            if (latest)
+                status = JSON.parse(latest.slice('ai-delivery.verify '.length));
+            if (Number(status?.elapsedMs) >= 5_000)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        }
+        assert.equal(status?.completedCommands, 0);
+        assert.equal(status?.remainingCommands, 1);
+        assert.equal(status?.completedStages, 0);
+        assert.equal(status?.capturedOutputBytes, 0);
+        assert.ok(Number(status?.lastCompletedWorkAgeMs) >= 5_000);
+        controller.abort();
+        await assert.rejects(running, /cancelled/u);
+    }
+    finally {
+        controller.abort();
+        await running?.catch(() => undefined);
+        vi.restoreAllMocks();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('writer persistence failure retains recovery identity while cancellation cleans its owned command', async () => {
+    const directory = mkdtempSync(join(tmpdir(), 'ai-delivery-writer-failure-'));
+    const marker = join(directory, 'started');
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');fs.writeFileSync(${JSON.stringify(marker)},String(process.pid));setInterval(()=>{},1000);`,
+    });
+    const controller = new AbortController();
+    const original = atomicJson.writePrivateJsonFileAtomically;
+    let failWrites = false;
+    const persistence = vi.spyOn(atomicJson, 'writePrivateJsonFileAtomically').mockImplementation((path, value) => {
+        if (failWrites && path.includes('/writers@1/'))
+            throw new Error('ENOSPC: synthetic writer persistence failure');
+        original(path, value);
+    });
+    let running;
+    let owner;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const writerPath = join(root, '.git/ai-delivery/writers@1', `${digestValue(row.path).slice(7)}.json`);
+        running = verifyIssue({ issueNumber: 17, repoRoot: row.path, signal: controller.signal }).catch((error) => error);
+        for (let attempt = 0; attempt < 100 && !existsSync(marker); attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.ok(existsSync(marker));
+        const recorded = JSON.parse(readFileSync(writerPath, 'utf8'));
+        owner = recorded.command.root;
+        assert.equal(Number(readFileSync(marker, 'utf8')), owner.pid);
+        failWrites = true;
+        controller.abort();
+        const failure = String(await running);
+        assert.match(failure, /cancelled.*Writer state persistence failed.*ENOSPC/u);
+        assert.doesNotMatch(failure, /Owned process cleanup failed/u);
+        const remaining = spawnSync('ps', ['-p', String(owner.pid), '-o', 'stat='], { encoding: 'utf8' });
+        assert.ok(remaining.status === 1 || remaining.stdout.trim().startsWith('Z'));
+        assert.deepEqual(JSON.parse(readFileSync(writerPath, 'utf8')).command.root, owner);
+        assert.equal(existsSync(`${writerPath}.lock`), false);
+        failWrites = false;
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path }), /live verification writer/u);
+        assert.equal(existsSync(writerPath), true);
+    }
+    finally {
+        controller.abort();
+        await running;
+        persistence.mockRestore();
+        if (owner !== undefined) {
+            const current = spawnSync('ps', ['-p', String(owner.pid), '-o', 'lstart='], { encoding: 'utf8' });
+            if (current.status === 0 && current.stdout.trim() === owner.identity)
+                process.kill(owner.pid, 'SIGKILL');
+        }
+        rmSync(root, { recursive: true, force: true });
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test('verification excludes a second writer in the same worktree before command execution', async () => {
+    const marker = join(tmpdir(), `ai-delivery-writer-${String(process.pid)}`);
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');fs.appendFileSync(${JSON.stringify(marker)},'started\\n');setInterval(()=>{},1000);`,
+    });
+    const controller = new AbortController();
+    let running;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        running = verifyIssue({ issueNumber: 17, repoRoot: row.path, signal: controller.signal }).catch((error) => error);
+        for (let attempt = 0; attempt < 100 && !existsSync(marker); attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.ok(existsSync(marker));
+        const contender = new AbortController();
+        const stopContender = setTimeout(() => contender.abort(), 500);
+        try {
+            await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, signal: contender.signal }), /writer|Lock acquisition/u);
+        }
+        finally {
+            clearTimeout(stopContender);
+        }
+        assert.equal(readFileSync(marker, 'utf8'), 'started\n');
+        controller.abort();
+        assert.match(String(await running), /cancelled/u);
+    }
+    finally {
+        controller.abort();
+        await running;
+        rmSync(root, { recursive: true, force: true });
+        rmSync(marker, { force: true });
+    }
+});
+test('live or unknown writer state fails closed even after a file lease becomes stale', async () => {
+    const { root, counter } = await fixture();
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const writerDirectory = join(root, '.git/ai-delivery/writers@1');
+        mkdirSync(writerDirectory, { recursive: true });
+        const writerPath = join(writerDirectory, `${digestValue(row.path).slice(7)}.json`);
+        const state = {
+            schemaVersion: 'ai-delivery.verification-writer@1',
+            writerId: '00000000-0000-4000-8000-000000000001',
+            worktreeDigest: digestValue(row.path),
+            owner: {
+                pid: process.pid,
+                identity: execFileSync('/bin/ps', ['-p', String(process.pid), '-o', 'lstart='], { encoding: 'utf8' }).trim(),
+            },
+            command: { phase: 'idle' },
+        };
+        writeFileSync(writerPath, JSON.stringify({ ...state, stateId: digestValue(state) }), { mode: 0o600 });
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path }), /live verification writer/u);
+        const unknown = {
+            ...state,
+            owner: { ...state.owner, identity: 'replaced historical process' },
+            command: { phase: 'starting' },
+        };
+        writeFileSync(writerPath, JSON.stringify({ ...unknown, stateId: digestValue(unknown) }));
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path }), /unknown command ownership/u);
+        assert.equal(existsSync(counter), false);
+        assert.equal(existsSync(writerPath), true);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('same-head worktrees overlap with isolated checkpoints and cancellation preserves the peer', { timeout: 15_000 }, async () => {
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');const cp=require('child_process');const path=require('path');const dir=cp.execFileSync('git',['rev-parse','--absolute-git-dir'],{encoding:'utf8'}).trim();const marker=path.join(dir,'peer-command');fs.writeFileSync(marker,'running');const wait=setInterval(()=>{if(fs.existsSync(marker+'.release')){clearInterval(wait);fs.writeFileSync(marker,'passed');}},20);`,
+    });
+    const cancel = new AbortController();
+    const parallelCancel = new AbortController();
+    let first;
+    let second;
+    let parallelRuns = [];
+    try {
+        const a = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const b = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 18,
+            repoRoot: root,
+        });
+        assert.equal(git(a.path, 'rev-parse', 'HEAD'), git(b.path, 'rev-parse', 'HEAD'));
+        first = verifyIssue({ issueNumber: 17, repoRoot: a.path, signal: cancel.signal }).catch((error) => error);
+        second = verifyIssue({ issueNumber: 18, repoRoot: b.path });
+        void second.catch(() => undefined);
+        const markerA = join(git(a.path, 'rev-parse', '--absolute-git-dir'), 'peer-command');
+        const markerB = join(git(b.path, 'rev-parse', '--absolute-git-dir'), 'peer-command');
+        for (let attempt = 0; attempt < 100 && !(existsSync(markerA) && existsSync(markerB)); attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.equal(readFileSync(markerA, 'utf8'), 'running');
+        assert.equal(readFileSync(markerB, 'utf8'), 'running');
+        cancel.abort();
+        assert.match(String(await first), /cancelled/u);
+        writeFileSync(`${markerB}.release`, 'ready');
+        const peer = await second;
+        writeFileSync(`${markerA}.release`, 'ready');
+        const retried = await verifyIssue({ issueNumber: 17, repoRoot: a.path });
+        assert.notEqual(peer.stageReceipts[0].input.inputId, retried.stageReceipts[0].input.inputId);
+        assert.equal(loadVerifiedRun(b.path, 18).manifestId, peer.manifestId);
+        assert.equal(loadVerifiedRun(a.path, 17).manifestId, retried.manifestId);
+        assert.equal(readFileSync(markerA, 'utf8'), 'passed');
+        assert.equal(readFileSync(markerB, 'utf8'), 'passed');
+        assert.deepEqual(peer.stageReceipts[0].commands, retried.stageReceipts[0].commands);
+        const resourceBounds = { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 };
+        const parallelStartedAt = Date.now();
+        for (const marker of [markerA, markerB]) {
+            rmSync(marker);
+            rmSync(`${marker}.release`);
+        }
+        parallelRuns = [
+            verifyIssue({ issueNumber: 17, repoRoot: a.path, resourceBounds, signal: parallelCancel.signal }),
+            verifyIssue({ issueNumber: 18, repoRoot: b.path, resourceBounds, signal: parallelCancel.signal }),
+        ];
+        const parallelRun = Promise.all(parallelRuns);
+        void parallelRun.catch(() => undefined);
+        for (let attempt = 0; attempt < 200 && !(existsSync(markerA) && existsSync(markerB)); attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.equal(readFileSync(markerA, 'utf8'), 'running');
+        assert.equal(readFileSync(markerB, 'utf8'), 'running');
+        for (const marker of [markerA, markerB])
+            writeFileSync(`${marker}.release`, 'ready');
+        const parallel = await parallelRun;
+        const parallelElapsedMs = Date.now() - parallelStartedAt;
+        assert.deepEqual(parallel.map((run) => run.stageReceipts[0].commands), [peer.stageReceipts[0].commands, retried.stageReceipts[0].commands]);
+        assert.ok(parallel.every((run) => run.resources.sampleCount > 0));
+        const reused = await verifyIssue({ issueNumber: 18, repoRoot: b.path, resourceBounds });
+        assert.equal(reused.stageReceipts[0].receiptId, parallel[1].stageReceipts[0].receiptId);
+        const manifestA = join(root, '.git/ai-delivery/runs@2', digestValue(a.path).slice(7), `${peer.classification.head.sha}.json`);
+        const { manifestId: _foreignId, ...foreign } = parallel[1];
+        const foreignContent = { ...foreign, writer: { ...foreign.writer, worktreeDigest: digestValue(a.path) } };
+        writeFileSync(manifestA, JSON.stringify({ ...foreignContent, manifestId: digestValue(foreignContent) }));
+        assert.throws(() => loadVerifiedRun(a.path, 17), /environment|foreign/u);
+        writeFileSync(manifestA, JSON.stringify(parallel[0]));
+        console.log('WRITER_ISOLATION_RECEIPT', JSON.stringify({
+            sameHead: peer.classification.head.sha,
+            peerManifest: peer.manifestId,
+            retryManifest: retried.manifestId,
+            peerReused: true,
+            parallelElapsedMs,
+            maxObservedRssBytes: Math.max(...parallel.map((run) => run.resources.maxSampledAggregateRssBytes)),
+        }));
+    }
+    finally {
+        cancel.abort();
+        parallelCancel.abort();
+        await first;
+        await second?.catch(() => undefined);
+        await Promise.allSettled(parallelRuns);
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('interruption child verification', { skip: !process.env.AI_DELIVERY_INTERRUPTION_WORKTREE }, async () => {
+    await verifyIssue({ issueNumber: 17, repoRoot: process.env.AI_DELIVERY_INTERRUPTION_WORKTREE });
+});
+test('interrupted writer recovers only its recorded command and resumes completed checkpoints', { timeout: 30_000 }, async () => {
+    const { root, counter, secondCounter } = await fixture({
+        twoStages: true,
+        secondStageScript: `const fs=require('fs');const cp=require('child_process');const path=require('path');const dir=cp.execFileSync('git',['rev-parse','--git-common-dir'],{encoding:'utf8'}).trim();const count=path.join(dir,'second-stage-count.txt');fs.writeFileSync(count,String(Number(fs.existsSync(count)?fs.readFileSync(count,'utf8'):0)+1));if(!fs.existsSync(path.join(dir,'resume-interrupted')))setInterval(()=>{},1000);`,
+    });
+    let child;
+    let workerPid;
+    let ownedPid;
+    let workerIdentity;
+    let ownedIdentity;
+    let peer;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        child = spawn(process.execPath, [
+            join(process.cwd(), 'node_modules/vitest/vitest.mjs'),
+            'run',
+            'dist/lifecycle.test.js',
+            '-t',
+            '^interruption child verification$',
+        ], {
+            cwd: process.cwd(),
+            stdio: 'ignore',
+            env: { ...process.env, AI_DELIVERY_INTERRUPTION_WORKTREE: row.path },
+        });
+        const childClosed = new Promise((resolve) => child.once('close', resolve));
+        const writerPath = join(root, '.git/ai-delivery/writers@1', `${digestValue(row.path).slice(7)}.json`);
+        let recorded;
+        for (let attempt = 0; attempt < 200; attempt++) {
+            if (existsSync(writerPath))
+                recorded = JSON.parse(readFileSync(writerPath, 'utf8'));
+            if (recorded?.command.phase === 'running' && existsSync(secondCounter))
+                break;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        }
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '1');
+        assert.equal(recorded?.command.phase, 'running');
+        workerPid = recorded.owner.pid;
+        ownedPid = recorded.command.root.pid;
+        workerIdentity = recorded.owner.identity;
+        ownedIdentity = recorded.command.root.identity;
+        const completedDir = join(root, '.git/ai-delivery/verification@1/stages/check');
+        const completedCheckpoint = join(completedDir, readdirSync(completedDir)[0]);
+        const completedDigest = sha256(completedCheckpoint);
+        peer = spawn(process.execPath, ['-e', 'setInterval(()=>{},1000)'], { detached: true, stdio: 'ignore' });
+        assert.equal(spawnSync('ps', ['-p', String(workerPid), '-o', 'lstart='], { encoding: 'utf8' }).stdout.trim(), workerIdentity);
+        process.kill(workerPid, 'SIGKILL');
+        workerPid = undefined;
+        await childClosed;
+        process.kill(ownedPid, 0);
+        // A stale file lease is not permission to forget the durable command owner.
+        const stale = new Date(Date.now() - 20_000);
+        utimesSync(`${writerPath}.lock`, stale, stale);
+        writeFileSync(join(root, '.git/resume-interrupted'), 'ready');
+        const recovered = await verifyIssue({ issueNumber: 17, repoRoot: row.path });
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '2');
+        assert.equal(sha256(completedCheckpoint), completedDigest);
+        assert.equal(recovered.aggregate.result, 'passed');
+        process.kill(peer.pid, 0);
+        assert.equal(existsSync(writerPath), false);
+        assert.equal(existsSync(`${writerPath}.lock`), false);
+        const survivor = spawnSync('/bin/ps', ['-p', String(ownedPid), '-o', 'stat='], { encoding: 'utf8' });
+        assert.ok((survivor.status === 1 && !survivor.stdout.trim()) ||
+            (survivor.status === 0 && survivor.stdout.trim().startsWith('Z')));
+        console.log('INTERRUPTION_RESUME_RECEIPT', JSON.stringify({
+            completedCheckpoint: completedDigest,
+            firstStageExecutions: 1,
+            interruptedStageExecutions: 2,
+            peerPreserved: true,
+            aggregateId: recovered.aggregate.aggregateId,
+        }));
+        ownedPid = undefined;
+    }
+    finally {
+        for (const [pid, identity] of [
+            [workerPid, workerIdentity],
+            [ownedPid, ownedIdentity],
+        ])
+            if (pid !== undefined && identity !== undefined) {
+                const current = spawnSync('ps', ['-p', String(pid), '-o', 'lstart='], { encoding: 'utf8' });
+                if (current.status !== 0 || current.stdout.trim() !== identity)
+                    continue;
+                try {
+                    process.kill(pid, 'SIGKILL');
+                }
+                catch (error) {
+                    assert.equal(error.code, 'ESRCH');
+                }
+            }
+        for (const processHandle of [peer, child])
+            if (processHandle?.exitCode === null && processHandle.signalCode === null)
+                processHandle.kill('SIGKILL');
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 test('issue worktree verification resumes a completed stage and rejects changed inputs', async () => {
     const { root, counter, runtimeEntryPath } = await fixture();
     try {
@@ -1143,7 +1609,7 @@ test('a bounded passing run records measured resources in versioned evidence', a
             repoRoot: row.path,
             resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
         });
-        assert.equal(run.schemaVersion, 'ai-delivery.run@2');
+        assert.equal(run.schemaVersion, 'ai-delivery.run@3');
         const resources = run.resources;
         assert.ok(resources);
         assert.ok(resources.sampleCount > 0);
@@ -1738,25 +2204,46 @@ test('public PR dry run retains a configured host author and App reviewer', asyn
         rmSync(root, { recursive: true, force: true });
     }
 }, 15_000);
-test('public dispatch publishes with selected host token and submits the configured App review once', async () => {
-    const { root, runtimeEntryPath } = await fixture({ personalAuthor: true });
+test.each([
+    { transition: false, entry: 'source', highRisk: false, mcp: false },
+    { transition: true, entry: 'primary', highRisk: false, mcp: false },
+    { transition: true, entry: 'source', highRisk: false, mcp: false },
+    { transition: true, entry: 'primary', highRisk: true, mcp: false },
+    { transition: true, entry: 'source', highRisk: true, mcp: false },
+    { transition: true, entry: 'primary', highRisk: true, mcp: true },
+])('public dispatch publishes and reviews from $entry across policy transition $transition high risk $highRisk MCP $mcp', async ({ transition, entry, highRisk, mcp }) => {
+    const { root, runtimeEntryPath } = await fixture({ personalAuthor: !transition });
     const originalPath = process.env.PATH;
+    const driftEnv = 'AI_DELIVERY_TEST_CANDIDATE_CHECK';
+    const previousDrift = process.env[driftEnv];
+    delete process.env[driftEnv];
+    let closeMcp;
     try {
+        const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
+        const admissionBefore = readFileSync(admissionPath, 'utf8');
+        const primaryConfiguration = await loadDeliveryConfig(root);
         const row = await prepareIssueWorktree({
             baseRef: 'main',
-            identity: 'host-author',
+            identity: transition ? 'synthetic-author' : 'host-author',
             issueNumber: 17,
             repoRoot: root,
         });
+        if (transition) {
+            const policyPath = join(row.path, 'policy.mjs');
+            writeFileSync(policyPath, readFileSync(policyPath, 'utf8')
+                .replace(JSON.stringify(primaryConfiguration.config.roles.author), JSON.stringify({
+                authSource: 'personal',
+                credentialEnv: { token: 'AUTHOR_TOKEN' },
+                identity: 'host-author',
+            }))
+                .replace("risk: 'standard'", `risk: '${highRisk ? 'high' : 'standard'}'`) +
+                `
+Object.defineProperty(deliverySettings.commandPolicy.checks, 'test', { get: () => process.env.${driftEnv} ?? 'REQUIRED' });
+`);
+        }
         writeFileSync(join(row.path, 'change.txt'), 'host author publication\n');
-        git(row.path, 'add', 'change.txt');
+        git(row.path, 'add', '.');
         git(row.path, 'commit', '-qm', 'synthetic host publication');
-        const run = await verifyIssue({ issueNumber: 17, repoRoot: row.path });
-        personalRoute.baseSha = run.classification.base.sha;
-        personalRoute.headSha = run.classification.head.sha;
-        personalRoute.reviews.length = 0;
-        personalRoute.submitted = 0;
-        personalRoute.active = true;
         const realGit = (originalPath ?? '')
             .split(':')
             .map((directory) => join(directory, 'git'))
@@ -1779,24 +2266,36 @@ exec "${realGit}" "$@"
 `);
         chmodSync(shim, 0o700);
         process.env.PATH = `${shimDir}:${originalPath ?? ''}`;
-        const execution = { repoRoot: row.path, runtimeEntryPath, identity: 'host-author' };
-        const published = (await executeTool('issue_pr_create', { issueNumber: 17 }, execution));
-        assert.equal(published.prNumber, 23);
-        assert.equal(existsSync(pushMarker), true);
-        assert.equal(published.reviewRoute.author.actorLogin, 'host-user');
-        assert.equal(published.reviewRoute.author.credentialSource, 'env:AUTHOR_TOKEN');
-        assert.equal(published.reviewRoute.reviewer.actorLogin, 'synthetic-reviewer[bot]');
-        const info = (await executeTool('issue_pr_info', { prNumber: 23 }, execution));
-        assert.equal(info.authorLogin, 'host-user');
-        const artifactContent = {
+        const execution = { repoRoot: entry === 'primary' ? root : row.path, runtimeEntryPath, identity: 'host-author' };
+        let call = (name, args) => executeTool(name, args, execution);
+        if (mcp) {
+            const server = createAiDeliveryMcpServer(execution);
+            const client = new Client({ name: 'policy-transition-test', version: '1.0.0' });
+            closeMcp = async () => {
+                await client.close();
+                await server.close();
+            };
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+            await server.connect(serverTransport);
+            await client.connect(clientTransport);
+            call = async (name, args) => {
+                const result = await client.callTool({ name, arguments: args });
+                const text = result.content.find((block) => block.type === 'text').text;
+                if (result.isError)
+                    throw new Error(text);
+                return JSON.parse(text);
+            };
+        }
+        const classified = await verifyIssue({ issueNumber: 17, repoRoot: row.path });
+        const reviewContent = {
             authorIdentity: 'host-author',
             checks: ['verified exact diff'],
-            diffScopeHash: digestValue(run.classification.changedPaths),
+            diffScopeHash: digestValue(classified.classification.changedPaths),
             elapsedMs: 1,
             findings: [],
-            head: run.classification.head,
+            head: classified.classification.head,
             issueNumber: 17,
-            prNumber: 23,
+            prNumber: null,
             readOnly: true,
             requestedEffort: 'xhigh',
             requestedModel: 'gpt-6-astra',
@@ -1807,19 +2306,112 @@ exec "${realGit}" "$@"
             summary: 'Independent exact-head review',
             verdict: 'approve',
         };
+        const prepublicationReview = join(root, '.git', 'prepublication-review.json');
+        if (highRisk) {
+            await assert.rejects(call('issue_verify', { issueNumber: 17 }), /independent exact-head approval/u);
+            writeFileSync(prepublicationReview, JSON.stringify({ ...reviewContent, artifactId: digestValue(reviewContent) }));
+        }
+        const verified = (await call('issue_verify', {
+            issueNumber: 17,
+            ...(highRisk ? { prepublicationReview } : {}),
+        }));
+        const run = loadVerifiedRun(row.path, 17);
+        const candidateConfiguration = await loadDeliveryConfig(row.path);
+        assert.equal(run.classification.configDigest, candidateConfiguration.configDigest);
+        assert.equal(run.classification.policyDigest, sha256(join(row.path, 'policy.mjs')));
+        if (transition)
+            assert.notEqual(run.classification.configDigest, primaryConfiguration.configDigest);
+        assert.equal(readFileSync(admissionPath, 'utf8'), admissionBefore);
+        const phaseEvidence = JSON.parse(readFileSync(join(root, '.git', 'ai-delivery', 'receipts', 'delivery@1', run.classification.head.sha, `${verified.evidenceId.slice(7)}.json`), 'utf8'));
+        assert.equal(phaseEvidence.configDigest, candidateConfiguration.configDigest);
+        assert.equal(phaseEvidence.aggregateId, run.aggregate.aggregateId);
+        if (highRisk) {
+            assert.equal(phaseEvidence.approval?.authorIdentity, 'host-author');
+            assert.equal(phaseEvidence.approval?.reviewerIdentity, 'synthetic-reviewer');
+        }
+        personalRoute.baseSha = run.classification.base.sha;
+        personalRoute.headSha = run.classification.head.sha;
+        personalRoute.reviews.length = 0;
+        personalRoute.submitted = 0;
+        personalRoute.created = false;
+        personalRoute.failCreate = false;
+        personalRoute.ready = false;
+        personalRoute.readyPromotions = 0;
+        personalRoute.active = true;
+        if (transition) {
+            await assert.rejects(executeTool('issue_pr_create', { issueNumber: 17 }, { ...execution, identity: 'synthetic-author' }), /configured author identity/u);
+            writeFileSync(join(row.path, 'dirty.txt'), 'unverified');
+            await assert.rejects(executeTool('issue_pr_create', { issueNumber: 17 }, execution), /clean worktree/u);
+            rmSync(join(row.path, 'dirty.txt'));
+            git(row.path, 'commit', '--allow-empty', '-qm', 'unverified head');
+            await assert.rejects(executeTool('issue_pr_create', { issueNumber: 17 }, execution));
+            assert.equal(existsSync(pushMarker), false);
+            git(row.path, 'reset', '--hard', run.classification.head.sha);
+            personalRoute.baseSha = 'f'.repeat(40);
+            await assert.rejects(call('issue_pr_create', { issueNumber: 17 }), /Remote base changed/u);
+            assert.equal(existsSync(pushMarker), false);
+            personalRoute.baseSha = run.classification.base.sha;
+            personalRoute.failCreate = true;
+            await assert.rejects(call('issue_pr_create', { issueNumber: 17 }), /response lost after branch push/u);
+            assert.equal(existsSync(pushMarker), true);
+            assert.equal(personalRoute.created, false);
+        }
+        const published = (await call('issue_pr_create', { issueNumber: 17 }));
+        assert.equal(published.prNumber, 23);
+        assert.equal(existsSync(pushMarker), true);
+        assert.equal(published.reviewRoute.author.actorLogin, 'host-user');
+        assert.equal(published.reviewRoute.author.credentialSource, 'env:AUTHOR_TOKEN');
+        assert.equal(published.reviewRoute.reviewer.actorLogin, 'synthetic-reviewer[bot]');
+        const info = (await call('issue_pr_info', { issueNumber: 17, prNumber: 23 }));
+        assert.equal(info.authorLogin, 'host-user');
+        assert.equal(readFileSync(admissionPath, 'utf8'), admissionBefore);
+        const artifactContent = { ...reviewContent, prNumber: 23 };
         const artifact = JSON.stringify({ ...artifactContent, artifactId: digestValue(artifactContent) });
         const reviewInput = { issueNumber: 17, prNumber: 23, identity: 'synthetic-reviewer', artifact };
-        const first = (await executeTool('issue_pr_review', reviewInput, execution));
+        if (transition) {
+            personalRoute.headSha = 'b'.repeat(40);
+            await assert.rejects(call('issue_pr_review', reviewInput), /head/u);
+            assert.equal(personalRoute.submitted, 0);
+            personalRoute.headSha = run.classification.head.sha;
+        }
+        if (transition && entry === 'source') {
+            process.env[driftEnv] = 'SKIP';
+            assert.notEqual((await loadDeliveryConfig(row.path)).configDigest, candidateConfiguration.configDigest);
+            assert.equal((await loadDeliveryConfig(root)).configDigest, primaryConfiguration.configDigest);
+            await assert.rejects(call('issue_pr_review', reviewInput), /classification is stale against config/u);
+            assert.equal(personalRoute.submitted, 0);
+            delete process.env[driftEnv];
+        }
+        const first = (await call('issue_pr_review', reviewInput));
         assert.equal(first.reviewState.status, 'still-required');
         assert.equal(first.reviewState.submittedReviewAuthorCanPushToRepository, false);
         assert.equal(personalRoute.submitted, 1);
-        const second = (await executeTool('issue_pr_review', reviewInput, execution));
+        if (transition && entry === 'primary') {
+            process.env[driftEnv] = 'SKIP';
+            assert.notEqual((await loadDeliveryConfig(row.path)).configDigest, candidateConfiguration.configDigest);
+            assert.equal((await loadDeliveryConfig(root)).configDigest, primaryConfiguration.configDigest);
+            await assert.rejects(call('issue_pr_create', { issueNumber: 17, draft: false }), /classification is stale against config/u);
+            assert.equal(personalRoute.readyPromotions, 0);
+            delete process.env[driftEnv];
+            await call('issue_pr_create', { issueNumber: 17, draft: false });
+            assert.equal(personalRoute.readyPromotions, 1);
+        }
+        const second = (await call('issue_pr_review', reviewInput));
         assert.equal(second.receiptId, first.receiptId);
         assert.equal(personalRoute.submitted, 1);
     }
     finally {
+        await closeMcp?.();
         personalRoute.active = false;
+        personalRoute.created = false;
+        personalRoute.failCreate = false;
         personalRoute.reviews.length = 0;
+        personalRoute.ready = false;
+        personalRoute.readyPromotions = 0;
+        if (previousDrift === undefined)
+            delete process.env[driftEnv];
+        else
+            process.env[driftEnv] = previousDrift;
         if (originalPath === undefined)
             delete process.env.PATH;
         else
@@ -1827,6 +2419,96 @@ exec "${realGit}" "$@"
         rmSync(root, { recursive: true, force: true });
     }
 }, 15_000);
+test.each(['runtime', 'primary-policy', 'witness', 'sibling', 'foreign-repository', 'missing-source'])('source-bound dispatch rejects invalid %s before running candidate stages', async (invalid) => {
+    const { root, runtimeEntryPath, counter } = await fixture();
+    let foreignRoot;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        let requestedRoot = root;
+        const expected = {
+            runtime: /source, capability or repository admission/u,
+            'primary-policy': /source, capability or repository admission/u,
+            witness: /ownership witness/u,
+            sibling: /primary or exact registered issue checkout/u,
+            'foreign-repository': /primary Git repository/u,
+            'missing-source': /git rev-parse failed/u,
+        }[invalid];
+        if (invalid === 'runtime')
+            writeFileSync(join(dirname(runtimeEntryPath), 'changed.js'), 'unadmitted');
+        if (invalid === 'primary-policy')
+            writeFileSync(join(root, 'policy.mjs'), `${readFileSync(join(root, 'policy.mjs'), 'utf8')}\n// unadmitted controller policy\n`);
+        if (invalid === 'witness')
+            rmSync(join(root, '.git', 'ai-delivery', 'worktree-owners'), { recursive: true });
+        if (invalid === 'sibling')
+            requestedRoot = (await prepareStandaloneWorktree({
+                name: 'sibling',
+                branch: 'scratch/sibling',
+                identity: 'synthetic-author',
+                repoRoot: root,
+            })).path;
+        if (invalid === 'foreign-repository') {
+            foreignRoot = (await fixture()).root;
+            const foreign = await prepareIssueWorktree({
+                baseRef: 'main',
+                identity: 'synthetic-author',
+                issueNumber: 17,
+                repoRoot: foreignRoot,
+            });
+            await removeWorktreeEntry(row.path, root);
+            await addWorktreeEntry(foreign, root);
+        }
+        if (invalid === 'missing-source')
+            git(root, 'worktree', 'remove', row.path);
+        await assert.rejects(executeTool('issue_verify', { issueNumber: 17 }, { repoRoot: requestedRoot, runtimeEntryPath }), expected);
+        assert.equal(existsSync(counter), false);
+    }
+    finally {
+        if (foreignRoot !== undefined)
+            rmSync(foreignRoot, { recursive: true, force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('source-bound publication preserves rejection of a legacy personal override for an App author', async () => {
+    const { root, runtimeEntryPath } = await fixture();
+    let restore;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const run = await verifyIssue({ issueNumber: 17, repoRoot: row.path });
+        const factory = githubClient.createDeliveryGitHubClients;
+        const selected = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockImplementation(async (input) => {
+            const clients = await factory(input);
+            if (input.role !== 'author')
+                return clients;
+            Object.assign(clients.rest.issues, { get: async () => ({ data: { title: 'Synthetic issue' } }) });
+            Object.assign(clients.rest.git, {
+                getRef: async () => ({ data: { object: { sha: run.classification.base.sha } } }),
+            });
+            return { ...clients, authSource: 'personal', credentialSource: 'legacy:personal' };
+        });
+        restore = () => selected.mockRestore();
+        await assert.rejects(executeTool('issue_pr_create', { issueNumber: 17 }, {
+            repoRoot: root,
+            runtimeEntryPath,
+            identity: 'personal',
+            personalAuth: true,
+        }), /requires the configured author credential/u);
+        assert.equal(git(join(root, '.git', 'remote.git'), 'for-each-ref', '--format=%(refname)', 'refs/heads/issue/17'), '');
+    }
+    finally {
+        restore?.();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 test('scratch start derives safe names and reports the requested worktree', async () => {
     const { root, runtimeEntryPath } = await fixture();
     try {
@@ -1903,7 +2585,7 @@ test('MCP request rejects unsupported legacy options before lifecycle dispatch',
     }
 });
 async function syntheticLifecycle(routing) {
-    const { root } = await fixture(routing);
+    const { root, runtimeEntryPath } = await fixture(routing);
     const remoteName = routing.remote;
     assert.equal(defaultBaseRef(root, remoteName), `refs/remotes/${remoteName}/main`);
     const remote = join(root, '.git', 'remote.git');
@@ -1943,7 +2625,7 @@ async function syntheticLifecycle(routing) {
     let reviewDecision = 'REVIEW_REQUIRED';
     const calls = [];
     const createPayloads = [];
-    const statuses = { Queued: 'todo', Active: 'active', Waiting: 'blocked', Shipped: 'done' };
+    const statuses = { Queued: 'STATUS-0', Active: 'STATUS-1', Waiting: 'STATUS-2', Shipped: 'STATUS-3' };
     const statusName = (option) => Object.entries(statuses).find(([, id]) => id === option)?.[0];
     const pageInfo = { endCursor: null, hasNextPage: false };
     const issueFieldValues = (number = issueNumber) => [
@@ -2264,6 +2946,7 @@ async function syntheticLifecycle(routing) {
             }),
         },
     };
+    let restoreDispatchClient;
     try {
         await assert.rejects(startTrackedIssue(context, { request: 'Unready task', develop: true }), /New issue is not ready/u);
         assert.equal(calls.filter((call) => call === 'issue:create').length, 0);
@@ -2443,7 +3126,19 @@ async function syntheticLifecycle(routing) {
         await assert.rejects(finishIssue(context, { issueNumber, prNumber, strategy: 'merge' }), /Delivery record store is invalid/u);
         assert.equal(existsSync(row.path), false);
         rmSync(blockedRecordPath, { recursive: true });
-        const finished = await finishIssue(context, { issueNumber, prNumber, strategy: 'merge' });
+        const dispatchClient = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockImplementation(async () => ({
+            ...context.clients,
+            graphql: (async (query, variables) => query.includes('DeliveryDiscovery') ||
+                query.includes('DeliveryRepository') ||
+                query.includes('ProjectDeliveryConfiguration')
+                ? syntheticDiscoveryClients().graphql(query, variables)
+                : graphql(query, variables)),
+        }));
+        restoreDispatchClient = () => dispatchClient.mockRestore();
+        const execution = { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' };
+        const terminalMerge = (await executeTool('issue_pr_merge', { issueNumber, prNumber, strategy: 'merge' }, execution));
+        assert.equal(terminalMerge.mergeSha, git(remote, 'rev-parse', 'refs/heads/main'));
+        const finished = (await executeTool('issue_finish', { issueNumber, prNumber, strategy: 'merge' }, execution));
         assert.equal(finished.issueClosed, true);
         assert.equal(finished.cleaned, true);
         assert.equal(projectStatus, 'Shipped');
@@ -2452,7 +3147,9 @@ async function syntheticLifecycle(routing) {
         assert.equal(getDeliveryRecords(root).length, 1);
         assert.equal(getDeliveryRecords(root)[0]?.points, 4);
         assert.deepEqual(calls, ['issue:create', 'review:create', 'git:createCommit']);
-        assert.deepEqual(await finishIssue(context, { issueNumber, prNumber, strategy: 'merge' }), finished);
+        assert.deepEqual(await executeTool('issue_finish', { issueNumber, prNumber, strategy: 'merge' }, execution), finished);
+        await assert.rejects(executeTool('issue_finish', { issueNumber, prNumber: 24 }, execution), /exact terminal merge receipts/u);
+        dispatchClient.mockRestore();
         assert.equal(getDeliveryRecords(root).length, 1);
         await assert.rejects(finishIssue(context, { issueNumber, prNumber: 24 }), /exact terminal merge receipts/u);
         const newlyStarted = await startTrackedIssue(context, { request: 'New synthetic task' });
@@ -2491,6 +3188,7 @@ async function syntheticLifecycle(routing) {
         assert.equal(calls.filter((call) => call === 'issue:create').length, beforeTracking + 1);
     }
     finally {
+        restoreDispatchClient?.();
         rmSync(root, { recursive: true, force: true });
     }
 }