@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/task/control-authority.ts

@@ -2,27 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
-import { isAgentClientId } from '../agent-clients/types.ts';
-import type { AgentClientId } from '../agent-clients/types.ts';
 import { sandboxControlPaths } from '../sandbox/workspace-view.ts';
-import { getAgentClientAdapter } from '../agent-clients/registry.ts';
-import {
-  activateMatchingOrchestrationDelegation,
-  activateOrchestrationDelegation,
-  advanceOrchestration,
-  awaitOrchestrationDelegationActivation,
-  beginOrResumeOrchestration,
-  dispatchOrchestrationDelegation,
-  OrchestrationStateError,
-  pauseOrchestration,
-  prepareOrchestrationDelegation,
-  recoverPreparedOrchestrationDelegation,
-  routeOrchestration,
-  sealMatchingOrchestrationDelegation,
-  sealOrchestrationDelegation,
-  statusOrchestration
-} from './orchestration.ts';
-import type { OrchestrationOptions, OrchestrationResult } from './orchestration.ts';
 import {
   applyTaskFinalization,
   type TaskFinalizationRequest,
@@ -33,11 +13,7 @@ import {
   type TaskLifecycleRequest,
   type TaskLifecycleResult
 } from './lifecycle.ts';
-import type {
-  AgentClientLifecycleRecoveryRequest as LifecycleRecoveryRequest,
-  AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult
-} from '../agent-clients/adapter.ts';
-import { resolveTaskContext, resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
+import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
 import { verifyTaskEvent } from './verification.ts';
 import { releaseStaleShortIdRegistry } from './short-id.ts';
 
@@ -62,39 +38,11 @@ export type TaskControlExecutionContext =
       requestId: string;
     }>;
 
-export type TaskControlOrchestrationIntent =
-  | 'begin-or-resume'
-  | 'route'
-  | 'prepare'
-  | 'dispatch'
-  | 'await-activation'
-  | 'recover-prepared'
-  | 'hook-start'
-  | 'hook-stop'
-  | 'advance'
-  | 'pause'
-  | 'status';
-
 export type TaskControlOperation =
   | Readonly<{ family: 'task-lifecycle'; request: TaskLifecycleControlRequest }>
-  | Readonly<{ family: 'task-finalization'; request: TaskFinalizationRequest }>
-  | Readonly<{
-      family: 'task-orchestration';
-      taskRef: string;
-      intent: TaskControlOrchestrationIntent;
-      input: Readonly<Record<string, unknown>>;
-      options?: Omit<OrchestrationOptions, 'repoRoot'>;
-    }>;
+  | Readonly<{ family: 'task-finalization'; request: TaskFinalizationRequest }>;
 
-export type TaskControlDispatchResult = TaskLifecycleResult | LifecycleRecoveryResult | TaskFinalizationResult | OrchestrationResult;
-
-export function taskControlOperationKey(operation: TaskControlOperation): string {
-  if (operation.family === 'task-finalization') return 'complete';
-  if (operation.family === 'task-lifecycle') return operation.request.intent;
-  return operation.intent === 'route'
-    ? operation.input && operation.input.completed === true ? 'route.clean-completion' : 'route.read'
-    : operation.intent;
-}
+export type TaskControlDispatchResult = TaskLifecycleResult | TaskFinalizationResult;
 
 export type TaskLifecycleControlRequest = TaskLifecycleRequest;
 
@@ -178,26 +126,6 @@ function boundTaskRef(context: TaskControlExecutionContext, taskRef: string): st
   return context.source === 'sandbox-executor' ? context.taskId : taskRef;
 }
 
