@aviaratech/ai-delivery 0.2.1 → 0.3.1

package/dist/lifecycle.test.js

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 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 { cpSync, chmodSync, 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, vi } from 'vitest';
@@ -17,28 +17,124 @@ import { executeTool, resumedIssueUpdate, startTrackedIssue } from './dispatch.j
 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 { checkoutPr, finishIssue, listPrs, mergePr, prChecks, prInfo, publishPr, submitFormalReview } from './pr.js';
 import { updateIssueWorktreeDelivery } from './services/worktreeRegistry.js';
 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';
+const personalRoute = vi.hoisted(() => ({
+    active: false,
+    baseSha: '',
+    headSha: '',
+    reviews: [],
+    submitted: 0,
+}));
 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({
+        createDeliveryGitHubClients: async (input) => {
+            if (personalRoute.active && input.config.roles.author.authSource === 'personal') {
+                const pr = () => ({
+                    number: 23,
+                    node_id: 'PR-23',
+                    html_url: 'https://github.com/example/widget/pull/23',
+                    head: { sha: personalRoute.headSha, ref: 'issue/17' },
+                    base: { sha: personalRoute.baseSha, ref: 'main' },
+                    state: 'open',
+                    draft: true,
+                    user: { login: 'host-user' },
+                });
+                if (input.role === 'reviewer') {
+                    assert.equal(input.identity, 'synthetic-reviewer');
+                    return {
+                        ...syntheticDiscoveryClients(),
+                        authSource: 'app',
+                        credentialSource: 'app:reviewer',
+                        role: 'reviewer',
+                        appActorLogin: async () => 'synthetic-reviewer[bot]',
+                        rest: {
+                            repos: { get: async () => ({ data: { full_name: 'example/widget' } }) },
+                            pulls: {
+                                get: async () => ({ data: pr() }),
+                                listReviews: async () => ({ data: personalRoute.reviews }),
+                                createReview: async (request) => {
+                                    assert.equal(request.event, 'APPROVE');
+                                    assert.equal(request.commit_id, personalRoute.headSha);
+                                    personalRoute.submitted += 1;
+                                    const review = {
+                                        id: 31,
+                                        body: request.body,
+                                        state: 'APPROVED',
+                                        commit_id: personalRoute.headSha,
+                                        user: { login: 'synthetic-reviewer[bot]' },
+                                        html_url: 'https://github.com/example/widget/pull/23#pullrequestreview-31',
+                                    };
+                                    personalRoute.reviews.push(review);
+                                    return { data: review };
+                                },
+                            },
+                        },
+                        graphql: async (query, variables) => query.includes('DeliveryReviewDecision')
+                            ? {
+                                repository: {
+                                    pullRequest: { headRefOid: personalRoute.headSha, reviewDecision: 'REVIEW_REQUIRED' },
+                                },
+                            }
+                            : syntheticDiscoveryClients().graphql(query, variables),
+                    };
+                }
+                assert.equal(input.identity, 'host-author');
+                const clients = await actual.createDeliveryGitHubClients({
+                    ...input,
+                    env: { AUTHOR_TOKEN: 'selected-personal-token', GH_TOKEN: 'ambient-token' },
+                });
+                Object.assign(clients, {
+                    authenticatedAuthor: async () => ({ actorLogin: 'host-user', credentialIdentity: 'user:37' }),
+                    graphql: syntheticDiscoveryClients().graphql,
+                    rest: {
+                        issues: { get: async () => ({ data: { title: 'Synthetic issue' } }) },
+                        git: { getRef: async () => ({ data: { object: { sha: personalRoute.baseSha } } }) },
+                        pulls: {
+                            list: async () => ({ data: [] }),
+                            create: async () => ({ data: pr() }),
+                            get: async () => ({ data: pr() }),
+                        },
+                        request: async () => Promise.reject(Object.assign(new Error('Rules unreadable'), { status: 403 })),
+                    },
+                });
+                return clients;
+            }
+            const rest = new Octokit({
                 request: {
                     fetch: async () => {
                         throw new Error('Unexpected network request in synthetic lifecycle test.');
                     },
                 },
-            }),
-        }),
+            });
+            if (input.role === 'reviewer') {
+                Object.assign(rest.repos, { get: async () => ({ data: { full_name: 'example/widget' } }) });
+            }
+            return {
+                ...syntheticDiscoveryClients(),
+                authSource: input.role === 'author' && input.config.roles.author.authSource === 'personal' ? 'personal' : 'app',
+                role: input.role,
+                ...(input.role === 'author'
+                    ? {
+                        authenticatedAuthor: async () => ({
+                            actorLogin: input.config.roles.author.authSource === 'personal' ? 'host-user' : 'synthetic-author[bot]',
+                            credentialIdentity: input.config.roles.author.authSource === 'personal' ? 'user:37' : 'app:201',
+                        }),
+                        credentialSource: input.config.roles.author.authSource === 'personal' ? 'env:AUTHOR_TOKEN' : 'app:author',
+                    }
+                    : {}),
+                ...(input.role === 'reviewer'
+                    ? { appActorLogin: async () => 'synthetic-reviewer', credentialSource: 'app:reviewer' }
+                    : {}),
+                rest,
+            };
+        },
     };
 });
 function git(root, ...args) {
@@ -100,14 +196,16 @@ async function fixture(options = {}) {
             policy: { contract: 'RepositoryDeliveryPolicy@1', module: './policy.mjs' },
             repository: 'example/widget',
             roles: {
-                author: {
-                    credentialEnv: {
-                        appId: 'AUTHOR_APP_ID',
-                        installationId: 'AUTHOR_INSTALLATION_ID',
-                        privateKeyPath: 'AUTHOR_KEY_PATH',
+                author: options.personalAuthor
+                    ? { authSource: 'personal', credentialEnv: { token: 'AUTHOR_TOKEN' }, identity: 'host-author' }
+                    : {
+                        credentialEnv: {
+                            appId: 'AUTHOR_APP_ID',
+                            installationId: 'AUTHOR_INSTALLATION_ID',
+                            privateKeyPath: 'AUTHOR_KEY_PATH',
+                        },
+                        identity: 'synthetic-author',
                     },
-                    identity: 'synthetic-author',
-                },
                 reviewer: {
                     credentialEnv: {
                         appId: 'REVIEWER_APP_ID',
@@ -147,7 +245,7 @@ export default {
           ${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);`)}] }] }`
+          ${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);`)}] }] }`
             : ''}],
       risk: 'standard' };
   },
@@ -820,6 +918,65 @@ test('MCP request cancellation stops verification and leaves no stage receipt',
         rmSync(root, { recursive: true, force: true });
     }
 });
+test('MCP server shutdown cancellation waits for owned verification cleanup', async () => {
+    const marker = join(tmpdir(), `ai-delivery-mcp-shutdown-${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 shutdown = new AbortController();
+    const server = createAiDeliveryMcpServer({
+        repoRoot: root,
+        runtimeEntryPath,
+        identity: 'synthetic-author',
+        signal: shutdown.signal,
+    });
+    const client = new Client({ name: 'synthetic-shutdown-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'), 'shutdown\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic MCP shutdown');
+        await server.connect(serverTransport);
+        await client.connect(clientTransport);
+        const call = client.callTool({ name: 'issue_verify', arguments: { issueNumber: 17 } });
+        const deadline = Date.now() + 2_000;
+        while (!existsSync(marker) && Date.now() < deadline)
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        assert.equal(existsSync(marker), true);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        shutdown.abort();
+        const result = await call;
+        assert.equal(result.isError, true);
+        assert.match(JSON.stringify(result.content), /cancelled/u);
+        const size = existsSync(heartbeat) ? readFileSync(heartbeat).length : 0;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        assert.equal(existsSync(heartbeat) ? readFileSync(heartbeat).length : 0, size);
+        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));`,
@@ -841,169 +998,971 @@ test('the stage output bound covers both streams and publishes no checkpoint on
         rmSync(root, { recursive: true, force: true });
     }
 });
-test('scratch start derives safe names and reports the requested worktree', async () => {
-    const { root, runtimeEntryPath } = await fixture();
+test('a consumer RSS ceiling stops a running stage before it can publish a checkpoint', async () => {
+    const { root } = await fixture({
+        firstStageScript: 'const held=Buffer.alloc(32*1024*1024,1);setTimeout(()=>process.stdout.write(String(held.length)),500);',
+    });
     try {
-        const first = (await executeTool('issue_start', { scratch: true, request: 'Investigate button layout' }, { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' }));
-        assert.equal(first.mode, 'scratch');
-        assert.equal(first.title, 'Investigate button layout');
-        assert.equal(first.branch, 'scratch/investigate-button-layout');
-        assert.ok(first.worktreePath.endsWith('/.worktrees/scratch-investigate-button-layout'));
-        const overridden = (await executeTool('issue_start', { scratch: true, request: 'Work on parser', branch: 'scratch/custom/parser' }, { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' }));
-        assert.equal(overridden.branch, 'scratch/custom/parser');
-        assert.equal(overridden.worktreePath, join(dirname(first.worktreePath), 'scratch-scratch-custom-parser'));
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'bounded stage\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic resource bound');
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: { maxAggregateRssBytes: 1, minFreeDiskBytes: 1 },
+        }), /aggregate RSS.*limit/u);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
     }
     finally {
         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), [
-        'issue_create',
-        'issue_start',
-        'issue_update',
-        'issue_info',
-        'issue_ready_check',
-        'issue_develop',
-        'issue_verify',
-        'issue_pr_create',
-        'issue_pr_info',
-        'issue_pr_review',
-        'issue_pr_merge',
-        'issue_finish',
-        'issue_worktree_create',
-    ]);
-    const validInputs = {
-        issue_create: { title: 'Synthetic tracking parent' },
-        issue_ready_check: { issueNumber: 17 },
-        issue_develop: { issueNumber: 17 },
-        issue_verify: { issueNumber: 17 },
-        issue_pr_create: { issueNumber: 17, draft: true },
-        issue_pr_review: { issueNumber: 17, prNumber: 23, artifact: '{}' },
-        issue_pr_merge: { issueNumber: 17, prNumber: 23, strategy: 'merge' },
-        issue_finish: { issueNumber: 17, prNumber: 23, strategy: 'merge' },
-    };
-    for (const [name, input] of Object.entries(validInputs)) {
-        const tool = AI_DELIVERY_MCP_TOOLS.find((candidate) => candidate.name === name);
-        assert.ok(tool, `${name} has an MCP definition`);
-        assert.equal(tool.inputSchema.safeParse(input).success, true, `${name} accepts its lifecycle input`);
-        assert.equal(tool.inputSchema.safeParse({ ...input, unexpected: true }).success, false, `${name} rejects unrelated fields`);
+test('a consumer filesystem-output ceiling measures new files apart from captured stdout', async () => {
+    const { root } = await fixture({
+        firstStageScript: "const fs=require('fs');fs.writeFileSync('generated.bin',Buffer.alloc(4096));setTimeout(()=>{},500);",
+    });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'filesystem output\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic filesystem output');
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 1_024,
+                outputRoots: ['.'],
+            },
+        }), /new filesystem output.*limit/u);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
     }
 });
-test('MCP request rejects unsupported legacy options before lifecycle dispatch', async () => {
-    const server = createAiDeliveryMcpServer({ repoRoot: '/missing-synthetic-repository' });
-    const client = new Client({ name: 'synthetic-test', version: '1.0.0' });
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+test('insufficient free disk refuses admission before starting a selected command', async () => {
+    const { root } = await fixture({ firstStageScript: 'setTimeout(()=>{},500);' });
+    const progress = vi.spyOn(process.stderr, 'write');
     try {
-        await server.connect(serverTransport);
-        await client.connect(clientTransport);
-        const result = await client.callTool({
-            name: 'issue_create',
-            arguments: {
-                body: 'tracked work',
-                issueType: 'Task',
-                points: 1,
-                priority: 'High',
-                title: 'Synthetic change',
-                unsupportedLegacyOption: true,
-            },
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
         });
-        assert.equal(result.isError, true);
-        assert.match(JSON.stringify(result.content), /unsupportedLegacyOption/u);
+        writeFileSync(join(row.path, 'change.txt'), 'disk admission\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic disk admission');
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: Number.MAX_SAFE_INTEGER },
+        }), /Free disk fell below limit/u);
+        assert.equal(progress.mock.calls.some(([message]) => String(message).includes('"state":"running"')), false);
     }
     finally {
-        await client.close();
-        await server.close();
+        progress.mockRestore();
+        rmSync(root, { recursive: true, force: true });
     }
 });
