@aviaratech/ai-delivery 0.3.3 → 0.3.5

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';
@@ -13,15 +13,16 @@ import { AI_DELIVERY_MCP_TOOLS } from './mcp/tools.js';
 import { createAiDeliveryMcpServer } from './mcp/index.js';
 import { loadDeliveryConfig, parseDeliveryConfig } from './config/deliveryConfig.js';
 import { digestValue } from './delivery/index.js';
-import { executeTool, resumedIssueUpdate, startTrackedIssue } from './dispatch.js';
+import { contextFor, 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);`)}] }] }`
             : ''}],
@@ -300,7 +329,7 @@ export default {
             mkdirSync(dirname(path), { recursive: true });
         }
         writeFileSync(runtimeEntryPath, 'synthetic CLI bytes\n');
-        writeFileSync(packagePath, JSON.stringify({ name: '@aviaratech/ai-delivery', version: '0.1.0' }));
+        writeFileSync(packagePath, JSON.stringify({ name: '@aviaratech/ai-delivery', version: '0.1.0', bin: { 'ai-delivery': './dist/cli.js' } }));
         writeFileSync(mcpLauncherPath, 'synthetic MCP launcher bytes\n');
         writeFileSync(pluginManifestPath, JSON.stringify({ name: 'ai-delivery', packageVersion: '0.1.0', deliveryCapabilityVersion: 2 }));
         const content = {
@@ -322,7 +351,8 @@ export default {
         };
         const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
         mkdirSync(dirname(admissionPath), { recursive: true });
-        writeFileSync(admissionPath, JSON.stringify({ ...content, admissionId: digestValue(content) }), { mode: 0o600 });
+        if (!options.omitRuntimeAdmission)
+            writeFileSync(admissionPath, JSON.stringify({ ...content, admissionId: digestValue(content) }), { mode: 0o600 });
         return { root, counter, secondCounter, failSecond, runtimeEntryPath };
     }
     catch (error) {
@@ -647,6 +677,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 +1610,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);
@@ -1413,6 +1880,37 @@ test('filesystem output from a sampled detached child crosses its declared root
         rmSync(root, { recursive: true, force: true });
     }
 });