-function autoTaskOptions(
-  context: TaskControlExecutionContext,
-  options: OrchestrationOptions
-): OrchestrationOptions {
-  if (context.source === 'sandbox-executor') return { ...options, taskId: context.taskId };
-  const resolved = resolveTaskContext(undefined, { repoRoot: context.repoRoot });
-  if (!resolved.ok) throw new Error(`${resolved.code}: ${resolved.message}`);
-  return { ...options, taskId: resolved.taskId };
-}
-
-function domainOptions(
-  context: TaskControlExecutionContext,
-  options: Omit<OrchestrationOptions, 'repoRoot'> | undefined
-): OrchestrationOptions {
-  return {
-    ...options,
-    repoRoot: context.repoRoot
-  };
-}
-
 function lifecycleTaskId(request: TaskLifecycleControlRequest, repoRoot: string): string | null {
   if (request.intent === 'restore') return TASK_ID_RE.test(request.taskRef) ? request.taskRef : null;
   try {
@@ -211,23 +139,10 @@ function lifecycleTaskId(request: TaskLifecycleControlRequest, repoRoot: string)
 async function applyLifecycleWithAuthority(
   context: TaskControlExecutionContext,
   request: TaskLifecycleControlRequest
-): Promise<TaskLifecycleResult | LifecycleRecoveryResult> {
+): Promise<TaskLifecycleResult> {
   const taskId = lifecycleTaskId(request, context.repoRoot);
   const controlRoot = taskId ? controlRootForTask(context, taskId) : undefined;
-  const execute = async (): Promise<TaskLifecycleResult | LifecycleRecoveryResult> => {
-    if (request.intent === 'recover-started') {
-      const adapter = isAgentClientId(request.agent)
-        ? getAgentClientAdapter(request.agent).orchestrationAdapter
-        : undefined;
-      if (!adapter?.recoverStarted) {
-        return {
-          status: 'no-op', changed: false, targetState: 'active',
-          requestRef: request.taskRef, intent: 'recover-started', taskId: null,
-          receiptId: null, childId: null, error: null
-        };
-      }
-      return adapter.recoverStarted(request as LifecycleRecoveryRequest, { repoRoot: context.repoRoot });
-    }
+  const execute = async (): Promise<TaskLifecycleResult> => {
     return applyTaskLifecycle(request, {
       repoRoot: context.repoRoot,
       ...(controlRoot ? { controlRoot } : {}),
@@ -248,94 +163,14 @@ function controlRootForTask(context: TaskControlExecutionContext, taskId: string
   }).root;
 }
 
-function orchestration(
-  context: TaskControlExecutionContext,
-  operation: Extract<TaskControlOperation, { family: 'task-orchestration' }>
-): OrchestrationResult | Promise<OrchestrationResult> {
-  const taskRef = boundTaskRef(context, operation.taskRef);
-  const input = operation.input;
-  const options = domainOptions(context, operation.options);
-  switch (operation.intent) {
-    case 'begin-or-resume':
-      return beginOrResumeOrchestration(taskRef, {
-        ...options,
-        client: input.client as AgentClientId,
-        maxSteps: input.maxSteps as number | undefined,
-        modelPolicy: input.modelPolicy as OrchestrationOptions['modelPolicy']
-      });
-    case 'route': return routeOrchestration(taskRef, options);
-    case 'status': return statusOrchestration(taskRef, options);
-    case 'prepare': return prepareTaskOrchestration(context, { ...operation, taskRef }, options);
-    case 'dispatch': return dispatchOrchestrationDelegation(taskRef, options);
-    case 'await-activation':
-      return awaitOrchestrationDelegationActivation(taskRef, input.event as never, options);
-    case 'recover-prepared': return recoverPreparedOrchestrationDelegation(taskRef, options);
-    case 'hook-start':
-      return input.auto === true
-        ? activateMatchingOrchestrationDelegation(
-            input.client as AgentClientId, input.event as never, autoTaskOptions(context, options)
-          )
-        : activateOrchestrationDelegation(taskRef, input.event as never, options);
-    case 'hook-stop':
-      return input.auto === true
-        ? sealMatchingOrchestrationDelegation(
-            input.client as AgentClientId, input.event as never, autoTaskOptions(context, options)
-          )
-        : sealOrchestrationDelegation(taskRef, input.event as never, undefined, options);
-    case 'advance': return advanceOrchestration(taskRef, options);
-    case 'pause':
-      return pauseOrchestration(
-        taskRef,
-        input.code as string,
-        input.message as string,
-        input.recoverable as boolean,
-        options
-      );
-  }
-}
-
-function prepareTaskOrchestration(
-  context: TaskControlExecutionContext,
-  operation: Extract<TaskControlOperation, { family: 'task-orchestration' }>,
-  options: OrchestrationOptions
-): OrchestrationResult | Promise<OrchestrationResult> {
-  const input = operation.input;
-  const prepareInput = {
-    client: input.client as AgentClientId,
-    requestedModel: input.requestedModel as string | undefined,
-    requestedReasoningEffort: input.requestedReasoningEffort as string | undefined,
-  };
-  const prepareDelegation = getAgentClientAdapter(prepareInput.client).orchestrationAdapter?.prepareDelegation;
-  return prepareDelegation
-    ? prepareDelegation(operation.taskRef, prepareInput, {
-      repoRoot: context.repoRoot,
-      orchestrationOptions: options,
-    })
-    : prepareOrchestrationDelegation(operation.taskRef, prepareInput, options);
-}
-
-function orchestrationFailure(error: unknown): OrchestrationResult {
-  if (error instanceof OrchestrationStateError) {
-    return {
-      status: 'failed', changed: false, taskId: error.taskId, run: null, next: null,
-      error: { code: error.code, message: error.message }
-    };
-  }
-  throw error;
-}
-
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-lifecycle' }>
-): Promise<TaskLifecycleResult | LifecycleRecoveryResult>;
+): Promise<TaskLifecycleResult>;
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-finalization' }>
 ): Promise<TaskFinalizationResult>;
-export function dispatchTaskControlOperation(
-  context: TaskControlExecutionContext,
-  operation: Extract<TaskControlOperation, { family: 'task-orchestration' }>
-): OrchestrationResult | Promise<OrchestrationResult>;
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: TaskControlOperation
@@ -389,12 +224,7 @@ export function dispatchTaskControlOperation(
       }
     });
   }
