import { assert, canonicalJsonValue, hashJsonValue, hashValue, } from '../assertions/core.mjs'; import { collectToolPlanRepairAuditEvidence, countExactSecrets, emptyToolPlanRepairCountsByProtocolErrorKind, hasSafeToolPlanAuditPayload, isNonEmptyString, sumObjectValues, toolPlanRepairEvidenceHasNoFatalLocalRepair, } from '../assertions/runtime.mjs'; import { fs, os, path, readFileSync } from '../dependencies.mjs'; import { isolatedSuiteAppDataProfile, isolatedSuiteProtectsSourceAppData, isolatedSuiteUsesSiblingAppData, sourceAppDataDirectoryEventIsViolation, } from '../harness/app-data.mjs'; import { parseArguments } from '../harness/config.mjs'; import { safeProcessFailureDiagnostic } from '../harness/process.mjs'; import { isIsolatedRunnerSuite } from '../harness/reporting.mjs'; import { agentConversationPath } from '../harness/runtime.mjs'; import { appRoot, commandFailureMarker, commandPassedMarker, isolatedAgentJoinClaimSchemaVersion, projectSupervisorAgentId, providerActionBatchSchemaVersion, repoRoot, runnerEndpointFileName, state, StreamingSecretScanner, supervisorAutonomousPlayableAppDataSentinelFileName, supervisorAutonomousPlayableAppDataSentinelSchema, supervisorAutonomousPlayableLaneDefenseSuite, supervisorAutonomousPlayableLaneDefenseTask, supervisorCollaborationContractSchemaVersion, supervisorCollaborationPolicySchemaVersion, supervisorCollaborationPolicySnapshotInitialBatchBinding, supervisorCollaborationPolicySnapshotSchemaVersion, supervisorSwarmAutonomousChatSuite, supervisorSwarmCollaborationPolicyMixedRecoverySuite, supervisorSwarmFollowupIsolatedReviews, supervisorSwarmInitialIsolatedReviews, supervisorSwarmIsolatedReviewGroups, supervisorSwarmIsolatedReviews, supervisorSwarmSessionId, supervisorSwarmStaticIsolatedAutonomousChatSuite, supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelFileName, supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelSchema, supervisorSwarmToolPlanHandoffRunnerKillSuite, toolPlanProtocolAuditSafeFields, toolPlanProtocolErrorKinds, toolPlanRepairAuditSafeFields, } from '../runtime-state.mjs'; import { buildSupervisorAutonomousPlayablePartialEvidence, buildSupervisorAutonomousPlayableStdin, collectPartialSupervisorAutonomousPlayableEvidence, isSupervisorAutonomousPlayableLaneDefenseSuite, } from './supervisor-autonomous-playable.mjs'; import { buildSupervisorSwarmEvidence, collectSupervisorSwarmDynamicPrivateValues, driftedSupervisorSwarmCollaborationPolicy, duplicateSupervisorSwarmCollaborationPolicySnapshotBindingCount, duplicateSupervisorSwarmCollaborationPolicySnapshotCount, expectedSupervisorSwarmCollaborationPolicy, inspectSupervisorSwarmCollaborationPolicySnapshot, inspectSupervisorSwarmCollaborationPolicySnapshotBinding, inspectSupervisorSwarmRecoveredRepairConfirmationLifecycle, isSupervisorSwarmSuite, isSupervisorSwarmToolPlanHandoffRunnerKillSuite, normalizeSupervisorSwarmToolPlanUpdate, parseSupervisorSwarmToolPlanHandoffPlan, registerSupervisorSwarmPrivateOutputValues, registerSupervisorSwarmPrivateTransportValues, supervisorSwarmCollaborationPolicyDriftObservationCount, supervisorSwarmCollaborationPolicySnapshotBinding, supervisorSwarmEvidenceFieldTemplate, supervisorSwarmExpectedIsolatedReviewGroups, supervisorSwarmFinalReplyFaultInjectionAllowed, supervisorSwarmFinalReplyFaultPrerequisites, supervisorSwarmFollowupBeforeClaimOrderValid, supervisorSwarmHostVerificationPassed, supervisorSwarmInitialBatchBindsPolicySnapshot, supervisorSwarmIsolatedReviewGroupIndex, supervisorSwarmIsolatedWriteScopeRoots, supervisorSwarmMixedIsolatedGroupEntries, supervisorSwarmObservedJoinClaimForGroups, supervisorSwarmReadyIsolatedGroupIds, supervisorSwarmResidualSidecarsEmpty, supervisorSwarmSeedPrivateValues, supervisorSwarmToolPlanHandoffProxyNeedsCleanup, supervisorSwarmToolPlanHandoffSnapshotEvidence, validateSupervisorSwarmCollaborationPolicySnapshot, validateSupervisorSwarmCollaborationPolicySnapshotBinding, } from './supervisor-swarm.mjs'; export async function runAgentRuntimeRealE2eSelfTests() { const syntheticSourceEndpointLifecycleEvents = [ { phase: 'created', fileName: runnerEndpointFileName }, { phase: 'deleted', fileName: Buffer.from(runnerEndpointFileName) }, ]; const sourceEndpointAbsentLifecycleGuardValidated = syntheticSourceEndpointLifecycleEvents.every(({ fileName }) => sourceAppDataDirectoryEventIsViolation( fileName, '.synthetic-isolated-suite-', { exists: false, fingerprint: null }, ), ) && !sourceAppDataDirectoryEventIsViolation( runnerEndpointFileName, '.synthetic-isolated-suite-', { exists: true, fingerprint: 'synthetic-endpoint-fingerprint' }, ) && sourceAppDataDirectoryEventIsViolation( '.synthetic-isolated-suite-created', '.synthetic-isolated-suite-', { exists: true, fingerprint: 'synthetic-endpoint-fingerprint' }, ) && !sourceAppDataDirectoryEventIsViolation( 'unrelated-source-config-file.json', '.synthetic-isolated-suite-', { exists: false, fingerprint: null }, ); assert( sourceEndpointAbsentLifecycleGuardValidated, 'agent-runtime-real-e2e-self-test-source-endpoint-lifecycle-guard-invalid', ); const previousSuiteForToolPlanHandoff = state.suite; state.suite = supervisorSwarmToolPlanHandoffRunnerKillSuite; const toolPlanHandoffProfile = isolatedSuiteAppDataProfile(); const toolPlanHandoffParsedArguments = parseArguments([ '--config-dir', path.resolve('synthetic-tool-plan-handoff-config'), '--suite', supervisorSwarmToolPlanHandoffRunnerKillSuite, ]); const rootPackage = JSON.parse( readFileSync(path.join(repoRoot, 'package.json'), 'utf8'), ); const shellPackage = JSON.parse( readFileSync(path.join(appRoot, 'package.json'), 'utf8'), ); const previousSuiteForAutonomousPlayable = state.suite; state.suite = supervisorAutonomousPlayableLaneDefenseSuite; const autonomousPlayableProfile = isolatedSuiteAppDataProfile(); const autonomousPlayableParsedArguments = parseArguments([ '--config-dir', path.resolve('synthetic-autonomous-playable-config'), '--suite', supervisorAutonomousPlayableLaneDefenseSuite, ]); const autonomousPlayableStdin = buildSupervisorAutonomousPlayableStdin(); const autonomousPlayablePackageCommandsRegistered = shellPackage.scripts?.[ 'agent-runtime:supervisor-autonomous-playable-lane-defense-real-e2e' ] === 'node scripts/agent-runtime-real-e2e.mjs --suite supervisor-autonomous-playable-lane-defense' && rootPackage.scripts?.[ 'ai-game-creator-shell:agent-runtime:supervisor-autonomous-playable-lane-defense-real-e2e' ] === 'npm --prefix apps/ai-game-creator-shell run agent-runtime:supervisor-autonomous-playable-lane-defense-real-e2e --'; const autonomousPlayableSuiteRegistered = autonomousPlayableParsedArguments.suite === supervisorAutonomousPlayableLaneDefenseSuite && isSupervisorAutonomousPlayableLaneDefenseSuite() && !isSupervisorSwarmSuite() && isIsolatedRunnerSuite() && isolatedSuiteProtectsSourceAppData() && isolatedSuiteUsesSiblingAppData() && autonomousPlayableProfile.sentinelName === supervisorAutonomousPlayableAppDataSentinelFileName && autonomousPlayableProfile.sentinelSchema === supervisorAutonomousPlayableAppDataSentinelSchema && autonomousPlayableStdin.equals( Buffer.from(`${supervisorAutonomousPlayableLaneDefenseTask}\n`, 'utf8'), ) && autonomousPlayablePackageCommandsRegistered; const previousInitialRunIdForAutonomousPlayable = state.initialRunId; const previousProjectRootForAutonomousPlayable = state.projectRoot; const previousInitialTaskForAutonomousPlayable = state.initialTask; const previousAutonomousPlayableTurnReport = state.supervisorAutonomousPlayable.turnReport; const previousAutonomousPlayablePrivateValues = [ ...state.supervisorAutonomousPlayable.privateValues, ]; const previousSupervisorSwarmPrivateValues = [ ...state.supervisorSwarm.privateValues, ]; const previousSupervisorSwarmInitialProviderBatch = state.supervisorSwarm.initialProviderBatch; const autonomousPlayablePartialCanary = 'private-autonomous-partial-canary'; const syntheticAutonomousPlayableRunId = 'synthetic-autonomous-playable-partial-root'; state.initialRunId = syntheticAutonomousPlayableRunId; state.supervisorAutonomousPlayable.privateValues = [ ...new Set([ ...state.supervisorAutonomousPlayable.privateValues, autonomousPlayablePartialCanary, ]), ]; const syntheticAutonomousPlayablePartialEvidence = buildSupervisorAutonomousPlayablePartialEvidence( { taskSnapshot: { latest: [ { agentId: projectSupervisorAgentId, runId: syntheticAutonomousPlayableRunId, status: 'running', phase: 'waiting-for-agent', task: autonomousPlayablePartialCanary, }, { agentId: 'code-prototype', sessionId: 'synthetic-original-session', runId: 'synthetic-original-run', parentAgentId: projectSupervisorAgentId, parentRunId: syntheticAutonomousPlayableRunId, delegationId: 'synthetic-original-delivery', status: 'failed', phase: 'failed', }, { agentId: 'code-prototype', sessionId: 'synthetic-repair-session', runId: 'synthetic-repair-run', parentAgentId: projectSupervisorAgentId, parentRunId: syntheticAutonomousPlayableRunId, delegationId: 'synthetic-repair-delivery', status: 'running', phase: 'planning', }, ], }, runtimeStates: [ { agentId: projectSupervisorAgentId, runId: syntheticAutonomousPlayableRunId, status: 'running', phase: 'waiting-for-agent', currentTask: autonomousPlayablePartialCanary, }, { agentId: 'code-prototype', runId: 'synthetic-original-run', parentAgentId: projectSupervisorAgentId, parentRunId: syntheticAutonomousPlayableRunId, status: 'failed', phase: 'failed', }, { agentId: 'code-prototype', runId: 'synthetic-repair-run', parentAgentId: projectSupervisorAgentId, parentRunId: syntheticAutonomousPlayableRunId, status: 'running', phase: 'waiting-for-provider-retry', }, ], deliveries: [ { parentAgentId: projectSupervisorAgentId, parentRunId: syntheticAutonomousPlayableRunId, delegationId: 'synthetic-original-delivery', repairOfDelegationId: null, targetAgentId: 'code-prototype', targetSessionId: 'synthetic-original-session', targetRunId: 'synthetic-original-run', status: 'ready', terminalStatus: 'failed', structuredResult: { contractStatus: 'needs-repair' }, }, { parentAgentId: projectSupervisorAgentId, parentRunId: syntheticAutonomousPlayableRunId, delegationId: 'synthetic-repair-delivery', repairOfDelegationId: 'synthetic-original-delivery', targetAgentId: 'code-prototype', targetSessionId: 'synthetic-repair-session', targetRunId: 'synthetic-repair-run', status: 'dispatched', terminalStatus: null, }, ], agentDb: [ { recordType: 'agent.runtime.provider_request.lifecycle', agentId: 'code-prototype', runId: 'synthetic-original-run', requestId: 'synthetic-provider-request', status: 'started', }, { recordType: 'agent.runtime.provider_request.lifecycle', agentId: 'code-prototype', runId: 'synthetic-original-run', requestId: 'synthetic-provider-request', status: 'failed', }, { recordType: 'agent.runtime.provider_request.retry', agentId: 'code-prototype', runId: 'synthetic-original-run', errorKind: 'transport', }, ], supervisorConversation: [ { role: 'user', content: autonomousPlayablePartialCanary, }, ], professionalConversations: [], failureEvidenceErrors: {}, }, { residualSidecars: { providerRetries: 1 }, pendingActionCount: 0, turnReport: { outcome: 'incomplete', parentAgentId: projectSupervisorAgentId, sessionId: supervisorSwarmSessionId, parentRunId: syntheticAutonomousPlayableRunId, runtimeCount: 3, busyRuntimeCount: 2, pendingTaskCount: 0, runningTaskCount: 2, waitingForConfirmationCount: 0, waitingForUserInputCount: 0, reconciliationAgentCount: 0, }, }, ); const autonomousPlayablePartialEvidenceValidated = syntheticAutonomousPlayablePartialEvidence.evidenceCompleteness === 'partial' && syntheticAutonomousPlayablePartialEvidence.partialEvidenceCollected === true && syntheticAutonomousPlayablePartialEvidence.partialPrivacyScanComplete === false && syntheticAutonomousPlayablePartialEvidence.rootRunObserved === true && syntheticAutonomousPlayablePartialEvidence.parentRuntimePhase === 'waiting-for-agent' && syntheticAutonomousPlayablePartialEvidence.childTaskStatusCounts.failed === 1 && syntheticAutonomousPlayablePartialEvidence.childTaskStatusCounts.running === 1 && syntheticAutonomousPlayablePartialEvidence.failedOriginalChildCount === 1 && syntheticAutonomousPlayablePartialEvidence.failedRepairChildCount === 0 && syntheticAutonomousPlayablePartialEvidence.awaitingRepairCount === 1 && syntheticAutonomousPlayablePartialEvidence.repairDeliveryStatusCounts .dispatched === 1 && syntheticAutonomousPlayablePartialEvidence.providerLifecycleFailedCount === 1 && syntheticAutonomousPlayablePartialEvidence.providerRetryAuditCount === 1 && syntheticAutonomousPlayablePartialEvidence.providerTransportRetryAuditCount === 1 && syntheticAutonomousPlayablePartialEvidence.providerRetrySidecarCount === 1 && syntheticAutonomousPlayablePartialEvidence.turnReportOutcome === 'incomplete' && syntheticAutonomousPlayablePartialEvidence.turnReportCaptured === true && syntheticAutonomousPlayablePartialEvidence.turnReportParentIdentityStable === true && syntheticAutonomousPlayablePartialEvidence.turnReportPrivateLeakCount === 0 && !JSON.stringify(syntheticAutonomousPlayablePartialEvidence).includes( autonomousPlayablePartialCanary, ); const syntheticAutonomousPlayableCollectorRoot = await fs.mkdtemp( path.join(os.tmpdir(), 'genarrative-autonomous-partial-self-test-'), ); let syntheticAutonomousPlayableCollectorEvidence; try { state.projectRoot = syntheticAutonomousPlayableCollectorRoot; state.initialTask = { bytes: Buffer.byteLength(autonomousPlayablePartialCanary, 'utf8'), sha256: hashValue(autonomousPlayablePartialCanary), }; state.supervisorSwarm.privateValues = [autonomousPlayablePartialCanary]; state.supervisorSwarm.initialProviderBatch = null; state.supervisorAutonomousPlayable.turnReport = { outcome: 'needs-reconciliation', parentAgentId: projectSupervisorAgentId, sessionId: supervisorSwarmSessionId, parentRunId: syntheticAutonomousPlayableRunId, runtimeCount: 1, busyRuntimeCount: 0, pendingTaskCount: 0, runningTaskCount: 0, waitingForConfirmationCount: 0, waitingForUserInputCount: 0, reconciliationAgentCount: 1, privateDiagnostic: autonomousPlayablePartialCanary, }; const taskPath = path.join( state.projectRoot, '.agent/runtime/tasks/project-supervisor.jsonl', ); const runtimePath = path.join( state.projectRoot, '.agent/runtime/agents/project-supervisor.json', ); const conversationPath = agentConversationPath( projectSupervisorAgentId, supervisorSwarmSessionId, ); await fs.mkdir(path.dirname(taskPath), { recursive: true }); await fs.mkdir(path.dirname(runtimePath), { recursive: true }); await fs.mkdir(path.dirname(conversationPath), { recursive: true }); await fs.writeFile( taskPath, `${JSON.stringify({ agentId: projectSupervisorAgentId, runId: syntheticAutonomousPlayableRunId, status: 'budget-exhausted', phase: 'budget-exhausted', task: autonomousPlayablePartialCanary, })}\n`, ); await fs.writeFile( runtimePath, JSON.stringify({ agentId: projectSupervisorAgentId, runId: syntheticAutonomousPlayableRunId, status: 'needs-reconciliation', phase: 'needs-reconciliation', currentTask: autonomousPlayablePartialCanary, }), ); await fs.writeFile( conversationPath, `${JSON.stringify({ role: 'user', content: autonomousPlayablePartialCanary, })}\n`, ); syntheticAutonomousPlayableCollectorEvidence = await collectPartialSupervisorAutonomousPlayableEvidence(); } finally { state.projectRoot = previousProjectRootForAutonomousPlayable; state.initialTask = previousInitialTaskForAutonomousPlayable; state.supervisorAutonomousPlayable.turnReport = previousAutonomousPlayableTurnReport; state.supervisorAutonomousPlayable.privateValues = previousAutonomousPlayablePrivateValues; state.supervisorSwarm.privateValues = previousSupervisorSwarmPrivateValues; state.supervisorSwarm.initialProviderBatch = previousSupervisorSwarmInitialProviderBatch; await fs.rm(syntheticAutonomousPlayableCollectorRoot, { recursive: true, force: true, }); } const autonomousPlayablePartialCollectorPrivacyValidated = syntheticAutonomousPlayableCollectorEvidence.evidenceCompleteness === 'partial' && syntheticAutonomousPlayableCollectorEvidence.rootRunObserved === true && syntheticAutonomousPlayableCollectorEvidence.parentTaskStatus === 'budget-exhausted' && syntheticAutonomousPlayableCollectorEvidence.parentTaskPhase === 'budget-exhausted' && syntheticAutonomousPlayableCollectorEvidence.parentRuntimeStatus === 'needs-reconciliation' && syntheticAutonomousPlayableCollectorEvidence.parentRuntimePhase === 'needs-reconciliation' && syntheticAutonomousPlayableCollectorEvidence.supervisorUserMessageCount === 1 && syntheticAutonomousPlayableCollectorEvidence.turnReportPrivateLeakCount === 1 && !JSON.stringify(syntheticAutonomousPlayableCollectorEvidence).includes( autonomousPlayablePartialCanary, ); state.initialRunId = previousInitialRunIdForAutonomousPlayable; state.suite = previousSuiteForAutonomousPlayable; assert( autonomousPlayableSuiteRegistered && autonomousPlayablePartialEvidenceValidated && autonomousPlayablePartialCollectorPrivacyValidated, 'agent-runtime-real-e2e-self-test-autonomous-playable-suite-invalid', ); const rootToolPlanHandoffCommand = 'npm --prefix apps/ai-game-creator-shell run agent-runtime:supervisor-swarm-tool-plan-handoff-runner-kill-real-e2e --'; const shellToolPlanHandoffCommand = 'node scripts/agent-runtime-real-e2e.mjs --suite supervisor-swarm-tool-plan-handoff-runner-kill'; const originalToolPlanHandoffProxy = state.supervisorSwarm.toolPlanHandoffProxy; state.supervisorSwarm.toolPlanHandoffProxy = {}; const toolPlanHandoffCleanupRegistered = supervisorSwarmToolPlanHandoffProxyNeedsCleanup(); state.supervisorSwarm.toolPlanHandoffProxy = originalToolPlanHandoffProxy; const toolPlanHandoffPartialEvidence = supervisorSwarmToolPlanHandoffSnapshotEvidence(); const toolPlanHandoffPackageCommandsRegistered = rootPackage.scripts?.[ 'ai-game-creator-shell:agent-runtime:supervisor-swarm-tool-plan-handoff-runner-kill-real-e2e' ] === rootToolPlanHandoffCommand && shellPackage.scripts?.[ 'agent-runtime:supervisor-swarm-tool-plan-handoff-runner-kill-real-e2e' ] === shellToolPlanHandoffCommand; const toolPlanHandoffSourceGuardRegistered = sourceAppDataDirectoryEventIsViolation( `${toolPlanHandoffProfile.prefix}synthetic`, toolPlanHandoffProfile.prefix, { exists: false, fingerprint: null }, ); const toolPlanHandoffSuiteRegistered = toolPlanHandoffParsedArguments.suite === supervisorSwarmToolPlanHandoffRunnerKillSuite && isSupervisorSwarmToolPlanHandoffRunnerKillSuite() && isSupervisorSwarmSuite() && isIsolatedRunnerSuite() && isolatedSuiteProtectsSourceAppData() && toolPlanHandoffProfile.prefix === '.agent-runtime-real-e2e-supervisor-swarm-tool-plan-handoff-runner-kill-' && toolPlanHandoffProfile.codePrefix === 'supervisor-swarm-tool-plan-handoff-runner-kill-appdata' && toolPlanHandoffProfile.sentinelName === supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelFileName && toolPlanHandoffProfile.sentinelSchema === supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelSchema && toolPlanHandoffSourceGuardRegistered && toolPlanHandoffPackageCommandsRegistered && toolPlanHandoffCleanupRegistered && toolPlanHandoffPartialEvidence.toolPlanHandoffModeEnabled === true && Object.hasOwn( toolPlanHandoffPartialEvidence, 'toolPlanHandoffNetworkReplayCount', ); state.suite = previousSuiteForToolPlanHandoff; const syntheticToolPlanHandoffEntry = { response: { toolCalls: [ { id: 'synthetic-plan-call', name: 'update_agent_plan', arguments: JSON.stringify({ explanation: 'synthetic plan', steps: [{ step: 'delegate', status: 'in_progress' }], }), }, ...['design', 'quality'].map((agentId) => ({ id: `synthetic-${agentId}-call`, name: 'runtime_tool_agent_delegate', arguments: JSON.stringify({ reason: `delegate ${agentId}`, input: { agentId }, }), })), ], }, }; const syntheticToolPlanHandoffPlan = parseSupervisorSwarmToolPlanHandoffPlan( syntheticToolPlanHandoffEntry, ); const syntheticNormalizedPlanUpdate = normalizeSupervisorSwarmToolPlanUpdate({ explanation: ` ${'x'.repeat(241)} `, steps: [{ step: ` ${'y'.repeat(181)} `, status: ' pending ' }], }); const toolPlanHandoffPlanProjectionValidated = syntheticToolPlanHandoffPlan.thinkingSummary === 'synthetic plan' && syntheticToolPlanHandoffPlan.planUpdate?.steps?.length === 1 && syntheticToolPlanHandoffPlan.actions.length === 2 && syntheticToolPlanHandoffPlan.actions.every( (action) => action.tool === 'agent.delegate', ) && syntheticToolPlanHandoffPlan.response === '' && syntheticNormalizedPlanUpdate.explanation === `${'x'.repeat(240)}…` && syntheticNormalizedPlanUpdate.steps[0].step === `${'y'.repeat(180)}…` && syntheticNormalizedPlanUpdate.steps[0].status === 'pending' && hashJsonValue(syntheticToolPlanHandoffPlan) === hashJsonValue(canonicalJsonValue(syntheticToolPlanHandoffPlan)); const toolPlanHandoffEvidenceFieldsRegistered = [ 'toolPlanHandoffModeEnabled', 'toolPlanHandoffCheckpointCaptured', 'toolPlanHandoffNetworkReplayCount', 'toolPlanHandoffLifecycleClosedExactlyOnce', 'toolPlanHandoffAuditIdempotent', 'toolPlanHandoffRecoveredPlanFingerprintMatched', 'toolPlanHandoffCapabilityLeakCount', 'toolPlanHandoffPrePersistUnknownResultWindowCovered', ].every((field) => Object.hasOwn(supervisorSwarmEvidenceFieldTemplate(), field), ); assert( toolPlanHandoffSuiteRegistered && toolPlanHandoffPlanProjectionValidated && toolPlanHandoffEvidenceFieldsRegistered && supervisorSwarmEvidenceFieldTemplate() .toolPlanHandoffPrePersistUnknownResultWindowCovered === false, 'agent-runtime-real-e2e-self-test-tool-plan-handoff-suite-invalid', ); const previousInitialRunId = state.initialRunId; const syntheticFinalReplyRunId = 'synthetic-final-reply-run'; state.initialRunId = syntheticFinalReplyRunId; const syntheticToolPlanStarted = { recordType: 'agent.runtime.provider_request.lifecycle', status: 'started', agentId: projectSupervisorAgentId, runId: syntheticFinalReplyRunId, requestKind: 'tool-plan', requestId: 'synthetic-tool-plan-request', }; const syntheticVerificationAudit = { recordType: 'agent.runtime.project.verify', agentId: projectSupervisorAgentId, runId: syntheticFinalReplyRunId, actionId: 'synthetic-verification-action', status: 'completed', exitCode: 0, timedOut: false, }; const syntheticVerificationReceipt = { recordType: 'agent.runtime.action_receipt', agentId: projectSupervisorAgentId, runId: syntheticFinalReplyRunId, actionId: syntheticVerificationAudit.actionId, tool: 'project.verify', status: 'ok', }; const syntheticVerificationObservation = { recordType: 'agent.runtime.tool_observation', agentId: projectSupervisorAgentId, runId: syntheticFinalReplyRunId, actionId: syntheticVerificationAudit.actionId, tool: 'project.verify', status: 'ok', }; const syntheticFinalReplyStarted = { recordType: 'agent.runtime.provider_request.lifecycle', status: 'started', agentId: projectSupervisorAgentId, taskId: 'synthetic-final-reply-task', sessionId: supervisorSwarmSessionId, runId: syntheticFinalReplyRunId, requestKind: 'final-reply', requestId: 'synthetic-final-reply-request', requestSlot: 'synthetic-final-reply-slot', }; const syntheticDeliveries = [ ['synthetic-design', null], ['synthetic-quality', null], ['synthetic-repair', 'synthetic-quality'], ].map(([delegationId, repairOfDelegationId]) => ({ parentAgentId: projectSupervisorAgentId, parentSessionId: supervisorSwarmSessionId, parentRunId: syntheticFinalReplyRunId, delegationId, repairOfDelegationId, status: 'claimed-by-parent', terminalStatus: 'completed', })); const syntheticFinalReplyPrerequisites = supervisorSwarmFinalReplyFaultPrerequisites( { deliveries: syntheticDeliveries, claims: [ { status: 'observed', receipts: [ { delegationId: 'synthetic-design' }, { delegationId: 'synthetic-quality' }, ], }, { status: 'observed', receipts: [{ delegationId: 'synthetic-repair' }], }, ], agentDb: [ syntheticToolPlanStarted, syntheticVerificationAudit, syntheticVerificationReceipt, syntheticVerificationObservation, syntheticFinalReplyStarted, ], supervisorConversation: [], projectRevision: { revision: 2 }, }, syntheticFinalReplyStarted, { sequence: 7, acceptedAtMs: 1234 }, ); const syntheticInvalidFinalReplyPrerequisites = supervisorSwarmFinalReplyFaultPrerequisites( { deliveries: syntheticDeliveries, claims: [ { status: 'observed', receipts: [ { delegationId: 'synthetic-design' }, { delegationId: 'synthetic-quality' }, ], }, { status: 'observed', receipts: [{ delegationId: 'synthetic-repair' }], }, ], agentDb: [ syntheticToolPlanStarted, syntheticFinalReplyStarted, syntheticVerificationAudit, syntheticVerificationReceipt, syntheticVerificationObservation, ], supervisorConversation: [{ role: 'assistant' }], projectRevision: { revision: 2 }, }, syntheticFinalReplyStarted, { sequence: 7, acceptedAtMs: 1234 }, ); state.initialRunId = previousInitialRunId; assert( syntheticFinalReplyPrerequisites.preconditionsValid && syntheticFinalReplyPrerequisites.requestKind === 'final-reply' && syntheticFinalReplyPrerequisites.deliveryCount === 3 && syntheticFinalReplyPrerequisites.repairDeliveryCount === 1 && syntheticFinalReplyPrerequisites.observedClaimReceiptCount === 3 && syntheticFinalReplyPrerequisites.runtimeVerificationCount === 1 && syntheticFinalReplyPrerequisites.parentToolPlanStartedCount === 1 && !syntheticInvalidFinalReplyPrerequisites.preconditionsValid && JSON.stringify( syntheticInvalidFinalReplyPrerequisites.invalidPrerequisiteFields, ) === JSON.stringify(['assistantAbsent']) && supervisorSwarmHostVerificationPassed({ stdout: commandPassedMarker, stderr: '', }) && !supervisorSwarmHostVerificationPassed({ stdout: commandFailureMarker, stderr: '', }) && supervisorSwarmFinalReplyFaultInjectionAllowed({ preconditionsValid: true, }) && !supervisorSwarmFinalReplyFaultInjectionAllowed({ preconditionsValid: false, }) && supervisorSwarmResidualSidecarsEmpty({ finalizations: 0, retries: 0 }) && !supervisorSwarmResidualSidecarsEmpty({ finalizations: 1, retries: 0, }), 'agent-runtime-real-e2e-self-test-final-reply-fault-prerequisite-invalid', ); const newlineValue = 'private first line\nprivate second line'; const quotedValue = 'private value says "quoted"'; const backslashValue = 'private\\nested\\value'; const combinedValue = `${newlineValue}\n${quotedValue}\n${backslashValue}`; const exactSecretCounts = { newline: countExactSecrets( Buffer.from(JSON.stringify({ value: newlineValue })), [newlineValue], ), quote: countExactSecrets( Buffer.from(JSON.stringify({ value: quotedValue })), [quotedValue], ), backslash: countExactSecrets( Buffer.from(JSON.stringify({ value: backslashValue })), [backslashValue], ), combined: countExactSecrets( Buffer.from(JSON.stringify({ value: combinedValue })), [combinedValue], ), escapedFallback: countExactSecrets( Buffer.from( `prefix:${JSON.stringify(combinedValue).slice(1, -1)}:suffix`, ), [combinedValue], ), duplicateSecretInput: countExactSecrets( Buffer.from(JSON.stringify({ value: combinedValue })), [combinedValue, combinedValue], ), }; assert( Object.values(exactSecretCounts).every((count) => count === 1), 'agent-runtime-real-e2e-self-test-exact-secret-count-invalid', ); const previousPrivateValueScopeState = { secrets: state.secrets, transcriptOnlySecrets: state.transcriptOnlySecrets, privateValues: state.supervisorSwarm.privateValues, transcriptScanner: state.transcriptScanner, }; const syntheticTransportSecret = 'synthetic-private-transport-secret-for-scope-self-test'; const syntheticPrivateOutput = 'synthetic-private-output-for-scope-self-test'; state.secrets = []; state.transcriptOnlySecrets = []; state.supervisorSwarm.privateValues = []; state.transcriptScanner = new StreamingSecretScanner([]); registerSupervisorSwarmPrivateTransportValues([syntheticTransportSecret]); registerSupervisorSwarmPrivateOutputValues([syntheticPrivateOutput]); const privateOutputSplitAt = Math.floor(syntheticPrivateOutput.length / 2); state.transcriptScanner.scan( 'synthetic-private-output', syntheticPrivateOutput.slice(0, privateOutputSplitAt), ); state.transcriptScanner.scan( 'synthetic-private-output', syntheticPrivateOutput.slice(privateOutputSplitAt), ); const scopedPrivateOutputValidated = state.secrets.includes(syntheticTransportSecret) && !state.secrets.includes(syntheticPrivateOutput) && state.transcriptOnlySecrets.includes(syntheticPrivateOutput) && state.supervisorSwarm.privateValues.includes(syntheticTransportSecret) && state.supervisorSwarm.privateValues.includes(syntheticPrivateOutput) && state.transcriptScanner.count === 1 && countExactSecrets( JSON.stringify({ privateOutput: syntheticPrivateOutput }), state.secrets, ) === 0 && countExactSecrets( JSON.stringify({ privateOutput: syntheticPrivateOutput }), [...state.secrets, ...state.transcriptOnlySecrets], ) === 1; state.secrets = previousPrivateValueScopeState.secrets; state.transcriptOnlySecrets = previousPrivateValueScopeState.transcriptOnlySecrets; state.supervisorSwarm.privateValues = previousPrivateValueScopeState.privateValues; state.transcriptScanner = previousPrivateValueScopeState.transcriptScanner; assert( scopedPrivateOutputValidated, 'agent-runtime-real-e2e-self-test-private-output-scope-invalid', ); const syntheticRecoveredRepairSessionId = 'synthetic-repair-session'; const syntheticRecoveredRepairIdentity = { agentId: 'synthetic-repair-agent', runId: 'synthetic-repair-run', actionId: 'synthetic-repair-action', actionFingerprint: 'synthetic-repair-fingerprint', tool: 'project.patchset', }; const matchesSyntheticRecoveredRepair = (record) => Object.entries(syntheticRecoveredRepairIdentity).every( ([field, value]) => record[field] === value, ); const syntheticRecoveredRepairRecords = (requirementRecordType) => [ { ...syntheticRecoveredRepairIdentity, recordType: requirementRecordType, ...(requirementRecordType === 'agent.runtime.provider_action_batch.confirmation_required' ? { sessionId: syntheticRecoveredRepairSessionId, batchId: 'synthetic-repair-batch', actionCount: 1, actionIndex: 0, } : { summary: 'synthetic legacy confirmation requirement' }), }, { ...syntheticRecoveredRepairIdentity, recordType: 'agent.runtime.tool_confirmation.approved', sessionId: syntheticRecoveredRepairSessionId, confirmedRunId: syntheticRecoveredRepairIdentity.runId, commandId: syntheticRecoveredRepairIdentity.tool, }, { ...syntheticRecoveredRepairIdentity, recordType: 'agent.runtime.action_receipt', sessionId: syntheticRecoveredRepairSessionId, executionMode: 'confirmation', status: 'ok', }, ]; const inspectSyntheticRecoveredRepair = (records) => inspectSupervisorSwarmRecoveredRepairConfirmationLifecycle( records, matchesSyntheticRecoveredRepair, syntheticRecoveredRepairSessionId, syntheticRecoveredRepairIdentity.runId, ); const syntheticModernRecoveredRepairRecords = syntheticRecoveredRepairRecords( 'agent.runtime.provider_action_batch.confirmation_required', ); const syntheticLegacyRecoveredRepairRecords = syntheticRecoveredRepairRecords( 'agent.runtime.tool_confirmation_required', ); const syntheticModernRecoveredRepairLifecycle = inspectSyntheticRecoveredRepair(syntheticModernRecoveredRepairRecords); const syntheticLegacyRecoveredRepairLifecycle = inspectSyntheticRecoveredRepair(syntheticLegacyRecoveredRepairRecords); const syntheticRecoveredRepairLifecycles = [ syntheticModernRecoveredRepairLifecycle, syntheticLegacyRecoveredRepairLifecycle, ]; const syntheticRecoveredRepairNegativeLifecycles = [ syntheticModernRecoveredRepairRecords, syntheticLegacyRecoveredRepairRecords, ].flatMap((records) => [ ...records.map((record) => inspectSyntheticRecoveredRepair([...records, { ...record }]), ), ...records.map((_, missingIndex) => inspectSyntheticRecoveredRepair( records.filter((__, recordIndex) => recordIndex !== missingIndex), ), ), ]); const syntheticRecoveredRepairConflictLifecycle = inspectSyntheticRecoveredRepair([ syntheticModernRecoveredRepairRecords[0], syntheticLegacyRecoveredRepairRecords[0], ...syntheticModernRecoveredRepairRecords.slice(1), ]); const syntheticRecoveredRepairAutoReceiptLifecycle = inspectSyntheticRecoveredRepair( syntheticModernRecoveredRepairRecords.map((record) => record.recordType === 'agent.runtime.action_receipt' ? { ...record, executionMode: 'auto' } : record, ), ); const syntheticRecoveredRepairWrongRunLifecycle = inspectSyntheticRecoveredRepair( syntheticModernRecoveredRepairRecords.map((record) => record.recordType === 'agent.runtime.tool_confirmation.approved' ? { ...record, confirmedRunId: 'synthetic-other-run' } : record, ), ); const syntheticRecoveredRepairMissingSessionLifecycles = syntheticModernRecoveredRepairRecords.map((_, missingSessionIndex) => inspectSyntheticRecoveredRepair( syntheticModernRecoveredRepairRecords.map((record, recordIndex) => { if (recordIndex !== missingSessionIndex) return record; const recordWithoutSession = { ...record }; delete recordWithoutSession.sessionId; return recordWithoutSession; }), ), ); const syntheticRecoveredRepairWrongSessionLifecycle = inspectSyntheticRecoveredRepair( syntheticModernRecoveredRepairRecords.map((record) => isNonEmptyString(record.sessionId) ? { ...record, sessionId: 'synthetic-other-session' } : record, ), ); const syntheticLegacyRecoveredRepairWrongSessionLifecycle = inspectSyntheticRecoveredRepair([ { ...syntheticLegacyRecoveredRepairRecords[0], sessionId: 'synthetic-other-session', }, ...syntheticLegacyRecoveredRepairRecords.slice(1), ]); const syntheticRecoveredRepairOutOfOrderLifecycle = inspectSyntheticRecoveredRepair([ syntheticModernRecoveredRepairRecords[1], syntheticModernRecoveredRepairRecords[0], syntheticModernRecoveredRepairRecords[2], ]); assert( syntheticRecoveredRepairLifecycles.every( (lifecycle) => lifecycle.valid && lifecycle.confirmationRequirements.length === 1 && lifecycle.approvals.length === 1 && lifecycle.receipts.length === 1, ) && syntheticRecoveredRepairNegativeLifecycles.every( (lifecycle) => !lifecycle.valid, ) && !Object.hasOwn(syntheticLegacyRecoveredRepairRecords[0], 'sessionId') && syntheticLegacyRecoveredRepairLifecycle.valid && syntheticRecoveredRepairMissingSessionLifecycles.every( (lifecycle) => !lifecycle.valid, ) && !syntheticRecoveredRepairConflictLifecycle.valid && !syntheticRecoveredRepairAutoReceiptLifecycle.valid && !syntheticRecoveredRepairWrongRunLifecycle.valid && !syntheticRecoveredRepairWrongSessionLifecycle.valid && !syntheticLegacyRecoveredRepairWrongSessionLifecycle.valid && !syntheticRecoveredRepairOutOfOrderLifecycle.valid, 'agent-runtime-real-e2e-self-test-recovered-repair-confirmation-lifecycle-invalid', ); const evidenceMetadata = { kind: 'project.verify.metadata', path: 'game/metadata-only.txt', sha256: 'a'.repeat(64), }; const expectedPrivateValues = [ 'private static delivery task', 'private static acceptance criterion', 'private static result summary', 'private evidence summary body', 'private professional conversation body', ]; const dynamicPrivateValues = collectSupervisorSwarmDynamicPrivateValues({ deliveries: [ { task: expectedPrivateValues[0], acceptanceCriteria: [expectedPrivateValues[1]], resultSummary: expectedPrivateValues[2], structuredResult: { evidence: [ { ...evidenceMetadata, summary: expectedPrivateValues[3], }, ], }, }, ], professionalConversations: [ { messages: [{ content: expectedPrivateValues[4] }] }, ], isolatedGroups: [], isolatedInstances: [], isolatedResults: [], isolatedConversations: [], }); assert( expectedPrivateValues.every((value) => dynamicPrivateValues.includes(value), ), 'agent-runtime-real-e2e-self-test-dynamic-private-body-missing', ); assert( Object.values(evidenceMetadata).every( (value) => !dynamicPrivateValues.includes(value), ), 'agent-runtime-real-e2e-self-test-evidence-metadata-private', ); const seedPrivateValues = supervisorSwarmSeedPrivateValues( 'private repository instructions body', ); assert( supervisorSwarmIsolatedReviews.every( (review) => seedPrivateValues.includes(review.content) && seedPrivateValues.includes(review.requirement) && review.boundaryTerms.every((term) => !seedPrivateValues.includes(term)), ), 'agent-runtime-real-e2e-self-test-generic-boundary-term-private', ); const syntheticMixedGroups = [ { delegationGroupId: 'synthetic-followup-group', request: { children: supervisorSwarmFollowupIsolatedReviews.map((review) => ({ expectedArtifacts: [review.path], })), }, }, { delegationGroupId: 'synthetic-initial-group', request: { children: supervisorSwarmInitialIsolatedReviews.map((review) => ({ expectedArtifacts: [review.path], })), }, }, ]; const syntheticMixedEntries = supervisorSwarmMixedIsolatedGroupEntries( syntheticMixedGroups, supervisorSwarmIsolatedReviewGroups, ); const syntheticSingleGroupEntries = supervisorSwarmMixedIsolatedGroupEntries( [ { delegationGroupId: 'synthetic-single-group', request: { children: supervisorSwarmIsolatedReviews.map((review) => ({ expectedArtifacts: [review.path], })), }, }, ], [supervisorSwarmIsolatedReviews], ); const syntheticReadyGroupIds = supervisorSwarmReadyIsolatedGroupIds( `readyIsolatedJoins: ${JSON.stringify({ ready: true, joins: syntheticMixedEntries.map(({ group }) => ({ delegationGroupId: group.delegationGroupId, })), })}\n\nagentId: ${projectSupervisorAgentId}`, ); const syntheticObservedJoinClaim = supervisorSwarmObservedJoinClaimForGroups( [ { schemaVersion: isolatedAgentJoinClaimSchemaVersion, parentAgentId: projectSupervisorAgentId, parentRunId: 'synthetic-parent-run', actionId: 'synthetic-claim-action', status: 'observed', joins: syntheticMixedEntries.map(({ group }) => ({ delegationGroupId: group.delegationGroupId, })), }, ], syntheticReadyGroupIds, ); const syntheticWriteScopeRoots = supervisorSwarmIsolatedWriteScopeRoots( supervisorSwarmIsolatedReviewGroups.flatMap((reviews) => reviews.map((review) => ({ writeScopes: [review.scope] })), ), ); let syntheticOverlappingWriteScopesRejected = false; try { supervisorSwarmIsolatedWriteScopeRoots([ { writeScopes: ['e2e/**'] }, { writeScopes: ['e2e/isolated-a/**'] }, ]); } catch (error) { syntheticOverlappingWriteScopesRejected = error?.code === 'supervisor-swarm-mixed-child-write-scopes-overlap'; } const syntheticFollowupOrderValidated = supervisorSwarmFollowupBeforeClaimOrderValid(3, 5, [8, 9]) && !supervisorSwarmFollowupBeforeClaimOrderValid(3, 8, [8, 9]); const originalSuite = state.suite; const originalInitialRunId = state.initialRunId; state.suite = supervisorSwarmStaticIsolatedAutonomousChatSuite; const multiGroupPolicy = expectedSupervisorSwarmCollaborationPolicy(); const multiGroupCount = supervisorSwarmExpectedIsolatedReviewGroups().length; const syntheticSnapshotExpected = { projectId: 'synthetic-project-id', parentAgentId: projectSupervisorAgentId, parentRunId: 'synthetic-parent-run', boundFrom: supervisorCollaborationPolicySnapshotInitialBatchBinding, policy: multiGroupPolicy, policyFingerprint: hashValue(JSON.stringify(multiGroupPolicy)), }; const syntheticSnapshotBindingBatch = { schemaVersion: providerActionBatchSchemaVersion, batchId: 'synthetic-provider-batch', projectId: syntheticSnapshotExpected.projectId, agentId: projectSupervisorAgentId, taskId: 'synthetic-parent-task', sessionId: supervisorSwarmSessionId, runId: syntheticSnapshotExpected.parentRunId, status: 'waiting-confirmation', collaborationContract: { schemaVersion: supervisorCollaborationContractSchemaVersion, policySchemaVersion: supervisorCollaborationPolicySchemaVersion, policySnapshot: multiGroupPolicy, policyFingerprint: syntheticSnapshotExpected.policyFingerprint, contractFingerprint: hashValue('synthetic-collaboration-contract'), }, }; const syntheticSnapshotBindingBatchAccepted = supervisorSwarmInitialBatchBindsPolicySnapshot( syntheticSnapshotBindingBatch, syntheticSnapshotExpected.parentRunId, ); const syntheticSnapshotBindingBatchRejections = [ { ...syntheticSnapshotBindingBatch, status: 'aborted' }, { ...syntheticSnapshotBindingBatch, collaborationContract: null }, { ...syntheticSnapshotBindingBatch, agentId: 'synthetic-other-agent' }, { ...syntheticSnapshotBindingBatch, runId: 'synthetic-other-run' }, { ...syntheticSnapshotBindingBatch, schemaVersion: 'legacy-v1' }, ].every( (batch) => !supervisorSwarmInitialBatchBindsPolicySnapshot( batch, syntheticSnapshotExpected.parentRunId, ), ); const syntheticSnapshotIdentity = { schemaVersion: supervisorCollaborationPolicySnapshotSchemaVersion, ...syntheticSnapshotExpected, }; const syntheticSnapshot = { ...syntheticSnapshotIdentity, snapshotFingerprint: hashJsonValue(syntheticSnapshotIdentity), boundAt: 1_784_305_826, }; const syntheticSnapshotInspection = validateSupervisorSwarmCollaborationPolicySnapshot( syntheticSnapshot, syntheticSnapshotExpected, ); const syntheticSnapshotBinding = supervisorSwarmCollaborationPolicySnapshotBinding(syntheticSnapshot); const syntheticSnapshotBindingInspection = validateSupervisorSwarmCollaborationPolicySnapshotBinding( syntheticSnapshotBinding, syntheticSnapshot, ); const syntheticSnapshotBytes = JSON.stringify(syntheticSnapshot); const syntheticSnapshotBindingBytes = JSON.stringify( syntheticSnapshotBinding, ); const syntheticDriftedPolicy = driftedSupervisorSwarmCollaborationPolicy(); state.initialRunId = syntheticSnapshotExpected.parentRunId; const syntheticDriftObservationCount = supervisorSwarmCollaborationPolicyDriftObservationCount([ { recordType: 'agent.runtime.tool_observation', agentId: projectSupervisorAgentId, runId: syntheticSnapshotExpected.parentRunId, tool: 'agent.run_status', status: 'ok', summary: '项目协作策略已漂移，当前父 run 继续使用已绑定快照', }, ]); state.initialRunId = originalInitialRunId; let syntheticSnapshotTamperRejected = false; try { validateSupervisorSwarmCollaborationPolicySnapshot( { ...syntheticSnapshot, snapshotFingerprint: '0'.repeat(64) }, syntheticSnapshotExpected, ); } catch (error) { syntheticSnapshotTamperRejected = error?.code === 'supervisor-swarm-collaboration-policy-snapshot-invalid'; } let syntheticSnapshotBindingTamperRejected = false; try { validateSupervisorSwarmCollaborationPolicySnapshotBinding( { ...syntheticSnapshotBinding, boundAt: syntheticSnapshot.boundAt + 1 }, syntheticSnapshot, ); } catch (error) { syntheticSnapshotBindingTamperRejected = error?.code === 'supervisor-swarm-collaboration-policy-snapshot-binding-invalid'; } const syntheticMissingSnapshotSafe = inspectSupervisorSwarmCollaborationPolicySnapshot( null, syntheticSnapshotExpected, ).identityHashMatched === false; const syntheticMissingBindingSafe = inspectSupervisorSwarmCollaborationPolicySnapshotBinding( null, syntheticSnapshot, ).snapshotMatched === false; const syntheticSnapshotDuplicateCount = duplicateSupervisorSwarmCollaborationPolicySnapshotCount([ syntheticSnapshot, ]); const syntheticSnapshotBindingDuplicateCount = duplicateSupervisorSwarmCollaborationPolicySnapshotBindingCount([ syntheticSnapshotBinding, ]); const syntheticEnospcDiagnostic = safeProcessFailureDiagnostic({ code: 1, stderr: 'No space left on device (os error 28)', }); const syntheticChatSessionFailureEvidence = buildSupervisorSwarmEvidence({ chatSessionUnexpectedlyClosed: true, chatSessionFailureKind: syntheticEnospcDiagnostic.failureKind, chatSessionExitCode: syntheticEnospcDiagnostic.exitCode, chatSessionCloseSignal: syntheticEnospcDiagnostic.signal, chatSessionProcessErrorCode: syntheticEnospcDiagnostic.processErrorCode, chatSessionStderrChars: syntheticEnospcDiagnostic.stderrChars, chatSessionStderrSha256: syntheticEnospcDiagnostic.stderrSha256, }); state.suite = supervisorSwarmCollaborationPolicyMixedRecoverySuite; const recoveryPolicy = expectedSupervisorSwarmCollaborationPolicy(); const recoveryGroupCount = supervisorSwarmExpectedIsolatedReviewGroups().length; state.suite = supervisorSwarmAutonomousChatSuite; const syntheticSnapshotBindingBatchSuiteIndependent = supervisorSwarmInitialBatchBindsPolicySnapshot( syntheticSnapshotBindingBatch, syntheticSnapshotExpected.parentRunId, ); state.suite = originalSuite; assert( syntheticSnapshotInspection.identityHashMatched && syntheticSnapshotBindingInspection.snapshotMatched && syntheticSnapshotBytes === JSON.stringify(syntheticSnapshot) && syntheticSnapshotBindingBytes === JSON.stringify(syntheticSnapshotBinding) && multiGroupPolicy.minIsolatedGroupsBeforeClaim === 2 && syntheticDriftedPolicy.minIsolatedGroupsBeforeClaim === 1 && syntheticDriftObservationCount === 1 && syntheticSnapshotTamperRejected && syntheticSnapshotBindingTamperRejected && syntheticMissingSnapshotSafe && syntheticMissingBindingSafe && syntheticSnapshotDuplicateCount === 0 && syntheticSnapshotBindingDuplicateCount === 0 && syntheticSnapshotBindingBatchAccepted && syntheticSnapshotBindingBatchRejections && syntheticSnapshotBindingBatchSuiteIndependent && syntheticEnospcDiagnostic.failureKind === 'enospc' && syntheticEnospcDiagnostic.stderrChars > 0 && /^[0-9a-f]{64}$/u.test(syntheticEnospcDiagnostic.stderrSha256) && syntheticChatSessionFailureEvidence.chatSessionUnexpectedlyClosed === true && syntheticChatSessionFailureEvidence.chatSessionFailureKind === 'enospc', 'agent-runtime-real-e2e-self-test-collaboration-policy-snapshot-binding-invalid', ); assert( JSON.stringify( syntheticMixedEntries.map(({ groupIndex }) => groupIndex), ) === JSON.stringify([0, 1]) && JSON.stringify( syntheticSingleGroupEntries.map(({ groupIndex }) => groupIndex), ) === JSON.stringify([0]) && supervisorSwarmIsolatedReviewGroupIndex( supervisorSwarmIsolatedReviews.map((review) => ({ expectedArtifacts: [review.path], })), ) === -1 && JSON.stringify(syntheticReadyGroupIds) === JSON.stringify( syntheticMixedGroups.map((group) => group.delegationGroupId).sort(), ) && syntheticObservedJoinClaim.actionId === 'synthetic-claim-action' && syntheticWriteScopeRoots.length === supervisorSwarmIsolatedReviews.length && new Set(syntheticWriteScopeRoots).size === supervisorSwarmIsolatedReviews.length && syntheticOverlappingWriteScopesRejected && syntheticFollowupOrderValidated && multiGroupPolicy.minIsolatedChildren === 2 && Object.hasOwn(multiGroupPolicy, 'minIsolatedGroupsBeforeClaim') && multiGroupPolicy.minIsolatedGroupsBeforeClaim === 2 && multiGroupCount === 2 && recoveryPolicy.minIsolatedChildren === 3 && !Object.hasOwn(recoveryPolicy, 'minIsolatedGroupsBeforeClaim') && (recoveryPolicy.minIsolatedGroupsBeforeClaim ?? 0) === 0 && recoveryGroupCount === 1, 'agent-runtime-real-e2e-self-test-mixed-isolated-groups-invalid', ); const syntheticIdentity = { agentId: 'private-agent-id', taskId: 'private-task-id', sessionId: 'private-session-id', runId: 'private-run-id', source: 'private-source', }; const persistedAuditEnvelope = { schemaVersion: 'game-creator-agent-db.v1', updatedAt: 1_784_305_826, }; const retryableProtocolErrorKinds = toolPlanProtocolErrorKinds.filter( (kind) => kind !== 'catalog-binding', ); const repairRecords = retryableProtocolErrorKinds.map((kind, index) => ({ ...persistedAuditEnvelope, recordType: 'agent.runtime.tool_plan.repair', ...syntheticIdentity, loopIteration: index, repairAttempt: 0, requestSlot: `loop-${index}-repair-0`, responseFingerprint: hashValue(`private-response-${kind}`), providerRequestIdSha256: hashValue(`private-provider-request-${kind}`), attempt: 1, maxAttempts: 2, protocolErrorKind: kind, protocolErrorSha256: hashValue(`private-error-${kind}`), protocolErrorChars: 24, responsePreviewSha256: hashValue(`private-preview-${kind}`), responsePreviewChars: 26, protocol: 'native_runtime_tools', callIdSha256: hashValue(`private-call-${kind}`), functionNameSha256: hashValue(`runtime_tool_${kind}`), })); repairRecords.push({ ...repairRecords[0], repairAttempt: 1, requestSlot: 'loop-0-repair-1', responseFingerprint: hashValue('private-response-shape-second'), providerRequestIdSha256: hashValue('private-provider-request-shape-second'), attempt: 2, }); const fatalCatalogBindingRepair = { ...repairRecords[0], loopIteration: retryableProtocolErrorKinds.length, requestSlot: `loop-${retryableProtocolErrorKinds.length}-repair-0`, responseFingerprint: hashValue('private-response-catalog-binding'), providerRequestIdSha256: hashValue( 'private-provider-request-catalog-binding', ), protocolErrorKind: 'catalog-binding', }; const syntheticProtocolCallId = 'private-call-id'; const syntheticProtocolResponseId = 'private-response-id'; const normalizedProtocolRecord = { ...persistedAuditEnvelope, recordType: 'agent.runtime.tool_plan.protocol', ...syntheticIdentity, loopIteration: 8, repairAttempt: 0, requestSlot: 'loop-8-repair-0', responseFingerprint: hashValue('private-protocol-response'), providerRequestIdSha256: hashValue('private-protocol-provider-request'), protocol: 'native_runtime_tools', functionCallCount: 1, callIdSha256s: [hashValue(syntheticProtocolCallId)], functionNames: ['runtime_tool_file_read'], normalizationKinds: ['complete-think-block', 'planner-commentary'], normalizationCount: 3, normalizedTextChars: 80, normalizedTextSha256: hashValue('private-normalized-text'), responseIdSha256: hashValue(syntheticProtocolResponseId), responseIdChars: syntheticProtocolResponseId.length, }; const toolPlanAudits = [normalizedProtocolRecord, ...repairRecords]; const fullRepairEvidence = collectToolPlanRepairAuditEvidence(toolPlanAudits); const fatalRepairEvidence = collectToolPlanRepairAuditEvidence([ normalizedProtocolRecord, fatalCatalogBindingRepair, ]); const expectedRepairCounts = emptyToolPlanRepairCountsByProtocolErrorKind(); for (const kind of retryableProtocolErrorKinds) { expectedRepairCounts[kind] = kind === 'response-shape' ? 2 : 1; } assert( fullRepairEvidence.toolPlanRepairCount === 8 && fullRepairEvidence.toolPlanRepairedLoopCount === 7 && fullRepairEvidence.toolPlanSecondRepairCount === 1 && JSON.stringify( fullRepairEvidence.toolPlanRepairCountsByProtocolErrorKind, ) === JSON.stringify(expectedRepairCounts) && sumObjectValues( fullRepairEvidence.toolPlanRepairCountsByProtocolErrorKind, ) === fullRepairEvidence.toolPlanRepairCount && fullRepairEvidence.toolPlanAuditPayloadLeakCount === 0 && toolPlanRepairEvidenceHasNoFatalLocalRepair(fullRepairEvidence) && !toolPlanRepairEvidenceHasNoFatalLocalRepair(fatalRepairEvidence), 'agent-runtime-real-e2e-self-test-tool-plan-repair-aggregate-invalid', ); const rawPayloadFields = [ 'errorBody', 'detail', 'preview', 'arguments', 'body', 'text', 'protocolError', 'responsePreview', 'toolArguments', ]; const rejectedRawPayloadFieldCount = rawPayloadFields.filter( (field) => !hasSafeToolPlanAuditPayload({ ...repairRecords[0], [field]: `private-${field}`, }), ).length; const recordsMissingRequiredFields = [ ...[...toolPlanProtocolAuditSafeFields].map((field) => { const record = { ...normalizedProtocolRecord }; delete record[field]; return record; }), ...[...toolPlanRepairAuditSafeFields].map((field) => { const record = { ...repairRecords[0] }; delete record[field]; return record; }), ]; const rejectedMissingAuditFieldCount = recordsMissingRequiredFields.filter( (record) => !hasSafeToolPlanAuditPayload(record), ).length; const wrongSlotAuditRecords = [ { ...normalizedProtocolRecord, requestSlot: 'loop-8-repair-1' }, { ...repairRecords[0], requestSlot: 'loop-0-repair-1' }, ]; const rejectedWrongSlotCount = wrongSlotAuditRecords.filter( (record) => !hasSafeToolPlanAuditPayload(record), ).length; const rawIdentifierAuditFields = { callId: syntheticProtocolCallId, callIds: [syntheticProtocolCallId], functionName: 'runtime_tool_file_read', providerRequestId: 'private-provider-request-id', responseId: syntheticProtocolResponseId, }; const rejectedRawIdentifierFieldCount = Object.entries( rawIdentifierAuditFields, ).filter( ([field, value]) => !hasSafeToolPlanAuditPayload({ ...normalizedProtocolRecord, [field]: value, }), ).length; const invalidHashOrCatalogAuditRecords = [ { ...normalizedProtocolRecord, callIdSha256s: ['A'.repeat(64)], }, { ...normalizedProtocolRecord, responseIdSha256: null, }, { ...normalizedProtocolRecord, functionNames: ['private_uncatalogued_function'], }, { ...repairRecords[0], providerRequestIdSha256: '0'.repeat(63), }, { ...repairRecords[0], repairAttempt: 1, requestSlot: 'loop-0-repair-1', }, ]; const rejectedInvalidHashOrCatalogCount = invalidHashOrCatalogAuditRecords.filter( (record) => !hasSafeToolPlanAuditPayload(record), ).length; assert( rejectedRawPayloadFieldCount === rawPayloadFields.length && rejectedMissingAuditFieldCount === recordsMissingRequiredFields.length && rejectedWrongSlotCount === wrongSlotAuditRecords.length && rejectedRawIdentifierFieldCount === Object.keys(rawIdentifierAuditFields).length && rejectedInvalidHashOrCatalogCount === invalidHashOrCatalogAuditRecords.length && hasSafeToolPlanAuditPayload(normalizedProtocolRecord) && !hasSafeToolPlanAuditPayload({ ...normalizedProtocolRecord, normalizationKinds: ['private-kind'], }) && !hasSafeToolPlanAuditPayload({ ...repairRecords[0], protocolErrorKind: 'private-error', }), 'agent-runtime-real-e2e-self-test-tool-plan-payload-boundary-invalid', ); const repairReport = JSON.stringify(fullRepairEvidence); const repairReportPrivateValueLeakCount = countExactSecrets( Buffer.from(repairReport), [ ...Object.values(syntheticIdentity), ...repairRecords.flatMap((record) => [ record.responseFingerprint, record.providerRequestIdSha256, record.protocolErrorSha256, record.responsePreviewSha256, record.callIdSha256, record.functionNameSha256, ]), ], ); assert( repairReportPrivateValueLeakCount === 0 && !/(agentId|taskId|sessionId|runId|source|requestSlot|loopIteration|Sha256)/u.test( repairReport, ), 'agent-runtime-real-e2e-self-test-tool-plan-report-private-data-leak', ); return { status: 'PASS', suite: 'agent-runtime-real-e2e-self-test', providerUsed: false, exactSecretCounts, scopedPrivateOutputValidated, recoveredRepairConfirmationLifecycleValidated: true, modernRecoveredRepairConfirmationLifecycleValidated: true, legacyRecoveredRepairConfirmationLifecycleValidated: true, recoveredRepairConfirmationConflictRejected: true, recoveredRepairConfirmationModeAndOrderValidated: true, dynamicPrivateBodyCount: expectedPrivateValues.length, evidenceMetadataExcluded: true, genericBoundaryTermsExcluded: true, mixedIsolatedGroupTopologyValidated: true, mixedReadyJoinObservationValidated: true, mixedObservedJoinClaimValidated: true, mixedCrossGroupWriteScopesValidated: true, mixedFollowupBeforeClaimOrderValidated: true, legacySingleIsolatedGroupTopologyValidated: true, mixedSuitePolicyIsolationValidated: true, collaborationPolicySnapshotCaptured: true, collaborationPolicySnapshotStable: true, collaborationPolicySnapshotBindingCaptured: true, collaborationPolicySnapshotBindingStable: true, durableSnapshotEligibilityAndContractBindingValidated: true, sourceEndpointAbsentLifecycleGuardValidated, autonomousPlayableSuiteRegistered, autonomousPlayablePackageCommandsRegistered, autonomousPlayableDedicatedPathValidated: true, autonomousPlayableExactStdinValidated: true, autonomousPlayablePartialCollectorPrivacyValidated, toolPlanHandoffSuiteRegistered, toolPlanHandoffPackageCommandsRegistered, toolPlanHandoffSourceGuardRegistered, toolPlanHandoffCleanupRegistered, toolPlanHandoffPartialEvidenceRegistered: true, toolPlanHandoffPlanProjectionValidated, toolPlanHandoffEvidenceFieldsRegistered, toolPlanHandoffUnknownResultBoundaryPreserved: true, finalReplyFaultPrerequisiteValidated: true, collaborationPolicyDriftFixtureValidated: true, collaborationPolicyDriftStatusObserved: true, duplicateCollaborationPolicySnapshotCount: syntheticSnapshotDuplicateCount, duplicateCollaborationPolicySnapshotBindingCount: syntheticSnapshotBindingDuplicateCount, collaborationPolicySnapshotTamperRejected: syntheticSnapshotTamperRejected, collaborationPolicySnapshotBindingTamperRejected: syntheticSnapshotBindingTamperRejected, collaborationPolicyPartialMissingEvidenceSafe: syntheticMissingSnapshotSafe && syntheticMissingBindingSafe, enospcFailureDiagnosticClassified: true, chatSessionFailureEvidenceSchemaValidated: true, toolPlanRepairCount: fullRepairEvidence.toolPlanRepairCount, toolPlanRepairedLoopCount: fullRepairEvidence.toolPlanRepairedLoopCount, toolPlanSecondRepairCount: fullRepairEvidence.toolPlanSecondRepairCount, toolPlanRepairCountsByProtocolErrorKind: fullRepairEvidence.toolPlanRepairCountsByProtocolErrorKind, toolPlanRepairClassificationTotalMatched: true, toolPlanFatalLocalRepairRejected: true, toolPlanPersistedAuditEnvelopeAccepted: true, toolPlanRawPayloadFieldRejectionCount: rejectedRawPayloadFieldCount, toolPlanMissingAuditFieldRejectionCount: rejectedMissingAuditFieldCount, toolPlanWrongSlotRejectionCount: rejectedWrongSlotCount, toolPlanRawIdentifierFieldRejectionCount: rejectedRawIdentifierFieldCount, toolPlanInvalidHashOrCatalogRejectionCount: rejectedInvalidHashOrCatalogCount, toolPlanRepairReportPrivateValueLeakCount: repairReportPrivateValueLeakCount, }; }