| import { describe, expect, it } from "vitest"; |
| import { observeOmegaExecutiveState } from "./executive-arbitration.js"; |
| import type { OmegaMemoryOrchestratorSummary } from "./memory-orchestrator.js"; |
| import type { OmegaSessionAuthority } from "./session-context.js"; |
| import type { OmegaWorldModelSnapshot } from "./world-model.js"; |
|
|
| function makeSnapshot(overrides: Partial<OmegaWorldModelSnapshot> = {}): OmegaWorldModelSnapshot { |
| return { |
| sessionKey: "agent:test:main", |
| sessionAuthority: { |
| timeline: [], |
| transactions: [], |
| } satisfies OmegaSessionAuthority, |
| timelineLength: 0, |
| relevantMemories: [], |
| operationalSignals: [], |
| problemAgenda: [], |
| degradedComponents: [], |
| ...overrides, |
| }; |
| } |
|
|
| function makeMemory( |
| overrides: Partial<OmegaMemoryOrchestratorSummary> = {}, |
| ): OmegaMemoryOrchestratorSummary { |
| return { |
| health: "stable", |
| promotionCandidates: 0, |
| revalidationCandidates: 0, |
| repeatedFailurePatterns: [], |
| recentUsefulSuccesses: 0, |
| ...overrides, |
| }; |
| } |
|
|
| describe("observeOmegaExecutiveState", () => { |
| it("prioritizes recovery when failure streak is high", () => { |
| const result = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 2, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 2 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/app.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 2, |
| createdTurn: 1, |
| updatedTurn: 2, |
| failureCount: 2, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 2, |
| repeatedFailureKinds: ["target_not_touched"], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 2, |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| expect(result.mode).toBe("recovering"); |
| expect(result.decision.selectedAction).toBe("recover"); |
| expect(result.decision.selectedGoalId).toBe("goal-1"); |
| expect(result.decision.selectedWorkItemId).toBe("anomaly:repeated_failure"); |
| expect(result.decision.selectedQueueKind).toBe("anomaly"); |
| }); |
|
|
| it("promotes a proactive failure probe when repeated failures hit a causal limit", () => { |
| const result = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 2, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 2 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/app.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 2, |
| createdTurn: 1, |
| updatedTurn: 2, |
| failureCount: 2, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 2, |
| repeatedFailureKinds: ["target_not_touched"], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 2, |
| }, |
| problemAgenda: [ |
| { |
| id: "agenda-failure", |
| classKey: "failure:target_not_touched", |
| label: "Explore a reusable strategy for target_not_touched", |
| source: "failure_pattern", |
| status: "open", |
| priority: 0.8, |
| evidenceCount: 2, |
| activationCount: 0, |
| successCount: 0, |
| failureCount: 0, |
| realizedUtility: 0, |
| firstSeenAt: 1, |
| lastSeenAt: 2, |
| }, |
| ], |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| expect(result.mode).toBe("active"); |
| expect(result.decision.selectedAction).toBe("maintain"); |
| expect(result.decision.selectedGoalId).toBe("agenda:failure:target_not_touched"); |
| expect(result.decision.selectedWorkItemId).toBe( |
| "maintenance:agenda:failure:target_not_touched", |
| ); |
| expect(result.decision.selectedQueueKind).toBe("maintenance"); |
| expect(result.decision.rationale.join(" ")).toContain("probe experiment"); |
| }); |
|
|
| it("switches into self-repair maintenance when recent turns are stalled", () => { |
| const result = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 4, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 4 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/app.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 4, |
| createdTurn: 1, |
| updatedTurn: 4, |
| failureCount: 0, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 4, |
| }, |
| operationalSignals: [ |
| { |
| id: "turn-1", |
| recordedAt: 1, |
| iteration: 1, |
| terminationReason: "continue", |
| turnHealth: "stalled", |
| progressObserved: false, |
| timelineDelta: 0, |
| kernelUpdated: false, |
| latencyBreakdown: { |
| sendAgentTurnMs: 10, |
| loadSnapshotMs: 10, |
| readLatestReplyMs: 0, |
| totalMs: 20, |
| }, |
| }, |
| { |
| id: "turn-2", |
| recordedAt: 2, |
| iteration: 2, |
| terminationReason: "continue", |
| turnHealth: "stalled", |
| progressObserved: false, |
| timelineDelta: 0, |
| kernelUpdated: false, |
| latencyBreakdown: { |
| sendAgentTurnMs: 10, |
| loadSnapshotMs: 10, |
| readLatestReplyMs: 0, |
| totalMs: 20, |
| }, |
| }, |
| ], |
| }), |
| memory: makeMemory({ health: "stalled" }), |
| }); |
|
|
| expect(result.mode).toBe("active"); |
| expect(result.decision.selectedAction).toBe("maintain"); |
| expect(result.decision.selectedGoalId).toBe("self_repair:stalled_progress"); |
| expect(result.decision.selectedWorkItemId).toBe("maintenance:self_repair:stalled_progress"); |
| expect(result.decision.selectedQueueKind).toBe("maintenance"); |
| expect(result.maintenanceQueue[0]?.kind).toBe("self_repair"); |
| expect(result.decision.rationale.join(" ")).toContain("stalled"); |
| }); |
|
|
| it("penalizes direct execution value after a learned reframe-before-retry constraint", () => { |
| const baseline = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 3, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 3 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/a.ts", "src/b.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 3, |
| createdTurn: 1, |
| updatedTurn: 3, |
| failureCount: 1, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 3, |
| }, |
| selfState: { |
| activeGoal: "repair app", |
| activeTargets: ["src/a.ts", "src/b.ts"], |
| requiredKeys: [], |
| learnedConstraints: [], |
| updatedAt: 3, |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| const reframed = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 3, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 3 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/a.ts", "src/b.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 3, |
| createdTurn: 1, |
| updatedTurn: 3, |
| failureCount: 1, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 3, |
| }, |
| selfState: { |
| activeGoal: "repair app", |
| activeTargets: ["src/b.ts"], |
| requiredKeys: [], |
| learnedConstraints: ["reframe_before_retry", "narrow_to_unresolved_targets"], |
| updatedAt: 3, |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| expect(reframed.queue[0]?.expectedUtility).toBeLessThan( |
| baseline.queue[0]?.expectedUtility ?? 1, |
| ); |
| expect(reframed.queue[0]?.failureRisk).toBeGreaterThan(baseline.queue[0]?.failureRisk ?? 0); |
| expect(reframed.queue[0]?.estimatedCost).toBeLessThan(baseline.queue[0]?.estimatedCost ?? 1); |
| }); |
|
|
| it("devalues direct execution when empirical recovery preference favors isolation", () => { |
| const baseline = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 3, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 3 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/a.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 3, |
| createdTurn: 1, |
| updatedTurn: 3, |
| failureCount: 1, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 3, |
| }, |
| selfState: { |
| activeGoal: "repair app", |
| activeTargets: ["src/a.ts"], |
| requiredKeys: [], |
| learnedConstraints: [], |
| updatedAt: 3, |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| const isolationBiased = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 3, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 3 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/a.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 3, |
| createdTurn: 1, |
| updatedTurn: 3, |
| failureCount: 1, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 3, |
| }, |
| selfState: { |
| activeGoal: "repair app", |
| activeTargets: ["src/a.ts"], |
| requiredKeys: [], |
| learnedConstraints: [], |
| updatedAt: 3, |
| }, |
| activeRecoveryPreference: { |
| preferredRoute: "sessions_spawn", |
| confidence: 0.8, |
| delegateSuccesses: 1, |
| isolatedSuccesses: 4, |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| expect(isolationBiased.queue[0]?.expectedUtility).toBeLessThan( |
| baseline.queue[0]?.expectedUtility ?? 1, |
| ); |
| expect(isolationBiased.queue[0]?.failureRisk).toBeGreaterThan( |
| baseline.queue[0]?.failureRisk ?? 0, |
| ); |
| }); |
|
|
| it("falls back to generalized recovery preference when active preference is absent", () => { |
| const baseline = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 3, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 3 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/a.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 3, |
| createdTurn: 1, |
| updatedTurn: 3, |
| failureCount: 1, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 3, |
| }, |
| selfState: { |
| activeGoal: "repair app", |
| activeTargets: ["src/a.ts"], |
| requiredKeys: [], |
| learnedConstraints: [], |
| updatedAt: 3, |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| const generalized = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 3, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 3 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [ |
| { |
| id: "goal-1", |
| task: "repair app", |
| targets: ["src/a.ts"], |
| requiredKeys: [], |
| status: "active", |
| createdAt: 1, |
| updatedAt: 3, |
| createdTurn: 1, |
| updatedTurn: 3, |
| failureCount: 1, |
| successCount: 0, |
| observedChangedFiles: [], |
| }, |
| ], |
| tension: { |
| openGoalCount: 1, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: true, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 3, |
| }, |
| selfState: { |
| activeGoal: "repair app", |
| activeTargets: ["src/a.ts"], |
| requiredKeys: [], |
| learnedConstraints: [], |
| updatedAt: 3, |
| }, |
| generalizedRecoveryPreference: { |
| preferredRoute: "sessions_spawn", |
| confidence: 0.75, |
| delegateSuccesses: 1, |
| isolatedSuccesses: 3, |
| mechanismKey: "target_not_touched|single_target", |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| expect(generalized.queue[0]?.expectedUtility).toBeLessThan( |
| baseline.queue[0]?.expectedUtility ?? 1, |
| ); |
| expect(generalized.queue[0]?.failureRisk).toBeGreaterThan(baseline.queue[0]?.failureRisk ?? 0); |
| }); |
|
|
| it("prefers the higher-yield agenda line when reopening proactive work", () => { |
| const result = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| problemAgenda: [ |
| { |
| id: "agenda-low", |
| classKey: "initiative:stalled_progress", |
| label: "Investigate stalled progress patterns and open a better line of attack", |
| source: "stalled_progress", |
| status: "open", |
| priority: 0.6, |
| evidenceCount: 2, |
| activationCount: 2, |
| successCount: 0, |
| failureCount: 2, |
| realizedUtility: -0.45, |
| firstSeenAt: 1, |
| lastSeenAt: 3, |
| }, |
| { |
| id: "agenda-high", |
| classKey: "initiative:autonomy_improvement", |
| label: "Open a small autonomy-improvement experiment with measurable value", |
| source: "initiative", |
| status: "open", |
| priority: 0.38, |
| evidenceCount: 1, |
| activationCount: 1, |
| successCount: 2, |
| failureCount: 0, |
| realizedUtility: 0.42, |
| firstSeenAt: 1, |
| lastSeenAt: 4, |
| }, |
| ], |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 3, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 3 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [], |
| tension: { |
| openGoalCount: 0, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: false, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 3, |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| expect(result.decision.selectedAction).toBe("maintain"); |
| expect(result.decision.selectedGoalId).toBe("agenda:initiative:autonomy_improvement"); |
| }); |
|
|
| it("reopens a proactive agenda line when no active goals are pending", () => { |
| const result = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot({ |
| problemAgenda: [ |
| { |
| id: "agenda-1", |
| classKey: "initiative:autonomy_improvement", |
| label: "Open a small autonomy-improvement experiment with measurable value", |
| source: "initiative", |
| status: "open", |
| priority: 0.42, |
| evidenceCount: 1, |
| activationCount: 0, |
| successCount: 0, |
| failureCount: 0, |
| realizedUtility: 0, |
| firstSeenAt: 1, |
| lastSeenAt: 1, |
| }, |
| ], |
| kernel: { |
| revision: 2, |
| sessionKey: "agent:test:main", |
| turnCount: 3, |
| identity: { continuityId: "c1", firstSeenAt: 1, lastSeenAt: 3 }, |
| world: { lastObservedChangedFiles: [] }, |
| goals: [], |
| tension: { |
| openGoalCount: 0, |
| staleGoalCount: 0, |
| failureStreak: 0, |
| repeatedFailureKinds: [], |
| pendingCorrection: false, |
| }, |
| causalGraph: { files: [], edges: [] }, |
| updatedAt: 3, |
| }, |
| }), |
| memory: makeMemory(), |
| }); |
|
|
| expect(result.mode).toBe("active"); |
| expect(result.decision.selectedAction).toBe("maintain"); |
| expect(result.decision.selectedGoalId).toBe("agenda:initiative:autonomy_improvement"); |
| expect(result.decision.rationale.join(" ")).toContain("proactive"); |
| }); |
|
|
| it("stays idle when no goals or anomalies justify work", () => { |
| const result = observeOmegaExecutiveState({ |
| snapshot: makeSnapshot(), |
| memory: makeMemory(), |
| }); |
|
|
| expect(result.mode).toBe("idle"); |
| expect(result.decision.selectedAction).toBe("idle"); |
| }); |
| }); |
|
|
