@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/task/platform-operation-recovery.ts

@@ -7,8 +7,8 @@ import { inspectPlatformCommentOperation, syncPlatformComment } from '../platfor
 import { parseDeliverySummaryContent, renderDeliverySummaryContent, parseCancelSummaryContent, renderCancelSummaryContent } from '../platform/issue-summary-content.ts';
 import { enumerateArtifacts } from './artifacts.ts';
 import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.ts';
-import { resolvePlatformProviderContext } from '../platform/context.ts';
-import { providerOperationContext, providerError, unsupportedProviderOperation } from '../platform/provider-bridge.ts';
+import '../platform/context.ts';
+import '../platform/provider-bridge.ts';
 import { inLabelMappingDigest } from '../platform/in-label-sync.ts';
 import { bindPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.ts';
 import { replayPullRequestSummary } from '../platform/pr-summary.ts';
@@ -21,11 +21,12 @@ import { operationId } from './platform-operation-journal.ts';
 import { canonicalizeSummaryBody } from '../platform/comment-safety.ts';
 import { platformResult } from '../platform/types.ts';
 import type { PlatformResult } from '../platform/types.ts';
+import { mergeOperationWarnings, type OperationWarning } from './operation-outcome.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import { readPlatformOperationJournal, recordPlatformOperation } from './platform-operation-journal.ts';
-import { providerErrorRetryable } from '../platform/provider-validation.ts';
+import '../platform/provider-validation.ts';
 
-type RecoveryOptions = Readonly<{ agent: string; client?: PlatformClient; cwd?: string; limit?: number; attempts?: number; excludeId?: string }>;
+type RecoveryOptions = Readonly<{ agent: string; client?: PlatformClient; cwd?: string; limit?: number; attempts?: number; excludeId?: string; beforeId?: string }>;
 const DEFAULT_RECOVERY_ATTEMPTS = 3;
 type RecoveryResult = Readonly<{
   status: 'applied' | 'no-op' | 'blocked' | 'failed';
@@ -33,6 +34,8 @@ type RecoveryResult = Readonly<{
   recovered: readonly string[];
   pending: readonly string[];
   error: { code: string; message: string } | null;
+  degraded?: readonly { id: string; reasonCode: string }[];
+  warnings?: readonly OperationWarning[];
 }>;
 type RecoveryError = { code: string; message: string; retryable?: boolean };
 
@@ -48,8 +51,8 @@ function fieldsMatchExpected(
   return Object.entries(expected).every(([name, value]) => actual[name] === value);
 }
 
-function result(status: RecoveryResult['status'], recovered: string[], pending: string[], error: RecoveryError | null = null): RecoveryResult {
-  return { status, changed: recovered.length > 0, recovered, pending, error: error ? { code: error.code, message: error.message } : null };
+function result(status: RecoveryResult['status'], recovered: string[], pending: string[], error: RecoveryError | null = null, warnings: readonly OperationWarning[] = []): RecoveryResult {
+  return { status, changed: recovered.length > 0, recovered, pending, error: error ? { code: error.code, message: error.message } : null, ...(warnings.length ? { warnings } : {}) };
 }
 
 function summaryPayload(taskDir: string, taskId: string): { body: string; sha256: string } | null {
@@ -164,7 +167,8 @@ async function replayIssueMetadata(taskId: string, operation: ReturnType<typeof
   }
   const issue = after.issue;
   const metadata = operation.issueMetadata;
-  const failedOperation = sync.operations.find((item) => item.status === 'failed' || item.status === 'skipped');
+  const failedOperation = sync.operations.find((item) => item.status === 'failed' || (item.status === 'skipped'
+    && !(sync.capabilities.push === false && ['fields', 'issue-type'].includes(item.name) && item.reasonCode === 'PUSH_REQUIRED')));
   if (failedOperation) return platformResult('blocked', { error: {
     code: failedOperation.reasonCode || 'PLATFORM_OPERATION_METADATA_UNCONFIRMED',
     message: `Issue metadata recovery did not confirm operation '${failedOperation.name}'`, retryable: true
@@ -189,7 +193,7 @@ async function replayIssueMetadata(taskId: string, operation: ReturnType<typeof
     code: 'PLATFORM_OPERATION_METADATA_UNCONFIRMED',
     message: 'Issue metadata differs from the requested recovery target after reread', retryable: true
   } });
-  return platformResult('no-op', { changed: sync.changed || after.changed });
+  return platformResult('no-op', { changed: sync.changed || after.changed, operations: sync.operations });
 }
 
 async function verifyIssueCreate(taskId: string, operation: ReturnType<typeof readPlatformOperationJournal>['operations'][number], cwd: string, client?: PlatformClient): Promise<PlatformResult> {
@@ -265,6 +269,12 @@ function isRecoveryEligible(operation: ReturnType<typeof readPlatformOperationJo
 ;
 }
 
+function recoveryCandidates(journal: ReturnType<typeof readPlatformOperationJournal>, options: RecoveryOptions) {
+  const boundary = options.beforeId ? journal.operations.findIndex((item) => item.id === options.beforeId) : journal.operations.length;
+  if (boundary < 0) throw Object.assign(new Error('Current platform operation boundary is unavailable'), { code: 'PLATFORM_OPERATION_BOUNDARY_MISSING' });
+  return journal.operations.slice(0, boundary).filter((item) => isRecoveryEligible(item, options.excludeId));
+}
+
 async function recoverPlatformOperationsOnce(
   taskRef: string,
   selection: 'required' | 'deferred' | 'all',
@@ -278,7 +288,9 @@ async function recoverPlatformOperationsOnce(
     const value = error as { code?: string; message?: string };
     return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
   }
-  const candidates = journal.operations.filter((operation) => isRecoveryEligible(operation, options.excludeId));
+  let candidates;
+  try { candidates = recoveryCandidates(journal, options); }
+  catch (error) { const value = error as { code: string; message: string }; return result('blocked', [], [], value); }
   if (!candidates.length) return result('no-op', [], []);
   const head = candidates[0]!;
   if (selection !== 'all' && head.dependency !== selection) {
@@ -291,8 +303,9 @@ async function recoverPlatformOperationsOnce(
   const limit = options.limit === undefined ? candidates.length : Math.max(1, options.limit);
   const recovered: string[] = [];
   const pending: string[] = [];
+  let warnings: readonly OperationWarning[] = [];
   const selected = candidates.slice(0, limit);
-  for (const [index, operation] of selected.entries()) {
+  for (const operation of selected) {
     {
       try {
         recordPlatformOperation({
@@ -368,7 +381,7 @@ async function recoverPlatformOperationsOnce(
         }
       }
     }
-    let remote: PlatformResult;
+    let remote: PlatformResult & { warnings?: readonly OperationWarning[] };
     try {
       remote = operation.kind === 'issue-create'
         ? await verifyIssueCreate(resolved.taskId, operation, resolved.repoRoot)
@@ -402,7 +415,7 @@ async function recoverPlatformOperationsOnce(
         ...(operation.pullRequestReview ? { pullRequestReview: operation.pullRequestReview } : {}),
         dependency: operation.dependency,
         state: succeeded ? 'succeeded' : 'unknown',
-        lastCode: remote.error?.code ?? latestOperation?.lastCode ?? null
+        lastCode: remote.error?.code ?? remote.operations.find((item) => item.status === 'skipped' && item.reasonCode === 'PUSH_REQUIRED')?.reasonCode ?? (succeeded ? null : latestOperation?.lastCode) ?? null
       });
     } catch (error) {
       const value = error as { code?: string; message?: string };
@@ -412,11 +425,12 @@ async function recoverPlatformOperationsOnce(
       pending.push(targetOperation.id);
       return result(remote.status === 'failed' ? 'failed' : 'blocked', recovered, pending, remote.error ?? { code: 'PLATFORM_OPERATION_RECOVERY_UNKNOWN', message: 'Platform operation outcome remains unknown', retryable: true });
     }
+      warnings = mergeOperationWarnings(warnings, remote.warnings ?? []);
       recovered.push(targetOperation.id);
   }
   const remaining = candidates.slice(limit).map((operation) => operation.id);
   pending.push(...remaining);
-  return result(pending.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, pending, pending.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain pending after the recovery budget', retryable: true } : null);
+  return result(pending.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, pending, pending.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain pending after the recovery budget', retryable: true } : null, warnings);
 }
 
 async function recoverPlatformOperations(
@@ -432,8 +446,9 @@ async function recoverPlatformOperations(
     const value = error as { code?: string; message?: string };
     return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
   }
-  const eligible = (operation: typeof initial.operations[number]) => isRecoveryEligible(operation, options.excludeId);
-  const first = initial.operations.filter(eligible);
+  let first;
+  try { first = recoveryCandidates(initial, options); }
+  catch (error) { const value = error as { code: string; message: string }; return result('blocked', [], [], value); }
   if (!first.length) return result('no-op', [], []);
   const operationLimit = options.limit === undefined ? first.length : Math.max(1, options.limit);
   const attemptLimit = options.attempts ?? DEFAULT_RECOVERY_ATTEMPTS;
@@ -441,47 +456,56 @@ async function recoverPlatformOperations(
     return result('failed', [], [], { code: 'PLATFORM_OPERATION_RECOVERY_PAYLOAD_INVALID', message: 'Recovery attempts must be a positive safe integer', retryable: false });
   }
   const recovered: string[] = [];
+  let warnings: readonly OperationWarning[] = [];
 
   for (let operationIndex = 0; operationIndex < operationLimit; operationIndex += 1) {
     let latest;
     try { latest = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot); }
     catch (error) {
       const value = error as { code?: string; message?: string };
-      return result('failed', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
+      return result('failed', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false }, warnings);
     }
-    const head = latest.operations.find(eligible);
+    let candidates;
+    try { candidates = recoveryCandidates(latest, options); }
+    catch (error) { const value = error as { code: string; message: string }; return result('blocked', recovered, [], value, warnings); }
+    const head = candidates[0];
     if (!head) break;
     if (selection !== 'all' && head.dependency !== selection) {
-      const pending = latest.operations.filter(eligible).map((operation) => operation.id);
+      const pending = candidates.map((operation) => operation.id);
       return result('blocked', recovered, pending, {
         code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
         message: 'The first unresolved platform operation belongs to another recovery selection',
         retryable: true
-      });
+      }, warnings);
     }
     let last: RecoveryResult | null = null;
     for (let attempt = 0; attempt < attemptLimit; attempt += 1) {
       last = await recoverPlatformOperationsOnce(taskRef, selection, { ...options, limit: 1 });
       recovered.push(...last.recovered.filter((id) => !recovered.includes(id)));
+      warnings = mergeOperationWarnings(warnings, last.warnings ?? []);
       if (last.recovered.length > 0 || last.status === 'applied' || last.status === 'no-op') break;
     }
     if (!last || (last.recovered.length === 0 && last.status !== 'applied' && last.status !== 'no-op')) {
       let current;
       try { current = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot); }
-      catch { return result('blocked', recovered, [head.id], last?.error ?? null); }
-      const pending = current.operations.filter(eligible).map((operation) => operation.id);
+      catch { return result('blocked', recovered, [head.id], last?.error ?? null, warnings); }
+      let pending: string[];
+      try { pending = recoveryCandidates(current, options).map((operation) => operation.id); }
+      catch (error) { const value = error as { code: string; message: string }; return result('blocked', recovered, [], value, warnings); }
       return result(last?.status === 'failed' ? 'failed' : 'blocked', recovered, pending, last?.error ?? {
         code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
         message: 'The first queued platform operation remains unresolved after this recovery run',
         retryable: true
-      });
+      }, warnings);
     }
   }
   let remaining: string[];
-  try { remaining = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.filter(eligible).map((operation) => operation.id); }
-  catch { remaining = []; }
-  return result(remaining.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, remaining,
-    remaining.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain queued after this recovery run', retryable: true } : null);
+  try { remaining = recoveryCandidates(readPlatformOperationJournal(resolved.taskId, resolved.repoRoot), options).map((operation) => operation.id); }
+  catch (error) { const value = error as { code?: string; message?: string }; return result('blocked', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || 'Unable to read platform operations' }, warnings); }
+  const output = result(remaining.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, remaining,
+    remaining.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain queued after this recovery run', retryable: true } : null, warnings);
+  const degraded = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.filter((item) => recovered.includes(item.id) && item.lastCode === 'PUSH_REQUIRED').map((item) => ({ id: item.id, reasonCode: item.lastCode! }));
+  return degraded.length ? { ...output, degraded } : output;
 }
 
 export { fieldsMatchExpected, labelsMatchOwnedPrefix, recoverPlatformOperations };

package/lib/task/pr-delivery-fact.ts

@@ -1,10 +1,5 @@
 import type { ResourceIdentity } from '../platform/resource-identity.ts';
-import {
-  isResourceIdentity,
-  parseResourceIdentity,
-  resourceIdentityNumber,
-  serializeResourceIdentity
-} from '../platform/resource-identity.ts';
+import { parseResourceIdentity, serializeResourceIdentity } from '../platform/resource-identity.ts';
 
 const PR_DELIVERY_FACT_KEY = 'pr_delivery_fact';
 
@@ -182,9 +177,5 @@ function buildBoundFact(input: {
   }, provenance: { establishedBy: provenanceForSource(input.source) } });
 }
 function factFrontmatterMutation(fact: PrDeliveryFact): { set: { [PR_DELIVERY_FACT_KEY]: string } } { return { set: { [PR_DELIVERY_FACT_KEY]: encodePrDeliveryFact(fact) } }; }
-function identityFromPullRequest(pullRequest: PrDeliveryIdentityInput): PrDeliveryIdentity {
-  return canonicalIdentity(pullRequest);
-}
-
-export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, identityFromPullRequest, readPrDeliveryFact, serializeResourceIdentity };
+export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, readPrDeliveryFact, serializeResourceIdentity };
 export type { CreationOutcome, PrDeliveryBindingSource, PrDeliveryFact, PrDeliveryFactError, PrDeliveryFactReadResult, PrDeliveryIdentity, PrDeliveryIdentityInput, PrDeliveryProvenance };

package/lib/task/qualification-confirmation.ts

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 
-import { appendActivityEntry, locateActivityLog } from './activity-log.ts';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.ts';
 import { CONFIRMATION_COLUMNS, CONFIRMATION_HEADINGS, constraintDigest, parseQualificationConfirmations, parseTaskQualification } from './qualification-audit.ts';
 import type { QualificationConfirmation } from './qualification-audit.ts';
 import { findSectionHeading } from './sections.ts';
@@ -25,6 +25,7 @@ type QualificationConfirmationResult = {
   requestId: string | null;
   operations: readonly TaskOperationSummary[];
   error: { code: string; message: string } | null;
+  warnings?: readonly { code: string; message: string }[];
 };
 
 function failed(code: string, message: string, taskId: string | null = null): QualificationConfirmationResult {
@@ -73,13 +74,13 @@ function applyQualificationConfirmation(request: QualificationConfirmationReques
   const previous = existing.confirmations.find((row) => row.qcrId === constraint.approvalEvidence);
   if (operation === 'confirm' && constraint.status === 'confirmed') {
     if (previous?.constraintId === constraint.constraintId && previous.approvedDigest === constraint.digest && previous.rationale === request.rationale.trim()) {
-      return { status: 'no-op', changed: false, taskId: resolved.taskId, qcrId: previous.qcrId, requestId: previous.requestId, operations: [], error: null };
+      return { status: 'no-op', changed: false, taskId: resolved.taskId, qcrId: previous.qcrId, requestId: previous.requestId, operations: [], error: null, warnings: activityWarnings(content) };
     }
     return failed('QUALIFICATION_CONFIRMATION_CONFLICT', `constraint '${request.constraintId}' is already confirmed with different evidence`, resolved.taskId);
   }
   const transitionStatus = operation === 'supersede' ? 'superseded' : 'open';
   if (operation !== 'confirm' && constraint.status === transitionStatus && !constraint.approvalEvidence) {
-    return { status: 'no-op', changed: false, taskId: resolved.taskId, qcrId: null, requestId: null, operations: [], error: null };
+    return { status: 'no-op', changed: false, taskId: resolved.taskId, qcrId: null, requestId: null, operations: [], error: null, warnings: activityWarnings(content) };
   }
   if (operation !== 'confirm' && constraint.status !== 'confirmed') return failed('QUALIFICATION_CONFIRMATION_REQUIRED', `constraint '${request.constraintId}' is not confirmed`, resolved.taskId);
   if (parsed.qualification.constraintDigest !== request.expectedDigest) return failed('QUALIFICATION_DIGEST_CONFLICT', 'constraint digest changed before human confirmation', resolved.taskId);
@@ -99,18 +100,17 @@ function applyQualificationConfirmation(request: QualificationConfirmationReques
   } : null;
   const confirmations = confirmation ? [...existing.confirmations, confirmation] : existing.confirmations;
   const activity = locateActivityLog(content);
-  if (!activity) return failed('QUALIFICATION_ACTIVITY_MISSING', 'task has no unique Activity Log section', resolved.taskId);
   const mutations: Parameters<typeof writeTask>[0]['mutations'][number][] = [
     {
       kind: 'table-row', action: 'upsert', sectionAliases: ['约束', 'Constraints'], columns: ['constraint_id', 'statement', 'status', 'authority', 'source', 'evidence', 'derived_from', 'approval_evidence'], keyColumn: 'constraint_id', key: constraint.constraintId,
       values: { statement: constraint.statement, status: operation === 'confirm' ? 'confirmed' : transitionStatus, authority: operation === 'confirm' ? 'human-declared' : constraint.authority, source: constraint.source, evidence: constraint.evidence, derived_from: constraint.derivedFrom.join(','), approval_evidence: qcrId ?? '' }
     },
     ...(operation === 'confirm' ? [{ kind: 'section' as const, aliases: CONFIRMATION_HEADINGS, heading: findSectionHeading(content, [...CONFIRMATION_HEADINGS]), body: renderConfirmations(confirmations) }] : []),
-    { kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: activity.heading, body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Qualification Confirmation', agent: 'human', note: operation === 'confirm' ? `${request.constraintId} confirmed → ${qcrId}` : `${request.constraintId} ${operation}d` }) }
+    ...(activity ? [{ kind: 'section' as const, aliases: ['活动日志', 'Activity Log'], heading: activity.heading, body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Qualification Confirmation', agent: 'human', note: operation === 'confirm' ? `${request.constraintId} confirmed → ${qcrId}` : `${request.constraintId} ${operation}d` }) }] : [])
   ];
   const result = writeTask({ taskRef: resolved.taskId, expectedState: 'active', mutations, dryRun: request.dryRun }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state }, metadataProvider: () => metadata });
   if (result.status === 'failed') return failed(result.error.code, result.error.message, result.taskId);
-  return { status: result.status, changed: result.changed, taskId: result.taskId, qcrId, requestId, operations: result.operations, error: null };
+  return { status: result.status, changed: result.changed, taskId: result.taskId, qcrId, requestId, operations: result.operations, error: null, warnings: activityWarnings(content) };
 }
 
 export { applyQualificationConfirmation };

package/lib/task/resolve-ref.ts

@@ -114,28 +114,6 @@ function findTaskMd(
   return archived ? { taskMdPath: archived, state: 'archive' } : null;
 }
 
-/**
- * Enumerate every task directory under the flat workspace states
- * (active / blocked / completed) — archive is intentionally excluded so a
- * full-tree scan never pulls in cold data. Ordered by state, then task id
- * ascending, giving callers a deterministic traversal.
- */
-function enumerateTaskDirs(repoRoot: string): { taskId: string; taskDir: string }[] {
-  const out: { taskId: string; taskDir: string }[] = [];
-  const workspaceRoot = taskRoot(repoRoot);
-  for (const sub of FLAT_WORKSPACE_DIRS) {
-    const base = path.join(workspaceRoot, sub);
-    if (!fs.existsSync(base)) continue;
-    for (const entry of fs.readdirSync(base).sort()) {
-      if (!TASK_ID_RE.test(entry)) continue;
-      const taskDir = path.join(base, entry);
-      if (!fs.existsSync(path.join(taskDir, 'task.md'))) continue;
-      out.push({ taskId: entry, taskDir });
-    }
-  }
-  return out;
-}
-
 /**
  * Enumerate every task directory, including the cold YYYY/MM/DD archive.
  * Invalid directory names, symlinks and entries without task.md are ignored;
@@ -364,7 +342,6 @@ export {
   resolveTaskRef,
   resolveTaskContext,
   detectRepoRoot,
-  enumerateTaskDirs,
   enumerateAllTaskDirs,
   locateHotTaskDirs,
   TASK_ID_RE

package/lib/task/review-command.ts

@@ -4,14 +4,14 @@ export function parseReviewCommand(args: readonly string[]): ReviewFinalizationR
   if (!args[0] || !['preflight', 'finalize-summary'].includes(args[1] ?? '')) throw new Error('task ref and a supported review operation are required');
   const values: Record<string, string | boolean> = {};
   const flags = {
-    '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun'
+    '--stage': 'stage', '--artifact': 'artifact', '--dry-run': 'dryRun'
   } as const;
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;
     if (!Object.hasOwn(flags, flag)) throw new Error(`unknown option '${flag}'`);
     const key = flags[flag as keyof typeof flags];
     if (Object.hasOwn(values, key)) throw new Error(`duplicate option '${flag}'`);
-    const value = flag === '--orchestrated' || flag === '--dry-run' ? true : args[++index];
+    const value = flag === '--dry-run' ? true : args[++index];
     if (!value || typeof value === 'string' && value.startsWith('--')) throw new Error(`option '${flag}' requires a value`);
     values[key] = value;
   }

package/lib/task/review-finalization.ts

@@ -9,7 +9,6 @@ import type { LedgerStageStatus, ReviewStage } from './ledger.ts';
 import { finalizeReviewSummaryContent } from './review-artifacts.ts';
 import { inspectDecisionDetailDuplicates } from './decision-details.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
-import { validateLifecycleExecution } from './lifecycle-execution.ts';
 import type { ResolveTaskRefErrorCode } from './resolve-ref.ts';
 import { getArtifactSchema } from './artifact-schema.ts';
 import { validateQualificationAudit } from './qualification-audit.ts';
@@ -36,7 +35,6 @@ type ReviewFinalizationRequest = {
   taskRef: string;
   stage: string;
   artifact: string;
-  orchestrated?: boolean;
   dryRun?: boolean;
 };
 type ReviewFinalizationResult = {
@@ -144,13 +142,6 @@ function preflightReviewSummary(
     content = fs.readFileSync(validated.artifact.path, 'utf8');
   } catch (error) { return preflightFailed(request, 'REVIEW_ARTIFACT_NOT_REGULAR', String(error), resolved.taskId); }
 
-  const execution = validateLifecycleExecution(request.taskRef, {
-    mode: request.orchestrated ? 'orchestrated' : 'standalone',
-    identity: { stage: spec.family, round: parsed.round, artifact: request.artifact, role: 'reviewer' },
-    dryRun: request.dryRun
-  }, { repoRoot: options.repoRoot });
-  if (!execution.ok) return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', `${execution.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH'}: ${execution.error?.message ?? 'orchestration provenance validation failed'}`, resolved.taskId);
-
   const artifactSha256 = sha256Content(content);
   const semanticDigest = canonicalSemanticDigest(content);
   const detail = inspectDecisionDetailDuplicates(content);
@@ -211,15 +202,6 @@ function prepareReviewSummaryCandidate(
   catch (error) { return reject('REVIEW_ARTIFACT_NOT_REGULAR', String(error)); }
   const artifactSha256 = sha256Content(artifactContent);
   const semanticDigest = canonicalSemanticDigest(artifactContent);
-  const digests = { artifactSha256, semanticDigest };
-  const execution = validateLifecycleExecution(request.taskRef, {
-    mode: request.orchestrated ? 'orchestrated' : 'standalone',
-    identity: { stage: spec.family, round: parsed.round, artifact: request.artifact, role: 'reviewer' },
-    dryRun: request.dryRun
-  }, { repoRoot: options.repoRoot });
-  if (!execution.ok) {
-    return reject('REVIEW_PROVENANCE_INVALID', `${execution.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH'}: ${execution.error?.message ?? 'orchestration provenance validation failed'}`);
-  }
   try {
     const ledger = parseLedgerDocument(taskContent);
     if (!ledger.present) return reject('REVIEW_LEDGER_INVALID', `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}`);
@@ -259,14 +241,6 @@ function prepareReviewSummaryCandidate(
   };
 }
 
-function commitReviewSummaryProvenance(
-  prepared: ReviewSummaryCandidatePreparation,
-  repoRoot: string,
-  options: Readonly<{ afterPublish?: () => void }> = {}
-): ReviewFinalizationResult {
-  return prepared.result;
-}
-
 function replaceCurrentArtifactAtomically(file: string, content: string): void {
   const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
   try {
@@ -316,7 +290,7 @@ function finalizeReviewSummary(
   }
 }
 
-export { finalizeReviewSummary, preflightReviewSummary, prepareReviewSummaryCandidate, commitReviewSummaryProvenance };
+export { finalizeReviewSummary, preflightReviewSummary, prepareReviewSummaryCandidate };
 export type {
   ReviewFinalizationError,
   ReviewFinalizationErrorCode,

package/lib/task/review-fingerprint.ts

@@ -3,13 +3,6 @@ import path from "node:path";
 
 import { inspectArtifactDirectory } from "./artifact-lifecycle.ts";
 
-type ReviewedGitTree = string & { readonly __reviewedGitTree: unique symbol };
-const REVIEWED_TREE_RE = /^[a-f0-9]{40,64}$/;
-
-export function parseReviewedGitTree(value: string): ReviewedGitTree | null {
-  return REVIEWED_TREE_RE.test(value) ? value as ReviewedGitTree : null;
-}
-
 // Paths excluded from the post-review coverage gate. Fail-closed: the gate
 // covers ALL tracked changes by default. This default denylist is EMPTY —
 // projects opt into exclusions explicitly via review.post_review_exclude_globs.
@@ -87,7 +80,6 @@ export function extractReviewedSnapshotTree(content: string): string {
   return match ? match[1]!.trim().replace(/`/g, "") : "";
 }
 
-export type { ReviewedGitTree };
 
 export function parseReviewVerdict(content: string): string {
   const match = String(content).match(/^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.*?)\s*$/m);

package/lib/task/secure-fs.ts

@@ -3,7 +3,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 const NO_FOLLOW = fs.constants.O_NOFOLLOW ?? 0;
-const DIRECTORY = fs.constants.O_DIRECTORY ?? 0;
 
 export class SecureFileError extends Error {
   readonly code: string;
@@ -40,10 +39,6 @@ function assertNoSymlinkAncestors(candidate: string): void {
   }
 }
 
-export async function readStableFile(candidate: string, options: Readonly<{ maxBytes: number; expectedSha256?: string }>): Promise<StableFile> {
-  return readStableFileSync(candidate, options);
-}
-
 export function readStableFileSync(candidate: string, options: Readonly<{ maxBytes: number; expectedSha256?: string }>): StableFile {
   if (!path.isAbsolute(candidate)) conflict('candidate path must be absolute and terminal');
   assertNoSymlinkAncestors(candidate);
@@ -74,40 +69,3 @@ export function readStableFileSync(candidate: string, options: Readonly<{ maxByt
     if (descriptor !== undefined) fs.closeSync(descriptor);
   }
 }
-
-export async function writeAtomicFile(target: string, bytes: Buffer, mode = 0o600, expectedSha256?: string): Promise<void> {
-  const parent = path.dirname(target);
-  let current = path.resolve(parent);
-  while (true) {
-    let stat: fs.Stats;
-    try { stat = await fs.promises.lstat(current); }
-    catch { throw new SecureFileError('TASK_ARTIFACT_WRITE_CONFLICT', 'authoritative parent directory is missing'); }
-    if (!stat.isDirectory() || stat.isSymbolicLink()) throw new SecureFileError('TASK_ARTIFACT_WRITE_CONFLICT', 'authoritative parent directory is not a real directory');
-    const next = path.dirname(current);
-    if (next === current) break;
-    current = next;
-  }
-  try {
-    const existing = await fs.promises.lstat(target);
-    if (existing.isSymbolicLink() || !existing.isFile()) throw new SecureFileError('TASK_ARTIFACT_WRITE_CONFLICT', 'authoritative target is not a regular file');
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-  }
-  const temporary = path.join(parent, `.${path.basename(target)}.${process.pid}.${Date.now()}.tmp`);
-  let handle: fs.promises.FileHandle | undefined;
-  try {
-    handle = await fs.promises.open(temporary, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, mode);
-    await handle.writeFile(bytes);
-    await handle.sync();
-    await handle.chmod(mode);
-    await handle.close();
-    handle = undefined;
-    if (expectedSha256 !== undefined) readStableFileSync(target, { maxBytes: 1024 * 1024, expectedSha256 });
-    fs.renameSync(temporary, target);
-    const directory = await fs.promises.open(parent, fs.constants.O_RDONLY | DIRECTORY);
-    try { await directory.sync(); } finally { await directory.close(); }
-  } finally {
-    await handle?.close().catch(() => undefined);
-    await fs.promises.rm(temporary, { force: true }).catch(() => undefined);
-  }
-}

package/lib/task/short-id.ts

@@ -447,15 +447,6 @@ function readRegistry(repoRoot: string): RegistrySchema | null {
   }
 }
 
-function readBranchFromTaskMd(repoRoot: string, taskId: string): string | null {
-  const taskMdPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', taskId, 'task.md');
-  if (!fs.existsSync(taskMdPath)) return null;
-  const content = fs.readFileSync(taskMdPath, 'utf8');
-  const m = content.match(/^branch:\s*(.+)$/m);
-  if (!m || !m[1]) return null;
-  return m[1].trim().replace(/^(["'])(.*)\1$/, '$2');
-}
-
 function loadShortIdByTaskId(repoRoot: string): Map<string, string> {
   const registry = readRegistry(repoRoot);
   const map = new Map<string, string>();
@@ -527,44 +518,10 @@ function inspectShortIdRegistry(
   }
 }
 
-/**
- * Resolve a branch to its active-task short id (`NN`), or `null` when no
- * active task is bound to that branch.
- *
- * Two-state semantics: this only consults the active registry
- * (`active/.short-ids.json`) plus each `active/{taskId}/task.md`. Tasks moved
- * to completed/blocked/cancelled/archive have already released their short id,
- * so their branches return `null` — in `ai sandbox ls` that surfaces as `-`,
- * meaning the sandbox is free to remove.
- */
-function lookupShortIdByBranch(
-  branch: string,
-  repoRoot: string,
-  _opts?: { shortIdLength?: number }
-): string | null {
-  const registry = readRegistry(repoRoot);
-  if (!registry) return null;
-  const matches: string[] = [];
-  for (const [key, taskId] of Object.entries(registry.ids)) {
-    const taskBranch = readBranchFromTaskMd(repoRoot, taskId);
-    if (taskBranch && taskBranch === branch) {
-      matches.push(key);
-    }
-  }
-  if (matches.length === 0) return null;
-  if (matches.length > 1) {
-    process.stderr.write(
-      `Warning: branch '${branch}' is bound to multiple active tasks: ${matches.join(', ')}; using ${matches[0]}\n`
-    );
-  }
-  return matches[0]!;
-}
-
 export {
   normalizeShortIdInput,
   isRemovedHashShortIdInput,
   resolveShortIdReadOnly,
-  lookupShortIdByBranch,
   loadShortIdByTaskId,
   inspectShortIdRegistry,
   configuredShortIdLength,

package/lib/task/skill-scope.ts

@@ -13,7 +13,6 @@ const TASK_SCOPE_SKILLS: ReadonlySet<string> = new Set([
   'review-code',
   'review-plan',
   'run-manual-validation',
-  'run-task',
   'watch-pr'
 ]);