@fitlab-ai/agent-infra 0.9.11 → 0.9.13

package/dist/lib/task/create-service.js

@@ -12,8 +12,8 @@ const DEFAULT_DEPENDENCIES = {
     syncComment: syncPlatformComment,
     addWarning: applyWorkflowWarningIntent
 };
-function verifyCreatedTask(repoRoot, taskId) {
-    const verification = verifyTaskEvent({ taskRef: taskId, event: 'create-task.completed' }, { repoRoot });
+async function verifyCreatedTask(repoRoot, taskId) {
+    const verification = await verifyTaskEvent({ taskRef: taskId, event: 'create-task.completed' }, { repoRoot });
     if (verification.status === 'pass') {
         return { operation: { name: 'task:verify', status: 'pass', reasonCode: null }, error: null };
     }
@@ -42,7 +42,7 @@ function issueFromTask(repoRoot, taskId) {
     const match = /^issue_number:\s*(\d+)\s*$/m.exec(content);
     return match ? { number: Number(match[1]), url: '' } : null;
 }
-function createTask(value, options) {
+async function createTask(value, options) {
     const dependencies = { ...DEFAULT_DEPENDENCIES, ...options.dependencies };
     let candidate;
     let local;
@@ -65,13 +65,13 @@ function createTask(value, options) {
             name: 'task:local', status: local.status, reasonCode: null
         }];
     let issue = issueFromTask(options.repoRoot, local.task.id);
-    const created = dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
+    const created = await dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
     operations.push(...platformOperations('platform-create', created.operations));
     if (created.issue)
         issue = { number: created.issue.number, url: created.issue.url };
     let platformFailure = created.status === 'failed' || created.status === 'blocked' ? created : null;
     if (!platformFailure && (created.task.issueNumber || issue)) {
-        const synced = dependencies.syncIssue(local.task.id, {
+        const synced = await dependencies.syncIssue(local.task.id, {
             cwd: options.repoRoot,
             agent: candidate.agent,
             status: 'waiting-for-triage',
@@ -86,7 +86,7 @@ function createTask(value, options) {
         if (synced.status === 'failed' || synced.status === 'blocked')
             platformFailure = synced;
         if (!platformFailure) {
-            const commented = dependencies.syncComment(local.task.id, { cwd: options.repoRoot, kind: 'task', agent: candidate.agent });
+            const commented = await dependencies.syncComment(local.task.id, { cwd: options.repoRoot, kind: 'task', agent: candidate.agent });
             operations.push(...platformOperations('platform-comment', commented.operations));
             if (commented.status === 'failed' || commented.status === 'blocked')
                 platformFailure = commented;
@@ -99,7 +99,7 @@ function createTask(value, options) {
             code: 'ISSUE_CREATE_FAILED', target: 'issue', message: `${error.code}: ${error.message}`,
             action: 'Fix platform authentication or connectivity, then retry Issue creation for this task.'
         }, { repoRoot: options.repoRoot });
-        const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+        const verified = await verifyCreatedTask(options.repoRoot, local.task.id);
         operations.push(verified.operation);
         if (verified.error)
             return {
@@ -116,7 +116,7 @@ function createTask(value, options) {
             error
         };
     }
-    const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+    const verified = await verifyCreatedTask(options.repoRoot, local.task.id);
     operations.push(verified.operation);
     if (verified.error)
         return {

package/dist/lib/task/create.js

@@ -4,6 +4,8 @@ import path from 'node:path';
 import { isValidAgentInfraVersion, VERSION } from '../version.js';
 import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
+import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.js';
+import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.js';
 const AGENTS = ['claude', 'codex', 'antigravity', 'opencode', 'cursor'];
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'];
 const PRIORITIES = ['Urgent', 'High', 'Medium', 'Low'];
@@ -15,12 +17,15 @@ const TASK_INPUT_KEYS = [
 function payloadError(message) {
     throw new Error(`TASK_CREATE_PAYLOAD_INVALID: ${message}`);
 }
-function exactKeys(value, expected, label) {
+function exactKeys(value, expected, label, optional = []) {
     const actual = Object.keys(value).sort();
     const wanted = [...expected].sort();
-    if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
+    const allowed = new Set([...expected, ...optional]);
+    if (actual.some((key) => !allowed.has(key))) {
         payloadError(`${label} has unknown or missing fields`);
     }
+    if (expected.some((key) => !actual.includes(key)))
+        payloadError(`${label} has unknown or missing fields`);
 }
 function cleanString(value, label, maxBytes, oneLine = false) {
     if (typeof value !== 'string' || value.length === 0 || Buffer.byteLength(value, 'utf8') > maxBytes) {
@@ -43,7 +48,7 @@ function validateTaskCreateCandidate(value) {
     exactKeys(candidate, [
         'version', 'idempotencyKey', 'agent', 'title', 'type', 'branchSlug',
         'priority', 'effort', 'description', 'taskInput'
-    ], 'candidate');
+    ], 'candidate', ['deliveryRemote', 'deliveryBaseRef']);
     if (candidate.version !== 1)
         payloadError('version must be 1');
     const idempotencyKey = cleanString(candidate.idempotencyKey, 'idempotencyKey', 64, true);
@@ -58,6 +63,16 @@ function validateTaskCreateCandidate(value) {
         payloadError('branchSlug must be lowercase ASCII kebab-case with length 3-64');
     }
     const description = cleanString(candidate.description, 'description', 8 * 1024);
+    const deliveryRemote = candidate.deliveryRemote === undefined
+        ? undefined
+        : cleanString(candidate.deliveryRemote, 'deliveryRemote', 200, true);
+    const deliveryBaseRef = candidate.deliveryBaseRef === undefined
+        ? undefined
+        : cleanString(candidate.deliveryBaseRef, 'deliveryBaseRef', 200, true);
+    if (deliveryRemote !== undefined && !validateRemote(deliveryRemote))
+        payloadError('deliveryRemote is invalid');
+    if (deliveryBaseRef !== undefined && !validateBaseRef(deliveryBaseRef))
+        payloadError('deliveryBaseRef is invalid');
     if (!candidate.taskInput || typeof candidate.taskInput !== 'object' || Array.isArray(candidate.taskInput)) {
         payloadError('taskInput must be an object');
     }
@@ -79,6 +94,8 @@ function validateTaskCreateCandidate(value) {
         priority: enumValue(candidate.priority, PRIORITIES, 'priority'),
         effort: enumValue(candidate.effort, EFFORTS, 'effort'),
         description,
+        ...(deliveryRemote === undefined ? {} : { deliveryRemote }),
+        ...(deliveryBaseRef === undefined ? {} : { deliveryBaseRef }),
         taskInput
     };
 }
@@ -94,6 +111,8 @@ function canonicalTaskCreateCandidate(candidate) {
         priority: valid.priority,
         effort: valid.effort,
         description: valid.description,
+        deliveryRemote: valid.deliveryRemote ?? null,
+        deliveryBaseRef: valid.deliveryBaseRef ?? null,
         taskInput: Object.fromEntries(TASK_INPUT_KEYS.map((key) => [key, valid.taskInput[key]]))
     });
 }
@@ -145,7 +164,11 @@ function renderTask(params) {
         'target_date:',
         'current_step: requirement-analysis',
         `assigned_to: ${candidate.agent}`,
-        'pr_status: pending',
+        `pr_delivery_fact: ${JSON.stringify(encodePrDeliveryFact(buildUnboundFact()))}`,
+        `delivery_remote: ${candidate.deliveryRemote ?? params.delivery.remote}`,
+        `delivery_base_ref: ${candidate.deliveryBaseRef ?? params.delivery.baseRef}`,
+        'checkpoint_commit:',
+        'delivery_remote_head:',
         `task_create_key_digest: ${params.keyDigest}`,
         `task_create_candidate_digest: ${params.candidateDigest}`,
         '---'
@@ -175,7 +198,10 @@ function readProject(repoRoot) {
     if (typeof config.project !== 'string' || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(config.project)) {
         throw new Error('TASK_CREATE_CONFIG_INVALID: project is missing or invalid');
     }
-    return config.project;
+    const delivery = readDeliveryDefaults(repoRoot);
+    if (!delivery.ok)
+        throw new Error(`TASK_CREATE_CONFIG_INVALID: ${delivery.message}`);
+    return { project: config.project, delivery: delivery.value };
 }
 function assertRealDirectory(directory, code) {
     const stat = fs.lstatSync(directory);
@@ -269,7 +295,7 @@ function createLocalTask(value, options) {
     ensureRealDirectory(path.join(repoRoot, '.agents'), 'TASK_CREATE_WORKSPACE_INVALID');
     ensureRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
     ensureRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
-    const project = readProject(repoRoot);
+    const projectConfig = readProject(repoRoot);
     const canonical = canonicalTaskCreateCandidate(candidate);
     const candidateDigest = sha256(canonical);
     const keyDigest = sha256(candidate.idempotencyKey);
@@ -312,7 +338,7 @@ function createLocalTask(value, options) {
         if (!templateStat.isFile() || templateStat.isSymbolicLink())
             throw new Error('TASK_CREATE_TEMPLATE_INVALID');
         const rendered = renderTask({
-            template: fs.readFileSync(templatePath, 'utf8'), candidate, taskId, project, timestamp,
+            template: fs.readFileSync(templatePath, 'utf8'), candidate, taskId, project: projectConfig.project, delivery: projectConfig.delivery, timestamp,
             agentInfraVersion, keyDigest, candidateDigest
         });
         const temporary = path.join(workspaceRoot, `.task-create.tmp.${process.pid}.${randomUUID()}`);

package/dist/lib/task/current-contract.js

@@ -1,6 +1,7 @@
 import { isValidAgentInfraVersion } from '../version.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, validateLedgerRows } from './ledger.js';
+import { parseInvalidationDocument } from './invalidation.js';
 function validateCurrentTaskContract(content) {
     let metadata;
     try {
@@ -29,7 +30,10 @@ function validateCurrentTaskContract(content) {
     const invalid = validateLedgerRows(ledger.rows);
     if (invalid)
         return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalid.code}: ${invalid.message}` };
-    return { ok: true, metadata, ledger };
+    const invalidation = parseInvalidationDocument(content);
+    if (!invalidation.ok)
+        return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalidation.code}: ${invalidation.message}` };
+    return { ok: true, metadata, ledger, invalidation: invalidation.document };
 }
 export { validateCurrentTaskContract };
 //# sourceMappingURL=current-contract.js.map

package/dist/lib/task/decision-details.js

@@ -109,31 +109,8 @@ function resolveDecisionDetail(content, rowId, anchor) {
     }
     return { status: 'found', block: matches[0] };
 }
-const INFORMAL_SHORT_HEADING = /^(?:AN|PL|CD|HD)-[1-9]\d*[：:]\s*(?:上一轮)?简短复核$/i;
-const INFORMAL_SHORT_FRAGMENT = /^简短(?:结论|说明)$/;
-function isInformalShortBlock(block) {
-    if (block.canonical || block.content.length > 600)
-        return false;
-    if (!INFORMAL_SHORT_HEADING.test(block.heading))
-        return false;
-    const scanned = scanVisibleMarkdown(block.content);
-    const bodyLines = scanned.lines
-        .filter((line) => !scanned.headings.some((heading) => heading.start === line.start) && line.text.trim())
-        .map((line) => line.text);
-    if (bodyLines.length === 0 || bodyLines.length > 2)
-        return false;
-    const fragments = bodyLines.map((line) => line.match(/^\s*[-*]\s+([^\s].*?)\s*$/)?.[1] ?? null);
-    if (fragments.some((fragment) => fragment === null))
-        return false;
-    return fragments.every((fragment) => INFORMAL_SHORT_FRAGMENT.test(fragment));
-}
-function hasDirectPrecedingAnchor(block, scanned) {
-    return scanned.anchors.some((anchor) => (anchor.end < block.start
-        && !scanned.lines.some((line) => line.start > anchor.end && line.start < block.start && line.text.trim())));
-}
 function inspectDecisionDetailDuplicates(content) {
     const blocks = parseDecisionDetailBlocks(content);
-    const scanned = scanVisibleMarkdown(content);
     const grouped = new Map();
     for (const block of blocks) {
         const key = block.id.toUpperCase();
@@ -145,15 +122,13 @@ function inspectDecisionDetailDuplicates(content) {
     for (const group of grouped.values()) {
         if (group.length < 2)
             continue;
-        const canonical = group.filter((block) => block.canonical);
-        const repairable = canonical.length === 1 && group.every((block) => (block.canonical || (!hasDirectPrecedingAnchor(block, scanned) && isInformalShortBlock(block))));
-        duplicates.push({ id: canonical[0]?.id ?? group[0].id, blocks: group, repairable });
+        duplicates.push({ id: group[0].id, blocks: group });
     }
     if (duplicates.length === 0)
         return { ok: true, blocks };
     const summary = duplicates.map((duplicate) => {
         const types = duplicate.blocks.map((block) => block.canonical ? 'canonical' : 'informal').join(', ');
-        return `${duplicate.id} (${duplicate.blocks.length} blocks: ${types}${duplicate.repairable ? '; safe repair available' : ''})`;
+        return `${duplicate.id} (${duplicate.blocks.length} blocks: ${types})`;
     }).join(', ');
     return {
         ok: false,
@@ -163,26 +138,6 @@ function inspectDecisionDetailDuplicates(content) {
         duplicates
     };
 }
-function repairDecisionDetailDuplicates(content) {
-    const inspection = inspectDecisionDetailDuplicates(content);
-    if (inspection.ok)
-        return { ok: true, changed: false, content };
-    const unsafe = inspection.duplicates.filter((duplicate) => !duplicate.repairable);
-    if (unsafe.length > 0) {
-        return {
-            ok: false,
-            code: 'DECISION_DETAIL_AMBIGUOUS',
-            message: `Cannot safely repair duplicate decision detail ids: ${unsafe.map((duplicate) => duplicate.id).join(', ')}`,
-            content
-        };
-    }
-    const removals = inspection.duplicates.flatMap((duplicate) => duplicate.blocks.filter((block) => !block.canonical));
-    let repaired = content;
-    for (const block of removals.sort((left, right) => right.start - left.start)) {
-        repaired = repaired.slice(0, block.start) + repaired.slice(block.end);
-    }
-    return { ok: true, changed: repaired !== content, content: repaired };
-}
 const FIELD_KEYS = {
     '为什么现在要决定': 'why', 'why decide now': 'why', 'why a decision is needed now': 'why',
     '要决定什么': 'decision', 'what to decide': 'decision', 'what needs a decision': 'decision',
@@ -259,5 +214,5 @@ function normalizeDecisionDetailForDisplay(block) {
         ordered.push(byKey.get('implementation'));
     return [body.slice(heading.start, heading.end).trim(), ...ordered].join('\n\n').trim();
 }
-export { inspectDecisionDetailDuplicates, normalizeDecisionDetailForDisplay, parseDecisionDetailBlocks, parseDecisionEvidence, repairDecisionDetailDuplicates, resolveDecisionDetail };
+export { inspectDecisionDetailDuplicates, normalizeDecisionDetailForDisplay, parseDecisionDetailBlocks, parseDecisionEvidence, resolveDecisionDetail, scanVisibleMarkdown };
 //# sourceMappingURL=decision-details.js.map

package/dist/lib/task/delivery-target.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+const REMOTE_RE = /^(?!-)(?!.*\.\.)(?!.*[~^:?*\\\s])[A-Za-z0-9._/-]+$/;
+const REF_RE = /^(?!-)(?!.*\.\.)(?!.*(?:^|\/)\.)(?!.*[~^:?*\\\s])[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
+function validateRemote(value) {
+    return typeof value === 'string' && value.length > 0 && REMOTE_RE.test(value);
+}
+function validateBaseRef(value) {
+    return typeof value === 'string' && value.length > 0 && !value.startsWith('refs/') && REF_RE.test(value);
+}
+function invalid(field, value) {
+    return { ok: false, code: 'DELIVERY_TARGET_INVALID', message: `${field} is invalid: ${String(value ?? '')}` };
+}
+function bindDeliveryTarget(input) {
+    const remote = input.existing?.remote ?? input.explicit?.remote ?? input.defaults?.remote;
+    const baseRef = input.existing?.baseRef ?? input.explicit?.baseRef ?? input.defaults?.baseRef;
+    if (input.existing?.remote !== undefined && input.explicit?.remote !== undefined && input.existing.remote !== input.explicit.remote) {
+        return { ok: false, code: 'DELIVERY_TARGET_CONFLICT', message: 'Explicit delivery remote does not match the task binding' };
+    }
+    if (input.existing?.baseRef !== undefined && input.explicit?.baseRef !== undefined && input.existing.baseRef !== input.explicit.baseRef) {
+        return { ok: false, code: 'DELIVERY_TARGET_CONFLICT', message: 'Explicit delivery base ref does not match the task binding' };
+    }
+    if (!validateRemote(remote))
+        return invalid('delivery remote', remote);
+    if (!validateBaseRef(baseRef))
+        return invalid('delivery base ref', baseRef);
+    return { ok: true, value: { remote, baseRef } };
+}
+function readDeliveryDefaults(repoRoot) {
+    try {
+        const configPath = path.join(repoRoot, '.agents', '.airc.json');
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (!config.delivery || typeof config.delivery !== 'object' || Array.isArray(config.delivery)) {
+            return { ok: false, code: 'DELIVERY_CONFIG_INVALID', message: 'delivery config must declare remote and baseRef' };
+        }
+        const delivery = config.delivery;
+        if (typeof delivery.remote !== 'string' || typeof delivery.baseRef !== 'string') {
+            return { ok: false, code: 'DELIVERY_CONFIG_INVALID', message: 'delivery config must declare remote and baseRef' };
+        }
+        return bindDeliveryTarget({
+            defaults: {
+                remote: delivery.remote,
+                baseRef: delivery.baseRef
+            }
+        });
+    }
+    catch (error) {
+        return { ok: false, code: 'DELIVERY_CONFIG_INVALID', message: error instanceof Error ? error.message : String(error) };
+    }
+}
+function resolveDeliveryTarget(repoRoot, existing = {}, explicit = {}) {
+    const defaults = readDeliveryDefaults(repoRoot);
+    if (!defaults.ok)
+        return defaults;
+    return bindDeliveryTarget({ defaults: defaults.value, existing, explicit });
+}
+function gitText(repoRoot, args) {
+    return execFileSync('git', [...args], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+}
+function resolveTargetHead(repoRoot, target) {
+    try {
+        const output = gitText(repoRoot, ['ls-remote', '--refs', target.remote, `refs/heads/${target.baseRef}`]);
+        const head = output.split(/\s+/)[0] ?? '';
+        if (!/^[a-f0-9]{40}$/i.test(head)) {
+            return { ok: false, code: 'DELIVERY_TARGET_UNAVAILABLE', message: `Delivery target ${target.remote}/${target.baseRef} is unavailable` };
+        }
+        try {
+            gitText(repoRoot, ['cat-file', '-e', `${head}^{commit}`]);
+        }
+        catch {
+            return { ok: false, code: 'DELIVERY_TARGET_OBJECT_MISSING', message: `Delivery target commit ${head} is not available locally` };
+        }
+        return { ok: true, value: target, head };
+    }
+    catch (error) {
+        return { ok: false, code: 'DELIVERY_TARGET_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) };
+    }
+}
+function resolveDiffBase(repoRoot, reviewedHead, targetHead) {
+    try {
+        const diffBase = gitText(repoRoot, ['merge-base', reviewedHead, targetHead]);
+        if (!/^[a-f0-9]{40}$/i.test(diffBase)) {
+            return { ok: false, code: 'DELIVERY_DIFF_BASE_UNAVAILABLE', message: 'Git returned an invalid diff base' };
+        }
+        return { ok: true, diffBase };
+    }
+    catch (error) {
+        return { ok: false, code: 'DELIVERY_DIFF_BASE_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) };
+    }
+}
+export { bindDeliveryTarget, readDeliveryDefaults, resolveDeliveryTarget, resolveTargetHead, resolveDiffBase, validateBaseRef, validateRemote };
+//# sourceMappingURL=delivery-target.js.map

package/dist/lib/task/delivery.js

@@ -0,0 +1,153 @@
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { parseTaskFrontmatter } from './frontmatter.js';
+import { resolveTaskRef } from './resolve-ref.js';
+import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead, validateBaseRef, validateRemote } from './delivery-target.js';
+import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead, findAuthoritativeReviewCodeArtifact } from './review-fingerprint.js';
+import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.js';
+function classifyDeliveryState(localHead, remoteHead, lastDelivered) {
+    if (remoteHead === null)
+        return { state: 'absent', shouldPush: true };
+    if (remoteHead === localHead)
+        return { state: 'same', shouldPush: false };
+    if (lastDelivered && remoteHead === lastDelivered)
+        return { state: 'known-old', shouldPush: true };
+    return { state: 'unknown-drift', shouldPush: false };
+}
+function git(cwd, args) {
+    const result = spawnSync('git', [...args], { cwd, encoding: 'utf8' });
+    return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+}
+function gitValue(cwd, args) {
+    const result = git(cwd, args);
+    return result.status === 0 ? result.stdout.trim() : null;
+}
+function validateBranch(cwd, branch) {
+    return git(cwd, ['check-ref-format', `refs/heads/${branch}`]).status === 0;
+}
+function validateReviewTargetCompatibility(repoRoot, taskDir, target, reviewedHead) {
+    const artifact = findAuthoritativeReviewCodeArtifact(taskDir);
+    if (!artifact.ok || !artifact.path)
+        return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'A current review-code artifact is required before delivery' };
+    let content;
+    try {
+        content = fs.readFileSync(artifact.path, 'utf8');
+    }
+    catch (error) {
+        return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: error instanceof Error ? error.message : String(error) };
+    }
+    const savedReviewedHead = extractReviewedHead(content) || extractReviewBaseline(content);
+    const savedTargetHead = extractReviewTargetHead(content);
+    const savedDiffBase = extractReviewDiffBase(content);
+    if (!savedReviewedHead || !savedTargetHead || !savedDiffBase) {
+        return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: 'review-code must save reviewed head, target head, and diff base before delivery' };
+    }
+    if (savedReviewedHead !== reviewedHead) {
+        return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'review-code reviewed head does not match last_reviewed_commit' };
+    }
+    const saved = resolveDiffBase(repoRoot, reviewedHead, savedTargetHead);
+    if (!saved.ok || saved.diffBase !== savedDiffBase) {
+        return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: saved.ok ? 'saved review diff base does not match saved target head' : saved.message };
+    }
+    const currentTarget = resolveTargetHead(repoRoot, target);
+    if (!currentTarget.ok)
+        return { ok: false, code: currentTarget.code, message: currentTarget.message };
+    const current = resolveDiffBase(repoRoot, reviewedHead, currentTarget.head);
+    if (!current.ok)
+        return { ok: false, code: current.code, message: current.message };
+    if (current.diffBase !== savedDiffBase) {
+        return { ok: false, code: 'DELIVERY_REVIEW_TARGET_CHANGED', message: 'current delivery target changed the reviewed diff base; re-run review-code' };
+    }
+    return { ok: true };
+}
+function failure(taskId, code, message, retryable = false, status = retryable ? 'blocked' : 'failed') {
+    return { status, changed: false, taskId, remoteHead: null, localHead: null, state: null, error: { code, message, retryable } };
+}
+function deliverUnlocked(taskId, taskDir, repoRoot, options) {
+    let frontmatter;
+    try {
+        frontmatter = parseTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'));
+    }
+    catch (error) {
+        return failure(taskId, 'TASK_CONTEXT_UNREADABLE', error instanceof Error ? error.message : String(error));
+    }
+    if (frontmatter.status !== 'active')
+        return failure(taskId, 'TASK_STATE_INVALID', 'task branch delivery requires an active task');
+    const branch = frontmatter.branch ?? '';
+    if (!branch)
+        return failure(taskId, 'DELIVERY_BRANCH_MISSING', 'task branch is missing');
+    if (!validateBranch(repoRoot, branch))
+        return failure(taskId, 'DELIVERY_BRANCH_INVALID', 'task branch is invalid');
+    if (!frontmatter.delivery_remote || !frontmatter.delivery_base_ref) {
+        return failure(taskId, 'DELIVERY_TARGET_MISSING', 'task delivery target is not bound; recreate or repair task metadata before delivery');
+    }
+    const target = resolveDeliveryTarget(repoRoot, {
+        remote: frontmatter.delivery_remote,
+        baseRef: frontmatter.delivery_base_ref
+    }, {
+        ...(options.remote === undefined ? {} : { remote: options.remote }),
+        ...(options.baseRef === undefined ? {} : { baseRef: options.baseRef })
+    });
+    if (!target.ok)
+        return failure(taskId, target.code, target.message);
+    if (!validateRemote(target.value.remote) || !validateBaseRef(target.value.baseRef))
+        return failure(taskId, 'DELIVERY_TARGET_INVALID', 'task delivery target is invalid');
+    const localHead = gitValue(repoRoot, ['rev-parse', 'HEAD']);
+    if (!localHead)
+        return failure(taskId, 'DELIVERY_LOCAL_HEAD_UNAVAILABLE', 'Unable to resolve local HEAD');
+    const status = git(repoRoot, ['status', '--porcelain=v1']);
+    if (status.status !== 0)
+        return failure(taskId, 'DELIVERY_GIT_INSPECT_FAILED', status.stderr.trim() || 'Unable to inspect Git state');
+    if (status.stdout.trim())
+        return failure(taskId, 'DELIVERY_WORKTREE_DIRTY', 'Working tree must be clean before branch delivery');
+    const reviewed = frontmatter.last_reviewed_commit ?? '';
+    if (reviewed !== localHead)
+        return failure(taskId, 'DELIVERY_REVIEW_REQUIRED', 'Local HEAD must equal last_reviewed_commit before delivery');
+    const reviewTarget = validateReviewTargetCompatibility(repoRoot, taskDir, target.value, reviewed);
+    if (!reviewTarget.ok)
+        return failure(taskId, reviewTarget.code, reviewTarget.message, reviewTarget.code.includes('UNAVAILABLE'), reviewTarget.code.includes('UNAVAILABLE') ? 'blocked' : 'failed');
+    const ref = `refs/heads/${branch}`;
+    const remoteOutput = git(repoRoot, ['ls-remote', '--refs', target.value.remote, ref]);
+    if (remoteOutput.status !== 0)
+        return failure(taskId, 'DELIVERY_REMOTE_UNAVAILABLE', remoteOutput.stderr.trim() || 'Unable to inspect the delivery remote', true);
+    const remoteHead = remoteOutput.stdout.trim().split(/\s+/)[0] || null;
+    const classification = classifyDeliveryState(localHead, remoteHead, frontmatter.delivery_remote_head ?? null);
+    if (classification.state === 'unknown-drift')
+        return failure(taskId, 'DELIVERY_REMOTE_DRIFT', `Remote branch ${branch} has an unexpected head; refusing to overwrite it`);
+    if (options.dryRun)
+        return { status: 'planned', changed: classification.shouldPush, taskId, remoteHead, localHead, state: classification.state, error: null };
+    if (classification.shouldPush) {
+        const args = classification.state === 'known-old'
+            ? ['push', `--force-with-lease=${ref}:${frontmatter.delivery_remote_head}`, target.value.remote, `HEAD:${ref}`]
+            : ['push', `--force-with-lease=${ref}:`, target.value.remote, `HEAD:${ref}`];
+        const pushed = git(repoRoot, args);
+        if (pushed.status !== 0)
+            return failure(taskId, 'DELIVERY_PUSH_FAILED', pushed.stderr.trim() || 'Task branch delivery was rejected', true, 'blocked');
+    }
+    const verified = gitValue(repoRoot, ['ls-remote', '--refs', target.value.remote, ref])?.split(/\s+/)[0] ?? null;
+    if (verified !== localHead)
+        return failure(taskId, 'DELIVERY_REMOTE_VERIFY_FAILED', `Expected remote head ${localHead}, received ${verified ?? 'unavailable'}`, true, 'blocked');
+    const written = writeTask({
+        taskRef: taskId,
+        expectedState: 'active',
+        mutations: [{ kind: 'frontmatter', set: { delivery_remote: target.value.remote, delivery_base_ref: target.value.baseRef, delivery_remote_head: localHead, assigned_to: options.agent } }]
+    }, { repoRoot, metadataProvider: captureTaskWriteMetadata });
+    if (written.status === 'failed')
+        return failure(taskId, 'DELIVERY_TASK_SYNC_FAILED', written.error.message, true, 'blocked');
+    return { status: classification.shouldPush ? 'applied' : 'no-op', changed: classification.shouldPush || written.changed, taskId, remoteHead: localHead, localHead, state: classification.state, error: null };
+}
+function deliverTaskBranch(taskRef, options) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failure(resolved.taskId, resolved.code, resolved.message);
+    try {
+        return withRepositoryMutationLock(resolved.repoRoot, () => withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-delivery', () => deliverUnlocked(resolved.taskId, resolved.taskDir, resolved.repoRoot, options)));
+    }
+    catch (error) {
+        return failure(resolved.taskId, 'DELIVERY_LOCK_FAILED', error instanceof Error ? error.message : String(error), true, 'blocked');
+    }
+}
+export { classifyDeliveryState, deliverTaskBranch };
+//# sourceMappingURL=delivery.js.map