@@ -921,6 +921,189 @@ describe("ProviderRuntimeIngestion", () => {
921921 await waitForThread ( harness . readModel , ( thread ) => thread . session ?. status === "ready" ) ;
922922 } ) ;
923923
924+ it ( "closes the session lifecycle when the active turn is aborted" , async ( ) => {
925+ const harness = await createHarness ( ) ;
926+ const now = "2026-01-01T00:00:00.000Z" ;
927+
928+ // Regression: an interrupt whose abort lands while the provider is already
929+ // idle emits `turn.aborted` instead of `turn.completed`. Without an
930+ // ingestion handler the thread stayed "running" with a dangling active
931+ // turn forever: stop looked like a no-op and settling was refused.
932+ harness . emit ( {
933+ type : "turn.started" ,
934+ eventId : asEventId ( "evt-turn-started-abort-lifecycle" ) ,
935+ provider : ProviderDriverKind . make ( "opencode" ) ,
936+ createdAt : now ,
937+ threadId : asThreadId ( "thread-1" ) ,
938+ turnId : asTurnId ( "turn-abort-lifecycle" ) ,
939+ } ) ;
940+
941+ await waitForThread (
942+ harness . readModel ,
943+ ( thread ) =>
944+ thread . session ?. status === "running" &&
945+ thread . session ?. activeTurnId === "turn-abort-lifecycle" ,
946+ ) ;
947+
948+ harness . emit ( {
949+ type : "content.delta" ,
950+ eventId : asEventId ( "evt-message-delta-abort-lifecycle" ) ,
951+ provider : ProviderDriverKind . make ( "opencode" ) ,
952+ createdAt : now ,
953+ threadId : asThreadId ( "thread-1" ) ,
954+ turnId : asTurnId ( "turn-abort-lifecycle" ) ,
955+ itemId : asItemId ( "item-abort-lifecycle" ) ,
956+ payload : { streamKind : "assistant_text" , delta : "partial answer" } ,
957+ } ) ;
958+ harness . emit ( {
959+ type : "turn.proposed.delta" ,
960+ eventId : asEventId ( "evt-plan-delta-abort-lifecycle" ) ,
961+ provider : ProviderDriverKind . make ( "opencode" ) ,
962+ createdAt : now ,
963+ threadId : asThreadId ( "thread-1" ) ,
964+ turnId : asTurnId ( "turn-abort-lifecycle" ) ,
965+ payload : { delta : "## Partial plan\n\n- keep this" } ,
966+ } ) ;
967+
968+ harness . emit ( {
969+ type : "turn.aborted" ,
970+ eventId : asEventId ( "evt-turn-aborted-lifecycle" ) ,
971+ provider : ProviderDriverKind . make ( "opencode" ) ,
972+ createdAt : now ,
973+ threadId : asThreadId ( "thread-1" ) ,
974+ turnId : asTurnId ( "turn-abort-lifecycle" ) ,
975+ payload : { reason : "Interrupted by user." } ,
976+ } ) ;
977+
978+ const thread = await waitForThread (
979+ harness . readModel ,
980+ ( entry ) =>
981+ entry . session ?. status === "ready" &&
982+ entry . session ?. activeTurnId === null &&
983+ entry . messages . some (
984+ ( message : ProviderRuntimeTestMessage ) =>
985+ message . id === "assistant:item-abort-lifecycle" && ! message . streaming ,
986+ ) &&
987+ entry . proposedPlans . some (
988+ ( plan : ProviderRuntimeTestProposedPlan ) =>
989+ plan . id === "plan:thread-1:turn:turn-abort-lifecycle" ,
990+ ) ,
991+ ) ;
992+ expect (
993+ thread . messages . find (
994+ ( message : ProviderRuntimeTestMessage ) => message . id === "assistant:item-abort-lifecycle" ,
995+ ) ?. text ,
996+ ) . toBe ( "partial answer" ) ;
997+ expect (
998+ thread . proposedPlans . find (
999+ ( plan : ProviderRuntimeTestProposedPlan ) =>
1000+ plan . id === "plan:thread-1:turn:turn-abort-lifecycle" ,
1001+ ) ?. planMarkdown ,
1002+ ) . toBe ( "## Partial plan\n\n- keep this" ) ;
1003+ } ) ;
1004+
1005+ it ( "ignores stale turn.aborted events" , async ( ) => {
1006+ const harness = await createHarness ( ) ;
1007+ const now = "2026-01-01T00:00:00.000Z" ;
1008+
1009+ harness . emit ( {
1010+ type : "turn.started" ,
1011+ eventId : asEventId ( "evt-turn-started-abort-guarded" ) ,
1012+ provider : ProviderDriverKind . make ( "opencode" ) ,
1013+ createdAt : now ,
1014+ threadId : asThreadId ( "thread-1" ) ,
1015+ turnId : asTurnId ( "turn-abort-guarded-main" ) ,
1016+ } ) ;
1017+
1018+ await waitForThread (
1019+ harness . readModel ,
1020+ ( thread ) =>
1021+ thread . session ?. status === "running" &&
1022+ thread . session ?. activeTurnId === "turn-abort-guarded-main" ,
1023+ ) ;
1024+
1025+ harness . emit ( {
1026+ type : "content.delta" ,
1027+ eventId : asEventId ( "evt-message-delta-abort-guarded" ) ,
1028+ provider : ProviderDriverKind . make ( "opencode" ) ,
1029+ createdAt : now ,
1030+ threadId : asThreadId ( "thread-1" ) ,
1031+ turnId : asTurnId ( "turn-abort-guarded-main" ) ,
1032+ itemId : asItemId ( "item-abort-guarded-main" ) ,
1033+ payload : { streamKind : "assistant_text" , delta : "still running" } ,
1034+ } ) ;
1035+ harness . emit ( {
1036+ type : "turn.proposed.delta" ,
1037+ eventId : asEventId ( "evt-plan-delta-abort-guarded" ) ,
1038+ provider : ProviderDriverKind . make ( "opencode" ) ,
1039+ createdAt : now ,
1040+ threadId : asThreadId ( "thread-1" ) ,
1041+ turnId : asTurnId ( "turn-abort-guarded-main" ) ,
1042+ payload : { delta : "## Active plan\n\n- do not finalize" } ,
1043+ } ) ;
1044+
1045+ harness . emit ( {
1046+ type : "turn.aborted" ,
1047+ eventId : asEventId ( "evt-turn-aborted-guarded-stale" ) ,
1048+ provider : ProviderDriverKind . make ( "opencode" ) ,
1049+ createdAt : now ,
1050+ threadId : asThreadId ( "thread-1" ) ,
1051+ turnId : asTurnId ( "turn-abort-guarded-stale" ) ,
1052+ payload : { reason : "Interrupted by user." } ,
1053+ } ) ;
1054+
1055+ await harness . drain ( ) ;
1056+ const readModel = await harness . readModel ( ) ;
1057+ const thread = readModel . threads . find ( ( entry ) => entry . id === ThreadId . make ( "thread-1" ) ) ;
1058+ expect ( thread ?. session ?. status ) . toBe ( "running" ) ;
1059+ expect ( thread ?. session ?. activeTurnId ) . toBe ( "turn-abort-guarded-main" ) ;
1060+ expect (
1061+ thread ?. messages . some (
1062+ ( message : ProviderRuntimeTestMessage ) => message . id === "assistant:item-abort-guarded-main" ,
1063+ ) ,
1064+ ) . toBe ( false ) ;
1065+ expect (
1066+ thread ?. proposedPlans . some (
1067+ ( plan : ProviderRuntimeTestProposedPlan ) =>
1068+ plan . id === "plan:thread-1:turn:turn-abort-guarded-main" ,
1069+ ) ,
1070+ ) . toBe ( false ) ;
1071+
1072+ harness . emit ( {
1073+ type : "session.exited" ,
1074+ eventId : asEventId ( "evt-session-exited-abort-guarded" ) ,
1075+ provider : ProviderDriverKind . make ( "opencode" ) ,
1076+ createdAt : now ,
1077+ threadId : asThreadId ( "thread-1" ) ,
1078+ payload : { reason : "Provider stopped" , exitKind : "graceful" } ,
1079+ } ) ;
1080+
1081+ await waitForThread (
1082+ harness . readModel ,
1083+ ( entry ) => entry . session ?. status === "stopped" && entry . session ?. activeTurnId === null ,
1084+ ) ;
1085+
1086+ // The formerly active turn is no longer authoritative after session exit.
1087+ // A delayed or duplicate abort must not revive the stopped session as ready.
1088+ harness . emit ( {
1089+ type : "turn.aborted" ,
1090+ eventId : asEventId ( "evt-turn-aborted-guarded-late" ) ,
1091+ provider : ProviderDriverKind . make ( "opencode" ) ,
1092+ createdAt : now ,
1093+ threadId : asThreadId ( "thread-1" ) ,
1094+ turnId : asTurnId ( "turn-abort-guarded-main" ) ,
1095+ payload : { reason : "Interrupted by user." } ,
1096+ } ) ;
1097+
1098+ await harness . drain ( ) ;
1099+ const finalReadModel = await harness . readModel ( ) ;
1100+ const finalThread = finalReadModel . threads . find (
1101+ ( entry ) => entry . id === ThreadId . make ( "thread-1" ) ,
1102+ ) ;
1103+ expect ( finalThread ?. session ?. status ) . toBe ( "stopped" ) ;
1104+ expect ( finalThread ?. session ?. activeTurnId ) . toBeNull ( ) ;
1105+ } ) ;
1106+
9241107 it ( "ignores non-active turn completion when runtime omits thread id" , async ( ) => {
9251108 const harness = await createHarness ( ) ;
9261109 const now = "2026-01-01T00:00:00.000Z" ;
0 commit comments