@aviaratech/ai-delivery 0.3.4 → 0.3.6

package/dist/lifecycle.test.js

@@ -13,7 +13,7 @@ import { AI_DELIVERY_MCP_TOOLS } from './mcp/tools.js';
 import { createAiDeliveryMcpServer } from './mcp/index.js';
 import { loadDeliveryConfig, parseDeliveryConfig } from './config/deliveryConfig.js';
 import { digestValue } from './delivery/index.js';
-import { executeTool, resumedIssueUpdate, startTrackedIssue } from './dispatch.js';
+import { contextFor, executeTool, resumedIssueUpdate, startTrackedIssue } from './dispatch.js';
 import { defaultBaseRef, gitCommonDir } from './git.js';
 import * as githubClient from './github/client.js';
 import * as atomicJson from './utils/atomicJson.js';
@@ -329,7 +329,7 @@ export default {
             mkdirSync(dirname(path), { recursive: true });
         }
         writeFileSync(runtimeEntryPath, 'synthetic CLI bytes\n');
-        writeFileSync(packagePath, JSON.stringify({ name: '@aviaratech/ai-delivery', version: '0.1.0' }));
+        writeFileSync(packagePath, JSON.stringify({ name: '@aviaratech/ai-delivery', version: '0.1.0', bin: { 'ai-delivery': './dist/cli.js' } }));
         writeFileSync(mcpLauncherPath, 'synthetic MCP launcher bytes\n');
         writeFileSync(pluginManifestPath, JSON.stringify({ name: 'ai-delivery', packageVersion: '0.1.0', deliveryCapabilityVersion: 2 }));
         const content = {
@@ -351,7 +351,8 @@ export default {
         };
         const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
         mkdirSync(dirname(admissionPath), { recursive: true });
-        writeFileSync(admissionPath, JSON.stringify({ ...content, admissionId: digestValue(content) }), { mode: 0o600 });
+        if (!options.omitRuntimeAdmission)
+            writeFileSync(admissionPath, JSON.stringify({ ...content, admissionId: digestValue(content) }), { mode: 0o600 });
         return { root, counter, secondCounter, failSecond, runtimeEntryPath };
     }
     catch (error) {
@@ -1879,6 +1880,37 @@ test('filesystem output from a sampled detached child crosses its declared root
         rmSync(root, { recursive: true, force: true });
     }
 });
+test('contained npm bin aliases are counted once and target growth still enforces the output bound', async () => {
+    const outside = realpathSync(mkdtempSync(join(tmpdir(), 'ai-delivery-contained-alias-')));
+    const target = join(outside, 'output', 'actual');
+    const { root } = await fixture({
+        firstStageScript: `require('fs').appendFileSync(${JSON.stringify(target)},'x'.repeat(512));`,
+    });
+    try {
+        mkdirSync(dirname(target));
+        writeFileSync(target, 'baseline');
+        symlinkSync('./actual', join(dirname(target), 'alias'));
+        const row = await prepareIssueWorktree({
+            baseRef: 'main',
+            identity: 'synthetic-author',
+            issueNumber: 17,
+            repoRoot: root,
+        });
+        const bounds = {
+            maxAggregateRssBytes: 1_000_000_000,
+            minFreeDiskBytes: 1,
+            maxNewOutputBytes: 600,
+            outputRoots: [dirname(target)],
+        };
+        const run = await verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: bounds });
+        assert.equal(run.resources?.maxSampledNewOutputBytes, 512);
+        await assert.rejects(verifyIssue({ issueNumber: 17, repoRoot: row.path, resourceBounds: { ...bounds, maxNewOutputBytes: 100 } }), /filesystem output.*exceeded/u);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(outside, { recursive: true, force: true });
+    }
+});
 test('a symbolic link in declared output roots fails before publishing sampled output evidence', async () => {
     const { root } = await fixture();
     const outside = mkdtempSync(join(tmpdir(), 'ai-delivery-output-link-'));
@@ -2525,8 +2557,228 @@ test('scratch start derives safe names and reports the requested worktree', asyn
         rmSync(root, { recursive: true, force: true });
     }
 });
