@fitlab-ai/agent-infra 0.11.0 → 0.11.2

package/lib/sandbox/control/executor.ts

@@ -441,49 +441,6 @@ async function executeRequestInner(
       ? lifecycleFailure('LIFECYCLE_PAYLOAD_INVALID', message)
       : orchestrationFailure(code, message);
   }
-  let controllerBinding: Readonly<{
-    instanceDigest: string;
-    controlGeneration: string;
-  }> | null = null;
-  if (request.family === 'task-orchestration') {
-    const codexPrepare = operation.family === 'task-orchestration'
-      && operation.intent === 'prepare'
-      && operation.input.client === 'codex';
-    if (codexPrepare) {
-      if (!request.controllerProof) {
-        const authority = options.lifecycleRecoveryAttestation;
-        if (!authority || authority.phase !== 'orchestration.prepare') {
-          return orchestrationFailure(
-            'CODEX_SANDBOX_CONTROLLER_PROOF_REQUIRED',
-            'Codex prepare requires a current controller lease proof'
-          );
-        }
-        controllerBinding = {
-          instanceDigest: authority.controllerInstanceDigest,
-          controlGeneration: authority.controlGeneration
-        };
-      } else {
-        try {
-          controllerBinding = (options.resolveControllerBinding ?? resolveCodexControllerBinding)({
-            manifest,
-            manifestPath,
-            proof: request.controllerProof,
-            buildIdentity: (options.buildIdentity ?? computeLifecycleBuildIdentity)(manifest.repoRoot)
-          });
-        } catch (error) {
-          const code = error instanceof CodexControllerRegistrationError
-            ? error.code
-            : 'CODEX_SANDBOX_CONTROLLER_PROOF_INVALID';
-          return orchestrationFailure(code, `${code}: Codex controller proof was rejected`);
-        }
-      }
-    } else if (request.controllerProof !== null) {
-      return orchestrationFailure(
-        'CODEX_SANDBOX_CONTROLLER_PROOF_INVALID',
-        'Controller proof is only accepted for canonical Codex prepare'
-      );
-    }
-  }
   const diagnosticLog: OrchestrationDiagnosticLogger = (event, fields): void => {
     appendExecutorAudit(manifest, event.startsWith('orchestration-') ? event : `orchestration-${event}`, {
       requestId: request.id,
@@ -501,7 +458,6 @@ async function executeRequestInner(
     manifestPath,
     requestId: request.id,
     diagnosticLog,
-    ...(controllerBinding ? { controllerBinding } : {}),
     lifecycleRecoveryAttestation: options.lifecycleRecoveryAttestation ?? null
   });
   const format = (value: unknown): SandboxControlExecutionResult => {

package/lib/sandbox/control/finalization-response.ts

@@ -4,9 +4,15 @@ import type { SandboxControlResponse } from './protocol.ts';
 export function finalizationTerminalResponse(taskId: string, requestId: string, receipt: TaskFinalizationReceipt): SandboxControlResponse {
   const pendingSteps = [
     receipt.taskComment === 'pending' ? 'task-comment' : null,
-    receipt.verification === 'pending' ? 'verification' : null
+    receipt.verification === 'pending' ? 'verification' : null,
+    receipt.summary === 'pending' ? 'summary' : null,
+    receipt.postSummaryVerification === 'pending' ? 'post-summary-verification' : null
   ].filter((step): step is string => step !== null);
-  const completedSteps = ['lifecycle', receipt.taskComment === 'pending' ? null : 'task-comment', receipt.verification === 'pending' ? null : 'verification']
+  const completedSteps = [
+    'lifecycle', receipt.taskComment === 'pending' ? null : 'task-comment',
+    receipt.verification === 'pending' ? null : 'verification', receipt.summary === 'pending' ? null : 'summary',
+    receipt.postSummaryVerification === 'pending' ? null : 'post-summary-verification'
+  ]
     .filter((step): step is string => step !== null);
   const warnings = receipt.warnings
     .filter((warning) => warning.status === 'open')
@@ -16,6 +22,8 @@ export function finalizationTerminalResponse(taskId: string, requestId: string,
     lifecycle: { status: 'no-op', changed: false, error: null },
     taskComment: receipt.taskComment === 'pending' ? null : { status: 'no-op', changed: false, error: null },
     verification: receipt.verification === 'pending' ? null : { status: 'no-op', changed: false, error: null },
+    summary: receipt.summary === 'pending' ? null : { status: 'no-op', changed: false, error: null },
+    postSummaryVerification: receipt.postSummaryVerification === 'pending' ? null : { status: 'no-op', changed: false, error: null },
     completedSteps, pendingSteps,
     result: pendingSteps.length > 0 || receipt.warningProjection === 'pending' || warnings.length > 0
       ? 'completed_with_warnings' : 'completed',

package/lib/sandbox/control/task-view.ts

@@ -56,9 +56,11 @@ function receiptIdentity(value: unknown, generation: string, requestId?: string)
   const binding = receipt.controlBinding;
   if (!binding || typeof binding !== 'object' || Array.isArray(binding)) return null;
   const controlBinding = binding as Record<string, unknown>;
-  if (receipt.version !== 2 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
+  if (receipt.version !== 3 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
     || !Number.isSafeInteger(receipt.revision) || (receipt.revision as number) < 0
     || receipt.lifecycle !== 'done'
+    || !['pending', 'done', 'skipped'].includes(String(receipt.summary))
+    || !['pending', 'done', 'skipped'].includes(String(receipt.postSummaryVerification))
     || controlBinding.generation !== generation
     || typeof controlBinding.requestId !== 'string'
     || !/^[a-f0-9-]{16,64}$/u.test(controlBinding.requestId)

package/lib/sandbox/control/workflow-executor.ts

@@ -1,10 +1,16 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
 import { TASK_WORKFLOW_COMMANDS } from '../../task/workflow-command.ts';
 
 import { parseArtifactCommand, executeArtifactCommand } from '../../task/artifact-command.ts';
 import { parseReviewCommand } from '../../task/review-command.ts';
 import { prepareLocalArtifact, preflightLocalArtifact, commitLocalArtifactProvenance } from '../../task/local-artifact-finalization.ts';
-import { prepareReviewSummaryCandidate, commitReviewSummaryProvenance } from '../../task/review-finalization.ts';
-import { readArtifactRecoveryIntent } from '../../task/artifact-repair-intent.ts';
+import {
+  prepareReviewSummaryCandidate,
+  preflightReviewSummary
+} from '../../task/review-finalization.ts';
 import { withTaskExecutionLock } from '../../task/task-execution-lock.ts';
 import { dispatchWorkflowCommand } from '../../task/workflow-dispatch.ts';
 import { assertSandboxTaskSource } from '../workspace-view.ts';
@@ -33,6 +39,18 @@ function executionResult(result: Record<string, unknown>): SandboxControlExecuti
   return { exitCode: result.status === 'failed' || result.status === 'refused' ? 1 : 0, stdout: `${JSON.stringify(result)}\n`, stderr: '' };
 }
 
+function replaceCurrentArtifactAtomically(file: string, content: string): void {
+  const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    fs.writeFileSync(temporary, content, { encoding: 'utf8', flag: 'wx' });
+    fs.renameSync(temporary, file);
+  } finally {
+    try { fs.unlinkSync(temporary); } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+  }
+}
+
 /** The broker already authorized this host executor; domain operations own validation. */
 export async function executeTaskWorkflow(
   manifest: SandboxControlManifest,
@@ -41,25 +59,6 @@ export async function executeTaskWorkflow(
   options: TaskWorkflowExecutionOptions = {}
 ): Promise<SandboxControlExecutionResult> {
   let publicationCommitted = false;
-  let recoveryObservation: Readonly<{
-    family: 'analysis' | 'plan' | 'code' | 'review-analysis' | 'review-plan' | 'review-code';
-    artifact: string;
-    wasPassed: boolean;
-  }> | null = null;
-  const observeRecoveryPublication = (): void => {
-    if (!recoveryObservation || recoveryObservation.wasPassed) return;
-    const intent = readArtifactRecoveryIntent(
-      manifest.repoRoot,
-      request.taskId,
-      recoveryObservation.family,
-      recoveryObservation.artifact
-    );
-    publicationCommitted ||= intent?.state === 'preflight-ready'
-      || intent?.state === 'preflight-commit-started'
-      || intent?.state === 'preflight-passed'
-      || intent?.state === 'passed'
-      || intent?.state === 'commit-started';
-  };
   let faultTriggered = false;
   const fault = (window: TaskWorkflowFaultWindow): void => {
     if (faultTriggered || options.faultWindow !== window) return;
@@ -121,41 +120,26 @@ export async function executeTaskWorkflow(
       if ('operation' in input) {
         const { family } = input;
         if (family !== 'analysis' && family !== 'plan' && family !== 'code') throw new Error('ARTIFACT_IDENTITY_INVALID');
-        const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot, recoveryId: input.recoveryId, lockAlreadyHeld: true } as const;
+        const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot, lockAlreadyHeld: true } as const;
         if (input.operation === 'preflight') {
-          // Preflight only seals a verified generation. It must not publish the
-          // formal artifact, set publicationStarted, or append finalizer audit.
           const result = preflightLocalArtifact(local);
-          recoveryObservation = { family, artifact: input.artifact, wasPassed: false };
-          observeRecoveryPublication();
           return response(result);
         }
-        recoveryObservation = {
-          family,
-          artifact: input.artifact,
-          wasPassed: readArtifactRecoveryIntent(manifest.repoRoot, request.taskId, family, input.artifact)?.state === 'passed'
-        };
-        const prepared = prepareLocalArtifact(local, content, lifecycleRecoveryAttestation ?? undefined);
-        observeRecoveryPublication();
-        const commitOptions = { afterPublish: () => fault('after-atomic-rename') };
-        if (prepared.result.status === 'failed') return executionResult(commitLocalArtifactProvenance(prepared, commitOptions));
-        result = commitLocalArtifactProvenance(prepared, commitOptions);
+        const prepared = prepareLocalArtifact(local, content);
+        result = commitLocalArtifactProvenance(prepared);
       } else {
         if (input.overrideTicket) throw new Error('TASK_WORKFLOW_OVERRIDE_UNSUPPORTED');
         const family = `review-${input.stage}` as 'review-analysis' | 'review-plan' | 'review-code';
-        recoveryObservation = {
-          family,
-          artifact: input.artifact,
-          wasPassed: readArtifactRecoveryIntent(manifest.repoRoot, request.taskId, family, input.artifact)?.state === 'passed'
-        };
-        const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true, startRecovery: true });
-        observeRecoveryPublication();
+        if (request.operation === 'review-preflight') {
+          const result = preflightReviewSummary(input, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true });
+          return response(result);
+        }
+        const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true });
         if (input.dryRun || prepared.result.status === 'planned') return executionResult(prepared.result);
-        const commitOptions = { afterPublish: () => fault('after-atomic-rename') };
-        if (prepared.result.status === 'failed') return executionResult(commitReviewSummaryProvenance(prepared, manifest.repoRoot, commitOptions));
-        result = commitReviewSummaryProvenance(prepared, manifest.repoRoot, commitOptions);
+        if (prepared.result.status === 'failed') return executionResult(prepared.result);
+        if (prepared.result.changed) replaceCurrentArtifactAtomically(path.join(taskDir, input.artifact), prepared.content);
+        result = prepared.result;
       }
-      observeRecoveryPublication();
       publicationCommitted ||= result.changed === true;
       if (result.status !== 'failed') appendDiagnosticAudit(manifest, 'task-workflow-artifact-finalized', {
         requestId: request.id, sandboxTaskId: request.taskId, workflowOperation: request.operation,
@@ -165,7 +149,6 @@ export async function executeTaskWorkflow(
       return response(result);
     });
   } catch (error) {
-    observeRecoveryPublication();
     const message = error instanceof Error ? error.message : String(error);
     const code = (error as { code?: string })?.code ?? /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'TASK_WORKFLOW_REQUEST_INVALID';
     return executionResult({ status: 'failed', changed: publicationCommitted ? null : false, error: { code, message } });

package/lib/task/artifact-command.ts

@@ -13,7 +13,6 @@ export type ArtifactCommand = Readonly<{
   family: string;
   artifact: string;
   locale?: 'zh-CN' | 'en';
-  recoveryId?: string;
 }>;
 
 /** One option contract for the CLI and trusted projection executor. */
@@ -26,8 +25,8 @@ export function parseArtifactCommand(args: readonly string[]): ArtifactCommand {
   const allowed = {
     inspect: ['--family'],
     init: ['--family', '--artifact', '--locale'],
-    'preflight': ['--family', '--artifact', '--recovery-id'],
-    'finalize-local': ['--family', '--artifact', '--recovery-id']
+    'preflight': ['--family', '--artifact'],
+    'finalize-local': ['--family', '--artifact']
   }[operation as ArtifactCommand['operation']];
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;
@@ -43,7 +42,7 @@ export function parseArtifactCommand(args: readonly string[]): ArtifactCommand {
   if (locale !== undefined && locale !== 'zh-CN' && locale !== 'en') throw new Error("option '--locale' must be 'zh-CN' or 'en'");
   return {
     taskRef, operation: operation as ArtifactCommand['operation'], family: fields['--family'],
-    artifact: fields['--artifact'] ?? '', locale, recoveryId: fields['--recovery-id']
+    artifact: fields['--artifact'] ?? '', locale
   };
 }
 /** Resolve authoritative task metadata separately from a trusted candidate directory. */
@@ -51,7 +50,7 @@ export function executeArtifactCommand(
   command: ArtifactCommand,
   options: Readonly<{ repoRoot?: string; artifactDir?: string }> = {}
 ): Record<string, unknown> {
-  const { taskRef, operation, family, artifact, locale, recoveryId } = command;
+  const { taskRef, operation, family, artifact, locale } = command;
   const fail = (code: string, message: string) => ({ status: 'failed', changed: false, error: { code, message } });
   if (operation === 'inspect') {
     const result = resolveArtifactContext(taskRef, family, { repoRoot: options.repoRoot });
@@ -82,6 +81,6 @@ export function executeArtifactCommand(
   if (family !== 'analysis' && family !== 'plan' && family !== 'code') {
     return fail('ARTIFACT_PAYLOAD_INVALID', "preflight and finalize-local only support 'analysis', 'plan', and 'code'");
   }
-  if (operation === 'preflight') return { ...preflightLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot, recoveryId }) };
-  return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot, recoveryId }) };
+  if (operation === 'preflight') return { ...preflightLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
+  return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
 }

package/lib/task/artifact-lifecycle.ts

@@ -221,67 +221,30 @@ function resolveReviewedInput(
   expectedFamily: ArtifactFamily,
   diagnostics: ArtifactDiagnostic[]
 ): ArtifactIdentity | null {
-  let content: string;
-  try { content = fs.readFileSync(review.path, 'utf8'); }
-  catch (error) {
-    diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, String(error)));
-    return null;
-  }
-  const parsed = parseReviewedInputReference(content, expectedFamily);
-  if (!parsed) {
-    diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, `${review.name} does not reference a canonical ${expectedFamily} artifact`));
-    return null;
-  }
-  const abs = path.join(taskDir, parsed.name);
   try {
+    const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    const receipt = receiptForOutput(taskContent, review.name);
+    const expectedEvent = reviewEventName(review.family);
+    if (!receipt || receipt.event !== expectedEvent) throw new Error(`receipt for ${review.name} is missing or invalid`);
+    const input = parseArtifactName(receipt.input);
+    if (!input || input.family !== expectedFamily) throw new Error(`receipt input '${receipt.input}' is not a canonical ${expectedFamily} artifact`);
+    const abs = path.join(taskDir, input.name);
     const stat = fs.lstatSync(abs);
     if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('referenced input is not a regular file');
-    const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
     const invalidation = parseInvalidationDocument(taskContent);
     if (!invalidation.ok) throw new Error(invalidation.message);
-    if (isArtifactInvalidated(invalidation.document, expectedFamily, parsed.name)) {
-      throw new Error(`${parsed.name} is invalidated`);
-    }
-    const receipt = receiptForOutput(taskContent, review.name);
-    if (!receipt) throw new Error(`receipt for ${review.name} is missing`);
-    const expectedEvent = reviewEventName(review.family);
-    if (receipt.event !== expectedEvent || receipt.input !== parsed.name) {
-      throw new Error(`receipt for ${review.name} does not match ${parsed.name}`);
-    }
+    if (isArtifactInvalidated(invalidation.document, expectedFamily, input.name)) throw new Error(`${input.name} is invalidated`);
     const actualSha256 = sha256File(abs);
     if (actualSha256 !== receipt.inputSha256) {
-      throw new Error(`${parsed.name} content digest does not match receipt`);
+      throw new Error(`${input.name} content digest does not match receipt`);
     }
-    return { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
+    return { ...input, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
   } catch (error) {
-    diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, `${parsed.name}: ${String(error)}`));
+    diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, String(error)));
     return null;
   }
 }
 
