The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | import { ProviderDriverKind } from "@t3tools/contracts"; |
| 2 | |
| 3 | import { claudeBackgroundSubagentAfterRootInput } from "./claude_background_subagent_after_root/input.ts"; |
| 4 | import { assertClaudeBackgroundSubagentAfterRootOutput } from "./claude_background_subagent_after_root/output.ts"; |
| 5 | import { claudeBackgroundTaskAfterRootInput } from "./claude_background_task_after_root/input.ts"; |
| 6 | import { assertClaudeBackgroundTaskAfterRootOutput } from "./claude_background_task_after_root/output.ts"; |
| 7 | import { claudeBackgroundSubagentLifecycleInput } from "./claude_background_subagent_lifecycle/input.ts"; |
| 8 | import { assertClaudeBackgroundSubagentLifecycleOutput } from "./claude_background_subagent_lifecycle/output.ts"; |
| 9 | import { claudeBackgroundTaskInterruptInput } from "./claude_background_task_interrupt/input.ts"; |
| 10 | import { claudeBackgroundWakeBeforeQueuedPromptInput } from "./claude_background_wake_before_queued_prompt/input.ts"; |
| 11 | import { assertClaudeBackgroundWakeBeforeQueuedPromptOutput } from "./claude_background_wake_before_queued_prompt/output.ts"; |
| 12 | import { claudeBackgroundWakeBeforeQueuedPromptNoEchoInput } from "./claude_background_wake_before_queued_prompt_no_echo/input.ts"; |
| 13 | import { assertClaudeBackgroundWakeBeforeQueuedPromptNoEchoOutput } from "./claude_background_wake_before_queued_prompt_no_echo/output.ts"; |
| 14 | import { assertClaudeBackgroundTaskInterruptOutput } from "./claude_background_task_interrupt/output.ts"; |
| 15 | import { claudeBackgroundMonitorWakeInput } from "./claude_background_monitor_wake/input.ts"; |
| 16 | import { assertClaudeBackgroundMonitorWakeOutput } from "./claude_background_monitor_wake/output.ts"; |
| 17 | import { claudeBackgroundTaskWakeInput } from "./claude_background_task_wake/input.ts"; |
| 18 | import { assertClaudeBackgroundTaskWakeOutput } from "./claude_background_task_wake/output.ts"; |
| 19 | import { |
| 20 | claudeCompactAfterPeerTurnInput, |
| 21 | claudeCompactAfterPeerTurnNoEchoInput, |
| 22 | } from "./claude_compact_after_peer_turn/input.ts"; |
| 23 | import { assertClaudeCompactAfterPeerTurnOutput } from "./claude_compact_after_peer_turn/output.ts"; |
| 24 | import { assertClaudeCompactAfterPeerTurnNoEchoOutput } from "./claude_compact_after_peer_turn_no_echo/output.ts"; |
| 25 | import { claudeCompactAfterResumeWakeInput } from "./claude_compact_after_resume_wake/input.ts"; |
| 26 | import { assertClaudeCompactAfterResumeWakeOutput } from "./claude_compact_after_resume_wake/output.ts"; |
| 27 | import { claudeIdleResumeInput } from "./claude_idle_resume/input.ts"; |
| 28 | import { assertClaudeIdleResumeOutput } from "./claude_idle_resume/output.ts"; |
| 29 | import { claudeLocalBashTaskInput } from "./claude_local_bash_task/input.ts"; |
| 30 | import { assertClaudeLocalBashTaskOutput } from "./claude_local_bash_task/output.ts"; |
| 31 | import { claudeNestedBackgroundSubagentWakeInput } from "./claude_nested_background_subagent_wake/input.ts"; |
| 32 | import { assertClaudeNestedBackgroundSubagentWakeOutput } from "./claude_nested_background_subagent_wake/output.ts"; |
| 33 | import { claudeNestedSubagentModelInput } from "./claude_nested_subagent_model/input.ts"; |
| 34 | import { assertClaudeNestedSubagentModelOutput } from "./claude_nested_subagent_model/output.ts"; |
| 35 | import { claudeMcpToolPresentationInput } from "./claude_mcp_tool_presentation/input.ts"; |
| 36 | import { assertClaudeMcpToolPresentationOutput } from "./claude_mcp_tool_presentation/output.ts"; |
| 37 | import { claudeResultIsErrorInput } from "./claude_result_is_error/input.ts"; |
| 38 | import { assertClaudeResultIsErrorOutput } from "./claude_result_is_error/output.ts"; |
| 39 | import { assertClaudeUsageLimitOutput } from "./usage_limit/claude_output.ts"; |
| 40 | import { grokAutoBlockedCommandInput } from "./grok_auto_blocked_command/input.ts"; |
| 41 | import { kiroCompactionInput } from "./kiro_compaction/input.ts"; |
| 42 | import { kiroForkFromTurnInput } from "./kiro_fork_from_turn/input.ts"; |
| 43 | import { assertKiroForkFromTurnOutput } from "./kiro_fork_from_turn/output.ts"; |
| 44 | import { kiroMessageSteeringInput } from "./kiro_message_steering/input.ts"; |
| 45 | import { assertKiroMessageSteeringOutput } from "./kiro_message_steering/output.ts"; |
| 46 | import { assertKiroCompactionOutput } from "./kiro_compaction/output.ts"; |
| 47 | import { KIRO_EFFORT_LEVEL, KIRO_EFFORT_MODEL, kiroEffortInput } from "./kiro_effort/input.ts"; |
| 48 | import { assertKiroEffortOutput } from "./kiro_effort/output.ts"; |
| 49 | import { kiroModelSwitchInput } from "./kiro_model_switch/input.ts"; |
| 50 | import { assertKiroModelSwitchOutput } from "./kiro_model_switch/output.ts"; |
| 51 | import { |
| 52 | kiroFullAccessWriteInput, |
| 53 | kiroSupervisedWriteInput, |
| 54 | } from "./kiro_permission_modes/input.ts"; |
| 55 | import { |
| 56 | assertKiroFullAccessWriteOutput, |
| 57 | assertKiroSupervisedWriteOutput, |
| 58 | } from "./kiro_permission_modes/output.ts"; |
| 59 | import { kiroSubagentInterruptInput } from "./kiro_subagent_interrupt/input.ts"; |
| 60 | import { assertKiroSubagentInterruptOutput } from "./kiro_subagent_interrupt/output.ts"; |
| 61 | import { assertGrokAutoBlockedCommandOutput } from "./grok_auto_blocked_command/output.ts"; |
| 62 | import { grokBackgroundBashInput } from "./grok_background_bash/input.ts"; |
| 63 | import { assertGrokBackgroundBashOutput } from "./grok_background_bash/output.ts"; |
| 64 | import { grokBackgroundBashFastWakeInput } from "./grok_background_bash_fast_wake/input.ts"; |
| 65 | import { assertGrokBackgroundBashFastWakeOutput } from "./grok_background_bash_fast_wake/output.ts"; |
| 66 | import { grokBackgroundSubagentInput } from "./grok_background_subagent/input.ts"; |
| 67 | import { assertGrokBackgroundSubagentOutput } from "./grok_background_subagent/output.ts"; |
| 68 | import { grokMonitorInput } from "./grok_monitor/input.ts"; |
| 69 | import { assertGrokMonitorOutput } from "./grok_monitor/output.ts"; |
| 70 | import { grokPromptErrorInput } from "./grok_prompt_error/input.ts"; |
| 71 | import { assertGrokPromptErrorOutput } from "./grok_prompt_error/output.ts"; |
| 72 | import { grokSubagentLineageInput } from "./grok_subagent_lineage/input.ts"; |
| 73 | import { assertGrokSubagentLineageOutput } from "./grok_subagent_lineage/output.ts"; |
| 74 | import { assertClaudeMessageSteeringOutput } from "./message_steering/claude_output.ts"; |
| 75 | import { assertMessageSteeringOutput } from "./message_steering/codex_output.ts"; |
| 76 | import { assertCursorMessageSteeringOutput } from "./message_steering/cursor_output.ts"; |
| 77 | import { assertGrokMessageSteeringOutput } from "./message_steering/grok_output.ts"; |
| 78 | import { messageSteeringInput } from "./message_steering/input.ts"; |
| 79 | import { assertPiMessageSteeringOutput } from "./message_steering/pi_output.ts"; |
| 80 | import { MUSE_PERMISSION_DECLINED_FILE, musePermissionInput } from "./muse_permission/input.ts"; |
| 81 | import { assertMusePermissionOutput } from "./muse_permission/output.ts"; |
| 82 | import { museSubagentApprovalInput } from "./muse_subagent_approval/input.ts"; |
| 83 | import { assertMuseSubagentApprovalOutput } from "./muse_subagent_approval/output.ts"; |
| 84 | import { museSubagentInterruptInput } from "./muse_subagent_interrupt/input.ts"; |
| 85 | import { assertMuseSubagentInterruptOutput } from "./muse_subagent_interrupt/output.ts"; |
| 86 | import { museWorkflowInput } from "./muse_workflow/input.ts"; |
| 87 | import { assertMuseWorkflowOutput } from "./muse_workflow/output.ts"; |
| 88 | import { assertMuseSubagentV2Output } from "./subagent_v2/muse_output.ts"; |
| 89 | import { assertMuseMultiTurnOutput } from "./multi_turn/muse_output.ts"; |
| 90 | import { assertMuseTurnInterruptOutput } from "./turn_interrupt/muse_output.ts"; |
| 91 | import { piCompactionInput } from "./pi_compaction/input.ts"; |
| 92 | import { assertPiCompactionOutput } from "./pi_compaction/output.ts"; |
| 93 | import { providerThreadResumeInput } from "./provider_thread_resume/input.ts"; |
| 94 | import { assertPiProviderThreadResumeOutput } from "./provider_thread_resume/pi_output.ts"; |
| 95 | import { assertMultiTurnClaudeOutput } from "./multi_turn/claude_output.ts"; |
| 96 | import { assertMultiTurnOutput } from "./multi_turn/codex_output.ts"; |
| 97 | import { assertPiMultiTurnOutput } from "./multi_turn/pi_output.ts"; |
| 98 | import { multiTurnInput } from "./multi_turn/input.ts"; |
| 99 | import { openCodeChildApprovalInput } from "./opencode_child_approval/input.ts"; |
| 100 | import { assertOpenCodeChildApprovalOutput } from "./opencode_child_approval/output.ts"; |
| 101 | import { openCodeRunningChildApprovalInput } from "./opencode_running_child_approval/input.ts"; |
| 102 | import { assertOpenCodeRunningChildApprovalOutput } from "./opencode_running_child_approval/output.ts"; |
| 103 | import { openCodeSubagentInput } from "./opencode_subagent/input.ts"; |
| 104 | import { openCodeBackgroundWakeInput } from "./opencode_background_wake/input.ts"; |
| 105 | import { openCode2InboxInput } from "./opencode2_inbox/input.ts"; |
| 106 | import { openCode2RevertInput } from "./opencode2_revert/input.ts"; |
| 107 | import { assertOpenCode2RevertOutput } from "./opencode2_revert/output.ts"; |
| 108 | import { assertOpenCode2InboxOutput } from "./opencode2_inbox/output.ts"; |
| 109 | import { openCode2CommandInput } from "./opencode2_command/input.ts"; |
| 110 | import { assertOpenCode2CommandOutput } from "./opencode2_command/output.ts"; |
| 111 | import { openCode2CompactionInput } from "./opencode2_compaction/input.ts"; |
| 112 | import { assertOpenCode2CompactionOutput } from "./opencode2_compaction/output.ts"; |
| 113 | import { openCode2InterruptInput } from "./opencode2_interrupt/input.ts"; |
| 114 | import { assertOpenCode2InterruptOutput } from "./opencode2_interrupt/output.ts"; |
| 115 | import { openCode2PermissionInput } from "./opencode2_permission/input.ts"; |
| 116 | import { assertOpenCode2PermissionOutput } from "./opencode2_permission/output.ts"; |
| 117 | import { openCode2QuestionInput } from "./opencode2_question/input.ts"; |
| 118 | import { assertOpenCode2QuestionOutput } from "./opencode2_question/output.ts"; |
| 119 | import { openCode2BackgroundInput } from "./opencode2_background/input.ts"; |
| 120 | import { assertOpenCode2BackgroundOutput } from "./opencode2_background/output.ts"; |
| 121 | import { openCode2NestedBackgroundInput } from "./opencode2_nested_background/input.ts"; |
| 122 | import { assertOpenCode2NestedBackgroundOutput } from "./opencode2_nested_background/output.ts"; |
| 123 | import { openCode2SubagentInput } from "./opencode2_subagent/input.ts"; |
| 124 | import { assertOpenCode2SubagentOutput } from "./opencode2_subagent/output.ts"; |
| 125 | import { openCode2ResumeAfterRestartInput } from "./opencode2_resume_after_restart/input.ts"; |
| 126 | import { assertOpenCode2ResumeAfterRestartOutput } from "./opencode2_resume_after_restart/output.ts"; |
| 127 | import { openCode2SimpleInput } from "./opencode2_simple/input.ts"; |
| 128 | import { openCode2SkillInput } from "./opencode2_skill/input.ts"; |
| 129 | import { assertOpenCode2SkillOutput } from "./opencode2_skill/output.ts"; |
| 130 | import { assertOpenCode2SimpleOutput } from "./opencode2_simple/output.ts"; |
| 131 | import { assertOpenCode2MissingStepUsageOutput } from "./opencode2_missing_step_usage/output.ts"; |
| 132 | import { assertCodexModelRerouteOutput } from "./codex_model_reroute/output.ts"; |
| 133 | import { openCode2ToolCallInput } from "./opencode2_tool_call/input.ts"; |
| 134 | import { assertOpenCode2ToolCallOutput } from "./opencode2_tool_call/output.ts"; |
| 135 | import { assertOpenCodeSubagentOutput } from "./opencode_subagent/output.ts"; |
| 136 | import { assertOpenCodeBackgroundWakeOutput } from "./opencode_background_wake/output.ts"; |
| 137 | import { |
| 138 | assertCodexPlanQuestionsOutput, |
| 139 | assertPlanQuestionsOutput, |
| 140 | } from "./plan_questions/codex_output.ts"; |
| 141 | import { assertOpenCodePlanQuestionsOutput } from "./plan_questions/opencode_output.ts"; |
| 142 | import { planQuestionsInput } from "./plan_questions/input.ts"; |
| 143 | import { acpTitledMultiSelectInput } from "./acp_titled_multiselect/input.ts"; |
| 144 | import { assertAcpTitledMultiSelectOutput } from "./acp_titled_multiselect/output.ts"; |
| 145 | import { assertProposedPlanOutput } from "./proposed_plan/codex_output.ts"; |
| 146 | import { assertProposedPlanCursorOutput } from "./proposed_plan/cursor_output.ts"; |
| 147 | import { proposedPlanInput } from "./proposed_plan/input.ts"; |
| 148 | import { assertQueuedCancelledWhileActiveOutput } from "./queued_cancelled_while_active/codex_output.ts"; |
| 149 | import { queuedCancelledWhileActiveInput } from "./queued_cancelled_while_active/input.ts"; |
| 150 | import { assertQueuedTurnOutput } from "./queued_turn/codex_output.ts"; |
| 151 | import { queuedTurnInput } from "./queued_turn/input.ts"; |
| 152 | import { assertSimpleClaudeOutput } from "./simple/claude_output.ts"; |
| 153 | import { assertSkillInvocationCursorOutput } from "./skill_invocation/cursor_output.ts"; |
| 154 | import { skillInvocationInput } from "./skill_invocation/input.ts"; |
| 155 | import { assertSimpleOutput } from "./simple/codex_output.ts"; |
| 156 | import { assertPiSimpleOutput } from "./simple/pi_output.ts"; |
| 157 | import { simpleInput } from "./simple/input.ts"; |
| 158 | import { malformedSessionUpdateInput } from "./malformed_session_update/input.ts"; |
| 159 | import { assertMalformedSessionUpdateOutput } from "./malformed_session_update/output.ts"; |
| 160 | import { assertSubagentOutput } from "./subagent/codex_output.ts"; |
| 161 | import { assertClaudeSubagentOutput } from "./subagent/claude_output.ts"; |
| 162 | import { subagentInput } from "./subagent/input.ts"; |
| 163 | import { assertCursorSubagentOutput } from "./subagent/cursor_output.ts"; |
| 164 | import { assertKiroSubagentOutput } from "./subagent/kiro_output.ts"; |
| 165 | import { assertSubagentContinueOutput } from "./subagent_continue/codex_output.ts"; |
| 166 | import { subagentContinueInput } from "./subagent_continue/input.ts"; |
| 167 | import { assertSubagentV2Output } from "./subagent_v2/codex_output.ts"; |
| 168 | import { subagentV2Input, subagentV2NestedInput } from "./subagent_v2/input.ts"; |
| 169 | import { assertSubagentV2ApprovalOutput } from "./subagent_v2_approval/codex_output.ts"; |
| 170 | import { |
| 171 | SUBAGENT_V2_APPROVAL_POLICY, |
| 172 | subagentV2ApprovalInput, |
| 173 | } from "./subagent_v2_approval/input.ts"; |
| 174 | import { assertSubagentV2NestedOutput } from "./subagent_v2_nested/codex_output.ts"; |
| 175 | import { assertSubagentV2NestedApprovalOutput } from "./subagent_v2_nested_approval/codex_output.ts"; |
| 176 | import { subagentV2NestedApprovalInput } from "./subagent_v2_nested_approval/input.ts"; |
| 177 | import { assertClaudeThreadRollbackOutput } from "./thread_rollback/claude_output.ts"; |
| 178 | import { assertThreadRollbackOutput } from "./thread_rollback/codex_output.ts"; |
| 179 | import { threadRollbackInput } from "./thread_rollback/input.ts"; |
| 180 | import { assertPiThreadRollbackOutput } from "./thread_rollback/pi_output.ts"; |
| 181 | import { assertThreadRollbackAfterRestartOutput } from "./thread_rollback_after_restart/codex_output.ts"; |
| 182 | import { threadRollbackAfterRestartInput } from "./thread_rollback_after_restart/input.ts"; |
| 183 | import { threadRollbackAfterStopInput } from "./thread_rollback_after_stop/input.ts"; |
| 184 | import { assertPiThreadRollbackAfterStopOutput } from "./thread_rollback_after_stop/pi_output.ts"; |
| 185 | import { assertThreadRollbackToStoppedTurnOutput } from "./thread_rollback_to_stopped_turn/codex_output.ts"; |
| 186 | import { threadRollbackToStoppedTurnInput } from "./thread_rollback_to_stopped_turn/input.ts"; |
| 187 | import { assertTodoListOutput } from "./todo_list/codex_output.ts"; |
| 188 | import { assertTodoListCursorOutput } from "./todo_list/cursor_output.ts"; |
| 189 | import { assertTodoListGrokOutput } from "./todo_list/grok_output.ts"; |
| 190 | import { todoListInput } from "./todo_list/input.ts"; |
| 191 | import { assertToolCallDeniedWriteClaudeOutput } from "./tool_call_denied_write/claude_output.ts"; |
| 192 | import { assertToolCallDeniedWriteFxOutput } from "./tool_call_denied_write/fx_output.ts"; |
| 193 | import { |
| 194 | DENIED_WRITE_POLICY, |
| 195 | TOOL_CALL_DENIED_WRITE_TARGET, |
| 196 | toolCallDeniedWriteInput, |
| 197 | } from "./tool_call_denied_write/input.ts"; |
| 198 | import { assertToolCallReadOnlyClaudeOutput } from "./tool_call_read_only/claude_output.ts"; |
| 199 | import { assertToolCallReadOnlyCursorOutput } from "./tool_call_read_only/cursor_output.ts"; |
| 200 | import { toolCallReadOnlyInput } from "./tool_call_read_only/input.ts"; |
| 201 | import { |
| 202 | assertToolCallReadOnlyOnRequestGrokOutput, |
| 203 | assertToolCallReadOnlyOnRequestKiroOutput, |
| 204 | assertToolCallReadOnlyOnRequestOutput, |
| 205 | } from "./tool_call_read_only_on_request/output.ts"; |
| 206 | import { |
| 207 | toolCallReadOnlyOnRequestInput, |
| 208 | toolCallReadOnlyOnRequestKiroInput, |
| 209 | } from "./tool_call_read_only_on_request/input.ts"; |
| 210 | import { assertToolCallReadOnlyOnRequestFxOutput } from "./tool_call_read_only_on_request/fx_output.ts"; |
| 211 | import { |
| 212 | stopBackgroundWorkAfterFailedTurnInput, |
| 213 | stopBackgroundWorkAfterReleaseInput, |
| 214 | } from "./stop_background_work_after_failed_turn/input.ts"; |
| 215 | import { assertStopBackgroundWorkAfterFailedTurnOutput } from "./stop_background_work_after_failed_turn/output.ts"; |
| 216 | import { assertToolCallRestrictedGranularClaudeOutput } from "./tool_call_restricted_granular/claude_output.ts"; |
| 217 | import { assertToolCallRestrictedGranularOutput } from "./tool_call_restricted_granular/codex_output.ts"; |
| 218 | import { toolCallRestrictedGranularInput } from "./tool_call_restricted_granular/input.ts"; |
| 219 | import { assertToolCallWorkspaceNeverClaudeOutput } from "./tool_call_workspace_never/claude_output.ts"; |
| 220 | import { assertToolCallWorkspaceNeverOutput } from "./tool_call_workspace_never/codex_output.ts"; |
| 221 | import { toolCallWorkspaceNeverInput } from "./tool_call_workspace_never/input.ts"; |
| 222 | import { assertTurnInterruptClaudeOutput } from "./turn_interrupt/claude_output.ts"; |
| 223 | import { assertCommandOutputStreamingOutput } from "./command_output_streaming/output.ts"; |
| 224 | import { commandOutputStreamingInput } from "./command_output_streaming/input.ts"; |
| 225 | import { assertTurnInterruptOutput } from "./turn_interrupt/codex_output.ts"; |
| 226 | import { turnInterruptInput } from "./turn_interrupt/input.ts"; |
| 227 | import { fxEarlyStopInput } from "./fx_early_stop/input.ts"; |
| 228 | import { assertFxEarlyStopOutput } from "./fx_early_stop/fx_output.ts"; |
| 229 | import { fxSubagentInput } from "./fx_subagent/input.ts"; |
| 230 | import { assertFxSubagentOutput } from "./fx_subagent/fx_output.ts"; |
| 231 | import { fxSubagentStopInput } from "./fx_subagent_stop/input.ts"; |
| 232 | import { assertFxSubagentStopOutput } from "./fx_subagent_stop/fx_output.ts"; |
| 233 | import { assertTurnInterruptMidToolClaudeOutput } from "./turn_interrupt_mid_tool/claude_output.ts"; |
| 234 | import { assertTurnInterruptMidToolCodexOutput } from "./turn_interrupt_mid_tool/codex_output.ts"; |
| 235 | import { assertTurnInterruptMidToolCursorOutput } from "./turn_interrupt_mid_tool/cursor_output.ts"; |
| 236 | import { assertTurnInterruptMidToolFxOutput } from "./turn_interrupt_mid_tool/fx_output.ts"; |
| 237 | import { |
| 238 | turnInterruptMidToolInput, |
| 239 | turnInterruptMidToolKiroInput, |
| 240 | } from "./turn_interrupt_mid_tool/input.ts"; |
| 241 | import { assertTurnInterruptMidToolKiroOutput } from "./turn_interrupt_mid_tool/kiro_output.ts"; |
| 242 | import { assertTurnInterruptMidToolPiOutput } from "./turn_interrupt_mid_tool/pi_output.ts"; |
| 243 | import { assertTurnInterruptRestartClaudeOutput } from "./turn_interrupt_restart/claude_output.ts"; |
| 244 | import { turnInterruptRestartInput } from "./turn_interrupt_restart/input.ts"; |
| 245 | import { assertClaudeWebSearchOutput } from "./web_search/claude_output.ts"; |
| 246 | import { assertWebSearchOutput } from "./web_search/codex_output.ts"; |
| 247 | import { webSearchInput } from "./web_search/input.ts"; |
| 248 | import { |
| 249 | ACP_REGISTRY_MODEL_SELECTION, |
| 250 | CLAUDE_MODEL_SELECTION, |
| 251 | CODEX_MODEL_SELECTION, |
| 252 | CURSOR_MODEL_SELECTION, |
| 253 | FX_MODEL_SELECTION, |
| 254 | GROK_MODEL_SELECTION, |
| 255 | KIRO_MODEL_SELECTION, |
| 256 | MUSE_MODEL_SELECTION, |
| 257 | OPENCODE_MODEL_SELECTION, |
| 258 | OPENCODE2_MODEL_SELECTION, |
| 259 | PI_MODEL_SELECTION, |
| 260 | READ_ONLY_NEVER_POLICY, |
| 261 | READ_ONLY_ON_REQUEST_POLICY, |
| 262 | RESTRICTED_GRANULAR_POLICY, |
| 263 | type OrchestratorReplayFixture, |
| 264 | WORKSPACE_NEVER_POLICY, |
| 265 | } from "./shared.ts"; |
| 266 | |
| 267 | export const ORCHESTRATOR_REPLAY_FIXTURES: ReadonlyArray<OrchestratorReplayFixture> = [ |
| 268 | { |
| 269 | name: "claude_background_subagent_after_root", |
| 270 | buildInput: claudeBackgroundSubagentAfterRootInput, |
| 271 | providers: [ |
| 272 | { |
| 273 | driver: ProviderDriverKind.make("claudeAgent"), |
| 274 | transcriptFile: new URL( |
| 275 | "./claude_background_subagent_after_root/claude_transcript.ndjson", |
| 276 | import.meta.url, |
| 277 | ), |
| 278 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 279 | runContinuationWorker: true, |
| 280 | assertOutput: assertClaudeBackgroundSubagentAfterRootOutput, |
| 281 | }, |
| 282 | ], |
| 283 | }, |
| 284 | { |
| 285 | name: "claude_background_task_after_root", |
| 286 | buildInput: claudeBackgroundTaskAfterRootInput, |
| 287 | providers: [ |
| 288 | { |
| 289 | driver: ProviderDriverKind.make("claudeAgent"), |
| 290 | transcriptFile: new URL( |
| 291 | "./claude_background_task_after_root/claude_transcript.ndjson", |
| 292 | import.meta.url, |
| 293 | ), |
| 294 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 295 | runContinuationWorker: true, |
| 296 | assertOutput: assertClaudeBackgroundTaskAfterRootOutput, |
| 297 | }, |
| 298 | ], |
| 299 | }, |
| 300 | { |
| 301 | name: "claude_background_subagent_lifecycle", |
| 302 | buildInput: claudeBackgroundSubagentLifecycleInput, |
| 303 | providers: [ |
| 304 | { |
| 305 | driver: ProviderDriverKind.make("claudeAgent"), |
| 306 | transcriptFile: new URL( |
| 307 | "./claude_background_subagent_lifecycle/claude_transcript.ndjson", |
| 308 | import.meta.url, |
| 309 | ), |
| 310 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 311 | runContinuationWorker: true, |
| 312 | assertOutput: assertClaudeBackgroundSubagentLifecycleOutput, |
| 313 | }, |
| 314 | ], |
| 315 | }, |
| 316 | { |
| 317 | name: "claude_background_task_interrupt", |
| 318 | buildInput: claudeBackgroundTaskInterruptInput, |
| 319 | providers: [ |
| 320 | { |
| 321 | driver: ProviderDriverKind.make("claudeAgent"), |
| 322 | transcriptFile: new URL( |
| 323 | "./claude_background_task_interrupt/claude_transcript.ndjson", |
| 324 | import.meta.url, |
| 325 | ), |
| 326 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 327 | runContinuationWorker: true, |
| 328 | assertOutput: assertClaudeBackgroundTaskInterruptOutput, |
| 329 | }, |
| 330 | ], |
| 331 | }, |
| 332 | { |
| 333 | name: "claude_background_wake_before_queued_prompt", |
| 334 | buildInput: claudeBackgroundWakeBeforeQueuedPromptInput, |
| 335 | providers: [ |
| 336 | { |
| 337 | driver: ProviderDriverKind.make("claudeAgent"), |
| 338 | transcriptFile: new URL( |
| 339 | "./claude_background_wake_before_queued_prompt/claude_transcript.ndjson", |
| 340 | import.meta.url, |
| 341 | ), |
| 342 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 343 | runContinuationWorker: true, |
| 344 | assertOutput: assertClaudeBackgroundWakeBeforeQueuedPromptOutput, |
| 345 | }, |
| 346 | ], |
| 347 | }, |
| 348 | { |
| 349 | name: "claude_background_wake_before_queued_prompt_no_echo", |
| 350 | buildInput: claudeBackgroundWakeBeforeQueuedPromptNoEchoInput, |
| 351 | providers: [ |
| 352 | { |
| 353 | driver: ProviderDriverKind.make("claudeAgent"), |
| 354 | transcriptFile: new URL( |
| 355 | "./claude_background_wake_before_queued_prompt_no_echo/claude_transcript.ndjson", |
| 356 | import.meta.url, |
| 357 | ), |
| 358 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 359 | runContinuationWorker: true, |
| 360 | assertOutput: assertClaudeBackgroundWakeBeforeQueuedPromptNoEchoOutput, |
| 361 | }, |
| 362 | ], |
| 363 | }, |
| 364 | { |
| 365 | name: "claude_compact_after_resume_wake", |
| 366 | buildInput: claudeCompactAfterResumeWakeInput, |
| 367 | providers: [ |
| 368 | { |
| 369 | driver: ProviderDriverKind.make("claudeAgent"), |
| 370 | transcriptFile: new URL( |
| 371 | "./claude_compact_after_resume_wake/claude_transcript.ndjson", |
| 372 | import.meta.url, |
| 373 | ), |
| 374 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 375 | runContinuationWorker: true, |
| 376 | assertOutput: assertClaudeCompactAfterResumeWakeOutput, |
| 377 | }, |
| 378 | ], |
| 379 | }, |
| 380 | { |
| 381 | name: "claude_compact_after_peer_turn", |
| 382 | buildInput: claudeCompactAfterPeerTurnInput, |
| 383 | providers: [ |
| 384 | { |
| 385 | driver: ProviderDriverKind.make("claudeAgent"), |
| 386 | transcriptFile: new URL( |
| 387 | "./claude_compact_after_peer_turn/claude_transcript.ndjson", |
| 388 | import.meta.url, |
| 389 | ), |
| 390 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 391 | runContinuationWorker: true, |
| 392 | assertOutput: assertClaudeCompactAfterPeerTurnOutput, |
| 393 | }, |
| 394 | ], |
| 395 | }, |
| 396 | { |
| 397 | name: "claude_compact_after_peer_turn_no_echo", |
| 398 | buildInput: claudeCompactAfterPeerTurnNoEchoInput, |
| 399 | providers: [ |
| 400 | { |
| 401 | driver: ProviderDriverKind.make("claudeAgent"), |
| 402 | transcriptFile: new URL( |
| 403 | "./claude_compact_after_peer_turn_no_echo/claude_transcript.ndjson", |
| 404 | import.meta.url, |
| 405 | ), |
| 406 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 407 | runContinuationWorker: true, |
| 408 | assertOutput: assertClaudeCompactAfterPeerTurnNoEchoOutput, |
| 409 | }, |
| 410 | ], |
| 411 | }, |
| 412 | { |
| 413 | name: "claude_background_monitor_wake", |
| 414 | buildInput: claudeBackgroundMonitorWakeInput, |
| 415 | providers: [ |
| 416 | { |
| 417 | driver: ProviderDriverKind.make("claudeAgent"), |
| 418 | transcriptFile: new URL( |
| 419 | "./claude_background_monitor_wake/claude_transcript.ndjson", |
| 420 | import.meta.url, |
| 421 | ), |
| 422 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 423 | runContinuationWorker: true, |
| 424 | assertOutput: assertClaudeBackgroundMonitorWakeOutput, |
| 425 | }, |
| 426 | ], |
| 427 | }, |
| 428 | { |
| 429 | name: "claude_background_task_wake", |
| 430 | buildInput: claudeBackgroundTaskWakeInput, |
| 431 | providers: [ |
| 432 | { |
| 433 | driver: ProviderDriverKind.make("claudeAgent"), |
| 434 | transcriptFile: new URL( |
| 435 | "./claude_background_task_wake/claude_transcript.ndjson", |
| 436 | import.meta.url, |
| 437 | ), |
| 438 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 439 | runContinuationWorker: true, |
| 440 | assertOutput: assertClaudeBackgroundTaskWakeOutput, |
| 441 | }, |
| 442 | ], |
| 443 | }, |
| 444 | { |
| 445 | name: "claude_local_bash_task", |
| 446 | buildInput: claudeLocalBashTaskInput, |
| 447 | providers: [ |
| 448 | { |
| 449 | driver: ProviderDriverKind.make("claudeAgent"), |
| 450 | transcriptFile: new URL( |
| 451 | "./claude_local_bash_task/claude_transcript.ndjson", |
| 452 | import.meta.url, |
| 453 | ), |
| 454 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 455 | assertOutput: assertClaudeLocalBashTaskOutput, |
| 456 | }, |
| 457 | ], |
| 458 | }, |
| 459 | { |
| 460 | name: "claude_nested_background_subagent_wake", |
| 461 | buildInput: claudeNestedBackgroundSubagentWakeInput, |
| 462 | providers: [ |
| 463 | { |
| 464 | driver: ProviderDriverKind.make("claudeAgent"), |
| 465 | transcriptFile: new URL( |
| 466 | "./claude_nested_background_subagent_wake/claude_transcript.ndjson", |
| 467 | import.meta.url, |
| 468 | ), |
| 469 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 470 | runContinuationWorker: true, |
| 471 | assertOutput: assertClaudeNestedBackgroundSubagentWakeOutput, |
| 472 | }, |
| 473 | ], |
| 474 | }, |
| 475 | { |
| 476 | name: "claude_nested_subagent_model", |
| 477 | buildInput: claudeNestedSubagentModelInput, |
| 478 | providers: [ |
| 479 | { |
| 480 | driver: ProviderDriverKind.make("claudeAgent"), |
| 481 | transcriptFile: new URL( |
| 482 | "./claude_nested_subagent_model/claude_transcript.ndjson", |
| 483 | import.meta.url, |
| 484 | ), |
| 485 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 486 | assertOutput: assertClaudeNestedSubagentModelOutput, |
| 487 | }, |
| 488 | ], |
| 489 | }, |
| 490 | { |
| 491 | name: "claude_mcp_tool_presentation", |
| 492 | buildInput: claudeMcpToolPresentationInput, |
| 493 | providers: [ |
| 494 | { |
| 495 | driver: ProviderDriverKind.make("claudeAgent"), |
| 496 | transcriptFile: new URL( |
| 497 | "./claude_mcp_tool_presentation/claude_transcript.ndjson", |
| 498 | import.meta.url, |
| 499 | ), |
| 500 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 501 | assertOutput: assertClaudeMcpToolPresentationOutput, |
| 502 | }, |
| 503 | ], |
| 504 | }, |
| 505 | { |
| 506 | name: "claude_idle_resume", |
| 507 | buildInput: claudeIdleResumeInput, |
| 508 | providers: [ |
| 509 | { |
| 510 | driver: ProviderDriverKind.make("claudeAgent"), |
| 511 | transcriptFile: new URL("./claude_idle_resume/claude_transcript.ndjson", import.meta.url), |
| 512 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 513 | assertOutput: assertClaudeIdleResumeOutput, |
| 514 | }, |
| 515 | ], |
| 516 | }, |
| 517 | { |
| 518 | name: "usage_limit", |
| 519 | buildInput: simpleInput, |
| 520 | providers: [ |
| 521 | { |
| 522 | driver: ProviderDriverKind.make("claudeAgent"), |
| 523 | transcriptFile: new URL("./usage_limit/claude_transcript.ndjson", import.meta.url), |
| 524 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 525 | assertOutput: assertClaudeUsageLimitOutput, |
| 526 | }, |
| 527 | ], |
| 528 | }, |
| 529 | { |
| 530 | name: "claude_result_is_error", |
| 531 | buildInput: claudeResultIsErrorInput, |
| 532 | providers: [ |
| 533 | { |
| 534 | driver: ProviderDriverKind.make("claudeAgent"), |
| 535 | transcriptFile: new URL( |
| 536 | "./claude_result_is_error/claude_transcript.ndjson", |
| 537 | import.meta.url, |
| 538 | ), |
| 539 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 540 | assertOutput: assertClaudeResultIsErrorOutput, |
| 541 | }, |
| 542 | ], |
| 543 | }, |
| 544 | { |
| 545 | name: "grok_auto_blocked_command", |
| 546 | buildInput: grokAutoBlockedCommandInput, |
| 547 | providers: [ |
| 548 | { |
| 549 | driver: ProviderDriverKind.make("grok"), |
| 550 | transcriptFile: new URL( |
| 551 | "./grok_auto_blocked_command/grok_transcript.ndjson", |
| 552 | import.meta.url, |
| 553 | ), |
| 554 | modelSelection: { ...GROK_MODEL_SELECTION, model: "grok-4.7-build-fast" }, |
| 555 | assertOutput: assertGrokAutoBlockedCommandOutput, |
| 556 | }, |
| 557 | ], |
| 558 | }, |
| 559 | { |
| 560 | name: "kiro_tool_call_read_only_on_request", |
| 561 | buildInput: toolCallReadOnlyOnRequestKiroInput, |
| 562 | providers: [ |
| 563 | { |
| 564 | driver: ProviderDriverKind.make("kiro"), |
| 565 | transcriptFile: new URL( |
| 566 | "./tool_call_read_only_on_request/kiro_transcript.ndjson", |
| 567 | import.meta.url, |
| 568 | ), |
| 569 | modelSelection: KIRO_MODEL_SELECTION, |
| 570 | runtimePolicyOverride: READ_ONLY_ON_REQUEST_POLICY, |
| 571 | assertOutput: assertToolCallReadOnlyOnRequestKiroOutput, |
| 572 | }, |
| 573 | ], |
| 574 | }, |
| 575 | { |
| 576 | name: "kiro_message_steering", |
| 577 | buildInput: kiroMessageSteeringInput, |
| 578 | providers: [ |
| 579 | { |
| 580 | driver: ProviderDriverKind.make("kiro"), |
| 581 | transcriptFile: new URL("./kiro_message_steering/kiro_transcript.ndjson", import.meta.url), |
| 582 | modelSelection: KIRO_MODEL_SELECTION, |
| 583 | assertOutput: assertKiroMessageSteeringOutput, |
| 584 | }, |
| 585 | ], |
| 586 | }, |
| 587 | { |
| 588 | name: "kiro_fork_from_turn", |
| 589 | buildInput: kiroForkFromTurnInput, |
| 590 | providers: [ |
| 591 | { |
| 592 | driver: ProviderDriverKind.make("kiro"), |
| 593 | transcriptFile: new URL("./kiro_fork_from_turn/kiro_transcript.ndjson", import.meta.url), |
| 594 | modelSelection: KIRO_MODEL_SELECTION, |
| 595 | assertOutput: assertKiroForkFromTurnOutput, |
| 596 | }, |
| 597 | ], |
| 598 | }, |
| 599 | { |
| 600 | name: "kiro_compaction", |
| 601 | buildInput: kiroCompactionInput, |
| 602 | providers: [ |
| 603 | { |
| 604 | driver: ProviderDriverKind.make("kiro"), |
| 605 | transcriptFile: new URL("./kiro_compaction/kiro_transcript.ndjson", import.meta.url), |
| 606 | modelSelection: KIRO_MODEL_SELECTION, |
| 607 | assertOutput: assertKiroCompactionOutput, |
| 608 | }, |
| 609 | ], |
| 610 | }, |
| 611 | { |
| 612 | name: "kiro_model_switch", |
| 613 | buildInput: kiroModelSwitchInput, |
| 614 | providers: [ |
| 615 | { |
| 616 | driver: ProviderDriverKind.make("kiro"), |
| 617 | transcriptFile: new URL("./kiro_model_switch/kiro_transcript.ndjson", import.meta.url), |
| 618 | modelSelection: KIRO_MODEL_SELECTION, |
| 619 | assertOutput: assertKiroModelSwitchOutput, |
| 620 | }, |
| 621 | ], |
| 622 | }, |
| 623 | { |
| 624 | name: "kiro_effort", |
| 625 | buildInput: kiroEffortInput, |
| 626 | providers: [ |
| 627 | { |
| 628 | driver: ProviderDriverKind.make("kiro"), |
| 629 | transcriptFile: new URL("./kiro_effort/kiro_transcript.ndjson", import.meta.url), |
| 630 | modelSelection: { |
| 631 | ...KIRO_MODEL_SELECTION, |
| 632 | model: KIRO_EFFORT_MODEL, |
| 633 | options: [{ id: "reasoningEffort", value: KIRO_EFFORT_LEVEL }], |
| 634 | }, |
| 635 | assertOutput: assertKiroEffortOutput, |
| 636 | }, |
| 637 | ], |
| 638 | }, |
| 639 | { |
| 640 | name: "kiro_cloud_config", |
| 641 | buildInput: turnInterruptInput, |
| 642 | providers: [ |
| 643 | { |
| 644 | driver: ProviderDriverKind.make("kiro"), |
| 645 | transcriptFile: new URL("./kiro_cloud_config/kiro_transcript.ndjson", import.meta.url), |
| 646 | modelSelection: KIRO_MODEL_SELECTION, |
| 647 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 648 | assertOutput: assertTurnInterruptOutput, |
| 649 | }, |
| 650 | ], |
| 651 | }, |
| 652 | { |
| 653 | name: "kiro_supervised_write", |
| 654 | buildInput: kiroSupervisedWriteInput, |
| 655 | providers: [ |
| 656 | { |
| 657 | driver: ProviderDriverKind.make("kiro"), |
| 658 | transcriptFile: new URL( |
| 659 | "./kiro_permission_modes/kiro_supervised_transcript.ndjson", |
| 660 | import.meta.url, |
| 661 | ), |
| 662 | modelSelection: KIRO_MODEL_SELECTION, |
| 663 | assertOutput: assertKiroSupervisedWriteOutput, |
| 664 | }, |
| 665 | ], |
| 666 | }, |
| 667 | { |
| 668 | name: "kiro_full_access_write", |
| 669 | buildInput: kiroFullAccessWriteInput, |
| 670 | providers: [ |
| 671 | { |
| 672 | driver: ProviderDriverKind.make("kiro"), |
| 673 | transcriptFile: new URL( |
| 674 | "./kiro_permission_modes/kiro_full_access_transcript.ndjson", |
| 675 | import.meta.url, |
| 676 | ), |
| 677 | modelSelection: KIRO_MODEL_SELECTION, |
| 678 | assertOutput: assertKiroFullAccessWriteOutput, |
| 679 | }, |
| 680 | ], |
| 681 | }, |
| 682 | { |
| 683 | name: "kiro_subagent_interrupt", |
| 684 | buildInput: kiroSubagentInterruptInput, |
| 685 | providers: [ |
| 686 | { |
| 687 | driver: ProviderDriverKind.make("kiro"), |
| 688 | transcriptFile: new URL( |
| 689 | "./kiro_subagent_interrupt/kiro_transcript.ndjson", |
| 690 | import.meta.url, |
| 691 | ), |
| 692 | modelSelection: KIRO_MODEL_SELECTION, |
| 693 | assertOutput: assertKiroSubagentInterruptOutput, |
| 694 | }, |
| 695 | ], |
| 696 | }, |
| 697 | { |
| 698 | name: "grok_background_bash", |
| 699 | buildInput: grokBackgroundBashInput, |
| 700 | providers: [ |
| 701 | { |
| 702 | driver: ProviderDriverKind.make("grok"), |
| 703 | transcriptFile: new URL("./grok_background_bash/grok_transcript.ndjson", import.meta.url), |
| 704 | modelSelection: { ...GROK_MODEL_SELECTION, model: "grok-4.7-build-fast" }, |
| 705 | runContinuationWorker: true, |
| 706 | assertOutput: assertGrokBackgroundBashOutput, |
| 707 | }, |
| 708 | ], |
| 709 | }, |
| 710 | { |
| 711 | name: "grok_background_bash_fast_wake", |
| 712 | buildInput: grokBackgroundBashFastWakeInput, |
| 713 | providers: [ |
| 714 | { |
| 715 | driver: ProviderDriverKind.make("grok"), |
| 716 | transcriptFile: new URL( |
| 717 | "./grok_background_bash_fast_wake/grok_transcript.ndjson", |
| 718 | import.meta.url, |
| 719 | ), |
| 720 | modelSelection: { ...GROK_MODEL_SELECTION, model: "grok-4.7-build-fast" }, |
| 721 | runContinuationWorker: true, |
| 722 | assertOutput: assertGrokBackgroundBashFastWakeOutput, |
| 723 | }, |
| 724 | ], |
| 725 | }, |
| 726 | { |
| 727 | name: "grok_background_subagent", |
| 728 | buildInput: grokBackgroundSubagentInput, |
| 729 | providers: [ |
| 730 | { |
| 731 | driver: ProviderDriverKind.make("grok"), |
| 732 | transcriptFile: new URL( |
| 733 | "./grok_background_subagent/grok_transcript.ndjson", |
| 734 | import.meta.url, |
| 735 | ), |
| 736 | modelSelection: GROK_MODEL_SELECTION, |
| 737 | runContinuationWorker: true, |
| 738 | assertOutput: assertGrokBackgroundSubagentOutput, |
| 739 | }, |
| 740 | ], |
| 741 | }, |
| 742 | { |
| 743 | name: "grok_monitor", |
| 744 | buildInput: grokMonitorInput, |
| 745 | providers: [ |
| 746 | { |
| 747 | driver: ProviderDriverKind.make("grok"), |
| 748 | transcriptFile: new URL("./grok_monitor/grok_transcript.ndjson", import.meta.url), |
| 749 | modelSelection: GROK_MODEL_SELECTION, |
| 750 | runContinuationWorker: true, |
| 751 | assertOutput: assertGrokMonitorOutput, |
| 752 | }, |
| 753 | ], |
| 754 | }, |
| 755 | { |
| 756 | name: "grok_prompt_error", |
| 757 | buildInput: grokPromptErrorInput, |
| 758 | providers: [ |
| 759 | { |
| 760 | driver: ProviderDriverKind.make("grok"), |
| 761 | transcriptFile: new URL("./grok_prompt_error/grok_transcript.ndjson", import.meta.url), |
| 762 | modelSelection: GROK_MODEL_SELECTION, |
| 763 | assertOutput: assertGrokPromptErrorOutput, |
| 764 | }, |
| 765 | ], |
| 766 | }, |
| 767 | { |
| 768 | name: "grok_subagent_lineage", |
| 769 | buildInput: grokSubagentLineageInput, |
| 770 | providers: [ |
| 771 | { |
| 772 | driver: ProviderDriverKind.make("grok"), |
| 773 | transcriptFile: new URL("./grok_subagent_lineage/grok_transcript.ndjson", import.meta.url), |
| 774 | modelSelection: { |
| 775 | ...GROK_MODEL_SELECTION, |
| 776 | model: "grok-composer-2.5-fast", |
| 777 | }, |
| 778 | assertOutput: assertGrokSubagentLineageOutput, |
| 779 | }, |
| 780 | ], |
| 781 | }, |
| 782 | { |
| 783 | name: "acp_elicitation", |
| 784 | buildInput: planQuestionsInput, |
| 785 | providers: [ |
| 786 | // Grok Build uses removed session/elicitation; cover the registry driver until it supports standard elicitation/create. |
| 787 | { |
| 788 | driver: ProviderDriverKind.make("acpRegistry"), |
| 789 | transcriptFile: new URL("./acp_elicitation/registry_transcript.ndjson", import.meta.url), |
| 790 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 791 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 792 | assertOutput: assertPlanQuestionsOutput, |
| 793 | }, |
| 794 | ], |
| 795 | }, |
| 796 | { |
| 797 | name: "malformed_session_update", |
| 798 | buildInput: malformedSessionUpdateInput, |
| 799 | providers: [ |
| 800 | { |
| 801 | driver: ProviderDriverKind.make("acpRegistry"), |
| 802 | transcriptFile: new URL( |
| 803 | "./malformed_session_update/registry_transcript.ndjson", |
| 804 | import.meta.url, |
| 805 | ), |
| 806 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 807 | assertOutput: assertMalformedSessionUpdateOutput, |
| 808 | }, |
| 809 | ], |
| 810 | }, |
| 811 | { |
| 812 | name: "acp_titled_multiselect", |
| 813 | buildInput: acpTitledMultiSelectInput, |
| 814 | providers: [ |
| 815 | { |
| 816 | driver: ProviderDriverKind.make("acpRegistry"), |
| 817 | transcriptFile: new URL( |
| 818 | "./acp_titled_multiselect/registry_transcript.ndjson", |
| 819 | import.meta.url, |
| 820 | ), |
| 821 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 822 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 823 | assertOutput: assertAcpTitledMultiSelectOutput, |
| 824 | }, |
| 825 | ], |
| 826 | }, |
| 827 | { |
| 828 | name: "simple", |
| 829 | buildInput: simpleInput, |
| 830 | providers: [ |
| 831 | { |
| 832 | driver: ProviderDriverKind.make("codex"), |
| 833 | transcriptFile: new URL("./simple/codex_transcript.ndjson", import.meta.url), |
| 834 | modelSelection: CODEX_MODEL_SELECTION, |
| 835 | assertOutput: assertSimpleOutput, |
| 836 | }, |
| 837 | { |
| 838 | driver: ProviderDriverKind.make("claudeAgent"), |
| 839 | transcriptFile: new URL("./simple/claude_transcript.ndjson", import.meta.url), |
| 840 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 841 | assertOutput: assertSimpleClaudeOutput, |
| 842 | }, |
| 843 | { |
| 844 | driver: ProviderDriverKind.make("cursor"), |
| 845 | transcriptFile: new URL("./simple/cursor_transcript.ndjson", import.meta.url), |
| 846 | modelSelection: CURSOR_MODEL_SELECTION, |
| 847 | assertOutput: assertSimpleOutput, |
| 848 | }, |
| 849 | { |
| 850 | driver: ProviderDriverKind.make("grok"), |
| 851 | transcriptFile: new URL("./simple/grok_transcript.ndjson", import.meta.url), |
| 852 | modelSelection: GROK_MODEL_SELECTION, |
| 853 | assertOutput: assertSimpleOutput, |
| 854 | }, |
| 855 | { |
| 856 | driver: ProviderDriverKind.make("fx"), |
| 857 | transcriptFile: new URL("./simple/fx_transcript.ndjson", import.meta.url), |
| 858 | modelSelection: FX_MODEL_SELECTION, |
| 859 | assertOutput: assertSimpleOutput, |
| 860 | }, |
| 861 | { |
| 862 | driver: ProviderDriverKind.make("kiro"), |
| 863 | transcriptFile: new URL("./simple/kiro_transcript.ndjson", import.meta.url), |
| 864 | modelSelection: KIRO_MODEL_SELECTION, |
| 865 | assertOutput: assertSimpleOutput, |
| 866 | }, |
| 867 | { |
| 868 | driver: ProviderDriverKind.make("acpRegistry"), |
| 869 | transcriptFile: new URL("./simple/registry_transcript.ndjson", import.meta.url), |
| 870 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 871 | assertOutput: assertSimpleOutput, |
| 872 | }, |
| 873 | { |
| 874 | driver: ProviderDriverKind.make("opencode"), |
| 875 | transcriptFile: new URL("./simple/opencode_transcript.ndjson", import.meta.url), |
| 876 | modelSelection: OPENCODE_MODEL_SELECTION, |
| 877 | assertOutput: assertSimpleOutput, |
| 878 | }, |
| 879 | { |
| 880 | driver: ProviderDriverKind.make("pi"), |
| 881 | transcriptFile: new URL("./simple/pi_transcript.ndjson", import.meta.url), |
| 882 | modelSelection: PI_MODEL_SELECTION, |
| 883 | assertOutput: assertPiSimpleOutput, |
| 884 | }, |
| 885 | { |
| 886 | driver: ProviderDriverKind.make("muse"), |
| 887 | transcriptFile: new URL("./simple/muse_transcript.ndjson", import.meta.url), |
| 888 | modelSelection: MUSE_MODEL_SELECTION, |
| 889 | assertOutput: assertSimpleOutput, |
| 890 | }, |
| 891 | ], |
| 892 | }, |
| 893 | { |
| 894 | name: "skill_invocation", |
| 895 | buildInput: skillInvocationInput, |
| 896 | providers: [ |
| 897 | { |
| 898 | driver: ProviderDriverKind.make("cursor"), |
| 899 | transcriptFile: new URL("./skill_invocation/cursor_transcript.ndjson", import.meta.url), |
| 900 | modelSelection: CURSOR_MODEL_SELECTION, |
| 901 | assertOutput: assertSkillInvocationCursorOutput, |
| 902 | }, |
| 903 | ], |
| 904 | }, |
| 905 | { |
| 906 | name: "tool_call_denied_write", |
| 907 | buildInput: toolCallDeniedWriteInput, |
| 908 | providers: [ |
| 909 | { |
| 910 | driver: ProviderDriverKind.make("claudeAgent"), |
| 911 | transcriptFile: new URL( |
| 912 | "./tool_call_denied_write/claude_transcript.ndjson", |
| 913 | import.meta.url, |
| 914 | ), |
| 915 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 916 | runtimePolicyOverride: DENIED_WRITE_POLICY, |
| 917 | expectedAbsentWorkspacePaths: [TOOL_CALL_DENIED_WRITE_TARGET], |
| 918 | assertOutput: assertToolCallDeniedWriteClaudeOutput, |
| 919 | }, |
| 920 | { |
| 921 | driver: ProviderDriverKind.make("fx"), |
| 922 | transcriptFile: new URL("./tool_call_denied_write/fx_transcript.ndjson", import.meta.url), |
| 923 | modelSelection: FX_MODEL_SELECTION, |
| 924 | runtimePolicyOverride: DENIED_WRITE_POLICY, |
| 925 | expectedAbsentWorkspacePaths: [TOOL_CALL_DENIED_WRITE_TARGET], |
| 926 | assertOutput: assertToolCallDeniedWriteFxOutput, |
| 927 | }, |
| 928 | ], |
| 929 | }, |
| 930 | { |
| 931 | name: "tool_call_read_only", |
| 932 | buildInput: toolCallReadOnlyInput, |
| 933 | providers: [ |
| 934 | { |
| 935 | driver: ProviderDriverKind.make("claudeAgent"), |
| 936 | transcriptFile: new URL("./tool_call_read_only/claude_transcript.ndjson", import.meta.url), |
| 937 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 938 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 939 | assertOutput: assertToolCallReadOnlyClaudeOutput, |
| 940 | }, |
| 941 | { |
| 942 | driver: ProviderDriverKind.make("cursor"), |
| 943 | transcriptFile: new URL("./tool_call_read_only/cursor_transcript.ndjson", import.meta.url), |
| 944 | modelSelection: CURSOR_MODEL_SELECTION, |
| 945 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 946 | assertOutput: assertToolCallReadOnlyCursorOutput, |
| 947 | }, |
| 948 | { |
| 949 | driver: ProviderDriverKind.make("grok"), |
| 950 | transcriptFile: new URL("./tool_call_read_only/grok_transcript.ndjson", import.meta.url), |
| 951 | modelSelection: GROK_MODEL_SELECTION, |
| 952 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 953 | assertOutput: assertToolCallReadOnlyCursorOutput, |
| 954 | }, |
| 955 | { |
| 956 | driver: ProviderDriverKind.make("acpRegistry"), |
| 957 | transcriptFile: new URL( |
| 958 | "./tool_call_read_only/registry_transcript.ndjson", |
| 959 | import.meta.url, |
| 960 | ), |
| 961 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 962 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 963 | assertOutput: assertToolCallReadOnlyCursorOutput, |
| 964 | }, |
| 965 | ], |
| 966 | }, |
| 967 | { |
| 968 | name: "tool_call_read_only_on_request", |
| 969 | buildInput: toolCallReadOnlyOnRequestInput, |
| 970 | providers: [ |
| 971 | { |
| 972 | driver: ProviderDriverKind.make("codex"), |
| 973 | transcriptFile: new URL( |
| 974 | "./tool_call_read_only_on_request/codex_transcript.ndjson", |
| 975 | import.meta.url, |
| 976 | ), |
| 977 | // gpt-6-luna declines the write under a read-only sandbox, so nothing asks for approval. |
| 978 | modelSelection: { ...CODEX_MODEL_SELECTION, model: "gpt-6-sol" }, |
| 979 | runtimePolicyOverride: READ_ONLY_ON_REQUEST_POLICY, |
| 980 | assertOutput: assertToolCallReadOnlyOnRequestOutput, |
| 981 | }, |
| 982 | { |
| 983 | driver: ProviderDriverKind.make("claudeAgent"), |
| 984 | transcriptFile: new URL( |
| 985 | "./tool_call_read_only_on_request/claude_transcript.ndjson", |
| 986 | import.meta.url, |
| 987 | ), |
| 988 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 989 | runtimePolicyOverride: READ_ONLY_ON_REQUEST_POLICY, |
| 990 | assertOutput: assertToolCallReadOnlyOnRequestOutput, |
| 991 | }, |
| 992 | { |
| 993 | driver: ProviderDriverKind.make("grok"), |
| 994 | transcriptFile: new URL( |
| 995 | "./tool_call_read_only_on_request/grok_transcript.ndjson", |
| 996 | import.meta.url, |
| 997 | ), |
| 998 | modelSelection: GROK_MODEL_SELECTION, |
| 999 | runtimePolicyOverride: READ_ONLY_ON_REQUEST_POLICY, |
| 1000 | assertOutput: assertToolCallReadOnlyOnRequestGrokOutput, |
| 1001 | }, |
| 1002 | { |
| 1003 | driver: ProviderDriverKind.make("fx"), |
| 1004 | transcriptFile: new URL( |
| 1005 | "./tool_call_read_only_on_request/fx_transcript.ndjson", |
| 1006 | import.meta.url, |
| 1007 | ), |
| 1008 | modelSelection: FX_MODEL_SELECTION, |
| 1009 | runtimePolicyOverride: READ_ONLY_ON_REQUEST_POLICY, |
| 1010 | assertOutput: assertToolCallReadOnlyOnRequestFxOutput, |
| 1011 | }, |
| 1012 | { |
| 1013 | driver: ProviderDriverKind.make("acpRegistry"), |
| 1014 | transcriptFile: new URL( |
| 1015 | "./tool_call_read_only_on_request/registry_transcript.ndjson", |
| 1016 | import.meta.url, |
| 1017 | ), |
| 1018 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 1019 | runtimePolicyOverride: READ_ONLY_ON_REQUEST_POLICY, |
| 1020 | assertOutput: assertToolCallReadOnlyOnRequestOutput, |
| 1021 | }, |
| 1022 | ], |
| 1023 | }, |
| 1024 | { |
| 1025 | name: "tool_call_workspace_never", |
| 1026 | buildInput: toolCallWorkspaceNeverInput, |
| 1027 | providers: [ |
| 1028 | { |
| 1029 | driver: ProviderDriverKind.make("codex"), |
| 1030 | transcriptFile: new URL( |
| 1031 | "./tool_call_workspace_never/codex_transcript.ndjson", |
| 1032 | import.meta.url, |
| 1033 | ), |
| 1034 | modelSelection: CODEX_MODEL_SELECTION, |
| 1035 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1036 | assertOutput: assertToolCallWorkspaceNeverOutput, |
| 1037 | }, |
| 1038 | { |
| 1039 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1040 | transcriptFile: new URL( |
| 1041 | "./tool_call_workspace_never/claude_transcript.ndjson", |
| 1042 | import.meta.url, |
| 1043 | ), |
| 1044 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1045 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1046 | assertOutput: assertToolCallWorkspaceNeverClaudeOutput, |
| 1047 | }, |
| 1048 | ], |
| 1049 | }, |
| 1050 | { |
| 1051 | name: "tool_call_restricted_granular", |
| 1052 | buildInput: toolCallRestrictedGranularInput, |
| 1053 | providers: [ |
| 1054 | { |
| 1055 | driver: ProviderDriverKind.make("codex"), |
| 1056 | transcriptFile: new URL( |
| 1057 | "./tool_call_restricted_granular/codex_transcript.ndjson", |
| 1058 | import.meta.url, |
| 1059 | ), |
| 1060 | // gpt-6 uses shell writes; gpt-5.6-terra triggers this fixture's apply_patch approval. |
| 1061 | modelSelection: { ...CODEX_MODEL_SELECTION, model: "gpt-5.6-terra" }, |
| 1062 | runtimePolicyOverride: RESTRICTED_GRANULAR_POLICY, |
| 1063 | assertOutput: assertToolCallRestrictedGranularOutput, |
| 1064 | }, |
| 1065 | { |
| 1066 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1067 | transcriptFile: new URL( |
| 1068 | "./tool_call_restricted_granular/claude_transcript.ndjson", |
| 1069 | import.meta.url, |
| 1070 | ), |
| 1071 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1072 | runtimePolicyOverride: RESTRICTED_GRANULAR_POLICY, |
| 1073 | assertOutput: assertToolCallRestrictedGranularClaudeOutput, |
| 1074 | }, |
| 1075 | ], |
| 1076 | }, |
| 1077 | { |
| 1078 | name: "subagent", |
| 1079 | buildInput: subagentInput, |
| 1080 | providers: [ |
| 1081 | { |
| 1082 | driver: ProviderDriverKind.make("codex"), |
| 1083 | transcriptFile: new URL("./subagent/codex_transcript.ndjson", import.meta.url), |
| 1084 | // gpt-5.6-luna still runs multi-agent v1 (collabAgentToolCall); subagent_v2 covers v2. |
| 1085 | modelSelection: { ...CODEX_MODEL_SELECTION, model: "gpt-5.6-luna" }, |
| 1086 | runtimePolicyOverride: READ_ONLY_ON_REQUEST_POLICY, |
| 1087 | assertOutput: assertSubagentOutput, |
| 1088 | }, |
| 1089 | { |
| 1090 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1091 | transcriptFile: new URL("./subagent/claude_transcript.ndjson", import.meta.url), |
| 1092 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1093 | assertOutput: assertClaudeSubagentOutput, |
| 1094 | }, |
| 1095 | { |
| 1096 | driver: ProviderDriverKind.make("cursor"), |
| 1097 | transcriptFile: new URL("./subagent/cursor_transcript.ndjson", import.meta.url), |
| 1098 | modelSelection: CURSOR_MODEL_SELECTION, |
| 1099 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 1100 | assertOutput: assertCursorSubagentOutput, |
| 1101 | }, |
| 1102 | { |
| 1103 | driver: ProviderDriverKind.make("kiro"), |
| 1104 | transcriptFile: new URL("./subagent/kiro_transcript.ndjson", import.meta.url), |
| 1105 | modelSelection: KIRO_MODEL_SELECTION, |
| 1106 | assertOutput: assertKiroSubagentOutput, |
| 1107 | }, |
| 1108 | ], |
| 1109 | }, |
| 1110 | { |
| 1111 | name: "subagent_continue", |
| 1112 | buildInput: subagentContinueInput, |
| 1113 | providers: [ |
| 1114 | { |
| 1115 | driver: ProviderDriverKind.make("codex"), |
| 1116 | transcriptFile: new URL("./subagent_continue/codex_transcript.ndjson", import.meta.url), |
| 1117 | // gpt-5.6-luna still runs multi-agent v1 (collabAgentToolCall); subagent_v2 covers v2. |
| 1118 | modelSelection: { ...CODEX_MODEL_SELECTION, model: "gpt-5.6-luna" }, |
| 1119 | assertOutput: assertSubagentContinueOutput, |
| 1120 | }, |
| 1121 | ], |
| 1122 | }, |
| 1123 | { |
| 1124 | name: "subagent_v2", |
| 1125 | buildInput: subagentV2Input, |
| 1126 | providers: [ |
| 1127 | { |
| 1128 | driver: ProviderDriverKind.make("codex"), |
| 1129 | transcriptFile: new URL("./subagent_v2/codex_transcript.ndjson", import.meta.url), |
| 1130 | modelSelection: CODEX_MODEL_SELECTION, |
| 1131 | assertOutput: assertSubagentV2Output, |
| 1132 | }, |
| 1133 | { |
| 1134 | driver: ProviderDriverKind.make("muse"), |
| 1135 | transcriptFile: new URL("./subagent_v2/muse_transcript.ndjson", import.meta.url), |
| 1136 | modelSelection: MUSE_MODEL_SELECTION, |
| 1137 | assertOutput: assertMuseSubagentV2Output, |
| 1138 | }, |
| 1139 | ], |
| 1140 | }, |
| 1141 | { |
| 1142 | name: "subagent_v2_approval", |
| 1143 | buildInput: subagentV2ApprovalInput, |
| 1144 | providers: [ |
| 1145 | { |
| 1146 | driver: ProviderDriverKind.make("codex"), |
| 1147 | transcriptFile: new URL("./subagent_v2_approval/codex_transcript.ndjson", import.meta.url), |
| 1148 | modelSelection: CODEX_MODEL_SELECTION, |
| 1149 | runtimePolicyOverride: SUBAGENT_V2_APPROVAL_POLICY, |
| 1150 | assertOutput: assertSubagentV2ApprovalOutput, |
| 1151 | }, |
| 1152 | ], |
| 1153 | }, |
| 1154 | { |
| 1155 | name: "subagent_v2_nested", |
| 1156 | buildInput: subagentV2NestedInput, |
| 1157 | providers: [ |
| 1158 | { |
| 1159 | driver: ProviderDriverKind.make("codex"), |
| 1160 | transcriptFile: new URL("./subagent_v2_nested/codex_transcript.ndjson", import.meta.url), |
| 1161 | modelSelection: CODEX_MODEL_SELECTION, |
| 1162 | assertOutput: assertSubagentV2NestedOutput, |
| 1163 | }, |
| 1164 | ], |
| 1165 | }, |
| 1166 | { |
| 1167 | name: "subagent_v2_nested_approval", |
| 1168 | buildInput: subagentV2NestedApprovalInput, |
| 1169 | providers: [ |
| 1170 | { |
| 1171 | driver: ProviderDriverKind.make("codex"), |
| 1172 | transcriptFile: new URL( |
| 1173 | "./subagent_v2_nested_approval/codex_transcript.ndjson", |
| 1174 | import.meta.url, |
| 1175 | ), |
| 1176 | modelSelection: CODEX_MODEL_SELECTION, |
| 1177 | runtimePolicyOverride: SUBAGENT_V2_APPROVAL_POLICY, |
| 1178 | assertOutput: assertSubagentV2NestedApprovalOutput, |
| 1179 | }, |
| 1180 | ], |
| 1181 | }, |
| 1182 | { |
| 1183 | name: "opencode_subagent", |
| 1184 | buildInput: openCodeSubagentInput, |
| 1185 | providers: [ |
| 1186 | { |
| 1187 | driver: ProviderDriverKind.make("opencode"), |
| 1188 | transcriptFile: new URL("./opencode_subagent/opencode_transcript.ndjson", import.meta.url), |
| 1189 | modelSelection: OPENCODE_MODEL_SELECTION, |
| 1190 | assertOutput: assertOpenCodeSubagentOutput, |
| 1191 | }, |
| 1192 | ], |
| 1193 | }, |
| 1194 | { |
| 1195 | name: "opencode_background_wake", |
| 1196 | buildInput: openCodeBackgroundWakeInput, |
| 1197 | providers: [ |
| 1198 | { |
| 1199 | driver: ProviderDriverKind.make("opencode"), |
| 1200 | transcriptFile: new URL( |
| 1201 | "./opencode_background_wake/opencode_transcript.ndjson", |
| 1202 | import.meta.url, |
| 1203 | ), |
| 1204 | modelSelection: OPENCODE_MODEL_SELECTION, |
| 1205 | runContinuationWorker: true, |
| 1206 | assertOutput: assertOpenCodeBackgroundWakeOutput, |
| 1207 | }, |
| 1208 | ], |
| 1209 | }, |
| 1210 | { |
| 1211 | name: "opencode2_simple", |
| 1212 | buildInput: openCode2SimpleInput, |
| 1213 | providers: [ |
| 1214 | { |
| 1215 | driver: ProviderDriverKind.make("opencode"), |
| 1216 | transcriptFile: new URL("./opencode2_simple/opencode_transcript.ndjson", import.meta.url), |
| 1217 | modelSelection: OPENCODE2_MODEL_SELECTION, |
| 1218 | assertOutput: assertOpenCode2SimpleOutput, |
| 1219 | }, |
| 1220 | ], |
| 1221 | }, |
| 1222 | { |
| 1223 | name: "opencode2_missing_step_usage", |
| 1224 | buildInput: openCode2SimpleInput, |
| 1225 | providers: [ |
| 1226 | { |
| 1227 | driver: ProviderDriverKind.make("opencode"), |
| 1228 | transcriptFile: new URL( |
| 1229 | "./opencode2_missing_step_usage/opencode_transcript.ndjson", |
| 1230 | import.meta.url, |
| 1231 | ), |
| 1232 | modelSelection: OPENCODE2_MODEL_SELECTION, |
| 1233 | assertOutput: assertOpenCode2MissingStepUsageOutput, |
| 1234 | }, |
| 1235 | ], |
| 1236 | }, |
| 1237 | { |
| 1238 | name: "opencode2_tool_call", |
| 1239 | buildInput: openCode2ToolCallInput, |
| 1240 | providers: [ |
| 1241 | { |
| 1242 | driver: ProviderDriverKind.make("opencode"), |
| 1243 | transcriptFile: new URL( |
| 1244 | "./opencode2_tool_call/opencode_transcript.ndjson", |
| 1245 | import.meta.url, |
| 1246 | ), |
| 1247 | modelSelection: { |
| 1248 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1249 | model: "opencode/big-pickle", |
| 1250 | }, |
| 1251 | assertOutput: assertOpenCode2ToolCallOutput, |
| 1252 | }, |
| 1253 | ], |
| 1254 | }, |
| 1255 | { |
| 1256 | name: "opencode2_interrupt", |
| 1257 | buildInput: openCode2InterruptInput, |
| 1258 | providers: [ |
| 1259 | { |
| 1260 | driver: ProviderDriverKind.make("opencode"), |
| 1261 | transcriptFile: new URL( |
| 1262 | "./opencode2_interrupt/opencode_transcript.ndjson", |
| 1263 | import.meta.url, |
| 1264 | ), |
| 1265 | modelSelection: { |
| 1266 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1267 | model: "opencode/big-pickle", |
| 1268 | }, |
| 1269 | assertOutput: assertOpenCode2InterruptOutput, |
| 1270 | }, |
| 1271 | ], |
| 1272 | }, |
| 1273 | { |
| 1274 | name: "opencode2_inbox", |
| 1275 | buildInput: openCode2InboxInput, |
| 1276 | providers: [ |
| 1277 | { |
| 1278 | driver: ProviderDriverKind.make("opencode"), |
| 1279 | transcriptFile: new URL("./opencode2_inbox/opencode_transcript.ndjson", import.meta.url), |
| 1280 | modelSelection: { |
| 1281 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1282 | model: "opencode/big-pickle", |
| 1283 | }, |
| 1284 | assertOutput: assertOpenCode2InboxOutput, |
| 1285 | }, |
| 1286 | ], |
| 1287 | }, |
| 1288 | { |
| 1289 | name: "opencode2_revert", |
| 1290 | buildInput: openCode2RevertInput, |
| 1291 | providers: [ |
| 1292 | { |
| 1293 | driver: ProviderDriverKind.make("opencode"), |
| 1294 | transcriptFile: new URL("./opencode2_revert/opencode_transcript.ndjson", import.meta.url), |
| 1295 | modelSelection: { |
| 1296 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1297 | model: "opencode/big-pickle", |
| 1298 | }, |
| 1299 | assertOutput: assertOpenCode2RevertOutput, |
| 1300 | }, |
| 1301 | ], |
| 1302 | }, |
| 1303 | { |
| 1304 | name: "opencode2_permission", |
| 1305 | buildInput: openCode2PermissionInput, |
| 1306 | providers: [ |
| 1307 | { |
| 1308 | driver: ProviderDriverKind.make("opencode"), |
| 1309 | transcriptFile: new URL( |
| 1310 | "./opencode2_permission/opencode_transcript.ndjson", |
| 1311 | import.meta.url, |
| 1312 | ), |
| 1313 | modelSelection: { |
| 1314 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1315 | model: "opencode/big-pickle", |
| 1316 | }, |
| 1317 | assertOutput: assertOpenCode2PermissionOutput, |
| 1318 | }, |
| 1319 | ], |
| 1320 | }, |
| 1321 | { |
| 1322 | name: "opencode2_question", |
| 1323 | buildInput: openCode2QuestionInput, |
| 1324 | providers: [ |
| 1325 | { |
| 1326 | driver: ProviderDriverKind.make("opencode"), |
| 1327 | transcriptFile: new URL("./opencode2_question/opencode_transcript.ndjson", import.meta.url), |
| 1328 | modelSelection: { |
| 1329 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1330 | model: "opencode/big-pickle", |
| 1331 | }, |
| 1332 | assertOutput: assertOpenCode2QuestionOutput, |
| 1333 | }, |
| 1334 | ], |
| 1335 | }, |
| 1336 | { |
| 1337 | name: "opencode2_subagent", |
| 1338 | buildInput: openCode2SubagentInput, |
| 1339 | providers: [ |
| 1340 | { |
| 1341 | driver: ProviderDriverKind.make("opencode"), |
| 1342 | transcriptFile: new URL("./opencode2_subagent/opencode_transcript.ndjson", import.meta.url), |
| 1343 | modelSelection: { |
| 1344 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1345 | model: "opencode/big-pickle", |
| 1346 | }, |
| 1347 | assertOutput: assertOpenCode2SubagentOutput, |
| 1348 | }, |
| 1349 | ], |
| 1350 | }, |
| 1351 | { |
| 1352 | name: "opencode2_background", |
| 1353 | buildInput: openCode2BackgroundInput, |
| 1354 | providers: [ |
| 1355 | { |
| 1356 | driver: ProviderDriverKind.make("opencode"), |
| 1357 | transcriptFile: new URL( |
| 1358 | "./opencode2_background/opencode_transcript.ndjson", |
| 1359 | import.meta.url, |
| 1360 | ), |
| 1361 | modelSelection: { |
| 1362 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1363 | model: "opencode/big-pickle", |
| 1364 | }, |
| 1365 | runContinuationWorker: true, |
| 1366 | assertOutput: assertOpenCode2BackgroundOutput, |
| 1367 | }, |
| 1368 | ], |
| 1369 | }, |
| 1370 | { |
| 1371 | name: "opencode2_nested_background", |
| 1372 | buildInput: openCode2NestedBackgroundInput, |
| 1373 | providers: [ |
| 1374 | { |
| 1375 | driver: ProviderDriverKind.make("opencode"), |
| 1376 | transcriptFile: new URL( |
| 1377 | "./opencode2_nested_background/opencode_transcript.ndjson", |
| 1378 | import.meta.url, |
| 1379 | ), |
| 1380 | modelSelection: { |
| 1381 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1382 | model: "openrouter/deepseek/deepseek-v4-flash", |
| 1383 | }, |
| 1384 | assertOutput: assertOpenCode2NestedBackgroundOutput, |
| 1385 | }, |
| 1386 | ], |
| 1387 | }, |
| 1388 | { |
| 1389 | name: "opencode2_compaction", |
| 1390 | buildInput: openCode2CompactionInput, |
| 1391 | providers: [ |
| 1392 | { |
| 1393 | driver: ProviderDriverKind.make("opencode"), |
| 1394 | transcriptFile: new URL( |
| 1395 | "./opencode2_compaction/opencode_transcript.ndjson", |
| 1396 | import.meta.url, |
| 1397 | ), |
| 1398 | modelSelection: { |
| 1399 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1400 | model: "opencode/big-pickle", |
| 1401 | }, |
| 1402 | assertOutput: assertOpenCode2CompactionOutput, |
| 1403 | }, |
| 1404 | ], |
| 1405 | }, |
| 1406 | { |
| 1407 | name: "opencode2_resume_after_restart", |
| 1408 | buildInput: openCode2ResumeAfterRestartInput, |
| 1409 | providers: [ |
| 1410 | { |
| 1411 | driver: ProviderDriverKind.make("opencode"), |
| 1412 | transcriptFile: new URL( |
| 1413 | "./opencode2_resume_after_restart/opencode_transcript.ndjson", |
| 1414 | import.meta.url, |
| 1415 | ), |
| 1416 | modelSelection: { |
| 1417 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1418 | model: "opencode/big-pickle", |
| 1419 | }, |
| 1420 | assertOutput: assertOpenCode2ResumeAfterRestartOutput, |
| 1421 | }, |
| 1422 | ], |
| 1423 | }, |
| 1424 | ...( |
| 1425 | [ |
| 1426 | ["opencode2_command", openCode2CommandInput, assertOpenCode2CommandOutput], |
| 1427 | ["opencode2_skill", openCode2SkillInput, assertOpenCode2SkillOutput], |
| 1428 | ] as const |
| 1429 | ).map(([name, buildInput, assertOutput]) => ({ |
| 1430 | name, |
| 1431 | buildInput, |
| 1432 | providers: [ |
| 1433 | { |
| 1434 | driver: ProviderDriverKind.make("opencode"), |
| 1435 | transcriptFile: new URL(`./${name}/opencode_transcript.ndjson`, import.meta.url), |
| 1436 | modelSelection: { |
| 1437 | instanceId: OPENCODE2_MODEL_SELECTION.instanceId, |
| 1438 | model: "openrouter/deepseek/deepseek-v4-flash", |
| 1439 | }, |
| 1440 | assertOutput, |
| 1441 | }, |
| 1442 | ], |
| 1443 | })), |
| 1444 | { |
| 1445 | name: "opencode_child_approval", |
| 1446 | buildInput: openCodeChildApprovalInput, |
| 1447 | providers: [ |
| 1448 | { |
| 1449 | driver: ProviderDriverKind.make("opencode"), |
| 1450 | transcriptFile: new URL( |
| 1451 | "./opencode_child_approval/opencode_transcript.ndjson", |
| 1452 | import.meta.url, |
| 1453 | ), |
| 1454 | modelSelection: OPENCODE_MODEL_SELECTION, |
| 1455 | assertOutput: assertOpenCodeChildApprovalOutput, |
| 1456 | }, |
| 1457 | ], |
| 1458 | }, |
| 1459 | { |
| 1460 | name: "opencode_running_child_approval", |
| 1461 | buildInput: openCodeRunningChildApprovalInput, |
| 1462 | providers: [ |
| 1463 | { |
| 1464 | driver: ProviderDriverKind.make("opencode"), |
| 1465 | transcriptFile: new URL( |
| 1466 | "./opencode_running_child_approval/opencode_transcript.ndjson", |
| 1467 | import.meta.url, |
| 1468 | ), |
| 1469 | modelSelection: OPENCODE_MODEL_SELECTION, |
| 1470 | assertOutput: assertOpenCodeRunningChildApprovalOutput, |
| 1471 | }, |
| 1472 | ], |
| 1473 | }, |
| 1474 | { |
| 1475 | name: "codex_model_reroute", |
| 1476 | buildInput: multiTurnInput, |
| 1477 | providers: [ |
| 1478 | { |
| 1479 | driver: ProviderDriverKind.make("codex"), |
| 1480 | transcriptFile: new URL("./codex_model_reroute/codex_transcript.ndjson", import.meta.url), |
| 1481 | modelSelection: CODEX_MODEL_SELECTION, |
| 1482 | assertOutput: assertCodexModelRerouteOutput, |
| 1483 | }, |
| 1484 | ], |
| 1485 | }, |
| 1486 | { |
| 1487 | name: "multi_turn", |
| 1488 | buildInput: multiTurnInput, |
| 1489 | providers: [ |
| 1490 | { |
| 1491 | driver: ProviderDriverKind.make("codex"), |
| 1492 | transcriptFile: new URL("./multi_turn/codex_transcript.ndjson", import.meta.url), |
| 1493 | modelSelection: CODEX_MODEL_SELECTION, |
| 1494 | assertOutput: assertMultiTurnOutput, |
| 1495 | }, |
| 1496 | { |
| 1497 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1498 | transcriptFile: new URL("./multi_turn/claude_transcript.ndjson", import.meta.url), |
| 1499 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1500 | assertOutput: assertMultiTurnClaudeOutput, |
| 1501 | }, |
| 1502 | { |
| 1503 | driver: ProviderDriverKind.make("cursor"), |
| 1504 | transcriptFile: new URL("./multi_turn/cursor_transcript.ndjson", import.meta.url), |
| 1505 | modelSelection: CURSOR_MODEL_SELECTION, |
| 1506 | assertOutput: assertMultiTurnOutput, |
| 1507 | }, |
| 1508 | { |
| 1509 | driver: ProviderDriverKind.make("grok"), |
| 1510 | transcriptFile: new URL("./multi_turn/grok_transcript.ndjson", import.meta.url), |
| 1511 | modelSelection: GROK_MODEL_SELECTION, |
| 1512 | assertOutput: assertMultiTurnOutput, |
| 1513 | }, |
| 1514 | { |
| 1515 | driver: ProviderDriverKind.make("fx"), |
| 1516 | transcriptFile: new URL("./multi_turn/fx_transcript.ndjson", import.meta.url), |
| 1517 | modelSelection: FX_MODEL_SELECTION, |
| 1518 | assertOutput: assertMultiTurnOutput, |
| 1519 | }, |
| 1520 | { |
| 1521 | driver: ProviderDriverKind.make("kiro"), |
| 1522 | transcriptFile: new URL("./multi_turn/kiro_transcript.ndjson", import.meta.url), |
| 1523 | modelSelection: KIRO_MODEL_SELECTION, |
| 1524 | assertOutput: assertMultiTurnOutput, |
| 1525 | }, |
| 1526 | { |
| 1527 | driver: ProviderDriverKind.make("acpRegistry"), |
| 1528 | transcriptFile: new URL("./multi_turn/registry_transcript.ndjson", import.meta.url), |
| 1529 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 1530 | assertOutput: assertMultiTurnOutput, |
| 1531 | }, |
| 1532 | { |
| 1533 | driver: ProviderDriverKind.make("pi"), |
| 1534 | transcriptFile: new URL("./multi_turn/pi_transcript.ndjson", import.meta.url), |
| 1535 | modelSelection: PI_MODEL_SELECTION, |
| 1536 | assertOutput: assertPiMultiTurnOutput, |
| 1537 | }, |
| 1538 | { |
| 1539 | driver: ProviderDriverKind.make("muse"), |
| 1540 | transcriptFile: new URL("./multi_turn/muse_transcript.ndjson", import.meta.url), |
| 1541 | modelSelection: MUSE_MODEL_SELECTION, |
| 1542 | assertOutput: assertMuseMultiTurnOutput, |
| 1543 | }, |
| 1544 | ], |
| 1545 | }, |
| 1546 | { |
| 1547 | name: "muse_permission", |
| 1548 | buildInput: musePermissionInput, |
| 1549 | providers: [ |
| 1550 | { |
| 1551 | driver: ProviderDriverKind.make("muse"), |
| 1552 | transcriptFile: new URL("./muse_permission/muse_transcript.ndjson", import.meta.url), |
| 1553 | modelSelection: MUSE_MODEL_SELECTION, |
| 1554 | expectedAbsentWorkspacePaths: [MUSE_PERMISSION_DECLINED_FILE], |
| 1555 | assertOutput: assertMusePermissionOutput, |
| 1556 | }, |
| 1557 | ], |
| 1558 | }, |
| 1559 | { |
| 1560 | name: "muse_subagent_approval", |
| 1561 | buildInput: museSubagentApprovalInput, |
| 1562 | providers: [ |
| 1563 | { |
| 1564 | driver: ProviderDriverKind.make("muse"), |
| 1565 | transcriptFile: new URL("./muse_subagent_approval/muse_transcript.ndjson", import.meta.url), |
| 1566 | modelSelection: MUSE_MODEL_SELECTION, |
| 1567 | assertOutput: assertMuseSubagentApprovalOutput, |
| 1568 | }, |
| 1569 | ], |
| 1570 | }, |
| 1571 | { |
| 1572 | name: "muse_subagent_interrupt", |
| 1573 | buildInput: museSubagentInterruptInput, |
| 1574 | providers: [ |
| 1575 | { |
| 1576 | driver: ProviderDriverKind.make("muse"), |
| 1577 | transcriptFile: new URL( |
| 1578 | "./muse_subagent_interrupt/muse_transcript.ndjson", |
| 1579 | import.meta.url, |
| 1580 | ), |
| 1581 | modelSelection: MUSE_MODEL_SELECTION, |
| 1582 | assertOutput: assertMuseSubagentInterruptOutput, |
| 1583 | }, |
| 1584 | ], |
| 1585 | }, |
| 1586 | { |
| 1587 | name: "muse_workflow", |
| 1588 | buildInput: museWorkflowInput, |
| 1589 | providers: [ |
| 1590 | { |
| 1591 | driver: ProviderDriverKind.make("muse"), |
| 1592 | transcriptFile: new URL("./muse_workflow/muse_transcript.ndjson", import.meta.url), |
| 1593 | modelSelection: MUSE_MODEL_SELECTION, |
| 1594 | runContinuationWorker: true, |
| 1595 | assertOutput: assertMuseWorkflowOutput, |
| 1596 | }, |
| 1597 | ], |
| 1598 | }, |
| 1599 | { |
| 1600 | name: "pi_compaction", |
| 1601 | buildInput: piCompactionInput, |
| 1602 | providers: [ |
| 1603 | { |
| 1604 | driver: ProviderDriverKind.make("pi"), |
| 1605 | transcriptFile: new URL("./pi_compaction/pi_transcript.ndjson", import.meta.url), |
| 1606 | modelSelection: PI_MODEL_SELECTION, |
| 1607 | assertOutput: assertPiCompactionOutput, |
| 1608 | }, |
| 1609 | ], |
| 1610 | }, |
| 1611 | { |
| 1612 | name: "provider_thread_resume", |
| 1613 | buildInput: providerThreadResumeInput, |
| 1614 | providers: [ |
| 1615 | { |
| 1616 | driver: ProviderDriverKind.make("pi"), |
| 1617 | transcriptFile: new URL("./provider_thread_resume/pi_transcript.ndjson", import.meta.url), |
| 1618 | modelSelection: PI_MODEL_SELECTION, |
| 1619 | assertOutput: assertPiProviderThreadResumeOutput, |
| 1620 | }, |
| 1621 | ], |
| 1622 | }, |
| 1623 | { |
| 1624 | name: "multi_turn_restart", |
| 1625 | buildInput: multiTurnInput, |
| 1626 | providers: [ |
| 1627 | { |
| 1628 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1629 | transcriptFile: new URL("./multi_turn_restart/claude_transcript.ndjson", import.meta.url), |
| 1630 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1631 | assertOutput: assertMultiTurnClaudeOutput, |
| 1632 | }, |
| 1633 | ], |
| 1634 | }, |
| 1635 | { |
| 1636 | name: "queued_cancelled_while_active", |
| 1637 | buildInput: queuedCancelledWhileActiveInput, |
| 1638 | providers: [ |
| 1639 | { |
| 1640 | driver: ProviderDriverKind.make("codex"), |
| 1641 | transcriptFile: new URL("./queued_turn/codex_transcript.ndjson", import.meta.url), |
| 1642 | recordedScenario: "queued_turn", |
| 1643 | transcriptEntriesThroughLabel: "turn/completed", |
| 1644 | modelSelection: CODEX_MODEL_SELECTION, |
| 1645 | assertOutput: assertQueuedCancelledWhileActiveOutput, |
| 1646 | }, |
| 1647 | ], |
| 1648 | }, |
| 1649 | { |
| 1650 | name: "queued_turn", |
| 1651 | buildInput: queuedTurnInput, |
| 1652 | providers: [ |
| 1653 | { |
| 1654 | driver: ProviderDriverKind.make("codex"), |
| 1655 | transcriptFile: new URL("./queued_turn/codex_transcript.ndjson", import.meta.url), |
| 1656 | modelSelection: CODEX_MODEL_SELECTION, |
| 1657 | assertOutput: assertQueuedTurnOutput, |
| 1658 | }, |
| 1659 | { |
| 1660 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1661 | transcriptFile: new URL("./queued_turn/claude_transcript.ndjson", import.meta.url), |
| 1662 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1663 | assertOutput: assertQueuedTurnOutput, |
| 1664 | }, |
| 1665 | { |
| 1666 | driver: ProviderDriverKind.make("cursor"), |
| 1667 | transcriptFile: new URL("./queued_turn/cursor_transcript.ndjson", import.meta.url), |
| 1668 | modelSelection: CURSOR_MODEL_SELECTION, |
| 1669 | assertOutput: assertQueuedTurnOutput, |
| 1670 | }, |
| 1671 | { |
| 1672 | driver: ProviderDriverKind.make("grok"), |
| 1673 | transcriptFile: new URL("./queued_turn/grok_transcript.ndjson", import.meta.url), |
| 1674 | modelSelection: GROK_MODEL_SELECTION, |
| 1675 | assertOutput: assertQueuedTurnOutput, |
| 1676 | }, |
| 1677 | { |
| 1678 | driver: ProviderDriverKind.make("fx"), |
| 1679 | transcriptFile: new URL("./queued_turn/fx_transcript.ndjson", import.meta.url), |
| 1680 | modelSelection: FX_MODEL_SELECTION, |
| 1681 | assertOutput: assertQueuedTurnOutput, |
| 1682 | }, |
| 1683 | { |
| 1684 | driver: ProviderDriverKind.make("kiro"), |
| 1685 | transcriptFile: new URL("./queued_turn/kiro_transcript.ndjson", import.meta.url), |
| 1686 | modelSelection: KIRO_MODEL_SELECTION, |
| 1687 | assertOutput: assertQueuedTurnOutput, |
| 1688 | }, |
| 1689 | { |
| 1690 | driver: ProviderDriverKind.make("acpRegistry"), |
| 1691 | transcriptFile: new URL("./queued_turn/registry_transcript.ndjson", import.meta.url), |
| 1692 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 1693 | assertOutput: assertQueuedTurnOutput, |
| 1694 | }, |
| 1695 | ], |
| 1696 | }, |
| 1697 | { |
| 1698 | name: "todo_list", |
| 1699 | buildInput: todoListInput, |
| 1700 | providers: [ |
| 1701 | { |
| 1702 | driver: ProviderDriverKind.make("codex"), |
| 1703 | transcriptFile: new URL("./todo_list/codex_transcript.ndjson", import.meta.url), |
| 1704 | modelSelection: CODEX_MODEL_SELECTION, |
| 1705 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 1706 | assertOutput: assertTodoListOutput, |
| 1707 | }, |
| 1708 | { |
| 1709 | driver: ProviderDriverKind.make("cursor"), |
| 1710 | transcriptFile: new URL("./todo_list/cursor_transcript.ndjson", import.meta.url), |
| 1711 | modelSelection: CURSOR_MODEL_SELECTION, |
| 1712 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 1713 | assertOutput: assertTodoListCursorOutput, |
| 1714 | }, |
| 1715 | { |
| 1716 | driver: ProviderDriverKind.make("grok"), |
| 1717 | transcriptFile: new URL("./todo_list/grok_transcript.ndjson", import.meta.url), |
| 1718 | modelSelection: GROK_MODEL_SELECTION, |
| 1719 | assertOutput: assertTodoListGrokOutput, |
| 1720 | }, |
| 1721 | { |
| 1722 | driver: ProviderDriverKind.make("acpRegistry"), |
| 1723 | transcriptFile: new URL("./todo_list/registry_transcript.ndjson", import.meta.url), |
| 1724 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 1725 | assertOutput: assertTodoListGrokOutput, |
| 1726 | }, |
| 1727 | ], |
| 1728 | }, |
| 1729 | { |
| 1730 | name: "web_search", |
| 1731 | buildInput: webSearchInput, |
| 1732 | providers: [ |
| 1733 | { |
| 1734 | driver: ProviderDriverKind.make("codex"), |
| 1735 | transcriptFile: new URL("./web_search/codex_transcript.ndjson", import.meta.url), |
| 1736 | modelSelection: CODEX_MODEL_SELECTION, |
| 1737 | assertOutput: assertWebSearchOutput, |
| 1738 | }, |
| 1739 | { |
| 1740 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1741 | transcriptFile: new URL("./web_search/claude_transcript.ndjson", import.meta.url), |
| 1742 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1743 | assertOutput: assertClaudeWebSearchOutput, |
| 1744 | }, |
| 1745 | ], |
| 1746 | }, |
| 1747 | { |
| 1748 | name: "plan_questions", |
| 1749 | buildInput: planQuestionsInput, |
| 1750 | providers: [ |
| 1751 | { |
| 1752 | driver: ProviderDriverKind.make("codex"), |
| 1753 | transcriptFile: new URL("./plan_questions/codex_transcript.ndjson", import.meta.url), |
| 1754 | modelSelection: CODEX_MODEL_SELECTION, |
| 1755 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 1756 | assertOutput: assertCodexPlanQuestionsOutput, |
| 1757 | }, |
| 1758 | { |
| 1759 | driver: ProviderDriverKind.make("grok"), |
| 1760 | transcriptFile: new URL("./plan_questions/grok_transcript.ndjson", import.meta.url), |
| 1761 | modelSelection: GROK_MODEL_SELECTION, |
| 1762 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 1763 | assertOutput: assertPlanQuestionsOutput, |
| 1764 | }, |
| 1765 | { |
| 1766 | driver: ProviderDriverKind.make("opencode"), |
| 1767 | transcriptFile: new URL("./plan_questions/opencode_transcript.ndjson", import.meta.url), |
| 1768 | modelSelection: OPENCODE_MODEL_SELECTION, |
| 1769 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 1770 | assertOutput: assertOpenCodePlanQuestionsOutput, |
| 1771 | }, |
| 1772 | ], |
| 1773 | }, |
| 1774 | { |
| 1775 | name: "proposed_plan", |
| 1776 | buildInput: proposedPlanInput, |
| 1777 | providers: [ |
| 1778 | { |
| 1779 | driver: ProviderDriverKind.make("codex"), |
| 1780 | transcriptFile: new URL("./proposed_plan/codex_transcript.ndjson", import.meta.url), |
| 1781 | modelSelection: CODEX_MODEL_SELECTION, |
| 1782 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 1783 | assertOutput: assertProposedPlanOutput, |
| 1784 | }, |
| 1785 | { |
| 1786 | driver: ProviderDriverKind.make("cursor"), |
| 1787 | transcriptFile: new URL("./proposed_plan/cursor_transcript.ndjson", import.meta.url), |
| 1788 | modelSelection: CURSOR_MODEL_SELECTION, |
| 1789 | runtimePolicyOverride: READ_ONLY_NEVER_POLICY, |
| 1790 | assertOutput: assertProposedPlanCursorOutput, |
| 1791 | }, |
| 1792 | ], |
| 1793 | }, |
| 1794 | { |
| 1795 | name: "message_steering", |
| 1796 | buildInput: messageSteeringInput, |
| 1797 | providers: [ |
| 1798 | { |
| 1799 | driver: ProviderDriverKind.make("codex"), |
| 1800 | transcriptFile: new URL("./message_steering/codex_transcript.ndjson", import.meta.url), |
| 1801 | modelSelection: CODEX_MODEL_SELECTION, |
| 1802 | assertOutput: assertMessageSteeringOutput, |
| 1803 | }, |
| 1804 | { |
| 1805 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1806 | transcriptFile: new URL("./message_steering/claude_transcript.ndjson", import.meta.url), |
| 1807 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1808 | assertOutput: assertClaudeMessageSteeringOutput, |
| 1809 | }, |
| 1810 | { |
| 1811 | driver: ProviderDriverKind.make("cursor"), |
| 1812 | transcriptFile: new URL("./message_steering/cursor_transcript.ndjson", import.meta.url), |
| 1813 | modelSelection: CURSOR_MODEL_SELECTION, |
| 1814 | assertOutput: assertCursorMessageSteeringOutput, |
| 1815 | }, |
| 1816 | { |
| 1817 | driver: ProviderDriverKind.make("fx"), |
| 1818 | transcriptFile: new URL("./message_steering/fx_transcript.ndjson", import.meta.url), |
| 1819 | modelSelection: FX_MODEL_SELECTION, |
| 1820 | assertOutput: assertGrokMessageSteeringOutput, |
| 1821 | }, |
| 1822 | { |
| 1823 | driver: ProviderDriverKind.make("acpRegistry"), |
| 1824 | transcriptFile: new URL("./message_steering/registry_transcript.ndjson", import.meta.url), |
| 1825 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 1826 | assertOutput: assertGrokMessageSteeringOutput, |
| 1827 | }, |
| 1828 | { |
| 1829 | driver: ProviderDriverKind.make("pi"), |
| 1830 | transcriptFile: new URL("./message_steering/pi_transcript.ndjson", import.meta.url), |
| 1831 | modelSelection: PI_MODEL_SELECTION, |
| 1832 | assertOutput: assertPiMessageSteeringOutput, |
| 1833 | }, |
| 1834 | ], |
| 1835 | }, |
| 1836 | { |
| 1837 | name: "turn_interrupt", |
| 1838 | buildInput: turnInterruptInput, |
| 1839 | providers: [ |
| 1840 | { |
| 1841 | driver: ProviderDriverKind.make("codex"), |
| 1842 | transcriptFile: new URL("./turn_interrupt/codex_transcript.ndjson", import.meta.url), |
| 1843 | modelSelection: CODEX_MODEL_SELECTION, |
| 1844 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1845 | assertOutput: assertTurnInterruptOutput, |
| 1846 | }, |
| 1847 | { |
| 1848 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1849 | transcriptFile: new URL("./turn_interrupt/claude_transcript.ndjson", import.meta.url), |
| 1850 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1851 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1852 | assertOutput: assertTurnInterruptClaudeOutput, |
| 1853 | }, |
| 1854 | { |
| 1855 | driver: ProviderDriverKind.make("grok"), |
| 1856 | transcriptFile: new URL("./turn_interrupt/grok_transcript.ndjson", import.meta.url), |
| 1857 | modelSelection: GROK_MODEL_SELECTION, |
| 1858 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1859 | assertOutput: assertTurnInterruptOutput, |
| 1860 | }, |
| 1861 | { |
| 1862 | driver: ProviderDriverKind.make("fx"), |
| 1863 | transcriptFile: new URL("./turn_interrupt/fx_transcript.ndjson", import.meta.url), |
| 1864 | modelSelection: FX_MODEL_SELECTION, |
| 1865 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1866 | assertOutput: assertTurnInterruptOutput, |
| 1867 | }, |
| 1868 | { |
| 1869 | driver: ProviderDriverKind.make("kiro"), |
| 1870 | transcriptFile: new URL("./turn_interrupt/kiro_transcript.ndjson", import.meta.url), |
| 1871 | modelSelection: KIRO_MODEL_SELECTION, |
| 1872 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1873 | assertOutput: assertTurnInterruptOutput, |
| 1874 | }, |
| 1875 | { |
| 1876 | driver: ProviderDriverKind.make("acpRegistry"), |
| 1877 | transcriptFile: new URL("./turn_interrupt/registry_transcript.ndjson", import.meta.url), |
| 1878 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 1879 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1880 | assertOutput: assertTurnInterruptOutput, |
| 1881 | }, |
| 1882 | { |
| 1883 | driver: ProviderDriverKind.make("opencode"), |
| 1884 | transcriptFile: new URL("./turn_interrupt/opencode_transcript.ndjson", import.meta.url), |
| 1885 | modelSelection: OPENCODE_MODEL_SELECTION, |
| 1886 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1887 | assertOutput: assertTurnInterruptOutput, |
| 1888 | }, |
| 1889 | { |
| 1890 | driver: ProviderDriverKind.make("muse"), |
| 1891 | transcriptFile: new URL("./turn_interrupt/muse_transcript.ndjson", import.meta.url), |
| 1892 | modelSelection: MUSE_MODEL_SELECTION, |
| 1893 | assertOutput: assertMuseTurnInterruptOutput, |
| 1894 | }, |
| 1895 | ], |
| 1896 | }, |
| 1897 | { |
| 1898 | name: "fx_early_stop", |
| 1899 | buildInput: fxEarlyStopInput, |
| 1900 | providers: [ |
| 1901 | { |
| 1902 | driver: ProviderDriverKind.make("fx"), |
| 1903 | transcriptFile: new URL("./fx_early_stop/fx_transcript.ndjson", import.meta.url), |
| 1904 | modelSelection: FX_MODEL_SELECTION, |
| 1905 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1906 | assertOutput: assertFxEarlyStopOutput, |
| 1907 | }, |
| 1908 | ], |
| 1909 | }, |
| 1910 | { |
| 1911 | name: "fx_subagent", |
| 1912 | buildInput: fxSubagentInput, |
| 1913 | providers: [ |
| 1914 | { |
| 1915 | driver: ProviderDriverKind.make("fx"), |
| 1916 | transcriptFile: new URL("./fx_subagent/fx_transcript.ndjson", import.meta.url), |
| 1917 | modelSelection: FX_MODEL_SELECTION, |
| 1918 | assertOutput: assertFxSubagentOutput, |
| 1919 | }, |
| 1920 | ], |
| 1921 | }, |
| 1922 | { |
| 1923 | name: "fx_subagent_stop", |
| 1924 | buildInput: fxSubagentStopInput, |
| 1925 | providers: [ |
| 1926 | { |
| 1927 | driver: ProviderDriverKind.make("fx"), |
| 1928 | transcriptFile: new URL("./fx_subagent_stop/fx_transcript.ndjson", import.meta.url), |
| 1929 | modelSelection: FX_MODEL_SELECTION, |
| 1930 | assertOutput: assertFxSubagentStopOutput, |
| 1931 | }, |
| 1932 | ], |
| 1933 | }, |
| 1934 | { |
| 1935 | name: "command_output_streaming", |
| 1936 | buildInput: commandOutputStreamingInput, |
| 1937 | providers: [ |
| 1938 | { |
| 1939 | driver: ProviderDriverKind.make("codex"), |
| 1940 | transcriptFile: new URL( |
| 1941 | "./command_output_streaming/codex_transcript.ndjson", |
| 1942 | import.meta.url, |
| 1943 | ), |
| 1944 | modelSelection: CODEX_MODEL_SELECTION, |
| 1945 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1946 | assertOutput: assertCommandOutputStreamingOutput, |
| 1947 | }, |
| 1948 | { |
| 1949 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1950 | transcriptFile: new URL( |
| 1951 | "./command_output_streaming/claude_transcript.ndjson", |
| 1952 | import.meta.url, |
| 1953 | ), |
| 1954 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1955 | assertOutput: assertCommandOutputStreamingOutput, |
| 1956 | }, |
| 1957 | ], |
| 1958 | }, |
| 1959 | { |
| 1960 | name: "turn_interrupt_mid_tool", |
| 1961 | buildInput: turnInterruptMidToolInput, |
| 1962 | providers: [ |
| 1963 | { |
| 1964 | driver: ProviderDriverKind.make("codex"), |
| 1965 | transcriptFile: new URL( |
| 1966 | "./turn_interrupt_mid_tool/codex_transcript.ndjson", |
| 1967 | import.meta.url, |
| 1968 | ), |
| 1969 | modelSelection: CODEX_MODEL_SELECTION, |
| 1970 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1971 | assertOutput: assertTurnInterruptMidToolCodexOutput, |
| 1972 | }, |
| 1973 | { |
| 1974 | driver: ProviderDriverKind.make("claudeAgent"), |
| 1975 | transcriptFile: new URL( |
| 1976 | "./turn_interrupt_mid_tool/claude_transcript.ndjson", |
| 1977 | import.meta.url, |
| 1978 | ), |
| 1979 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 1980 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1981 | assertOutput: assertTurnInterruptMidToolClaudeOutput, |
| 1982 | }, |
| 1983 | { |
| 1984 | driver: ProviderDriverKind.make("cursor"), |
| 1985 | transcriptFile: new URL( |
| 1986 | "./turn_interrupt_mid_tool/cursor_transcript.ndjson", |
| 1987 | import.meta.url, |
| 1988 | ), |
| 1989 | modelSelection: CURSOR_MODEL_SELECTION, |
| 1990 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 1991 | assertOutput: assertTurnInterruptMidToolCursorOutput, |
| 1992 | }, |
| 1993 | { |
| 1994 | driver: ProviderDriverKind.make("fx"), |
| 1995 | transcriptFile: new URL("./turn_interrupt_mid_tool/fx_transcript.ndjson", import.meta.url), |
| 1996 | modelSelection: FX_MODEL_SELECTION, |
| 1997 | // fx asks before running the command; a workspace sandbox would deny it. |
| 1998 | runtimePolicyOverride: { |
| 1999 | approvalPolicy: "never", |
| 2000 | sandboxPolicy: { type: "dangerFullAccess" }, |
| 2001 | }, |
| 2002 | assertOutput: assertTurnInterruptMidToolFxOutput, |
| 2003 | }, |
| 2004 | { |
| 2005 | driver: ProviderDriverKind.make("pi"), |
| 2006 | transcriptFile: new URL("./turn_interrupt_mid_tool/pi_transcript.ndjson", import.meta.url), |
| 2007 | modelSelection: PI_MODEL_SELECTION, |
| 2008 | assertOutput: assertTurnInterruptMidToolPiOutput, |
| 2009 | }, |
| 2010 | ], |
| 2011 | }, |
| 2012 | { |
| 2013 | name: "kiro_turn_interrupt_mid_tool", |
| 2014 | buildInput: turnInterruptMidToolKiroInput, |
| 2015 | providers: [ |
| 2016 | { |
| 2017 | driver: ProviderDriverKind.make("kiro"), |
| 2018 | transcriptFile: new URL( |
| 2019 | "./turn_interrupt_mid_tool/kiro_transcript.ndjson", |
| 2020 | import.meta.url, |
| 2021 | ), |
| 2022 | modelSelection: KIRO_MODEL_SELECTION, |
| 2023 | assertOutput: assertTurnInterruptMidToolKiroOutput, |
| 2024 | }, |
| 2025 | ], |
| 2026 | }, |
| 2027 | { |
| 2028 | name: "turn_interrupt_restart", |
| 2029 | buildInput: turnInterruptRestartInput, |
| 2030 | providers: [ |
| 2031 | { |
| 2032 | driver: ProviderDriverKind.make("claudeAgent"), |
| 2033 | transcriptFile: new URL( |
| 2034 | "./turn_interrupt_restart/claude_transcript.ndjson", |
| 2035 | import.meta.url, |
| 2036 | ), |
| 2037 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 2038 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 2039 | assertOutput: assertTurnInterruptRestartClaudeOutput, |
| 2040 | }, |
| 2041 | ], |
| 2042 | }, |
| 2043 | { |
| 2044 | name: "thread_rollback", |
| 2045 | buildInput: threadRollbackInput, |
| 2046 | providers: [ |
| 2047 | { |
| 2048 | driver: ProviderDriverKind.make("codex"), |
| 2049 | transcriptFile: new URL("./thread_rollback/codex_transcript.ndjson", import.meta.url), |
| 2050 | modelSelection: CODEX_MODEL_SELECTION, |
| 2051 | assertOutput: assertThreadRollbackOutput, |
| 2052 | }, |
| 2053 | { |
| 2054 | driver: ProviderDriverKind.make("claudeAgent"), |
| 2055 | transcriptFile: new URL("./thread_rollback/claude_transcript.ndjson", import.meta.url), |
| 2056 | modelSelection: CLAUDE_MODEL_SELECTION, |
| 2057 | assertOutput: assertClaudeThreadRollbackOutput, |
| 2058 | }, |
| 2059 | { |
| 2060 | driver: ProviderDriverKind.make("pi"), |
| 2061 | transcriptFile: new URL("./thread_rollback/pi_transcript.ndjson", import.meta.url), |
| 2062 | modelSelection: PI_MODEL_SELECTION, |
| 2063 | assertOutput: assertPiThreadRollbackOutput, |
| 2064 | }, |
| 2065 | ], |
| 2066 | }, |
| 2067 | { |
| 2068 | name: "thread_rollback_after_restart", |
| 2069 | buildInput: threadRollbackAfterRestartInput, |
| 2070 | providers: [ |
| 2071 | { |
| 2072 | driver: ProviderDriverKind.make("codex"), |
| 2073 | transcriptFile: new URL( |
| 2074 | "./thread_rollback_after_restart/codex_transcript.ndjson", |
| 2075 | import.meta.url, |
| 2076 | ), |
| 2077 | modelSelection: CODEX_MODEL_SELECTION, |
| 2078 | assertOutput: assertThreadRollbackAfterRestartOutput, |
| 2079 | }, |
| 2080 | ], |
| 2081 | }, |
| 2082 | { |
| 2083 | name: "thread_rollback_after_stop", |
| 2084 | buildInput: threadRollbackAfterStopInput, |
| 2085 | providers: [ |
| 2086 | { |
| 2087 | driver: ProviderDriverKind.make("pi"), |
| 2088 | transcriptFile: new URL( |
| 2089 | "./thread_rollback_after_stop/pi_transcript.ndjson", |
| 2090 | import.meta.url, |
| 2091 | ), |
| 2092 | modelSelection: PI_MODEL_SELECTION, |
| 2093 | assertOutput: assertPiThreadRollbackAfterStopOutput, |
| 2094 | }, |
| 2095 | ], |
| 2096 | }, |
| 2097 | { |
| 2098 | name: "thread_rollback_to_stopped_turn", |
| 2099 | buildInput: threadRollbackToStoppedTurnInput, |
| 2100 | providers: [ |
| 2101 | { |
| 2102 | driver: ProviderDriverKind.make("codex"), |
| 2103 | transcriptFile: new URL( |
| 2104 | "./thread_rollback_to_stopped_turn/codex_transcript.ndjson", |
| 2105 | import.meta.url, |
| 2106 | ), |
| 2107 | modelSelection: CODEX_MODEL_SELECTION, |
| 2108 | runtimePolicyOverride: WORKSPACE_NEVER_POLICY, |
| 2109 | assertOutput: assertThreadRollbackToStoppedTurnOutput, |
| 2110 | }, |
| 2111 | ], |
| 2112 | }, |
| 2113 | { |
| 2114 | name: "stop_background_work_after_failed_turn", |
| 2115 | buildInput: stopBackgroundWorkAfterFailedTurnInput, |
| 2116 | providers: [ |
| 2117 | { |
| 2118 | driver: ProviderDriverKind.make("acpRegistry"), |
| 2119 | transcriptFile: new URL( |
| 2120 | "./stop_background_work_after_failed_turn/registry_transcript.ndjson", |
| 2121 | import.meta.url, |
| 2122 | ), |
| 2123 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 2124 | assertOutput: assertStopBackgroundWorkAfterFailedTurnOutput, |
| 2125 | }, |
| 2126 | ], |
| 2127 | }, |
| 2128 | { |
| 2129 | name: "stop_background_work_after_release", |
| 2130 | buildInput: stopBackgroundWorkAfterReleaseInput, |
| 2131 | providers: [ |
| 2132 | { |
| 2133 | driver: ProviderDriverKind.make("acpRegistry"), |
| 2134 | transcriptFile: new URL( |
| 2135 | "./stop_background_work_after_failed_turn/registry_transcript.ndjson", |
| 2136 | import.meta.url, |
| 2137 | ), |
| 2138 | recordedScenario: "stop_background_work_after_failed_turn", |
| 2139 | modelSelection: ACP_REGISTRY_MODEL_SELECTION, |
| 2140 | assertOutput: assertStopBackgroundWorkAfterFailedTurnOutput, |
| 2141 | }, |
| 2142 | ], |
| 2143 | }, |
| 2144 | ]; |