@fitlab-ai/agent-infra 0.9.11 → 0.9.13

package/lib/task/commit-operation.ts

@@ -11,10 +11,13 @@ import { appendActivityEntry, locateActivityLog } from './activity-log.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation } from './write.ts';
 import {
-  commitOrchestrationStageCompletion,
-  planOrchestrationStageCompletion
-} from './orchestration.ts';
-import type { OrchestrationStageCompletion } from './orchestration.ts';
+  checkpointIntentDigest,
+  readCheckpointIntent,
+  removeCheckpointIntent,
+  sameCheckpointIntent,
+  updateCheckpointIntent,
+  writeCheckpointIntent
+} from './commit-intent.ts';
 
 type CommitExecutionMode = 'direct' | 'orchestrated';
 
@@ -27,7 +30,13 @@ type CommitOperationInput = Readonly<{
   taskRef?: string;
   agent?: string;
   mode?: CommitExecutionMode;
-  push: Readonly<{
+  round?: number;
+  delivery?: Readonly<{
+    mode: 'local' | 'push';
+    remote: string;
+    refs: readonly string[];
+  }> | Readonly<{ mode: 'local' }>;
+  push?: Readonly<{
     remote: string;
     refs: readonly string[];
   }>;
@@ -55,6 +64,7 @@ type BoundTask = Readonly<{
 }>;
 
 const HEAD_REF = /^refs\/heads\/(.+)$/;
+type CommitDelivery = Readonly<{ mode: 'local' } | { mode: 'push'; remote: string; refs: readonly string[] }>;
 
 function isCommitExecutionMode(value: unknown): value is CommitExecutionMode {
   return value === 'direct' || value === 'orchestrated';
@@ -68,6 +78,12 @@ function gitText(repoRoot: string, args: readonly string[]): string {
   }).trim();
 }
 
+function effectiveDelivery(input: CommitOperationInput): CommitDelivery | null {
+  if (input.delivery) return input.delivery;
+  if (input.push) return { mode: 'push', remote: input.push.remote, refs: input.push.refs };
+  return null;
+}
+
 function canonicalRepositoryRoot(cwd: string): string {
   return gitText(cwd, ['rev-parse', '--show-toplevel']);
 }
@@ -156,7 +172,8 @@ function validateCommon(input: CommitOperationInput, branch: string | null): Rea
   if (!input.message.trim()) return { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Commit message is required' };
   if (!/^[a-f0-9]{40,64}$/.test(input.expectedHead)) return { code: 'GIT_HEAD_EXPECTATION_REQUIRED', message: 'A valid expected HEAD is required' };
   if (!/^[a-f0-9]{40,64}$/.test(input.expectedTree)) return { code: 'GIT_TREE_EXPECTATION_REQUIRED', message: 'A valid expected tree is required' };
-  if (!input.push) return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Commit delivery requires a push policy' };
+  const delivery = effectiveDelivery(input);
+  if (!delivery) return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Commit delivery requires a delivery policy' };
   if (input.paths.some((candidate) => !candidate || candidate.startsWith('/') || candidate.split(/[\\/]/).includes('..'))) {
     return { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Commit paths must stay inside the repository' };
   }
@@ -164,42 +181,16 @@ function validateCommon(input: CommitOperationInput, branch: string | null): Rea
     return { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Sensitive paths cannot be committed' };
   }
   if (branch !== null && branch === '') return { code: 'GIT_BRANCH_INVALID', message: 'A named branch is required' };
-  if (!input.push.remote || input.push.refs.length !== 1) return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push requires one remote and one ref' };
-  const ref = input.push.refs[0] ?? '';
-  if (!HEAD_REF.test(ref) || HEAD_REF.exec(ref)?.[1] !== branch) {
-    return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push ref must be the current full heads ref' };
+  if (delivery.mode === 'push') {
+    if (!delivery.remote || delivery.refs.length !== 1) return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push requires one remote and one ref' };
+    const ref = delivery.refs[0] ?? '';
+    if (!HEAD_REF.test(ref) || HEAD_REF.exec(ref)?.[1] !== branch) {
+      return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push ref must be the current full heads ref' };
+    }
   }
   return null;
 }
 
-function validateOrchestrated(
-  input: CommitOperationInput,
-  task: BoundTask
-): { plan: OrchestrationStageCompletion } | { error: Readonly<{ code: string; message: string }> } {
-  if (!input.agent) return { error: { code: 'ORCHESTRATION_PROVENANCE_MISMATCH', message: 'orchestrated commit requires an agent' } };
-  const planned = planOrchestrationStageCompletion(task.taskId, {
-    stage: 'commit',
-    round: 1,
-    artifact: 'commit',
-    role: 'executor',
-    agent: input.agent
-  }, { repoRoot: task.repoRoot });
-  const run = planned.result.run;
-  if (
-    !planned.plan
-    || !run
-    || run.status !== 'running'
-    || !run.commitAuthorization.issuedAt
-    || run.commitAuthorization.consumedAt
-  ) return {
-    error: {
-      code: planned.result.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH',
-      message: planned.result.error?.message ?? 'orchestrated commit requires one matching activated commit delegation'
-    }
-  };
-  return { plan: planned.plan };
-}
-
 function syncTaskCommit(
   input: CommitOperationInput,
   task: BoundTask,
@@ -219,7 +210,18 @@ function syncTaskCommit(
     );
     const metadata = captureTaskWriteMetadata();
     const commitNote = gitText(task.repoRoot, ['show', '-s', '--format=%h %s', committedHead]);
-    const alreadyLogged = activity.entries.some((entry) => entry.step === 'Commit' && entry.note === commitNote);
+    let matchingCommitIndex = -1;
+    for (let index = activity.entries.length - 1; index >= 0; index -= 1) {
+      const entry = activity.entries[index]!;
+      if (entry.step === 'Commit' && entry.note === commitNote) {
+        matchingCommitIndex = index;
+        break;
+      }
+    }
+    const reviewedAfterCommit = matchingCommitIndex >= 0 && activity.entries
+      .slice(matchingCommitIndex + 1)
+      .some((entry) => /^Review Code \(Round \d+\)$/.test(entry.step));
+    const alreadyLogged = matchingCommitIndex >= 0 && !reviewedAfterCommit;
     const mutations: TaskMutation[] = [];
     if (!alreadyLogged) mutations.push({
       kind: 'section',
@@ -227,7 +229,10 @@ function syncTaskCommit(
       heading: activity.heading,
       body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Commit', agent: input.agent!, note: commitNote })
     });
-    const frontmatter: Record<string, string> = { assigned_to: input.agent! };
+    const frontmatter: Record<string, string> = {
+      assigned_to: input.agent!,
+      checkpoint_commit: committedHead
+    };
     mutations.push({ kind: 'frontmatter', set: frontmatter });
     if (mutations.length === 0) return null;
     const written = writeTask({
@@ -256,29 +261,133 @@ function syncTaskCommit(
   }
 }
 
+function checkpointChildMatches(task: BoundTask, intent: NonNullable<ReturnType<typeof readCheckpointIntent>>, head: string): boolean {
+  try {
+    const parent = gitText(task.repoRoot, ['rev-parse', `${head}^`]);
+    const tree = gitText(task.repoRoot, ['rev-parse', `${head}^{tree}`]);
+    const message = gitText(task.repoRoot, ['show', '-s', '--format=%s', head]);
+    const changed = gitText(task.repoRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', head]).split('\n').filter(Boolean).sort();
+    return parent === intent.expectedHead
+      && tree === intent.expectedTree
+      && message === intent.message
+      && JSON.stringify(changed) === JSON.stringify([...intent.paths].sort());
+  } catch {
+    return false;
+  }
+}
+
+function checkpointIdentity(input: CommitOperationInput, task: BoundTask, delivery: CommitDelivery): Parameters<typeof checkpointIntentDigest>[0] {
+  if (delivery.mode !== 'local') throw new Error('checkpoint identity requires local delivery');
+  return {
+    taskId: task.taskId,
+    branch: task.branch,
+    mode: 'local',
+    expectedHead: input.expectedHead,
+    expectedTree: input.expectedTree,
+    paths: [...input.paths],
+    message: input.message,
+    round: input.round ?? 1
+  };
+}
+
+function checkpointTimestamp(): string {
+  return new Date().toISOString();
+}
+
 function executeUnlocked(input: CommitOperationInput, task: BoundTask | null, mode: CommitExecutionMode): CommitOperationResult {
   const inspected = inspectGitWorkflow(input.cwd);
   if (!inspected.snapshot) return failure(input, mode, task?.taskId ?? null, 'GIT_INSPECT_FAILED', 'Unable to inspect Git repository');
+  if (mode === 'orchestrated') return failure(
+    input,
+    mode,
+    task?.taskId ?? null,
+    'ORCHESTRATED_COMMIT_REMOVED',
+    'Orchestrated commit is no longer a lifecycle stage; use local checkpoint delivery from code-task',
+    'blocked',
+    inspected.snapshot
+  );
   const branch = inspected.snapshot.branch;
   const commonError = validateCommon(input, branch);
   if (commonError) return failure(input, mode, task?.taskId ?? null, commonError.code, commonError.message, 'blocked', inspected.snapshot);
   if (task && task.state !== 'active') return failure(input, mode, task.taskId, 'TASK_STATE_INVALID', 'task-bound commit requires an active task', 'blocked', inspected.snapshot);
   if (task && task.branch !== branch) return failure(input, mode, task.taskId, 'GIT_BRANCH_MISMATCH', `Task branch '${task.branch}' does not match current branch '${branch}'`, 'blocked', inspected.snapshot);
   if (task && !input.agent) return failure(input, mode, task.taskId, 'COMMIT_AGENT_REQUIRED', 'task-bound commit requires an agent', 'blocked', inspected.snapshot);
-  const orchestrationValidation = mode === 'orchestrated'
-    ? (task
-      ? validateOrchestrated(input, task)
-      : { error: { code: 'ORCHESTRATION_TASK_REQUIRED', message: 'orchestrated commit requires a task context' } })
-    : null;
-  if (orchestrationValidation && 'error' in orchestrationValidation) {
-    const error = orchestrationValidation.error;
-    return failure(input, mode, task?.taskId ?? null, error.code, error.message, 'blocked', inspected.snapshot);
-  }
-  const orchestrationCompletion = orchestrationValidation && 'plan' in orchestrationValidation
-    ? orchestrationValidation.plan
-    : null;
-
-  const committed = input.paths.length === 0
+  const delivery = effectiveDelivery(input)!;
+  if (delivery.mode === 'local' && !task) return failure(input, mode, null, 'CHECKPOINT_TASK_REQUIRED', 'local checkpoint delivery requires a task context', 'blocked', inspected.snapshot);
+  let pendingIntent: NonNullable<ReturnType<typeof readCheckpointIntent>> | null = null;
+  let checkpointCommittedHead: string | null = null;
+  const committed = delivery.mode === 'local'
+    ? (() => {
+      const identity = checkpointIdentity(input, task!, delivery);
+      try {
+        pendingIntent = readCheckpointIntent(task!.repoRoot, task!.taskId);
+      } catch (error) {
+        return {
+          status: 'failed' as const, changed: false, snapshot: inspected.snapshot, operations: [],
+          error: { code: 'COMMIT_INTENT_INVALID', message: error instanceof Error ? error.message : String(error) }
+        };
+      }
+      if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity)) return {
+        status: 'failed' as const, changed: false, snapshot: inspected.snapshot, operations: [],
+        error: { code: 'COMMIT_INTENT_CONFLICT', message: 'A different checkpoint intent is still pending for this task' }
+      };
+      if (!pendingIntent) {
+        const timestamp = checkpointTimestamp();
+        pendingIntent = {
+          version: 1, ...identity, digest: checkpointIntentDigest(identity), state: 'prepared',
+          committedHead: null, createdAt: timestamp, updatedAt: timestamp
+        };
+        try { writeCheckpointIntent(task!.repoRoot, pendingIntent); }
+        catch (error) {
+          return {
+            status: 'failed' as const, changed: false, snapshot: inspected.snapshot, operations: [],
+            error: { code: 'COMMIT_INTENT_WRITE_FAILED', message: error instanceof Error ? error.message : String(error) }
+          };
+        }
+      }
+      if (pendingIntent.state !== 'prepared') {
+        checkpointCommittedHead = pendingIntent.committedHead;
+        return {
+          status: 'no-op' as const, changed: false, snapshot: inspected.snapshot,
+          operations: [{ name: 'commit', status: 'no-op' as const }], error: null
+        };
+      }
+      if (inspected.snapshot.head !== identity.expectedHead && !checkpointChildMatches(task!, pendingIntent, inspected.snapshot.head)) return {
+        status: 'failed' as const, changed: false, snapshot: inspected.snapshot, operations: [],
+        error: { code: 'COMMIT_INTENT_HEAD_CONFLICT', message: 'Current HEAD does not match the pending checkpoint intent' }
+      };
+      if (inspected.snapshot.head !== identity.expectedHead) {
+        checkpointCommittedHead = inspected.snapshot.head;
+        pendingIntent = updateCheckpointIntent(pendingIntent, {
+          state: 'committed', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
+        });
+        writeCheckpointIntent(task!.repoRoot, pendingIntent);
+        return {
+          status: 'no-op' as const, changed: false, snapshot: inspected.snapshot,
+          operations: [{ name: 'commit', status: 'no-op' as const }], error: null
+        };
+      }
+      if (input.paths.length === 0) return {
+        status: 'failed' as const, changed: false, snapshot: inspected.snapshot, operations: [],
+        error: { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Local checkpoint requires explicit paths' }
+      };
+      const created = commitExplicitPaths({
+        cwd: input.cwd, paths: input.paths, message: input.message,
+        expectedHead: identity.expectedHead, expectedTree: identity.expectedTree
+      });
+      if (created.status === 'applied' && created.snapshot?.head) {
+        checkpointCommittedHead = created.snapshot.head;
+        pendingIntent = updateCheckpointIntent(pendingIntent, {
+          state: 'committed', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
+        });
+        writeCheckpointIntent(task!.repoRoot, pendingIntent);
+      } else if (created.status === 'no-op') {
+        removeCheckpointIntent(task!.repoRoot, task!.taskId);
+        pendingIntent = null;
+      }
+      return created;
+    })()
+    : input.paths.length === 0
     ? (() => {
       if (inspected.snapshot.worktree.length > 0 || inspected.snapshot.staged.length > 0) return {
         status: 'failed' as const,
@@ -327,53 +436,42 @@ function executeUnlocked(input: CommitOperationInput, task: BoundTask | null, mo
   };
 
   const warnings: OperationWarning[] = [];
-  if (orchestrationCompletion) {
-    try {
-      commitOrchestrationStageCompletion(orchestrationCompletion);
-    } catch (error) {
-      warnings.push(warning(
-        'ORCHESTRATION_COMPLETION_FAILED',
-        error instanceof Error ? error.message : String(error),
-        true,
-        'orchestration',
-        task?.taskId ?? 'orchestration',
-        'ACTION_REQUIRED'
-      ));
-    }
-  }
   let status: CommitOperationResult['status'] = committed.status;
   let result: CommitOperationResult['result'] = committed.status === 'applied' ? 'committed' : 'no_op';
-  const target = `${input.push.remote}:${input.push.refs[0]}`;
-  const decision = commitPushDecision({ branch }, target);
-  if (!decision.shouldPush) {
-    warnings.push(decision.warning!);
-  } else {
-    const pushed = pushGitRefs({
-      cwd: input.cwd,
-      remote: input.push.remote,
-      refs: input.push.refs,
-      expectedSha: committed.snapshot?.head ?? gitText(input.cwd, ['rev-parse', 'HEAD'])
-    });
-    if (pushed.status !== 'applied') warnings.push(warning(
-      'COMMIT_PUSH_FAILED',
-      pushed.error?.message ?? 'Git push failed',
-      true,
-      'push',
-      target,
-      'ACTION_REQUIRED'
-    ));
+  if (delivery.mode === 'push') {
+    const target = `${delivery.remote}:${delivery.refs[0]}`;
+    const decision = commitPushDecision({ branch }, target);
+    if (!decision.shouldPush) {
+      warnings.push(decision.warning!);
+    } else {
+      const pushed = pushGitRefs({
+        cwd: input.cwd, remote: delivery.remote, refs: delivery.refs,
+        expectedSha: committed.snapshot?.head ?? gitText(input.cwd, ['rev-parse', 'HEAD'])
+      });
+      if (pushed.status !== 'applied') warnings.push(warning(
+        'COMMIT_PUSH_FAILED', pushed.error?.message ?? 'Git push failed', true, 'push', target, 'ACTION_REQUIRED'
+      ));
+    }
   }
   if (warnings.length > 0) {
     status = 'applied';
     result = 'committed_with_warnings';
   }
   if (task && (committed.status === 'applied' || committed.status === 'no-op')) {
-    const taskWarning = syncTaskCommit(input, task, committed.snapshot?.head ?? gitText(task.repoRoot, ['rev-parse', 'HEAD']));
+    const committedHead = checkpointCommittedHead ?? committed.snapshot?.head ?? gitText(task.repoRoot, ['rev-parse', 'HEAD']);
+    const taskWarning = syncTaskCommit(input, task, committedHead);
     if (taskWarning) {
       warnings.push(taskWarning);
       status = 'applied';
       result = 'committed_with_warnings';
     }
+    if (delivery.mode === 'local' && !taskWarning && pendingIntent && checkpointCommittedHead) {
+      const synced = updateCheckpointIntent(pendingIntent, {
+        state: 'synced', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
+      });
+      writeCheckpointIntent(task.repoRoot, synced);
+      removeCheckpointIntent(task.repoRoot, task.taskId);
+    }
   }
   return {
     status,

package/lib/task/control-authority.ts

@@ -206,15 +206,15 @@ function lifecycleTaskId(request: TaskLifecycleControlRequest, repoRoot: string)
   }
 }
 
-function applyLifecycleWithAuthority(
+async function applyLifecycleWithAuthority(
   context: TaskControlExecutionContext,
   request: TaskLifecycleControlRequest
-): TaskLifecycleResult & { humanOverride?: unknown } {
+): Promise<TaskLifecycleResult & { humanOverride?: unknown }> {
   const conflict = overrideDryRunConflict(request as unknown as Record<string, unknown>);
   if (conflict) {
     return taskLifecycleFailure(request, { code: 'LIFECYCLE_PAYLOAD_INVALID', message: conflict.message });
   }
-  const execute = (): TaskLifecycleResult & { humanOverride?: unknown } => {
+  const execute = async (): Promise<TaskLifecycleResult & { humanOverride?: unknown }> => {
     const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
     if (lifecycleResult.status !== 'failed' || !request.overrideTicket) return lifecycleResult;
     if (!request.overrideTarget || !request.overrideScope) {
@@ -223,7 +223,7 @@ function applyLifecycleWithAuthority(
         error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires --override-target and --override-scope' }
       };
     }
-    const override = consumeHumanOverride({
+    const override = await consumeHumanOverride({
       taskRef: request.taskRef,
       ticketId: request.overrideTicket,
       failureId: failureId('lifecycle.apply', lifecycleResult.error?.code ?? 'LIFECYCLE_FAILED'),
@@ -238,9 +238,9 @@ function applyLifecycleWithAuthority(
     return { ...lifecycleResult, ...override, humanOverride: override, error: null };
   };
   const taskId = lifecycleTaskId(request, context.repoRoot);
-  if (!taskId) return execute();
+  if (!taskId) return await execute();
   try {
-    return withTaskExecutionLock(
+    return await withTaskExecutionLock(
       context.repoRoot,
       taskId,
       `task-lifecycle.${request.intent}`,
@@ -322,11 +322,11 @@ function orchestrationFailure(error: unknown): OrchestrationResult {
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-lifecycle' }>
-): TaskLifecycleResult;
+): Promise<TaskLifecycleResult & { humanOverride?: unknown }>;
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-finalization' }>
-): TaskFinalizationResult;
+): Promise<TaskFinalizationResult>;
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-orchestration' }>
@@ -345,6 +345,9 @@ export function dispatchTaskControlOperation(
     operationTaskId(context, operation.request.taskRef);
     return applyTaskFinalization(operation.request, {
       repoRoot: context.repoRoot,
+      ...(context.source === 'sandbox-executor' ? {
+        controlBinding: { generation: context.generation, requestId: context.requestId }
+      } : {}),
       preflight: (request, options) => verifyTaskEvent(
         { ...request, event: 'complete-task.hard-preflight' }, options
       )

package/lib/task/create-service.ts

@@ -42,8 +42,8 @@ const DEFAULT_DEPENDENCIES: TaskCreateDependencies = {
   addWarning: applyWorkflowWarningIntent
 };
 
-function verifyCreatedTask(repoRoot: string, taskId: string): { operation: TaskCreateOperation; error: TaskCreateResult['error'] } {
-  const verification = verifyTaskEvent(
+async function verifyCreatedTask(repoRoot: string, taskId: string): Promise<{ operation: TaskCreateOperation; error: TaskCreateResult['error'] }> {
+  const verification = await verifyTaskEvent(
     { taskRef: taskId, event: 'create-task.completed' },
     { repoRoot }
   );
@@ -78,7 +78,7 @@ function issueFromTask(repoRoot: string, taskId: string): { number: number; url:
   return match ? { number: Number(match[1]), url: '' } : null;
 }
 
-function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResult {
+async function createTask(value: unknown, options: CreateTaskOptions): Promise<TaskCreateResult> {
   const dependencies = { ...DEFAULT_DEPENDENCIES, ...options.dependencies };
   let candidate: TaskCreateCandidateV1;
   let local;
@@ -101,13 +101,13 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
     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: PlatformResult | null = 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',
@@ -120,7 +120,7 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
     if (synced.issue) issue = { number: synced.issue.number, url: synced.issue.url };
     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;
     }
@@ -133,7 +133,7 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
       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 {
       status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
@@ -150,7 +150,7 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
     };
   }
 
-  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 {
     status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,

package/lib/task/create.ts

@@ -5,6 +5,8 @@ import path from 'node:path';
 import { isValidAgentInfraVersion, VERSION } from '../version.ts';
 import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
+import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.ts';
+import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.ts';
 
 const AGENTS = ['claude', 'codex', 'antigravity', 'opencode', 'cursor'] as const;
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'] as const;
@@ -30,6 +32,8 @@ type TaskCreateCandidateV1 = Readonly<{
   priority: TaskPriority;
   effort: TaskEffort;
   description: string;
+  deliveryRemote?: string;
+  deliveryBaseRef?: string;
   taskInput: Readonly<Record<typeof TASK_INPUT_KEYS[number], readonly string[]>>;
 }>;
 
@@ -49,12 +53,14 @@ function payloadError(message: string): never {
   throw new Error(`TASK_CREATE_PAYLOAD_INVALID: ${message}`);
 }
 
-function exactKeys(value: Record<string, unknown>, expected: readonly string[], label: string): void {
+function exactKeys(value: Record<string, unknown>, expected: readonly string[], label: string, optional: readonly string[] = []): void {
   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: unknown, label: string, maxBytes: number, oneLine = false): string {
@@ -78,7 +84,7 @@ function validateTaskCreateCandidate(value: unknown): TaskCreateCandidateV1 {
   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);
   if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(idempotencyKey)) {
@@ -91,6 +97,14 @@ function validateTaskCreateCandidate(value: unknown): TaskCreateCandidateV1 {
     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');
   }
@@ -111,6 +125,8 @@ function validateTaskCreateCandidate(value: unknown): TaskCreateCandidateV1 {
     priority: enumValue(candidate.priority, PRIORITIES, 'priority'),
     effort: enumValue(candidate.effort, EFFORTS, 'effort'),
     description,
+    ...(deliveryRemote === undefined ? {} : { deliveryRemote }),
+    ...(deliveryBaseRef === undefined ? {} : { deliveryBaseRef }),
     taskInput
   };
 }
@@ -127,6 +143,8 @@ function canonicalTaskCreateCandidate(candidate: TaskCreateCandidateV1): string
     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]]))
   });
 }
@@ -170,6 +188,7 @@ function renderTask(params: Readonly<{
   candidate: TaskCreateCandidateV1;
   taskId: string;
   project: string;
+  delivery: { remote: string; baseRef: string };
   timestamp: string;
   agentInfraVersion: string;
   keyDigest: string;
@@ -194,7 +213,11 @@ function renderTask(params: Readonly<{
     '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}`,
     '---'
@@ -219,12 +242,14 @@ function renderTask(params: Readonly<{
   return `${content.trimEnd()}\n`;
 }
 
-function readProject(repoRoot: string): string {
-  const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8')) as { project?: unknown };
+function readProject(repoRoot: string): { project: string; delivery: { remote: string; baseRef: string } } {
+  const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8')) as { project?: unknown; delivery?: { remote?: unknown; baseRef?: unknown } };
   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: string, code: string): void {
@@ -305,7 +330,7 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
   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);
@@ -346,7 +371,7 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
     const templateStat = fs.lstatSync(templatePath);
     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/lib/task/current-contract.ts

@@ -2,6 +2,8 @@ import { isValidAgentInfraVersion } from '../version.ts';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, validateLedgerRows } from './ledger.ts';
 import type { LedgerDocument } from './ledger.ts';
+import { parseInvalidationDocument } from './invalidation.ts';
+import type { InvalidationDocument } from './invalidation.ts';
 
 type CurrentTaskContractErrorCode = 'TASK_DOCUMENT_INVALID' | 'TASK_CURRENT_CONTRACT_INVALID';
 type CurrentTaskContractResult =
@@ -9,6 +11,7 @@ type CurrentTaskContractResult =
       ok: true;
       metadata: ReturnType<typeof parseTypedTaskFrontmatter>;
       ledger: LedgerDocument;
+      invalidation: InvalidationDocument;
     }
   | {
       ok: false;
@@ -42,7 +45,9 @@ function validateCurrentTaskContract(content: string): CurrentTaskContractResult
   }
   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 };