+test('contained npm bin aliases are counted once and target growth still enforces the output bound', async () => {
+    const outside = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-contained-alias-')));
+    const target = join(outside, 'output', 'actual');
+    const { root } = await fixture({
+        firstStageScript: `require('fs').appendFileSync(${JSON.stringify(target)},'x'.repeat(512));`,
+    });
+    try {
+        mkdirSync(dirname(target));
+        writeFileSync(target, 'baseline');
+        symlinkSync('./actual', join(dirname(target), 'alias'));
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const bounds = {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 600,
+            outputRoots: [dirname(target)],
+        };
+        const run = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds });
+        assert.equal(run.resources?.maxSampledNewOutputBytes, 512);
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: { ...bounds, maxNewOutputBytes: 100 } }), /filesystem output.*exceeded/u);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(outside, { recursive: true, force: true });
+    }
+});
 test('a symbolic link in declared output roots fails before publishing sampled output evidence', async () => {
     const { root } = await fixture();
     const outside = mkdtempSync(join(tmpdir(), 'ai-delivery-output-link-'));
@@ -1738,25 +2236,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 +2298,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 +2338,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 +2451,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 {
@@ -1843,8 +2557,228 @@ test('scratch start derives safe names and reports the requested worktree', asyn
         rmSync(root, { recursive: true, force: true });
     }
 });
+test.each(['direct-develop', 'direct-start', 'develop', 'existing-start', 'new-start', 'scratch', 'standalone'])('development access preflight rejects absent reviewer credentials before %s preparation', async (entry) => {
+    const { root, runtimeEntryPath } = await fixture();
+    const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
+    const admissionBefore = readFileSync(admissionPath, 'utf8');
+    const syntheticClients = githubClient.createDeliveryGitHubClients;
+    const actual = await vi.importActual('./github/client.js');
+    const mocked = vi
+        .spyOn(githubClient, 'createDeliveryGitHubClients')
+        .mockImplementation((input) => input.role === 'reviewer' ? actual.createDeliveryGitHubClients({ ...input, env: {} }) : syntheticClients(input));
+    const execution = { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' };
+    const tracking = {
+        title: 'Synthetic change',
+        body: '## Outcome\nDeliver a verified change.\n\n## Scope\n- `artifact.txt`\n\n## Acceptance Criteria\n- [ ] Change is verified\n- [ ] Review is recorded\n\n## Verification\nRun `node --version`.',
+        points: 2,
+        develop: true,
+    };
+    try {
+        const run = async () => {
+            if (entry === 'direct-develop' || entry === 'direct-start') {
+                const context = await contextFor(execution, 'develop');
+                return entry === 'direct-develop' ? developIssue(context, 17) : startTrackedIssue(context, tracking);
+            }
+            if (entry === 'develop')
+                return executeTool('issue_develop', { issueNumber: 17 }, execution);
+            if (entry === 'existing-start')
+                return executeTool('issue_start', { issueNumber: 17 }, execution);
+            if (entry === 'new-start')
+                return executeTool('issue_start', tracking, execution);
+            if (entry === 'scratch')
+                return executeTool('issue_start', { scratch: true, request: 'Inspect parser' }, execution);
+            return executeTool('issue_worktree_create', { name: 'scratch-access', branch: 'scratch/access' }, execution);
+        };
+        await assert.rejects(run(), /Missing GitHub App credentials for reviewer role/u);
+        assert.equal(existsSync(join(root, '.worktrees')), false);
+        assert.equal(existsSync(join(root, '.issue-cli', 'worktrees.json')), false);
+        assert.equal(readFileSync(admissionPath, 'utf8'), admissionBefore);
+    }
+    finally {
+        mocked.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test.each(['author-source', 'author-readback', 'same-actor', 'reviewer-repository'])('development access preflight rejects a mismatched %s route before issue reads or writes', async (failure) => {
+    const { root, runtimeEntryPath } = await fixture({ personalAuthor: true });
+    const syntheticClients = githubClient.createDeliveryGitHubClients;
+    const mocked = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockImplementation(async (input) => {
+        const clients = await syntheticClients(input);
+        if (input.role === 'author' && failure === 'author-source')
+            return { ...clients, authSource: 'app' };
+        if (input.role === 'author' && failure === 'author-readback')
+            return { ...clients, authenticatedAuthor: async () => ({ actorLogin: '', credentialIdentity: '' }) };
+        if (input.role === 'reviewer' && failure === 'same-actor')
+            return { ...clients, appActorLogin: async () => 'host-user' };
+        if (input.role === 'reviewer' && failure === 'reviewer-repository')
+            Object.assign(clients.rest.repos, { get: async () => ({ data: { full_name: 'example/other' } }) });
+        return clients;
+    });
+    try {
+        const context = await contextFor({ repoRoot: root, runtimeEntryPath, identity: 'host-author' }, 'develop');
+        await assert.rejects(developIssue(context, 17), {
+            'author-source': /requires the configured author credential/u,
+            'author-readback': /Author GitHub identity readback is incomplete/u,
+            'same-actor': /same GitHub actor/u,
+            'reviewer-repository': /repository readback disagrees/u,
+        }[failure]);
+        assert.equal(existsSync(join(root, '.worktrees')), false);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'issue-info')), false);
+    }
+    finally {
+        mocked.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('development access preflight permits the configured host author and independent App with unreadable rules', async () => {
+    const { root, runtimeEntryPath } = await fixture({ personalAuthor: true });
+    const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
+    const admissionBefore = readFileSync(admissionPath, 'utf8');
+    try {
+        const row = (await executeTool('issue_worktree_create', { name: 'scratch-host', branch: 'scratch/host' }, { repoRoot: root, runtimeEntryPath, identity: 'host-author' }));
+        assert.equal(row.identity, 'host-author');
+        assert.equal(row.path, join(root, '.worktrees', 'scratch-host'));
+        assert.equal(existsSync(row.path), true);
+        assert.equal(readFileSync(admissionPath, 'utf8'), admissionBefore);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test.each([
+    'direct-develop',
+    'direct-start',
+    'develop',
+    'existing-start',
+    'new-start',
+    'scratch',
+    'standalone',
+    'config-resolve',
+])('development access preflight preserves the explicit personal override for %s', async (entry) => {
+    const { root, runtimeEntryPath } = await fixture();
+    const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
+    const admissionBefore = readFileSync(admissionPath, 'utf8');
+    const factory = githubClient.createDeliveryGitHubClients;
+    const actual = await vi.importActual('./github/client.js');
+    const downstream = new Error('Reached the downstream issue API with the selected author');
+    const selected = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockImplementation(async (input) => {
+        const clients = await factory(input);
+        if (input.role !== 'author' || input.personalAuth === undefined)
+            return clients;
+        const personal = await actual.createDeliveryGitHubClients({
+            ...input,
+            env: { GH_TOKEN: 'synthetic-development-token' },
+        });
+        Object.assign(clients.rest.issues, {
+            get: async () => {
+                throw downstream;
+            },
+            create: async () => {
+                throw downstream;
+            },
+        });
+        Object.assign(clients.rest, { request: async () => Promise.reject(new Error('Rules unavailable')) });
+        return {
+            ...personal,
+            graphql: clients.graphql,
+            rest: clients.rest,
+            authenticatedAuthor: async () => ({ actorLogin: 'host-user', credentialIdentity: 'user:37' }),
+        };
+    });
+    const execution = { repoRoot: root, runtimeEntryPath, identity: 'personal', personalAuth: true };
+    const tracking = {
+        title: 'Synthetic change',
+        body: '## Outcome\nDeliver a verified change.\n\n## Scope\n- `artifact.txt`\n\n## Acceptance Criteria\n- [ ] Change is verified\n- [ ] Review is recorded\n\n## Verification\nRun `node --version`.',
+        points: 2,
+        develop: true,
+    };
+    try {
+        if (entry === 'config-resolve') {
+            // The prescribed CLI read must inspect this development selection without admission.
+            rmSync(admissionPath);
+            const originalArgv = process.argv;
+            const originalExitCode = process.exitCode;
+            let stdout = '';
+            let stderr = '';
+            let completed = () => { };
+            const output = new Promise((resolve) => {
+                completed = resolve;
+            });
+            const out = vi.spyOn(process.stdout, 'write').mockImplementation((value) => {
+                stdout += String(value);
+                completed();
+                return true;
+            });
+            const err = vi.spyOn(process.stderr, 'write').mockImplementation((value) => {
+                stderr += String(value);
+                completed();
+                return true;
+            });
+            try {
+                process.argv = [
+                    process.execPath,
+                    'ai-delivery',
+                    '--repo-root',
+                    root,
+                    '--identity',
+                    'personal',
+                    '--personal-auth',
+                    'config:resolve',
+                ];
+                await import('./cli.js');
+                await output;
+                assert.equal(stderr, '');
+                const resolved = JSON.parse(stdout);
+                assert.equal(resolved.reviewRoute.author.identity, 'personal');
+                assert.equal(resolved.reviewRoute.author.authSource, 'personal');
+                assert.equal(resolved.reviewRoute.author.actorLogin, 'host-user');
+                assert.equal(resolved.reviewRoute.approvalEligibility, 'unknown');
+                assert.equal(resolved.reviewRoute.rules.visibility, 'unknown');
+                assert.equal(existsSync(admissionPath), false);
+                assert.equal(existsSync(join(root, '.worktrees')), false);
+            }
+            finally {
+                out.mockRestore();
+                err.mockRestore();
+                process.argv = originalArgv;
+                process.exitCode = originalExitCode;
+            }
+        }
+        else if (entry === 'scratch' || entry === 'standalone') {
+            const row = (entry === 'scratch'
+                ? await executeTool('issue_start', { scratch: true, request: 'Inspect parser' }, execution)
+                : await executeTool('issue_worktree_create', { name: 'scratch-override', branch: 'scratch/override' }, execution));
+            if (entry === 'standalone')
+                assert.equal(row.identity, 'personal');
+            assert.equal(existsSync(entry === 'scratch' ? row.worktreePath : row.path), true);
+        }
+        else {
+            const run = async () => {
+                if (entry === 'direct-develop' || entry === 'direct-start') {
+                    const context = await contextFor(execution, 'develop');
+                    return entry === 'direct-develop' ? developIssue(context, 17) : startTrackedIssue(context, tracking);
+                }
+                if (entry === 'develop')
+                    return executeTool('issue_develop', { issueNumber: 17 }, execution);
+                if (entry === 'existing-start')
+                    return executeTool('issue_start', { issueNumber: 17 }, execution);
+                return executeTool('issue_start', tracking, execution);
+            };
+            await assert.rejects(run(), (error) => error === downstream);
+            assert.equal(existsSync(join(root, '.worktrees')), false);
+        }
+        if (entry !== 'config-resolve')
+            assert.equal(readFileSync(admissionPath, 'utf8'), admissionBefore);
+    }
+    finally {
+        selected.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 test('MCP exposes one implementation surface for native lifecycle commands', () => {
     assert.deepEqual(AI_DELIVERY_MCP_TOOLS.map((tool) => tool.name), [
+        'runtime_stage',
+        'runtime_admit',
         'issue_create',
         'issue_start',
         'issue_update',
@@ -1903,7 +2837,11 @@ test('MCP request rejects unsupported legacy options before lifecycle dispatch',
     }
 });
 async function syntheticLifecycle(routing) {
-    const { root } = await fixture(routing);
+    const created = await fixture({ ...routing, omitRuntimeAdmission: routing.producerOnboarding === true });
+    const root = created.root;
+    let runtimeEntryPath = created.runtimeEntryPath;
+    const originalPath = process.env.PATH;
+    let restoreTransport;
     const remoteName = routing.remote;
     assert.equal(defaultBaseRef(root, remoteName), `refs/remotes/${remoteName}/main`);
     const remote = join(root, '.git', 'remote.git');
@@ -1943,7 +2881,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,7 +3202,67 @@ async function syntheticLifecycle(routing) {
             }),
         },
     };
+    let restoreDispatchClient;
     try {
+        if (routing.producerOnboarding) {
+            assert.equal(existsSync(join(root, 'AGENTS.md')), false);
+            const archiveBase = join(root, '.git', 'producer-fixture');
+            const packageSource = join(archiveBase, 'package');
+            mkdirSync(archiveBase);
+            cpSync(dirname(dirname(created.runtimeEntryPath)), packageSource, { recursive: true });
+            cpSync(join(root, '.git/synthetic-runtime/plugin'), join(packageSource, 'plugins/ai-delivery'), {
+                recursive: true,
+            });
+            const archive = join(archiveBase, 'reviewed.tgz');
+            execFileSync('tar', ['-czf', archive, '-C', archiveBase, 'package']);
+            const shimDir = join(archiveBase, 'bin');
+            mkdirSync(shimDir);
+            const npmShim = join(shimDir, 'npm');
+            // Only installer and GitHub transports are synthetic; the public producer and validator are real.
+            writeFileSync(npmShim, `#!${process.execPath}\nconst fs=require('fs'),path=require('path');const args=process.argv.slice(2);if(args[0]!=='install'||!['--omit=dev','--ignore-scripts','--no-audit','--no-fund'].every(x=>args.includes(x)))process.exit(91);const target=path.join(args[args.indexOf('--prefix')+1],'node_modules/@aviaratech/ai-delivery');fs.mkdirSync(path.dirname(target),{recursive:true});fs.cpSync(${JSON.stringify(packageSource)},target,{recursive:true});\n`);
+            chmodSync(npmShim, 0o700);
+            process.env.PATH = `${shimDir}:${originalPath ?? ''}`;
+            const server = createAiDeliveryMcpServer({ repoRoot: root, identity: 'synthetic-author' });
+            const client = new Client({ name: 'unrelated-public-onboarding', version: '1.0.0' });
+            const [ct, st] = InMemoryTransport.createLinkedPair();
+            await server.connect(st);
+            await client.connect(ct);
+            const setup = {
+                expectedSourceCommit: baseSha,
+                expectedConfigDigest: configuration.configDigest,
+                runtimeDirectory: join(root, '.git', 'public-runtime-stage'),
+            };
+            try {
+                const stageResponse = await client.callTool({
+                    name: 'runtime_stage',
+                    arguments: {
+                        ...setup,
+                        authority: 'runtime:stage',
+                        archivePath: archive,
+                        expectedArchiveSha256: sha256(archive),
+                        packageVersion: '0.1.0',
+                    },
+                });
+                assert.equal(stageResponse.isError, undefined);
+                const stage = JSON.parse(stageResponse.content[0].text);
+                const admitted = await client.callTool({
+                    name: 'runtime_admit',
+                    arguments: {
+                        ...setup,
+                        authority: 'runtime:admit',
+                        stageId: stage.stageId,
+                        expectedPriorAdmissionSha256: null,
+                    },
+                });
+                assert.equal(admitted.isError, undefined);
+                runtimeEntryPath = stage.admission.cliPath;
+            }
+            finally {
+                await client.close();
+                await server.close();
+            }
+            await assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath });
+        }
         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);
         const unsized = await createIssue(context, { title: 'Synthetic child', parentIssueNumber: 11 });
@@ -2336,30 +3334,66 @@ async function syntheticLifecycle(routing) {
         headSha = git(row.path, 'rev-parse', 'HEAD');
         const run = await verifyIssue({ issueNumber, repoRoot: row.path });
         await assert.rejects(publishPr(context, { issueNumber, body: 'Closes #17' }), /Delivery Impact/);
-        await assert.rejects(publishPr(context, { issueNumber }), /Git push requires the selected author credential token/);
-        // The public push requires a real author App installation token. Bind a synthetic
-        // publication at that external boundary so the remaining public phases run offline.
-        git(row.path, 'push', '-q', remoteName, `${headSha}:refs/heads/issue/17`);
-        const publishEvidence = await createIssuePhaseEvidence({ issueNumber, phase: 'publish', repoRoot: row.path });
-        const publicationContent = {
-            baseSha,
-            evidenceId: publishEvidence.evidenceId,
-            headSha,
-            issueNumber,
-            prNumber,
-            schemaVersion: 'ai-delivery.publication@1',
-        };
-        const publicationPath = join(gitCommonDir(row.path), 'ai-delivery', 'publications', String(issueNumber), `${headSha}.json`);
-        mkdirSync(dirname(publicationPath), { recursive: true });
-        writeFileSync(publicationPath, JSON.stringify({ ...publicationContent, publicationId: digestValue(publicationContent) }), { mode: 0o600 });
-        await updateIssueWorktreeDelivery({
-            branch: row.branch,
-            issueNumber,
-            path: row.path,
-            prNumber,
-            projectRoot: root,
-            status: 'pr-published',
-        });
+        if (routing.producerOnboarding) {
+            const realGit = execFileSync('/usr/bin/which', ['git'], {
+                encoding: 'utf8',
+                env: { ...process.env, PATH: originalPath },
+            }).trim();
+            const shimDir = join(root, '.git/producer-fixture/bin');
+            git(root, 'config', '--unset', `url.${remote}.insteadOf`);
+            const gitShim = join(shimDir, 'git');
+            writeFileSync(gitShim, `#!/bin/sh
+if [ "$1" = -c ] && [ "$2" = credential.helper= ]; then
+  [ "$AI_DELIVERY_GIT_TOKEN" = synthetic-selected-author-token ] || exit 92
+  shift 2
+  operation="$1"; shift
+  [ "$1" = https://github.com/example/widget.git ] || exit 93
+  shift
+  exec "${realGit}" -c credential.helper= "$operation" "${remote}" "$@"
+fi
+if [ "$1" = push ] && [ "$2" = -q ] && [ "$3" = "${remoteName}" ]; then
+  shift 3
+  exec "${realGit}" push -q "${remote}" "$@"
+fi
+exec "${realGit}" "$@"
+`);
+            chmodSync(gitShim, 0o700);
+            const transport = vi.spyOn(githubClient, 'withAuthorGitToken').mockImplementation(async (clients, callback) => {
+                assert.equal(clients.role, 'author');
+                return callback('synthetic-selected-author-token');
+            });
+            restoreTransport = () => transport.mockRestore();
+            const published = await publishPr(context, { issueNumber });
+            assert.equal(published.prNumber, prNumber);
+            assert.equal(published.reviewRoute?.author.actorLogin, 'synthetic-author[bot]');
+            assert.equal(published.reviewRoute?.approvalEligibility, 'unknown');
+        }
+        else {
+            await assert.rejects(publishPr(context, { issueNumber }), /Git push requires the selected author credential token/);
+            // The public push requires a real author App installation token. Bind a synthetic
+            // publication at that external boundary so the remaining public phases run offline.
+            git(row.path, 'push', '-q', remoteName, `${headSha}:refs/heads/issue/17`);
+            const publishEvidence = await createIssuePhaseEvidence({ issueNumber, phase: 'publish', repoRoot: row.path });
+            const publicationContent = {
+                baseSha,
+                evidenceId: publishEvidence.evidenceId,
+                headSha,
+                issueNumber,
+                prNumber,
+                schemaVersion: 'ai-delivery.publication@1',
+            };
+            const publicationPath = join(gitCommonDir(row.path), 'ai-delivery', 'publications', String(issueNumber), `${headSha}.json`);
+            mkdirSync(dirname(publicationPath), { recursive: true });
+            writeFileSync(publicationPath, JSON.stringify({ ...publicationContent, publicationId: digestValue(publicationContent) }), { mode: 0o600 });
+            await updateIssueWorktreeDelivery({
+                branch: row.branch,
+                issueNumber,
+                path: row.path,
+                prNumber,
+                projectRoot: root,
+                status: 'pr-published',
+            });
+        }
         assert.equal((await listPrs(context)).pullRequests[0]?.number, prNumber);
         assert.equal((await prInfo(context, { prNumber })).authorLogin, 'synthetic-author[bot]');
         assert.equal((await prChecks(context, prNumber)).combinedStatus, 'success');
@@ -2443,7 +3477,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 +3498,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 +3539,9 @@ async function syntheticLifecycle(routing) {
         assert.equal(calls.filter((call) => call === 'issue:create').length, beforeTracking + 1);
     }
     finally {
+        restoreTransport?.();
+        process.env.PATH = originalPath;
+        restoreDispatchClient?.();
         rmSync(root, { recursive: true, force: true });
     }
 }
@@ -2499,4 +3550,46 @@ test.each([
     { remote: 'upstream', divergentOrigin: false },
     { remote: 'upstream', divergentOrigin: true },
 ])('synthetic lifecycle finishes with remote $remote and divergent origin $divergentOrigin', syntheticLifecycle, 15_000);
+test('an unrelated consumer uses public MCP setup through verified configured-author publication, counted review readback, merge and cleanup', async () => {
+    await syntheticLifecycle({ remote: 'origin', divergentOrigin: false, producerOnboarding: true });
+}, 15_000);
+test.each(['escape', 'broken', 'cycle'])('output observation rejects %s aliases without running policy commands', async (kind) => {
+    const { root, counter } = await fixture();
+    const base = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-output-alias-')));
+    try {
+        const output = join(base, 'output');
+        mkdirSync(output);
+        if (kind === 'escape') {
+            writeFileSync(join(base, 'outside'), 'outside');
+            symlinkSync('../outside', join(output, 'alias'));
+        }
+        if (kind === 'broken')
+            symlinkSync('./absent', join(output, 'alias'));
+        if (kind === 'cycle') {
+            symlinkSync('./other', join(output, 'alias'));
+            symlinkSync('./alias', join(output, 'other'));
+        }
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 1024,
+                outputRoots: [output],
+            },
+        }), /escaping|broken|cyclic/u);
+        assert.equal(existsSync(counter), false);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(base, { recursive: true, force: true });
+    }
+});
 //# sourceMappingURL=lifecycle.test.js.map