@aviaratech/ai-delivery 0.3.8 → 0.3.9

package/README.md

@@ -327,6 +327,8 @@ The `--admit` flag explicitly admits additional resource classes. Publication cr
 
 For a bounded run, pass `--max-aggregate-rss-bytes`, `--min-free-disk-bytes`, and optionally `--max-new-output-bytes` with one or more `--output-root` paths to `verify`. `issue_verify` accepts the same values in `resourceBounds`. RSS is sampled across the observed child process tree, including observed detached descendants; free disk is checked before commands and during execution on the worktree and declared output filesystems. Positive file-size growth is sampled under the declared roots, with previously measured completed stages carried across a resume. The caller must declare every output root relevant to its allowance; aliases must resolve within those roots. The roots are relative to the issue worktree unless absolute. Output growth is separate from the 8 MiB captured stdout/stderr limit. Resource limits are opt in and do not impose a total runtime deadline.
 
+During a running command, an `ENOENT` from symlink resolution can reflect ordinary tree removal. The observer reports the first path and errno and retries complete scans for at most one second; it never accepts a partial scan or resets that observation-stall window. Cancellation interrupts the wait, and RSS and disk checks continue. Baseline and final scans remain strict; persistent broken links, cycles and escaping aliases fail closed. Failed commands retain captured stdout/stderr in the existing private content-addressed command-output store, with its digest and the actual exit status in the failure diagnostic. Output still buffered inside a killed child is unavailable to the runner.
+
 Real filesystem-negative tests can use `withVerificationFilesystemFixture` from `@aviaratech/ai-delivery` (or its `agent` export):
 
 ```js

package/dist/lifecycle.test.js

@@ -3797,6 +3797,170 @@ test.each([
 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) => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-ordinary-teardown-')));
+    const { root } = await fixture();
+    const controller = new AbortController();
+    const events = join(output, 'events');
+    const ready = join(output, 'ready');
+    const release = join(output, 'release');
+    writeFileSync(join(output, 'unrelated'), 'preserved');
+    writeFileSync(join(output, 'target'), 'x'.repeat(128));
+    symlinkSync('./target', join(output, 'alias'));
+    let observedGap = false;
+    const observations = [];
+    let releaseTimer;
+    const progress = vi.spyOn(process.stderr, 'write').mockImplementation((line) => {
+        if (String(line).includes('ENOENT'))
+            observations.push(String(line));
+        if (!observedGap && existsSync(ready) && String(line).includes('sampledAggregateRssBytes')) {
+            observedGap = true;
+            // Synchronize real removal with the sample preceding the synchronous filesystem scan.
+            releaseTimer = setTimeout(() => {
+                if (mode === 'cancel')
+                    controller.abort();
+                else if (mode !== 'persistent')
+                    writeFileSync(release, 'continue');
+            }, 100);
+        }
+        return true;
+    });
+    const script = `
+(async () => {
+  const fs = require('node:fs');
+  const trace = value => fs.appendFileSync(${JSON.stringify(events)}, value + '\\n');
+  trace('command-started');
+  if (['command-error', 'persistent'].includes(${JSON.stringify(mode)})) console.error('synthetic buffered preparation failure');
+  fs.unlinkSync(${JSON.stringify(join(output, 'target'))});
+  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');
+  process.exitCode = ${mode === 'command-error' ? 7 : 0};
+})().catch(error => { console.error(error); process.exitCode = 1; });`;
+    try {
+        const { withRuntimeSetupWriter } = await import('./verification.js');
+        const run = withRuntimeSetupWriter(root, (runner) => runner.run([process.execPath, '-e', script], {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: mode === 'limit' ? 256 : 4096,
+            outputRoots: [output],
+        }, controller.signal));
+        if (mode === 'pass')
+            await run;
+        else
+            await assert.rejects(run, (error) => {
+                const message = String(error);
+                assert.match(message, mode === 'cancel'
+                    ? /cancelled/u
+                    : mode === 'persistent'
+                        ? /remained unavailable.*First observation:.*ENOENT/u
+                        : mode === 'limit'
+                            ? /filesystem output.*exceeded/u
+                            : /exit 7/u);
+                assert.doesNotMatch(message, /cleanup failed/u);
+                assert.ok(message.includes(join(output, 'alias')));
+                assert.match(message, /ENOENT/u);
+                if (mode === 'command-error' || mode === 'persistent') {
+                    const digest = /Command output (sha256:[a-f0-9]{64})/u.exec(message)?.[1];
+                    assert.ok(digest);
+                    assert.match(readFileSync(join(root, '.git', 'ai-delivery', 'verification@1', 'command-output', `${digest.slice(7)}.bin`), 'utf8'), /synthetic buffered preparation failure/u);
+                }
+                return true;
+            });
+        assert.ok(observedGap);
+        assert.ok(observations.some((line) => {
+            const observation = JSON.parse(line.slice(line.indexOf('{')));
+            return observation.reason.includes(join(output, 'alias'));
+        }));
+        assert.equal(readFileSync(join(output, 'unrelated'), 'utf8'), 'preserved');
+        console.log(JSON.stringify({
+            scenario: 'ordinary-owned-symlink-teardown',
+            mode,
+            firstObservation: JSON.parse(observations[0].slice(observations[0].indexOf('{')))
+                .reason,
+            events: readFileSync(events, 'utf8').trim().split('\n'),
+            unrelatedPreserved: true,
+            aliasRetained: readdirSync(output).includes('alias'),
+        }));
+        assert.deepEqual(readFileSync(events, 'utf8').trim().split('\n'), mode === 'cancel' || mode === 'persistent'
+            ? ['command-started', 'target-removed']
+            : ['command-started', 'target-removed', 'alias-removed']);
+        if (mode === 'cancel' || mode === 'persistent') {
+            await assert.rejects(withRuntimeSetupWriter(root, (runner) => runner.run([process.execPath, '-e', ''], {
+                maxAggregateRssBytes: 1_000_000_000,
+                minFreeDiskBytes: 1,
+                maxNewOutputBytes: 4096,
+                outputRoots: [output],
+            })), (error) => {
+                assert.ok(String(error).includes(join(output, 'alias')));
+                assert.match(String(error), /ENOENT/u);
+                return true;
+            });
+        }
+    }
+    finally {
+        controller.abort();
+        if (releaseTimer !== undefined)
+            clearTimeout(releaseTimer);
+        progress.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
+test('injected observation deadline rejects a late complete real filesystem retry', 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;
+    let advance;
+    const clock = vi.spyOn(Date, 'now').mockImplementation(() => now() + offset);
+    const progress = vi.spyOn(process.stderr, 'write').mockImplementation((line) => {
+        if (firstObservation === undefined && String(line).includes('ENOENT')) {
+            firstObservation = String(line);
+            advance = setTimeout(() => {
+                // This test injects only the deadline. Alias removal and the subsequent complete scan are real.
+                unlinkSync(alias);
+                offset = 1100;
+                writeFileSync(release, 'finish');
+            }, 0);
+        }
+        return true;
+    });
+    const script = `(async () => {
+    const fs = require('node:fs'); fs.unlinkSync(${JSON.stringify(target)});
+    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 assert.rejects(withRuntimeSetupWriter(root, (runner) => runner.run([process.execPath, '-e', script], {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 4096,
+            outputRoots: [output],
+        })), (error) => {
+            assert.match(String(error), /remained unavailable for 1 second/u);
+            assert.ok(String(error).includes(alias));
+            assert.match(String(error), /ENOENT/u);
+            assert.doesNotMatch(String(error), /cleanup failed/u);
+            return true;
+        });
+        assert.ok(firstObservation);
+        assert.equal(readdirSync(output).includes('alias'), false);
+    }
+    finally {
+        if (advance !== undefined)
+            clearTimeout(advance);
+        progress.mockRestore();
+        clock.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+    }
+});
 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-')));