@aviaratech/ai-delivery 0.1.0 → 0.2.1

package/dist/lifecycle.test.js

@@ -1,18 +1,21 @@
 import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, readdirSync, realpathSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { test } from 'vitest';
+import { test, vi } from 'vitest';
+import { syntheticDiscoveryClients, syntheticOverrides } from './fixtures/discovery.js';
+import { Octokit } from '@octokit/rest';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
 import { AI_DELIVERY_MCP_TOOLS } from './mcp/tools.js';
 import { createAiDeliveryMcpServer } from './mcp/index.js';
-import { loadDeliveryConfig } from './config/deliveryConfig.js';
+import { loadDeliveryConfig, parseDeliveryConfig } from './config/deliveryConfig.js';
 import { digestValue } from './delivery/index.js';
 import { executeTool, resumedIssueUpdate, startTrackedIssue } from './dispatch.js';
-import { gitCommonDir } from './git.js';
+import { defaultBaseRef, gitCommonDir } from './git.js';
+import * as githubClient from './github/client.js';
 import { createIssue, developIssue, listIssueSubissues, readyCheck, resumeCreatedIssue, updateIssue, } from './issue.js';
 import { checkoutPr, finishIssue, listPrs, mergePr, prChecks, publishPr, submitFormalReview } from './pr.js';
 import { updateIssueWorktreeDelivery } from './services/worktreeRegistry.js';
@@ -20,6 +23,24 @@ import { assertDeliveryRuntimeAdmitted } from './services/deliveryAdmission.js';
 import { getDeliveryRecords } from './services/deliveryRecordService.js';
 import { createIssuePhaseEvidence, verifyIssue } from './verification.js';
 import { cleanupNonIssueWorktree, prepareIssueWorktree, preparePrWorktree, prepareStandaloneWorktree, } from './worktree.js';
+vi.mock('./github/client.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        createDeliveryGitHubClients: async (input) => ({
+            ...syntheticDiscoveryClients(),
+            authSource: 'app',
+            role: input.role,
+            rest: new Octokit({
+                request: {
+                    fetch: async () => {
+                        throw new Error('Unexpected network request in synthetic lifecycle test.');
+                    },
+                },
+            }),
+        }),
+    };
+});
 function git(root, ...args) {
     return execFileSync('git', args, { cwd: root, encoding: 'utf8' }).trim();
 }
@@ -43,8 +64,9 @@ function directoryHash(path) {
     visit(path, '');
     return digestValue(entries);
 }
-function fixture(options = {}) {
+async function fixture(options = {}) {
     const root = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-lifecycle-')));
+    const remoteName = options.remote ?? 'origin';
     const counter = join(root, '.git', 'stage-count.txt');
     const secondCounter = join(root, '.git', 'second-stage-count.txt');
     const failSecond = join(root, '.git', 'fail-second-stage');
@@ -53,7 +75,7 @@ function fixture(options = {}) {
         git(root, 'config', 'user.name', 'Synthetic Delivery');
         git(root, 'config', 'user.email', 'delivery@example.test');
         git(root, 'init', '--bare', '-q', join(root, '.git', 'remote.git'));
-        git(root, 'remote', 'add', 'origin', join(root, '.git', 'remote.git'));
+        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');
         const config = {
@@ -95,9 +117,9 @@ function fixture(options = {}) {
                     identity: 'synthetic-reviewer',
                 },
             },
-            schemaVersion: 'ai-delivery.config@1',
+            schemaVersion: 'ai-delivery.config@2',
         };
-        writeFileSync(join(root, 'ai-delivery.config.json'), `${JSON.stringify(config)}\n`);
+        writeFileSync(join(root, 'ai-delivery.config.json'), `${JSON.stringify({ ...syntheticOverrides(parseDeliveryConfig(config)), ...(options.divergentOrigin ? { remote: remoteName } : {}) })}\n`);
         writeFileSync(join(root, 'policy.mjs'), `
 import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
@@ -109,6 +131,7 @@ const stable = value => Array.isArray(value) ? '[' + value.map(stable).join(',')
 const digest = value => 'sha256:' + createHash('sha256').update(stable(value)).digest('hex');
 const bytes = value => 'sha256:' + createHash('sha256').update(value).digest('hex');
 const policyDigest = bytes(readFileSync(fileURLToPath(import.meta.url)));
+export const deliverySettings = ${JSON.stringify({ roles: config.roles, commandPolicy: config.commandPolicy })};
 export default {
   schemaVersion: 'RepositoryDeliveryPolicy@1',
   classifyExactRange(input) {
@@ -121,7 +144,7 @@ export default {
     return { policyDigest, policyEvidence: { ...content, evidenceId: digest(content) },
       requiredStages: [{ id: 'check', dependsOn: [], semanticInputKeys: ['source'],
         resourceClass: 'source_only', commands: [{ label: 'count', argv: [process.execPath, '-e',
-          ${JSON.stringify(`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
+          ${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'],
         resourceClass: 'source_only', commands: [{ label: 'retry', argv: [process.execPath, '-e',
           ${JSON.stringify(`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);`)}] }] }`
@@ -140,8 +163,16 @@ export default {
 `);
         git(root, 'add', '.');
         git(root, 'commit', '-qm', 'synthetic base');
-        git(root, 'push', '-q', 'origin', 'main');
-        git(root, 'fetch', '-q', 'origin', 'main');
+        git(root, 'push', '-q', remoteName, 'main');
+        git(root, 'fetch', '-q', remoteName, 'main');
+        git(root, 'config', `url.${join(root, '.git', 'remote.git')}.insteadOf`, 'https://github.com/example/widget.git');
+        git(root, 'remote', 'set-url', remoteName, 'https://github.com/example/widget.git');
+        if (options.divergentOrigin) {
+            git(root, 'remote', 'add', 'origin', 'https://github.com/other/unrelated.git');
+            const unrelated = git(root, 'commit-tree', 'HEAD^{tree}', '-m', 'Unrelated origin root');
+            git(root, 'update-ref', 'refs/remotes/origin/main', unrelated);
+            git(root, 'symbolic-ref', 'refs/remotes/origin/HEAD', 'refs/remotes/origin/main');
+        }
         const runtimeRoot = join(root, '.git', 'synthetic-runtime');
         const runtimeEntryPath = join(runtimeRoot, 'package', 'dist', 'cli.js');
         const packagePath = join(runtimeRoot, 'package', 'package.json');
@@ -153,12 +184,12 @@ export default {
         writeFileSync(runtimeEntryPath, 'synthetic CLI bytes\n');
         writeFileSync(packagePath, JSON.stringify({ name: '@aviaratech/ai-delivery', version: '0.1.0' }));
         writeFileSync(mcpLauncherPath, 'synthetic MCP launcher bytes\n');
-        writeFileSync(pluginManifestPath, JSON.stringify({ name: 'ai-delivery', packageVersion: '0.1.0', deliveryCapabilityVersion: 1 }));
+        writeFileSync(pluginManifestPath, JSON.stringify({ name: 'ai-delivery', packageVersion: '0.1.0', deliveryCapabilityVersion: 2 }));
         const content = {
-            capability: { cli: 1, mcp: 1 },
+            capability: { cli: 2, mcp: 2 },
             cliPath: runtimeEntryPath,
             cliSha256: sha256(runtimeEntryPath),
-            configDigest: loadDeliveryConfig(root).configDigest,
+            configDigest: (await loadDeliveryConfig(root)).configDigest,
             mcpLauncherPath,
             mcpLauncherSha256: sha256(mcpLauncherPath),
             packageVersion: '0.1.0',
@@ -167,7 +198,7 @@ export default {
             pluginManifestPath,
             pluginManifestSha256: sha256(pluginManifestPath),
             repository: 'example/widget',
-            schemaVersion: 'ai-delivery.runtime-admission@1',
+            schemaVersion: 'ai-delivery.runtime-admission@2',
             sourceArchiveSha256: digestValue('synthetic archive'),
             sourceCommit: git(root, 'rev-parse', 'HEAD'),
         };
@@ -182,15 +213,15 @@ export default {
     }
 }
 test('installed CLI and MCP admission fails before a worktree mutation on source or capability drift', async () => {
-    const { root, runtimeEntryPath } = fixture();
+    const { root, runtimeEntryPath } = await fixture();
     try {
-        const input = { repoRoot: root, runtimeEntryPath };
+        const input = { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' };
         const path = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
         const original = readFileSync(path, 'utf8');
-        assert.equal(assertDeliveryRuntimeAdmitted(input).capability.mcp, 1);
+        assert.equal((await assertDeliveryRuntimeAdmitted(input)).capability.mcp, 2);
         const changedModule = join(dirname(runtimeEntryPath), 'mutated.js');
         writeFileSync(changedModule, 'unadmitted module bytes\n');
-        assert.throws(() => assertDeliveryRuntimeAdmitted(input), /source, capability or repository admission/u);
+        await assert.rejects(assertDeliveryRuntimeAdmitted(input), /source, capability or repository admission/u);
         rmSync(changedModule);
         rmSync(path);
         await assert.rejects(executeTool('issue_worktree_create', { name: 'scratch-admission', branch: 'scratch/admission' }, input), /runtime admission/u);
@@ -204,14 +235,122 @@ test('installed CLI and MCP admission fails before a worktree mutation on source
         const { admissionId: _old, ...content } = admission;
         const mismatched = { ...content, mcpLauncherSha256: sha256(launcherPath), capability: { cli: 1, mcp: 2 } };
         writeFileSync(path, JSON.stringify({ ...mismatched, admissionId: digestValue(mismatched) }));
-        assert.throws(() => assertDeliveryRuntimeAdmitted(input), /source, capability or repository admission/u);
+        await assert.rejects(assertDeliveryRuntimeAdmitted(input), /source, capability or repository admission/u);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('effective policy settings drift invalidates admission even when the policy wrapper is unchanged', async () => {
+    const { root, runtimeEntryPath } = await fixture();
+    const policyPath = join(root, 'policy.mjs');
+    const authorEnv = 'AI_DELIVERY_TEST_DYNAMIC_AUTHOR';
+    const checkEnv = 'AI_DELIVERY_TEST_DYNAMIC_CHECK';
+    const previousAuthor = process.env[authorEnv];
+    const previousCheck = process.env[checkEnv];
+    try {
+        delete process.env[authorEnv];
+        delete process.env[checkEnv];
+        writeFileSync(policyPath, readFileSync(policyPath, 'utf8') +
+            `
+Object.defineProperty(deliverySettings.roles.author, 'identity', { get: () => process.env.${authorEnv} ?? 'synthetic-author' });
+Object.defineProperty(deliverySettings.commandPolicy.checks, 'test', { get: () => process.env.${checkEnv} ?? 'REQUIRED' });
+`);
+        const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
+        const { admissionId: _id, ...content } = JSON.parse(readFileSync(admissionPath, 'utf8'));
+        const baseline = await loadDeliveryConfig(root);
+        const admitted = { ...content, configDigest: baseline.configDigest };
+        writeFileSync(admissionPath, JSON.stringify({ ...admitted, admissionId: digestValue(admitted) }));
+        await assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath });
+        const originalBytes = readFileSync(policyPath, 'utf8');
+        for (const [key, value] of [
+            [authorEnv, 'changed-author'],
+            [checkEnv, 'SKIP'],
+        ]) {
+            process.env[key] = value;
+            assert.notEqual((await loadDeliveryConfig(root)).configDigest, baseline.configDigest);
+            await assert.rejects(assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath }), /source, capability or repository admission/u);
+            delete process.env[key];
+        }
+        assert.equal(readFileSync(policyPath, 'utf8'), originalBytes);
+    }
+    finally {
+        if (previousAuthor === undefined)
+            delete process.env[authorEnv];
+        else
+            process.env[authorEnv] = previousAuthor;
+        if (previousCheck === undefined)
+            delete process.env[checkEnv];
+        else
+            process.env[checkEnv] = previousCheck;
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('a changed discovered Project identity invalidates the installed admission', async () => {
+    const { root, runtimeEntryPath } = await fixture();
+    const base = syntheticDiscoveryClients();
+    const graphql = async (query, variables) => {
+        const result = await base.graphql(query, variables);
+        if (query.includes('query ProjectDeliveryConfiguration')) {
+            result.organization.projectV2.id = 'REPLACED-PROJECT';
+        }
+        return result;
+    };
+    const mocked = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockResolvedValueOnce({
+        authSource: 'app',
+        role: 'author',
+        rest: new Octokit(),
+        graphql: graphql,
+    });
+    try {
+        await assert.rejects(assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath }), /source, capability or repository admission/u);
+        assert.equal(existsSync(join(root, '.worktrees')), false);
+    }
+    finally {
+        mocked.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('CLI dispatch and MCP reject ambiguous discovery with the same error before mutation', async () => {
+    const { root, runtimeEntryPath } = await fixture();
+    const path = join(root, 'ai-delivery.config.json');
+    const overrides = JSON.parse(readFileSync(path, 'utf8'));
+    delete overrides.project;
+    writeFileSync(path, JSON.stringify(overrides));
+    const base = syntheticDiscoveryClients();
+    const graphql = async (query, variables) => {
+        if (query.includes('projectsV2(first:'))
+            return { repository: { projectsV2: { nodes: [], pageInfo: { hasNextPage: false, endCursor: null } } } };
+        return base.graphql(query, variables);
+    };
+    const mocked = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockResolvedValue({
+        authSource: 'app',
+        role: 'author',
+        rest: new Octokit(),
+        graphql: graphql,
+    });
+    const execution = { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' };
+    const server = createAiDeliveryMcpServer(execution);
+    const client = new Client({ name: 'synthetic-discovery-client', version: '1.0.0' });
+    try {
+        await assert.rejects(executeTool('issue_create', { title: 'Ambiguous destination' }, execution), /Discovered 0 compatible linked Projects/u);
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        await server.connect(serverTransport);
+        await client.connect(clientTransport);
+        const result = await client.callTool({ name: 'issue_create', arguments: { title: 'Ambiguous destination' } });
+        assert.equal(result.isError, true);
+        assert.match(JSON.stringify(result.content), /Discovered 0 compatible linked Projects/u);
+        assert.equal(existsSync(join(root, '.worktrees')), false);
     }
     finally {
+        await client.close();
+        await server.close();
+        mocked.mockRestore();
         rmSync(root, { recursive: true, force: true });
     }
 });
 test('an old active issue remains pinned while a new row uses the same canonical registry', async () => {
-    const { root } = fixture();
+    const { root } = await fixture();
     try {
         const oldPath = join(root, '.worktrees', 'issue-17');
         git(root, 'worktree', 'add', '-b', 'issue/17', oldPath, 'main');
@@ -244,7 +383,7 @@ test('an old active issue remains pinned while a new row uses the same canonical
         const relationshipContext = {
             root,
             repo: { owner: 'example', repo: 'widget' },
-            config: loadDeliveryConfig(root).config,
+            config: (await loadDeliveryConfig(root)).config,
             clients: {
                 rest: {
                     issues: {
@@ -289,7 +428,7 @@ test('an old active issue remains pinned while a new row uses the same canonical
     }
 });
 test('synthetic cutover restores exact pre-write state and resumes an incomplete verification stage', async () => {
-    const { root, counter, secondCounter, failSecond } = fixture({ twoStages: true });
+    const { root, counter, secondCounter, failSecond } = await fixture({ twoStages: true });
     const backup = mkdtempSync(join(tmpdir(), 'ai-delivery-cutover-backup-'));
     try {
         const row = await prepareIssueWorktree({
@@ -313,19 +452,19 @@ test('synthetic cutover restores exact pre-write state and resumes an incomplete
         const evidenceBefore = directoryHash(evidencePath);
         const pointerBefore = readlinkSync(current);
         const currentCli = join(current, 'package', 'dist', 'cli.js');
-        assert.equal(assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath: currentCli }).capability.cli, 1);
+        assert.equal((await assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath: currentCli })).capability.cli, 2);
         cpSync(oldRelease, newRelease, { recursive: true });
         writeFileSync(join(newRelease, 'package', 'dist', 'cli.js'), 'unadmitted CLI bytes\n');
         unlinkSync(current);
         symlinkSync(newRelease, current);
-        await assert.rejects(executeTool('issue_worktree_create', { branch: 'scratch/cutover', name: 'scratch-cutover' }, { repoRoot: root, runtimeEntryPath: currentCli }), /source, capability or repository admission/u);
+        await assert.rejects(executeTool('issue_worktree_create', { branch: 'scratch/cutover', name: 'scratch-cutover' }, { repoRoot: root, runtimeEntryPath: currentCli, identity: 'synthetic-author' }), /source, capability or repository admission/u);
         assert.equal(existsSync(join(root, '.worktrees', 'scratch-cutover')), false);
         assert.equal(directoryHash(registryPath), registryBefore);
         assert.equal(directoryHash(evidencePath), evidenceBefore);
         unlinkSync(current);
         symlinkSync(pointerBefore, current);
         assert.equal(readlinkSync(current), pointerBefore);
-        assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath: currentCli });
+        await assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath: currentCli });
         const uninterrupted = await verifyIssue({ issueNumber: 17, repoRoot: row.path });
         assert.equal(readFileSync(counter, 'utf8'), '1');
         assert.equal(readFileSync(secondCounter, 'utf8'), '1');
@@ -386,7 +525,7 @@ test('synthetic cutover restores exact pre-write state and resumes an incomplete
     }
 });
 test('issue worktree verification resumes a completed stage and rejects changed inputs', async () => {
-    const { root, counter, runtimeEntryPath } = fixture();
+    const { root, counter, runtimeEntryPath } = await fixture();
     try {
         await assert.rejects(executeTool('issue_create', { title: 'Wrong repository', repo: 'other/widget' }, { repoRoot: root }), /Repository selector must match/u);
         const row = await prepareIssueWorktree({
@@ -468,8 +607,242 @@ test('issue worktree verification resumes a completed stage and rejects changed
         rmSync(root, { recursive: true, force: true });
     }
 });
+test('a progressing stage remains observable beyond a former short deadline', async () => {
+    const marker = join(tmpdir(), `ai-delivery-stage-start-${process.pid}-${Date.now()}`);
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');fs.writeFileSync(${JSON.stringify(marker)},'started');process.stdout.write('begin');setTimeout(()=>{process.stdout.write('end');},180);`,
+    });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'feature\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic progressing stage');
+        const progressSpy = vi.spyOn(process.stderr, 'write');
+        let completed = false;
+        const run = verifyIssue({ issueNumber: 17, repoRoot: row.path }).then((value) => {
+            completed = true;
+            return value;
+        });
+        const markerDeadline = Date.now() + 2_000;
+        while (!existsSync(marker) && Date.now() < markerDeadline)
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        assert.equal(existsSync(marker), true);
+        assert.equal(completed, false, 'stage must remain observable while its process runs');
+        assert.ok(progressSpy.mock.calls.some(([chunk]) => String(chunk).includes('"state":"running"') && String(chunk).includes('"stageId":"check"')));
+        await new Promise((resolve) => setTimeout(resolve, 40));
+        assert.equal(completed, false, 'useful work continues beyond the injected former deadline');
+        const result = await run;
+        assert.equal(result.stageReceipts.length, 1);
+    }
+    finally {
+        vi.restoreAllMocks();
+        rmSync(marker, { force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('cancelling verification stops its owned descendant and preserves an unrelated process', async () => {
+    const marker = join(tmpdir(), `ai-delivery-stage-child-${process.pid}-${Date.now()}`);
+    const heartbeat = `${marker}-heartbeat`;
+    const unrelatedHeartbeat = `${marker}-unrelated`;
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');const {spawn}=require('child_process');const child=spawn(process.execPath,['-e',${JSON.stringify(`const fs=require('fs');setInterval(()=>fs.appendFileSync(${JSON.stringify(heartbeat)},'x'),20);`)}],{stdio:'ignore'});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));setTimeout(()=>{},400);`,
+    });
+    let descendantPid;
+    const unrelated = spawn(process.execPath, ['-e', `const fs=require('fs');setInterval(()=>fs.appendFileSync(${JSON.stringify(unrelatedHeartbeat)},'x'),20);`], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    unrelated.unref();
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'feature\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic cancellable stage');
+        const controller = new AbortController();
+        const run = verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            signal: controller.signal,
+        });
+        const markerDeadline = Date.now() + 2_000;
+        while (!existsSync(marker) && Date.now() < markerDeadline)
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        assert.equal(existsSync(marker), true);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        controller.abort();
+        await assert.rejects(run, /cancelled/u);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+        await new Promise((resolve) => setTimeout(resolve, 60));
+        const stoppedSize = existsSync(heartbeat) ? readFileSync(heartbeat).length : 0;
+        const unrelatedSize = existsSync(unrelatedHeartbeat) ? readFileSync(unrelatedHeartbeat).length : 0;
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        assert.equal(existsSync(heartbeat) ? readFileSync(heartbeat).length : 0, stoppedSize);
+        assert.ok(readFileSync(unrelatedHeartbeat).length > unrelatedSize);
+    }
+    finally {
+        if (descendantPid !== undefined) {
+            try {
+                process.kill(descendantPid, 'SIGKILL');
+            }
+            catch {
+                /* already stopped */
+            }
+        }
+        if (unrelated.pid !== undefined) {
+            try {
+                process.kill(unrelated.pid, 'SIGKILL');
+            }
+            catch {
+                /* already stopped */
+            }
+        }
+        rmSync(marker, { force: true });
+        rmSync(heartbeat, { force: true });
+        rmSync(unrelatedHeartbeat, { force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test.each([
+    { name: 'nonzero exit', terminate: 'process.exit(7)', expected: /exit 7/u },
+    { name: 'signal', terminate: "process.kill(process.pid,'SIGTERM')", expected: /signal SIGTERM/u },
+])('a stage $name stops descendants holding its output pipes open', async ({ terminate, expected }) => {
+    const marker = join(tmpdir(), `ai-delivery-failed-stage-${process.pid}-${Date.now()}`);
+    const heartbeat = `${marker}-heartbeat`;
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');const {spawn}=require('child_process');const child=spawn(process.execPath,['-e',${JSON.stringify(`const fs=require('fs');setInterval(()=>fs.appendFileSync(${JSON.stringify(heartbeat)},'x'),20);`)}],{stdio:['ignore','inherit','inherit']});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));${terminate};`,
+    });
+    let descendantPid;
+    let timeout;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'feature\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic failing stage');
+        const controller = new AbortController();
+        const run = verifyIssue({ issueNumber: 17, repoRoot: row.path, signal: controller.signal });
+        const rejection = assert.rejects(run, expected);
+        const markerDeadline = Date.now() + 2_000;
+        while (!existsSync(marker) && Date.now() < markerDeadline)
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        assert.equal(existsSync(marker), true);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        timeout = setTimeout(() => controller.abort(), 500);
+        await rejection;
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+        await new Promise((resolve) => setTimeout(resolve, 60));
+        const stoppedSize = existsSync(heartbeat) ? readFileSync(heartbeat).length : 0;
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        assert.equal(existsSync(heartbeat) ? readFileSync(heartbeat).length : 0, stoppedSize);
+    }
+    finally {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        if (descendantPid !== undefined) {
+            try {
+                process.kill(descendantPid, 'SIGKILL');
+            }
+            catch {
+                /* already stopped */
+            }
+        }
+        rmSync(marker, { force: true });
+        rmSync(heartbeat, { force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('MCP request cancellation stops verification and leaves no stage receipt', async () => {
+    const marker = join(tmpdir(), `ai-delivery-mcp-cancel-${process.pid}-${Date.now()}`);
+    const heartbeat = `${marker}-heartbeat`;
+    const { root, runtimeEntryPath } = await fixture({
+        firstStageScript: `const fs=require('fs');const {spawn}=require('child_process');const child=spawn(process.execPath,['-e',${JSON.stringify(`const fs=require('fs');setInterval(()=>fs.appendFileSync(${JSON.stringify(heartbeat)},'x'),20);`)}],{stdio:'ignore'});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));setTimeout(()=>{},1000);`,
+    });
+    const server = createAiDeliveryMcpServer({ repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' });
+    const client = new Client({ name: 'synthetic-cancelling-client', version: '1.0.0' });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    let descendantPid;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'feature\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic MCP cancellable stage');
+        await server.connect(serverTransport);
+        await client.connect(clientTransport);
+        const controller = new AbortController();
+        const call = client.callTool({ name: 'issue_verify', arguments: { issueNumber: 17 } }, undefined, {
+            signal: controller.signal,
+        });
+        const markerDeadline = Date.now() + 2_000;
+        while (!existsSync(marker) && Date.now() < markerDeadline)
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        assert.equal(existsSync(marker), true);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        controller.abort();
+        await assert.rejects(call, /abort/iu);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const stoppedSize = existsSync(heartbeat) ? readFileSync(heartbeat).length : 0;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        assert.equal(existsSync(heartbeat) ? readFileSync(heartbeat).length : 0, stoppedSize);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+    }
+    finally {
+        await client.close();
+        await server.close();
+        if (descendantPid !== undefined) {
+            try {
+                process.kill(descendantPid, 'SIGKILL');
+            }
+            catch {
+                /* already stopped */
+            }
+        }
+        rmSync(marker, { force: true });
+        rmSync(heartbeat, { force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('the stage output bound covers both streams and publishes no checkpoint on overflow', async () => {
+    const { root } = await fixture({
+        firstStageScript: `process.stdout.write(Buffer.alloc(4*1024*1024));process.stderr.write(Buffer.alloc(4*1024*1024+1));`,
+    });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'feature\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic output bound');
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path }), /captured output exceeded 8 MiB/u);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 test('scratch start derives safe names and reports the requested worktree', async () => {
-    const { root, runtimeEntryPath } = fixture();
+    const { root, runtimeEntryPath } = await fixture();
     try {
         const first = (await executeTool('issue_start', { scratch: true, request: 'Investigate button layout' }, { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' }));
         assert.equal(first.mode, 'scratch');
@@ -543,10 +916,17 @@ test('MCP request rejects unsupported legacy options before lifecycle dispatch',
         await server.close();
     }
 });
-test('synthetic issue traverses native intake, readiness, receipt-bound App review, exact merge and finish', async () => {
-    const { root } = fixture();
+test.each([
+    { remote: 'origin', divergentOrigin: false },
+    { remote: 'upstream', divergentOrigin: false },
+    { remote: 'upstream', divergentOrigin: true },
+])('synthetic lifecycle finishes with remote $remote and divergent origin $divergentOrigin', async (routing) => {
+    const { root } = await fixture(routing);
+    const remoteName = routing.remote;
+    assert.equal(defaultBaseRef(root, remoteName), `refs/remotes/${remoteName}/main`);
     const remote = join(root, '.git', 'remote.git');
-    const config = loadDeliveryConfig(root).config;
+    const configuration = await loadDeliveryConfig(root);
+    const config = configuration.config;
     const baseSha = git(root, 'rev-parse', 'main');
     const issueNumber = 17;
     const prNumber = 23;
@@ -639,6 +1019,7 @@ test('synthetic issue traverses native intake, readiness, receipt-bound App revi
                                     options: [],
                                     issueField: {
                                         __typename: 'IssueFieldSingleSelect',
+                                        id: 'ISSUE-FIELD-101',
                                         fullDatabaseId: '101',
                                         name: 'Estimate',
                                         options: ['1', '2', '4'].map((name) => ({ id: name, name })),
@@ -652,6 +1033,7 @@ test('synthetic issue traverses native intake, readiness, receipt-bound App revi
                                     options: [],
                                     issueField: {
                                         __typename: 'IssueFieldSingleSelect',
+                                        id: 'ISSUE-FIELD-102',
                                         fullDatabaseId: '102',
                                         name: 'Urgency',
                                         options: ['High', 'Low'].map((name) => ({ id: name, name })),
@@ -853,7 +1235,7 @@ test('synthetic issue traverses native intake, readiness, receipt-bound App revi
             createCommit: async (input) => {
                 calls.push('git:createCommit');
                 mergeSha = git(root, 'commit-tree', input.tree, '-p', input.parents[0], '-p', input.parents[1], '-m', input.message);
-                git(root, 'push', '-q', 'origin', `${mergeSha}:refs/heads/merge-object`);
+                git(root, 'push', '-q', remoteName, `${mergeSha}:refs/heads/merge-object`);
                 return { data: { sha: mergeSha } };
             },
             getCommit: async () => ({
@@ -881,6 +1263,7 @@ test('synthetic issue traverses native intake, readiness, receipt-bound App revi
         root,
         repo: { owner: 'example', repo: 'widget' },
         config,
+        configuration,
         clients: {
             authSource: 'app',
             role: 'author',
@@ -967,7 +1350,7 @@ test('synthetic issue traverses native intake, readiness, receipt-bound App revi
         await assert.rejects(publishPr(context, { issueNumber }), /Git push requires the selected author GitHub App installation 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', 'origin', `${headSha}:refs/heads/issue/17`);
+        git(row.path, 'push', '-q', remoteName, `${headSha}:refs/heads/issue/17`);
         const publishEvidence = await createIssuePhaseEvidence({ issueNumber, phase: 'publish', repoRoot: row.path });
         const publicationContent = {
             baseSha,