-function parseReviewedInputReference(content: string, expectedFamily: ArtifactFamily): { family: ArtifactFamily; round: number; name: string } | null {
-  const lines = content.split(/\r?\n/);
-  const header = lines.findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
-  const referenceBlock = header >= 0 ? lines.slice(header, header + 12).join('\n') : '';
-  const candidates = [...referenceBlock.matchAll(/`([^`]+\.md)`/g)].map((match) => match[1]!);
-  return candidates
-    .map((name) => parseArtifactName(name))
-    .find((item) => item?.family === expectedFamily) ?? null;
-}
-
-function parseCodePlanInputReference(content: string): { family: 'plan'; round: number; name: string } | null {
-  const lines = content.split(/\r?\n/);
-  const sectionStart = lines.findIndex((line) => /^##\s+(?:实现输入|Implementation Input)\s*$/.test(line.trim()));
-  if (sectionStart < 0) return null;
-  const bodyLines = lines.slice(sectionStart + 1);
-  const nextSection = bodyLines.findIndex((line) => /^##\s+/.test(line.trim()));
-  const body = (nextSection < 0 ? bodyLines : bodyLines.slice(0, nextSection)).join('\n');
-  const match = body.match(/\*\*(?:方案输入|Plan Input)\*\*[:：]\s*`([^`]+\.md)`/);
-  if (!match) return null;
-  const parsed = parseArtifactName(match[1]!);
-  return parsed?.family === 'plan' ? { ...parsed, family: 'plan' } : null;
-}
-
 function reviewEventName(family: ArtifactFamily): 'review-analysis.completed' | 'review-plan.completed' | 'review-code.completed' {
   if (family === 'review-analysis') return 'review-analysis.completed';
   if (family === 'review-plan') return 'review-plan.completed';
@@ -557,7 +520,7 @@ function buildArtifactLinkSection(content: string, artifact: ArtifactIdentity):
 export {
   artifactFamilyCatalog, familySpec,
   inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext,
-  parseReviewedInputReference, parseCodePlanInputReference, resolveCodePlanInput, reviewEventName,
+  resolveCodePlanInput, reviewEventName,
   assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection
 };
 export type {

package/lib/task/artifact-operations.ts

@@ -10,6 +10,12 @@ import {
   renderArtifactSkeleton
 } from './artifact-schema.ts';
 import { withTaskExecutionLock } from './task-execution-lock.ts';
+import {
+  buildQualificationAudit,
+  expectedQualificationRelations,
+  parseTaskQualification,
+  renderQualificationAudit
+} from './qualification-audit.ts';
 import type {
   ArtifactSchema,
   ArtifactSchemaFamily,
@@ -288,6 +294,23 @@ function artifactRound(family: ArtifactSchemaFamily, artifact: string): number |
   return identity?.family === family ? identity.round : null;
 }
 
+function qualificationAuditForInit(request: ArtifactInitRequest): { ok: true; content: string } | { ok: false; code: string; message: string } {
+  let taskContent: string;
+  try {
+    taskContent = readStableFileSync(path.join(request.taskDir, 'task.md'), { maxBytes: 1024 * 1024 }).bytes.toString('utf8');
+  } catch (error) {
+    return { ok: false, code: 'ARTIFACT_INIT_TASK_READ_FAILED', message: error instanceof Error ? error.message : String(error) };
+  }
+  const qualification = parseTaskQualification(taskContent);
+  if (!qualification.ok) return qualification;
+  if (!qualification.qualification.present) return { ok: true, content: '' };
+  const relations = expectedQualificationRelations(taskContent, request.family);
+  if (!relations.ok) return relations;
+  const audit = buildQualificationAudit(taskContent, { upstreamRelations: relations.relations ?? [] });
+  if (!audit.ok) return audit;
+  return { ok: true, content: `\n## 资格审计\n\n${renderQualificationAudit(audit.audit)}\n` };
+}
+
 function initializeArtifactSkeleton(request: ArtifactInitRequest): ArtifactFileResult {
   const schema = getArtifactSchema(request.family);
   if (!schema) return resultFailure('ARTIFACT_FAMILY_UNKNOWN', `unknown artifact family '${request.family}'`);
@@ -304,12 +327,15 @@ function initializeArtifactSkeleton(request: ArtifactInitRequest): ArtifactFileR
       } catch (error) {
         if ((error as NodeJS.ErrnoException).code !== 'ENOENT') return resultFailure('ARTIFACT_INIT_TARGET_INVALID', String(error));
       }
-      const content = renderArtifactSkeleton({
+      const skeleton = renderArtifactSkeleton({
         taskId: request.taskId,
         family: request.family,
         artifact: request.artifact,
         ...(request.locale ? { locale: request.locale } : {})
       });
+      const audit = qualificationAuditForInit(request);
+      if (!audit.ok) return resultFailure(audit.code, audit.message);
+      const content = `${skeleton.trimEnd()}${audit.content}`;
       const tempPath = path.join(request.taskDir, `.${request.artifact}.init-${process.pid}-${Date.now()}.tmp`);
       try {
         fs.writeFileSync(tempPath, content, { encoding: 'utf8', mode: 0o600, flag: 'wx' });

package/lib/task/capabilities.ts

@@ -187,7 +187,6 @@ function qualificationRecoveryAction(facts: LifecycleFacts): LifecycleAction | n
 }
 
 function recommendNext(facts: LifecycleFacts): LifecycleRecommendation {
-  if (invalidationBlocks(facts.invalidation)) return { action: null, reasonCode: 'INVALIDATION_INCOMPLETE', evidence: ['reconcile task invalidation before routing'] };
   if (facts.qualificationStale) {
     const action = qualificationRecoveryAction(facts);
     return {