@aviaratech/ai-delivery 0.3.23 → 0.3.25

package/dist/dispatch.js

@@ -1,37 +1,13 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { loadDeliveryConfig, loadDeliverySettings, readDeliveryOverrides } from './config/deliveryConfig.js';
-import { resolveRepoFromRemote } from './github/repo.js';
-import { assertRepositoryClassificationCurrent } from './delivery/index.js';
+import { loadDeliverySettings } from './config/deliveryConfig.js';
+import { resolveCheckout, resolveRepoFromRemote } from './github/repo.js';
 import { DeliveryError } from './errors.js';
-import { assertClean, defaultBaseRef, gitCommonDir, gitExitCode, gitRoot, primaryGitRoot } from './git.js';
-import { createDeliveryGitHubClients } from './github/client.js';
+import { digestValue } from './delivery/common.js';
 import { evaluateCommandIdentityPolicy } from './github/commandIdentityPolicy.js';
-import { resolveNativeRelationshipTargets } from './github/relationships.js';
-import { cachedIssueInfo, CreatedTrackingIssueError, createIssue, commentIssue, developIssue, issueInfo, listIssues, journalIssueStart, loadDeliveryContext, readyCheck, resumeCreatedIssue, updateIssue, } from './issue.js';
-import { finishIssue, mergePr, preflightReviewRoute, prInfo, publishPr, submitFormalReview } from './pr.js';
-import { parseReviewArtifact, reviewArtifactApproval, savePrepublicationArtifact } from './review.js';
-import { evaluateAgentReadiness } from './services/agentReadinessService.js';
-import { assertDeliveryRuntimeAdmitted } from './services/deliveryAdmission.js';
-import { assertIssueWorktreeTransitionAdmission, getIssueWorktreeStrict, listWorktreesStrict, } from './services/worktreeRegistry.js';
+import { CreatedTrackingIssueError, createIssue, commentIssue, issueInfo, listIssues, journalIssueStart, loadDeliveryContext, readyCheck, resumeCreatedIssue, startIssueBranch, updateIssue, } from './issue.js';
+import { finishIssue, mergePr, prInfo, publishPr, submitFormalReview } from './pr.js';
 import { applyWorktreeTransition, inspectWorktreeTransition, } from './worktreeTransition.js';
-import { createIssuePhaseEvidence, loadVerifiedRun, verifyIssue, } from './verification.js';
 import { stageRuntime, admitRuntime } from './setup.js';
-import { prepareStandaloneWorktree } from './worktree.js';
 import { getAiDeliveryMcpTool } from './mcp/tools.js';
-const MUTATING_TOOLS = new Set([
-    'issue_comment',
-    'issue_create',
-    'issue_start',
-    'issue_update',
-    'issue_develop',
-    'issue_verify',
-    'issue_pr_create',
-    'issue_pr_review',
-    'issue_pr_merge',
-    'issue_finish',
-    'issue_worktree_create',
-    'issue_worktree_transition_apply',
-]);
 function requiredNumber(input, key) {
     const value = input[key];
     if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0)
@@ -47,502 +23,235 @@ function requireString(input, key) {
         throw new DeliveryError(`${key} is required.`);
     return value;
 }
-/** @internal Preserve every accepted tracking field when completing a partially created issue. */
+/** Preserve every accepted tracking field when completing a partially created issue. */
 export function resumedIssueUpdate(input) {
-    return {
-        issueNumber: requiredNumber(input, 'issueNumber'),
-        ...(input.body === undefined ? {} : { body: requireString(input, 'body') }),
-        ...(input.issueType === undefined ? {} : { issueType: requireString(input, 'issueType') }),
-        ...(input.points === undefined ? {} : { points: Number(input.points) }),
-        ...(input.priority === undefined ? {} : { priority: requireString(input, 'priority') }),
-        ...(input.title === undefined ? {} : { title: requireString(input, 'title') }),
-        ...(input.labels === undefined ? {} : { labels: input.labels }),
-        ...(input.milestone === undefined ? {} : { milestone: Number(input.milestone) }),
-        ...(input.parentIssueNumber === undefined ? {} : { parentIssueNumber: Number(input.parentIssueNumber) }),
-        ...(input.blockedBy === undefined ? {} : { blockedBy: input.blockedBy }),
-    };
+    const { issueNumber, request: _request, requestId: _requestId, repo: _repo, resumeCreated: _resume, branch: _branch, ...fields } = input;
+    return { ...fields, issueNumber: requiredNumber({ issueNumber }, 'issueNumber') };
 }
