Skip to content

CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息

52.1 KB
Raw Blame
import Foundation
import Testing

struct ActivityLivePresentationTests {
    private let now = TestFixtures.now

    private func message(_ method: String, _ fields: String = "", id: Int? = nil, turn: Bool = true) throws -> ActivityInput {
        let identity = id.map { "\"id\":\($0)," } ?? ""
        let turnField = turn ? #", "turnId":"turn-a""# : ""
        return try TestFixtures.decode(ActivityInput.self, """
        {\(identity)"method":"\(method)","params":{"threadId":"thread-a"\(turnField)\(fields.isEmpty ? "" : "," + fields)}}
        """)
    }

    private func prepared() throws -> AppServerActivityReducer {
        var reducer = AppServerActivityReducer()
        let thread = ActivityThread(id: "thread-a", status: ActivityThreadStatus(type: .active, activeFlags: []))
        _ = reducer.reconcile(thread: thread, turns: [ActivityTurn(id: "turn-a", status: .running)], now: now)
        _ = try reducer.consume(message("turn/started", #""turn":{"id":"turn-a","status":"inProgress"}"#), now: now)
        return reducer
    }

    private func summary(_ reducer: AppServerActivityReducer) throws -> ActivityLiveSummary {
        try #require(reducer.states.values.first?.presentation?.summary)
    }

    @Test func asyncQuestionMessageWaitsAfterItemCompletionAndActiveRefresh() throws {
        var reducer = try prepared()
        let item = """
        "item":{"id":"question-call","type":"agentMessage","phase":"final_answer","delivery":"async",
        "questions":[{"title":"Test question?","options":["Test option A","Test option B"]}]}
        """
        for method in ["item/started", "item/completed"] {
            #expect(try reducer.consume(message(method, item), now: now).isEmpty)
            #expect(try summary(reducer).current.key == "waiting-input")
        }
        _ = try reducer.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":[]}"#, turn: false), now: now.addingTimeInterval(1))
        _ = try reducer.consume(message("item/agentMessage/delta", #""itemId":"answer","delta":"Test response""#), now: now.addingTimeInterval(2))
        #expect(try summary(reducer).waiting?.since == now)
        #expect(try summary(reducer).current.key == "waiting-input")
        #expect(reducer.states.values.first?.isWaitingApproval == false)
    }

    private func userMessage(_ text: String, threadID: String = "thread-a", turnID: String = "turn-a") throws -> ActivityInput {
        try JSONDecoder().decode(ActivityInput.self, from: JSONSerialization.data(withJSONObject: [
            "method": "item/completed", "params": [
                "threadId": threadID, "turnId": turnID,
                "item": ["id": "reply", "type": "userMessage", "content": [["type": "text", "text": text]]]
            ]
        ]))
    }

    private func questionReply(_ itemID: String, index: Int) throws -> ActivityInput {
        let identity = try JSONSerialization.data(withJSONObject: ["request_user_input_async", itemID, index])
        let body = try JSONSerialization.data(withJSONObject: [["questionItemId": #require(String(data: identity, encoding: .utf8))]])
        return try userMessage("<send_user_message_question_reply>\n" + #require(String(data: body, encoding: .utf8)) + "\n</send_user_message_question_reply>")
    }

    @Test func asyncQuestionsResolveIndividuallyWithoutClearingOtherWaits() throws {
        var reducer = try prepared()
        for id in ["first", "second"] {
            _ = try reducer.consume(message("item/completed", """
            "item":{"id":"\(id)","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"},{"title":"Test question?"}]}
            """), now: now)
        }
        let progress = reducer.states.values.first?.lastProgressAt
        let unknown = try questionReply("unknown", index: 0)
        #expect(reducer.consume(unknown, now: now.addingTimeInterval(1)).isEmpty)
        for id in ["first", "second"] {
            let reply = try questionReply(id, index: 0)
            #expect(reply.params.item?.questionReplies == [.init(itemID: id, index: 0)])
            #expect(reducer.consume(reply, now: now.addingTimeInterval(2)).isEmpty)
            _ = reducer.consume(reply, now: now.addingTimeInterval(3))
            #expect(try summary(reducer).waiting?.since == now)
        }
        _ = try reducer.consume(questionReply("first", index: 1), now: now.addingTimeInterval(4))
        #expect(try summary(reducer).waiting != nil)
        _ = try reducer.consume(message("mcpServer/elicitation/request", #""mode":"form""#, id: 7), now: now.addingTimeInterval(5))
        _ = try reducer.consume(questionReply("second", index: 1), now: now.addingTimeInterval(6))
        #expect(try summary(reducer).current.key == "waiting-form")
        _ = try reducer.consume(message("serverRequest/resolved", #""requestId":7"#, turn: false), now: now.addingTimeInterval(7))
        #expect(try summary(reducer).waiting == nil)
        #expect(reducer.states.values.first?.lastProgressAt == progress)
        #expect(reducer.states.values.first?.isWaitingApproval == false)
    }

    @Test(arguments: [
        #""delivery":"async","questions":[]"#,
        #""delivery":"async","questions":null"#,
        #""questions":[{"title":"Test question?"}]"#
    ])
    func ordinaryAgentMessagesDoNotCreateQuestionWaits(fields: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/completed", "\"item\":{\"id\":\"plain\",\"type\":\"agentMessage\",\(fields)}"), now: now)
        #expect(try summary(reducer).waiting == nil)
    }

    @Test(arguments: [
        "Test user message", "测试用户消息",
        #"Quoted: <send_user_message_question_reply>[{"questionItemId":"[\"request_user_input_async\",\"question\",0]"}]</send_user_message_question_reply>"#,
        "<send_user_message_question_reply>",
        "  <send_user_message_question_reply> 测试用户消息\n",
        "<send_user_message_question_reply>invalid</send_user_message_question_reply>",
        "<send_user_message_question_reply>[{}]</send_user_message_question_reply>",
        "<send_user_message_question_reply>[]</send_user_message_question_reply> 测试用户消息",
        #"<send_user_message_question_reply>[{"questionItemId":"[\"other_tool\",\"first\",0]"}]</send_user_message_question_reply>"#,
        #"<send_user_message_question_reply>[{"questionItemId":"[\"request_user_input_async\",\"\",0]"}]</send_user_message_question_reply>"#,
        #"<send_user_message_question_reply>[{"questionItemId":"[\"request_user_input_async\",\"first\",-1]"}]</send_user_message_question_reply>"#,
        #"<send_user_message_question_reply>[{"questionItemId":"[\"request_user_input_async\",\"first\",0.5]"}]</send_user_message_question_reply>"#,
        #"""
        <send_user_message_question_reply>[
            {"questionItemId":"[\"request_user_input_async\",\"first\",0]"},
            {"questionItemId":"invalid"}
        ]</send_user_message_question_reply>
        """#
    ])
    func ordinaryUserMessagesClearAsyncQuestionsAndAllowNewWaits(text: String) throws {
        var reducer = try prepared()
        for id in ["first", "second"] {
            _ = try reducer.consume(message("item/completed", """
            "item":{"id":"\(id)","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}
            """), now: now)
        }
        _ = try reducer.consume(message("item/tool/requestUserInput", #""isBlocking":false"#, id: 9), now: now)
        _ = try reducer.consume(message("item/started", #""item":{"id":"cmd","type":"commandExecution"}"#), now: now.addingTimeInterval(1))
        #expect(try summary(reducer).current.key == "waiting-input")
        let progress = reducer.states.values.first?.lastProgressAt
        let reply = try userMessage(text)
        #expect(reply.params.item?.questionReplies == nil)
        #expect(reply.params.item?.affectsInputWait == true)
        #expect(reducer.consume(reply, now: now.addingTimeInterval(2)).isEmpty)
        #expect(try summary(reducer).waiting == nil)
        #expect(try summary(reducer).current.key == "command")
        #expect(reducer.states.values.first?.lastProgressAt == progress)
        #expect(reducer.states.values.first?.isWaitingApproval == false)

        _ = try reducer.consume(message("item/completed", """
        "item":{"id":"third","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}
        """), now: now.addingTimeInterval(3))
        #expect(try summary(reducer).waiting?.since == now.addingTimeInterval(3))
        _ = try reducer.consume(questionReply("third", index: 0), now: now.addingTimeInterval(4))
        #expect(try summary(reducer).waiting == nil)
    }

    @Test(arguments: ["item/tool/requestUserInput", "item/commandExecution/requestApproval"], [
        "Test user message", "<send_user_message_question_reply> 测试用户消息"
    ])
    func ordinaryUserMessagesPreserveBlockingInputAndApproval(method: String, text: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/completed", #""item":{"id":"question","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}"#), now: now)
        _ = try reducer.consume(message(method, #""itemId":"request","startedAtMs":1789459201000,"isBlocking":true"#, id: 7), now: now.addingTimeInterval(1))
        let approval = reducer.states.values.first?.isWaitingApproval
        _ = try reducer.consume(userMessage(text), now: now.addingTimeInterval(2))
        #expect(try summary(reducer).waiting?.since == now.addingTimeInterval(1))
        #expect(try summary(reducer).current.key == (method == "item/tool/requestUserInput" ? "waiting-input" : "waiting-approval"))
        #expect(try summary(reducer).hasBlockingInputRequest == (method == "item/tool/requestUserInput"))
        #expect(reducer.states.values.first?.isWaitingApproval == approval)
        let symbolName = try summary(reducer).current.symbolName
        _ = try reducer.consume(message("serverRequest/resolved", #""requestId":7"#, turn: false), now: now.addingTimeInterval(3))
        #expect(try summary(reducer).waiting == nil)
        #expect(try summary(reducer).recent?.label.symbolName == symbolName)
    }

    @Test(arguments: ["thread-a", "thread-b"])
    func ordinaryUserMessagesOnlyClearTheirOwnTurn(threadID: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/completed", #""item":{"id":"question","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}"#), now: now)
        let otherThread = ActivityThread(id: threadID, status: ActivityThreadStatus(type: .active, activeFlags: []))
        _ = reducer.reconcile(thread: otherThread, turns: [ActivityTurn(id: "turn-b", status: .running)], now: now)
        _ = try reducer.consume(userMessage("Test user message", threadID: threadID, turnID: "turn-b"), now: now.addingTimeInterval(1))
        let key = ActivityTurnReference(threadID: "thread-a", turnID: "turn-a")
        #expect(reducer.states[key]?.presentation?.summary.waiting?.since == now)
        _ = try reducer.consume(userMessage("Test user message"), now: now.addingTimeInterval(2))
        #expect(reducer.states[key]?.presentation?.summary.waiting == nil)
    }

    @Test(arguments: [
        "[]",
        #"[{"questionItemId":"[\"request_user_input_async\",\"unknown\",0]"}]"#,
        #"[{"questionItemId":"[\"request_user_input_async\",\"question\",1]"}]"#
    ])
    func unmatchedQuestionRepliesDoNotClearAsyncQuestions(body: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/completed", #""item":{"id":"question","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}"#), now: now)
        let reply = try userMessage("<send_user_message_question_reply>\(body)</send_user_message_question_reply>")
        #expect(reply.params.item?.questionReplies != nil)
        _ = reducer.consume(reply, now: now.addingTimeInterval(1))
        #expect(try summary(reducer).waiting?.since == now)
    }

    @Test func mixedContentQuestionRepliesOnlyResolveMatchingQuestions() throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/completed", """
        "item":{"id":"question","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"},{"title":"Test question?"}]}
        """), now: now)
        _ = try reducer.consume(message("item/completed", """
        "item":{"id":"other","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}
        """), now: now.addingTimeInterval(1))
        let reply = try message("item/completed", #"""
        "item":{"id":"reply","type":"userMessage","content":[
            {"type":"text","text":"Test user message"},
            {"type":"text",
             "text":"<send_user_message_question_reply>[{\"questionItemId\":\"[\\\"request_user_input_async\\\",\\\"question\\\",0]\"}]</send_user_message_question_reply>"},
            {"type":"text","text":"<send_user_message_question_reply>invalid</send_user_message_question_reply>"},
            {"type":"text",
             "text":"<send_user_message_question_reply>[{\"questionItemId\":\"[\\\"request_user_input_async\\\",\\\"question\\\",1]\"}]</send_user_message_question_reply>"}
        ]}
        """#)
        _ = reducer.consume(reply, now: now.addingTimeInterval(2))
        #expect(try summary(reducer).waiting?.since == now.addingTimeInterval(1))
        _ = try reducer.consume(questionReply("other", index: 0), now: now.addingTimeInterval(3))
        #expect(try summary(reducer).waiting == nil)
    }

    @Test(arguments: ["idle", "completed", "reconnect"])
    func asyncQuestionWaitsEndWithTheirTurnOrConnection(ending: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/completed", #""item":{"id":"question","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}"#), now: now)
        #expect(try summary(reducer).waiting != nil)
        switch ending {
        case "idle":
            _ = try reducer.consume(message("thread/status/changed", #""status":{"type":"idle"}"#, turn: false), now: now.addingTimeInterval(1))
        case "completed":
            _ = try reducer.consume(message("turn/completed", #""turn":{"id":"turn-a","status":"completed"}"#), now: now.addingTimeInterval(1))
        default:
            reducer.reconnect()
        }
        #expect(reducer.states.values.first?.presentation?.summary.waiting == nil)
    }

    @Test func toolCompletionDoesNotMaskReasoningOrAnswerDeltas() throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/started", #""item":{"id":"cmd","type":"commandExecution","commandActions":[{"type":"read"}]}"#), now: now)
        #expect(try summary(reducer).current.key == "command-read")
        _ = try reducer.consume(message("item/completed", """
        "item":{"id":"cmd","type":"commandExecution","status":"completed","commandActions":[{"type":"read"}]}
        """), now: now.addingTimeInterval(1))
        #expect(try summary(reducer).current.key == "processing")
        let recent = try summary(reducer).recent
        #expect(recent?.label.key == "action-completed")
        #expect(recent?.label.symbolName == "book")
        let events = try reducer.consume(message("item/reasoning/summaryTextDelta", #""itemId":"reason","delta":"Test response""#), now: now.addingTimeInterval(2))
        #expect(events.isEmpty)
        #expect(try summary(reducer).current.key == "thinking")
        _ = try reducer.consume(message("item/started", #""item":{"id":"answer","type":"agentMessage","phase":"final_answer"}"#), now: now.addingTimeInterval(3))
        _ = try reducer.consume(message("item/agentMessage/delta", #""itemId":"answer","delta":"Test response""#), now: now.addingTimeInterval(4))
        #expect(try summary(reducer).current.key == "answering")
        #expect(try summary(reducer).recent == recent)
    }

    @Test func concurrentToolCompletionKeepsOtherToolAndNewerReplyVisible() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("turn/started"), at: now)
        try live.consume(message("item/started", #""item":{"id":"first","type":"fileChange"}"#), at: now)
        try live.consume(message("item/started", #""item":{"id":"second","type":"imageView"}"#), at: now.addingTimeInterval(1))
        #expect(live.summary.toolCount == 2)
        try live.consume(message("item/completed", #""item":{"id":"second","type":"imageView"}"#), at: now.addingTimeInterval(2))
        #expect(live.summary.current.key == "editing")
        try live.consume(message("item/agentMessage/delta", #""itemId":"answer""#), at: now.addingTimeInterval(3))
        try live.consume(message("item/completed", #""item":{"id":"first","type":"fileChange","status":"completed"}"#), at: now.addingTimeInterval(4))
        #expect(live.summary.current.key == "replying")
        #expect(live.summary.toolCount == 0)
    }

    @Test(arguments: [("commandExecution", "command")])
    func outputAfterReconnectRestoresToolPhaseWithoutInventingInventory(type: String, key: String) throws {
        var reducer = try prepared()
        reducer.reconnect()
        let thread = ActivityThread(id: "thread-a", status: ActivityThreadStatus(type: .active, activeFlags: []))
        _ = reducer.reconcile(thread: thread, turns: [ActivityTurn(id: "turn-a", status: .running)], now: now)
        let output = try message("item/\(type)/outputDelta", #""itemId":"tool","delta":"Test output""#)
        #expect(reducer.consume(output, now: now.addingTimeInterval(1)).isEmpty)
        #expect(try summary(reducer).current.key == key)
        #expect(try summary(reducer).toolCount == nil)
        _ = reducer.consume(output, now: now.addingTimeInterval(2))
        #expect(try summary(reducer).toolCount == nil)
        _ = try reducer.consume(message("item/completed", """
        "item":{"id":"tool","type":"\(type)","status":"completed"}
        """), now: now.addingTimeInterval(3))
        #expect(try summary(reducer).current.key == "processing")
        #expect(try summary(reducer).toolCount == nil)
    }

    @Test func outputKeepsKnownActionsAndCompletesOnlyItsOwnItem() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("turn/started"), at: now)
        try live.consume(message("item/started", #""item":{"id":"cmd","type":"commandExecution","commandActions":[{"type":"read"}]}"#), at: now)
        try live.consume(message("item/commandExecution/outputDelta", #""itemId":"cmd""#), at: now.addingTimeInterval(1))
        #expect(live.summary.current.key == "command-read")
        try live.consume(message("item/started", #""item":{"id":"edit","type":"fileChange"}"#), at: now.addingTimeInterval(2))
        let beforeDeprecatedMessage = live.summary
        try live.consume(message("item/fileChange/outputDelta", #""itemId":"unknown""#), at: now.addingTimeInterval(3))
        #expect(live.summary == beforeDeprecatedMessage)
        #expect(live.summary.toolCount == 2)
        try live.consume(message("item/completed", #""item":{"id":"cmd","type":"commandExecution","status":"completed"}"#), at: now.addingTimeInterval(4))
        #expect(live.summary.current.key == "editing")
        #expect(live.summary.toolCount == 1)
        try live.consume(message("item/agentMessage/delta", #""itemId":"answer""#), at: now.addingTimeInterval(5))
        try live.consume(message("item/completed", #""item":{"id":"edit","type":"fileChange","status":"completed"}"#), at: now.addingTimeInterval(6))
        #expect(live.summary.current.key == "replying")
        #expect(live.summary.toolCount == 0)
    }

    @Test func recoveredToolOutputDoesNotClearUserWait() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":["waitingOnUserInput"]}"#, turn: false), at: now)
        try live.consume(message("item/commandExecution/outputDelta", #""itemId":"cmd""#), at: now.addingTimeInterval(1))
        #expect(live.summary.current.key == "waiting-input")
        #expect(live.summary.waiting?.since == now)
        try live.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":[]}"#, turn: false), at: now.addingTimeInterval(2))
        #expect(live.summary.current.key == "command")
    }

    @Test(arguments: ["completed", "failed", "declined"])
    func recentCommandOutcomesUseLocalizedActionDetails(status: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/completed", """
        "item":{"id":"cmd","type":"commandExecution","status":"\(status)","commandActions":[{"type":"search"},{"type":"read"},{"type":"read"}]}
        """), now: now)
        let recent = try #require(try summary(reducer).recent)
        #expect(recent.label.key == "action-" + status)
        #expect(recent.label.detail == String(localized: "activity.live.actions-read-search"))
        #expect(recent.label.symbolName == "doc.text.magnifyingglass")
        let action = String(localized: "activity.live.actions-read-search")
        let expected = switch status {
        case "completed": String(localized: "activity.live.action-completed", defaultValue: "\(action)")
        case "failed": String(localized: "activity.live.action-failed", defaultValue: "\(action)")
        default: String(localized: "activity.live.action-declined", defaultValue: "\(action)")
        }
        #expect(recent.label.text == expected)
        #expect(!recent.label.text.contains(" • "))
    }

    @Test(arguments: [
        (#""type":"commandExecution","commandActions":[{"type":"read"}]"#, ("book", "action")),
        (#""type":"commandExecution","commandActions":[{"type":"listFiles"}]"#, ("folder", "action")),
        (#""type":"commandExecution","commandActions":[{"type":"search"}]"#, ("magnifyingglass", "action")),
        (#""type":"commandExecution","commandActions":[{"type":"read"},{"type":"search"}]"#, ("doc.text.magnifyingglass", "action")),
        (#""type":"commandExecution""#, ("terminal", "command")),
        (#""type":"fileChange""#, ("square.and.pencil", "file")),
        (#""type":"webSearch","action":{"type":"search"}"#, ("globe", "action")),
        (#""type":"webSearch","action":{"type":"openPage"}"#, ("globe", "action")),
        (#""type":"webSearch","action":{"type":"findInPage"}"#, ("globe", "action")),
        (#""type":"webSearch""#, ("globe", "action")),
        (#""type":"webSearch","action":{"type":"future"}"#, ("globe", "action")),
        (#""type":"imageView""#, ("photo", "action")),
        (#""type":"imageGeneration""#, ("wand.and.stars", "image")),
        (#""type":"sleep""#, ("hourglass", "timer")),
        (#""type":"mcpToolCall","server":"server","tool":"tool""#, ("wrench.and.screwdriver", "tool")),
        (#""type":"mcpToolCall""#, ("wrench.and.screwdriver", "tool")),
        (#""type":"dynamicToolCall","tool":"tool""#, ("wrench.and.screwdriver", "tool")),
        (#""type":"dynamicToolCall""#, ("wrench.and.screwdriver", "tool")),
        (#""type":"collabAgentToolCall","tool":"spawnAgent""#, ("person.2", "action"))
    ], ["completed", "failed", "declined"])
    func toolResultsKeepOperationAndOutcome(example: (fields: String, expected: (symbol: String, completionPrefix: String)), status: String) throws {
        for observesStart in [false, true] {
            var live = ActivityLivePresentation()
            if observesStart {
                try live.consume(message("item/started", """
                "item":{"id":"operation",\(example.fields),"status":"inProgress"}
                """), at: now)
                #expect(live.summary.current.symbolName == example.expected.symbol)
            }
            try live.consume(message("item/completed", """
            "item":{"id":"operation",\(example.fields),"status":"\(status)"}
            """), at: now.addingTimeInterval(1))
            #expect(live.summary.recent?.label.symbolName == example.expected.symbol)
            #expect(live.summary.recent?.label.key == example.expected.completionPrefix + "-" + status)
        }
    }

    @Test func partialCompletionKeepsItsOwnOperationSymbolWhileAnotherToolRuns() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("item/started", #""item":{"id":"read","type":"commandExecution","commandActions":[{"type":"read"}]}"#), at: now)
        try live.consume(message("item/started", #""item":{"id":"edit","type":"fileChange"}"#), at: now.addingTimeInterval(1))
        try live.consume(message("item/completed", #""item":{"id":"read","type":"commandExecution","status":"failed"}"#), at: now.addingTimeInterval(2))
        #expect(live.summary.current.symbolName == "square.and.pencil")
        #expect(live.summary.recent?.label.symbolName == "book")
    }

    struct CommandPresentationCase {
        let command: String
        let started: ActivityLiveLabel
        let completionPrefix: String
    }

    @Test(arguments: [
        CommandPresentationCase(command: "python3 - <<'PY'\nprint('test')\nPY", started: .init("executing-tool", detail: "python3"), completionPrefix: "command-"),
        CommandPresentationCase(command: "git status; ls", started: .init("executing-tool", detail: "git, ls"), completionPrefix: "command-"),
        CommandPresentationCase(command: "git status; ls; pwd", started: .init("executing-tools", detail: "git, ls"), completionPrefix: "tools-"),
        CommandPresentationCase(command: "sed -n 1p a; sed -n 2p a; sed -n 3p a", started: .init("executing-tool", detail: "sed"), completionPrefix: "command-"),
        CommandPresentationCase(command: "sed -n 1p a; sed -n 2p a; git status", started: .init("executing-tool", detail: "sed, git"), completionPrefix: "command-"),
        CommandPresentationCase(command: "sed -n 1p a; sed -n 2p a; git status; ls", started: .init("executing-tools", detail: "sed, git"), completionPrefix: "tools-"),
        CommandPresentationCase(command: "\"$CMD\" status", started: .init("command"), completionPrefix: "command-"),
        CommandPresentationCase(command: "python3 'unfinished", started: .init("command"), completionPrefix: "command-")
    ], ["completed", "failed", "declined"])
    func parsedCommandsKeepStartedProgressAndCompletedConsistent(example: CommandPresentationCase, status: String) throws {
        var item: [String: Any] = [
            "id": "cmd", "type": "commandExecution", "commandActions": [["type": "unknown", "command": example.command]]
        ]
        func fields() throws -> String {
            let data = try JSONSerialization.data(withJSONObject: ["item": item])
            let text = try #require(String(data: data, encoding: .utf8))
            return String(text.dropFirst().dropLast())
        }
        var reducer = try prepared()
        _ = try reducer.consume(message("item/started", fields()), now: now)
        #expect(try summary(reducer).current == example.started)
        _ = try reducer.consume(message("item/commandExecution/outputDelta", #""itemId":"cmd""#), now: now.addingTimeInterval(1))
        #expect(try summary(reducer).current == example.started)
        item["status"] = status
        _ = try reducer.consume(message("item/completed", fields()), now: now.addingTimeInterval(2))
        #expect(try summary(reducer).recent?.label == ActivityLiveLabel(example.completionPrefix + status, detail: example.started.detail))
        #expect(try summary(reducer).current.key == "processing")
    }

    @Test func currentToolDetailsUseLocalizedTemplates() throws {
        let name = "server.tools"
        var reducer = try prepared()
        _ = try reducer.consume(message("item/started", """
        "item":{"id":"tool","type":"mcpToolCall","server":"server","tool":"tools","status":"inProgress","arguments":{"limit":1}}
        """), now: now)
        #expect(try summary(reducer).current.text == String(localized: "activity.live.calling-named-tool", defaultValue: "\(name)"))
        _ = try reducer.consume(message("item/completed", """
        "item":{"id":"tool","type":"mcpToolCall","server":"server","tool":"tools","status":"completed"}
        """), now: now.addingTimeInterval(1))
        #expect(try summary(reducer).recent?.label.detail == name)
    }

    @Test func modelChangePreservesRouteDetails() throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("model/rerouted", #""fromModel":"model-a","toModel":"model-b""#), now: now)
        let label = try #require(try summary(reducer).recent?.label)
        let route = "model-a → model-b"
        #expect(label.text == String(localized: "activity.live.model-changed-detail", defaultValue: "\(route)"))
        #expect(label.key == "model-changed")
        #expect(label.detail == route)
    }

    @Test(arguments: ["spawnAgent", "wait", "sendInput", "future"], ["running", "errored"])
    func interruptedCollabUpdatesRecentEvent(tool: String, childStatus: String) throws {
        var reducer = try prepared()
        for (method, status) in [("item/started", "inProgress"), ("item/completed", "interrupted")] {
            _ = try reducer.consume(message(method, """
            "item":{"id":"collab","type":"collabAgentToolCall","tool":"\(tool)","status":"\(status)",
            "agentsStates":{"child":{"status":"\(childStatus)"}}}
            """), now: now)
        }
        let presentation = try summary(reducer)
        let detail = String(localized: ActivityDisplayFormat.agentAction(tool: tool).action)
        #expect(presentation.current.key == "processing")
        #expect(presentation.toolCount == 0)
        #expect(presentation.recent?.label == ActivityLiveLabel("action-interrupted", detail: detail, symbolName: "person.2"))
        #expect(presentation.recent?.label.text == String(localized: "activity.live.action-interrupted", defaultValue: "\(detail)"))
        #expect(ActivityItem(id: "child", type: .subAgentActivity, kind: "interrupted").liveCompletionLabel?.key == "agent-interrupted")
    }

    @Test(arguments: [
        ("form", "waiting-form"), ("openai/form", "waiting-form"), ("openaiForm", "waiting-form"),
        ("url", "waiting-external"), ("future", "waiting-service")
    ])
    func elicitationWaitsAreSpecificAndEndByRequestID(mode: String, key: String) throws {
        var reducer = try prepared()
        let events = try reducer.consume(message("mcpServer/elicitation/request", "\"mode\":\"\(mode)\"", id: 7), now: now)
        #expect(events.isEmpty)
        #expect(try summary(reducer).waiting?.label.key == key)
        #expect(try summary(reducer).waiting?.since == now)
        _ = try reducer.consume(message("serverRequest/resolved", #""requestId":7"#, turn: false), now: now.addingTimeInterval(4))
        #expect(try summary(reducer).waiting == nil)
        #expect(try summary(reducer).recent?.label.key == "request-ended")
    }

    @Test func unrelatedOutputAndResolvedRequestDoNotClearConcurrentWait() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("mcpServer/elicitation/request", #""mode":"form""#, id: 1), at: now)
        try live.consume(message("mcpServer/elicitation/request", #""mode":"url""#, id: 2), at: now.addingTimeInterval(1))
        try live.consume(message("item/agentMessage/delta", #""itemId":"answer""#), at: now.addingTimeInterval(2))
        try live.consume(message("serverRequest/resolved", #""requestId":1"#, turn: false), at: now.addingTimeInterval(3))
        #expect(live.summary.waiting?.label.key == "waiting-external")
        try live.consume(message("serverRequest/resolved", #""requestId":999"#, turn: false), at: now.addingTimeInterval(4))
        #expect(live.summary.waiting?.since == now.addingTimeInterval(1))
    }

    @Test(arguments: [true, false, nil] as [Bool?])
    func userInputWaitsEndByRequestIDWithoutChangingLifecycle(isBlocking: Bool?) throws {
        var reducer = try prepared()
        let before = try #require(reducer.states.values.first)
        let blocking = isBlocking.map { String($0) } ?? "null"
        let input = try message("item/tool/requestUserInput", """
        "itemId":"question","isBlocking":\(blocking),"autoResolutionMs":null,
        "questions":[{"id":"q","header":"Test header","question":"Test question?","isOther":true,"isSecret":true,"options":null}]
        """, id: 1)
        #expect(input.kind.category == .presentation)
        #expect(reducer.consume(input, now: now).isEmpty)
        #expect(try summary(reducer).current.key == "waiting-input")
        #expect(try summary(reducer).current.detail == nil)
        #expect(try summary(reducer).waiting?.isBlocking == isBlocking)
        #expect(try summary(reducer).hasBlockingInputRequest == (isBlocking == true))
        #expect(try summary(reducer).waiting?.since == now)
        #expect(reducer.consume(input, now: now.addingTimeInterval(1)).isEmpty)
        #expect(try summary(reducer).waiting?.since == now)
        let state = try #require(reducer.states.values.first)
        #expect(state.isWaitingApproval == before.isWaitingApproval)
        #expect(state.pendingApprovals.isEmpty)
        #expect(state.lastProgressAt == before.lastProgressAt)
        _ = try reducer.consume(message("serverRequest/resolved", #""requestId":99"#, turn: false), now: now.addingTimeInterval(2))
        #expect(try summary(reducer).waiting != nil)
        #expect(try reducer.consume(message("serverRequest/resolved", #""requestId":1"#, turn: false), now: now.addingTimeInterval(3)).isEmpty)
        #expect(try summary(reducer).waiting == nil)
        #expect(try summary(reducer).hasBlockingInputRequest == false)
        #expect(try summary(reducer).recent?.label.key == "request-ended")
    }

    @Test func earlierAsyncWaitDoesNotMaskBlockingRequests() throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/completed", #""item":{"id":"async","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}"#), now: now)
        _ = try reducer.consume(message("item/tool/requestUserInput", #""isBlocking":false"#, id: 1), now: now.addingTimeInterval(1))
        for id in [2, 3] {
            _ = try reducer.consume(message("item/tool/requestUserInput", #""isBlocking":true"#, id: id), now: now.addingTimeInterval(Double(id)))
        }
        #expect(try summary(reducer).waiting?.since == now)
        #expect(try summary(reducer).waiting?.isBlocking == false)
        #expect(try summary(reducer).hasBlockingInputRequest == true)
        for id in [99, 1, 2] {
            _ = try reducer.consume(message("serverRequest/resolved", "\"requestId\":\(id)", turn: false), now: now.addingTimeInterval(4))
            #expect(try summary(reducer).hasBlockingInputRequest == true)
        }
        _ = try reducer.consume(message("serverRequest/resolved", #""requestId":3"#, turn: false), now: now.addingTimeInterval(5))
        #expect(try summary(reducer).hasBlockingInputRequest == false)
        #expect(try summary(reducer).waiting?.since == now)
    }

    @Test(arguments: ["active", "idle", "completed", "failed", "interrupted", "reconnect"])
    func blockingInputEndsWithAuthoritativeStateOrConnection(ending: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/tool/requestUserInput", #""isBlocking":true"#, id: 1), now: now)
        #expect(try summary(reducer).hasBlockingInputRequest == true)
        switch ending {
        case "active", "idle":
            _ = try reducer.consume(message("thread/status/changed", "\"status\":{\"type\":\"\(ending)\",\"activeFlags\":[]}", turn: false), now: now.addingTimeInterval(1))
        case "reconnect":
            reducer.reconnect()
        default:
            _ = try reducer.consume(message("turn/completed", "\"turn\":{\"id\":\"turn-a\",\"status\":\"\(ending)\"}"), now: now.addingTimeInterval(1))
        }
        #expect(reducer.states.values.first?.presentation?.summary.hasBlockingInputRequest != true)
    }

    @Test func nonblockingQuestionsSurviveActiveStatusAndResolveIndependently() throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/tool/requestUserInput", #""isBlocking":false"#, id: 1), now: now)
        _ = try reducer.consume(message("item/tool/requestUserInput", #""isBlocking":false"#, id: 2), now: now.addingTimeInterval(1))
        _ = try reducer.consume(message("item/agentMessage/delta", #""itemId":"answer""#), now: now.addingTimeInterval(2))
        _ = try reducer.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":[]}"#, turn: false), now: now.addingTimeInterval(3))
        let thread = ActivityThread(id: "thread-a", status: ActivityThreadStatus(type: .active, activeFlags: []))
        _ = reducer.reconcile(thread: thread, turns: [ActivityTurn(id: "turn-a", status: .running)], now: now.addingTimeInterval(4))
        #expect(try summary(reducer).waiting?.since == now)
        _ = try reducer.consume(message("serverRequest/resolved", #""requestId":1"#, turn: false), now: now.addingTimeInterval(5))
        #expect(try summary(reducer).waiting?.since == now.addingTimeInterval(1))
        _ = try reducer.consume(message("serverRequest/resolved", #""requestId":2"#, turn: false), now: now.addingTimeInterval(6))
        #expect(try summary(reducer).waiting == nil)
        #expect(try summary(reducer).current.key == "replying")
    }

    @Test func activeStatusClearsBlockingRequestsButKeepsNonblockingQuestions() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("item/tool/requestUserInput", #""isBlocking":true"#, id: 1), at: now)
        try live.consume(message("mcpServer/elicitation/request", #""mode":"form""#, id: 2), at: now)
        try live.consume(message("item/tool/requestUserInput", #""isBlocking":false"#, id: 3), at: now.addingTimeInterval(1))
        live.reconcile(status: ActivityThreadStatus(type: .active, activeFlags: []))
        #expect(live.requests.count == 1)
        #expect(live.summary.waiting?.since == now.addingTimeInterval(1))
        try live.consume(message("serverRequest/resolved", #""requestId":3"#, turn: false), at: now.addingTimeInterval(2))
        #expect(live.summary.waiting == nil)
    }

    @Test(arguments: ["mcpServer/elicitation/request", "item/tool/requestUserInput"])
    func uncorrelatedInputNeverBecomesWaiting(method: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message(method, #""mode":"url","isBlocking":false"#, id: 1, turn: false), now: now)
        #expect(try summary(reducer).waiting == nil)
        _ = try reducer.consume(message(method, #""mode":"url","isBlocking":false"#), now: now)
        #expect(try summary(reducer).waiting == nil)
    }

    @Test func reconnectDropsUnverifiablePhasesAndWaitingDuration() throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":["waitingOnUserInput"]}"#, turn: false), now: now)
        reducer.reconnect()
        #expect(reducer.states.values.first?.presentation == nil)
        let thread = ActivityThread(id: "thread-a", status: ActivityThreadStatus(type: .active, activeFlags: [.waitingOnUserInput]))
        _ = reducer.reconcile(thread: thread, turns: [ActivityTurn(id: "turn-a", status: .running)], now: now.addingTimeInterval(12))
        #expect(try summary(reducer).waiting?.label.key == "waiting-input")
        #expect(try summary(reducer).waiting?.since == nil)
        #expect(try summary(reducer).toolCount == nil)
    }

    @Test(arguments: ["approved", "denied", "timedOut", "aborted"])
    func automaticReviewHasNoPresentationOrHistory(status: String) throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/autoApprovalReview/started", #""reviewId":"review","review":{"status":"inProgress"}"#), now: now)
        #expect(try summary(reducer).current.key == "processing")
        #expect(try summary(reducer).waiting == nil)
        let events = try reducer.consume(
            message("item/autoApprovalReview/completed", "\"reviewId\":\"review\",\"review\":{\"status\":\"\(status)\"}"),
            now: now.addingTimeInterval(1)
        )
        #expect(events.isEmpty)
        #expect(try summary(reducer).current.key == "processing")
        #expect(try summary(reducer).recent == nil)
    }

    @Test func presentationEventsNeverProduceHistoricalRecords() throws {
        var reducer = try prepared()
        let messages = try [
            message("turn/plan/updated", #""plan":[{"step":"Test plan step","status":"completed"}]"#),
            message("turn/diff/updated", #""diff":"Test diff""#),
            message("model/rerouted", #""fromModel":"old","toModel":"new""#),
            message("modelProvider/authRecoveryStarted"),
            message("modelProvider/authRecoveryCompleted"),
            message("model/safetyBuffering/updated", #""showBufferingUi":true"#),
            message("hook/started", #""run":{"id":"hook","status":"running","executionMode":"sync"}"#)
        ]
        for notification in messages {
            #expect(notification.kind.category == .presentation)
            #expect(reducer.consume(notification, now: now).isEmpty)
        }
        #expect(try summary(reducer).planCompleted == 1)
        #expect(try summary(reducer).planTotal == 1)
        #expect(try summary(reducer).waiting == nil)
        #expect(reducer.tokenUsageTurns.isEmpty)
    }

    @Test(arguments: [
        ("thread/status/changed", false), ("mcpServer/elicitation/request", false),
        ("item/tool/requestUserInput", false), ("item/tool/requestUserInput", true), ("item/completed", false)
    ])
    func displayWaitingDoesNotChangeApprovalOrProtectionState(method: String, isBlocking: Bool) throws {
        let event = TestFixtures.event()
        var task = try ActivityTask(
            displayID: UUID(),
            key: #require(ActivityTaskKey(event: event)),
            event: event,
            state: .running,
            startedAt: now,
            progressGeneration: 0
        )
        var reducer = try prepared()
        _ = try reducer.consume(message(method, """
        "status":{"type":"active","activeFlags":["waitingOnUserInput"]},"isBlocking":\(isBlocking),
        "item":{"id":"question","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}
        """, id: 1), now: now)
        let state = try #require(reducer.states.values.first)
        task.mergeExecutionLifecycle(state, owner: ActivityExecutionKey(agentThreadID: nil, turnID: "turn-a"))
        let snapshot = ActivitySnapshot(waitingTasks: [], runningTasks: [task.snapshot], recentCompletions: [], recentTerminations: [])
        #expect(task.state == .running)
        #expect(snapshot.waitingCount == 0)
        #expect(snapshot.panelWaitingTasks.count == 1)
        #expect(snapshot.panelRunningTasks.isEmpty)
        #expect(snapshot.runningTasks == [task.snapshot])
        var selection = ActivityCardSelection()
        selection.update(snapshot: snapshot, isHealthy: true, now: now)
        #expect(selection.current == .waiting(task.snapshot))
        #expect(snapshot.keepAliveTaskIDs.waiting == (isBlocking ? [task.displayID] : []))
        #expect(snapshot.keepAliveTaskIDs.running == (isBlocking ? [] : [task.displayID]))
        let summary = ActivityDisplayFormat.liveSummaryComponents(for: task.snapshot, now: now)
        #expect(summary.count == 2)
        #expect(summary.first == ActivityLiveLabel("elapsed-running").text + " " + CodexDurationFormat.activityText(for: 0))
        #expect(summary.last == ActivityLiveLabel("elapsed-waiting").text + " " + CodexDurationFormat.activityText(for: 0))
    }

    @Test(arguments: [false, true])
    func keepAliveFindsBlockingInputAcrossExecutions(blockingInChild: Bool) throws {
        let event = TestFixtures.event()
        var task = try ActivityTask(
            displayID: UUID(), key: #require(ActivityTaskKey(event: event)), event: event,
            state: .running, startedAt: now, progressGeneration: 0
        )
        var nonblocking = ActivityLivePresentation()
        try nonblocking.consume(message("item/completed", #""item":{"id":"async","type":"agentMessage","delivery":"async","questions":[{"title":"Test question?"}]}"#), at: now)
        var blocking = ActivityLivePresentation()
        try blocking.consume(message("item/tool/requestUserInput", #""isBlocking":true"#, id: 1), at: now.addingTimeInterval(1))
        let rootOwner = ActivityExecutionKey(agentThreadID: nil, turnID: "turn-a")
        let childOwner = ActivityExecutionKey(agentThreadID: "child", turnID: "child-turn")
        task.executions[rootOwner] = ActivityExecution(presentation: blockingInChild ? nonblocking : blocking)
        task.executions[childOwner] = ActivityExecution(presentation: blockingInChild ? blocking : nonblocking)
        let waiting = task.snapshot
        #expect(waiting.presentation?.waiting?.isBlocking == false)
        #expect(waiting.presentation?.hasBlockingInputRequest == true)
        let snapshot = ActivitySnapshot(waitingTasks: [], runningTasks: [waiting], recentCompletions: [], recentTerminations: [])
        #expect(snapshot.keepAliveTaskIDs.waiting == [task.displayID])
        #expect(snapshot.keepAliveTaskIDs.running.isEmpty)

        let concurrent = ActivityTaskSnapshot(
            id: UUID(), projectName: nil, modelName: nil, effort: nil,
            startedAt: now, stateChangedAt: now, activeSubagentCount: nil, threadID: "concurrent-thread"
        )
        let mixed = ActivitySnapshot(waitingTasks: [], runningTasks: [waiting, concurrent], recentCompletions: [], recentTerminations: [])
        #expect(mixed.keepAliveTaskIDs.running == [concurrent.id])
        #expect(mixed.keepAliveTaskIDs.waiting == [task.displayID])
        let approval = ActivitySnapshot(waitingTasks: [concurrent], runningTasks: [waiting], recentCompletions: [], recentTerminations: [])
        #expect(approval.keepAliveTaskIDs.running.isEmpty)
        #expect(approval.keepAliveTaskIDs.waiting == [concurrent.id, task.displayID])

        task.finishExecution(blockingInChild ? childOwner : rootOwner, at: now.addingTimeInterval(2))
        #expect(task.snapshot.presentation?.waiting != nil)
        #expect(task.snapshot.presentation?.hasBlockingInputRequest == false)
        let resumed = ActivitySnapshot(waitingTasks: [], runningTasks: [task.snapshot], recentCompletions: [], recentTerminations: [])
        #expect(resumed.keepAliveTaskIDs.running == [task.displayID])
        #expect(resumed.keepAliveTaskIDs.waiting.isEmpty)
    }

    @Test func authoritativeIdleClearsRequestsWithoutInventingApproval() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("mcpServer/elicitation/request", #""mode":"form""#, id: 1), at: now)
        try live.consume(message("item/tool/requestUserInput", #""isBlocking":false"#, id: 2), at: now)
        live.reconcile(status: ActivityThreadStatus(type: .idle))
        #expect(live.summary.waiting == nil)
        #expect(live.summary.recent == nil)
    }

    @Test func temporaryOperationsEndWithoutClearingOtherOperations() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("modelProvider/authRecoveryStarted"), at: now)
        try live.consume(message("model/safetyBuffering/updated", #""showBufferingUi":true"#), at: now.addingTimeInterval(1))
        #expect(live.summary.current.key == "buffering")
        try live.consume(message("model/safetyBuffering/updated", #""showBufferingUi":false"#), at: now.addingTimeInterval(2))
        #expect(live.summary.current.key == "recovering-auth")
        try live.consume(message("modelProvider/authRecoveryCompleted"), at: now.addingTimeInterval(3))
        #expect(live.summary.current.key == "processing")
        #expect(live.summary.recent?.label.key == "auth-recovery-ended")
        #expect(live.summary.waiting == nil)
    }

    @Test func childWaitSurvivesRootOutputUntilChildLifecycleResolvesIt() throws {
        let event = TestFixtures.event()
        var task = try ActivityTask(
            displayID: UUID(),
            key: #require(ActivityTaskKey(event: event)),
            event: event,
            state: .running,
            startedAt: now,
            progressGeneration: 0
        )
        var root = ActivityLivePresentation()
        try root.consume(message("item/agentMessage/delta", #""itemId":"answer""#), at: now.addingTimeInterval(4))
        var child = ActivityLivePresentation()
        try child.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":["waitingOnUserInput"]}"#, turn: false), at: now)
        task.executions[ActivityExecutionKey(agentThreadID: nil, turnID: "turn-a")] = ActivityExecution(presentation: root)
        let childOwner = ActivityExecutionKey(agentThreadID: "child", turnID: "child-turn")
        task.executions[childOwner] = ActivityExecution(presentation: child)
        #expect(task.snapshot.presentation?.waiting?.since == now)
        #expect(task.snapshot.presentation?.current.key == "waiting-input")
        try child.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":[]}"#, turn: false), at: now.addingTimeInterval(5))
        task.executions[childOwner]?.presentation = child
        #expect(task.snapshot.presentation?.waiting == nil)
        #expect(task.snapshot.presentation?.current.key == "replying")
    }

    @Test func failedTurnKeepsItsOutcomeWithoutChangingTerminalPolicy() throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/tool/requestUserInput", #""isBlocking":false"#, id: 1), now: now)
        let events = try reducer.consume(message("turn/completed", #""turn":{"id":"turn-a","status":"failed"}"#), now: now)
        let state = try #require(reducer.states.values.first)
        #expect(state.turnStatus == .failed)
        #expect(state.presentation == nil)
        #expect(events.first?.eventKind == .turnAborted)
        #expect(events.first?.context?.turnStatus == .failed)
        let event = TestFixtures.event()
        var task = try ActivityTask(
            displayID: UUID(),
            key: #require(ActivityTaskKey(event: event)),
            event: event,
            state: .running,
            startedAt: now,
            progressGeneration: 0
        )
        ActivityTaskGraph.mergeLifecycleBackfill(from: state, into: &task)
        #expect(task.terminalFailed)
    }

    @Test func reconnectDiscardsPendingNonblockingQuestions() throws {
        var reducer = try prepared()
        _ = try reducer.consume(message("item/tool/requestUserInput", #""isBlocking":false"#, id: 1), now: now)
        reducer.reconnect()
        let thread = ActivityThread(id: "thread-a", status: ActivityThreadStatus(type: .active, activeFlags: []))
        _ = reducer.reconcile(thread: thread, turns: [ActivityTurn(id: "turn-a", status: .running)], now: now.addingTimeInterval(1))
        #expect(try summary(reducer).waiting == nil)
    }

    @Test func resolvedRequestDoesNotClearThreadInputWait() throws {
        var live = ActivityLivePresentation()
        try live.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":["waitingOnUserInput"]}"#, turn: false), at: now)
        try live.consume(message("mcpServer/elicitation/request", #""mode":"form""#, id: 1), at: now)
        try live.consume(message("serverRequest/resolved", #""requestId":1"#, turn: false), at: now.addingTimeInterval(2))
        #expect(live.summary.waiting?.label.key == "waiting-input")
        #expect(live.summary.waiting?.since == now)
        try live.consume(message("thread/status/changed", #""status":{"type":"active","activeFlags":[]}"#, turn: false), at: now.addingTimeInterval(3))
        #expect(live.summary.waiting == nil)
    }

    @Test func verificationRequestDoesNotCreateWaitingOrRecentEvent() throws {
        var reducer = try prepared()
        let before = try summary(reducer)
        #expect(try reducer.consume(message("mcpServer/elicitation/request", #""mode":"openai/userVerification""#, id: 1), now: now).isEmpty)
        _ = try reducer.consume(message("serverRequest/resolved", #""requestId":1"#, turn: false), now: now)
        #expect(try summary(reducer) == before)
    }

    @Test(arguments: ["item/started", "item/completed"])
    func planItemsDoNotChangePresentationOrProgress(method: String) throws {
        var reducer = try prepared()
        let before = try summary(reducer)
        let progress = reducer.states.values.first?.lastProgressAt
        #expect(try reducer.consume(message(method, #""item":{"id":"plan","type":"plan"}"#), now: now.addingTimeInterval(10)).isEmpty)
        #expect(try summary(reducer) == before)
        #expect(reducer.states.values.first?.lastProgressAt == progress)
    }
}