@aviaratech/ai-delivery 0.3.13 → 0.3.14

package/README.md

@@ -350,7 +350,7 @@ Verification holds one file lease per worktree and durably records its writer an
 
 The `--admit` flag explicitly admits additional resource classes for execution. Compatible complete stages are reused only after their existing stage, artifact, command-output and applicable resource proofs are fully validated, without admitting execution of those classes. Missing or incompatible proof requires the current invocation's admission for the actual stage class before any command runs; corrupt proof remains a hard failure. This permits serial `source_only`, `model`, then `postgres_docker` invocations to reuse prior completed stages while admitting only the next class to execute. Publication creates a draft PR only after exact-head verification; a high-risk policy also requires a prepublication review artifact. Ready promotion and merge require a submitted formal review. Merge checks live blockers, checks, base/head coordinates, and the policy boundary. Repositories may require an exact base/head lease for merge.
 
-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.
+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. Unix-domain IPC sockets inside declared roots are observed as endpoints with zero regular-file payload bytes and remain counted toward the scan entry limit. Regular-file growth in every root is still measured; FIFOs and device entries remain unsupported. 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, a previously validated, unchanged alias may temporarily lose its physical target during a rebuild. The observer checks its current identity and target ancestry, reports the path and errno, and still completes a fresh scan of all physical files in every declared root. It never substitutes an incomplete scan or an earlier byte count. A missing target does not impose a build deadline when complete output accounting remains available. Unvalidated aliases that prevent a complete scan retain the one-second observation-stall window, starting after the first failed scan rather than before it. Cancellation, RSS and disk checks continue. Baseline and final scans remain strict; permanent broken links, cycles, escaping aliases and changed identities fail closed. Failed commands retain captured stdout/stderr in the existing private content-addressed command-output store, with its digest, actual exit status and first/last filesystem observation in the failure diagnostic. Output still buffered inside a killed child is unavailable to the runner.
 
@@ -369,7 +369,7 @@ await withVerificationFilesystemFixture(async () => {
 });
 ```
 
-Bounded verification supplies an inherited, run-owned filesystem coordination capability. The helper serializes the fixture's lifetime against strict scans of every declared root; nested verification and runtime setup join the same boundary. Without an inherited observer the helper runs its callback normally. Malformed, foreign or stale capabilities fail closed. The callback must contain only the negative test and its teardown, and must not start verification while holding the fixture. A queued scan takes priority over new fixtures. RSS, disk, captured-log limits and cancellation continue while the scan waits; waiting observations do not claim a new filesystem measurement. A fixture that fails to release a waiting scan within five seconds is a stalled reader/teardown failure: the command is terminated through the existing identity-checked cleanup, without stealing the live fixture lease. This is an operation-specific observation-stall bound, not a verification runtime limit. Successful commands and fully cached resumes receive fresh strict scans; ordinary or leaked unsupported entries still fail. Abrupt termination can prevent callback teardown; leaked fixtures remain visible and fail subsequent verification. After existing writer recovery confirms command quiescence, only validated abandoned control metadata from that worktree is retired. No output roots, special-file kinds or byte growth are exempted.
+Bounded verification supplies an inherited, run-owned filesystem coordination capability. The helper serializes the fixture's lifetime against strict scans of every declared root; nested verification and runtime setup join the same boundary. Without an inherited observer the helper runs its callback normally. Malformed, foreign or stale capabilities fail closed. The callback must contain only the negative test and its teardown, and must not start verification while holding the fixture. A queued scan takes priority over new fixtures. RSS, disk, captured-log limits and cancellation continue while the scan waits; waiting observations do not claim a new filesystem measurement. A fixture that fails to release a waiting scan within five seconds is a stalled reader/teardown failure: the command is terminated through the existing identity-checked cleanup, without stealing the live fixture lease. This is an operation-specific observation-stall bound, not a verification runtime limit. Successful commands and fully cached resumes receive fresh strict scans; ordinary or leaked unsupported entries still fail. Abrupt termination can prevent callback teardown; leaked fixtures remain visible and fail subsequent verification. After existing writer recovery confirms command quiescence, only validated abandoned control metadata from that worktree is retired. No output roots, unsupported file kinds or regular-file byte growth are exempted.
 
 Bounded stage checkpoints bind the limits and sampled observations. Older unmeasured stages and stages with different limits rerun. Current manifests use `ai-delivery.run@3`, bind the worktree and producer, and live under `runs@2/<worktree-digest>/<head>.json`. Bounded manifests also record limits, sample count, and sampled RSS, output, and disk extrema. Historical run versions 1 and 2 remain historical and are available for merged-issue recovery; current publication requires current-producer verification. `processCoverage: "observed-processes-only"` means a passing aggregate is not proof that every detached descendant was drained. A descendant that detaches and closes inherited pipes between samples can evade observation; a pipe holder that prevents command closure fails with unverified cleanup and no checkpoint. Output roots must be canonical and nonoverlapping. Resolvable aliases such as npm `.bin` links may point only within the declared roots; aliases are not traversed or counted twice, and growth of their physical targets remains measured. Escaping, broken and cyclic links fail closed. Output baselines are retained across retries, including failed stages. They are range scoped: a changed baseline regenerates the measured stage proof. Consumers must confirm their command graph remains observable and declare all relevant output roots; this contract does not assert ownership of undeclared output locations or other concurrent writers.
 

package/dist/lifecycle.test.js

@@ -4,6 +4,7 @@ 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 { createServer } from 'node:net';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { afterAll, test, vi } from 'vitest';
@@ -4701,6 +4702,125 @@ const child = require('node:child_process').spawnSync(${JSON.stringify(consumer.
 if (child.error) throw child.error;
 process.exit(child.status ?? 1);`;
 }
