@aviaratech/ai-delivery 0.3.11 → 0.3.13

package/dist/lifecycle.test.js

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import { execFileSync, spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
+import { syncBuiltinESMExports } from 'node:module';
 import { cpSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, readdirSync, realpathSync, rmSync, symlinkSync, unlinkSync, utimesSync, writeFileSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
@@ -20,7 +21,7 @@ import * as githubClient from './github/client.js';
 import * as atomicJson from './utils/atomicJson.js';
 import { createIssue, developIssue, listIssueSubissues, readyCheck, resumeCreatedIssue, updateIssue, } from './issue.js';
 import { checkoutPr, finishIssue, listPrs, mergePr, prChecks, prInfo, publishPr, submitFormalReview } from './pr.js';
-import { addWorktreeEntry, removeWorktreeEntry, updateIssueWorktreeDelivery } from './services/worktreeRegistry.js';
+import { addWorktreeEntry, assertNativeIssueTrackingAdmission, getIssueWorktreeStrict, removeWorktreeEntry, updateIssueWorktreeDelivery, } from './services/worktreeRegistry.js';
 import { assertDeliveryRuntimeAdmitted } from './services/deliveryAdmission.js';
 import { getDeliveryRecords } from './services/deliveryRecordService.js';
 import { createIssuePhaseEvidence, loadVerifiedRun, verifyIssue } from './verification.js';
@@ -539,38 +540,13 @@ test('an old active issue remains pinned while a new row uses the same canonical
         assert.equal(readFileSync(registryPath, 'utf8'), futureBytes);
         assert.equal(existsSync(join(root, '.worktrees', 'scratch-new')), false);
         writeFileSync(registryPath, JSON.stringify({ worktrees: [old] }));
-        let issueWrites = 0;
-        const relationshipContext = {
-            root,
-            repo: { owner: 'example', repo: 'widget' },
-            config: (await loadDeliveryConfig(root)).config,
-            clients: {
-                rest: {
-                    issues: {
-                        get: async () => ({ data: { id: 17, number: 17, node_id: 'PARENT-17', state: 'open' } }),
-                        create: async () => {
-                            issueWrites += 1;
-                            return { data: {} };
-                        },
-                        update: async () => {
-                            issueWrites += 1;
-                            return { data: {} };
-                        },
-                    },
-                },
-                graphql: async () => ({
-                    repository: {
-                        issue: {
-                            parent: { id: 'PARENT-17', number: 17 },
-                            blockedBy: { nodes: [], pageInfo: { endCursor: null, hasNextPage: false } },
-                        },
-                    },
-                }),
-            },
-        };
-        await assert.rejects(createIssue(relationshipContext, { title: 'Synthetic child', parentIssueNumber: 17 }), /ownership witness/u);
-        await assert.rejects(updateIssue(relationshipContext, { issueNumber: 17, parentIssueNumber: null }), /ownership witness/u);
-        assert.equal(issueWrites, 0);
+        assert.doesNotThrow(() => assertNativeIssueTrackingAdmission(17, root));
+        const original = readFileSync(registryPath, 'utf8');
+        writeFileSync(registryPath, JSON.stringify({ worktrees: [old, old] }));
+        assert.throws(() => assertNativeIssueTrackingAdmission(17, root), /duplicate/u);
+        writeFileSync(registryPath, futureBytes);
+        assert.throws(() => assertNativeIssueTrackingAdmission(17, root), /unsupported fields/u);
+        writeFileSync(registryPath, original);
         await assert.rejects(prepareIssueWorktree({ identity: 'synthetic-author', issueNumber: 17, repoRoot: root }), /ownership witness/u);
         const row = await prepareStandaloneWorktree({
             branch: 'scratch/new',
@@ -732,8 +708,7 @@ test.each(['current-blocker', 'new-blocker', 'current-parent', 'new-parent'])('t
         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);
+        assert.throws(() => getIssueWorktreeStrict(17, root), /ownership witness/u);
         writeFileSync(registryPath, JSON.stringify({ worktrees: [{ ...legacy, schemaVersion: 'unknown@99' }] }));
         await assert.rejects(updateIssue(context, input), /unsupported fields/u);
         assert.equal(writes, 0);
@@ -3617,7 +3592,10 @@ async function syntheticLifecycle(routing) {
                 },
             }),
         },
-        repos: { getCombinedStatusForRef: async () => ({ data: { statuses: [], state: 'success' } }) },
+        repos: {
+            get: async () => ({ data: { full_name: 'example/widget' } }),
+            getCombinedStatusForRef: async () => ({ data: { statuses: [], state: 'success' } }),
+        },
     };
     let authenticatedAuthor = 'synthetic-author[bot]';
     const context = {
@@ -3637,7 +3615,71 @@ async function syntheticLifecycle(routing) {
         },
     };
     let restoreDispatchClient;
+    const enableDispatch = () => {
+        const dispatchClient = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockImplementation(async (input) => ({
+            ...context.clients,
+            ...(input.role === 'reviewer'
+                ? {
+                    role: 'reviewer',
+                    appActorLogin: async () => 'synthetic-reviewer[bot]',
+                }
+                : {}),
+            graphql: (async (query, variables) => query.includes('DeliveryDiscovery') ||
+                query.includes('DeliveryRepository') ||
+                query.includes('ProjectDeliveryConfiguration')
+                ? syntheticDiscoveryClients().graphql(query, variables)
+                : graphql(query, variables)),
+        }));
+        restoreDispatchClient = () => dispatchClient.mockRestore();
+        return dispatchClient;
+    };
+    const execution = { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' };
     try {
+        if (routing.legacyNativeMetadata) {
+            enableDispatch();
+            const legacyPath = join(root, '.worktrees', 'issue-17');
+            git(root, 'worktree', 'add', '-b', 'issue/17', legacyPath, 'main');
+            writeFileSync(join(legacyPath, 'artifact.txt'), 'unadopted legacy source\n');
+            const receiptRoot = join(root, '.git', 'legacy-receipts');
+            mkdirSync(receiptRoot);
+            writeFileSync(join(receiptRoot, 'run.json'), '{"producer":"synthetic-legacy"}\n');
+            const registryPath = join(root, '.issue-cli', 'worktrees.json');
+            mkdirSync(dirname(registryPath), { recursive: true });
+            const legacy = {
+                branch: 'issue/17',
+                createdAt: '2026-01-01T00:00:00.000Z',
+                identity: 'synthetic-legacy',
+                issueNumber,
+                path: legacyPath,
+                status: 'active',
+                type: 'issue',
+                updatedAt: '2026-01-01T00:00:00.000Z',
+            };
+            const registryBytes = JSON.stringify({ worktrees: [legacy] });
+            writeFileSync(registryPath, registryBytes);
+            const source = directoryHash(legacyPath);
+            const receipts = directoryHash(receiptRoot);
+            await assert.rejects(executeTool('issue_update', { issueNumber, points: 2 }, {
+                ...execution,
+                identity: 'synthetic-reviewer',
+            }), /identity|author|permitted|allowed/u);
+            const updated = (await executeTool('issue_update', {
+                issueNumber,
+                parentIssueNumber: 11,
+                points: 2,
+                priority: 'High',
+            }, execution));
+            assert.equal(updated.points, 2);
+            assert.equal(updated.priority, 'High');
+            assert.equal(parentIssueNumber, 11);
+            assert.equal(parentPoints, undefined);
+            await assert.rejects(executeTool('issue_develop', { issueNumber }, execution), /ownership witness/u);
+            assert.equal(readFileSync(registryPath, 'utf8'), registryBytes);
+            assert.equal(directoryHash(legacyPath), source);
+            assert.equal(directoryHash(receiptRoot), receipts);
+            assert.equal(existsSync(join(gitCommonDir(root), 'ai-delivery/worktree-owners')), false);
+            return;
+        }
         if (routing.producerOnboarding) {
             assert.equal(existsSync(join(root, 'AGENTS.md')), false);
             const archiveBase = join(root, '.git', 'producer-fixture');
@@ -3941,21 +3983,126 @@ exec "${realGit}" "$@"
         await assert.rejects(finishIssue(context, { issueNumber, prNumber, strategy: 'merge' }), /exact prepared merge intent/u);
         headSha = reviewedHead;
         assert.equal(calls.filter((call) => call === 'git:createCommit').length, 1);
+        if (routing.mergedContinuation) {
+            enableDispatch();
+            const terminal = await executeTool('issue_pr_merge', { issueNumber, prNumber, strategy: 'merge' }, execution);
+            assert.equal(terminal.mergeSha, mergeSha);
+            assert.equal(issue.state, 'open');
+            const previous = getIssueWorktreeStrict(issueNumber, root);
+            assert.equal(previous.status, 'merged');
+            const registryPath = join(root, '.issue-cli', 'worktrees.json');
+            const registryBytes = readFileSync(registryPath);
+            const custody = [
+                'runs@2',
+                'publications',
+                'reviews',
+                'merge-intents',
+                'merge-attempts',
+                'merge-results',
+                'merges',
+            ];
+            const oldReceipts = [];
+            const saveReceipts = (path) => {
+                if (!existsSync(path))
+                    return;
+                for (const entry of readdirSync(path, { withFileTypes: true })) {
+                    const child = join(path, entry.name);
+                    if (entry.isDirectory())
+                        saveReceipts(child);
+                    else
+                        oldReceipts.push({ path: child, bytes: readFileSync(child) });
+                }
+            };
+            for (const name of custody)
+                saveReceipts(join(gitCommonDir(root), 'ai-delivery', name));
+            const ownerPath = join(gitCommonDir(root), 'ai-delivery/worktree-owners');
+            const ownerHash = directoryHash(ownerPath);
+            const publicationPath = join(gitCommonDir(root), 'ai-delivery/publications', String(issueNumber), `${headSha}.json`);
+            const publicationBytes = readFileSync(publicationPath);
+            const { publicationId: _publicationId, ...publicationContent } = JSON.parse(publicationBytes.toString());
+            for (const stale of [
+                { issueNumber: 18 },
+                { headSha: 'c'.repeat(40) },
+                { baseSha: 'c'.repeat(40) },
+                { evidenceId: `sha256:${'c'.repeat(64)}` },
+            ]) {
+                const content = { ...publicationContent, ...stale };
+                const bytes = Buffer.from(JSON.stringify({ ...content, publicationId: digestValue(content) }));
+                writeFileSync(publicationPath, bytes, { mode: 0o600 });
+                await assert.rejects(executeTool('issue_develop', { issueNumber }, execution), /publication.*(?:verified coordinates|historical approved review)/u);
+                assert.deepEqual(readFileSync(registryPath), registryBytes);
+                assert.deepEqual(readFileSync(publicationPath), bytes);
+            }
+            writeFileSync(publicationPath, publicationBytes, { mode: 0o600 });
+            const reviewPath = join(gitCommonDir(root), 'ai-delivery/reviews', String(issueNumber), `${headSha}.json`);
+            const reviewBytes = readFileSync(reviewPath);
+            const { receiptId: _receiptId, artifact: savedArtifact, ...reviewContent } = JSON.parse(reviewBytes.toString());
+            const { artifactId: _artifactId, ...artifactContent } = savedArtifact;
+            const staleArtifact = { ...artifactContent, diffScopeHash: `sha256:${'c'.repeat(64)}` };
+            const staleReview = { ...reviewContent, artifact: { ...staleArtifact, artifactId: digestValue(staleArtifact) } };
+            const staleReviewBytes = Buffer.from(JSON.stringify({ ...staleReview, receiptId: digestValue(staleReview) }));
+            writeFileSync(reviewPath, staleReviewBytes, { mode: 0o600 });
+            await assert.rejects(executeTool('issue_develop', { issueNumber }, execution), /exact historical approved review/u);
+            assert.deepEqual(readFileSync(registryPath), registryBytes);
+            assert.deepEqual(readFileSync(reviewPath), staleReviewBytes);
+            writeFileSync(reviewPath, reviewBytes, { mode: 0o600 });
+            await assert.rejects(developIssue({
+                ...context,
+                config: {
+                    ...config,
+                    roles: {
+                        ...config.roles,
+                        author: { ...config.roles.author, identity: 'other-owner' },
+                    },
+                },
+            }, issueNumber), /same preparing owner/u);
+            issue.state = 'closed';
+            await assert.rejects(executeTool('issue_develop', { issueNumber }, execution), /closed/u);
+            issue.state = 'open';
+            headSha = 'b'.repeat(40);
+            await assert.rejects(executeTool('issue_develop', { issueNumber }, execution), /terminal receipt/u);
+            headSha = reviewedHead;
+            const mergePath = join(gitCommonDir(root), 'ai-delivery/merges', String(issueNumber), `${headSha}.json`);
+            const mergeBytes = readFileSync(mergePath);
+            unlinkSync(mergePath);
+            await assert.rejects(executeTool('issue_develop', { issueNumber }, execution), /exact terminal merge receipt/u);
+            writeFileSync(mergePath, mergeBytes, { mode: 0o600 });
+            assert.deepEqual(readFileSync(registryPath), registryBytes);
+            projectStatus = null;
+            failNextProjectSync = true;
+            await assert.rejects(executeTool('issue_develop', { issueNumber }, execution), /synthetic Project interruption/u);
+            const reactivated = getIssueWorktreeStrict(issueNumber, root);
+            assert.equal(reactivated.status, 'active');
+            assert.equal(reactivated.prNumber, undefined);
+            assert.equal(reactivated.identity, previous.identity);
+            assert.equal(reactivated.createdAt, previous.createdAt);
+            const resumed = await executeTool('issue_develop', { issueNumber }, execution);
+            assert.deepEqual(resumed, { path: previous.path, branch: previous.branch });
+            assert.equal(projectStatus, 'Active');
+            await assert.rejects(verifyIssue({ issueNumber, repoRoot: row.path }), /already-merged issue head/u);
+            for (const saved of oldReceipts) {
+                assert.deepEqual(readFileSync(saved.path), saved.bytes);
+            }
+            assert.equal(directoryHash(ownerPath), ownerHash);
+            // A fresh commit produces new verification slots while the complete prior head remains immutable.
+            writeFileSync(join(row.path, 'change.txt'), 'continued feature\n');
+            git(row.path, 'add', 'change.txt');
+            git(row.path, 'commit', '-qm', 'continue unfinished synthetic issue');
+            const continued = await verifyIssue({ issueNumber, repoRoot: row.path });
+            assert.notEqual(continued.classification.head.sha, reviewedHead);
+            for (const saved of oldReceipts)
+                assert.deepEqual(readFileSync(saved.path), saved.bytes);
+            assert.equal(directoryHash(ownerPath), ownerHash);
+            assert.equal(calls.filter((call) => call === 'git:createCommit').length, 1);
+            return;
+        }
         const blockedRecordPath = join(gitCommonDir(root), 'ai-delivery', 'deliveries.json');
         mkdirSync(blockedRecordPath);
         await assert.rejects(finishIssue(context, { issueNumber, prNumber, strategy: 'merge' }), /Delivery record store is invalid/u);
         assert.equal(existsSync(row.path), false);
         rmSync(blockedRecordPath, { recursive: true });
-        const dispatchClient = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockImplementation(async () => ({
-            ...context.clients,
-            graphql: (async (query, variables) => query.includes('DeliveryDiscovery') ||
-                query.includes('DeliveryRepository') ||
-                query.includes('ProjectDeliveryConfiguration')
-                ? syntheticDiscoveryClients().graphql(query, variables)
-                : graphql(query, variables)),
-        }));
-        restoreDispatchClient = () => dispatchClient.mockRestore();
-        const execution = { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' };
+        const dispatchClient = enableDispatch();
+        execution.runtimeEntryPath = runtimeEntryPath;
         const terminalMerge = (await executeTool('issue_pr_merge', { issueNumber, prNumber, strategy: 'merge' }, execution));
         assert.equal(terminalMerge.mergeSha, git(remote, 'rev-parse', 'refs/heads/main'));
         const finished = (await executeTool('issue_finish', { issueNumber, prNumber, strategy: 'merge' }, execution));
@@ -4019,10 +4166,201 @@ test.each([
     { remote: 'upstream', divergentOrigin: false },
     { remote: 'upstream', divergentOrigin: true },
 ])('synthetic lifecycle finishes with remote $remote and divergent origin $divergentOrigin', syntheticLifecycle, 15_000);
+test('supported develop resumes an open merged issue under the same owner and preserves prior receipts', { timeout: 0 }, async () => syntheticLifecycle({ remote: 'origin', divergentOrigin: false, mergedContinuation: true }));
+test('supported native metadata updates a legacy target without adopting its source or receipts', { timeout: 0 }, async () => syntheticLifecycle({ remote: 'origin', divergentOrigin: false, legacyNativeMetadata: true }));
 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 });
 });
-test.each(['pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary owned symlink teardown preserves observation and %s command evidence', async (mode) => {
+function ordinaryCliRebuildScript(output, mode = 'pass', target = join(output, 'cli.js')) {
+    return `(async () => {
+    const fs = require('node:fs');
+    const trace = event => fs.appendFileSync(${JSON.stringify(join(output, 'events'))}, event + '\\n');
+    trace('command-started'); fs.unlinkSync(${JSON.stringify(target)}); trace('target-removed');
+    if (${JSON.stringify(dirname(target))} !== ${JSON.stringify(output)}) fs.rmdirSync(${JSON.stringify(dirname(target))});
+    if (${JSON.stringify(mode)} === 'limit') fs.writeFileSync(${JSON.stringify(join(output, 'oversized'))}, 'x'.repeat(4096));
+    for (let unit = 0; unit < 32; unit++) {
+      fs.appendFileSync(${JSON.stringify(join(output, 'compiled'))}, 'build-unit\\n');
+      trace('build-unit-' + unit);
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    if (${JSON.stringify(mode)} !== 'absent') {
+      fs.mkdirSync(${JSON.stringify(dirname(target))}, { recursive: true });
+      fs.writeFileSync(${JSON.stringify(target)}, 'rebuilt CLI'); trace('target-restored');
+    }
+  })().catch(error => { console.error(error); process.exitCode = 1; });`;
+}
+test.each(['direct', 'chain', 'directory'])('ordinary bounded rebuild restores its %s CLI target after observable build work', async (shape) => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-cli-rebuild-')));
+    const { root } = await fixture();
+    const target = shape === 'directory' ? join(output, 'dist', 'cli.js') : join(output, 'cli.js');
+    const alias = join(output, 'cli');
+    const events = join(output, 'events');
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, 'original CLI');
+    writeFileSync(join(output, 'unrelated'), 'preserved');
+    if (shape === 'direct')
+        symlinkSync('./cli.js', alias);
+    else {
+        symlinkSync(shape === 'chain' ? './cli.js' : './dist', join(output, 'intermediate'));
+        symlinkSync(shape === 'chain' ? './intermediate' : './intermediate/cli.js', alias);
+    }
+    const observations = [];
+    const duringAbsence = [];
+    const progress = vi.spyOn(process.stderr, 'write').mockImplementation((line) => {
+        observations.push(String(line));
+        if (!existsSync(target) && String(line).includes('sampledNewOutputBytes'))
+            duringAbsence.push(JSON.parse(String(line).slice(String(line).indexOf('{'))));
+        return true;
+    });
+    const script = ordinaryCliRebuildScript(output, 'pass', target);
+    try {
+        const { withRuntimeSetupWriter } = await import('./verification.js');
+        await withRuntimeSetupWriter(root, (runner) => runner.run([process.execPath, '-e', script], {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 8192,
+            outputRoots: [output],
+        }));
+        assert.equal(readFileSync(target, 'utf8'), 'rebuilt CLI');
+        assert.equal(readFileSync(join(output, 'compiled'), 'utf8').split('\n').length, 33);
+        assert.equal(readFileSync(join(output, 'unrelated'), 'utf8'), 'preserved');
+        assert.ok(duringAbsence.some((sample) => (sample.sampledNewOutputBytes ?? 0) > 0));
+        assert.ok(duringAbsence.every((sample) => (sample.sampledAggregateRssBytes ?? 0) > 0));
+    }
+    finally {
+        console.log(JSON.stringify({
+            scenario: 'ordinary-cli-rebuild',
+            shape,
+            firstObservation: observations.find((line) => line.includes('ENOENT')),
+            events: readFileSync(events, 'utf8').trim().split('\n'),
+            targetRestored: existsSync(target),
+            unrelatedPreserved: readFileSync(join(output, 'unrelated'), 'utf8') === 'preserved',
+        }));
+        progress.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test.each([
+    'bytes',
+    'rss',
+    'disk',
+    'fifo',
+    'permission',
+    'identity',
+    'ancestor',
+    'cycle',
+    'chain-identity',
+    'directory-identity',
+    'chain-cycle',
+])('a missing validated target retains complete scan and %s rejection across roots', async (mode) => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-rebuild-boundary-')));
+    const { root } = await fixture();
+    const first = join(output, 'first'), second = join(output, 'second');
+    mkdirSync(first);
+    mkdirSync(second);
+    const directory = join(first, 'dist'), target = join(directory, 'cli.js'), alias = join(first, 'cli');
+    mkdirSync(directory);
+    writeFileSync(target, 'CLI');
+    const intermediate = join(first, 'intermediate');
+    if (mode === 'chain-identity' || mode === 'chain-cycle') {
+        symlinkSync('./dist/cli.js', intermediate);
+        symlinkSync('./intermediate', alias);
+    }
+    else if (mode === 'directory-identity') {
+        symlinkSync('./dist', intermediate);
+        symlinkSync('./intermediate/cli.js', alias);
+    }
+    else
+        symlinkSync('./dist/cli.js', alias);
+    writeFileSync(join(second, 'unrelated'), 'preserved');
+    const released = join(second, 'released');
+    const observations = [];
+    const progress = vi.spyOn(process.stderr, 'write').mockImplementation((line) => {
+        observations.push(String(line));
+        if (String(line).includes('ENOENT'))
+            writeFileSync(released, 'observed');
+        return true;
+    });
+    const script = `(async () => {
+      const fs = require('node:fs'), cp = require('node:child_process');
+      fs.unlinkSync(${JSON.stringify(target)});
+      while (!fs.existsSync(${JSON.stringify(released)})) await new Promise(resolve => setTimeout(resolve, 10));
+      if (${JSON.stringify(mode)} === 'bytes') fs.writeFileSync(${JSON.stringify(join(second, 'oversized'))}, 'x'.repeat(4096));
+      if (${JSON.stringify(mode)} === 'rss') globalThis.retainedBuildMemory = Buffer.alloc(200 * 1024 * 1024, 1);
+      if (${JSON.stringify(mode)} === 'disk') fs.writeFileSync(${JSON.stringify(join(second, 'disk-output'))}, Buffer.alloc(64 * 1024 * 1024, 1));
+      if (${JSON.stringify(mode)} === 'fifo') cp.execFileSync('mkfifo', [${JSON.stringify(join(second, 'unsupported'))}]);
+      if (${JSON.stringify(mode)} === 'permission') {
+        fs.mkdirSync(${JSON.stringify(join(second, 'denied'))});
+        fs.chmodSync(${JSON.stringify(join(second, 'denied'))}, 0);
+      }
+      if (${JSON.stringify(mode)} === 'identity') {
+        fs.unlinkSync(${JSON.stringify(alias)}); fs.writeFileSync(${JSON.stringify(join(first, 'other'))}, 'other');
+        fs.symlinkSync('./other', ${JSON.stringify(alias)});
+      }
+      if (${JSON.stringify(mode)} === 'ancestor') {
+        fs.rmdirSync(${JSON.stringify(directory)}); fs.symlinkSync(${JSON.stringify(second)}, ${JSON.stringify(directory)});
+      }
+      if (${JSON.stringify(mode)} === 'cycle') fs.symlinkSync('./cli.js', ${JSON.stringify(target)});
+      if (${JSON.stringify(mode)} === 'chain-identity') {
+        fs.unlinkSync(${JSON.stringify(intermediate)}); fs.writeFileSync(${JSON.stringify(join(first, 'other'))}, 'other');
+        fs.symlinkSync('./other', ${JSON.stringify(intermediate)});
+      }
+      if (${JSON.stringify(mode)} === 'directory-identity') {
+        fs.unlinkSync(${JSON.stringify(intermediate)}); fs.mkdirSync(${JSON.stringify(join(first, 'other'))});
+        fs.writeFileSync(${JSON.stringify(join(first, 'other', 'cli.js'))}, 'other');
+        fs.symlinkSync('./other', ${JSON.stringify(intermediate)});
+      }
+      if (${JSON.stringify(mode)} === 'chain-cycle') {
+        fs.unlinkSync(${JSON.stringify(intermediate)}); fs.symlinkSync('./cli', ${JSON.stringify(intermediate)});
+      }
+      for (let unit = 0; unit < 32; unit++) {
+        fs.appendFileSync(${JSON.stringify(join(second, 'work'))}, 'unit\\n');
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+      fs.writeFileSync(${JSON.stringify(target)}, 'rebuilt CLI');
+    })().catch(error => { console.error(error); process.exitCode = 1; });`;
+    try {
+        const { withRuntimeSetupWriter } = await import('./verification.js');
+        const disk = (await import('node:fs')).statfsSync(output);
+        await assert.rejects(withRuntimeSetupWriter(root, (runner) => runner.run([process.execPath, '-e', script], {
+            maxAggregateRssBytes: mode === 'rss' ? 128 * 1024 * 1024 : 1_000_000_000,
+            minFreeDiskBytes: mode === 'disk' ? disk.bavail * disk.bsize - 32 * 1024 * 1024 : 1,
+            maxNewOutputBytes: mode === 'disk' ? 128 * 1024 * 1024 : 1024,
+            outputRoots: [first, second],
+        })), (error) => {
+            const message = String(error);
+            assert.match(message, mode === 'bytes'
+                ? /filesystem output.*exceeded/u
+                : mode === 'rss'
+                    ? /aggregate RSS.*exceeded/u
+                    : mode === 'disk'
+                        ? /Free disk fell below/u
+                        : mode === 'fifo'
+                            ? /unsupported file/u
+                            : mode === 'permission'
+                                ? /readdir failed.*EACCES/u
+                                : mode === 'cycle' || mode === 'chain-cycle'
+                                    ? /ELOOP/u
+                                    : /identity changed/u);
+            assert.match(message, /First filesystem observation:.*ENOENT.*Last filesystem observation:/u);
+            assert.doesNotMatch(message, /cleanup failed/u);
+            return true;
+        });
+        assert.ok(observations.some((line) => line.includes('ENOENT')));
+        assert.equal(observations.some((line) => line.includes('"state":"completed"')), false);
+        assert.equal(readFileSync(join(second, 'unrelated'), 'utf8'), 'preserved');
+    }
+    finally {
+        const denied = join(second, 'denied');
+        if (existsSync(denied))
+            chmodSync(denied, 0o700);
+        progress.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test.each(['pass', 'chain-pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary owned symlink teardown preserves observation and %s command evidence', async (mode) => {
     const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-ordinary-teardown-')));
     const { root } = await fixture();
     const controller = new AbortController();
@@ -4031,7 +4369,9 @@ test.each(['pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary
     const release = join(output, 'release');
     writeFileSync(join(output, 'unrelated'), 'preserved');
     writeFileSync(join(output, 'target'), 'x'.repeat(128));
-    symlinkSync('./target', join(output, 'alias'));
+    if (mode === 'chain-pass')
+        symlinkSync('./target', join(output, 'intermediate'));
+    symlinkSync(mode === 'chain-pass' ? './intermediate' : './target', join(output, 'alias'));
     let observedGap = false;
     const observations = [];
     let releaseTimer;
@@ -4044,7 +4384,7 @@ test.each(['pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary
             releaseTimer = setTimeout(() => {
                 if (mode === 'cancel')
                     controller.abort();
-                else if (mode !== 'persistent')
+                else
                     writeFileSync(release, 'continue');
             }, 100);
         }
@@ -4060,7 +4400,10 @@ test.each(['pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary
   trace('target-removed'); fs.writeFileSync(${JSON.stringify(ready)}, 'ready');
   if (${JSON.stringify(mode)} === 'limit') fs.writeFileSync(${JSON.stringify(join(output, 'retained'))}, 'x'.repeat(512));
   while (!fs.existsSync(${JSON.stringify(release)})) await new Promise(resolve => setTimeout(resolve, 10));
-  fs.unlinkSync(${JSON.stringify(join(output, 'alias'))}); trace('alias-removed');
+  if (${JSON.stringify(mode)} !== 'persistent') {
+    fs.unlinkSync(${JSON.stringify(join(output, 'alias'))}); trace('alias-removed');
+    if (${JSON.stringify(mode)} === 'chain-pass') fs.unlinkSync(${JSON.stringify(join(output, 'intermediate'))});
+  }
   process.exitCode = ${mode === 'command-error' ? 7 : 0};
 })().catch(error => { console.error(error); process.exitCode = 1; });`;
     try {
@@ -4071,7 +4414,7 @@ test.each(['pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary
             maxNewOutputBytes: mode === 'limit' ? 256 : 4096,
             outputRoots: [output],
         }, controller.signal));
-        if (mode === 'pass')
+        if (mode === 'pass' || mode === 'chain-pass')
             await run;
         else
             await assert.rejects(run, (error) => {
@@ -4079,7 +4422,7 @@ test.each(['pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary
                 assert.match(message, mode === 'cancel'
                     ? /cancelled/u
                     : mode === 'persistent'
-                        ? /remained unavailable.*First observation:.*ENOENT/u
+                        ? /broken or cyclic symbolic link.*ENOENT/u
                         : mode === 'limit'
                             ? /filesystem output.*exceeded/u
                             : /exit 7/u);
@@ -4108,7 +4451,7 @@ test.each(['pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary
             unrelatedPreserved: true,
             aliasRetained: readdirSync(output).includes('alias'),
         }));
-        assert.deepEqual(readFileSync(events, 'utf8').trim().split('\n'), mode === 'cancel' || mode === 'persistent'
+        assert.deepEqual(readFileSync(events, 'utf8').trim().split('\n'), mode === 'cancel' || mode === 'persistent' || mode === 'limit'
             ? ['command-started', 'target-removed']
             : ['command-started', 'target-removed', 'alias-removed']);
         if (mode === 'cancel' || mode === 'persistent') {
@@ -4133,12 +4476,68 @@ test.each(['pass', 'command-error', 'cancel', 'persistent', 'limit'])('ordinary
         rmSync(output, { recursive: true, force: true });
     }
 });
-test('injected observation deadline rejects a late complete real filesystem retry', async () => {
+test('injected first failed scan duration does not consume the subsequent observation stall window', async () => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-scan-duration-')));
+    const { root } = await fixture();
+    const target = join(output, 'target'), alias = join(output, 'alias'), release = join(output, 'release');
+    writeFileSync(target, 'target');
+    const fs = (await import('node:fs')).default;
+    const actualRealpath = fs.realpathSync;
+    const now = Date.now.bind(Date);
+    let offset = 0, delayed = false, firstObservation;
+    const clock = vi.spyOn(Date, 'now').mockImplementation(() => now() + offset);
+    const scan = vi.spyOn(fs, 'realpathSync').mockImplementation((path, options) => {
+        try {
+            return actualRealpath(path, options);
+        }
+        catch (error) {
+            if (path === alias && !delayed) {
+                delayed = true;
+                offset = 1500;
+            }
+            throw error;
+        }
+    });
+    syncBuiltinESMExports();
+    const progress = vi.spyOn(process.stderr, 'write').mockImplementation((line) => {
+        if (firstObservation === undefined && String(line).includes('ENOENT')) {
+            firstObservation = String(line);
+            unlinkSync(alias);
+            writeFileSync(release, 'finish');
+        }
+        return true;
+    });
+    const script = `(async () => {
+    const fs = require('node:fs'); fs.unlinkSync(${JSON.stringify(target)});
+    fs.symlinkSync('./target', ${JSON.stringify(alias)});
+    while (!fs.existsSync(${JSON.stringify(release)})) await new Promise(resolve => setTimeout(resolve, 10));
+  })().catch(error => { console.error(error); process.exitCode = 1; });`;
+    try {
+        const { withRuntimeSetupWriter } = await import('./verification.js');
+        await withRuntimeSetupWriter(root, (runner) => runner.run([process.execPath, '-e', script], {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 4096,
+            outputRoots: [output],
+        }));
+        assert.ok(delayed);
+        assert.ok(firstObservation);
+        assert.equal(existsSync(alias), false);
+    }
+    finally {
+        progress.mockRestore();
+        scan.mockRestore();
+        syncBuiltinESMExports();
+        clock.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test('injected observation stall rejects a late complete retry for an unvalidated alias', async () => {
     const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-observation-deadline-')));
     const { root } = await fixture();
     const target = join(output, 'target'), alias = join(output, 'alias'), release = join(output, 'release');
     writeFileSync(target, 'target');
-    symlinkSync('./target', alias);
     const now = Date.now.bind(Date);
     let offset = 0;
     let firstObservation;
@@ -4158,6 +4557,7 @@ test('injected observation deadline rejects a late complete real filesystem retr
     });
     const script = `(async () => {
     const fs = require('node:fs'); fs.unlinkSync(${JSON.stringify(target)});
+    fs.symlinkSync('./target', ${JSON.stringify(alias)});
     while (!fs.existsSync(${JSON.stringify(release)})) await new Promise(resolve => setTimeout(resolve, 10));
   })().catch(error => { console.error(error); process.exitCode = 1; });`;
     try {
@@ -4301,6 +4701,90 @@ const child = require('node:child_process').spawnSync(${JSON.stringify(consumer.
 if (child.error) throw child.error;
 process.exit(child.status ?? 1);`;
 }
+test.each(['pass', 'absent', 'limit', 'cancel'])('Node 26 packed public verification preserves CLI rebuild %s behavior', async (mode) => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-packed-rebuild-')));
+    const target = join(output, 'cli.js');
+    writeFileSync(target, 'original CLI');
+    symlinkSync('./cli.js', join(output, 'cli'));
+    writeFileSync(join(output, 'unrelated'), 'preserved');
+    const { root } = await fixture({ personalAuthor: true, firstStageScript: ordinaryCliRebuildScript(output, mode) });
+    try {
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'host-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const clients = syntheticDiscoveryClients();
+        const replies = [];
+        for (const fragment of [
+            'query DeliveryRepository',
+            'query ProjectDeliveryConfiguration',
+            'issueFields(first:',
+            'issueTypes(first:',
+        ])
+            replies.push({ fragment, data: await clients.graphql(fragment) });
+        const consumer = packedNode26Consumer();
+        const result = execFileSync(consumer.executable, [
+            '-e',
+            `(async () => {
+        const assert = require('node:assert/strict'), fs = require('node:fs');
+        assert.equal(process.version, 'v26.2.0');
+        const replies = ${JSON.stringify(replies)};
+        // Only GitHub discovery transport is synthetic; package, writer, scanner and child filesystem are real.
+        globalThis.fetch = async (url, options) => {
+          assert.equal(String(url), 'https://api.github.com/graphql');
+          const query = JSON.parse(options.body).query;
+          const reply = replies.find(reply => query.includes(reply.fragment));
+          assert.ok(reply, 'unexpected synthetic discovery query');
+          return new Response(JSON.stringify({ data: reply.data }), { status: 200, headers: { 'content-type': 'application/json' } });
+        };
+        process.env.AUTHOR_TOKEN = 'synthetic-author-token';
+        const { verifyIssue } = await import('@aviaratech/ai-delivery/agent');
+        const controller = new AbortController();
+        const observations = []; const write = process.stderr.write.bind(process.stderr);
+        process.stderr.write = line => {
+          observations.push(String(line));
+          if (${JSON.stringify(mode)} === 'cancel' && String(line).includes('ENOENT')) controller.abort();
+          return true;
+        };
+        try {
+          const running = verifyIssue({ issueNumber: 17, repoRoot: ${JSON.stringify(row.path)}, signal: controller.signal,
+            resourceBounds: { maxAggregateRssBytes: 1000000000, minFreeDiskBytes: 1,
+              maxNewOutputBytes: ${mode === 'limit' ? 1024 : 8192}, outputRoots: [${JSON.stringify(output)}] } });
+          if (${JSON.stringify(mode)} === 'pass') {
+            const run = await running;
+            assert.ok(run.resources.sampleCount > 0); assert.ok(run.resources.maxSampledNewOutputBytes > 0);
+            assert.equal(fs.readFileSync(${JSON.stringify(target)}, 'utf8'), 'rebuilt CLI');
+            // Compatible completed proof is reused, but the current final filesystem is still strictly scanned.
+            fs.unlinkSync(${JSON.stringify(target)});
+            await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: ${JSON.stringify(row.path)},
+              resourceBounds: { maxAggregateRssBytes: 1000000000, minFreeDiskBytes: 1, maxNewOutputBytes: 8192,
+                outputRoots: [${JSON.stringify(output)}] } }), /broken or cyclic symbolic link/);
+          } else {
+            await assert.rejects(running, error => {
+              assert.match(String(error), ${mode === 'cancel' ? '/cancelled/' : mode === 'limit' ? '/filesystem output.*exceeded/' : '/broken or cyclic symbolic link/'});
+              assert.doesNotMatch(String(error), /cleanup failed/); return true;
+            });
+          }
+          assert.ok(observations.some(line => line.includes('ENOENT')));
+          assert.equal(fs.readFileSync(${JSON.stringify(join(output, 'unrelated'))}, 'utf8'), 'preserved');
+          console.log(JSON.stringify({ scenario: 'packed-node26-cli-rebuild', mode: ${JSON.stringify(mode)},
+            firstObservation: observations.find(line => line.includes('ENOENT')), events: fs.readFileSync(${JSON.stringify(join(output, 'events'))}, 'utf8').trim().split('\\n') }));
+        } finally { controller.abort(); process.stderr.write = write; }
+      })().catch(error => { console.error(error); process.exitCode = 1; });`,
+        ], {
+            cwd: consumer.root,
+            encoding: 'utf8',
+            maxBuffer: 1024 * 1024,
+        });
+        console.log(result.trim());
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
 function filesystemFixtureScript(output, mode, runtime = 'node24') {
     const script = `
 (async () => {