@aviaratech/ai-delivery 0.3.6 → 0.3.8

package/dist/lifecycle.test.js

@@ -562,7 +562,7 @@ test('an old active issue remains pinned while a new row uses the same canonical
             },
         };
         await assert.rejects(createIssue(relationshipContext, { title: 'Synthetic child', parentIssueNumber: 17 }), /ownership witness/u);
-        await assert.rejects(updateIssue(relationshipContext, { issueNumber: 19, parentIssueNumber: null }), /ownership witness/u);
+        await assert.rejects(updateIssue(relationshipContext, { issueNumber: 17, parentIssueNumber: null }), /ownership witness/u);
         assert.equal(issueWrites, 0);
         await assert.rejects(prepareIssueWorktree({ identity: 'synthetic-author', issueNumber: 17, repoRoot: root }), /ownership witness/u);
         const row = await prepareStandaloneWorktree({
@@ -580,6 +580,179 @@ test('an old active issue remains pinned while a new row uses the same canonical
         rmSync(root, { recursive: true, force: true });
     }
 });
+test.each(['current-blocker', 'new-blocker', 'current-parent', 'new-parent'])('tracking-only relationships preserve the related legacy worktree for %s', async (relationship) => {
+    const { root } = await fixture();
+    try {
+        const legacyPath = join(root, '.worktrees', 'issue-17');
+        git(root, 'worktree', 'add', '-b', 'issue/17', legacyPath, 'main');
+        writeFileSync(join(legacyPath, 'artifact.txt'), 'legacy source remains untouched\n');
+        const evidencePath = join(root, '.git', 'legacy-evidence');
+        mkdirSync(evidencePath);
+        writeFileSync(join(evidencePath, 'receipt.json'), '{"producer":"synthetic-legacy"}\n');
+        const legacy = {
+            branch: 'issue/17',
+            createdAt: '2026-01-01T00:00:00.000Z',
+            identity: 'synthetic-legacy',
+            issueNumber: 17,
+            path: legacyPath,
+            status: 'active',
+            type: 'issue',
+            updatedAt: '2026-01-01T00:00:00.000Z',
+        };
+        const registryPath = join(root, '.issue-cli', 'worktrees.json');
+        mkdirSync(dirname(registryPath), { recursive: true });
+        const registryBytes = JSON.stringify({ worktrees: [legacy] });
+        writeFileSync(registryPath, registryBytes);
+        const sourceBefore = directoryHash(legacyPath);
+        const evidenceBefore = directoryHash(evidencePath);
+        const loaded = await loadDeliveryConfig(root);
+        const pageInfo = { endCursor: null, hasNextPage: false };
+        let parent = relationship === 'current-parent' ? 17 : null;
+        let blockers = relationship === 'current-blocker' ? [17] : [];
+        let missingRelated = true;
+        let malformedRelationships = false;
+        let writes = 0;
+        let projectOption = 'STATUS-0';
+        const statuses = ['Queued', 'Active', 'Waiting', 'Shipped'];
+        const projectItem = () => ({
+            id: 'ITEM-19',
+            isArchived: false,
+            content: { id: 'ISSUE-19' },
+            fieldValueByName: { name: statuses[Number(projectOption.slice(-1))], optionId: projectOption },
+        });
+        const context = {
+            root,
+            repo: { owner: 'example', repo: 'widget' },
+            config: loaded.config,
+            clients: {
+                rest: {
+                    request: async (route, input) => {
+                        assert.equal(input.owner, 'example');
+                        assert.equal(input.repo, 'widget');
+                        assert.equal(route, 'GET /repos/{owner}/{repo}/issues/{issue_number}/issue-field-values');
+                        return { data: [] };
+                    },
+                    issues: {
+                        get: async (input) => {
+                            assert.equal(input.owner, 'example');
+                            assert.equal(input.repo, 'widget');
+                            if (input.issue_number === 17 && missingRelated)
+                                throw new Error('Synthetic issue not found');
+                            return {
+                                data: {
+                                    id: input.issue_number * 10,
+                                    number: input.issue_number,
+                                    node_id: `ISSUE-${String(input.issue_number)}`,
+                                    title: 'Synthetic tracking issue',
+                                    state: 'open',
+                                    html_url: `https://example.test/issues/${String(input.issue_number)}`,
+                                },
+                            };
+                        },
+                        update: async () => {
+                            writes += 1;
+                            return { data: {} };
+                        },
+                        removeSubIssue: async (input) => {
+                            assert.equal(input.issue_number, 17);
+                            assert.equal(input.sub_issue_id, 190);
+                            writes += 1;
+                            parent = null;
+                            return { data: {} };
+                        },
+                        addSubIssue: async (input) => {
+                            assert.equal(input.issue_number, 17);
+                            assert.equal(input.sub_issue_id, 190);
+                            writes += 1;
+                            parent = 17;
+                            return { data: {} };
+                        },
+                        listSubIssues: async () => ({ data: [] }),
+                    },
+                    paginate: async () => (parent === 17 ? [{ number: 19 }] : []),
+                },
+                graphql: async (query, variables) => {
+                    if (query.includes('blockedBy(first:')) {
+                        assert.equal(variables.owner, 'example');
+                        assert.equal(variables.name, 'widget');
+                        assert.equal(variables.number, 19);
+                        if (malformedRelationships)
+                            return { repository: null };
+                        return {
+                            repository: {
+                                issue: {
+                                    parent: parent === null ? null : { id: 'ISSUE-17', number: parent },
+                                    blockedBy: {
+                                        nodes: blockers.map((number) => ({
+                                            id: `ISSUE-${String(number)}`,
+                                            number,
+                                            state: 'OPEN',
+                                            title: 'Synthetic blocker',
+                                        })),
+                                        pageInfo,
+                                    },
+                                },
+                            },
+                        };
+                    }
+                    if (query.includes('removeBlockedBy') || query.includes('addBlockedBy')) {
+                        assert.equal(variables.issue, 'ISSUE-19');
+                        assert.equal(variables.blocking, 'ISSUE-17');
+                        writes += 1;
+                        blockers = query.includes('addBlockedBy') ? [17] : [];
+                        return {};
+                    }
+                    if (query.includes('ProjectDeliveryItems'))
+                        return { organization: { projectV2: { items: { nodes: [projectItem()], pageInfo } } } };
+                    if (query.includes('UpdateProjectDeliveryStatus')) {
+                        projectOption = String(variables.optionId);
+                        writes += 1;
+                        return { updateProjectV2ItemFieldValue: { projectV2Item: { id: 'ITEM-19' } } };
+                    }
+                    if (query.includes('ProjectDeliveryItemReadback'))
+                        return { node: { ...projectItem(), project: { id: 'PROJECT-1', number: 1 } } };
+                    return syntheticDiscoveryClients().graphql(query, variables);
+                },
+            },
+        };
+        const input = relationship.endsWith('blocker')
+            ? { issueNumber: 19, blockedBy: relationship === 'new-blocker' ? [17] : [] }
+            : { issueNumber: 19, parentIssueNumber: relationship === 'new-parent' ? 17 : null };
+        await assert.rejects(updateIssue(context, input), /Unable to resolve (?:blocker|parent) issue/u);
+        assert.equal(writes, 0);
+        missingRelated = false;
+        malformedRelationships = true;
+        await assert.rejects(updateIssue(context, input), /invalid blocked-by relationship evidence/u);
+        assert.equal(writes, 0);
+        malformedRelationships = false;
+        await assert.rejects(updateIssue(context, { ...input, issueNumber: 17 }), /ownership witness/u);
+        assert.equal(writes, 0);
+        writeFileSync(registryPath, JSON.stringify({ worktrees: [{ ...legacy, schemaVersion: 'unknown@99' }] }));
+        await assert.rejects(updateIssue(context, input), /unsupported fields/u);
+        assert.equal(writes, 0);
+        writeFileSync(registryPath, registryBytes);
+        const transitionPath = join(root, '.git', 'ai-delivery', 'worktree-owners', 'issue-19.transition.json');
+        mkdirSync(dirname(transitionPath), { recursive: true });
+        writeFileSync(transitionPath, '{"schemaVersion":"unknown-transition@99"}', { mode: 0o600 });
+        await assert.rejects(updateIssue(context, input), /transition is incomplete or unreadable/u);
+        assert.equal(writes, 0);
+        unlinkSync(transitionPath);
+        const result = await updateIssue(context, input);
+        assert.equal(result.worktree, null);
+        assert.deepEqual(result.blockedBy, relationship === 'new-blocker' ? [17] : []);
+        assert.equal(result.parentIssueNumber, relationship === 'new-parent' ? 17 : null);
+        assert.equal(result.projectStatus, relationship === 'new-blocker' ? 'Blocked' : 'Todo');
+        assert.ok(writes > 0);
+        await assert.rejects(prepareIssueWorktree({ identity: 'synthetic-author', issueNumber: 17, repoRoot: root }), /ownership witness/u);
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: legacyPath }), /ownership witness/u);
+        assert.equal(readFileSync(registryPath, 'utf8'), registryBytes);
+        assert.equal(directoryHash(legacyPath), sourceBefore);
+        assert.equal(directoryHash(evidencePath), evidenceBefore);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 test('synthetic cutover restores exact pre-write state and resumes an incomplete verification stage', async () => {
     const { root, counter, secondCounter, failSecond } = await fixture({ twoStages: true });
     const backup = mkdtempSync(join(tmpdir(), 'ai-delivery-cutover-backup-'));
@@ -3663,4 +3836,399 @@ test.each(['escape', 'broken', 'cycle'])('output observation rejects %s aliases
         rmSync(base, { recursive: true, force: true });
     }
 });
+test('fully cached bounded verification still rejects a newly leaked FIFO', async () => {
+    const { root, counter } = await fixture();
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-cached-fifo-')));
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const bounds = {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 1024,
+            outputRoots: [output],
+        };
+        await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds });
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        execFileSync('mkfifo', [join(output, 'leaked')]);
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds }), /unsupported file/u);
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+    }
+    finally {
+        rmSync(output, { recursive: true, force: true });
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+function filesystemFixtureScript(output, mode) {
+    return `
+(async () => {
+  const fs = require('node:fs'), cp = require('node:child_process'), path = require('node:path'), assert = require('node:assert/strict');
+  const { withVerificationFilesystemFixture } = await import(${JSON.stringify(new URL('./agent.js', import.meta.url).href)});
+  const { assertPrivateFile } = await import(${JSON.stringify(new URL('./delivery/common.js', import.meta.url).href)});
+  const output = ${JSON.stringify(output)}, fifo = path.join(output, 'fifo'), events = path.join(output, 'events');
+  const gate = JSON.parse(process.env.AI_DELIVERY_OUTPUT_OBSERVATION_GATE);
+  const trace = value => fs.appendFileSync(events, value + '\\n');
+  await withVerificationFilesystemFixture(async () => {
+    cp.execFileSync('mkfifo', ['-m', '600', fifo]);
+    fs.writeFileSync(path.join(output, 'capability'), JSON.stringify(gate));
+    trace('created');
+    try {
+      if (${JSON.stringify(mode)} === 'abrupt') process.exit(9);
+      if (${JSON.stringify(mode)} === 'cancel') await new Promise(() => { setInterval(() => {}, 1000); });
+      if (${JSON.stringify(mode)} === 'block') fs.readFileSync(fifo);
+      while (fs.readdirSync(path.join(gate.directory, 'requests')).length === 0) await new Promise(resolve => setTimeout(resolve, 10));
+      assert.ok(fs.existsSync(fifo)); trace('scan-queued');
+      assert.throws(() => assertPrivateFile(fifo), /private regular file/); trace('reader-rejected');
+      const regular = path.join(output, 'regular'), hard = path.join(output, 'hard'), alias = path.join(output, 'alias');
+      fs.writeFileSync(regular, 'x'.repeat(128), { mode: 0o600 });
+      fs.linkSync(regular, hard); assert.throws(() => assertPrivateFile(hard), /private regular file/); fs.unlinkSync(hard);
+      fs.symlinkSync('./regular', alias); assert.throws(() => assertPrivateFile(alias), /private regular file/); fs.unlinkSync(alias);
+      if (${JSON.stringify(mode)} === 'assertion') throw new Error('synthetic reader assertion failure');
+    } finally { fs.unlinkSync(fifo); trace('cleaned'); }
+  });
+  trace('released');
+})().catch(error => { console.error(error.message); process.exitCode = 1; });`;
+}
+test.each(['pass', 'assertion'])('filesystem fixture gate deterministically queues a scan through reader rejection and %s teardown', async (mode) => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-fixture-gate-')));
+    const { root } = await fixture({ firstStageScript: filesystemFixtureScript(output, mode) });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const run = verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 2048,
+                outputRoots: [output],
+            },
+        });
+        if (mode === 'assertion')
+            await assert.rejects(run, /exit 1/u);
+        else
+            assert.ok((await run).resources.maxSampledNewOutputBytes >= 128);
+        assert.equal(existsSync(join(output, 'fifo')), false);
+        const events = readFileSync(join(output, 'events'), 'utf8').trim().split('\n');
+        assert.deepEqual(events, mode === 'pass'
+            ? ['created', 'scan-queued', 'reader-rejected', 'cleaned', 'released']
+            : ['created', 'scan-queued', 'reader-rejected', 'cleaned']);
+        const capability = JSON.parse(readFileSync(join(output, 'capability'), 'utf8'));
+        assert.equal(existsSync(capability.directory), false);
+        assert.equal(readFileSync(join(output, 'regular'), 'utf8').length, 128);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test.each(['abrupt', 'block', 'cancel'])('filesystem fixture gate preserves leaked FIFO and unrelated files after %s', async (mode) => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-fixture-failure-')));
+    writeFileSync(join(output, 'unrelated'), 'preserved');
+    const { root } = await fixture({ firstStageScript: filesystemFixtureScript(output, mode) });
+    const controller = new AbortController();
+    let running;
+    const progress = vi.spyOn(process.stderr, 'write');
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const bounds = {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 2048,
+            outputRoots: [output],
+        };
+        running = verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: bounds,
+            signal: controller.signal,
+        }).catch((error) => error);
+        if (mode === 'cancel') {
+            for (let attempt = 0; attempt < 300 && !existsSync(join(output, 'capability')); attempt++)
+                await new Promise((resolve) => setTimeout(resolve, 20));
+            assert.ok(existsSync(join(output, 'capability')));
+            const cap = JSON.parse(readFileSync(join(output, 'capability'), 'utf8'));
+            for (let attempt = 0; attempt < 300 && readdirSync(join(cap.directory, 'requests')).length === 0; attempt++)
+                await new Promise((resolve) => setTimeout(resolve, 20));
+            assert.ok(readdirSync(join(cap.directory, 'requests')).length > 0);
+            controller.abort();
+        }
+        const failure = String(await running);
+        assert.match(failure, mode === 'abrupt' ? /exit 9/u : mode === 'block' ? /reader or teardown is stalled/u : /cancelled/u);
+        assert.doesNotMatch(failure, /cleanup failed|live holder/u);
+        const capability = JSON.parse(readFileSync(join(output, 'capability'), 'utf8'));
+        assert.equal(existsSync(capability.directory), false);
+        assert.ok(existsSync(join(output, 'fifo')));
+        assert.equal(readFileSync(join(output, 'unrelated'), 'utf8'), 'preserved');
+        if (mode !== 'abrupt')
+            assert.ok(progress.mock.calls.filter(([line]) => String(line).includes('sampledAggregateRssBytes')).length > 2);
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds }), /unsupported file/u);
+    }
+    finally {
+        controller.abort();
+        await running;
+        progress.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test('filesystem fixture gate still enforces positive byte limits after deterministic contention', async () => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-fixture-limit-')));
+    const { root } = await fixture({ firstStageScript: filesystemFixtureScript(output, 'pass') });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        await assert.rejects(verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 64,
+                outputRoots: [output],
+            },
+        }), /filesystem output.*exceeded/u);
+        assert.equal(existsSync(join(output, 'fifo')), false);
+        assert.equal(readFileSync(join(output, 'regular'), 'utf8').length, 128);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test.each(['verification', 'runtime'])('filesystem fixture gate preserves observation and cancellation after direct %s command closure', async (mode) => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-fixture-close-')));
+    writeFileSync(join(output, 'unrelated'), 'preserved');
+    const script = `
+(async () => {
+  const fs = require('node:fs'), cp = require('node:child_process');
+  const child = cp.spawn(process.execPath, ['-e', ${JSON.stringify(filesystemFixtureScript(output, 'cancel'))}], { stdio: 'ignore' });
+  child.unref();
+  fs.writeFileSync(${JSON.stringify(join(output, 'pids'))}, JSON.stringify({ root: process.pid, descendant: child.pid }));
+  while (!fs.existsSync(${JSON.stringify(join(output, 'exit-parent'))})) await new Promise(resolve => setTimeout(resolve, 10));
+  process.exit(0);
+})().catch(error => { console.error(error.message); process.exitCode = 1; });`;
+    const { root } = await fixture({ firstStageScript: script });
+    const controller = new AbortController();
+    const progress = vi.spyOn(process.stderr, 'write');
+    let running;
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const bounds = {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 4096,
+            outputRoots: [output],
+        };
+        const { withRuntimeSetupWriter } = await import('./verification.js');
+        running = (mode === 'verification'
+            ? verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds, signal: controller.signal })
+            : withRuntimeSetupWriter(row.path, (runner) => runner.run([process.execPath, '-e', script], bounds, controller.signal))).catch((error) => error);
+        for (let attempt = 0; attempt < 300 && !existsSync(join(output, 'capability')); attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.ok(existsSync(join(output, 'capability')));
+        const cap = JSON.parse(readFileSync(join(output, 'capability'), 'utf8'));
+        const pids = JSON.parse(readFileSync(join(output, 'pids'), 'utf8'));
+        const writerPath = join(root, '.git', 'ai-delivery', 'writers@1', digestValue(row.path).slice(7) + '.json');
+        const descendantObserved = () => {
+            const state = JSON.parse(readFileSync(writerPath, 'utf8'));
+            return state.command.tracked?.some((member) => member.pid === pids.descendant) === true;
+        };
+        for (let attempt = 0; attempt < 300 && (!descendantObserved() || readdirSync(join(cap.directory, 'requests')).length === 0); attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.ok(descendantObserved());
+        assert.ok(readdirSync(join(cap.directory, 'requests')).length > 0);
+        writeFileSync(join(output, 'exit-parent'), 'exit');
+        const parentAlive = () => spawnSync('ps', ['-p', String(pids.root), '-o', 'stat='], { encoding: 'utf8' }).stdout.trim().length > 0;
+        for (let attempt = 0; attempt < 100 && parentAlive(); attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.equal(parentAlive(), false);
+        const samples = () => progress.mock.calls.filter(([line]) => String(line).includes('sampledAggregateRssBytes')).length;
+        const afterExit = samples();
+        for (let attempt = 0; attempt < 100 && samples() === afterExit; attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        const observedAfterExit = samples() > afterExit;
+        controller.abort();
+        const failure = String(await running);
+        assert.match(failure, /cancelled/u);
+        assert.doesNotMatch(failure, /cleanup failed|live holder/u);
+        assert.ok(observedAfterExit, 'RSS and disk observation continues while the closed command awaits its scan');
+        assert.equal(existsSync(cap.directory), false);
+        assert.ok(existsSync(join(output, 'fifo')));
+        assert.equal(readFileSync(join(output, 'unrelated'), 'utf8'), 'preserved');
+        assert.equal(spawnSync('ps', ['-p', String(pids.descendant), '-o', 'stat='], { encoding: 'utf8' }).stdout.trim().length, 0);
+        assert.equal(progress.mock.calls.some(([line]) => String(line).includes('"state":"completed"')), false);
+    }
+    finally {
+        controller.abort();
+        await running;
+        progress.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test('filesystem fixture helper runs standalone and fails closed on malformed capability', async () => {
+    const { withVerificationFilesystemFixture } = await import('./agent.js');
+    assert.equal(await withVerificationFilesystemFixture(() => 'standalone'), 'standalone');
+    const prior = process.env['AI_DELIVERY_OUTPUT_OBSERVATION_GATE'];
+    try {
+        process.env['AI_DELIVERY_OUTPUT_OBSERVATION_GATE'] = '{}';
+        let executed = false;
+        await assert.rejects(withVerificationFilesystemFixture(() => {
+            executed = true;
+        }), /invalid or stale/u);
+        assert.equal(executed, false);
+    }
+    finally {
+        if (prior === undefined)
+            delete process.env['AI_DELIVERY_OUTPUT_OBSERVATION_GATE'];
+        else
+            process.env['AI_DELIVERY_OUTPUT_OBSERVATION_GATE'] = prior;
+    }
+});
+test('nested runtime setup inherits the outer gate for its baseline and child command', async () => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-nested-fixture-')));
+    const inner = await fixture();
+    const worker = filesystemFixtureScript(output, 'pass');
+    const { root } = await fixture({
+        firstStageScript: `
+(async () => {
+  const fs = require('node:fs'), cp = require('node:child_process'), assert = require('node:assert/strict');
+  const { withRuntimeSetupWriter } = await import(${JSON.stringify(new URL('./verification.js', import.meta.url).href)});
+  const capability = process.env.AI_DELIVERY_OUTPUT_OBSERVATION_GATE;
+  const child = cp.spawn(process.execPath, ['-e', ${JSON.stringify(worker)}], { stdio: ['ignore', 'inherit', 'inherit'] });
+  const closed = new Promise((resolve, reject) => child.once('exit', code => code === 0 ? resolve() : reject(new Error('fixture child exit ' + code))));
+  while (!fs.existsSync(${JSON.stringify(join(output, 'capability'))})) await new Promise(resolve => setTimeout(resolve, 10));
+  assert.equal(fs.readFileSync(${JSON.stringify(join(output, 'capability'))}, 'utf8'), capability);
+  await withRuntimeSetupWriter(${JSON.stringify(inner.root)}, async runner => {
+    await runner.run([process.execPath, '-e', 'require("node:assert/strict").equal(process.env.AI_DELIVERY_OUTPUT_OBSERVATION_GATE, ' + JSON.stringify(capability) + ')'], { maxAggregateRssBytes: 1000000000, minFreeDiskBytes: 1, maxNewOutputBytes: 2048, outputRoots: [${JSON.stringify(output)}] });
+  });
+  await closed;
+})().catch(error => { console.error(error.message); process.exitCode = 1; });`,
+    });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        await verifyIssue({
+            issueNumber: 17,
+            repoRoot: row.path,
+            resourceBounds: {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 2048,
+                outputRoots: [output],
+            },
+        });
+        assert.deepEqual(readFileSync(join(output, 'events'), 'utf8').trim().split('\n'), [
+            'created',
+            'scan-queued',
+            'reader-rejected',
+            'cleaned',
+            'released',
+        ]);
+        assert.equal(existsSync(join(inner.root, '.git', 'ai-delivery', 'output-observation')), false);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(inner.root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test('interrupted fixture owner recovers its gate, preserves completed work and rejects a leaked FIFO before resume', async () => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-fixture-recovery-')));
+    const marker = join(output, 'capability');
+    const { root, counter, secondCounter, failSecond } = await fixture({ twoStages: true });
+    let child;
+    let childOutput = '';
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const bounds = {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 2048,
+            outputRoots: [output],
+        };
+        writeFileSync(failSecond, 'fail once');
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds }), /exit 7/u);
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        child = spawn(process.execPath, [
+            '-e',
+            `(async () => {
+      const { withRuntimeSetupWriter } = await import(${JSON.stringify(new URL('./verification.js', import.meta.url).href)});
+      await withRuntimeSetupWriter(${JSON.stringify(row.path)}, runner => runner.run([process.execPath, '-e', ${JSON.stringify(filesystemFixtureScript(output, 'cancel'))}], ${JSON.stringify(bounds)}));
+    })().catch(error => { console.error(error.message); process.exitCode = 1; });`,
+        ], { stdio: ['ignore', 'pipe', 'pipe'] });
+        const capture = (chunk) => {
+            childOutput += chunk.toString();
+            if (childOutput.length > 1024 * 1024)
+                child.kill('SIGKILL');
+        };
+        child.stdout.on('data', capture);
+        child.stderr.on('data', capture);
+        const closed = new Promise((resolve) => child.once('exit', () => resolve()));
+        for (let attempt = 0; attempt < 500 && !existsSync(marker); attempt++)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        assert.ok(existsSync(marker), childOutput);
+        const priorGate = JSON.parse(readFileSync(marker, 'utf8'));
+        child.kill('SIGKILL');
+        await closed;
+        assert.equal(child.signalCode, 'SIGKILL');
+        // Exercise the existing writer's stale-file recovery after the exact parent has exited.
+        const writerPath = join(root, '.git', 'ai-delivery', 'writers@1', digestValue(row.path).slice(7) + '.json');
+        const stale = new Date(Date.now() - 20_000);
+        utimesSync(writerPath + '.lock', stale, stale);
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds }), /unsupported file/u);
+        assert.equal(existsSync(priorGate.directory), false);
+        assert.ok(existsSync(join(output, 'fifo')));
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        unlinkSync(join(output, 'fifo'));
+        unlinkSync(failSecond);
+        const resumed = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds });
+        assert.equal(resumed.stageReceipts.length, 2);
+        assert.equal(readFileSync(counter, 'utf8'), '1');
+        assert.equal(readFileSync(secondCounter, 'utf8'), '2');
+        assert.ok(resumed.stageReceipts.every((receipt) => receipt.commands.every((command) => command.exitCode === 0)));
+        const cached = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds });
+        assert.deepEqual(cached.stageReceipts.map((receipt) => receipt.receiptId), resumed.stageReceipts.map((receipt) => receipt.receiptId));
+        await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: { ...bounds, maxNewOutputBytes: 4096 } });
+        assert.equal(readFileSync(counter, 'utf8'), '2');
+    }
+    finally {
+        child?.kill('SIGKILL');
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
 //# sourceMappingURL=lifecycle.test.js.map