+test.each(['direct-develop', 'direct-start', 'develop', 'existing-start', 'new-start', 'scratch', 'standalone'])('development access preflight rejects absent reviewer credentials before %s preparation', async (entry) => {
+    const { root, runtimeEntryPath } = await fixture();
+    const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
+    const admissionBefore = readFileSync(admissionPath, 'utf8');
+    const syntheticClients = githubClient.createDeliveryGitHubClients;
+    const actual = await vi.importActual('./github/client.js');
+    const mocked = vi
+        .spyOn(githubClient, 'createDeliveryGitHubClients')
+        .mockImplementation((input) => input.role === 'reviewer' ? actual.createDeliveryGitHubClients({ ...input, env: {} }) : syntheticClients(input));
+    const execution = { repoRoot: root, runtimeEntryPath, identity: 'synthetic-author' };
+    const tracking = {
+        title: 'Synthetic change',
+        body: '## Outcome\nDeliver a verified change.\n\n## Scope\n- `artifact.txt`\n\n## Acceptance Criteria\n- [ ] Change is verified\n- [ ] Review is recorded\n\n## Verification\nRun `node --version`.',
+        points: 2,
+        develop: true,
+    };
+    try {
+        const run = async () => {
+            if (entry === 'direct-develop' || entry === 'direct-start') {
+                const context = await contextFor(execution, 'develop');
+                return entry === 'direct-develop' ? developIssue(context, 17) : startTrackedIssue(context, tracking);
+            }
+            if (entry === 'develop')
+                return executeTool('issue_develop', { issueNumber: 17 }, execution);
+            if (entry === 'existing-start')
+                return executeTool('issue_start', { issueNumber: 17 }, execution);
+            if (entry === 'new-start')
+                return executeTool('issue_start', tracking, execution);
+            if (entry === 'scratch')
+                return executeTool('issue_start', { scratch: true, request: 'Inspect parser' }, execution);
+            return executeTool('issue_worktree_create', { name: 'scratch-access', branch: 'scratch/access' }, execution);
+        };
+        await assert.rejects(run(), /Missing GitHub App credentials for reviewer role/u);
+        assert.equal(existsSync(join(root, '.worktrees')), false);
+        assert.equal(existsSync(join(root, '.issue-cli', 'worktrees.json')), false);
+        assert.equal(readFileSync(admissionPath, 'utf8'), admissionBefore);
+    }
+    finally {
+        mocked.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test.each(['author-source', 'author-readback', 'same-actor', 'reviewer-repository'])('development access preflight rejects a mismatched %s route before issue reads or writes', async (failure) => {
+    const { root, runtimeEntryPath } = await fixture({ personalAuthor: true });
+    const syntheticClients = githubClient.createDeliveryGitHubClients;
+    const mocked = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockImplementation(async (input) => {
+        const clients = await syntheticClients(input);
+        if (input.role === 'author' && failure === 'author-source')
+            return { ...clients, authSource: 'app' };
+        if (input.role === 'author' && failure === 'author-readback')
+            return { ...clients, authenticatedAuthor: async () => ({ actorLogin: '', credentialIdentity: '' }) };
+        if (input.role === 'reviewer' && failure === 'same-actor')
+            return { ...clients, appActorLogin: async () => 'host-user' };
+        if (input.role === 'reviewer' && failure === 'reviewer-repository')
+            Object.assign(clients.rest.repos, { get: async () => ({ data: { full_name: 'example/other' } }) });
+        return clients;
+    });
+    try {
+        const context = await contextFor({ repoRoot: root, runtimeEntryPath, identity: 'host-author' }, 'develop');
+        await assert.rejects(developIssue(context, 17), {
+            'author-source': /requires the configured author credential/u,
+            'author-readback': /Author GitHub identity readback is incomplete/u,
+            'same-actor': /same GitHub actor/u,
+            'reviewer-repository': /repository readback disagrees/u,
+        }[failure]);
+        assert.equal(existsSync(join(root, '.worktrees')), false);
+        assert.equal(existsSync(join(root, '.git', 'ai-delivery', 'issue-info')), false);
+    }
+    finally {
+        mocked.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('development access preflight permits the configured host author and independent App with unreadable rules', async () => {
+    const { root, runtimeEntryPath } = await fixture({ personalAuthor: true });
+    const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
+    const admissionBefore = readFileSync(admissionPath, 'utf8');
+    try {
+        const row = (await executeTool('issue_worktree_create', { name: 'scratch-host', branch: 'scratch/host' }, { repoRoot: root, runtimeEntryPath, identity: 'host-author' }));
+        assert.equal(row.identity, 'host-author');
+        assert.equal(row.path, join(root, '.worktrees', 'scratch-host'));
+        assert.equal(existsSync(row.path), true);
+        assert.equal(readFileSync(admissionPath, 'utf8'), admissionBefore);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test.each([
+    'direct-develop',
+    'direct-start',
+    'develop',
+    'existing-start',
+    'new-start',
+    'scratch',
+    'standalone',
+    'config-resolve',
+])('development access preflight preserves the explicit personal override for %s', async (entry) => {
+    const { root, runtimeEntryPath } = await fixture();
+    const admissionPath = join(root, '.git', 'ai-delivery', 'runtime-admission.json');
+    const admissionBefore = readFileSync(admissionPath, 'utf8');
+    const factory = githubClient.createDeliveryGitHubClients;
+    const actual = await vi.importActual('./github/client.js');
+    const downstream = new Error('Reached the downstream issue API with the selected author');
+    const selected = vi.spyOn(githubClient, 'createDeliveryGitHubClients').mockImplementation(async (input) => {
+        const clients = await factory(input);
+        if (input.role !== 'author' || input.personalAuth === undefined)
+            return clients;
+        const personal = await actual.createDeliveryGitHubClients({
+            ...input,
+            env: { GH_TOKEN: 'synthetic-development-token' },
+        });
+        Object.assign(clients.rest.issues, {
+            get: async () => {
+                throw downstream;
+            },
+            create: async () => {
+                throw downstream;
+            },
+        });
+        Object.assign(clients.rest, { request: async () => Promise.reject(new Error('Rules unavailable')) });
+        return {
+            ...personal,
+            graphql: clients.graphql,
+            rest: clients.rest,
+            authenticatedAuthor: async () => ({ actorLogin: 'host-user', credentialIdentity: 'user:37' }),
+        };
+    });
+    const execution = { repoRoot: root, runtimeEntryPath, identity: 'personal', personalAuth: true };
+    const tracking = {
+        title: 'Synthetic change',
+        body: '## Outcome\nDeliver a verified change.\n\n## Scope\n- `artifact.txt`\n\n## Acceptance Criteria\n- [ ] Change is verified\n- [ ] Review is recorded\n\n## Verification\nRun `node --version`.',
+        points: 2,
+        develop: true,
+    };
+    try {
+        if (entry === 'config-resolve') {
+            // The prescribed CLI read must inspect this development selection without admission.
+            rmSync(admissionPath);
+            const originalArgv = process.argv;
+            const originalExitCode = process.exitCode;
+            let stdout = '';
+            let stderr = '';
+            let completed = () => { };
+            const output = new Promise((resolve) => {
+                completed = resolve;
+            });
+            const out = vi.spyOn(process.stdout, 'write').mockImplementation((value) => {
+                stdout += String(value);
+                completed();
+                return true;
+            });
+            const err = vi.spyOn(process.stderr, 'write').mockImplementation((value) => {
+                stderr += String(value);
+                completed();
+                return true;
+            });
+            try {
+                process.argv = [
+                    process.execPath,
+                    'ai-delivery',
+                    '--repo-root',
+                    root,
+                    '--identity',
+                    'personal',
+                    '--personal-auth',
+                    'config:resolve',
+                ];
+                await import('./cli.js');
+                await output;
+                assert.equal(stderr, '');
+                const resolved = JSON.parse(stdout);
+                assert.equal(resolved.reviewRoute.author.identity, 'personal');
+                assert.equal(resolved.reviewRoute.author.authSource, 'personal');
+                assert.equal(resolved.reviewRoute.author.actorLogin, 'host-user');
+                assert.equal(resolved.reviewRoute.approvalEligibility, 'unknown');
+                assert.equal(resolved.reviewRoute.rules.visibility, 'unknown');
+                assert.equal(existsSync(admissionPath), false);
+                assert.equal(existsSync(join(root, '.worktrees')), false);
+            }
+            finally {
+                out.mockRestore();
+                err.mockRestore();
+                process.argv = originalArgv;
+                process.exitCode = originalExitCode;
+            }
+        }
+        else if (entry === 'scratch' || entry === 'standalone') {
+            const row = (entry === 'scratch'
+                ? await executeTool('issue_start', { scratch: true, request: 'Inspect parser' }, execution)
+                : await executeTool('issue_worktree_create', { name: 'scratch-override', branch: 'scratch/override' }, execution));
+            if (entry === 'standalone')
+                assert.equal(row.identity, 'personal');
+            assert.equal(existsSync(entry === 'scratch' ? row.worktreePath : row.path), true);
+        }
+        else {
+            const run = async () => {
+                if (entry === 'direct-develop' || entry === 'direct-start') {
+                    const context = await contextFor(execution, 'develop');
+                    return entry === 'direct-develop' ? developIssue(context, 17) : startTrackedIssue(context, tracking);
+                }
+                if (entry === 'develop')
+                    return executeTool('issue_develop', { issueNumber: 17 }, execution);
+                if (entry === 'existing-start')
+                    return executeTool('issue_start', { issueNumber: 17 }, execution);
+                return executeTool('issue_start', tracking, execution);
+            };
+            await assert.rejects(run(), (error) => error === downstream);
+            assert.equal(existsSync(join(root, '.worktrees')), false);
+        }
+        if (entry !== 'config-resolve')
+            assert.equal(readFileSync(admissionPath, 'utf8'), admissionBefore);
+    }
+    finally {
+        selected.mockRestore();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
 test('MCP exposes one implementation surface for native lifecycle commands', () => {
     assert.deepEqual(AI_DELIVERY_MCP_TOOLS.map((tool) => tool.name), [
+        'runtime_stage',
+        'runtime_admit',
         'issue_create',
         'issue_start',
         'issue_update',
@@ -2540,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 },
@@ -2550,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`);
@@ -2585,7 +2850,11 @@ test('MCP request rejects unsupported legacy options before lifecycle dispatch',
     }
 });
 async function syntheticLifecycle(routing) {
-    const { root, runtimeEntryPath } = await fixture(routing);
+    const created = await fixture({ ...routing, omitRuntimeAdmission: routing.producerOnboarding === true });
+    const root = created.root;
+    let runtimeEntryPath = created.runtimeEntryPath;
+    const originalPath = process.env.PATH;
+    let restoreTransport;
     const remoteName = routing.remote;
     assert.equal(defaultBaseRef(root, remoteName), `refs/remotes/${remoteName}/main`);
     const remote = join(root, '.git', 'remote.git');
@@ -2614,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';
@@ -2720,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,
@@ -2743,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: {
@@ -2776,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')) {
@@ -2948,6 +3240,65 @@ async function syntheticLifecycle(routing) {
     };
     let restoreDispatchClient;
     try {
+        if (routing.producerOnboarding) {
+            assert.equal(existsSync(join(root, 'AGENTS.md')), false);
+            const archiveBase = join(root, '.git', 'producer-fixture');
+            const packageSource = join(archiveBase, 'package');
+            mkdirSync(archiveBase);
+            cpSync(dirname(dirname(created.runtimeEntryPath)), packageSource, { recursive: true });
+            cpSync(join(root, '.git/synthetic-runtime/plugin'), join(packageSource, 'plugins/ai-delivery'), {
+                recursive: true,
+            });
+            const archive = join(archiveBase, 'reviewed.tgz');
+            execFileSync('tar', ['-czf', archive, '-C', archiveBase, 'package']);
+            const shimDir = join(archiveBase, 'bin');
+            mkdirSync(shimDir);
+            const npmShim = join(shimDir, 'npm');
+            // Only installer and GitHub transports are synthetic; the public producer and validator are real.
+            writeFileSync(npmShim, `#!${process.execPath}\nconst fs=require('fs'),path=require('path');const args=process.argv.slice(2);if(args[0]!=='install'||!['--omit=dev','--ignore-scripts','--no-audit','--no-fund'].every(x=>args.includes(x)))process.exit(91);const target=path.join(args[args.indexOf('--prefix')+1],'node_modules/@aviaratech/ai-delivery');fs.mkdirSync(path.dirname(target),{recursive:true});fs.cpSync(${JSON.stringify(packageSource)},target,{recursive:true});\n`);
+            chmodSync(npmShim, 0o700);
+            process.env.PATH = `${shimDir}:${originalPath ?? ''}`;
+            const server = createAiDeliveryMcpServer({ repoRoot: root, identity: 'synthetic-author' });
+            const client = new Client({ name: 'unrelated-public-onboarding', version: '1.0.0' });
+            const [ct, st] = InMemoryTransport.createLinkedPair();
+            await server.connect(st);
+            await client.connect(ct);
+            const setup = {
+                expectedSourceCommit: baseSha,
+                expectedConfigDigest: configuration.configDigest,
+                runtimeDirectory: join(root, '.git', 'public-runtime-stage'),
+            };
+            try {
+                const stageResponse = await client.callTool({
+                    name: 'runtime_stage',
+                    arguments: {
+                        ...setup,
+                        authority: 'runtime:stage',
+                        archivePath: archive,
+                        expectedArchiveSha256: sha256(archive),
+                        packageVersion: '0.1.0',
+                    },
+                });
+                assert.equal(stageResponse.isError, undefined);
+                const stage = JSON.parse(stageResponse.content[0].text);
+                const admitted = await client.callTool({
+                    name: 'runtime_admit',
+                    arguments: {
+                        ...setup,
+                        authority: 'runtime:admit',
+                        stageId: stage.stageId,
+                        expectedPriorAdmissionSha256: null,
+                    },
+                });
+                assert.equal(admitted.isError, undefined);
+                runtimeEntryPath = stage.admission.cliPath;
+            }
+            finally {
+                await client.close();
+                await server.close();
+            }
+            await assertDeliveryRuntimeAdmitted({ repoRoot: root, runtimeEntryPath });
+        }
         await assert.rejects(startTrackedIssue(context, { request: 'Unready task', develop: true }), /New issue is not ready/u);
         assert.equal(calls.filter((call) => call === 'issue:create').length, 0);
         const unsized = await createIssue(context, { title: 'Synthetic child', parentIssueNumber: 11 });
@@ -3013,36 +3364,107 @@ 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');
         headSha = git(row.path, 'rev-parse', 'HEAD');
         const run = await verifyIssue({ issueNumber, repoRoot: row.path });
         await assert.rejects(publishPr(context, { issueNumber, body: 'Closes #17' }), /Delivery Impact/);
-        await assert.rejects(publishPr(context, { issueNumber }), /Git push requires the selected author credential token/);
-        // The public push requires a real author App installation token. Bind a synthetic
-        // publication at that external boundary so the remaining public phases run offline.
-        git(row.path, 'push', '-q', remoteName, `${headSha}:refs/heads/issue/17`);
-        const publishEvidence = await createIssuePhaseEvidence({ issueNumber, phase: 'publish', repoRoot: row.path });
-        const publicationContent = {
-            baseSha,
-            evidenceId: publishEvidence.evidenceId,
-            headSha,
-            issueNumber,
-            prNumber,
-            schemaVersion: 'ai-delivery.publication@1',
-        };
-        const publicationPath = join(gitCommonDir(row.path), 'ai-delivery', 'publications', String(issueNumber), `${headSha}.json`);
-        mkdirSync(dirname(publicationPath), { recursive: true });
-        writeFileSync(publicationPath, JSON.stringify({ ...publicationContent, publicationId: digestValue(publicationContent) }), { mode: 0o600 });
-        await updateIssueWorktreeDelivery({
-            branch: row.branch,
-            issueNumber,
-            path: row.path,
-            prNumber,
-            projectRoot: root,
-            status: 'pr-published',
-        });
+        if (routing.producerOnboarding) {
+            const realGit = execFileSync('/usr/bin/which', ['git'], {
+                encoding: 'utf8',
+                env: { ...process.env, PATH: originalPath },
+            }).trim();
+            const shimDir = join(root, '.git/producer-fixture/bin');
+            git(root, 'config', '--unset', `url.${remote}.insteadOf`);
+            const gitShim = join(shimDir, 'git');
+            writeFileSync(gitShim, `#!/bin/sh
+if [ "$1" = -c ] && [ "$2" = credential.helper= ]; then
+  [ "$AI_DELIVERY_GIT_TOKEN" = synthetic-selected-author-token ] || exit 92
+  shift 2
+  operation="$1"; shift
+  [ "$1" = https://github.com/example/widget.git ] || exit 93
+  shift
+  exec "${realGit}" -c credential.helper= "$operation" "${remote}" "$@"
+fi
+if [ "$1" = push ] && [ "$2" = -q ] && [ "$3" = "${remoteName}" ]; then
+  shift 3
+  exec "${realGit}" push -q "${remote}" "$@"
+fi
+exec "${realGit}" "$@"
+`);
+            chmodSync(gitShim, 0o700);
+            const transport = vi.spyOn(githubClient, 'withAuthorGitToken').mockImplementation(async (clients, callback) => {
+                assert.equal(clients.role, 'author');
+                return callback('synthetic-selected-author-token');
+            });
+            restoreTransport = () => transport.mockRestore();
+            const published = await publishPr(context, { issueNumber });
+            assert.equal(published.prNumber, prNumber);
+            assert.equal(published.reviewRoute?.author.actorLogin, 'synthetic-author[bot]');
+            assert.equal(published.reviewRoute?.approvalEligibility, 'unknown');
+        }
+        else {
+            await assert.rejects(publishPr(context, { issueNumber }), /Git push requires the selected author credential token/);
+            // The public push requires a real author App installation token. Bind a synthetic
+            // publication at that external boundary so the remaining public phases run offline.
+            git(row.path, 'push', '-q', remoteName, `${headSha}:refs/heads/issue/17`);
+            const publishEvidence = await createIssuePhaseEvidence({ issueNumber, phase: 'publish', repoRoot: row.path });
+            const publicationContent = {
+                baseSha,
+                evidenceId: publishEvidence.evidenceId,
+                headSha,
+                issueNumber,
+                prNumber,
+                schemaVersion: 'ai-delivery.publication@1',
+            };
+            const publicationPath = join(gitCommonDir(row.path), 'ai-delivery', 'publications', String(issueNumber), `${headSha}.json`);
+            mkdirSync(dirname(publicationPath), { recursive: true });
+            writeFileSync(publicationPath, JSON.stringify({ ...publicationContent, publicationId: digestValue(publicationContent) }), { mode: 0o600 });
+            await updateIssueWorktreeDelivery({
+                branch: row.branch,
+                issueNumber,
+                path: row.path,
+                prNumber,
+                projectRoot: root,
+                status: 'pr-published',
+            });
+        }
         assert.equal((await listPrs(context)).pullRequests[0]?.number, prNumber);
         assert.equal((await prInfo(context, { prNumber })).authorLogin, 'synthetic-author[bot]');
         assert.equal((await prChecks(context, prNumber)).combinedStatus, 'success');
@@ -3188,6 +3610,8 @@ async function syntheticLifecycle(routing) {
         assert.equal(calls.filter((call) => call === 'issue:create').length, beforeTracking + 1);
     }
     finally {
+        restoreTransport?.();
+        process.env.PATH = originalPath;
         restoreDispatchClient?.();
         rmSync(root, { recursive: true, force: true });
     }
@@ -3197,4 +3621,46 @@ 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', { timeout: 0 }, async () => {
+    await syntheticLifecycle({ remote: 'origin', divergentOrigin: false, producerOnboarding: 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-')));
+    try {
+        const output = join(base, 'output');
+        mkdirSync(output);
+        if (kind === 'escape') {
+            writeFileSync(join(base, 'outside'), 'outside');
+            symlinkSync('../outside', join(output, 'alias'));
+        }
+        if (kind === 'broken')
+            symlinkSync('./absent', join(output, 'alias'));
+        if (kind === 'cycle') {
+            symlinkSync('./other', join(output, 'alias'));
+            symlinkSync('./alias', join(output, 'other'));
+        }
+        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: 1024,
+                outputRoots: [output],
+            },
+        }), /escaping|broken|cyclic/u);
+        assert.equal(existsSync(counter), false);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+        rmSync(base, { recursive: true, force: true });
+    }
+});
 //# sourceMappingURL=lifecycle.test.js.map