+test.each([
+    ['pass', 'node24'],
+    ['limit', 'node24'],
+    ['cancel', 'node24'],
+    ['error', 'node24'],
+    ['pass', 'node26'],
+    ['limit', 'node26'],
+    ['cancel', 'node26'],
+    ['error', 'node26'],
+])('Unix IPC sockets preserve regular-file output and %s verification on %s', async (mode, runtime) => {
+    const output = realpathSync(mkdtempSync(join(tmpdir(), 'ad-socket-')));
+    const baselineSocket = join(output, 'baseline.sock'), childSocket = join(output, 'child.sock');
+    const artifact = join(output, 'artifact'), unrelated = join(output, 'unrelated');
+    writeFileSync(artifact, 'x'.repeat(512));
+    writeFileSync(unrelated, 'preserved');
+    const server = createServer((socket) => {
+        socket.destroy();
+    });
+    let root;
+    try {
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(baselineSocket, resolve);
+        });
+        const script = `(async () => {
+    const fs = require('node:fs'), net = require('node:net');
+    await new Promise((resolve, reject) => {
+      const socket = net.connect(${JSON.stringify(baselineSocket)});
+      socket.once('error', reject); socket.once('connect', () => { socket.destroy(); resolve(); });
+    });
+    const server = net.createServer();
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(${JSON.stringify(childSocket)}, resolve); });
+    fs.writeFileSync(${JSON.stringify(join(output, 'socket-ready'))}, 'ready');
+    try {
+      for (let unit = 0; unit < 12; unit++) {
+        fs.appendFileSync(${JSON.stringify(artifact)}, 'x'.repeat(256));
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+    } finally { await new Promise(resolve => server.close(resolve)); }
+    if (${JSON.stringify(mode)} === 'error') process.exitCode = 9;
+  })().catch(error => { console.error(error); process.exitCode = 1; });`;
+        ({ root } = await fixture({ personalAuthor: true, firstStageScript: script }));
+        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 = runtime === 'node26'
+            ? packedNode26Consumer()
+            : { executable: process.execPath, root: fileURLToPath(new URL('../', import.meta.url)) };
+        const result = execFileSync(consumer.executable, [
+            '-e',
+            `(async () => {
+      const assert = require('node:assert/strict'), fs = require('node:fs');
+      assert.equal(process.version, ${JSON.stringify(runtime === 'node26' ? 'v26.2.0' : 'v24.21.0')});
+      const replies = ${JSON.stringify(replies)};
+      globalThis.fetch = async (url, options) => {
+        assert.equal(String(url), 'https://api.github.com/graphql');
+        const reply = replies.find(reply => JSON.parse(options.body).query.includes(reply.fragment));
+        assert.ok(reply); 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(${JSON.stringify(runtime === 'node26' ? '@aviaratech/ai-delivery/agent' : new URL('./agent.js', import.meta.url).href)});
+      const controller = new AbortController(), observations = [];
+      const cancellation = ${JSON.stringify(mode)} === 'cancel' ? setInterval(() => {
+        if (fs.existsSync(${JSON.stringify(childSocket)})) {
+          assert.equal(fs.lstatSync(${JSON.stringify(childSocket)}).isSocket(), true);
+          controller.abort();
+        }
+      }, 10) : undefined;
+      const originalWrite = process.stderr.write;
+      process.stderr.write = line => {
+        observations.push(String(line));
+        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 >= 3072);
+          assert.equal(fs.statSync(${JSON.stringify(artifact)}).size, 3584);
+          assert.equal(fs.existsSync(${JSON.stringify(childSocket)}), false);
+          assert.equal(fs.lstatSync(${JSON.stringify(baselineSocket)}).isSocket(), true);
+        } else await assert.rejects(running, error => {
+          assert.match(String(error), ${mode === 'limit' ? '/filesystem output.*exceeded/' : mode === 'cancel' ? '/cancelled/' : '/exit 9/'});
+          assert.doesNotMatch(String(error), /cleanup failed/); return true;
+        });
+        assert.equal(fs.readFileSync(${JSON.stringify(unrelated)}, 'utf8'), 'preserved');
+        console.log(JSON.stringify({ scenario: 'unix-ipc-socket', runtime: process.version, mode: ${JSON.stringify(mode)},
+          sampleCount: observations.length, unrelatedPreserved: true }));
+      } finally { clearInterval(cancellation); controller.abort(); process.stderr.write = originalWrite; }
+    })().catch(error => { console.error(error); process.exitCode = 1; });`,
+        ], { cwd: consumer.root, encoding: 'utf8', maxBuffer: 1024 * 1024 });
+        console.log(result.trim());
+        assert.ok(existsSync(join(output, 'socket-ready')));
+    }
+    finally {
+        if (server.listening)
+            await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+        assert.equal(existsSync(baselineSocket), false);
+        if (root !== undefined)
+            rmSync(root, { recursive: true, force: true });
+        rmSync(output, { recursive: true, force: true });
+        assert.equal(existsSync(output), false);
+    }
+});
 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');