@fitlab-ai/agent-infra 0.9.11 → 0.9.12

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

package/dist/lib/task/human-override.js

@@ -19,6 +19,7 @@ import { applyWorkflowWarningIntent } from './workflow-warning-intents.js';
 import { verifyTaskEvent } from './verification.js';
 import { verifyInProcess } from './verification-engine.js';
 import { canonicalTimestamp, writeTask } from './write.js';
+import { readPrDeliveryFact } from './pr-delivery-fact.js';
 const LIFECYCLE_PRODUCER = 'lifecycle.apply';
 const HUMAN_OVERRIDE_SECTION_ALIASES = ['人工豁免账本', 'Human Override Ledger'];
 const HUMAN_OVERRIDE_COLUMNS = [
@@ -405,7 +406,8 @@ function resourceForSnapshot(policy, options, frontmatter) {
         return number === null ? null : { kind: 'issue', number };
     }
     if (policy.producerId === 'platform.pull-request') {
-        const number = options.probePullRequestNumber ?? toPositiveInteger(frontmatter?.pr_number);
+        const fact = frontmatter ? readPrDeliveryFact(frontmatter) : null;
+        const number = options.probePullRequestNumber ?? (fact?.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.number : null);
         return number === null ? null : { kind: 'pull-request', number };
     }
     return null;
@@ -468,7 +470,8 @@ function probePlatformFailure(taskRef, policy, resolved, options) {
         return error('OVERRIDE_DOCUMENT_INVALID', cause instanceof Error ? cause.message : String(cause));
     }
     const issueNumber = options.probeIssueNumber ?? toPositiveInteger(frontmatter.issue_number);
-    const pullRequestNumber = options.probePullRequestNumber ?? toPositiveInteger(frontmatter.pr_number);
+    const fact = readPrDeliveryFact(frontmatter);
+    const pullRequestNumber = options.probePullRequestNumber ?? (fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.number : null);
     const operation = policy.producerId === 'platform.issue'
         ? issueNumber === null
             ? null

package/dist/lib/task/lifecycle.js

@@ -14,6 +14,7 @@ const lifecycleIntentCatalog = [
 ];
 const lifecycleFailureCatalog = [
     'LIFECYCLE_DIRECTORY_RENAME_FAILED',
+    'LIFECYCLE_DIRECTORY_COPY_FAILED',
     'LIFECYCLE_DOCUMENT_INVALID',
     'LIFECYCLE_FINAL_STATE_INVALID',
     'LIFECYCLE_IDENTITY_CONFLICT',
@@ -295,6 +296,65 @@ function parseJournal(content) {
     }
     return value;
 }
+function directoryManifest(root) {
+    const entries = [];
+    const visit = (current, relative = '') => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
+            const relativePath = relative ? path.join(relative, entry.name) : entry.name;
+            const absolute = path.join(current, entry.name);
+            const stat = fs.lstatSync(absolute);
+            if (stat.isSymbolicLink())
+                throw new Error(`symbolic link is not allowed in lifecycle directory: ${relativePath}`);
+            if (entry.isDirectory()) {
+                entries.push({ relativePath, kind: 'directory', size: 0, digest: '' });
+                visit(absolute, relativePath);
+            }
+            else if (entry.isFile()) {
+                const digest = createHash('sha256').update(fs.readFileSync(absolute)).digest('hex');
+                entries.push({ relativePath, kind: 'file', size: stat.size, digest });
+            }
+            else {
+                throw new Error(`unsupported lifecycle directory entry: ${relativePath}`);
+            }
+        }
+    };
+    visit(root);
+    return entries;
+}
+function copyDirectoryVerified(source, target) {
+    if (fs.existsSync(target))
+        throw new Error(`target directory already exists: ${target}`);
+    const copy = (currentSource, currentTarget) => {
+        fs.mkdirSync(currentTarget);
+        for (const entry of fs.readdirSync(currentSource, { withFileTypes: true })) {
+            const sourcePath = path.join(currentSource, entry.name);
+            const targetPath = path.join(currentTarget, entry.name);
+            const stat = fs.lstatSync(sourcePath);
+            if (stat.isSymbolicLink())
+                throw new Error(`symbolic link is not allowed in lifecycle directory: ${entry.name}`);
+            if (entry.isDirectory())
+                copy(sourcePath, targetPath);
+            else if (entry.isFile())
+                fs.copyFileSync(sourcePath, targetPath);
+            else
+                throw new Error(`unsupported lifecycle directory entry: ${entry.name}`);
+        }
+    };
+    copy(source, target);
+    const sourceManifest = directoryManifest(source);
+    const targetManifest = directoryManifest(target);
+    if (JSON.stringify(sourceManifest) !== JSON.stringify(targetManifest)) {
+        throw new Error('copied lifecycle directory failed manifest verification');
+    }
+}
+function removeCopiedSource(source, target) {
+    const sourceManifest = directoryManifest(source);
+    const targetManifest = directoryManifest(target);
+    if (JSON.stringify(sourceManifest) !== JSON.stringify(targetManifest)) {
+        throw new Error('lifecycle source and target diverged before source cleanup');
+    }
+    fs.rmSync(source, { recursive: true, force: false });
+}
 function applyTaskLifecycle(requestInput, options = {}) {
     const normalized = normalizedRequest(requestInput);
     if ('code' in normalized)
@@ -356,7 +416,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
     if (!spec.sources.includes(sourceState) && !existingJournal && !allowsManualOverride(options, 'LIFECYCLE_SOURCE_INVALID')) {
         return failed(request, { code: 'LIFECYCLE_SOURCE_INVALID', message: `${request.intent} is not allowed from ${sourceState}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    if (sourcePath !== targetPath && fs.existsSync(targetPath)) {
+    if (sourcePath !== targetPath && fs.existsSync(targetPath) && !existingJournal) {
         return failed(request, { code: 'LIFECYCLE_TARGET_CONFLICT', message: `target directory already exists: ${targetPath}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
     const content = io.readFileSync(currentTaskFile);
@@ -501,18 +561,55 @@ function applyTaskLifecycle(requestInput, options = {}) {
             (options.directoryRenameSync ?? io.renameSync)(sourcePath, targetPath);
         }
         catch (error) {
-            const failure = { code: 'LIFECYCLE_DIRECTORY_RENAME_FAILED', message: String(error) };
-            rememberJournalFailure(journalPath, journal, io, failure);
-            return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            if (error.code === 'EXDEV') {
+                try {
+                    copyDirectoryVerified(sourcePath, targetPath);
+                    completed.add('directory-moved');
+                    journal.completedSteps = [...completed];
+                    const copiedJournalPath = path.join(targetPath, '.task-lifecycle.json');
+                    writeJournal(initialJournalPath, journal, io);
+                    writeJournal(copiedJournalPath, journal, io);
+                    removeCopiedSource(sourcePath, targetPath);
+                    journalPath = copiedJournalPath;
+                }
+                catch (copyError) {
+                    if (fs.existsSync(targetPath))
+                        fs.rmSync(targetPath, { recursive: true, force: false });
+                    const failure = { code: 'LIFECYCLE_DIRECTORY_COPY_FAILED', message: String(copyError) };
+                    rememberJournalFailure(initialJournalPath, journal, io, failure);
+                    return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+                }
+            }
+            else {
+                const failure = { code: 'LIFECYCLE_DIRECTORY_RENAME_FAILED', message: String(error) };
+                rememberJournalFailure(journalPath, journal, io, failure);
+                return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            }
         }
-        completed.add('directory-moved');
-        journal.completedSteps = [...completed];
-        journalPath = path.join(targetPath, '.task-lifecycle.json');
+        if (completed.has('directory-moved') && !fs.existsSync(sourcePath)) {
+            journalPath = path.join(targetPath, '.task-lifecycle.json');
+        }
+        else if (!completed.has('directory-moved')) {
+            completed.add('directory-moved');
+            journal.completedSteps = [...completed];
+            journalPath = path.join(targetPath, '.task-lifecycle.json');
+            try {
+                writeJournal(journalPath, journal, io);
+            }
+            catch (error) {
+                return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, directory: { effect: 'move', changed: true }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            }
+        }
+    }
+    if (completed.has('directory-moved') && sourcePath !== targetPath && fs.existsSync(sourcePath) && fs.existsSync(targetPath)) {
         try {
-            writeJournal(journalPath, journal, io);
+            removeCopiedSource(sourcePath, targetPath);
+            journalPath = path.join(targetPath, '.task-lifecycle.json');
         }
         catch (error) {
-            return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, directory: { effect: 'move', changed: true }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            const failure = { code: 'LIFECYCLE_DIRECTORY_COPY_FAILED', message: String(error) };
+            rememberJournalFailure(journalPath, journal, io, failure);
+            return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         }
     }
     let shortId = { effect: 'unchanged', shortId: null, changed: false };

package/dist/lib/task/orchestration.js

@@ -10,13 +10,14 @@ import { resolveTaskRef } from './resolve-ref.js';
 import { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
 import { normalizeAgentClients } from '../agent-clients/config.js';
 import { resolveAgentRuntimeStoreRoot } from '../runtime/agent-runtime.js';
-import { inspectPlatformPullRequest } from '../platform/pull-requests.js';
 import { getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots } from './workspace-snapshot.js';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { hasActiveCodexLifecycleEvidence } from '../agent-clients/adapters/codex-lifecycle/store.js';
+import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead } from './review-fingerprint.js';
+import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.js';
 function supportsLifecycleDelegation(client) {
     return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
         && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -106,9 +107,8 @@ function isCompletionEvidence(value) {
         && exactText(value.headTree)
         && exactText(value.worktreeTree)
         && exactText(value.lastReviewedCommit)
-        && Number.isSafeInteger(value.prNumber)
-        && value.prNumber > 0
-        && exactText(value.prHead);
+        && (value.prNumber === null || (Number.isSafeInteger(value.prNumber) && value.prNumber > 0))
+        && (value.prHead === null || exactText(value.prHead));
 }
 const ORCHESTRATION_RUN_KEYS = [
     'taskId', 'runId', 'status', 'nextStage', 'stepCount', 'maxSteps', 'modelPolicy',
@@ -340,6 +340,43 @@ function highestRound(taskDir, family) {
 function artifactName(family, round) {
     return round === 1 ? `${family}.md` : `${family}-r${round}.md`;
 }
+function validateSavedCurrentDiffBase(repoRoot, metadata, taskDir, reviewedHead) {
+    const reviewRound = highestRound(taskDir, 'review-code');
+    const reviewContent = fs.readFileSync(path.join(taskDir, artifactName('review-code', reviewRound)), 'utf8');
+    const savedTargetHead = extractReviewTargetHead(reviewContent);
+    const savedDiffBase = extractReviewDiffBase(reviewContent);
+    const savedReviewedHead = extractReviewedHead(reviewContent) || extractReviewBaseline(reviewContent);
+    if (!savedTargetHead && !savedDiffBase && !savedReviewedHead)
+        return null;
+    if (savedReviewedHead && savedReviewedHead !== reviewedHead) {
+        return { code: 'ORCHESTRATION_REVIEWED_HEAD_MISMATCH', message: 'review-code saved reviewed head does not match last_reviewed_commit' };
+    }
+    if (!savedTargetHead || !savedDiffBase) {
+        return { code: 'ORCHESTRATION_REVIEW_TARGET_INVALID', message: 'review-code must save target head and diff base together' };
+    }
+    const savedBase = resolveDiffBase(repoRoot, reviewedHead, savedTargetHead);
+    if (!savedBase.ok)
+        return { code: 'ORCHESTRATION_REVIEW_TARGET_INVALID', message: savedBase.message };
+    if (savedBase.diffBase !== savedDiffBase) {
+        return { code: 'ORCHESTRATION_REVIEW_DIFF_BASE_MISMATCH', message: 'saved review diff base does not match reviewed head and saved target head' };
+    }
+    const target = resolveDeliveryTarget(repoRoot, {
+        remote: typeof metadata.delivery_remote === 'string' ? metadata.delivery_remote : undefined,
+        baseRef: typeof metadata.delivery_base_ref === 'string' ? metadata.delivery_base_ref : undefined
+    });
+    if (!target.ok)
+        return { code: target.code, message: target.message };
+    const currentTarget = resolveTargetHead(repoRoot, target.value);
+    if (!currentTarget.ok)
+        return { code: currentTarget.code, message: currentTarget.message };
+    const currentBase = resolveDiffBase(repoRoot, reviewedHead, currentTarget.head);
+    if (!currentBase.ok)
+        return { code: currentBase.code, message: currentBase.message };
+    if (currentBase.diffBase !== savedDiffBase) {
+        return { code: 'ORCHESTRATION_REVIEW_TARGET_CHANGED', message: 'current delivery target changed the reviewed diff base; re-run review-code' };
+    }
+    return null;
+}
 function hasReviewAfterArtifact(taskDir, family, reviewFamily) {
     const artifact = inspectArtifactDirectory(taskDir, family);
     const review = inspectArtifactDirectory(taskDir, reviewFamily);
@@ -487,29 +524,8 @@ function routeOrchestration(taskRef, options = {}) {
         if (run?.status === 'completed') {
             return { status: 'completed', changed: false, taskId: resolved.taskId, run, next: null, error: null };
         }
-        let config;
-        try {
-            config = JSON.parse(fs.readFileSync(path.join(resolved.repoRoot, '.agents', '.airc.json'), 'utf8'));
-        }
-        catch (error) {
-            return failed('ORCHESTRATION_CONFIG_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
-        }
-        if (!config || typeof config !== 'object' || Array.isArray(config)) {
-            return failed('ORCHESTRATION_CONFIG_INVALID', 'project configuration must be an object', resolved.taskId);
-        }
-        const projectConfig = config;
-        if (!Object.hasOwn(projectConfig, 'prFlow') || projectConfig.prFlow === 'disabled') {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
-        }
-        if (projectConfig.prFlow !== 'required') {
-            return failed('ORCHESTRATION_CONFIG_INVALID', "project configuration 'prFlow' must be 'required' or 'disabled'", resolved.taskId);
-        }
-        const prNumber = Number(metadata.pr_number);
-        if (!Number.isInteger(prNumber) || prNumber <= 0) {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
-        }
         if (!run) {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
+            return { status: 'running', changed: false, taskId: resolved.taskId, run, next: null, error: null };
         }
         if (run.status !== 'running' || run.pendingDelegation !== null) {
             return failed('ORCHESTRATION_RUN_NOT_RUNNING', 'clean completion requires an idle running orchestration', resolved.taskId);
@@ -523,34 +539,15 @@ function routeOrchestration(taskRef, options = {}) {
             return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
         }
         if (before.headTree !== before.worktreeTree) {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
+            return { status: 'running', changed: false, taskId: resolved.taskId, run, next: null, error: null };
         }
         const lastReviewedCommit = String(metadata.last_reviewed_commit ?? '');
         if (before.head !== lastReviewedCommit) {
             return failed('ORCHESTRATION_REVIEWED_HEAD_MISMATCH', 'local HEAD does not match last_reviewed_commit', resolved.taskId);
         }
-        const inspect = options.inspectPullRequest ?? inspectPlatformPullRequest;
-        let inspection;
-        try {
-            inspection = inspect(resolved.taskId, { cwd: gitRoot });
-        }
-        catch (error) {
-            return failed('ORCHESTRATION_PR_INSPECTION_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
-        }
-        if (inspection.status === 'blocked') {
-            return failed('ORCHESTRATION_PR_INSPECTION_BLOCKED', inspection.error?.message ?? 'pull request inspection is blocked', resolved.taskId);
-        }
-        if (inspection.status === 'failed') {
-            return failed('ORCHESTRATION_PR_INSPECTION_FAILED', inspection.error?.message ?? 'pull request inspection failed', resolved.taskId);
-        }
-        const inspectedPrNumber = inspection.task?.prNumber ?? inspection.prNumber;
-        const prHead = inspection.pullRequest?.head?.sha;
-        if (typeof prHead !== 'string') {
-            return failed('ORCHESTRATION_PR_INSPECTION_INVALID', 'pull request inspection returned incomplete identity evidence', resolved.taskId);
-        }
-        if (inspectedPrNumber !== prNumber || prHead !== before.head) {
-            return failed('ORCHESTRATION_PR_HEAD_MISMATCH', 'pull request identity does not match the reviewed local HEAD', resolved.taskId);
-        }
+        const diffBaseError = validateSavedCurrentDiffBase(resolved.repoRoot, metadata, resolved.taskDir, lastReviewedCommit);
+        if (diffBaseError)
+            return failed(diffBaseError.code, diffBaseError.message, resolved.taskId);
         let after;
         try {
             after = capture(gitRoot);
@@ -559,7 +556,7 @@ function routeOrchestration(taskRef, options = {}) {
             return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
         }
         if (after.headTree !== after.worktreeTree) {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
+            return { status: 'running', changed: false, taskId: resolved.taskId, run, next: null, error: null };
         }
         if (after.head !== before.head || after.headTree !== before.headTree) {
             return failed('ORCHESTRATION_REPOSITORY_CHANGED', 'repository changed while clean completion evidence was collected', resolved.taskId);
@@ -572,8 +569,8 @@ function routeOrchestration(taskRef, options = {}) {
             headTree: after.headTree,
             worktreeTree: after.worktreeTree,
             lastReviewedCommit,
-            prNumber,
-            prHead
+            prNumber: null,
+            prHead: null
         };
         const completed = withUpdatedRun(run, {
             status: 'completed',
@@ -668,10 +665,7 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     }
     const updated = withUpdatedRun(run, {
         nextStage: next.stage,
-        pendingDelegation: receipt,
-        commitAuthorization: next.stage === 'commit' && run.commitAuthorization.issuedAt === null
-            ? { issuedAt: (options.now ?? (() => new Date().toISOString()))(), consumedAt: null }
-            : run.commitAuthorization
+        pendingDelegation: receipt
     });
     saveRun(resolved.taskDir, updated);
     return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next, error: null };
@@ -1093,16 +1087,15 @@ function advanceOrchestration(taskRef, options = {}) {
     const result = consumeDelegation(run.pendingDelegation, { now: options.now });
     if (!result.ok)
         return pauseOrchestration(taskRef, result.code, result.message, true, options);
-    const completed = result.receipt.stage === 'commit';
+    if (result.receipt.stage === 'commit') {
+        return failed('ORCHESTRATED_COMMIT_REMOVED', 'Orchestrated commit is no longer a lifecycle stage; use local checkpoint delivery from code-task', resolved.taskId);
+    }
     const updated = withUpdatedRun(run, {
-        status: completed ? 'completed' : 'running',
+        status: 'running',
         nextStage: null,
         stepCount: run.stepCount + 1,
         pendingDelegation: null,
-        receipts: Object.freeze([...run.receipts, result.receipt]),
-        commitAuthorization: completed
-            ? { ...run.commitAuthorization, consumedAt: (options.now ?? (() => new Date().toISOString()))() }
-            : run.commitAuthorization
+        receipts: Object.freeze([...run.receipts, result.receipt])
     });
     saveRun(resolved.taskDir, updated);
     return { status: updated.status, changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };