zidane 5.0.5 → 5.1.0

package/dist/theme-CcGLMJrn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-CcGLMJrn.d.ts","names":[],"sources":["../src/chat/agents.ts","../src/chat/providers.ts","../src/chat/auth.ts","../src/chat/completion.ts","../src/chat/keybindings.ts","../src/chat/types.ts","../src/chat/store.ts","../src/chat/config.ts","../src/chat/enabled-toggle-set.ts","../src/chat/interactions.tsx","../src/chat/mcps-discovery.ts","../src/chat/prompt-segments.ts","../src/chat/safe-mode-context.tsx","../src/chat/session-export.ts","../src/chat/theme.ts"],"mappings":";;;;;;;;;;;;KAyBY,WAAA;AAAA,UAEK,YAAA;EAeN;EAbT,EAAA;EAaoB;EAXpB,KAAA;EAcuB;EAZvB,WAAA;EAYkD;;;;;;EALlD,MAAA,EAAQ,MAAA;EAK0C;EAHlD,MAAA,GAAS,WAAA;AAAA;AAAA,KAGC,aAAA,GAAgB,QAAA,CAAS,MAAA,SAAe,YAAA;;;;;AAwFpD;;;;;AAqBA;;;;;AAkBA;;;;;AAMA;cAzGa,6BAAA;;;;AAiHb;;;;;;;;cArDa,WAAA,EAAa,YAAA;;AAwE1B;;;;;cAnDa,UAAA,EAAY,YAAA;;;;;;cAkBZ,cAAA,EAAgB,aAAA;AChJ7B;AAAA,cDsJa,gBAAA;;;;;;;iBAQG,cAAA,CACd,QAAA,EAAU,aAAA,EACV,WAAA,sBACA,SAAA;;;;;;;iBAgBc,mBAAA,CAAoB,MAAA,EAAQ,MAAA,GAAS,aAAA;;;;AAlLrD;;;;;;;;;;;UCCiB,SAAA;EACf,EAAA;EACA,IAAA;EACA,aAAA;EACA,SAAA;EACA,SAAA;EACA,KAAA;EACA,IAAA;IAAS,KAAA;IAAe,MAAA;IAAgB,SAAA;IAAoB,UAAA;EAAA;EAC5D,QAAA;AAAA;AAAA,UAGe,kBAAA;ED0ChB;;;;ECrCC,GAAA;EDsGD;ECpGC,KAAA;EDuFwB;;AAqB1B;;;;;ECpGE,OAAA,QAAe,QAAA;EDyHhB;;;;AAGD;;;;ECnHE,YAAA;ED2Hc;;;;;ECrHd,MAAA;EDuHA;;;;AAiBF;;ECjIE,iBAAA;EDiIgE;EC/HhE,iBAAA;ED+HkC;;;;EC1HlC,aAAA,GAAgB,sBAAA;;;AAvDlB;;;;EA8DE,SAAA;EA5DA;;;;EAiEA,YAAA;EA5DA;;;;;EAkEA,MAAA,YAAkB,SAAA;AAAA;;iBAIJ,SAAA,CAAU,IAAA,EAAM,kBAAA;;iBAKhB,MAAA,CAAO,IAAA,EAAM,kBAAA;AAAA,cAQhB,mBAAA,EAAqB,kBAAA;AAAA,cAWrB,gBAAA,EAAkB,kBAAA;AAAA,cAYlB,oBAAA,EAAsB,kBAAA;AAAA,cAStB,kBAAA,EAAoB,kBAAA;;;;;;;;;;cAkBpB,iBAAA,EAAmB,QAAA,CAAS,MAAA,SAAe,kBAAA;;;;;;;iBAiBxC,mBAAA,CAAoB,UAAA,EAAY,kBAAA,YAA8B,SAAA;AAhF9E;;;;;AAKA;AALA,iBAiGgB,YAAA,CAAa,UAAA,EAAY,kBAAA,EAAoB,OAAA,WAAkB,SAAA;;;;AApF/E;;iBAoGgB,gBAAA,CAAiB,UAAA,EAAY,kBAAA,EAAoB,OAAA;;;AAzFjE;;;;;AAYA;;;cA2Fa,qBAAA;;AAlFb;;;;;AAkBA;;;;;iBA6EgB,sBAAA,CAAuB,SAAA;;;;;;;;iBAavB,sBAAA,CAAuB,UAAA,EAAY,kBAAA,EAAoB,OAAA;;;;;;;;KCxP3D,WAAA;AAAA,UAEK,UAAA;EACf,MAAA;;EAEA,MAAA;AAAA;AAAA,UAGe,YAAA;EACf,GAAA,EAAK,WAAA;EACL,KAAA;EFsBoB;EEpBpB,SAAA;EACA,OAAA,EAAS,UAAA;AAAA;;;;;;;AFsBX;;;;;;;iBENgB,UAAA,CACd,OAAA,UACA,QAAA,EAAU,QAAA,CAAS,MAAA,SAAe,kBAAA,IAClC,GAAA,GAAK,MAAA,+BACJ,YAAA;;;;;;;;;;AFlBH;;;;;AAEA;;;;;;;;;;;UGGiB,cAAA;EHYK;EGVpB,EAAA;EHauB;EGXvB,KAAA;EHWkD;EGTlD,WAAA;EHS0B;;;;;EGH1B,UAAA;EHG8D;EGD9D,IAAA,EAAM,KAAA;AAAA;;;;;AHyFR;;;;;UG7EiB,mBAAA;EACf,UAAA;EACA,KAAA;EACA,GAAA;EACA,MAAA;EACA,IAAA,EAAM,KAAA;AAAA;;;;AHqHR;UG9GiB,kBAAA;;EAEf,EAAA;EH4G2B;AAQ7B;;;;;EG7GE,OAAA;EH+GA;EG7GA,KAAA;EH8G6B;;AAgB/B;;;;;;EGrHE,OAAA,GACE,KAAA,UACA,GAAA,EAAK,iBAAA,EACL,MAAA,EAAQ,WAAA,KACL,cAAA,CAAe,KAAA,MAAW,OAAA,CAAQ,cAAA,CAAe,KAAA;EHiHU;;;;;EG3GhE,eAAA,GACE,IAAA,UACA,GAAA,EAAK,iBAAA,KACF,mBAAA,CAAoB,KAAA;AAAA;;;;;UAOV,iBAAA;EF5Ef;EE8EA,IAAA;EF5EA;EE8EA,MAAA;AAAA;;;;;;UAQe,aAAA;EACf,QAAA,EAAU,kBAAA,CAAmB,KAAA;EFlFI;EEoFjC,KAAA;EFrEe;EEuEf,IAAA;IAAQ,KAAA;IAAe,GAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAoBT,iBAAA,OAAA,CACd,IAAA,UACA,MAAA,UACA,SAAA,WAAoB,kBAAA,CAAmB,KAAA,KACvC,OAAA;EAAW,cAAA;AAAA,IACV,aAAA,CAAc,KAAA;;;;;iBAqCD,WAAA,CACd,IAAA,UACA,IAAA;EAAQ,KAAA;EAAe,GAAA;AAAA,GACvB,UAAA;EACG,IAAA;EAAc,MAAA;AAAA;;;;AF9DnB;;;iBEyEgB,eAAA,OAAA,CACd,IAAA,WAAe,mBAAA,CAAoB,KAAA,MAClC,mBAAA,CAAoB,KAAA;;AF/DvB;;;;iBEiFgB,iBAAA,OAAA,CACd,IAAA,UACA,SAAA,WAAoB,kBAAA,CAAmB,KAAA,KACvC,MAAA,YACC,mBAAA,CAAoB,KAAA;AF5EvB;AAAA,UE2FiB,eAAA;;EAEf,MAAA,EAAQ,aAAA,CAAc,KAAA;EFtFvB;EEwFC,KAAA,WAAgB,cAAA,CAAe,KAAA;EFxEhC;EE0EC,OAAA;EF/EsD;EEiFtD,aAAA;EFjF8B;EEmF9B,UAAA;EACA,UAAA;EFpF8B;;;;EEyF9B,MAAA;IAAgB,IAAA;IAAc,MAAA;EAAA;EFxEuD;EE0ErF,OAAA;EF1EkC;EE4ElC,UAAA,WAAqB,mBAAA,CAAoB,KAAA;AAAA;;AF3D3C;;;;;;;;;;AAgBA;iBE0DgB,aAAA,iBAAA,CACd,KAAA;EAAS,IAAA;EAAc,MAAA;AAAA,GACvB,SAAA,WAAoB,kBAAA,CAAmB,KAAA,KACvC,OAAA;EAAW,cAAA;AAAA,IACV,eAAA,CAAgB,KAAA;;;;;;;;;;AH/PnB;;;;;AAEA;;;;;;;;;;;;;AAkBA;;;;;;;;;KIHY,SAAA;;KAkCA,WAAA,GAAc,MAAA,CAAO,SAAA;;UAGhB,aAAA;EJEhB;EIAC,MAAA,EAAQ,SAAA;EJAT;EIEC,OAAA;EJkDW;EIhDX,KAAA;;EAEA,WAAA;AAAA;AJmEF;;;;AAAA,cI5Da,eAAA,WAA0B,aAAA;AJ8EvC;AAAA,cIkDa,wBAAA,EAA0B,QAAA,CAAS,MAAA,CAAO,SAAA,EAAW,aAAA;;cAOrD,mBAAA,EAAqB,WAAA;;UAWjB,aAAA;EACf,IAAA;EACA,KAAA;EACA,GAAA;EACA,IAAA;EJ1Dc;EI4Dd,IAAA;AAAA;;;;;;;;AJzCF;;;;;iBI4FgB,gBAAA,CAAiB,IAAA,8BAAkC,aAAA;;;;;;;AH7QnE;;;;;iBGsTgB,cAAA,CACd,KAAA;EAAS,IAAA;EAAe,IAAA;EAAgB,KAAA;EAAiB,IAAA;EAAgB,MAAA;EAAkB,GAAA;AAAA,GAC3F,IAAA,WAAe,aAAA;;;;;;AH7SjB;iBG4UgB,gBAAA,CACd,SAAA,EAAW,QAAA,CAAS,MAAA,wCACnB,WAAA;;iBAgBa,eAAA,CAAgB,OAAA;;;;;;;;;;;;;iBAgBhB,eAAA,CAAgB,OAAA,WAAkB,WAAA;;;;;;;;iBAuBlC,qBAAA,CAAsB,OAAA;;;;;AH9TtC;;;;;AAQA;;;iBGuXgB,iBAAA,CAAkB,KAAA;;;KC1etB,MAAA;;KAGA,KAAA;AAAA,UAEK,WAAA;EACf,IAAA;ELgBU;;;;;AAEZ;;;;EAFY;EAMV;;;;EAAA;EAWS;;;AAGX;;;;;;;;EAHW;EKGT,IAAA;ELAkD;;;AA4BpD;;EKtBE,OAAA;IL8BD,iFK5BG,aAAA,ULgFS;IK9ET,KAAA,UL8EsB;IK5EtB,WAAA,ULyFH;IKvFG,WAAA;IACA,YAAA;IACA,eAAA;IACA,mBAAA;EAAA;EL8GS;;;;;AAMb;;EK3GE,SAAA;EL2G2B;EKzG3B,OAAA;ELiHc;EK/Gd,KAAA;;;;;;;EAOA,IAAA;EL2G6B;AAgB/B;;;;;EKpHE,KAAA,GAAQ,MAAA;ELoH2C;;;;;;ACjLrD;EIqEE,IAAA,GAAO,WAAA;;;;;;;;;;EAUP,IAAA;IAAkB,KAAA;IAAe,GAAA;IAAa,UAAA;EAAA;EJvEtC;;AAGV;;;;;;;;;EIgFE,MAAA;AAAA;;;;;;;;;;;;;;AJdF;;;;;UImCiB,WAAA;EJ9BK;EIgCpB,IAAA;EJhC2B;EIkC3B,IAAA;EJ1BW;EI4BX,KAAA,WAAgB,QAAA;AAAA;AAAA,UAGD,QAAA;EACf,SAAA;EACA,SAAA;EJZD;EIcC,UAAA;AAAA;AAAA,UAGe,MAAA;EACf,QAAA,EAAU,YAAA;EACV,KAAA;;;;AJRF;;;EIeE,MAAA,GAAS,aAAA;AAAA;AAAA,UAGM,WAAA;EACf,EAAA;EACA,KAAA;EJFsD;EIItD,SAAA;EJJ8B;EIM9B,gBAAA;EJNsC;EIQtC,QAAA;EJRuC;;;;AAiBzC;;EIFE,WAAA;EACA,SAAA;AAAA;;;;;AJkBF;;;;;;;;;;KIDY,eAAA;;UAGK,QAAA;EACf,YAAA;EJa2C;;;;;EIP3C,eAAA,EAAiB,eAAA;EACjB,eAAA;;;;AJiCF;;EI3BE,QAAA;EJ2BqC;;AAavC;;;;;;;;EI7BE,kBAAA;;;;AH3NF;;EGiOE,KAAA;EHjOqB;;AAEvB;;;;;EGuOE,eAAA;EHjO2B;;;;;;;;;;;EG6O3B,iBAAA;EHxNwB;;;;;;;;;;;;;;;EGwOxB,kBAAA;EHpOC;;;;;;ACbH;;;;;;;;;;;;EEoQE,WAAA;EF1Oe;;;;;;;;;;;;EEuPf,oBAAA;EF3Oe;;;;;;;;;;;EEuPf,aAAA;EFtNK;;;;;EE4NL,aAAA;EFlPA;;;;;EEwPA,WAAA;AAAA;;;UC9Re,QAAA;EACf,YAAA,GAAe,WAAA;EACf,aAAA;ENlBU;EMoBV,mBAAA,GAAsB,OAAA,CAAQ,MAAA,CAAO,WAAA;;;;ANlBvC;;EMwBE,iBAAA,GAAoB,MAAA,SAAe,aAAA;ENTf;;;;;;EMgBpB,SAAA;ENhBS;EMkBT,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA;AAAA,UAGJ,aAAA;EACf,IAAA,QAAY,QAAA;EACZ,IAAA,GAAO,KAAA,EAAO,QAAA;AAAA;AAAA,iBAGA,gBAAA,CAAiB,IAAA,WAAe,aAAA;AAAA,iBAOhC,SAAA,CAAU,IAAA,WAAe,QAAA;AAAA,iBAczB,SAAA,CAAU,IAAA,UAAc,KAAA,EAAO,QAAA;;;;;;ANhB/C;;;;;iBM0CsB,eAAA,CACpB,KAAA,EAAO,YAAA,EACP,MAAA;EN6BD;;;;AAQD;;EM9BI,WAAA;AAAA,IAED,OAAA,CAAQ,WAAA;;iBA+BK,cAAA,CAAe,KAAA,EAAO,WAAA;;;;;ANqBtC;;;;;AAQA;iBMNgB,kBAAA,CACd,KAAA,EAAO,WAAA,IACP,QAAA,GAAW,MAAA;;;;;;;;;ANuBb;;;;;;;;;;iBMGgB,eAAA,CACd,KAAA,EAAO,WAAA,IACP,IAAA,YAAe,UAAA,KACd,WAAA;;iBAyOa,eAAA,CAAgB,IAAA,UAAc,KAAA,EAAO,MAAA;;iBAMrC,cAAA,CAAe,MAAA,WAAiB,iBAAA;;;;;;;;;;;;;;iBAiBhC,oBAAA,CAAqB,IAAA;;AL5arC;;;;;;;;;;;;;;;;iBKgdgB,iBAAA,CAAkB,MAAA,WAAiB,WAAA;;;;;;;;AL9YnD;;;;;AAKA;iBKsagB,wBAAA,CACd,KAAA,EAAO,WAAA,IACP,IAAA,YAAe,UAAA;;;;;AN3fjB;;;;KOMY,gBAAA,GAAmB,QAAA,CAAS,MAAA,SAAe,kBAAA;;;;;;UAOtC,WAAA;EPEK;;AAGtB;;;EOCE,MAAA;EPDmC;;;;EOMnC,UAAA;EPNmC;;;;AA4BrC;;;;;AA4DA;;EOtEE,SAAA,GAAY,gBAAA;EPsEY;;AAqB1B;;;;;AAkBA;EOpGE,MAAA,GAAS,MAAA;;;;AP0GX;;;;;AAQA;;;;EOrGE,MAAA,GAAS,aAAA;EPsGT;;;;;EOhGA,YAAA;EPkHiC;;;;;;;;;;;ACjLnC;;;;;;;;EMmFE,KAAA,EAAO,YAAA,KAAiB,KAAA,EAAO,aAAA,KAAkB,YAAA;EN7EjD;;;;;;;;;AAKF;;;;;EMuFE,SAAA;ENzB2B;;;;;;EMgC3B,GAAA;AAAA;;UAIe,aAAA;ENtDf;;;;;;EM6DA,GAAA;EN3C2B;AAI7B;;;;;EM8CE,OAAA;ENzCoB;;;;EM8CpB,UAAA;EN7BD;EM+BC,EAAA;ENxCgC;EM0ChC,KAAA;AAAA;AAAA,UAOe,cAAA;EACf,MAAA;EACA,UAAA;EACA,KAAA,EAAO,aAAA;EACP,SAAA,EAAW,gBAAA;ENvBZ;;;;EM4BC,MAAA,EAAQ,aAAA;ENnBT;EMqBC,cAAA;EACA,KAAA,EAAO,YAAA;EACP,UAAA,EAAY,aAAA;ENZD;EMcX,SAAA,GAAY,GAAA,EAAK,WAAA,cAAyB,SAAA;EAC1C,YAAA,EAAc,QAAA;EACd,eAAA,EAAiB,OAAA,CAAQ,QAAA;EACzB,cAAA,EAAgB,YAAA;EAChB,aAAA,EAAe,MAAA;ENlBuB;;;;;;EMyBtC,WAAA,EAAa,WAAA;AAAA;;iBAIC,aAAA,CAAc,OAAA,EAAS,WAAA,GAAc,cAAA;;;;;;;;;;AP5KrD;;;;;AAEA;;;;;;;;;;KQDY,mBAAA;AAAA,UAEK,gBAAA;ERcK;EQZpB,UAAA,EAAY,WAAA;EReW;EQbvB,MAAA,GAAS,IAAA;AAAA;;;;;;;;iBAUK,mBAAA,GAAA,CAAuB,IAAA;EACrC,OAAA,WAAkB,CAAA;EAClB,KAAA,GAAQ,KAAA,EAAO,CAAA;EACf,UAAA,EAAY,mBAAA;AAAA,IACV,gBAAA;;;cCDS,iBAAA;AAAA,cACA,aAAA;;iBAGG,iBAAA,CAAkB,IAAA;AAAA,UAQjB,QAAA;EACf,EAAA;EACA,KAAA;EACA,WAAA;AAAA;AAAA,UAGe,WAAA;ET2FJ;ESzFX,KAAA;;EAEA,IAAA;ETkGD;EShGC,KAAA,YAAiB,QAAA;AAAA;AAAA,UAGF,cAAA;EACf,EAAA;EACA,KAAA;EACA,WAAA;AAAA;;;;AT+GF;;;;;;;;KSjGY,YAAA;AAAA,UAEF,YAAA;ETkHM;EShHd,EAAA;;EAEA,MAAA;ET8G0C;ES5G1C,WAAA;ET4GmD;;;;;;ESrGnD,QAAA;AAAA;AAAA,UAGe,YAAA,SAAqB,YAAA;EACpC,IAAA;ER/EA;EQiFA,WAAA;ER/EA;EQiFA,OAAA;AAAA;AAAA,UAGe,cAAA,SAAuB,YAAA;EACtC,IAAA;EACA,OAAA,WAAkB,cAAA;AAAA;AAAA,UAGH,eAAA,SAAwB,YAAA;EACvC,IAAA;ERrFA;EQuFA,WAAA;ERvFQ;EQyFR,SAAA;AAAA;AAAA,KAGU,QAAA,GAAW,YAAA,GAAe,cAAA,GAAiB,eAAA;AAAA,UAEtC,eAAA;ER/CC;EQiDhB,KAAA;ER/B2B;EQiC3B,SAAA,WAAoB,QAAA;AAAA;;KAIV,WAAA;AAAA,UAEF,WAAA;ER7ER;EQ+EA,EAAA;ERlEA;EQoEA,IAAA;ER7DA;EQ+DA,KAAA;ERxDA;EQ0DA,MAAA;ER/CA;EQiDA,SAAA;AAAA;AAAA,UAGe,WAAA,SAAoB,WAAA;EACnC,IAAA;EACA,IAAA,SAAa,iBAAA;EACb,OAAA,EAAS,WAAA;AAAA;AAAA,UAGM,eAAA,SAAwB,WAAA;EACvC,IAAA;EACA,IAAA,SAAa,aAAA;EACb,OAAA,EAAS,eAAA;AAAA;AAAA,KAGC,kBAAA,GAAqB,WAAA,GAAc,eAAA;AAAA,KAOnC,YAAA;AAAA,UAEK,YAAA;EACf,IAAA;EACA,QAAA,EAAU,YAAA;ERjDX;EQmDC,OAAA;AAAA;AAAA,UAGe,gBAAA;EACf,IAAA;ER3CD;AAED;;;;EQ+CE,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,WAAA;AAAA;AAAA,KAGvB,mBAAA,GAAsB,YAAA,GAAe,gBAAA;;;;ARvBjD;;iBQkCgB,4BAAA,CAA6B,QAAA,EAAU,mBAAA;;;;;;;;;;;ARjBvD;;iBQsEgB,2BAAA,CACd,QAAA,WAAmB,kBAAA,IACnB,SAAA,EAAW,WAAA,SAAoB,mBAAA,GAC/B,OAAA;ERzEqF,2CQ2EnF,MAAA;ER3EgC;;;;AAiBpC;;EQiEI,KAAA,WRjEoF;EQmEpF,SAAA;AAAA,IAED,WAAA;;;;;ARrDH;;;;;;;iBQoGgB,4BAAA,CAA6B,KAAA,WAAgB,WAAA,KAAgB,kBAAA;AAAA,UA0O5D,6BAAA;ERhUJ;;;;;AAab;EQ0TE,kBAAA,GAAqB,OAAA,EAAS,kBAAA,KAAuB,OAAA,CAAQ,mBAAA;AAAA;;;AR7S/D;;iBQoTgB,sBAAA,CAAuB,IAAA,EAAM,6BAAA,GAAgC,MAAA,SAAe,OAAA;AAAA,UAmL3E,uBAAA;EACf,OAAA,EAAS,kBAAA;ERxe4B;EQ0erC,OAAA,GAAU,QAAA,EAAU,mBAAA;ER1egE;;;;;ACxPtF;EOyuBE,MAAA,GAAS,MAAA;AAAA;AAAA,UAGM,mBAAA;EP5uBM;EO8uBrB,OAAA,GAAU,KAAA,EAAO,uBAAA;EP5uBQ;EO8uBzB,WAAA,GAAc,QAAA,EAAU,mBAAA;EP7uBxB;;AAKF;;;;;EOgvBE,UAAA,GAAa,MAAA;EP9uBb;EOgvBA,SAAA,GAAY,MAAA;AAAA;AAAA,iBAME,oBAAA,CAAA;EAAuB;AAAA;EAAc,QAAA,EAAU,SAAA;AAAA,IAAW,oBAAA,CAAA,GAAA,CAAA,OAAA;APnuB1E;AAAA,iBOqxBgB,oBAAA,CAAA,YAAiC,uBAAA;;iBAKjC,sBAAA,CAAA,GAA0B,mBAAA;;;;;;;iBAkB1B,sBAAA,CACd,OAAA,EAAS,mBAAA,GACR,6BAAA;;;AT1zBH;;;;AAAA,UUNiB,aAAA;EACf,MAAA,EAAQ,eAAA;EACR,MAAA;EACA,IAAA;AAAA;;;;;AVqBF;iBUbgB,sBAAA,CAAuB,IAAA;EACrC,GAAA;EACA,IAAA;EACA,MAAA;AAAA;EACS,IAAA;EAAc,MAAA;AAAA;;;;;AVqCzB;;;;;AA4DA;;;;;AAqBA;;;;;AAkBA;;;;;iBU5GgB,aAAA,CAAc,IAAA,WAAe,eAAA;;;;;AV0H7C;UUOiB,cAAA;EACf,IAAA;EACA,MAAA;EACA,OAAA;AAAA;;;;;AVSF;;UUAiB,eAAA;EACf,OAAA,EAAS,aAAA;EACT,MAAA,EAAQ,cAAA;AAAA;;;;;;;ATnLV;;;;iBSgMgB,mBAAA,CAAoB,IAAA;EAClC,GAAA;EACA,IAAA;EACA,MAAA;AAAA,IACO,eAAA;;;;;;;;;;ATzLT;;;iBSgOgB,eAAA,CAAgB,IAAA;EAC9B,UAAA,WAAqB,aAAA;EACrB,OAAA;AAAA,IACE,eAAA;;;;;;;;;;AVjPJ;;;;;AAEA;;;;UWViB,gBAAA;EACf,KAAA;EACA,GAAA;EXqBA;EWnBA,UAAA;AAAA;;;;AXwBF;;;KWfY,aAAA;EACJ,IAAA;EAAe,IAAA;AAAA;EACf,IAAA;EAAc,IAAA;EAAc,UAAA;AAAA;;;AXyCpC;;;;;AA4DA;;;;;AAqBA;;;;;AAkBA;;;;;iBWpHgB,mBAAA,CACd,IAAA,UACA,IAAA,WAAe,gBAAA,KACd,aAAA;;;KCnCS,gBAAA;AAAA,UAEK,eAAA;EACf,EAAA;EACA,IAAA;EACA,KAAA,EAAO,MAAA;EACP,OAAA,GAAU,QAAA,EAAU,gBAAA;AAAA;;KAIV,eAAA,IAAmB,IAAA,UAAc,KAAA,EAAO,MAAA,sBAA4B,OAAA,CAAQ,gBAAA;AAAA,UAEvE,eAAA;EZSmB;EYPlC,eAAA,EAAiB,eAAA;EZOS;EYL1B,WAAA,GAAc,QAAA,EAAU,gBAAA;EZK0B;EYHlD,OAAA;AAAA;AZ+BF;;;;AAAA,iBYZgB,gBAAA,CAAA;EAAmB;AAAA;EAAc,QAAA,EAAU,SAAA;AAAA,IAAW,oBAAA,CAAA,GAAA,CAAA,OAAA;AAAA,iBA8CtD,gBAAA,CAAA,YAA6B,eAAA;AAAA,iBAI7B,kBAAA,CAAA,GAAsB,eAAA;;;;KCnF1B,mBAAA;;;;;;KAOA,mBAAA;;UAGK,mBAAA;EbOmC;EaLlD,GAAA;EbK0B;EaH1B,QAAA;EbGkC;EaDlC,MAAA,EAAQ,mBAAA;AAAA;;UAIA,cAAA;EbHsD;EaK9D,GAAA;Eb+BD;Ea7BC,IAAA;Eb6BD;;AAoDD;;Ea5EE,MAAA;AAAA;;AbiGF;;;;;AAkBA;;;;;AAMA;;iBavGgB,0BAAA,CAA2B,IAAA;EACzC,SAAA;EACA,MAAA,EAAQ,mBAAA;AAAA,IACN,cAAA,GAAiB,mBAAA;;;;;;;;;;Ab+HrB;;;;;;iBanGgB,aAAA,CAAc,OAAA,EAAS,WAAA,EAAa,MAAA,EAAQ,mBAAA;;;;;;AZ9E5D;iBY0FsB,kBAAA,CACpB,IAAA;EAAQ,OAAA,EAAS,WAAA;EAAa,MAAA,EAAQ,mBAAA;AAAA,IAAwB,cAAA,GAC7D,OAAA,CAAQ,mBAAA;;;;;;;;;;Ab/FX;;;;;AAEA;;;;;;;;UcEiB,WAAA;Edaf;EcXA,KAAA;EdWoB;EcTpB,MAAA;EdYU;EcVV,KAAA;;EAEA,IAAA;EdQmC;EcNnC,KAAA;EdMkC;EcJlC,GAAA;EdI0B;EcF1B,IAAA;EdEkD;EcAlD,MAAA;EdA8D;EcE9D,YAAA;AAAA;;UAIe,WAAA;EACf,eAAA;EACA,sBAAA;EACA,uBAAA;EACA,iBAAA;EACA,SAAA;EACA,gBAAA;EACA,wBAAA;AAAA;;UAIe,SAAA;EduGhB;EcrGC,EAAA;Ed+GD;Ec7GC,EAAA;AAAA;;AdgHF;;;;;AAQA;;;;;;;KcxGY,YAAA;EAAiB,OAAA,EAAS,SAAA;AAAA,IAAc,OAAA,CAAQ,MAAA,SAAe,SAAA;Ad2H3E;;;;;;AAAA,iBcnHgB,gBAAA,CAAiB,KAAA,EAAO,YAAA,EAAc,UAAA,WAAqB,SAAA;;UAK1D,aAAA;;EAEf,KAAA;;AbrEF;;;;Ea2EE,KAAA,EAAO,YAAA;EbzEP;;;;;;;EaiFA,SAAA;Eb5EwC;;;;;AAI1C;;;;;;;;;EauFE,IAAA,EAAM,YAAA;AAAA;;UAIS,YAAA;EACf,KAAA;EACA,QAAA;EACA,SAAA;EACA,YAAA;EACA,eAAA;EACA,KAAA;EACA,QAAA;AAAA;;;;AbhCF;UauCiB,gBAAA;EACf,EAAA;EACA,EAAA;EACA,IAAA;EACA,MAAA;EACA,SAAA;EACA,GAAA;AAAA;;AbhCF;;;;;AAWA;;;;;AAYA;KawBY,YAAA,GAAe,MAAA,SAAe,gBAAA;;UAGzB,KAAA;EbpBhB;EasBC,EAAA;EbbD;EaeC,KAAA;EACA,MAAA,EAAQ,WAAA;EACR,MAAA,EAAQ,WAAA;EACR,QAAA,EAAU,aAAA;EACV,MAAA,EAAQ,YAAA;AAAA;AAAA,cAmDG,aAAA,EAAe,KAAA;;;;;;;;;;Ab1C5B;ca4Ka,cAAA,EAAgB,QAAA,CAAS,MAAA,SAAe,KAAA;;iBAUrC,YAAA,CAAa,EAAA,uBAAyB,KAAA"}

package/dist/{tools-CLazLRb4.js → tools-d1yeA6xK.js}

@@ -1,12 +1,12 @@
-import { n as createProcessContext } from "./contexts-3Arvn7yR.js";
+import { n as createProcessContext } from "./contexts-BwiHIr2w.js";
 import { r as AgentProviderError, s as toTypedError, t as AgentAbortedError } from "./errors-D1lhd6mX.js";
 import { t as toolOutputByteLength } from "./types-Bx_F8jet.js";
-import { t as connectMcpServers } from "./mcp-Dw-fRPVk.js";
+import { t as connectMcpServers } from "./mcp-BgwK6ySj.js";
 import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-Ck970-61.js";
-import { n as formatTokenUsage, t as flattenTurns } from "./stats-DZIsGqzu.js";
+import { n as formatTokenUsage, t as flattenTurns } from "./stats-DvCtBRwK.js";
 import { createHooks } from "hookable";
-import { stat } from "node:fs/promises";
-import { resolve } from "node:path";
+import { mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { Buffer } from "node:buffer";
 //#region src/aliasing.ts
 /**
@@ -204,6 +204,256 @@ function installDedupToolsGate(hooks, getDedupTools, getSession) {
 	};
 }
 //#endregion
+//#region src/loop-persistence.ts
+/**
+* Bytes of head content included in the inline preview block. 2 KiB matches
+* Claude Code's `PREVIEW_SIZE_BYTES` — enough for the model to identify the
+* content class (error output / structured data / log shape) and decide
+* whether to call `read_file` on the persisted path for the full payload.
+*
+* Tail-priority preview (matching `shell`'s truncation strategy) was
+* considered but rejected: most "what is this?" decisions get made from
+* the head, and the path is in the stub for the rare case where the tail
+* matters.
+*/
+const PERSISTENCE_PREVIEW_BYTES = 2 * 1024;
+/**
+* Byte-stable prefix every {@link buildPersistedStub} output starts with.
+* Exported so wire-level passes (tail compaction, future stale-output
+* elision) can recognize a persisted stub and preserve its path attribute
+* rather than replacing the stub with their own — losing the pointer to
+* the on-disk blob.
+*
+* Bound to the literal opening of the XML tag; changing the stub format
+* requires updating this constant in lockstep (and shipping a migration
+* for in-flight sessions).
+*/
+const PERSISTED_STUB_PREFIX = "<persisted-output tool=\"";
+/**
+* Characters that are safe to use verbatim as a filesystem segment under
+* `persistDir`. Alphanumeric + `_` + `-` + `.` covers every real-world
+* `tool_use.id` we've seen (Anthropic `toolu_…`, OpenAI `call_…`, Bun
+* `crypto.randomUUID()` style, our own short ids).
+*
+* Anything else — slashes, `..`, control chars, spaces, unicode — is
+* rejected by {@link maybePersistToolResult} so a malformed or hostile
+* `callId` can't escape `persistDir` via path traversal.
+*/
+const SAFE_CALL_ID = /^[\w.-]+$/;
+/**
+* Resolve the per-session persistence directory under `<userDir>/tool-results/<sessionId>/`.
+*
+* The chat layer calls this at session activation and forwards the result
+* via `behavior.persistDir`. Exposed as a public helper so SDK consumers
+* pick the same layout — single source of truth for "where do blobs live".
+*/
+function resolvePersistDir(opts) {
+	if (!isAbsolute(opts.userDir)) throw new Error(`resolvePersistDir: userDir must be absolute, got "${opts.userDir}"`);
+	if (!opts.sessionId) throw new Error("resolvePersistDir: sessionId must be a non-empty string");
+	return join(opts.userDir, "tool-results", opts.sessionId);
+}
+/**
+* Decide-and-persist for a single tool result. Pure decision + filesystem
+* side-effect; returns the new wire-level `output` string when substitution
+* happened, otherwise tells the caller to leave the result alone.
+*
+* Atomicity: writes go through `<path>.tmp` + `rename` so a concurrent
+* read (or a crash mid-write) never sees a half-written blob.
+*
+* `ToolResultContent[]` results (images, structured blocks) currently bypass
+* persistence — the inline image bytes are the point of the call, and a
+* mixed text/image array isn't representable as a single `.txt` file. We
+* may revisit if a tool starts returning very large text-only arrays.
+*/
+async function maybePersistToolResult(input) {
+	if (!input.threshold || input.threshold <= 0) return {
+		kind: "skip",
+		reason: "disabled"
+	};
+	if (input.excludeTools?.includes(input.toolName)) return {
+		kind: "skip",
+		reason: "excluded"
+	};
+	if (typeof input.output !== "string") return {
+		kind: "skip",
+		reason: "unsupported-shape"
+	};
+	if (!isAbsolute(input.persistDir)) return {
+		kind: "skip",
+		reason: "invalid-persist-dir"
+	};
+	if (!SAFE_CALL_ID.test(input.callId) || input.callId.includes("..")) return {
+		kind: "skip",
+		reason: "unsafe-call-id"
+	};
+	const originalBytes = toolOutputByteLength(input.output);
+	if (originalBytes <= input.threshold) return {
+		kind: "skip",
+		reason: "under-threshold"
+	};
+	const persistedPath = join(input.persistDir, `${input.callId}.txt`);
+	try {
+		await writeAtomic(persistedPath, input.output);
+	} catch (err) {
+		return {
+			kind: "error",
+			reason: "write-failed",
+			error: err instanceof Error ? err : new Error(String(err))
+		};
+	}
+	return {
+		kind: "persisted",
+		output: buildPersistedStub({
+			toolName: input.toolName,
+			originalBytes,
+			persistedPath,
+			output: input.output
+		}),
+		originalBytes,
+		persistedPath
+	};
+}
+/**
+* Render the byte-stable `<persisted-output>` stub the model sees in place
+* of the original `tool_result`.
+*
+* Format choices:
+*  - XML wrapper because models reliably parse it as structural.
+*  - Byte count + path in attributes so the model can decide whether to
+*    `read_file` the persisted blob without scanning the preview.
+*  - Preview always shows the head — `shell`'s tail-priority truncation is
+*    irrelevant here because the model has the full path if it needs the
+*    tail.
+*  - No timestamps, no random UUIDs inside the stub: every byte must be
+*    reproducible from the inputs, otherwise re-emission on subsequent
+*    turns would bust the prompt cache.
+*
+* Exported for tests (asserting the byte-stable contract) and for SDK
+* consumers wiring their own persistence middleware against the same
+* surface.
+*/
+function buildPersistedStub(input) {
+	const { slice: previewSlice, bytes: previewBytes } = sliceFirstBytes(input.output, PERSISTENCE_PREVIEW_BYTES);
+	const previewMarker = previewSlice.length < input.output.length ? `\n…(${input.originalBytes - previewBytes} more bytes in persisted file)` : "";
+	return [
+		`${PERSISTED_STUB_PREFIX}${escapeAttr(input.toolName)}" bytes="${input.originalBytes}" path="${escapeAttr(input.persistedPath)}">`,
+		`${previewSlice}${previewMarker}`,
+		"</persisted-output>"
+	].join("\n");
+}
+/**
+* Remove every persisted blob belonging to a session. Called by the chat
+* layer from its session-delete path so closing a session frees the disk
+* footprint alongside the SQLite row.
+*
+* Idempotent — missing directory (session never persisted anything) is a
+* no-op, not an error. Wraps the `rm -rf` so a permissions blip on one
+* blob doesn't propagate to the caller; the chat layer can't usefully
+* recover from "couldn't unlink a result file" mid-delete.
+*/
+async function cleanupPersistedSession(persistRoot) {
+	if (!isAbsolute(persistRoot)) throw new Error(`cleanupPersistedSession: persistRoot must be absolute, got "${persistRoot}"`);
+	try {
+		await rm(persistRoot, {
+			recursive: true,
+			force: true
+		});
+	} catch (err) {
+		if (process.env.ZIDANE_DEBUG) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`[zidane/persistence] cleanup "${persistRoot}" failed: ${msg}\n`);
+		}
+	}
+}
+/**
+* Write-then-rename for atomicity. A concurrent reader (or a crash mid-
+* write) never observes a partial file: the rename is atomic on every
+* POSIX FS, and the destination is either the fully-written file or
+* absent. Creates the parent directory on demand so the caller doesn't
+* have to track which sessions have already initialized their dir.
+*
+* On write failure (disk full, permissions, signal), removes the `.tmp`
+* file so it doesn't accumulate as debris alongside successful blobs.
+* The unlink itself is best-effort — if we can't write to the dir we
+* likely can't unlink from it either, and the original error is what
+* the caller needs to see.
+*
+* Same idiom we use elsewhere (state-store snapshots, session export).
+*/
+async function writeAtomic(path, content) {
+	await mkdir(dirname(path), { recursive: true });
+	const tmp = `${path}.tmp`;
+	try {
+		await writeFile(tmp, content, "utf8");
+		await rename(tmp, path);
+	} catch (err) {
+		await rm(tmp, { force: true }).catch(() => {});
+		throw err;
+	}
+}
+/**
+* Byte length of a UTF-8 string. `Buffer.byteLength` is the canonical
+* answer; pulling it through a small helper keeps `node:buffer` out of
+* call sites that don't otherwise need it.
+*/
+function byteLength(text) {
+	return Buffer.byteLength(text, "utf8");
+}
+/**
+* Take the first `cap` bytes of `text` without splitting a UTF-8
+* codepoint. Returns the substring AND its exact UTF-8 byte length so
+* the caller doesn't repeat the byte walk (the truncation marker in
+* {@link buildPersistedStub} needs both pieces).
+*
+* Iterates with `for...of` so each step yields a full Unicode codepoint
+* (not a UTF-16 code unit). This matters for content above the BMP —
+* emoji, supplementary-plane characters, anything encoded as a surrogate
+* pair in UTF-16. A naive `text[i]` walk would slice mid-pair, leaving a
+* lone surrogate that re-encodes to the UTF-8 replacement character
+* (garbled preview, off-by-one byte accounting).
+*
+* The `ch.length` advance handles both BMP chars (length 1) and surrogate
+* pairs (length 2) uniformly, since `ch` is whatever `for...of` yielded.
+*
+* Returns the original string when it already fits — no allocation when
+* the cap doesn't bite.
+*/
+function sliceFirstBytes(text, cap) {
+	if (cap <= 0) return {
+		slice: "",
+		bytes: 0
+	};
+	const total = byteLength(text);
+	if (total <= cap) return {
+		slice: text,
+		bytes: total
+	};
+	let bytes = 0;
+	let charIdx = 0;
+	for (const ch of text) {
+		const chBytes = byteLength(ch);
+		if (bytes + chBytes > cap) break;
+		bytes += chBytes;
+		charIdx += ch.length;
+	}
+	return {
+		slice: text.slice(0, charIdx),
+		bytes
+	};
+}
+/**
+* Escape `&`, `"`, and `<` for safe inclusion in an XML attribute. The
+* stub format embeds tool names and filesystem paths verbatim — both
+* theoretically could contain one of these (Windows paths can't, but a
+* tool alias is user-controlled). Keeping the attribute well-formed
+* prevents a malicious or unusual tool name from breaking the wrapper
+* parse. `&` is escaped first so the subsequent replacements don't
+* double-encode the entities we just emitted.
+*/
+function escapeAttr(text) {
+	return text.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+//#endregion
 //#region src/tools/validation.ts
 const TRUE_STRINGS = new Set([
 	"true",
@@ -417,6 +667,101 @@ function turnsToMessages(turns) {
 	}));
 }
 /**
+* Wire-level cutoff for {@link SessionContentBlock}'s `compact-summary`
+* markers.
+*
+* Walks `turns` to find the latest marker block. When found:
+*
+*   1. Turns whose id appears in the marker's `replacesTurnIds` are
+*      dropped from the wire-level list (the model sees the summary
+*      instead of those turns).
+*   2. The marker turn itself is replaced with a synthesized plain
+*      user-text turn whose text is the summary — providers don't know
+*      about the `compact-summary` block type, so we always normalize
+*      before they see it.
+*   3. The synthetic marker is positioned at the slot of the **first
+*      replaced turn**, so the summary appears CHRONOLOGICALLY where
+*      the content it summarizes used to live. This keeps the wire-
+*      level conversation in correct narrative order:
+*        - older unreplaced turns (PTL head-drops) come first
+*        - then the synthesized summary
+*        - then later unreplaced turns (preserved tail + new prompts)
+*   4. Every other turn is passed through by reference. This includes:
+*      - turns BEFORE the marker that aren't in `replacesTurnIds`
+*        (e.g. head turns dropped by `compactConversation`'s PTL retry
+*        path — the harness keeps them visible to the model verbatim
+*        because the summary doesn't describe them)
+*      - turns AFTER the marker (preserved tail + any new prompts the
+*        user appended after compaction)
+*
+* If no marker exists, the input array is returned unchanged.
+*
+* Only the latest `compact-summary` block is honored — sessions
+* compacted twice cascade only if the newer marker's `replacesTurnIds`
+* explicitly subsumes the older marker's id (which the runner does
+* when re-compacting because its `turnsToMessages` inlines older
+* markers into the summary scope).
+*
+* Note on role-alternation: when the marker is immediately followed by
+* a new user turn (the common case — user submits a prompt right after
+* compacting), the wire output ends in `[…, synthetic_user, new_user]`.
+* Anthropic folds adjacent same-role messages server-side; other
+* providers tolerate them via their own normalization passes. The
+* harness does NOT fold them here — keeping them separate preserves
+* the per-turn `turnId` tags that the TUI's select-turn mode relies on.
+*
+* Pure: a fresh array is returned only when a marker is found. Input
+* turns are never mutated; the synthetic marker is the only new
+* `SessionTurn` allocated.
+*/
+function applyCompactSummaryCutoff(turns) {
+	if (turns.length === 0) return turns;
+	let markerIdx = -1;
+	let markerSummary = "";
+	let markerReplacesIds = [];
+	for (let i = turns.length - 1; i >= 0; i--) {
+		const block = turns[i].content.find((b) => b.type === "compact-summary");
+		if (block && block.type === "compact-summary") {
+			markerIdx = i;
+			markerSummary = block.summary;
+			markerReplacesIds = block.replacesTurnIds;
+			break;
+		}
+	}
+	if (markerIdx < 0) return turns;
+	const markerTurn = turns[markerIdx];
+	const synthetic = {
+		id: markerTurn.id,
+		role: "user",
+		content: [{
+			type: "text",
+			text: markerSummary
+		}],
+		createdAt: markerTurn.createdAt,
+		...markerTurn.runId ? { runId: markerTurn.runId } : {}
+	};
+	const replacedSet = new Set(markerReplacesIds);
+	const out = [];
+	let syntheticInserted = false;
+	for (let i = 0; i < turns.length; i++) {
+		if (i === markerIdx) continue;
+		if (replacedSet.has(turns[i].id)) {
+			if (!syntheticInserted) {
+				out.push(synthetic);
+				syntheticInserted = true;
+			}
+			continue;
+		}
+		out.push(turns[i]);
+	}
+	if (!syntheticInserted) {
+		let insertAt = 0;
+		for (let i = 0; i < markerIdx; i++) if (!replacedSet.has(turns[i].id)) insertAt++;
+		out.splice(insertAt, 0, synthetic);
+	}
+	return out;
+}
+/**
 * Flatten image blocks inside previously-stored `tool_result` outputs to text
 * markers when the provider reports no vision capability. This handles the
 * session-resume / mid-session-provider-switch case:
@@ -465,6 +810,7 @@ function applyTailCompaction(messages, threshold, keepTurns) {
 		const newContent = msg.content.map((block) => {
 			if (block.type !== "tool_result") return block;
 			if (toolOutputByteLength(block.output) <= 86) return block;
+			if (typeof block.output === "string" && block.output.startsWith("<persisted-output tool=\"")) return block;
 			msgChanged = true;
 			changed = true;
 			return {
@@ -685,7 +1031,7 @@ function wrapProviderError(err, ctx) {
 }
 async function executeTurn(ctx, turn) {
 	const turnId = await ctx.generateTurnId();
-	let canonicalMessages = turnsToMessages(ctx.turns);
+	let canonicalMessages = turnsToMessages(applyCompactSummaryCutoff(ctx.turns));
 	if (ctx.elideStaleReads === true) canonicalMessages = applyStaleReadElision(canonicalMessages);
 	const wireMessages = rewriteMessagesToWire(canonicalMessages, ctx.aliasMaps);
 	let sanitizedMessages = sanitizeStoredToolResults(ctx.provider, wireMessages);
@@ -750,6 +1096,7 @@ async function executeTurn(ctx, turn) {
 			}
 		});
 	} catch (err) {
+		const wasAborted = ctx.signal.aborted || err instanceof Error && err.name === "AbortError";
 		const errorUsage = {
 			input: 0,
 			output: 0
@@ -759,7 +1106,7 @@ async function executeTurn(ctx, turn) {
 			text: currentText
 		}] : [{
 			type: "text",
-			text: "[provider error before any output]"
+			text: wasAborted ? "[⏹ Streaming was aborted.]" : "[✗ Streaming failed before any output.]"
 		}];
 		const errorTurn = {
 			id: turnId,
@@ -822,7 +1169,7 @@ async function executeTurn(ctx, turn) {
 				description: "Return the final structured output matching the required schema.",
 				inputSchema: ctx.schema
 			};
-			const schemaMessages = rewriteMessagesToWire(turnsToMessages(ctx.turns), ctx.aliasMaps);
+			const schemaMessages = rewriteMessagesToWire(turnsToMessages(applyCompactSummaryCutoff(ctx.turns)), ctx.aliasMaps);
 			let schemaResult;
 			try {
 				schemaResult = await ctx.provider.stream({
@@ -1126,6 +1473,20 @@ async function emitToolResult(ctx, params) {
 	await ctx.hooks.callHook("tool:transform", transformCtx);
 	output = transformCtx.result;
 	isError = transformCtx.isError;
+	const threshold = ctx.persistThreshold;
+	const persistDir = ctx.persistDir;
+	if (threshold && threshold > 0 && persistDir) {
+		const outcome = await maybePersistToolResult({
+			toolName: name,
+			callId,
+			output,
+			threshold,
+			persistDir,
+			...ctx.persistExcludeTools ? { excludeTools: ctx.persistExcludeTools } : {}
+		});
+		if (outcome.kind === "persisted") output = outcome.output;
+		else if (outcome.kind === "error" && process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/loop] persistence write failed for ${name}/${callId}: ${outcome.error.message}\n`);
+	}
 	output = stripImagesForNonVision(ctx.provider, output);
 	await ctx.hooks.callHook("tool:after", {
 		turnId,
@@ -1790,6 +2151,10 @@ const HOOK_EVENT_SET = new Set([
 	"mcp:close",
 	"mcp:bootstrap:start",
 	"mcp:bootstrap:end",
+	"mcp:auth:required",
+	"mcp:auth:url",
+	"mcp:auth:success",
+	"mcp:auth:error",
 	"mcp:tools:filter",
 	"mcp:tool:gate",
 	"mcp:tool:before",
@@ -1874,7 +2239,10 @@ function resolveBehavior(agentBehavior, runBehavior) {
 		readLineNumbers: runBehavior?.readLineNumbers ?? agentBehavior?.readLineNumbers,
 		elideStaleReads: runBehavior?.elideStaleReads ?? agentBehavior?.elideStaleReads,
 		toolDisclosure: runBehavior?.toolDisclosure ?? agentBehavior?.toolDisclosure ?? "eager",
-		toolSearch: runBehavior?.toolSearch ?? agentBehavior?.toolSearch
+		toolSearch: runBehavior?.toolSearch ?? agentBehavior?.toolSearch,
+		persistThreshold: runBehavior?.persistThreshold ?? agentBehavior?.persistThreshold,
+		persistExcludeTools: runBehavior?.persistExcludeTools ?? agentBehavior?.persistExcludeTools,
+		persistDir: runBehavior?.persistDir ?? agentBehavior?.persistDir
 	};
 }
 /**
@@ -2157,7 +2525,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const thinking = options.thinking ?? "off";
 			const model = options.model ?? provider.meta.defaultModel;
 			const resolvedBehavior = resolveBehavior(agentBehavior, options.behavior);
-			const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch } = resolvedBehavior;
+			const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir } = resolvedBehavior;
 			let system = options.system || agentSystem || "You are a helpful assistant.";
 			if (skillsCatalog) system = `${system}\n\n${skillsCatalog}`;
 			const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? {
@@ -2341,6 +2709,9 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					compactKeepTurns,
 					...elideStaleReads !== void 0 ? { elideStaleReads } : {},
 					...thinkingDecay !== void 0 ? { thinkingDecay } : {},
+					...persistThreshold !== void 0 ? { persistThreshold } : {},
+					...persistExcludeTools !== void 0 ? { persistExcludeTools } : {},
+					...persistDir !== void 0 ? { persistDir } : {},
 					runStartMs,
 					runToolCounts: {}
 				});
@@ -3985,7 +4356,22 @@ function createSpawnTool(options = {}) {
 					execution: ctx.execution,
 					...options.persist && ctx.session ? { session: ctx.session } : {}
 				});
-				if (forwardHooks) unbubble = bubbleHooks(agent.hooks, ctx.hooks, id, childDepth);
+				if (forwardHooks) {
+					const unregisterEnricher = agent.hooks.hook("tool:before", async (toolCtx) => {
+						if (toolCtx.name !== "write_file") return;
+						if (!agent.handle) return;
+						const inputPath = toolCtx.input?.path;
+						if (typeof inputPath !== "string") return;
+						try {
+							toolCtx.priorContent = await agent.execution.readFile(agent.handle, inputPath);
+						} catch {}
+					});
+					const unbubbleInner = bubbleHooks(agent.hooks, ctx.hooks, id, childDepth);
+					unbubble = () => {
+						unregisterEnricher();
+						unbubbleInner();
+					};
+				}
 				options.onSpawn?.(child);
 				await ctx.hooks.callHook("spawn:before", {
 					id,
@@ -4143,6 +4529,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-export { multiEdit as a, grep as c, createAgent as d, createToolSearchTool as f, validateToolArgs as g, createSkillsReadTool as h, readFile$1 as i, glob as l, createSkillsRunScriptTool as m, createSpawnTool as n, listFiles as o, createSkillsUseTool as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u };
+export { getReadState as C, resolvePersistDir as S, PERSISTED_STUB_PREFIX as _, multiEdit as a, cleanupPersistedSession as b, grep as c, createAgent as d, createToolSearchTool as f, validateToolArgs as g, createSkillsReadTool as h, readFile$1 as i, glob as l, createSkillsRunScriptTool as m, createSpawnTool as n, listFiles as o, createSkillsUseTool as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u, PERSISTENCE_PREVIEW_BYTES as v, maybePersistToolResult as x, buildPersistedStub as y };
 
-//# sourceMappingURL=tools-CLazLRb4.js.map
+//# sourceMappingURL=tools-d1yeA6xK.js.map