-async function identityFor(input, commandName) {
-    const config = await loadDeliverySettings(gitRoot(input.repoRoot));
-    const identity = input.identity ?? '';
+export async function contextFor(input, commandName, role = 'author') {
+    const settings = await loadDeliverySettings();
+    const identity = input.identity ?? settings.roles[role].identity;
     const policy = evaluateCommandIdentityPolicy({
         commandName,
-        deliveryConfig: config,
+        deliveryConfig: settings,
         identity,
         ...(input.personalAuth === undefined ? {} : { personalAuth: input.personalAuth }),
     });
     if (policy.error)
         throw new DeliveryError(policy.error);
-    return identity || config.roles.author.identity;
-}
-function assertRepositorySelector(input, execution) {
-    const selector = input.repo ?? execution.repo;
-    if (selector === undefined)
-        return;
-    const root = gitRoot(execution.repoRoot);
-    const selected = resolveRepoFromRemote(root, readDeliveryOverrides(root).overrides.remote);
-    const configured = `${selected.owner}/${selected.repo}`;
-    if (typeof selector !== 'string' || selector.toLowerCase() !== configured.toLowerCase()) {
-        throw new DeliveryError('Repository selector must match the configured repository for this Git checkout.');
-    }
-}
-export async function contextFor(input, commandName, role = 'author') {
-    assertRepositorySelector({}, input);
-    const identity = await identityFor(input, commandName);
     return loadDeliveryContext({
         identity,
-        ...(input.personalAuth === undefined ? {} : { personalAuth: input.personalAuth }),
         repoRoot: input.repoRoot,
         role,
+        ...(input.repo === undefined ? {} : { repository: input.repo }),
+        ...(input.personalAuth === undefined ? {} : { personalAuth: input.personalAuth }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
 }
-function sourceRootFor(name, input, execution) {
-    if (name !== 'issue_verify' &&
-        name !== 'issue_pr_create' &&
-        name !== 'issue_pr_review' &&
-        name !== 'issue_pr_merge' &&
-        name !== 'issue_finish' &&
-        !(name === 'issue_pr_info' && input.issueNumber !== undefined))
-        return undefined;
-    const primary = primaryGitRoot(execution.repoRoot);
-    const requested = gitRoot(execution.repoRoot);
-    const issueNumber = requiredNumber(input, 'issueNumber');
-    if (name === 'issue_finish' &&
-        !listWorktreesStrict(primary).some((row) => row.type === 'issue' && row.issueNumber === issueNumber))
-        return primary;
-    const row = getIssueWorktreeStrict(issueNumber, primary);
-    if (requested !== primary && requested !== row.path) {
-        throw new DeliveryError('Source-bound operations require the primary or exact registered issue checkout.');
-    }
-    // Terminal owners validate retained immutable receipts and the remote result.
-    // A removed merged checkout must not be imported or reconstructed here.
-    if ((name === 'issue_finish' || name === 'issue_pr_merge') && row.status === 'merged' && !existsSync(row.path)) {
-        return primary;
-    }
-    if (gitCommonDir(row.path) !== gitCommonDir(primary)) {
-        throw new DeliveryError('Registered issue source must belong to the primary Git repository.');
-    }
-    assertClean(row.path);
-    return row.path;
-}
-/** @internal Keep CLI and MCP start routing on the same native lifecycle owner. */
-export async function startTrackedIssue(context, input, runtimeEntryPath) {
-    const knownIssue = input.issueNumber === undefined ? undefined : requiredNumber(input, 'issueNumber');
-    if (input.resumeCreated === true && (knownIssue === undefined || typeof input.develop !== 'boolean')) {
-        throw new DeliveryError('Resume of a known created issue requires issueNumber and an explicit develop boolean.');
-    }
-    if (knownIssue !== undefined && input.resumeCreated !== true) {
-        const row = await developIssue(context, knownIssue, runtimeEntryPath);
-        const title = (await issueInfo(context, knownIssue)).title;
-        return {
-            issueNumber: knownIssue,
-            mode: 'existing-issue',
-            title,
-            branch: row.branch,
-            path: row.path,
-            worktreePath: row.path,
-        };
-    }
-    const request = optionalString(input, 'request');
-    const title = optionalString(input, 'title') ?? requireString(input, 'request');
-    const points = input.points === undefined ? 2 : requiredNumber(input, 'points');
-    const tracking = {
-        body: optionalString(input, 'body') ?? request ?? title,
-        title,
-        points,
-        ...(input.issueType === undefined ? {} : { issueType: requireString(input, 'issueType') }),
-        ...(input.priority === undefined ? {} : { priority: requireString(input, 'priority') }),
-        ...(input.blockedBy === undefined ? {} : { blockedBy: input.blockedBy }),
-        ...(input.labels === undefined ? {} : { labels: input.labels }),
-        ...(input.milestone === undefined ? {} : { milestone: Number(input.milestone) }),
-        ...(input.parentIssueNumber === undefined ? {} : { parentIssueNumber: Number(input.parentIssueNumber) }),
-    };
-    if (input.develop === true)
-        await preflightStartDevelopment(context, tracking);
-    const repository = `${context.repo.owner}/${context.repo.repo}`;
-    const createdNotStarted = (createdIssue, phase, error) => ({
-        schemaVersion: 'ai-delivery.issue-start-registration@1',
+/** GitHub owns branch linkage; hosts own worktree preparation. */
+export async function startTrackedIssue(context, input) {
+    let number = input.issueNumber === undefined ? undefined : requiredNumber(input, 'issueNumber');
+    let created;
+    const registration = (phase, error) => ({
         status: 'created-not-started',
-        provider: 'github',
-        repository,
-        identity: context.config.roles.author.identity,
-        createdIssue,
+        repository: context.config.repository,
+        createdIssue: created,
         failure: { phase, message: error instanceof Error ? error.message : String(error) },
         safeResume: {
             tool: 'issue_start',
-            arguments: {
-                ...tracking,
-                ...(input.repo === undefined ? {} : { repo: input.repo }),
-                issueNumber: createdIssue.number,
-                develop: input.develop === true,
-                resumeCreated: true,
-            },
+            arguments: { ...input, repo: context.config.repository, issueNumber: number, resumeCreated: true },
         },
     });
-    let created;
-    if (knownIssue !== undefined) {
-        const existing = (await context.clients.rest.issues.get({ ...context.repo, issue_number: knownIssue })).data;
-        if (existing.number !== knownIssue || 'pull_request' in existing) {
-            throw new DeliveryError('Known-created issue readback disagrees with the requested issue.');
-        }
-        created = { number: existing.number, title: existing.title, url: existing.html_url };
-        try {
-            await resumeCreatedIssue(context, resumedIssueUpdate(input));
-        }
-        catch (error) {
-            return createdNotStarted(created, 'tracking', error);
+    if (number === undefined) {
+        const title = optionalString(input, 'title') ?? requireString(input, 'request');
+        const tracking = {
+            ...input,
+            title,
+            body: optionalString(input, 'body') ?? optionalString(input, 'request') ?? title,
+        };
+        const intent = digestValue(Object.fromEntries(Object.entries({
+            title,
+            body: tracking.body,
+            issueType: tracking.issueType,
+            points: tracking.points,
+            priority: tracking.priority,
+            labels: tracking.labels,
+            blockedBy: tracking.blockedBy,
+            parentIssueNumber: tracking.parentIssueNumber,
+            milestone: tracking.milestone,
+            branch: input.branch,
+        }).filter(([, value]) => value !== undefined)));
+        const requestKey = optionalString(input, 'requestId') ?? intent;
+        const marker = `<!-- ai-delivery-start: ${digestValue({ repository: context.config.repository.toLowerCase(), requestKey })} -->`;
+        tracking.body = `${tracking.body}\n\n<!-- ai-delivery-start-intent: ${intent} -->\n${marker}`;
+        let completed = false;
+        const matches = [];
+        for (let page = 1; page <= 20; page++) {
+            const batch = (await context.clients.rest.issues.listForRepo({ ...context.repo, state: 'all', page, per_page: 100 })).data;
+            matches.push(...batch.filter((value) => !('pull_request' in value) && value.body?.includes(marker)));
+            if (batch.length < 100) {
+                completed = true;
+                break;
+            }
         }
-    }
-    else {
+        if (!completed)
+            throw new DeliveryError('Issue-start retry search exceeds the bounded readback window; select a known issue number.');
+        if (matches.length > 1)
+            throw new DeliveryError('Conflicting issues claim the same start request.');
+        const prior = matches[0];
+        if (prior && (prior.title !== title || prior.body !== tracking.body || prior.state !== 'open'))
+            throw new DeliveryError('Prior issue-start request conflicts with the requested intent or state.');
         try {
-            created = (await createIssue(context, tracking)).created;
+            if (prior) {
+                created = { number: prior.number, title: prior.title, url: prior.html_url };
+                number = prior.number;
+                await resumeCreatedIssue(context, { ...tracking, issueNumber: number });
+            }
+            else {
+                created = (await createIssue(context, tracking)).created;
+                number = created.number;
+            }
         }
         catch (error) {
-            if (input.develop === true && error instanceof CreatedTrackingIssueError) {
-                return createdNotStarted(error.created, 'tracking', error);
+            if (error instanceof CreatedTrackingIssueError) {
+                created = error.created;
+                number = created.number;
             }
-            throw error;
+            else if (!created)
+                throw error;
+            return registration('tracking', error);
         }
     }
-    if (input.develop === true) {
+    else if (input.resumeCreated === true) {
+        const issue = (await context.clients.rest.issues.get({ ...context.repo, issue_number: number })).data;
+        if (issue.number !== number || 'pull_request' in issue)
+            throw new DeliveryError('Known-created issue readback disagrees.');
+        created = { number, title: issue.title, url: issue.html_url };
         try {
-            const row = await developIssue(context, created.number, runtimeEntryPath);
-            return {
-                schemaVersion: 'ai-delivery.issue-start-registration@1',
-                status: 'started',
-                provider: 'github',
-                repository,
-                identity: context.config.roles.author.identity,
-                issue: created,
-                branch: row.branch,
-                worktreePath: row.path,
-            };
+            await resumeCreatedIssue(context, resumedIssueUpdate(input));
         }
         catch (error) {
-            return createdNotStarted(created, 'development', error);
+            return registration('tracking', error);
         }
     }
     try {
-        await journalIssueStart(context, created.number);
+        const branch = await startIssueBranch(context, number, optionalString(input, 'branch'));
+        await journalIssueStart(context, number);
+        return {
+            issueNumber: number,
+            repository: context.config.repository,
+            branch: branch.branch,
+            headSha: branch.headSha,
+            reused: branch.reused,
+        };
     }
     catch (error) {
-        return createdNotStarted(created, 'journal', error);
-    }
-    return { issueNumber: created.number, issueUrl: created.url, mode: 'created-issue', title: created.title };
-}
-async function preflightStartDevelopment(context, tracking) {
-    const targets = await resolveNativeRelationshipTargets({
-        blockers: tracking.blockedBy ?? [],
-        ...(tracking.parentIssueNumber === undefined ? {} : { parentIssueNumber: tracking.parentIssueNumber }),
-        repo: context.repo,
-        rest: context.clients.rest,
-    });
-    const readiness = evaluateAgentReadiness({
-        blockedBy: targets.unresolvedBlockers,
-        body: tracking.body ?? '',
-        ...(tracking.points === undefined ? {} : { points: tracking.points }),
-        repoRoot: context.root,
-        title: tracking.title,
-    });
-    if (!readiness.ready) {
-        throw new DeliveryError(`New issue is not ready: ${readiness.failures.map((failure) => failure.message).join('; ')}`);
-    }
-    listWorktreesStrict(context.root);
-    if (gitExitCode(context.root, 'rev-parse', '--verify', defaultBaseRef(context.root, context.configuration?.remote)) !==
-        0) {
-        throw new DeliveryError('Default base ref is missing before tracked issue creation.');
+        if (created)
+            return registration('branch-or-journal', error);
+        throw error;
     }
-    await preflightReviewRoute(context, undefined, undefined, 'development');
-}
-function scratchStart(input, execution, identity, remote) {
-    const title = (optionalString(input, 'title') ?? requireString(input, 'request'))
-        .replace(/\s+/gu, ' ')
-        .trim()
-        .slice(0, 90)
-        .trim();
-    const branchOverride = optionalString(input, 'branch');
-    const source = (branchOverride ?? optionalString(input, 'request') ?? title).replace(/\//gu, '-');
-    const slug = source
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/gu, '-')
-        .replace(/^-+|-+$/gu, '')
-        .slice(0, 56)
-        .replace(/-+$/gu, '') || 'scratch';
-    const branch = branchOverride ?? `scratch/${slug}`;
-    const name = `scratch-${slug}`;
-    return prepareStandaloneWorktree({
-        branch,
-        identity,
-        name,
-        repoRoot: execution.repoRoot,
-        ...(remote ? { remote } : {}),
-    }).then((row) => ({
-        mode: 'scratch',
-        title,
-        branch: row.branch,
-        worktreePath: row.path,
-    }));
 }
 export async function executeTool(name, raw, execution) {
     const definition = getAiDeliveryMcpTool(name);
     if (!definition)
         throw new DeliveryError(`Unknown ai-delivery tool ${name}.`);
-    const input = definition.inputSchema.parse(raw);
-    assertRepositorySelector(input, execution);
-    if (name === 'runtime_stage' || name === 'runtime_admit') {
-        const setup = {
-            ...input,
-            repoRoot: execution.repoRoot,
-            identity: optionalString(input, 'identity') ?? execution.identity ?? '',
-            ...(execution.personalAuth === undefined ? {} : { personalAuth: execution.personalAuth }),
-            ...(execution.signal === undefined ? {} : { signal: execution.signal }),
-        };
-        return name === 'runtime_stage'
-            ? stageRuntime(setup)
-            : admitRuntime(setup);
-    }
-    if (name === 'issue_info' && input.cached === true)
-        return cachedIssueInfo(execution.repoRoot, requiredNumber(input, 'issueNumber'));
-    const commands = {
-        issue_comment: 'comment',
-        runtime_stage: 'runtime:stage',
-        runtime_admit: 'runtime:admit',
-        issue_create: 'create',
-        issue_start: 'start',
-        issue_update: 'update',
-        issue_info: 'info',
-        issue_list: 'list',
-        issue_search: 'search',
-        issue_ready_check: 'ready:check',
-        issue_develop: 'develop',
-        issue_verify: 'verify',
-        issue_pr_create: 'pr:create',
-        issue_pr_info: 'pr:info',
-        issue_pr_review: 'pr:review',
-        issue_pr_merge: 'pr:merge',
-        issue_finish: 'finish',
-        issue_worktree_create: 'worktree:create',
-        issue_worktree_transition_inspect: 'worktree:transition:inspect',
-        issue_worktree_transition_apply: 'worktree:transition:apply',
-    };
-    const requestedIdentity = name === 'issue_pr_review' ? optionalString(input, 'identity') : undefined;
-    const selectedExecution = requestedIdentity === undefined ? execution : { ...execution, identity: requestedIdentity };
-    const sourceRoot = sourceRootFor(name, input, execution);
-    const context = await contextFor(sourceRoot === undefined ? selectedExecution : { ...selectedExecution, repoRoot: sourceRoot }, commands[name], name === 'issue_pr_review' ? 'reviewer' : 'author');
-    let controllerConfiguration = context.configuration;
-    if (sourceRoot !== undefined) {
-        const primary = primaryGitRoot(execution.repoRoot);
-        const settings = await loadDeliverySettings(primary);
-        if (settings.repository.toLowerCase() !== context.config.repository.toLowerCase()) {
-            throw new DeliveryError('Registered issue source and primary controller must select the same repository.');
+    const { repo: selected, ...input } = definition.inputSchema.parse(raw);
+    if (name === 'issue_finish' && input.nonClosing === true)
+        throw new DeliveryError('Non-closing delivery cannot finish or close its retained issue.');
+    if (selected !== undefined && execution.repo !== undefined && selected !== execution.repo)
+        throw new DeliveryError('Tool and execution repository selectors disagree.');
+    const repo = typeof selected === 'string' ? selected : execution.repo;
+    const selectedExecution = { ...execution, ...(repo === undefined ? {} : { repo }) };
+    const local = name === 'runtime_stage' || name === 'runtime_admit' || name.startsWith('issue_worktree_transition_');
+    let root = execution.repoRoot;
+    if (local) {
+        const settings = await loadDeliverySettings();
+        const coordinates = repo ??
+            (() => {
+                const r = resolveRepoFromRemote(root, 'origin');
+                return `${r.owner}/${r.repo}`;
+            })();
+        root = resolveCheckout({ repository: coordinates, launchDirectory: root, checkoutRoots: settings.checkoutRoots });
+        if (name === 'runtime_stage' || name === 'runtime_admit') {
+            const setup = {
+                ...input,
+                repoRoot: root,
+                identity: optionalString(input, 'identity') ?? execution.identity ?? settings.roles.author.identity,
+                ...(execution.personalAuth === undefined ? {} : { personalAuth: execution.personalAuth }),
+                ...(execution.signal === undefined ? {} : { signal: execution.signal }),
+            };
+            return name === 'runtime_stage'
+                ? stageRuntime(setup)
+                : admitRuntime(setup);
         }
-        const authorClients = name === 'issue_pr_review'
-            ? await createDeliveryGitHubClients({
-                config: context.config,
-                identity: context.config.roles.author.identity,
-                ...(execution.personalAuth ? { personalAuth: { enabled: true } } : {}),
-                role: 'author',
-            })
-            : context.clients;
-        // Discover the controller's metadata through the configured source author,
-        // while retaining the controller's policy, settings and admission digest.
-        controllerConfiguration = await loadDeliveryConfig(primary, { clients: authorClients });
-    }
-    if (MUTATING_TOOLS.has(name) && input.dryRun !== true) {
-        if (name !== 'issue_worktree_transition_apply' && typeof input.issueNumber === 'number')
-            assertIssueWorktreeTransitionAdmission(input.issueNumber, primaryGitRoot(execution.repoRoot), name === 'issue_develop' || (name === 'issue_start' && input.resumeCreated !== true));
-        await assertDeliveryRuntimeAdmitted({
-            ...execution,
-            repoRoot: sourceRoot === undefined ? execution.repoRoot : primaryGitRoot(execution.repoRoot),
-            ...(controllerConfiguration === undefined ? {} : { configuration: controllerConfiguration }),
-        });
-    }
-    if (sourceRoot !== undefined && (name === 'issue_pr_create' || name === 'issue_pr_review')) {
-        if (context.configuration === undefined)
-            throw new DeliveryError('Source-bound operation requires discovered candidate configuration.');
-        const run = loadVerifiedRun(sourceRoot, requiredNumber(input, 'issueNumber'));
-        assertRepositoryClassificationCurrent({
-            classification: run.classification,
-            configDigest: context.configuration.configDigest,
-            policySourcePath: context.config.policy.module,
-            repoRoot: sourceRoot,
-        });
     }
+    const requestedIdentity = name === 'issue_pr_review' ? optionalString(input, 'identity') : undefined;
+    const context = await contextFor({ ...selectedExecution, ...(requestedIdentity === undefined ? {} : { identity: requestedIdentity }) }, definition.commandName, name === 'issue_pr_review' ? 'reviewer' : 'author');
+    if (local)
+        context.root = root;
     switch (name) {
         case 'issue_comment':
             return commentIssue(context, input);
-        case 'issue_worktree_transition_inspect':
-            return inspectWorktreeTransition(context, {
-                ...input,
-                ...(execution.runtimeEntryPath === undefined ? {} : { runtimeEntryPath: execution.runtimeEntryPath }),
-            });
-        case 'issue_worktree_transition_apply':
-            return applyWorktreeTransition(context, {
-                authority: 'worktree:transition',
-                planPath: requireString(input, 'planPath'),
-                expectedPlanId: requireString(input, 'expectedPlanId'),
-                relinquishmentCommentId: requiredNumber(input, 'relinquishmentCommentId'),
-                acceptanceCommentId: requiredNumber(input, 'acceptanceCommentId'),
-                ...(execution.runtimeEntryPath === undefined ? {} : { runtimeEntryPath: execution.runtimeEntryPath }),
-            });
-        case 'issue_create': {
+        case 'issue_create':
             return createIssue(context, input);
-        }
-        case 'issue_start': {
-            const identity = await identityFor(execution, 'start');
-            if (input.resumeCreated === true && (input.issueNumber === undefined || typeof input.develop !== 'boolean')) {
-                throw new DeliveryError('Resume of a known created issue requires issueNumber and an explicit develop boolean.');
-            }
-            if (input.scratch === true) {
-                if (input.issueNumber !== undefined || input.develop === true || input.resumeCreated === true) {
-                    throw new DeliveryError('Scratch worktree cannot claim a tracked issue.');
-                }
-                await preflightReviewRoute(context, undefined, undefined, 'development');
-                return scratchStart(input, execution, identity, context.configuration?.remote);
-            }
-            return startTrackedIssue(context, input, execution.runtimeEntryPath);
-        }
-        case 'issue_update': {
+        case 'issue_start':
+            return startTrackedIssue(context, input);
+        case 'issue_update':
             return updateIssue(context, input);
-        }
         case 'issue_list':
         case 'issue_search':
             return listIssues(context, input);
-        case 'issue_info': {
-            if (input.cached === true)
-                return cachedIssueInfo(execution.repoRoot, requiredNumber(input, 'issueNumber'));
+        case 'issue_info':
             return issueInfo(context, requiredNumber(input, 'issueNumber'));
-        }
-        case 'issue_ready_check': {
+        case 'issue_ready_check':
             return readyCheck(context, requiredNumber(input, 'issueNumber'));
-        }
-        case 'issue_develop': {
-            const issueNumber = requiredNumber(input, 'issueNumber');
-            const result = await developIssue(context, issueNumber, execution.runtimeEntryPath);
-            if (input.assignee !== undefined)
-                await context.clients.rest.issues.addAssignees({
-                    ...context.repo,
-                    issue_number: issueNumber,
-                    assignees: [requireString(input, 'assignee')],
-                });
-            return result;
-        }
-        case 'issue_verify': {
-            const issueNumber = requiredNumber(input, 'issueNumber');
-            const root = primaryGitRoot(execution.repoRoot);
-            const row = getIssueWorktreeStrict(issueNumber, root);
-            const run = await verifyIssue({
-                personalAuth: context.clients.authSource === 'personal' && context.config.roles.author.authSource !== 'personal',
-                issueNumber,
-                repoRoot: row.path,
-                ...(execution.signal === undefined ? {} : { signal: execution.signal }),
-                ...(input.resourceBounds === undefined
-                    ? {}
-                    : { resourceBounds: input.resourceBounds }),
-                ...(input.admit === undefined
-                    ? {}
-                    : { admittedResourceClasses: ['source_only', ...input.admit] }),
-            });
-            let approval;
-            if (input.prepublicationReview !== undefined) {
-                const artifact = parseReviewArtifact(readFileSync(requireString(input, 'prepublicationReview'), 'utf8'));
-                const config = (await loadDeliveryConfig(row.path, execution.personalAuth === undefined ? {} : { personalAuth: execution.personalAuth })).config;
-                savePrepublicationArtifact({
-                    artifact,
-                    classification: run.classification,
-                    config,
-                    issueNumber,
-                    repoRoot: row.path,
-                });
-                approval = reviewArtifactApproval({ artifact, classification: run.classification, config, issueNumber });
-            }
-            const evidence = await createIssuePhaseEvidence({
-                personalAuth: context.clients.authSource === 'personal' && context.config.roles.author.authSource !== 'personal',
-                ...(approval === undefined ? {} : { approval }),
-                issueNumber,
-                phase: 'verify',
-                repoRoot: row.path,
-            });
-            return {
-                classificationReceiptId: run.classification.receiptId,
-                aggregateId: run.aggregate.aggregateId,
-                evidenceId: evidence.evidenceId,
-                manifestId: run.manifestId,
-                ...(run.resources === undefined ? {} : { resources: run.resources }),
-            };
-        }
-        case 'issue_pr_create': {
-            const issueNumber = requiredNumber(input, 'issueNumber');
-            if (input.dryRun === true) {
-                const row = getIssueWorktreeStrict(issueNumber, context.root);
-                const run = loadVerifiedRun(row.path, issueNumber);
-                return {
-                    dryRun: true,
-                    headSha: run.classification.head.sha,
-                    risk: run.classification.risk,
-                    reviewRoute: await preflightReviewRoute(context),
-                };
-            }
+        case 'issue_pr_create':
             return publishPr(context, {
-                issueNumber,
+                ...(input.prNumber === undefined ? {} : { prNumber: requiredNumber(input, 'prNumber') }),
+                issueNumber: requiredNumber(input, 'issueNumber'),
+                ...(input.nonClosing === undefined ? {} : { nonClosing: input.nonClosing === true }),
                 ...(input.body === undefined ? {} : { body: requireString(input, 'body') }),
                 ...(input.title === undefined ? {} : { title: requireString(input, 'title') }),
+                ...(input.headBranch === undefined ? {} : { headBranch: requireString(input, 'headBranch') }),
                 draft: input.draft !== false,
+                dryRun: input.dryRun === true,
             });
-        }
-        case 'issue_pr_info': {
-            return prInfo(context, {
-                ...(input.issueNumber === undefined ? {} : { issueNumber: Number(input.issueNumber) }),
-                ...(input.prNumber === undefined ? {} : { prNumber: Number(input.prNumber) }),
-            });
-        }
-        case 'issue_pr_review': {
-            if (input.dryRun === true) {
-                const issueNumber = requiredNumber(input, 'issueNumber');
-                const row = getIssueWorktreeStrict(issueNumber, context.root);
-                const run = loadVerifiedRun(row.path, issueNumber);
-                const artifact = parseReviewArtifact(requireString(input, 'artifact'));
-                reviewArtifactApproval({
-                    artifact,
-                    classification: run.classification,
-                    config: context.config,
-                    issueNumber,
-                    prNumber: requiredNumber(input, 'prNumber'),
-                });
-                return { dryRun: true, artifactId: artifact.artifactId };
-            }
+        case 'issue_pr_info':
+            return prInfo(context, input);
+        case 'issue_pr_review':
             return submitFormalReview(context, {
                 artifact: requireString(input, 'artifact'),
                 issueNumber: requiredNumber(input, 'issueNumber'),
+                ...(input.nonClosing === undefined ? {} : { nonClosing: input.nonClosing === true }),
                 prNumber: requiredNumber(input, 'prNumber'),
+                dryRun: input.dryRun === true,
             });
-        }
         case 'issue_pr_merge':
         case 'issue_finish': {
-            const issueNumber = requiredNumber(input, 'issueNumber');
-            const prNumber = requiredNumber(input, 'prNumber');
-            if (input.dryRun === true) {
-                const row = getIssueWorktreeStrict(issueNumber, context.root);
-                const run = loadVerifiedRun(row.path, issueNumber);
-                return { dryRun: true, headSha: run.classification.head.sha, prNumber };
-            }
-            const strategy = input.strategy;
-            return name === 'issue_finish'
-                ? finishIssue(context, { issueNumber, prNumber, ...(strategy === undefined ? {} : { strategy }) })
-                : mergePr(context, { issueNumber, prNumber, ...(strategy === undefined ? {} : { strategy }) });
+            const merge = {
+                issueNumber: requiredNumber(input, 'issueNumber'),
+                ...(input.nonClosing === undefined ? {} : { nonClosing: input.nonClosing === true }),
+                prNumber: requiredNumber(input, 'prNumber'),
+                ...(input.strategy === undefined ? {} : { strategy: input.strategy }),
+                ...(input.reviewedHeadSha === undefined ? {} : { reviewedHeadSha: requireString(input, 'reviewedHeadSha') }),
+                dryRun: input.dryRun === true,
+            };
+            return name === 'issue_finish' ? finishIssue(context, merge) : mergePr(context, merge);
         }
-        case 'issue_worktree_create': {
-            const identity = await identityFor(execution, 'worktree:create');
-            await preflightReviewRoute(context, undefined, undefined, 'development');
-            return prepareStandaloneWorktree({
-                ...(context.configuration?.remote ? { remote: context.configuration.remote } : {}),
-                branch: requireString(input, 'branch'),
-                identity,
-                name: requireString(input, 'name'),
-                repoRoot: execution.repoRoot,
+        case 'issue_worktree_transition_inspect':
+            return inspectWorktreeTransition(context, {
+                ...input,
+                ...(execution.runtimeEntryPath === undefined ? {} : { runtimeEntryPath: execution.runtimeEntryPath }),
+            });
+        case 'issue_worktree_transition_apply':
+            return applyWorktreeTransition(context, {
+                authority: 'worktree:transition',
+                planPath: requireString(input, 'planPath'),
+                expectedPlanId: requireString(input, 'expectedPlanId'),
+                relinquishmentCommentId: requiredNumber(input, 'relinquishmentCommentId'),
+                acceptanceCommentId: requiredNumber(input, 'acceptanceCommentId'),
+                ...(execution.runtimeEntryPath === undefined ? {} : { runtimeEntryPath: execution.runtimeEntryPath }),
             });
-        }
     }
 }
 //# sourceMappingURL=dispatch.js.map