-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 configuration = await loadDeliveryConfig(root);
-    const config = configuration.config;
-    const baseSha = git(root, 'rev-parse', 'main');
-    const issueNumber = 17;
-    const prNumber = 23;
-    const issue = {
-        id: 170,
-        number: issueNumber,
-        node_id: 'ISSUE-17',
-        title: 'Synthetic change',
-        body: `## Outcome\nDeliver a verified synthetic change to the local repository.\n\n## Scope\n- \`artifact.txt\`\n\n## Acceptance Criteria\n- [ ] Change is verified\n- [ ] Review and merge are recorded\n\n## Verification\nRun \`node --version\`.`,
-        state: 'open',
-        html_url: 'https://example.test/issues/17',
-        type: { name: 'Task' },
-    };
-    let issuePoints;
-    let parentPoints = 1;
-    let parentIssueNumber = null;
-    let parentChildren = [];
-    let issuePriority;
-    let projectStatus = null;
-    let blockerOpen = false;
-    let trackingParent = false;
-    let failFirstBlockerLink = true;
-    let failNextProjectSync = false;
-    let checksPassed = true;
-    let prDraft = true;
-    let prState = 'open';
-    let mergedAt = '';
-    let headSha = '';
-    let mergeSha = '';
-    let stalePrReadbacks = 0;
-    let review = null;
-    const calls = [];
-    const createPayloads = [];
-    const statuses = { Queued: 'todo', Active: 'active', Waiting: 'blocked', Shipped: 'done' };
-    const statusName = (option) => Object.entries(statuses).find(([, id]) => id === option)?.[0];
-    const pageInfo = { endCursor: null, hasNextPage: false };
-    const issueFieldValues = (number = issueNumber) => [
-        ...((number === 11 ? parentPoints : issuePoints) === undefined
-            ? []
-            : [
-                {
-                    data_type: 'single_select',
-                    issue_field_id: 101,
-                    issue_field_name: 'Estimate',
-                    value: String(number === 11 ? parentPoints : issuePoints),
-                },
-            ]),
-        ...(issuePriority === undefined
-            ? []
-            : [{ data_type: 'single_select', issue_field_id: 102, issue_field_name: 'Urgency', value: issuePriority }]),
-    ];
-    const pr = (stale = false) => ({
-        number: prNumber,
-        node_id: 'PR-23',
-        title: 'Synthetic change',
-        html_url: 'https://example.test/pulls/23',
-        state: stale ? 'open' : prState,
-        draft: prDraft,
-        merged_at: !stale && prState === 'closed' ? mergedAt : null,
-        merge_commit_sha: mergeSha || null,
-        mergeable: true,
-        mergeable_state: 'clean',
-        user: { login: 'synthetic-author' },
-        head: { sha: headSha, ref: 'issue/17' },
-        base: { sha: baseSha, ref: 'main' },
+test('the issue_verify request forwards consumer resource limits to the maintained runner', async () => {
+    const { root, runtimeEntryPath } = await fixture();
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'request resource limits\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic request resource limits');
+        await assert.rejects(executeTool('issue_verify', {
+            issueNumber: 17,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: Number.MAX_SAFE_INTEGER },
+        }, { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' }), /Free disk fell below limit/u);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('a bounded passing run records measured resources in versioned evidence', async () => {
+    const { root, runtimeEntryPath } = await fixture({
+        firstStageScript: "setTimeout(()=>process.stdout.write('done'),500);",
     });
-    const graphql = async (query, variables = {}) => {
-        if (query.includes('ProjectDeliveryConfiguration'))
-            return {
-                organization: {
-                    projectV2: {
-                        id: 'PROJECT-1',
-                        number: 1,
-                        title: 'Delivery',
-                        viewerCanUpdate: true,
-                        fields: {
-                            nodes: [
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'resource evidence\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic resource evidence');
+        const run = await verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
+        });
+        assert.equal(run.schemaVersion, 'ai-delivery.run@2');
+        const resources = run.resources;
+        assert.ok(resources);
+        assert.ok(resources.sampleCount > 0);
+        assert.ok((resources.maxSampledAggregateRssBytes ?? 0) > 0);
+        assert.ok((resources.minSampledFreeDiskBytes ?? 0) > 0);
+        assert.equal(resources.observation, 'sampled');
+        assert.equal(resources.processCoverage, 'observed-processes-only');
+        const evidence = await createIssuePhaseEvidence({ issueNumber: 17, phase: 'verify', repoRoot: row.path });
+        assert.equal(evidence.aggregateId, run.aggregate.aggregateId);
+        const dispatched = (await executeTool('issue_verify', {
+            issueNumber: 17,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
+        }, { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' }));
+        assert.equal(dispatched.resources?.processCoverage, 'observed-processes-only');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('bounded verification reruns unmeasured work and reuses only matching measured stages', async () => {
+    const { root, counter, secondCounter, failSecond } = await fixture({ twoStages: true });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'resource resume\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic resource resume');
+        await verifyIssue({ issueNumber: 17, repoRoot: row.path });
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '1');
+        const bounds = { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 };
+        writeFileSync(failSecond, 'fail once\n');
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds }), /exit 7/u);
+        assert.equal(readFileSync(counter, 'utf8'), '2');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '2');
+        rmSync(failSecond);
+        const resumed = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds });
+        assert.equal(readFileSync(counter, 'utf8'), '2');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '3');
+        assert.ok((resumed.resources?.sampleCount ?? 0) > 0);
+        const repeated = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds });
+        assert.equal(readFileSync(counter, 'utf8'), '2');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '3');
+        assert.ok((repeated.resources?.sampleCount ?? 0) > 0);
+        const stageInputId = repeated.stageReceipts[0].input.inputId.slice(7);
+        const stagePath = join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check', `${stageInputId}.json`);
+        rmSync(stagePath);
+        await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds });
+        assert.equal(readFileSync(counter, 'utf8'), '2');
+        assert.equal(existsSync(stagePath), true);
+        await verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: { ...bounds, maxAggregateRssBytes: 900_000_000 },
+        });
+        assert.equal(readFileSync(counter, 'utf8'), '3');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '4');
+        const sidecar = join(root, '.git', 'ai-delivery', 'resource-stages@1', `${stageInputId}.json`);
+        writeFileSync(sidecar, 'corrupt\n');
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds }), /Resource stage checkpoint is corrupt/u);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('filesystem output already measured in a resumed stage counts toward the run limit', async () => {
+    const { root } = await fixture({
+        twoStages: true,
+        firstStageScript: "const fs=require('fs');fs.mkdirSync('.issue-cli',{recursive:true});fs.writeFileSync('.issue-cli/a.bin',Buffer.alloc(700));const p='.issue-cli/count';fs.writeFileSync(p,String(Number(fs.existsSync(p)?fs.readFileSync(p,'utf8'):0)+1));setTimeout(()=>{},100);",
+        secondStageScript: "const fs=require('fs');if(fs.existsSync('.issue-cli/fail'))process.exit(7);fs.writeFileSync('.issue-cli/b.bin',Buffer.alloc(700));setTimeout(()=>{},100);",
+    });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'cumulative output\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic cumulative output');
+        mkdirSync(join(row.path, '.issue-cli'));
+        writeFileSync(join(row.path, '.issue-cli', 'fail'), 'x');
+        const resourceBounds = {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 1_000,
+            outputRoots: ['.issue-cli'],
+        };
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds }), /exit 7/u);
+        assert.equal(readFileSync(join(row.path, '.issue-cli', 'count'), 'utf8'), '1');
+        rmSync(join(row.path, '.issue-cli', 'fail'));
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds }), /new filesystem output.*limit/u);
+        assert.equal(readFileSync(join(row.path, '.issue-cli', 'count'), 'utf8'), '1');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('failed-stage filesystem output remains charged on retry', async () => {
+    const { root } = await fixture({
+        firstStageScript: "const fs=require('fs');fs.mkdirSync('.issue-cli',{recursive:true});fs.appendFileSync('.issue-cli/output.bin',Buffer.alloc(700));if(fs.existsSync('.issue-cli/fail'))process.exit(7);setTimeout(()=>{},100);",
+    });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'failed output\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic failed output');
+        mkdirSync(join(row.path, '.issue-cli'));
+        const fail = join(row.path, '.issue-cli', 'fail');
+        writeFileSync(fail, 'x');
+        const resourceBounds = {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 1_000,
+            outputRoots: ['.issue-cli'],
+        };
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds }), /exit 7/u);
+        assert.equal(readFileSync(join(row.path, '.issue-cli', 'output.bin')).length, 700);
+        rmSync(fail);
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds }), /new filesystem output.*limit/u);
+        assert.equal(readFileSync(join(row.path, '.issue-cli', 'output.bin')).length, 1_400);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+        rmSync(join(row.path, '.issue-cli', 'output.bin'));
+        const completed = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds });
+        assert.equal(readFileSync(join(row.path, '.issue-cli', 'output.bin')).length, 700);
+        assert.ok((completed.resources?.maxSampledNewOutputBytes ?? 0) < 1_000);
+        const baselineDirectory = join(root, '.git', 'ai-delivery', 'output-baselines@1');
+        const snapshot = readdirSync(baselineDirectory).find((name) => name.endsWith('.json') && !name.endsWith('.state.json'));
+        assert.ok(snapshot);
+        rmSync(join(baselineDirectory, snapshot));
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds }), /Filesystem output baseline checkpoint is missing or corrupt/u);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('mixed-case output filenames round-trip through the durable baseline', async () => {
+    const { root } = await fixture();
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'mixed-case output\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic mixed-case output');
+        const output = join(row.path, '.issue-cli');
+        mkdirSync(output);
+        writeFileSync(join(output, 'a.bin'), 'a');
+        writeFileSync(join(output, 'B.bin'), 'B');
+        const run = await verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 1_000,
+                outputRoots: ['.issue-cli'],
+            },
+        });
+        assert.equal(run.resources?.maxSampledNewOutputBytes, 0);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('aggregate RSS crossing stops three individually under-limit children', async () => {
+    const marker = join(tmpdir(), `ai-delivery-rss-children-${process.pid}-${Date.now()}`);
+    const limit = 200_000_000;
+    const worker = `const fs=require('fs');const held=Buffer.alloc(32*1024*1024,1);fs.writeFileSync(${JSON.stringify(marker)}+'-'+process.pid,String(process.memoryUsage().rss));setInterval(()=>{void held[0]},1000);`;
+    const { root } = await fixture({
+        firstStageScript: `const {spawn}=require('child_process');for(let i=0;i<3;i++)spawn(process.execPath,['-e',${JSON.stringify(worker)}],{stdio:'ignore'});setTimeout(()=>{},3000);`,
+    });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'aggregate RSS\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic aggregate RSS');
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: { maxAggregateRssBytes: limit, minFreeDiskBytes: 1 },
+        }), /aggregate RSS.*limit/u);
+        const rows = readdirSync(tmpdir()).filter((name) => name.startsWith(`${marker.split('/').at(-1)}-`));
+        assert.equal(rows.length, 3);
+        for (const name of rows)
+            assert.ok(Number(readFileSync(join(tmpdir(), name), 'utf8')) < limit);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+    }
+    finally {
+        for (const name of readdirSync(tmpdir()).filter((value) => value.startsWith(`${marker.split('/').at(-1)}-`))) {
+            const pid = Number(name.slice(name.lastIndexOf('-') + 1));
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                /* already stopped */
+            }
+            rmSync(join(tmpdir(), name), { force: true });
+        }
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('filesystem output from a sampled detached child crosses its declared root limit', async () => {
+    const marker = join(tmpdir(), `ai-delivery-detached-output-${process.pid}-${Date.now()}`);
+    const heartbeat = `${marker}-heartbeat`;
+    const worker = `const fs=require('fs');fs.writeFileSync('generated.bin',Buffer.alloc(4096));setInterval(()=>fs.appendFileSync(${JSON.stringify(heartbeat)},'x'),20);`;
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');const {spawn}=require('child_process');const child=spawn(process.execPath,['-e',${JSON.stringify(worker)}],{detached:true,stdio:'ignore'});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));setTimeout(()=>{},2500);`,
+    });
+    let descendantPid;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'detached output\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic detached output');
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 1_024,
+                outputRoots: ['.'],
+            },
+        }), /new filesystem output.*limit/u);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        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 {
+        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('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-'));
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'linked output\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic linked output');
+        mkdirSync(join(outside, 'target'));
+        symlinkSync(join(outside, 'target'), join(outside, 'declared'));
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 1_024,
+                outputRoots: [join(outside, 'declared')],
+            },
+        }), /symbolic link/u);
+    }
+    finally {
+        rmSync(outside, { recursive: true, force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('an unobserved detached pipe holder cannot keep a cancelled stage pending indefinitely', async () => {
+    const marker = join(tmpdir(), `ai-delivery-escaped-pipe-${process.pid}-${Date.now()}`);
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');const {spawn}=require('child_process');const child=spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{detached:true,stdio:['ignore','inherit','inherit']});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));process.exit(0);`,
+    });
+    let descendantPid;
+    let run;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'escaped pipe\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic escaped pipe');
+        const controller = new AbortController();
+        run = verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            signal: controller.signal,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
+        });
+        const deadline = Date.now() + 2_000;
+        while (!existsSync(marker) && Date.now() < deadline)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.equal(existsSync(marker), true);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        controller.abort();
+        await assert.rejects(Promise.race([
+            run,
+            new Promise((_, reject) => setTimeout(() => reject(new Error('cleanup remained pending')), 3_000)),
+        ]), /owned command pipes did not close/u);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+    }
+    finally {
+        if (descendantPid !== undefined) {
+            try {
+                process.kill(descendantPid, 'SIGKILL');
+            }
+            catch {
+                /* already stopped */
+            }
+        }
+        await run?.catch(() => undefined);
+        rmSync(marker, { force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('a direct child exit with inherited pipes still open fails within a bounded cleanup interval', async () => {
+    const marker = join(tmpdir(), `ai-delivery-exited-pipe-${process.pid}-${Date.now()}`);
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');const {spawn}=require('child_process');const child=spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{detached:true,stdio:['ignore','inherit','inherit']});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));process.exit(0);`,
+    });
+    let descendantPid;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'exited pipe\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic exited pipe');
+        const run = verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
+        });
+        const deadline = Date.now() + 2_000;
+        while (!existsSync(marker) && Date.now() < deadline)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.equal(existsSync(marker), true);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        await assert.rejects(Promise.race([
+            run,
+            new Promise((_, reject) => setTimeout(() => reject(new Error('stage remained pending')), 3_500)),
+        ]), /owned command pipes did not close/u);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'verification@1', 'stages', 'check')), false);
+    }
+    finally {
+        if (descendantPid !== undefined) {
+            try {
+                process.kill(descendantPid, 'SIGKILL');
+            }
+            catch {
+                /* already stopped */
+            }
+        }
+        rmSync(marker, { force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('bounded cancellation cleans a sampled detached descendant and preserves an unrelated process', async () => {
+    const marker = join(tmpdir(), `ai-delivery-detached-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);`)}],{detached:true,stdio:'ignore'});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));setTimeout(()=>{},2500);`,
+    });
+    const unrelated = spawn(process.execPath, ['-e', `const fs=require('fs');setInterval(()=>fs.appendFileSync(${JSON.stringify(unrelatedHeartbeat)},'x'),20);`], { detached: true, stdio: 'ignore' });
+    unrelated.unref();
+    let descendantPid;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'detached child\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic detached child');
+        const controller = new AbortController();
+        const run = verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            signal: controller.signal,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
+        });
+        const deadline = Date.now() + 2_000;
+        while (!existsSync(marker) && Date.now() < deadline)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.equal(existsSync(marker), true);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        await new Promise((resolve) => setTimeout(resolve, 1_200));
+        controller.abort();
+        await assert.rejects(run, /cancelled/u);
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        const stoppedSize = existsSync(heartbeat) ? readFileSync(heartbeat).length : 0;
+        const unrelatedSize = existsSync(unrelatedHeartbeat) ? readFileSync(unrelatedHeartbeat).length : 0;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        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('sampled evidence identifies the escape boundary for a detached pipe-free child', async () => {
+    const marker = join(tmpdir(), `ai-delivery-late-detach-${process.pid}-${Date.now()}`);
+    const heartbeat = `${marker}-heartbeat`;
+    const trigger = `${marker}-trigger`;
+    const { root } = await fixture({
+        firstStageScript: `const fs=require('fs');const {spawn}=require('child_process');const wait=setInterval(()=>{if(!fs.existsSync(${JSON.stringify(trigger)}))return;clearInterval(wait);setTimeout(()=>{const child=spawn(process.execPath,['-e',${JSON.stringify(`const fs=require('fs');setInterval(()=>fs.appendFileSync(${JSON.stringify(heartbeat)},'x'),20);`)}],{detached:true,stdio:'ignore'});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));},250);setTimeout(()=>process.exit(0),500);},5);`,
+    });
+    let descendantPid;
+    const controller = new AbortController();
+    const progress = vi.spyOn(process.stderr, 'write');
+    let run;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'late detach\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic late detach');
+        run = verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            signal: controller.signal,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
+        });
+        const deadline = Date.now() + 2_000;
+        while (!progress.mock.calls.some(([message]) => String(message).includes('"sampledAggregateRssBytes"')) &&
+            Date.now() < deadline)
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        assert.ok(progress.mock.calls.some(([message]) => String(message).includes('"sampledAggregateRssBytes"')));
+        writeFileSync(trigger, 'go');
+        const result = await run;
+        assert.equal(result.resources?.processCoverage, 'observed-processes-only');
+        assert.equal(result.aggregate.result, 'passed');
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        const size = existsSync(heartbeat) ? readFileSync(heartbeat).length : 0;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        assert.ok((existsSync(heartbeat) ? readFileSync(heartbeat).length : 0) > size);
+    }
+    finally {
+        controller.abort();
+        await run?.catch(() => undefined);
+        progress.mockRestore();
+        if (descendantPid !== undefined) {
+            try {
+                process.kill(descendantPid, 'SIGKILL');
+            }
+            catch {
+                /* already stopped */
+            }
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            const stopped = existsSync(heartbeat) ? readFileSync(heartbeat).length : 0;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            assert.equal(existsSync(heartbeat) ? readFileSync(heartbeat).length : 0, stopped);
+        }
+        rmSync(marker, { force: true });
+        rmSync(heartbeat, { force: true });
+        rmSync(trigger, { force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('a successful command cannot publish while its sampled detached descendant survives', async () => {
+    const marker = join(tmpdir(), `ai-delivery-left-behind-${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);`)}],{detached:true,stdio:'ignore'});child.unref();fs.writeFileSync(${JSON.stringify(marker)},String(child.pid));setTimeout(()=>{},1400);`,
+    });
+    let descendantPid;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'left behind\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic left behind descendant');
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: { maxAggregateRssBytes: 1_000_000_000, minFreeDiskBytes: 1 },
+        }), /owned descendant survived/u);
+        descendantPid = Number(readFileSync(marker, 'utf8'));
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        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 {
+        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('public PR dry run retains a configured host author and App reviewer', async () => {
+    const { root } = await fixture({ personalAuthor: true });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'host-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'host author change\n');
+        git(row.path, 'add', 'change.txt');
+        git(row.path, 'commit', '-qm', 'synthetic host author change');
+        await verifyIssue({ issueNumber: 17, repoRoot: row.path });
+        const result = (await executeTool('issue_pr_create', { issueNumber: 17, dryRun: true }, { repoRoot: row.path, identity: 'host-author' }));
+        assert.equal(result.dryRun, true);
+        assert.deepEqual(result.reviewRoute.author, {
+            actorLogin: 'host-user',
+            authSource: 'personal',
+            credentialSource: 'env:AUTHOR_TOKEN',
+            identity: 'host-author',
+        });
+        assert.equal(result.reviewRoute.reviewer.actorLogin, 'synthetic-reviewer');
+        assert.equal(result.reviewRoute.approvalEligibility, 'unknown');
+    }
+    finally {
+        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 });
+    const originalPath = process.env.PATH;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'host-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        writeFileSync(join(row.path, 'change.txt'), 'host author publication\n');
+        git(row.path, 'add', 'change.txt');
+        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'))
+            .find(existsSync);
+        if (!realGit)
+            throw new Error('Git executable unavailable for public transport test.');
+        git(root, 'config', '--local', '--unset', `url.${join(root, '.git', 'remote.git')}.insteadOf`);
+        const shimDir = join(root, '.git', 'git-shim');
+        const pushMarker = join(root, '.git', 'selected-host-push');
+        mkdirSync(shimDir);
+        const shim = join(shimDir, 'git');
+        writeFileSync(shim, `#!/bin/sh
+if [ "$1" = -c ] && [ "$2" = credential.helper= ] && [ "$3" = push ]; then
+  [ "$AI_DELIVERY_GIT_TOKEN" = selected-personal-token ] || exit 91
+  [ "$("$GIT_ASKPASS" Password)" = selected-personal-token ] || exit 92
+  : > "${pushMarker}"
+  exit 0
+fi
+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 = {
+            authorIdentity: 'host-author',
+            checks: ['verified exact diff'],
+            diffScopeHash: digestValue(run.classification.changedPaths),
+            elapsedMs: 1,
+            findings: [],
+            head: run.classification.head,
+            issueNumber: 17,
+            prNumber: 23,
+            readOnly: true,
+            requestedEffort: 'xhigh',
+            requestedModel: 'gpt-6-astra',
+            effectiveEffort: 'xhigh',
+            effectiveModel: 'gpt-6-astra',
+            reviewerIdentity: 'synthetic-reviewer',
+            schemaVersion: 'ai-delivery.review-artifact@1',
+            summary: 'Independent exact-head review',
+            verdict: 'approve',
+        };
+        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));
+        assert.equal(first.reviewState.status, 'still-required');
+        assert.equal(personalRoute.submitted, 1);
+        const second = (await executeTool('issue_pr_review', reviewInput, execution));
+        assert.equal(second.receiptId, first.receiptId);
+        assert.equal(personalRoute.submitted, 1);
+    }
+    finally {
+        personalRoute.active = false;
+        personalRoute.reviews.length = 0;
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        rmSync(root, { recursive: true, force: true });
+    }
+}, 15_000);
+test('scratch start derives safe names and reports the requested worktree', async () => {
+    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');
+        assert.equal(first.title, 'Investigate button layout');
+        assert.equal(first.branch, 'scratch/investigate-button-layout');
+        assert.ok(first.worktreePath.endsWith('/.worktrees/scratch-investigate-button-layout'));
+        const overridden = (await executeTool('issue_start', { scratch: true, request: 'Work on parser', branch: 'scratch/custom/parser' }, { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' }));
+        assert.equal(overridden.branch, 'scratch/custom/parser');
+        assert.equal(overridden.worktreePath, join(dirname(first.worktreePath), 'scratch-scratch-custom-parser'));
+    }
+    finally {
+        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), [
+        'issue_create',
+        'issue_start',
+        'issue_update',
+        'issue_info',
+        'issue_ready_check',
+        'issue_develop',
+        'issue_verify',
+        'issue_pr_create',
+        'issue_pr_info',
+        'issue_pr_review',
+        'issue_pr_merge',
+        'issue_finish',
+        'issue_worktree_create',
+    ]);
+    const validInputs = {
+        issue_create: { title: 'Synthetic tracking parent' },
+        issue_ready_check: { issueNumber: 17 },
+        issue_develop: { issueNumber: 17 },
+        issue_verify: { issueNumber: 17 },
+        issue_pr_create: { issueNumber: 17, draft: true },
+        issue_pr_review: { issueNumber: 17, prNumber: 23, artifact: '{}' },
+        issue_pr_merge: { issueNumber: 17, prNumber: 23, strategy: 'merge' },
+        issue_finish: { issueNumber: 17, prNumber: 23, strategy: 'merge' },
+    };
+    for (const [name, input] of Object.entries(validInputs)) {
+        const tool = AI_DELIVERY_MCP_TOOLS.find((candidate) => candidate.name === name);
+        assert.ok(tool, `${name} has an MCP definition`);
+        assert.equal(tool.inputSchema.safeParse(input).success, true, `${name} accepts its lifecycle input`);
+        assert.equal(tool.inputSchema.safeParse({ ...input, unexpected: true }).success, false, `${name} rejects unrelated fields`);
+    }
+});
+test('MCP request rejects unsupported legacy options before lifecycle dispatch', async () => {
+    const server = createAiDeliveryMcpServer({ repoRoot: '/missing-synthetic-repository' });
+    const client = new Client({ name: 'synthetic-test', version: '1.0.0' });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    try {
+        await server.connect(serverTransport);
+        await client.connect(clientTransport);
+        const result = await client.callTool({
+            name: 'issue_create',
+            arguments: {
+                body: 'tracked work',
+                issueType: 'Task',
+                points: 1,
+                priority: 'High',
+                title: 'Synthetic change',
+                unsupportedLegacyOption: true,
+            },
+        });
+        assert.equal(result.isError, true);
+        assert.match(JSON.stringify(result.content), /unsupportedLegacyOption/u);
+    }
+    finally {
+        await client.close();
+        await server.close();
+    }
+});
+async function syntheticLifecycle(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 configuration = await loadDeliveryConfig(root);
+    const config = configuration.config;
+    const baseSha = git(root, 'rev-parse', 'main');
+    const issueNumber = 17;
+    const prNumber = 23;
+    const issue = {
+        id: 170,
+        number: issueNumber,
+        node_id: 'ISSUE-17',
+        title: 'Synthetic change',
+        body: `## Outcome\nDeliver a verified synthetic change to the local repository.\n\n## Scope\n- \`artifact.txt\`\n\n## Acceptance Criteria\n- [ ] Change is verified\n- [ ] Review and merge are recorded\n\n## Verification\nRun \`node --version\`.`,
+        state: 'open',
+        html_url: 'https://example.test/issues/17',
+        type: { name: 'Task' },
+    };
+    let issuePoints;
+    let parentPoints = 1;
+    let parentIssueNumber = null;
+    let parentChildren = [];
+    let issuePriority;
+    let projectStatus = null;
+    let blockerOpen = false;
+    let trackingParent = false;
+    let failFirstBlockerLink = true;
+    let failNextProjectSync = false;
+    let checksPassed = true;
+    let prDraft = true;
+    let prState = 'open';
+    let mergedAt = '';
+    let headSha = '';
+    let mergeSha = '';
+    let stalePrReadbacks = 0;
+    let review = null;
+    let reviewDecision = 'REVIEW_REQUIRED';
+    const calls = [];
+    const createPayloads = [];
+    const statuses = { Queued: 'todo', Active: 'active', Waiting: 'blocked', Shipped: 'done' };
+    const statusName = (option) => Object.entries(statuses).find(([, id]) => id === option)?.[0];
+    const pageInfo = { endCursor: null, hasNextPage: false };
+    const issueFieldValues = (number = issueNumber) => [
+        ...((number === 11 ? parentPoints : issuePoints) === undefined
+            ? []
+            : [
+                {
+                    data_type: 'single_select',
+                    issue_field_id: 101,
+                    issue_field_name: 'Estimate',
+                    value: String(number === 11 ? parentPoints : issuePoints),
+                },
+            ]),
+        ...(issuePriority === undefined
+            ? []
+            : [{ data_type: 'single_select', issue_field_id: 102, issue_field_name: 'Urgency', value: issuePriority }]),
+    ];
+    const pr = (stale = false) => ({
+        number: prNumber,
+        node_id: 'PR-23',
+        title: 'Synthetic change',
+        html_url: 'https://example.test/pulls/23',
+        state: stale ? 'open' : prState,
+        draft: prDraft,
+        merged_at: !stale && prState === 'closed' ? mergedAt : null,
+        merge_commit_sha: mergeSha || null,
+        mergeable: true,
+        mergeable_state: 'clean',
+        user: { login: 'synthetic-author[bot]' },
+        head: { sha: headSha, ref: 'issue/17' },
+        base: { sha: baseSha, ref: 'main' },
+    });
+    const graphql = async (query, variables = {}) => {
+        if (query.includes('DeliveryReviewDecision'))
+            return { repository: { pullRequest: { headRefOid: headSha, reviewDecision } } };
+        if (query.includes('ProjectDeliveryConfiguration'))
+            return {
+                organization: {
+                    projectV2: {
+                        id: 'PROJECT-1',
+                        number: 1,
+                        title: 'Delivery',
+                        viewerCanUpdate: true,
+                        fields: {
+                            nodes: [
                                 {
                                     __typename: 'ProjectV2SingleSelectField',
                                     id: 'FIELD-FLOW',
@@ -1128,6 +2087,10 @@ test.each([
     };
     const rest = {
         request: async (route, parameters) => {
+            if (route === 'GET /repos/{owner}/{repo}/rules/branches/{branch}')
+                return { data: [{ type: 'pull_request', parameters: { required_approving_review_count: 1 } }] };
+            if (route === 'GET /repos/{owner}/{repo}/branches/{branch}/protection')
+                throw Object.assign(new Error('Synthetic protected branch visibility unavailable'), { status: 403 });
             if (route === 'GET /orgs/{org}/issue-fields')
                 return {
                     data: [
@@ -1347,7 +2310,7 @@ test.each([
         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 GitHub App installation token/);
+        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`);
@@ -1372,7 +2335,9 @@ test.each([
             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');
+        assert.equal((await prChecks(context, prNumber)).reviewState.status, 'still-required');
         await assert.rejects(checkoutPr(context, prNumber), /open in-repository branch/u);
         assert.equal(git(remote, 'rev-parse', 'refs/heads/issue/17'), headSha);
         await assert.rejects(mergePr(context, { issueNumber, prNumber }), /submitted independent review/);
@@ -1407,8 +2372,11 @@ test.each([
         await assert.rejects(submitFormalReview(personalReviewer, { artifact, issueNumber, prNumber }), /reviewer GitHub App role/);
         const reviewResult = await submitFormalReview(reviewer, { artifact, issueNumber, prNumber });
         assert.equal(reviewResult.githubReviewId, 31);
+        assert.equal(reviewResult.reviewState.status, 'still-required');
         await publishPr(context, { issueNumber, draft: false });
         assert.equal(prDraft, false);
+        await assert.rejects(mergePr(context, { issueNumber, prNumber }), /submitted APPROVED review.*still requires/u);
+        reviewDecision = 'APPROVED';
         checksPassed = false;
         await assert.rejects(mergePr(context, { issueNumber, prNumber }), /failed or pending checks/);
         checksPassed = true;
@@ -1434,7 +2402,9 @@ test.each([
         const result = JSON.parse(originalResult);
         const { resultId: _resultId, ...resultContent } = result;
         const wrongResult = { ...resultContent, mergeSha: 'a'.repeat(40) };
-        writeFileSync(resultPath, JSON.stringify({ ...wrongResult, resultId: digestValue(wrongResult) }), { mode: 0o600 });
+        writeFileSync(resultPath, JSON.stringify({ ...wrongResult, resultId: digestValue(wrongResult) }), {
+            mode: 0o600,
+        });
         await assert.rejects(finishIssue(context, { issueNumber, prNumber, strategy: 'merge' }), /exact prepared merge intent/u);
         writeFileSync(resultPath, originalResult, { mode: 0o600 });
         const reviewedHead = headSha;
@@ -1497,5 +2467,10 @@ test.each([
     finally {
         rmSync(root, { recursive: true, force: true });
     }
-});
+}
+test.each([
+    { remote: 'origin', divergentOrigin: false },
+    { remote: 'upstream', divergentOrigin: false },
+    { remote: 'upstream', divergentOrigin: true },
+])('synthetic lifecycle finishes with remote $remote and divergent origin $divergentOrigin', syntheticLifecycle, 15_000);
 //# sourceMappingURL=lifecycle.test.js.map