@fitlab-ai/agent-infra 0.11.0 → 0.11.2

package/dist/lib/sandbox/control/executor.js

@@ -357,43 +357,6 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             ? lifecycleFailure('LIFECYCLE_PAYLOAD_INVALID', message)
             : orchestrationFailure(code, message);
     }
-    let controllerBinding = 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 = (event, fields) => {
         appendExecutorAudit(manifest, event.startsWith('orchestration-') ? event : `orchestration-${event}`, {
             requestId: request.id,
@@ -411,7 +374,6 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
         manifestPath,
         requestId: request.id,
         diagnosticLog,
-        ...(controllerBinding ? { controllerBinding } : {}),
         lifecycleRecoveryAttestation: options.lifecycleRecoveryAttestation ?? null
     });
     const format = (value) => {

package/dist/lib/sandbox/control/finalization-response.js

@@ -1,9 +1,15 @@
 export function finalizationTerminalResponse(taskId, requestId, receipt) {
     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 !== 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 !== null);
     const warnings = receipt.warnings
         .filter((warning) => warning.status === 'open')
@@ -13,6 +19,8 @@ export function finalizationTerminalResponse(taskId, requestId, receipt) {
         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/dist/lib/sandbox/control/task-view.js

@@ -13,9 +13,11 @@ function receiptIdentity(value, generation, requestId) {
     if (!binding || typeof binding !== 'object' || Array.isArray(binding))
         return null;
     const controlBinding = binding;
-    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 < 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/dist/lib/sandbox/control/workflow-executor.js

@@ -1,9 +1,11 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { TASK_WORKFLOW_COMMANDS } from '../../task/workflow-command.js';
 import { parseArtifactCommand, executeArtifactCommand } from '../../task/artifact-command.js';
 import { parseReviewCommand } from '../../task/review-command.js';
 import { prepareLocalArtifact, preflightLocalArtifact, commitLocalArtifactProvenance } from '../../task/local-artifact-finalization.js';
-import { prepareReviewSummaryCandidate, commitReviewSummaryProvenance } from '../../task/review-finalization.js';
-import { readArtifactRecoveryIntent } from '../../task/artifact-repair-intent.js';
+import { prepareReviewSummaryCandidate, preflightReviewSummary } from '../../task/review-finalization.js';
 import { withTaskExecutionLock } from '../../task/task-execution-lock.js';
 import { dispatchWorkflowCommand } from '../../task/workflow-dispatch.js';
 import { assertSandboxTaskSource } from '../workspace-view.js';
@@ -14,20 +16,25 @@ import { parseTaskEventRequest } from '../../internal/task-event.js';
 function executionResult(result) {
     return { exitCode: result.status === 'failed' || result.status === 'refused' ? 1 : 0, stdout: `${JSON.stringify(result)}\n`, stderr: '' };
 }
+function replaceCurrentArtifactAtomically(file, content) {
+    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.code !== 'ENOENT')
+                throw error;
+        }
+    }
+}
 /** The broker already authorized this host executor; domain operations own validation. */
 export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAttestation = null, options = {}) {
     let publicationCommitted = false;
-    let recoveryObservation = null;
-    const observeRecoveryPublication = () => {
-        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) => {
         if (faultTriggered || options.faultWindow !== window)
@@ -91,46 +98,31 @@ export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAt
                 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 };
+                const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot, lockAlreadyHeld: true };
                 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}`;
-                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);
+                    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', {
@@ -142,7 +134,6 @@ export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAt
         });
     }
     catch (error) {
-        observeRecoveryPublication();
         const message = error instanceof Error ? error.message : String(error);
         const code = error?.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/dist/lib/task/artifact-command.js

@@ -15,8 +15,8 @@ export function parseArtifactCommand(args) {
     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];
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
@@ -38,12 +38,12 @@ export function parseArtifactCommand(args) {
         throw new Error("option '--locale' must be 'zh-CN' or 'en'");
     return {
         taskRef, operation: 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. */
 export function executeArtifactCommand(command, options = {}) {
-    const { taskRef, operation, family, artifact, locale, recoveryId } = command;
+    const { taskRef, operation, family, artifact, locale } = command;
     const fail = (code, message) => ({ status: 'failed', changed: false, error: { code, message } });
     if (operation === 'inspect') {
         const result = resolveArtifactContext(taskRef, family, { repoRoot: options.repoRoot });
@@ -76,7 +76,7 @@ export function executeArtifactCommand(command, options = {}) {
         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 }) };
+        return { ...preflightLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
+    return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
 }
 //# sourceMappingURL=artifact-command.js.map

package/dist/lib/task/artifact-lifecycle.js

@@ -150,72 +150,35 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
     };
 }
 function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
-    let content;
-    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, expectedFamily) {
-    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) {
-    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) {
     if (family === 'review-analysis')
         return 'review-analysis.completed';
@@ -509,5 +472,5 @@ function buildArtifactLinkSection(content, artifact) {
     body = lines.join('\n').replace(/^\n+|\n+$/g, '');
     return { aliases, heading, body };
 }
-export { artifactFamilyCatalog, familySpec, inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext, parseReviewedInputReference, parseCodePlanInputReference, resolveCodePlanInput, reviewEventName, assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection };
+export { artifactFamilyCatalog, familySpec, inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext, resolveCodePlanInput, reviewEventName, assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection };
 //# sourceMappingURL=artifact-lifecycle.js.map

package/dist/lib/task/artifact-operations.js

@@ -6,6 +6,7 @@ import { parseArtifactName } from './artifact-name.js';
 import { scanVisibleMarkdown } from './markdown.js';
 import { getArtifactSchema, renderArtifactSkeleton } from './artifact-schema.js';
 import { withTaskExecutionLock } from './task-execution-lock.js';
+import { buildQualificationAudit, expectedQualificationRelations, parseTaskQualification, renderQualificationAudit } from './qualification-audit.js';
 function sha256Content(content) {
     return createHash('sha256').update(content, 'utf8').digest('hex');
 }
@@ -193,6 +194,27 @@ function artifactRound(family, artifact) {
     const identity = parseArtifactName(artifact);
     return identity?.family === family ? identity.round : null;
 }
+function qualificationAuditForInit(request) {
+    let taskContent;
+    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) {
     const schema = getArtifactSchema(request.family);
     if (!schema)
@@ -216,12 +238,16 @@ function initializeArtifactSkeleton(request) {
                 if (error.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/dist/lib/task/capabilities.js

@@ -146,8 +146,6 @@ function qualificationRecoveryAction(facts) {
     return QUALIFICATION_RECOVERY_ORDER.find(({ pattern }) => stale.some((name) => pattern.test(name)))?.action ?? null;
 }
 function recommendNext(facts) {
-    if (invalidationBlocks(facts.invalidation))
-        return { action: null, reasonCode: 'INVALIDATION_INCOMPLETE', evidence: ['reconcile task invalidation before routing'] };
     if (facts.qualificationStale) {
         const action = qualificationRecoveryAction(facts);
         return {