@fitlab-ai/agent-infra 0.10.0 → 0.11.1

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

@@ -125,7 +125,9 @@ export async function prepareSandboxControlExecution(params) {
                 owner: gateOwner,
                 requestId: params.request.id,
                 operationId: authority?.operationId ?? params.request.id,
-                phase: authority?.phase ?? (params.request.family === 'task-workflow' ? 'artifact.finalize-local' : 'orchestration.prepare'),
+                phase: authority?.phase ?? (params.request.family === 'task-workflow'
+                    && params.request.workflow?.operation === 'artifact-preflight' ? 'artifact.preflight'
+                    : params.request.family === 'task-workflow' ? 'artifact.finalize-local' : 'orchestration.prepare'),
                 authority
             });
         },
@@ -163,7 +165,7 @@ function waitForGate(nonce, timeoutMs = 2_000) {
                 return;
             }
             if (typeof value.requestId !== 'string' || typeof value.operationId !== 'string'
-                || !['orchestration.prepare', 'artifact.finalize-local', 'task-event.completed'].includes(value.phase)
+                || !['orchestration.prepare', 'artifact.preflight', 'artifact.finalize-local', 'task-event.completed'].includes(value.phase)
                 || (value.authority !== null && value.authority !== undefined && (() => {
                     try {
                         validateLifecycleRecoveryAttestation(value.authority);

package/dist/lib/sandbox/control/task-workflow.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { readStableFile, SecureFileError, writeAtomicFile } from '../../host-control/secure-fs.js';
+import { readStableFile, SecureFileError, writeAtomicFile } from '../../task/secure-fs.js';
 import { TASK_WORKFLOW_COMMANDS, TASK_WORKFLOW_OPERATIONS } from '../../task/workflow-command.js';
 export function validateTaskWorkflowRequest(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))

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

@@ -1,10 +1,11 @@
 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, commitLocalArtifactProvenance } from '../../task/local-artifact-finalization.js';
-import { prepareReviewSummaryCandidate, commitReviewSummaryProvenance } from '../../task/review-finalization.js';
+import { prepareLocalArtifact, preflightLocalArtifact, commitLocalArtifactProvenance } from '../../task/local-artifact-finalization.js';
+import { prepareReviewSummaryCandidate, commitReviewSummaryProvenance, preflightReviewSummary } from '../../task/review-finalization.js';
+import { readArtifactRecoveryIntent } from '../../task/artifact-repair-intent.js';
 import { withTaskExecutionLock } from '../../task/task-execution-lock.js';
-import { dispatchHostControlCommand } from '../../host-control/command.js';
+import { dispatchWorkflowCommand } from '../../task/workflow-dispatch.js';
 import { assertSandboxTaskSource } from '../workspace-view.js';
 import { appendDiagnosticAudit } from './audit.js';
 import { readTaskArtifact } from './task-workflow.js';
@@ -14,9 +15,32 @@ function executionResult(result) {
     return { exitCode: result.status === 'failed' || result.status === 'refused' ? 1 : 0, stdout: `${JSON.stringify(result)}\n`, stderr: '' };
 }
 /** The broker already authorized this host executor; domain operations own validation. */
-export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAttestation = null) {
-    let publicationStarted = false;
+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)
+            return;
+        faultTriggered = true;
+        throw new Error(`TASK_WORKFLOW_FAULT_INJECTED:${window}`);
+    };
+    const response = (result) => {
+        fault('before-result-return');
+        return executionResult(result);
+    };
     try {
+        fault('before-call');
         const taskDir = assertSandboxTaskSource(manifest.repoRoot, request.taskId);
         const [command] = TASK_WORKFLOW_COMMANDS[request.operation];
         if (request.operation === 'event') {
@@ -24,66 +48,110 @@ export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAt
             const boundEventRequest = lifecycleRecoveryAttestation && eventRequest.requestId === undefined
                 ? { ...eventRequest, requestId: lifecycleRecoveryAttestation.lifecycleRequestId }
                 : eventRequest;
+            fault('before-domain-write');
             const result = applyTaskEvent(boundEventRequest, {
                 repoRoot: manifest.repoRoot,
                 lifecycleRecoveryAttestation,
                 deferLifecycleRecoveryConsumption: true
             });
-            return executionResult(result);
+            publicationCommitted = result.changed;
+            fault('after-atomic-rename');
+            return response(result);
         }
         if (command !== 'task-artifact' && command !== 'task-review') {
-            publicationStarted = true;
-            // Inherit this executor's process group so its existing recovery owns the worker too.
-            const result = await dispatchHostControlCommand({
-                operation: command, payload: { workingDirectory: manifest.repoRoot, args: request.args }
-            });
-            return result;
+            // The broker owns this short-lived executor; no global service or worker
+            // credential participates in the command's authority or recovery path.
+            fault('before-domain-write');
+            const result = dispatchWorkflowCommand(manifest.repoRoot, request.operation, request.args);
+            publicationCommitted = result.changed === true;
+            fault('after-atomic-rename');
+            return response(result);
         }
         const input = command === 'task-artifact' ? parseArtifactCommand(request.args) : parseReviewCommand(request.args);
         if (command === 'task-artifact' && 'operation' in input && input.operation === 'inspect') {
-            return executionResult(executeArtifactCommand(input, { repoRoot: manifest.repoRoot }));
+            fault('before-domain-write');
+            const result = executeArtifactCommand(input, { repoRoot: manifest.repoRoot });
+            publicationCommitted = result.changed === true;
+            fault('after-atomic-rename');
+            return response(result);
         }
         if ('operation' in input && input.operation === 'init') {
-            return executionResult(executeArtifactCommand(input, { repoRoot: manifest.repoRoot, artifactDir: taskDir }));
+            fault('before-domain-write');
+            const result = executeArtifactCommand(input, { repoRoot: manifest.repoRoot, artifactDir: taskDir });
+            publicationCommitted = result.changed === true;
+            fault('after-atomic-rename');
+            return response(result);
         }
         return await withTaskExecutionLock(manifest.repoRoot, request.taskId, `sandbox-control.${request.operation}`, async () => {
             const artifact = await readTaskArtifact(taskDir, { artifact: input.artifact });
             const content = artifact.bytes.toString('utf8');
+            fault('before-domain-write');
             let result;
             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 };
+                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));
-                publicationStarted = true;
-                result = commitLocalArtifactProvenance(prepared);
+                    return executionResult(commitLocalArtifactProvenance(prepared, commitOptions));
+                result = commitLocalArtifactProvenance(prepared, commitOptions);
             }
             else {
                 if (input.overrideTicket)
                     throw new Error('TASK_WORKFLOW_OVERRIDE_UNSUPPORTED');
+                const family = `review-${input.stage}`;
+                if (request.operation === 'review-preflight') {
+                    const result = preflightReviewSummary(input, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true });
+                    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 = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true, startRecovery: true });
+                observeRecoveryPublication();
                 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));
-                publicationStarted = true;
-                result = commitReviewSummaryProvenance(prepared, manifest.repoRoot);
+                    return executionResult(commitReviewSummaryProvenance(prepared, manifest.repoRoot, commitOptions));
+                result = commitReviewSummaryProvenance(prepared, manifest.repoRoot, commitOptions);
             }
+            observeRecoveryPublication();
+            publicationCommitted ||= result.changed === true;
             if (result.status !== 'failed')
                 appendDiagnosticAudit(manifest, 'task-workflow-artifact-finalized', {
                     requestId: request.id, sandboxTaskId: request.taskId, workflowOperation: request.operation,
                     artifact: input.artifact, sha256: result.artifactSha256, semanticDigest: result.semanticDigest
                 });
-            return executionResult({ ...result, changed: true });
+            fault('after-atomic-rename');
+            return response(result);
         });
     }
     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: publicationStarted ? null : false, error: { code, message } });
+        return executionResult({ status: 'failed', changed: publicationCommitted ? null : false, error: { code, message } });
     }
 }
 //# sourceMappingURL=workflow-executor.js.map

package/dist/lib/server/process-state.js

@@ -97,7 +97,7 @@ export function getProcessStartTime(pid, platform = process.platform) {
         return null;
     }
 }
-export function getProcessIdentityState(identity, platform = process.platform) {
+export function getProcessIdentityState(identity, platform = process.platform, runtime = {}) {
     if (!Number.isInteger(identity.pid) || identity.pid <= 0 || !Number.isSafeInteger(identity.startTime)) {
         return 'dead';
     }
@@ -114,8 +114,9 @@ export function getProcessIdentityState(identity, platform = process.platform) {
             return error.code === 'ENOENT' ? 'dead' : 'unknown';
         }
     }
+    const probePid = runtime.probePid ?? ((pid) => process.kill(pid, 0));
     try {
-        process.kill(identity.pid, 0);
+        probePid(identity.pid);
     }
     catch (error) {
         const code = error.code;
@@ -128,23 +129,34 @@ export function getProcessIdentityState(identity, platform = process.platform) {
     if (query === null)
         return 'unknown';
     try {
-        const output = execFileSync(query.command, query.args, {
+        const output = (runtime.execFileSync ?? execFileSync)(query.command, query.args, {
             encoding: 'utf8',
             env: platform === 'darwin' ? { ...process.env, LC_ALL: 'C', LANG: 'C', TZ: 'UTC' } : process.env
         }).trim();
         if (output.length === 0)
-            return 'unknown';
+            return recheckDarwinProcessExit(identity.pid, platform, probePid);
         const startTime = platform === 'win32'
             ? new Date(output).getTime()
             : platform === 'darwin'
                 ? parseDarwinStartTime(output)
                 : null;
         if (startTime === null || Number.isNaN(startTime))
-            return 'unknown';
+            return recheckDarwinProcessExit(identity.pid, platform, probePid);
         return startTime === identity.startTime ? 'alive' : 'dead';
     }
     catch {
+        return recheckDarwinProcessExit(identity.pid, platform, probePid);
+    }
+}
+function recheckDarwinProcessExit(pid, platform, probePid) {
+    if (platform !== 'darwin')
         return 'unknown';
+    try {
+        probePid(pid);
+        return 'unknown';
+    }
+    catch (error) {
+        return error.code === 'ESRCH' ? 'dead' : 'unknown';
     }
 }
 function parsePidRecord(raw) {

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

@@ -3,18 +3,19 @@ import { resolveArtifactContext, hasOpenArtifactRound } from './artifact-lifecyc
 import { parseArtifactName } from './artifact-name.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { getArtifactSchema } from './artifact-schema.js';
-import { finalizeLocalArtifact } from './local-artifact-finalization.js';
+import { finalizeLocalArtifact, preflightLocalArtifact } from './local-artifact-finalization.js';
 import { initializeArtifactSkeleton } from './artifact-operations.js';
 /** One option contract for the CLI and trusted projection executor. */
 export function parseArtifactCommand(args) {
     const [taskRef, operation] = args;
-    if (!taskRef || !['inspect', 'init', 'finalize-local'].includes(operation ?? '')) {
+    if (!taskRef || !['inspect', 'init', 'preflight', 'finalize-local'].includes(operation ?? '')) {
         throw new Error('task ref and a supported artifact operation are required');
     }
     const fields = {};
     const allowed = {
         inspect: ['--family'],
         init: ['--family', '--artifact', '--locale'],
+        'preflight': ['--family', '--artifact', '--recovery-id'],
         'finalize-local': ['--family', '--artifact', '--recovery-id']
     }[operation];
     for (let index = 2; index < args.length; index += 1) {
@@ -72,8 +73,10 @@ export function executeArtifactCommand(command, options = {}) {
         return { ...initializeArtifactSkeleton({ ...input, ...(locale ? { locale } : {}) }), ...identity };
     }
     if (family !== 'analysis' && family !== 'plan' && family !== 'code') {
-        return fail('ARTIFACT_PAYLOAD_INVALID', "finalize-local only supports 'analysis', 'plan', and '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 }) };
 }
 //# 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

@@ -1,11 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
-import { readStableFileSync } from '../host-control/secure-fs.js';
+import { readStableFileSync } from './secure-fs.js';
 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' });