-  try {
-    const result = orchestration(context, operation);
-    return result instanceof Promise ? result.catch(orchestrationFailure) : result;
-  } catch (error) {
-    return orchestrationFailure(error);
-  }
+  throw new Error('TASK_CONTROL_OPERATION_INVALID: unsupported operation family');
 }
 
 export function assertTaskControlOperation(operation: TaskControlOperation): void {
@@ -410,9 +240,6 @@ export function assertTaskControlOperation(operation: TaskControlOperation): voi
     }
     return;
   }
-  if (!operation.taskRef || !operation.intent || !operation.input || typeof operation.input !== 'object' || Array.isArray(operation.input)) {
-    throw new Error('TASK_CONTROL_OPERATION_INVALID: orchestration operation is invalid');
-  }
 }
 
 function operationInvalid(message: string): never {
@@ -421,20 +248,11 @@ function operationInvalid(message: string): never {
 
 const LIFECYCLE_FLAGS = new Set([
   '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-  '--auto', '--dry-run'
+  '--dry-run'
 ]);
 
 const FINALIZATION_FLAGS = new Set(['--agent']);
 
-const ORCHESTRATION_FLAGS = new Set([
-  '--agent', '--max-steps', '--executor-model', '--executor-reasoning-effort', '--reviewer-model',
-  '--reviewer-reasoning-effort', '--client', '--requested-model', '--requested-reasoning-effort',
-  '--parent-id', '--before-fingerprint', '--stage', '--round', '--artifact', '--role',
-  '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
-  '--model-fallback-reason', '--reasoning-effort-fallback-reason', '--exit-code', '--after-fingerprint',
-  '--changed-paths', '--code', '--message', '--recoverable'
-]);
-
 function parseValues(
   args: readonly string[],
   start: number,
@@ -443,7 +261,7 @@ function parseValues(
   const values: Record<string, string | boolean> = {};
   for (let index = start; index < args.length; index += 1) {
     const flag = args[index]!;
-    if (flag === '--dry-run' || flag === '--auto') {
+    if (flag === '--dry-run') {
       if (!flags.has(flag)) operationInvalid(`unknown option '${flag}'`);
       if (values[flag] !== undefined) operationInvalid(`duplicate option '${flag}'`);
       values[flag] = true;
@@ -463,13 +281,8 @@ function value(values: Record<string, string | boolean>, flag: string): string |
   return typeof current === 'string' ? current : undefined;
 }
 
-function required(values: Record<string, string | boolean>, flags: readonly string[]): void {
-  const missing = flags.find((flag) => value(values, flag) === undefined);
-  if (missing) operationInvalid(`option '${missing}' is required`);
-}
-
 export function parseTaskControlOperation(
-  family: 'task-lifecycle' | 'task-orchestration' | 'task-finalization',
+  family: 'task-lifecycle' | 'task-finalization',
   args: readonly string[]
 ): TaskControlOperation {
   if (family === 'task-finalization') {
@@ -484,124 +297,21 @@ export function parseTaskControlOperation(
   if (args.length < 2) operationInvalid('task ref and intent are required');
   const taskRef = args[0]!;
   const intent = args[1]!;
-  if (family === 'task-lifecycle') {
-    if (intent === 'complete') operationInvalid('complete must use task-finalization');
-    const values = parseValues(args, 2, LIFECYCLE_FLAGS);
-    const agent = normalizeAgentToken(value(values, '--agent') ?? '');
-    if (!agent) operationInvalid('lifecycle agent is invalid');
-    const input: Record<string, unknown> = {
-      taskRef,
-      intent,
-      agent,
-      ...(value(values, '--reason') ? { reason: value(values, '--reason') } : {}),
-      ...(value(values, '--unblock-condition') ? { unblockCondition: value(values, '--unblock-condition') } : {}),
-      ...(value(values, '--note') ? { note: value(values, '--note') } : {}),
-      ...(value(values, '--staging-dir') ? { stagingDir: value(values, '--staging-dir') } : {}),
-      ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
-      ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
-      ...(values['--auto'] === true ? { auto: true } : {}),
-      ...(values['--dry-run'] === true ? { dryRun: true } : {})
-    };
-    if (intent === 'recover-started') {
-      const recoveryFlags = new Set(['--agent', '--auto']);
-      for (const flag of Object.keys(values)) {
-        if (!recoveryFlags.has(flag)) operationInvalid(`option '${flag}' is not supported for recover-started`);
-      }
-      if (values['--auto'] !== true) operationInvalid('--auto is required for recover-started');
-      return { family, request: input as unknown as TaskLifecycleControlRequest };
-    } else if (values['--auto'] !== undefined) {
-      operationInvalid('--auto is only supported for recover-started');
-    }
-    return { family, request: input as unknown as TaskLifecycleControlRequest };
-  }
-
-  const values = parseValues(args, 2, ORCHESTRATION_FLAGS);
-  const orchestrationIntents = new Set<TaskControlOrchestrationIntent>([
-    'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
-    'hook-start', 'hook-stop', 'advance', 'pause', 'status'
-  ]);
-  if (!orchestrationIntents.has(intent as TaskControlOrchestrationIntent)) {
-    operationInvalid(`unknown orchestration intent '${intent}'`);
-  }
-  const client = value(values, '--client');
-  if (client !== undefined && !isAgentClientId(client)) operationInvalid(`unknown client '${client}'`);
-  const parsedIntent = intent as TaskControlOrchestrationIntent;
-  const input: Record<string, unknown> = {};
-  if (parsedIntent === 'begin-or-resume' || parsedIntent === 'prepare') {
-    required(values, ['--client']);
-    if (!client || !isAgentClientId(client)) operationInvalid(`unknown client '${client ?? ''}'`);
-    input.client = client;
-  }
-  if (parsedIntent === 'begin-or-resume') {
-    const maxSteps = value(values, '--max-steps');
-    if (maxSteps !== undefined) {
-      const parsed = Number(maxSteps);
-      if (!Number.isInteger(parsed) || parsed < 1) operationInvalid('--max-steps must be a positive integer');
-      input.maxSteps = parsed;
-    }
-    const policyFlags = ['--executor-model', '--executor-reasoning-effort', '--reviewer-model', '--reviewer-reasoning-effort'];
-    const hasPolicy = policyFlags.some((flag) => value(values, flag) !== undefined);
-    if (hasPolicy && policyFlags.some((flag) => value(values, flag) === undefined)) {
-      operationInvalid('explicit model policy requires executor/reviewer model and reasoning effort');
-    }
-    if (hasPolicy) {
-      input.modelPolicy = {
-        executor: { model: value(values, '--executor-model'), reasoningEffort: value(values, '--executor-reasoning-effort') },
-        reviewer: { model: value(values, '--reviewer-model'), reasoningEffort: value(values, '--reviewer-reasoning-effort') }
-      };
-    }
-  }
-  if (parsedIntent === 'prepare') {
-    input.requestedModel = value(values, '--requested-model');
-    input.requestedReasoningEffort = value(values, '--requested-reasoning-effort');
-  }
-  if (parsedIntent === 'await-activation') {
-    required(values, ['--stage', '--round', '--artifact', '--role']);
-    const round = Number(value(values, '--round'));
-    if (!Number.isSafeInteger(round) || round < 1) operationInvalid('--round must be a positive integer');
-    const role = value(values, '--role');
-    if (role !== 'executor' && role !== 'reviewer') operationInvalid('--role must be executor or reviewer');
-    input.event = { stage: value(values, '--stage'), round, artifact: value(values, '--artifact'), role };
-  }
-  if (parsedIntent === 'hook-start') {
-    required(values, ['--native-agent', '--child-id', '--parent-id']);
-    if (taskRef === 'auto') required(values, ['--client']);
-    input.auto = taskRef === 'auto';
-    input.client = value(values, '--client');
-    input.event = {
-      nativeAgent: value(values, '--native-agent'), childId: value(values, '--child-id'), parentId: value(values, '--parent-id'),
-      spawnMode: value(values, '--spawn-mode'), actualModel: value(values, '--actual-model'),
-      actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-      reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-    };
-  }
-  if (parsedIntent === 'hook-stop') {
-    input.auto = taskRef === 'auto';
-    if (input.auto) {
-      required(values, ['--client', '--native-agent', '--child-id']);
-      input.client = value(values, '--client');
-      input.event = {
-        nativeAgent: value(values, '--native-agent'), childId: value(values, '--child-id'), actualModel: value(values, '--actual-model'),
-        actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-        reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-      };
-    } else {
-      required(values, ['--child-id', '--exit-code', '--after-fingerprint']);
-      const exitCode = Number(value(values, '--exit-code'));
-      if (!Number.isInteger(exitCode)) operationInvalid('--exit-code must be an integer');
-      input.event = {
-        childId: value(values, '--child-id'), exitCode, afterFingerprint: value(values, '--after-fingerprint'),
-        changedPaths: value(values, '--changed-paths')?.split(',').filter(Boolean) ?? [], actualModel: value(values, '--actual-model'),
-        actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-        reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-      };
-    }
-  }
-  if (parsedIntent === 'pause') {
-    required(values, ['--code', '--message', '--recoverable']);
-    const recoverable = value(values, '--recoverable');
-    if (recoverable !== 'true' && recoverable !== 'false') operationInvalid('--recoverable must be true or false');
-    input.code = value(values, '--code'); input.message = value(values, '--message'); input.recoverable = recoverable === 'true';
-  }
-  return { family, taskRef, intent: parsedIntent, input };
+  if (intent === 'complete') operationInvalid('complete must use task-finalization');
+  const values = parseValues(args, 2, LIFECYCLE_FLAGS);
+  const agent = normalizeAgentToken(value(values, '--agent') ?? '');
+  if (!agent) operationInvalid('lifecycle agent is invalid');
+  const request: Record<string, unknown> = {
+    taskRef,
+    intent,
+    agent,
+    ...(value(values, '--reason') ? { reason: value(values, '--reason') } : {}),
+    ...(value(values, '--unblock-condition') ? { unblockCondition: value(values, '--unblock-condition') } : {}),
+    ...(value(values, '--note') ? { note: value(values, '--note') } : {}),
+    ...(value(values, '--staging-dir') ? { stagingDir: value(values, '--staging-dir') } : {}),
+    ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
+    ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
+    ...(values['--dry-run'] === true ? { dryRun: true } : {})
+  };
+  return { family, request: request as unknown as TaskLifecycleControlRequest };
 }

package/lib/task/control-recovery.ts

@@ -51,7 +51,7 @@ export type ControlRecoveryDecision = Readonly<{
   reasonCode: string;
 }>;
 
-const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'] as const;
+const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'close-codescan', 'close-dependabot', 'restore'] as const;
 export const SANDBOX_CONTROL_RECOVERY_OPERATIONS: readonly ControlRecoveryOperation[] = Object.freeze([
   ...LIFECYCLE_INTENTS.map((intent) => ({ family: 'task-lifecycle' as const, intent, class: 'lifecycle-mutation' })),
   { family: 'task-create', intent: 'create', class: 'task-create' }
@@ -73,13 +73,10 @@ function bindingMatchesResult(binding: ControlRecoveryBinding, result: Readonly<
 }
 
 function domainEvidenceMatches(
-  operation: ControlRecoveryOperation,
-  result: Readonly<Record<string, unknown>>,
   domain: Readonly<Record<string, unknown>> | null | undefined
 ): boolean {
   if (!domain) return false;
   if (domain.consistent !== true) return false;
-  if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started') return false;
   return true;
 }
 
@@ -110,7 +107,7 @@ export function classifySandboxControlRecovery(input: ControlRecoveryInput): Con
   if (result.changed === null) {
     return { outcome: 'unknown', responseReconstructable: false, reasonCode: 'RECOVERY_RESULT_CHANGE_FLAG_MISSING' };
   }
-  if (!domainEvidenceMatches(input.operation, result, input.domain)) {
+  if (!domainEvidenceMatches(input.domain)) {
     if (input.journal?.exists && (input.journal.completedSteps?.length ?? 0) > 0) {
       return { outcome: 'in-progress', responseReconstructable: false, reasonCode: 'RECOVERY_DOMAIN_EVIDENCE_INCOMPLETE' };
     }

package/lib/task/create.ts

@@ -9,6 +9,7 @@ import { readDeliveryDefaults, validateBaseRef, validateRemote } from './deliver
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.ts';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.ts';
 import { enumerateAllTaskDirs } from './resolve-ref.ts';
+import { serializeLifecycleExecution } from './lifecycle-execution.ts';
 import { parseTaskFrontmatter } from './frontmatter.ts';
 import { AGENT_TOKEN_VALUES, type AgentToken } from '../agent-clients/tokens.ts';
 import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
@@ -59,7 +60,6 @@ function payloadError(message: string): never {
 
 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();
   const allowed = new Set([...expected, ...optional]);
   if (actual.some((key) => !allowed.has(key))) {
     payloadError(`${label} has unknown or missing fields`);
@@ -170,10 +170,6 @@ function taskIdFor(date: Date): string {
   return `TASK-${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
 }
 
-function yamlString(value: string): string {
-  return JSON.stringify(value);
-}
-
 function markdownBlock(value: string): string {
   return value.split(/\r?\n/).map((line) => /^(?:#{1,6}\s|```)/.test(line) ? `\\${line}` : line).join('\n');
 }
@@ -289,6 +285,7 @@ function renderTask(params: Readonly<{
     'target_date:',
     'current_step: requirement-analysis',
     `assigned_to: ${candidate.agent}`,
+    `lifecycle_execution: ${JSON.stringify(serializeLifecycleExecution([]))}`,
     `pr_delivery_fact: ${JSON.stringify(encodePrDeliveryFact(buildUnboundFact()))}`,
     `delivery_remote: ${candidate.deliveryRemote ?? params.delivery.remote}`,
     `delivery_base_ref: ${candidate.deliveryBaseRef ?? params.delivery.baseRef}`,

package/lib/task/decision-intents.ts

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 
-import { appendActivityEntry, locateActivityLog } from './activity-log.ts';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.ts';
 import { isDecisionItem, listDecisionItems, selectDecisionItem } from './decision-items.ts';
 import {
   createImplementationInput,
@@ -31,6 +31,7 @@ type HumanDecisionResult = {
   taskId: string | null; ledgerId: string | null; recordId: string | null;
   implementationInputId: string | null; operations: readonly TaskOperationSummary[];
   error: { code: string; message: string } | null;
+  warnings?: readonly { code: string; message: string }[];
 };
 
 const DECISION_ALIASES = ['人工裁决', 'Human Rulings', 'Human Decisions', 'Human Decision'] as const;
@@ -102,7 +103,7 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
     try {
       const replay = existingDecision(content, direct[0]!, request.decision.trim(), request.needsImplementation);
       if ('conflict' in replay) return failed('DECISION_CONFLICT', replay.conflict, resolved.taskId, direct[0]!.id);
-      return { status: 'no-op', changed: false, taskId: resolved.taskId, ledgerId: direct[0]!.id, recordId: replay.recordId, implementationInputId: replay.implementationInputId, operations: [], error: null };
+      return { status: 'no-op', changed: false, taskId: resolved.taskId, ledgerId: direct[0]!.id, recordId: replay.recordId, implementationInputId: replay.implementationInputId, operations: [], error: null, warnings: activityWarnings(content) };
     } catch (error) { return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, direct[0]!.id); }
   }
 
@@ -144,7 +145,6 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
   const decision = request.decision.trim();
   const record = `### ${recordId}\n\n- **原账本 ID**：${row.id}\n- **裁决时间**：${metadata.timestamp}\n- **裁决结果**：${decision}`;
   const activity = locateActivityLog(content);
-  if (!activity) return failed('DECISION_ACTIVITY_MISSING', 'activity log section is missing or ambiguous', resolved.taskId, row.id);
   const mutations: TaskMutation[] = [
     {
       kind: 'table-row', action: 'upsert', sectionAliases: LEDGER_HEADINGS, columns: LEDGER_COLUMNS,
@@ -172,7 +172,7 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
       body: renderImplementationInputs(nextInputs)
     });
   }
-  mutations.push({
+  if (activity) mutations.push({
     kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
     body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
   });
@@ -190,7 +190,7 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
     metadataProvider: () => metadata
   });
   if (writeResult.status === 'failed') return failed(writeResult.error.code, writeResult.error.message, writeResult.taskId, row.id);
-  return { status: writeResult.status, changed: writeResult.changed, taskId: writeResult.taskId, ledgerId: row.id, recordId, implementationInputId, operations: writeResult.operations, error: null };
+  return { status: writeResult.status, changed: writeResult.changed, taskId: writeResult.taskId, ledgerId: row.id, recordId, implementationInputId, operations: writeResult.operations, error: null, warnings: activityWarnings(content) };
 }
 
 export { applyHumanDecision };

package/lib/task/delivery-target.ts

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { execFileSync } from 'node:child_process';
 
 export type DeliveryTarget = Readonly<{
   remote: string;
@@ -82,49 +81,10 @@ function resolveDeliveryTarget(
   return bindDeliveryTarget({ defaults: defaults.value, existing, explicit });
 }
 
-function gitText(repoRoot: string, args: readonly string[]): string {
-  return execFileSync('git', [...args], {
-    cwd: repoRoot,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe']
-  }).trim();
-}
-
-function resolveTargetHead(repoRoot: string, target: DeliveryTarget): DeliveryTargetResult & { head?: string } {
-  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: string, reviewedHead: string, targetHead: string): DiffBaseResult {
-  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
 };