@aviaratech/ai-delivery 0.3.5 → 0.3.7

package/dist/lifecycle.test.js

@@ -2792,9 +2792,12 @@ test('MCP exposes one implementation surface for native lifecycle commands', ()
         'issue_pr_merge',
         'issue_finish',
         'issue_worktree_create',
+        'issue_worktree_transition_inspect',
+        'issue_worktree_transition_apply',
     ]);
     const validInputs = {
         issue_create: { title: 'Synthetic tracking parent' },
+        issue_update: { issueNumber: 17, park: true },
         issue_ready_check: { issueNumber: 17 },
         issue_develop: { issueNumber: 17 },
         issue_verify: { issueNumber: 17 },
@@ -2802,7 +2805,17 @@ test('MCP exposes one implementation surface for native lifecycle commands', ()
         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' },
+        issue_worktree_transition_inspect: { issueNumber: 17, purpose: 'active-resume' },
+        issue_worktree_transition_apply: {
+            authority: 'worktree:transition',
+            planPath: '/synthetic/plan.json',
+            expectedPlanId: `sha256:${'a'.repeat(64)}`,
+            relinquishmentCommentId: 101,
+            acceptanceCommentId: 102,
+        },
     };
+    const updateTool = AI_DELIVERY_MCP_TOOLS.find((tool) => tool.name === 'issue_update');
+    assert.equal(updateTool.inputSchema.safeParse({ issueNumber: 17, park: false }).success, false);
     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`);
@@ -2870,6 +2883,9 @@ async function syntheticLifecycle(routing) {
     let trackingParent = false;
     let failFirstBlockerLink = true;
     let failNextProjectSync = false;
+    let interruptNextStatusUpdate = false;
+    let conflictNextStatusReadback = false;
+    let projectStatusWrites = 0;
     let checksPassed = true;
     let prDraft = true;
     let prState = 'open';
@@ -2976,6 +2992,12 @@ async function syntheticLifecycle(routing) {
                             nodes: projectStatus === null
                                 ? []
                                 : [
+                                    {
+                                        id: 'UNRELATED-ITEM',
+                                        isArchived: false,
+                                        content: { id: 'UNRELATED-ISSUE' },
+                                        fieldValueByName: { name: 'Active', optionId: 'STATUS-1' },
+                                    },
                                     {
                                         id: 'ITEM-17',
                                         isArchived: false,
@@ -2999,19 +3021,29 @@ async function syntheticLifecycle(routing) {
             return { addProjectV2ItemById: { item: { id: 'ITEM-17' } } };
         }
         if (query.includes('UpdateProjectDeliveryStatus')) {
+            assert.equal(variables.projectId, 'PROJECT-1');
+            assert.equal(variables.itemId, 'ITEM-17');
+            projectStatusWrites += 1;
             projectStatus = statusName(String(variables.optionId)) ?? null;
+            if (interruptNextStatusUpdate) {
+                interruptNextStatusUpdate = false;
+                throw new Error('synthetic ambiguous status write');
+            }
             return { updateProjectV2ItemFieldValue: { projectV2Item: { id: 'ITEM-17' } } };
         }
-        if (query.includes('ProjectDeliveryItemReadback'))
+        if (query.includes('ProjectDeliveryItemReadback')) {
+            const contentId = conflictNextStatusReadback ? 'UNRELATED-ISSUE' : issue.node_id;
+            conflictNextStatusReadback = false;
             return {
                 node: {
                     id: 'ITEM-17',
                     isArchived: false,
                     project: { id: 'PROJECT-1', number: 1 },
-                    content: { id: issue.node_id },
+                    content: { id: contentId },
                     fieldValueByName: { name: projectStatus, optionId: statuses[projectStatus] },
                 },
             };
+        }
         if (query.includes('blockedBy(first:'))
             return {
                 repository: {
@@ -3032,6 +3064,10 @@ async function syntheticLifecycle(routing) {
             blockerOpen = true;
             return { addBlockedBy: { issue: { number: issueNumber } } };
         }
+        if (query.includes('removeBlockedBy')) {
+            blockerOpen = false;
+            return { removeBlockedBy: { issue: { number: issueNumber } } };
+        }
         if (query.includes('RepositoryId'))
             return { repository: { id: 'REPO-1' } };
         if (query.includes('UpdateExactRefs')) {
@@ -3328,6 +3364,41 @@ async function syntheticLifecycle(routing) {
         assert.equal(started.title, issue.title);
         const row = started;
         assert.equal(projectStatus, 'Active');
+        const parked = await updateIssue(context, { issueNumber, park: true });
+        assert.equal(parked.projectStatus, 'Todo');
+        assert.equal(existsSync(row.path), true);
+        assert.equal((await updateIssue(context, { issueNumber, title: issue.title })).projectStatus, 'Todo');
+        await developIssue(context, issueNumber);
+        assert.equal(projectStatus, 'Active');
+        const blockedUpdate = await updateIssue(context, { issueNumber, blockedBy: [9] });
+        assert.deepEqual(blockedUpdate.blockedBy, [9]);
+        assert.equal(blockedUpdate.projectStatus, 'Blocked');
+        assert.equal(projectStatus, 'Waiting');
+        const blockedWrites = projectStatusWrites;
+        assert.equal((await updateIssue(context, { issueNumber, blockedBy: [9] })).projectStatus, 'Blocked');
+        assert.equal(projectStatusWrites, blockedWrites);
+        assert.equal((await updateIssue(context, { issueNumber, park: true })).projectStatus, 'Blocked');
+        await assert.rejects(developIssue(context, issueNumber), /not ready/u);
+        interruptNextStatusUpdate = true;
+        await assert.rejects(updateIssue(context, { issueNumber, blockedBy: [] }), /ambiguous status write/u);
+        assert.equal(blockerOpen, false);
+        assert.equal(projectStatus, 'Queued');
+        const interruptedWrites = projectStatusWrites;
+        const unblockedUpdate = await updateIssue(context, { issueNumber, blockedBy: [] });
+        assert.equal(projectStatusWrites, interruptedWrites);
+        assert.deepEqual(unblockedUpdate.blockedBy, []);
+        assert.equal(unblockedUpdate.projectStatus, 'Todo');
+        conflictNextStatusReadback = true;
+        await assert.rejects(updateIssue(context, { issueNumber, blockedBy: [9] }), /exact issue item/u);
+        assert.equal(blockerOpen, true);
+        assert.equal((await updateIssue(context, { issueNumber, blockedBy: [9] })).projectStatus, 'Blocked');
+        assert.equal((await updateIssue(context, { issueNumber, state: 'closed' })).projectStatus, 'Done');
+        assert.equal((await updateIssue(context, { issueNumber, park: true })).projectStatus, 'Done');
+        assert.equal((await resumeCreatedIssue(context, { issueNumber })).projectStatus, 'Done');
+        assert.equal((await updateIssue(context, { issueNumber, state: 'open', blockedBy: [] })).projectStatus, 'Done');
+        assert.equal(existsSync(row.path), true);
+        await developIssue(context, issueNumber);
+        assert.equal(projectStatus, 'Active');
         writeFileSync(join(row.path, 'change.txt'), 'feature\n');
         git(row.path, 'add', 'change.txt');
         git(row.path, 'commit', '-qm', 'synthetic change');
@@ -3550,9 +3621,9 @@ test.each([
     { remote: 'upstream', divergentOrigin: false },
     { remote: 'upstream', divergentOrigin: true },
 ])('synthetic lifecycle finishes with remote $remote and divergent origin $divergentOrigin', syntheticLifecycle, 15_000);
-test('an unrelated consumer uses public MCP setup through verified configured-author publication, counted review readback, merge and cleanup', async () => {
+test('an unrelated consumer uses public MCP setup through verified configured-author publication, counted review readback, merge and cleanup', { timeout: 0 }, async () => {
     await syntheticLifecycle({ remote: 'origin', divergentOrigin: false, producerOnboarding: true });
-}, 15_000);
+});
 test.each(['escape', 'broken', 'cycle'])('output observation rejects %s aliases without running policy commands', async (kind) => {
     const { root, counter } = await fixture();
     const base = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-output-alias-')));
@@ -3592,4 +3663,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