native macOS codings agent orchestrator prowl.onev.cat
Something went wrong. Try again.
Swift
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218import Foundationimport Testing
@testable import Prowl
/// OSC 7501 evidence inside the pure state machine (docs-ai 079 slice 2): the root/// record is the first-priority state evidence, a withdrawal falls back to the legacy/// paths with their own reasons, and taking authority retires the facts the machine/// will not refresh while the schedule is delegated.struct AgentStateMachineProgramStatusTests { private typealias Kind = GhosttyProgramStatusReport.Kind
private func screen(_ state: AgentRawState, reason: AgentScreenDetectionReason = .noRuleMatched) -> AgentDetectionEvent { .screen(AgentScreenDetection(state: state, reason: reason)) }
private func native(_ state: AgentRawState, revision: Double) -> AgentDetectionEvent { .native(AgentNativeSnapshot(sessionID: "s", state: state, statusUpdatedAt: revision)) }
private func evidence( root: ProgramStatusRecord.State, rootKind: Kind? = nil, blockedChild: ProgramStatusEvidence.BlockedChild? = nil ) -> ProgramStatusEvidence { ProgramStatusEvidence(root: root, rootKind: rootKind, blockedChild: blockedChild) }
private func osc( _ root: ProgramStatusRecord.State, kind: Kind? = nil, blockedChild: ProgramStatusEvidence.BlockedChild? = nil, revision: UInt64 ) -> AgentDetectionEvent { .programStatus(evidence(root: root, rootKind: kind, blockedChild: blockedChild), revision: revision) }
private struct RootMapping { let root: ProgramStatusRecord.State let kind: Kind? let state: AgentRawState let identifier: String let outstanding: Bool }
@Test func rootRecordMapsToStateReasonAndOutstandingWork() { let cases = [ RootMapping(root: .working, kind: nil, state: .working, identifier: "osc.working", outstanding: true), RootMapping( root: .blocked, kind: .permission, state: .blocked, identifier: "osc.blocked.permission", outstanding: true), RootMapping( root: .blocked, kind: .question, state: .blocked, identifier: "osc.blocked.question", outstanding: true), RootMapping(root: .blocked, kind: .auth, state: .blocked, identifier: "osc.blocked.auth", outstanding: true), RootMapping(root: .blocked, kind: nil, state: .blocked, identifier: "osc.blocked.unspecified", outstanding: true), RootMapping(root: .idle, kind: nil, state: .idle, identifier: "osc.idle", outstanding: false), RootMapping(root: .done, kind: nil, state: .idle, identifier: "osc.done", outstanding: false), RootMapping(root: .error, kind: nil, state: .idle, identifier: "osc.error", outstanding: false), ] for mapping in cases { var machine = AgentStateMachine() _ = machine.receive(screen(.working), now: 0) let decision = machine.receive(osc(mapping.root, kind: mapping.kind, revision: 1), now: 1) #expect(decision.state == mapping.state, "\(mapping.identifier)") #expect(decision.reason.identifier == mapping.identifier) #expect(decision.hasOutstandingWork == mapping.outstanding, "\(mapping.identifier)") #expect(decision.logSessionID == nil) #expect(machine.hasProgramStatusAuthority) } }
@Test func blockedChildVetoesIdleAndSetsOutstandingWork() { for kind in [Kind.permission, .question, .auth] { var machine = AgentStateMachine() let decision = machine.receive( osc(.done, blockedChild: ProgramStatusEvidence.BlockedChild(kind: kind), revision: 1), now: 0) #expect(decision.state == .blocked) #expect(decision.reason.identifier == "osc.childBlocked.\(kind.rawValue)") #expect(decision.hasOutstandingWork) } var machine = AgentStateMachine() let unspecified = machine.receive( osc(.working, blockedChild: ProgramStatusEvidence.BlockedChild(kind: nil), revision: 1), now: 0) #expect(unspecified.state == .blocked) #expect(unspecified.reason.identifier == "osc.childBlocked.unspecified") }
@Test func blockedRootOutranksABlockedChild() { var machine = AgentStateMachine() let decision = machine.receive( osc(.blocked, kind: .permission, blockedChild: ProgramStatusEvidence.BlockedChild(kind: .question), revision: 1), now: 0) #expect(decision.reason.identifier == "osc.blocked.permission") }
@Test func childWorkingIsNotEvidence() { // The evidence carries no child `working` at all: the fence leaves it in the store and // the pane follows the root. A root `done` with busy children is Idle without work. var machine = AgentStateMachine() let decision = machine.receive(osc(.done, revision: 1), now: 0) #expect(decision.state == .idle) #expect(!decision.hasOutstandingWork) }
@Test func programStatusOutranksNativeLogAndScreen() { var machine = AgentStateMachine() _ = machine.receive(screen(.blocked), now: 0) _ = machine.receive(native(.working, revision: 1), now: 0) _ = machine.receive(.inventory(["a"]), now: 0) _ = machine.receive(.turnStarted(session: "a", turn: "1"), now: 0) let decision = machine.receive(osc(.idle, revision: 1), now: 1) #expect(decision.state == .idle) #expect(decision.reason.identifier == "osc.idle") // A later screen frame changes nothing while the root record is live. #expect(machine.receive(screen(.blocked), now: 2).state == .idle) }
@Test func withdrawalFallsBackToScreenWithTheLegacyReason() { var machine = AgentStateMachine() _ = machine.receive(screen(.working, reason: .legacyDetector), now: 0) #expect(machine.receive(osc(.idle, revision: 1), now: 1).reason.identifier == "osc.idle")
let decision = machine.receive(.programStatus(nil, revision: 2), now: 2)
#expect(decision.state == .working) #expect(decision.reason.identifier == "legacy.detector") #expect(!machine.hasProgramStatusAuthority) }
@Test func olderOrEqualRevisionIsIgnored() { var machine = AgentStateMachine() #expect(machine.receive(osc(.working, revision: 5), now: 0).state == .working) // A poll snapshot captured before a newer push cannot roll it back. #expect(machine.receive(osc(.idle, revision: 4), now: 1).state == .working) #expect(machine.receive(.programStatus(nil, revision: 5), now: 2).state == .working) #expect(machine.hasProgramStatusAuthority) #expect(machine.receive(osc(.idle, revision: 6), now: 3).state == .idle) }
@Test func authorityRetiresTheNativeSnapshotAndCompletedFrameFence() { // Native idle fenced the unchanged working frame. With `.suspended` that fence survives // (068); the dedicated OSC transition must retire it so a withdrawal cannot publish a // pre-OSC Idle through `screen.retainedCompletion`. var machine = AgentStateMachine() _ = machine.receive(screen(.working), now: 0) _ = machine.receive(native(.working, revision: 1), now: 0) #expect(machine.receive(native(.idle, revision: 2), now: 1).state == .idle) #expect(machine.receive(screen(.working), now: 2).reason.identifier == "native.idle")
#expect(machine.receive(osc(.working, revision: 1), now: 3).reason.identifier == "osc.working") let decision = machine.receive(.programStatus(nil, revision: 2), now: 4)
#expect(decision.state == .working) #expect(decision.reason.identifier == "screen.logUnavailable") }
@Test func withdrawalThenSuspendedFirstSampleDoesNotRevivePreOSCIdle() { var machine = AgentStateMachine() _ = machine.receive(screen(.working), now: 0) _ = machine.receive(native(.working, revision: 1), now: 0) _ = machine.receive(native(.idle, revision: 2), now: 1) _ = machine.receive(osc(.working, revision: 1), now: 2) #expect(machine.receive(osc(.done, revision: 2), now: 3).reason.identifier == "osc.done") _ = machine.receive(.programStatus(nil, revision: 3), now: 4)
let decision = machine.receive(.suspended, now: 5)
#expect(decision.state == .working) #expect(decision.reason.identifier == "screen.logUnavailable") // A fresh native snapshot resumes authority as before. #expect(machine.receive(native(.idle, revision: 3), now: 6).reason.identifier == "native.idle") }
@Test func authorityLeavesHasLogProviderUntouched() { // Pi has no provider: after OSC authority ends, its fallback reason is still the // screen rule, never `screen.logUnavailable`, which only `.suspended` would set. var machine = AgentStateMachine() _ = machine.receive(screen(.idle, reason: .legacyDetector), now: 0) _ = machine.receive(osc(.working, revision: 1), now: 1) _ = machine.receive(.programStatus(nil, revision: 2), now: 2) #expect(machine.receive(screen(.working, reason: .legacyDetector), now: 3).reason.identifier == "legacy.detector") }
@Test func authorityRetiresLogRecencyButKeepsOpenWorkAccounting() { var machine = AgentStateMachine() _ = machine.receive(screen(.idle), now: 0) _ = machine.receive(.inventory(["a"]), now: 0) _ = machine.receive(.turnStarted(session: "a", turn: "1"), now: 0) _ = machine.receive(.turnEnded(session: "a", turn: "1"), now: 1) #expect(machine.decision.reason.identifier == "log.turnEnded")
_ = machine.receive(osc(.working, revision: 1), now: 2) let decision = machine.receive(.programStatus(nil, revision: 2), now: 3)
// The completed root's recency was retired: no eligible root, log fallback. #expect(decision.reason.identifier == "screen.noLiveTurn") #expect(decision.state == .idle) }
@Test func screenReasonUnderAuthorityIsTheDelegatedMarker() { var machine = AgentStateMachine() _ = machine.receive(screen(.working, reason: .matched(AgentScreenRuleID("pi.working"))), now: 0) let decision = machine.receive(osc(.idle, revision: 1), now: 1) #expect(decision.screenReason == .delegated) #expect(decision.screenReason?.identifier == "screen.delegated") let withdrawn = machine.receive(.programStatus(nil, revision: 2), now: 2) #expect(withdrawn.screenReason?.identifier == "pi.working") }
@Test func evidenceDecisionIsThePureMappingSharedWithShadowComparison() { let decision = evidence(root: .blocked, rootKind: .auth).decision #expect(decision.state == .blocked) #expect(decision.reason == .programStatus(.blocked(.auth))) #expect(decision.hasOutstandingWork) }}