@fitlab-ai/agent-infra 0.9.11 → 0.9.12

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,
@@ -227,7 +218,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 +250,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 +425,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/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/decision-details.ts

@@ -36,7 +36,6 @@ type DecisionDetailResolution =
 type DecisionDetailDuplicate = {
   id: string;
   blocks: DecisionDetailBlock[];
-  repairable: boolean;
 };
 
 type DecisionDetailInspection =
@@ -49,15 +48,6 @@ type DecisionDetailInspection =
       duplicates: DecisionDetailDuplicate[];
     };
 
-type DecisionDetailRepair =
-  | { ok: true; changed: boolean; content: string }
-  | {
-      ok: false;
-      code: 'DECISION_DETAIL_AMBIGUOUS';
-      message: string;
-      content: string;
-    };
-
 const DECISION_ID = /^(AN|PL|CD|HD)-[1-9]\d*(?=$|[\s:：])/i;
 const HEADING = /^ {0,3}(#{1,6})[ \t]+(.+?)\s*$/;
 const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
@@ -172,32 +162,8 @@ function resolveDecisionDetail(content: string, rowId: string, anchor: string):
   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: DecisionDetailBlock): boolean {
-  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: DecisionDetailBlock, scanned: VisibleMarkdown): boolean {
-  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: string): DecisionDetailInspection {
   const blocks = parseDecisionDetailBlocks(content);
-  const scanned = scanVisibleMarkdown(content);
   const grouped = new Map<string, DecisionDetailBlock[]>();
   for (const block of blocks) {
     const key = block.id.toUpperCase();
@@ -208,16 +174,12 @@ function inspectDecisionDetailDuplicates(content: string): DecisionDetailInspect
   const duplicates: DecisionDetailDuplicate[] = [];
   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,
@@ -228,26 +190,6 @@ function inspectDecisionDetailDuplicates(content: string): DecisionDetailInspect
   };
 }
 
-function repairDecisionDetailDuplicates(content: string): DecisionDetailRepair {
-  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 };
-}
-
 type FieldKey = 'decision' | 'why' | 'impact' | 'risk' | 'analogy' | 'recommend' | 'reason' | 'implementation';
 
 const FIELD_KEYS: Record<string, FieldKey> = {
@@ -328,13 +270,11 @@ export {
   normalizeDecisionDetailForDisplay,
   parseDecisionDetailBlocks,
   parseDecisionEvidence,
-  repairDecisionDetailDuplicates,
   resolveDecisionDetail
 };
 export type {
   DecisionDetailBlock,
   DecisionDetailDuplicate,
   DecisionDetailInspection,
-  DecisionDetailRepair,
   DecisionDetailResolution
 };