@modelprofile.com/flexharness 13.1.1 → 13.2.1

package/dist_ts_chat_harness/classes.transcript.js

@@ -83,7 +83,7 @@ export class FlexHarnessTranscript {
     /** A copy of the component inputs; the transcript keeps its own objects. */
     view() {
         return structuredClone({
-            messages: this.flexMessages.flatMap((message, index) => flexMessageToHarnessRows(message, index, this.timings)),
+            messages: this.flexMessages.flatMap((message, index) => message.cacheWarm ? [] : flexMessageToHarnessRows(message, index, this.timings)),
             permissions: [...this.permissionRows.values()],
             questions: [],
             status: this.status,
@@ -117,6 +117,10 @@ export class FlexHarnessTranscript {
         if (event.scopeId !== this.scopeId || event.sessionId !== this.sessionId)
             return change;
         const timestamp = Date.parse(event.timestamp);
+        // A cache-warm turn's messages are held but not shown, so their events change no row.
+        const warmMessage = 'message' in event
+            ? event.message.cacheWarm === true
+            : 'messageId' in event && this.flexMessages.some((message) => message.messageId === event.messageId && message.cacheWarm);
         switch (event.type) {
             case 'session.created':
             case 'session.updated':
@@ -127,7 +131,8 @@ export class FlexHarnessTranscript {
                 change.messages = change.permissions = change.status = change.usage = true;
                 break;
             case 'run.started':
-                this.setStatus(change, { type: 'busy' });
+                if (!event.cacheWarm)
+                    this.setStatus(change, { type: 'busy' });
                 break;
             case 'message.created':
             case 'message.updated':
@@ -182,13 +187,17 @@ export class FlexHarnessTranscript {
                     this.usage = sumUsage(this.usage, flexUsageToHarness(event.message.usage));
                     change.usage = true;
                 }
+                if (event.cacheWarm)
+                    break;
                 this.setStatus(change, event.status === 'failed'
                     ? { type: 'error', ...(event.error ? { message: event.error.message } : {}) }
                     : { type: 'idle' });
                 break;
             case 'prompt.started':
             case 'prompt.running':
-                this.runningQueueId = event.queueId;
+                // A steer cannot join a cache-warm turn.
+                if (!event.entry.cacheWarm)
+                    this.runningQueueId = event.queueId;
                 break;
             case 'prompt.finished':
                 if (this.runningQueueId === event.queueId)
@@ -200,6 +209,10 @@ export class FlexHarnessTranscript {
             default:
                 break;
         }
+        if (warmMessage) {
+            change.messages = false;
+            change.deltas = [];
+        }
         return change;
     }
     addPermission(request) {
@@ -308,4 +321,4 @@ export class FlexHarnessTranscript {
         change.messages = true;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.transcript.js","sourceRoot":"","sources":["../ts_chat_harness/classes.transcript.ts"],"names":[],"mappings":"AASA,OAAO,EACL,wBAAwB,EACxB,aAAa,EACb,iBAAiB,EACjB,uBAAuB,EACvB,8BAA8B,EAC9B,yBAAyB,EACzB,0BAA0B,EAC1B,qBAAqB,EACrB,kBAAkB,GAEnB,MAAM,wBAAwB,CAAC;AAiEhC,MAAM,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC;AAE/B,mFAAmF;AACnF,SAAS,iBAAiB,CAAC,IAAY,EAAE,KAAa;IACpD,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAClD,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IACpC,MAAM,kBAAkB,GAAG,QAAQ,IAAI,MAAM,IAAI,QAAQ,IAAI,MAAM;WAC9D,OAAO,IAAI,MAAM,IAAI,OAAO,IAAI,MAAM,CAAC;IAC5C,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAClE,CAAC;AAED,SAAS,QAAQ,CACf,KAA4B,EAC5B,KAA4B;IAE5B,MAAM,GAAG,GAAG,CAAC,GAAgC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACxF,OAAO;QACL,WAAW,EAAE,GAAG,CAAC,aAAa,CAAC;QAC/B,YAAY,EAAE,GAAG,CAAC,cAAc,CAAC;QACjC,WAAW,EAAE,GAAG,CAAC,aAAa,CAAC;QAC/B,eAAe,EAAE,GAAG,CAAC,iBAAiB,CAAC;QACvC,gBAAgB,EAAE,GAAG,CAAC,kBAAkB,CAAC;KAC1C,CAAC;AACJ,CAAC;AAED,MAAM,QAAQ,GAAG,GAAiC,EAAE,CAAC,CAAC;IACpD,QAAQ,EAAE,KAAK;IACf,MAAM,EAAE,EAAE;IACV,WAAW,EAAE,KAAK;IAClB,MAAM,EAAE,KAAK;IACb,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;CACd,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,OAAO,qBAAqB;IAChB,OAAO,CAAS;IAChB,SAAS,CAAS;IAC1B,YAAY,GAAmB,EAAE,CAAC;IACzB,OAAO,GAAG,IAAI,GAAG,EAA2B,CAAC;IAC7C,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtC,cAAc,GAAG,IAAI,GAAG,EAA6C,CAAC;IACvF,gGAAgG;IAC/E,cAAc,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC5D,8FAA8F;IACtF,gBAAgB,CAAU;IAC1B,MAAM,GAA2B,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAClD,KAAK,GAA0B,EAAE,CAAC;IAClC,KAAK,GAA+B,EAAE,CAAC;IACvC,UAAU,CAA8B;IACxC,cAAc,CAAU;IAEhC,YAAY,OAAsC;QAChD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IACrC,CAAC;IAED,8DAA8D;IAC9D,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,kEAAkE;IAC3D,IAAI,CAAC,QAAwC;QAClD,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QAChB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;QAChC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACrB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,QAAQ;YAAE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACrE,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAC5B,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAC5B,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,WAAW,IAAI,EAAE;YAAE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC9E,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC,QAAQ,CAAC;QAC1C,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,0BAA0B,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QACjG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CACnC,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAC9F,EAAE,CACH,CAAC;QACF,IAAI,QAAQ,CAAC,OAAO;YAAE,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACjE,CAAC;IAED,iFAAiF;IAC1E,iBAAiB,CAAC,OAAgC;QACvD,IAAI,CAAC,KAAK,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,CAAC,UAAU,GAAG,8BAA8B,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAED,4EAA4E;IACrE,IAAI;QACT,OAAO,eAAe,CAAC;YACrB,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CACrD,wBAAwB,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACzD,WAAW,EAAE,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;YAC9C,SAAS,EAAE,EAAE;YACb,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,GAAG,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC;SAC1E,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,UAAU,CACf,KAAwB,EACxB,QAAmC;QAEnC,MAAM,MAAM,GAAG,QAAQ,EAAE,CAAC;QAC1B,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACxC,IAAI,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,gBAAgB;gBAAE,OAAO,MAAM,CAAC;YAC3D,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,gBAAgB,GAAG,CAAC,EAAE,CAAC;gBACjD,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;gBACrB,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,QAAQ,CAAC;QACzC,CAAC;aAAM,IACL,QAAQ,CAAC,iBAAiB,KAAK,SAAS;eACrC,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC,iBAAiB,GAAG,CAAC,EACpD,CAAC;YACD,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;YACrB,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS;YAAE,OAAO,MAAM,CAAC;QACxF,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAC9C,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;YACnB,KAAK,iBAAiB,CAAC;YACvB,KAAK,iBAAiB;gBACpB,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,0BAA0B,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;gBAClE,MAAM;YACR,KAAK,iBAAiB;gBACpB,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;gBAC7D,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC;gBAC3E,MAAM;YACR,KAAK,aAAa;gBAChB,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;gBACzC,MAAM;YACR,KAAK,iBAAiB,CAAC;YACvB,KAAK,iBAAiB;gBACpB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBAClC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACvB,MAAM;YACR,KAAK,cAAc;gBACjB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC;gBAC7F,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC7E,MAAM;YACR,KAAK,cAAc;gBACjB,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC7E,MAAM;YACR,KAAK,gBAAgB,EAAE,CAAC;gBACtB,MAAM,GAAG,GAAG,iBAAiB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;gBAC7D,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;gBACxE,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC7E,MAAM;YACR,CAAC;YACD,KAAK,YAAY;gBACf,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;gBACnC,MAAM;YACR,KAAK,cAAc;gBACjB,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;gBAC/B,MAAM;YACR,KAAK,sBAAsB;gBACzB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBAClC,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC;gBAC1B,MAAM;YACR,KAAK,qBAAqB,EAAE,CAAC;gBAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;gBAChE,IAAI,CAAC,GAAG;oBAAE,MAAM;gBAChB,GAAG,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;gBAC9B,GAAG,CAAC,WAAW,GAAG,SAAS,CAAC;gBAC5B,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;gBACvD,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC;gBAC1B,MAAM;YACR,CAAC;YACD,KAAK,cAAc;gBACjB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBAClC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACvB,6FAA6F;gBAC7F,KAAK,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;oBAC7D,IAAI,KAAK,KAAK,KAAK,CAAC,KAAK;wBAAE,SAAS;oBACpC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;oBACzC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;oBACzC,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC;gBAC5B,CAAC;gBACD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;oBACxB,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,kBAAkB,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;oBAC3E,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC;gBACtB,CAAC;gBACD,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,KAAK,QAAQ;oBAC9C,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE;oBAC7E,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;gBACtB,MAAM;YACR,KAAK,gBAAgB,CAAC;YACtB,KAAK,gBAAgB;gBACnB,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC;gBACpC,MAAM;YACR,KAAK,iBAAiB;gBACpB,IAAI,IAAI,CAAC,cAAc,KAAK,KAAK,CAAC,OAAO;oBAAE,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;gBAC3E,MAAM;YACR,KAAK,yBAAyB;gBAC5B,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;gBACrB,MAAM;YACR;gBACE,MAAM;QACV,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,aAAa,CAAC,OAA+B;QACnD,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,YAAY,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAC;QAChF,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAEO,SAAS,CAAC,MAAoC,EAAE,MAA8B;QACpF,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC,MAAM,CAAC,OAAO;YAAE,OAAO;QACvF,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;IACvB,CAAC;IAEO,aAAa,CAAC,OAAqB;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;QAC5F,MAAM,IAAI,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;YAC1C,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;QACrC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC9B,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gBACtD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;YACpG,CAAC;QACH,CAAC;IACH,CAAC;IAEO,iBAAiB,CACvB,MAAoC,EACpC,SAAiB,EACjB,SAAiB,EACjB,IAAsB;QAEtB,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;QACjF,IAAI,CAAC,OAAO,IAAI,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YACjD,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;YACrB,OAAO;QACT,CAAC;QACD,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAC1C,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;QACjD,MAAM,GAAG,GAAG,iBAAiB,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACtD,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YACtD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,KAAK,GAAG,aAAa,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACpD,IAAI,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;YACpE,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;YACvB,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACzB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;gBACjB,IAAI,EAAE,aAAa;gBACnB,SAAS,EAAE,KAAK;gBAChB,IAAI,EAAE,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;aACzD,CAAC,CAAC;QACL,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC5D,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI;gBAAE,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;iBACnD,IAAI,OAAO,CAAC,MAAM,KAAK,WAAW,IAAI,SAAS,KAAK,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAClF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;YAChE,CAAC;QACH,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,IAAI,QAAQ,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YACtE,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI;gBAAE,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;iBACnD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;oBACjB,IAAI,EAAE,eAAe;oBACrB,SAAS,EAAE,KAAK;oBAChB,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,OAAO;iBACxC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;QACzB,CAAC;IACH,CAAC;IAEO,cAAc,CACpB,MAAoC,EACpC,KAAyD;QAEzD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;QACvF,MAAM,IAAI,GAAG,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAC7C,MAAM,GAAG,GAAG,iBAAiB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC7D,IACE,CAAC,IAAI;eACF,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;eAC5B,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,QAAQ;eAC5B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,iBAAiB,EACtD,CAAC;YACD,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;YACrB,OAAO;QACT,CAAC;QACD,MAAM,KAAK,GAAG,KAAK,CAAC,iBAAiB,GAAG,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QAClF,IAAI,KAAK,KAAK,KAAK,CAAC,aAAa,EAAE,CAAC;YAClC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;YACrB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC3D,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,MAAM;YAC1C,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE;YACxD,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;IACzF,CAAC;IAEO,UAAU,CAChB,MAAoC,EACpC,KAA2D;QAE3D,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;QACvF,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;YACxE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;YACrB,OAAO;QACT,CAAC;QACD,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QACzC,MAAM,GAAG,GAAG,iBAAiB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC7D,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC3B,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;IACzB,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.transcript.js","sourceRoot":"","sources":["../ts_chat_harness/classes.transcript.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness",
-  "version": "13.1.1",
+  "version": "13.2.1",
   "type": "module",
   "description": "Managed agent sessions with tools, MCP, chat, OCR, documents and browser control through focused subpath imports.",
   "main": "./dist_ts/index.js",
@@ -91,8 +91,8 @@
   },
   "dependencies": {
     "@cfworker/json-schema": "^4.1.1",
-    "@modelprofile.com/flexharness-agent": "13.1.1",
-    "@modelprofile.com/flexharness-models": "13.1.1",
+    "@modelprofile.com/flexharness-agent": "13.2.1",
+    "@modelprofile.com/flexharness-models": "13.2.1",
     "@push.rocks/smartrequest": "^5.5.1",
     "ai": "^7.0.111",
     "zod": "^4.6.5"

package/readme.md

@@ -418,6 +418,7 @@ The tools use strict action-discriminated inputs:
 - `goal`: `get`, `set`, or `clear`.
 - `scratchpad`: `get`, `set`, `append`, or `clear`. Append concatenates the supplied content exactly.
 - `rename_session`: sets the active session title and returns the authoritative session.
+- `keep_cache_warm` (`cacheWarm: true`, root sessions only): keeps the session's prompt cache warm; see [Keeping the Prompt Cache Warm](#keeping-the-prompt-cache-warm).
 
 Every project action returns the authoritative revision and state; task mutations also return the affected task, and clear returns the removed tasks. Reads never save. A set, clear, append, update, idempotent create, or empty task clear that makes no state change returns the current revision without writing. Mutations load once, apply once, validate the complete next snapshot, and issue one compare-and-swap save at `revision + 1`. FlexHarness never retries or merges an external conflict.
 
@@ -729,6 +730,32 @@ The run takes a steer in at its next step boundary: after the tool results of it
 
 `steerPrompt()` resolves with `{ steerId, queueId, runId }` once the run accepted the steer and `prompt.steer.accepted` was emitted; `prompt.steer.applied` carries the `messageId` of the user message the steer became. Every accepted steer ends in exactly one of two ways: it is in the model context of later turns, or it is listed in `unappliedSteerIds`, in arrival order, on `IFlexPromptResult` and `run.finished`, and on the finished queue entry when that list is not empty. A steer is listed when the run did not take it in before it ended, because its last model step was already running or because it was stopped or failed, and also when the run itself does not stay in context. `keptInContext` on `run.finished` and on the finished queue entry says whether it does: it is `false` for a failed run and for a run stopped before any model output, and such a run lists every steer it accepted, including the ones it took in and reported with `prompt.steer.applied`. Send its prompt and its unapplied steers again to have them answered. The run stops taking steers atomically when its generation ends or `abort()`/`cancelPrompt()` stops it. A steer for a prompt without a running run, or whose run is ending, is refused with `FlexHarnessSteerRejectedError` reason `not-running`; the caller sends it as the next turn instead. Reusing a `steerId` within a run is refused with reason `duplicate`, an unknown `queueId` throws `FlexHarnessNotFoundError`, and child sessions reject this general API (their exact parent run uses `sendSubagentInput()` or `delegate_send` instead). A run holds at most `maxOutstandingPromptsPerSession` pending steers, and their bytes count against the session's outstanding prompt byte limit until the run takes them in or ends, so `startPrompt()` and `enqueuePrompt()` are refused with `FlexHarnessQueueFullError` while pending steers fill it. They are process-local like queue entries: a process restart ends the run and drops its pending steers, while steers it took in are durable parts of the turn.
 
+### Keeping the Prompt Cache Warm
+
+A provider's prompt cache expires when nothing reads it for its TTL, and the next turn then writes the whole prefix again. `keepCacheWarm()` keeps a root session's cache warm until a deadline:
+
+```typescript
+await harness.keepCacheWarm(scopeId, sessionId, { durationMs: 60 * 60 * 1000 }); // warm until 1 h from now
+await harness.keepCacheWarm(scopeId, sessionId, { durationMs: 0 }); // stop
+const state = await harness.getCacheWarm(scopeId, sessionId); // { sessionId, warmUntil?, nextWarmAt?, idleMs?, basis? }
+```
+
+Each call replaces the deadline with `durationMs` from now, capped at `cacheWarm.maxDurationMs` (default 4 h, at most 24 h); `0` stops it. While the deadline has not passed and the session is idle, the harness sends a cache-warm prompt once the session has had no model call for the cache TTL less one minute: 4 minutes for a 5-minute cache, 29 for a 30-minute one, 59 for a 1-hour one. The TTL comes from the request the provider actually sent last, its `basis` in `getCacheWarm()`:
+
+| `basis` | TTL | Sent request |
+| --- | --- | --- |
+| `anthropic-5m`, `anthropic-1h` | 5 min, 1 h | Anthropic: the shortest `cache_control` lifetime of the request |
+| `openai-30m` | 30 min | OpenAI's API, GPT-5.6 and later: `prompt_cache_options.ttl` is 30 minutes after the last write or reuse |
+| `openai-24h` | 30 min | OpenAI's API, an earlier model with `prompt_cache_retention: '24h'` (`cache: { retention: '24h' }`): OpenAI keeps the prefix typically around 30 minutes and up to 24 hours, without promising more |
+| `openai-in-memory` | 5 min | OpenAI's API, an earlier model with `in_memory` or no retention; or the ChatGPT backend of ChatGPT accounts, which takes no retention and documents none. In-memory entries last 5 to 10 minutes of inactivity |
+| `configured` | `cache.warmDurationMs` | any |
+
+With no basis (another provider or endpoint, or a custom transport that may change the request) the TTL is 5 minutes. No OpenAI retention promises a hit beyond about 30 minutes, so none makes warming unnecessary; extended retention only spaces warm turns further apart. Source: OpenAI's [prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching), read 2026-10-11. A prompt, a steer or a running turn resets the wait, and no warm prompt is sent while a turn runs, a prompt is queued, an undo's redo history is open, a reversion is pending or a slash command runs. The warm prompt is the fixed text `FLEX_CACHE_WARM_PROMPT`, starting with `[cache-warm]`, which asks for the single word `ok`. Its turn uses the model and system of the session's last turn and offers the same tools, so it reads the cached prefix, but it refuses every tool call, takes at most two steps, caps each model call at `cacheWarm.maxOutputTokens` (default 1024) and takes no steer: `steerPrompt()` refuses one with reason `not-running`. Keeping a session warm costs a cache read of its prefix and a few new tokens per warm turn; the warm exchanges stay in the model context.
+
+Warm turns are marked so hosts can leave them out of what they show and of what they count as work: both messages, the session `activity`, the prompt queue entry, `run.started`, `run.finished` and `model.usage` carry `cacheWarm: true`. A warm turn changes neither the session's `updatedAt` nor its `preview`, and adds no undo step. Three events report the keeper: `cache.warm.changed` (`source` `host` or `agent`, `warmUntil` absent once stopped), `cache.warm.completed` with the warm turn's `usage`, whose `cacheReadTokens` and `cacheWriteTokens` are the provider's own counts and show whether it hit the cache (OpenAI's `input_tokens_details.cached_tokens` and `cache_write_tokens`, Anthropic's `cache_read_input_tokens` and `cache_creation_input_tokens`), its `idleForMs` since the session's previous model call and its `basis`, and `cache.warm.stopped` with `reason` `deadline`, `cleared`, `failed` (the warm turn failed; `error` set) or `unavailable` (the session or its scope went away).
+
+`builtInTools: { cacheWarm: true }` gives root sessions the `keep_cache_warm` tool, so the agent can keep its own cache warm: `{ duration: '1h' }` sets the deadline (amounts of `s`, `m` or `h`), `'off'` or `'0'` stops it. The keeper is process-local: it ends with `dispose()` and does not survive a restart. It warms only the loaded scope it was set in: retiring the scope or deleting the session stops it with `unavailable`, and it never loads a scope again. Tests pass `cacheWarm.clock` (`now`, `setTimeout`, `clearTimeout`) to drive it with a fake clock.
+
 ## Slash Commands
 
 `parseSlashCommand()` is the public strict pure parser. It accepts at most 768 KiB, returns `not-command` for input not starting with `/`, `malformed` for invalid slash syntax, and `parsed` with the exact input, lowercase command name, separator-stripped raw argument text, and OpenCode-compatible quoted tokenization. Command names match `[a-z][a-z0-9_-]{0,63}`. The public `isValidSlashCommandName(name)` and `isReservedSlashCommandName(name)` helpers let applications validate registration names against the same rules. Single and double quotes group tokens and are stripped; escapes are not interpreted.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '13.1.1',
+  version: '13.2.1',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }

package/ts/classes.flexharness.cachewarm.ts

@@ -0,0 +1,433 @@
+import * as plugins from './plugins.js';
+import {
+  FlexHarnessNotFoundError,
+  FlexHarnessSessionBusyError,
+  FlexHarnessValidationError,
+  errorToInfo,
+} from './errors.js';
+import type {
+  IFlexCacheWarmInput,
+  IFlexCacheWarmState,
+  IFlexPromptResult,
+  IFlexSession,
+} from './interfaces.js';
+import type {
+  IActiveRun,
+  IQueuedPrompt,
+  IStoredSessionState,
+  IStorageState,
+  TEventDetails,
+} from './interfaces.flexharness.js';
+import type { INormalizedCacheWarmOptions } from './utils.harnessoptions.js';
+import { validateIdentifier } from './utils.validation.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+
+/** The prompt of a cache-warm turn. It only has the model read the cached prefix again. */
+export const FLEX_CACHE_WARM_PROMPT =
+  '[cache-warm] This message only keeps the prompt cache warm. No action is needed: do not call '
+  + 'any tool and reply with the single word ok.';
+
+/** The cache TTL assumed when the model call does not report its own. */
+const defaultCacheTtlMs = 5 * 60 * 1000;
+/** How long before the cache expires a warm turn reads it. */
+const cacheWarmMarginMs = 60 * 1000;
+// A stray tool call is refused in the first step and answered in the second.
+const cacheWarmMaxSteps = 2;
+
+interface ISessionCacheWarm {
+  key: string;
+  scopeId: string;
+  sessionId: string;
+  /**
+   * The loaded scope state and session the keeper warms. The keeper never loads a scope: once
+   * these are retired, deleted or replaced, it stops.
+   */
+  state: IStorageState;
+  stored: IStoredSessionState;
+  /** The keeper's stop time, on its clock. */
+  warmUntil: number;
+  /** When the keeper was set, on its clock: the idle baseline before any model call. */
+  setAt: number;
+  deadlineTimer?: unknown;
+  warmTimer?: unknown;
+  nextWarmAt?: number;
+  firing: boolean;
+  /** The session's idle time since its previous model call when the last warm turn was due. */
+  firedAfterIdleMs?: number;
+}
+
+/** The idle time after a model call at which a warm turn reads the cache, from its TTL. */
+export function cacheWarmIdleMs(ttlMs: number | undefined): number {
+  const ttl = ttlMs ?? defaultCacheTtlMs;
+  return Math.max(ttl - cacheWarmMarginMs, Math.floor(ttl / 2));
+}
+
+/** Replaces each tool's `execute` so a cache-warm turn refuses any tool call it makes. */
+export function refuseToolExecution(tools: Record<string, unknown>): void {
+  for (const [name, tool] of Object.entries(tools)) {
+    if (!tool || typeof tool !== 'object' || typeof (tool as { execute?: unknown }).execute !== 'function') continue;
+    tools[name] = {
+      ...tool,
+      execute: async () => {
+        throw new FlexHarnessValidationError('A cache-warm turn runs no tools.');
+      },
+    };
+  }
+}
+
+/** Parses the agent tool's duration: `off`, `0`, or an amount of `s`, `m` or `h`, such as `1h`. */
+export function parseCacheWarmDuration(duration: string): number {
+  const normalized = duration.trim().toLowerCase();
+  if (normalized === 'off' || normalized === '0') return 0;
+  const match = /^(\d{1,6})\s*(s|m|h)$/u.exec(normalized);
+  if (!match) {
+    throw new FlexHarnessValidationError('duration must be "off", "0" or an amount of s, m or h, such as "1h".');
+  }
+  const unitMs = match[2] === 's' ? 1000 : match[2] === 'm' ? 60_000 : 3_600_000;
+  return Number(match[1]) * unitMs;
+}
+
+/**
+ * Keeps a session's prompt cache warm until a deadline. Whenever the session has been idle for
+ * the cache TTL less a minute, it sends a marked cache-warm prompt, whose short turn reads the
+ * cached prefix again and so refreshes it. Process-local: it ends with the harness.
+ */
+export class FlexHarnessCacheWarm<TScope> {
+  private readonly entries = new Map<string, ISessionCacheWarm>();
+
+  constructor(private readonly core: FlexHarnessCore<TScope>) {}
+
+  private get options(): INormalizedCacheWarmOptions {
+    return this.core.cacheWarmOptions;
+  }
+
+  private key(storageKey: string, sessionId: string): string {
+    return `${storageKey}\u0000${sessionId}`;
+  }
+
+  /** Sets the session's warm deadline to `durationMs` from now, capped; 0 stops the keeper. */
+  public async keepCacheWarm(
+    scopeId: string,
+    sessionId: string,
+    input: IFlexCacheWarmInput,
+  ): Promise<IFlexCacheWarmState> {
+    this.core.assertOpen();
+    validateIdentifier(sessionId, 'sessionId');
+    if (!input || typeof input !== 'object' || !Number.isSafeInteger(input.durationMs) || input.durationMs < 0) {
+      throw new FlexHarnessValidationError('durationMs must be a non-negative integer.');
+    }
+    const { state } = await this.core.resolveState(scopeId);
+    this.core.assertStateAcceptingWork(state);
+    const stored = this.core.requireSession(state, sessionId);
+    return this.set(scopeId, state, stored, input.durationMs, 'host');
+  }
+
+  public async getCacheWarm(scopeId: string, sessionId: string): Promise<IFlexCacheWarmState> {
+    validateIdentifier(sessionId, 'sessionId');
+    const { state } = await this.core.resolveState(scopeId);
+    const stored = this.core.requireSession(state, sessionId);
+    return this.project(stored, this.entries.get(this.key(state.storageKey, sessionId)));
+  }
+
+  /** The shared setter of the host API and the agent tool. */
+  public set(
+    scopeId: string,
+    state: IStorageState,
+    stored: IStoredSessionState,
+    durationMs: number,
+    source: 'host' | 'agent',
+  ): IFlexCacheWarmState {
+    this.core.assertSessionWritable(stored);
+    if (stored.session.agent !== undefined) {
+      throw new FlexHarnessValidationError('Only a root session keeps its cache warm.');
+    }
+    const key = this.key(state.storageKey, stored.session.sessionId);
+    const existing = this.entries.get(key);
+    if (durationMs === 0) {
+      if (existing) {
+        this.remove(existing);
+        this.emit(scopeId, stored.session, { type: 'cache.warm.changed', source });
+        this.emit(scopeId, stored.session, { type: 'cache.warm.stopped', reason: 'cleared' });
+      }
+      return this.project(stored, undefined);
+    }
+    const now = this.options.clock.now();
+    const entry: ISessionCacheWarm = existing ?? {
+      key,
+      scopeId,
+      sessionId: stored.session.sessionId,
+      state,
+      stored,
+      warmUntil: now,
+      setAt: now,
+      firing: false,
+    };
+    entry.scopeId = scopeId;
+    entry.state = state;
+    entry.stored = stored;
+    entry.warmUntil = now + Math.min(durationMs, this.options.maxDurationMs);
+    this.entries.set(key, entry);
+    if (entry.deadlineTimer !== undefined) this.options.clock.clearTimeout(entry.deadlineTimer);
+    entry.deadlineTimer = this.options.clock.setTimeout(
+      () => this.stopAtDeadline(entry),
+      entry.warmUntil - now,
+    );
+    this.emit(scopeId, stored.session, {
+      type: 'cache.warm.changed',
+      source,
+      warmUntil: new Date(this.toWallTime(entry.warmUntil)).toISOString(),
+    });
+    if (!entry.firing) this.arm(entry, state, stored);
+    return this.project(stored, entry);
+  }
+
+  /** The `keep_cache_warm` built-in tool of a root session. */
+  public createKeepCacheWarmTool(run: IActiveRun): unknown {
+    const maxHours = this.options.maxDurationMs / 3_600_000;
+    return plugins.tool({
+      description: 'Keep this session\'s prompt cache warm while you expect further work, so the next turn '
+        + 'reads the cached context instead of writing it again. While the session is idle, the harness then '
+        + 'sends a short "[cache-warm]" message shortly before the cache would expire. A duration such as '
+        + `"30m" or "1h" sets the deadline to that long from now, at most ${maxHours}h; calling the tool again `
+        + 'replaces the deadline; "off" or "0" stops it.',
+      inputSchema: plugins.z.object({
+        duration: plugins.z.string().min(1).max(32),
+      }).strict(),
+      execute: async ({ duration }: { duration: string }) => {
+        const durationMs = parseCacheWarmDuration(duration);
+        this.core.assertStateAcceptingWork(run.state);
+        if (run.state.sessions.get(run.sessionId) !== run.stored) {
+          throw new FlexHarnessNotFoundError('Session', run.sessionId);
+        }
+        return this.set(run.scopeId, run.state, run.stored, durationMs, 'agent');
+      },
+    });
+  }
+
+  /** A prompt or steer arrived: the session is active, so no warm turn is due. */
+  public onActivity(storageKey: string, sessionId: string): void {
+    const entry = this.entries.get(this.key(storageKey, sessionId));
+    if (entry) this.disarm(entry);
+  }
+
+  /** A root run starts: it is activity, and its model options are what warm turns repeat. */
+  public onRunStarted(run: IActiveRun, queued: IQueuedPrompt): void {
+    if (run.stored.session.agent !== undefined) return;
+    this.onActivity(run.state.storageKey, run.sessionId);
+    if (run.cacheWarm) return;
+    const options = queued.options ?? {};
+    run.stored.cacheWarmPromptOptions = {
+      ...(options.modelHint === undefined ? {} : { modelHint: options.modelHint }),
+      ...(options.system === undefined ? {} : { system: options.system }),
+    };
+  }
+
+  /** A model call of the session was dispatched: the cache's TTL counts from now. */
+  public onModelDispatch(run: IActiveRun, dispatch: plugins.ISmartAiCacheDispatch): void {
+    run.stored.lastCacheDispatch = {
+      at: this.options.clock.now(),
+      idleMs: cacheWarmIdleMs(dispatch.warmDurationMs),
+      ...(dispatch.basis === undefined ? {} : { basis: dispatch.basis }),
+    };
+  }
+
+  /** A prompt of the session finished, whether it ran or not. */
+  public onPromptFinished(
+    queued: IQueuedPrompt,
+    status: 'completed' | 'failed' | 'cancelled',
+    error?: unknown,
+    result?: IFlexPromptResult,
+  ): void {
+    const entry = this.entries.get(this.key(queued.state.storageKey, queued.sessionId));
+    if (queued.cacheWarm && status === 'completed' && result) {
+      const basis = queued.stored.lastCacheDispatch?.basis;
+      this.emit(queued.scopeId, queued.stored.session, {
+        type: 'cache.warm.completed',
+        runId: result.runId,
+        usage: result.usage,
+        ...(entry?.firedAfterIdleMs === undefined ? {} : { idleForMs: entry.firedAfterIdleMs }),
+        ...(basis === undefined ? {} : { basis }),
+      });
+    }
+    if (!entry) return;
+    entry.firing = false;
+    if (queued.cacheWarm && status === 'failed') {
+      this.remove(entry);
+      this.emit(queued.scopeId, queued.stored.session, {
+        type: 'cache.warm.stopped',
+        reason: 'failed',
+        ...(queued.runId === undefined ? {} : { runId: queued.runId }),
+        ...(error === undefined ? {} : { error: errorToInfo(error) }),
+      });
+      return;
+    }
+    if (!this.holdsSession(entry)) return;
+    this.arm(entry, entry.state, entry.stored);
+  }
+
+  /** The scope is being retired: its keepers stop, and none loads the scope again. */
+  public onStateRetiring(state: IStorageState): void {
+    for (const entry of [...this.entries.values()]) {
+      if (entry.state === state) this.stopUnavailable(entry);
+    }
+  }
+
+  /** The sessions were deleted: their keepers stop. */
+  public onSessionsDeleted(state: IStorageState, sessionIds: Iterable<string>): void {
+    for (const sessionId of sessionIds) {
+      const entry = this.entries.get(this.key(state.storageKey, sessionId));
+      if (entry?.state === state) this.stopUnavailable(entry);
+    }
+  }
+
+  public dispose(): void {
+    for (const entry of [...this.entries.values()]) this.remove(entry);
+  }
+
+  private project(stored: IStoredSessionState, entry: ISessionCacheWarm | undefined): IFlexCacheWarmState {
+    return Object.freeze({
+      sessionId: stored.session.sessionId,
+      ...(entry ? { warmUntil: new Date(this.toWallTime(entry.warmUntil)).toISOString() } : {}),
+      ...(entry?.nextWarmAt === undefined
+        ? {}
+        : { nextWarmAt: new Date(this.toWallTime(entry.nextWarmAt)).toISOString() }),
+      ...(entry ? { idleMs: stored.lastCacheDispatch?.idleMs ?? cacheWarmIdleMs(undefined) } : {}),
+      ...(entry && stored.lastCacheDispatch?.basis !== undefined ? { basis: stored.lastCacheDispatch.basis } : {}),
+    });
+  }
+
+  /** Projects a time of the keeper's clock onto the wall clock. */
+  private toWallTime(clockTime: number): number {
+    return Date.now() + (clockTime - this.options.clock.now());
+  }
+
+  private isBusy(state: IStorageState, stored: IStoredSessionState): boolean {
+    return state.activeRuns.has(stored.session.sessionId)
+      || stored.outstandingPromptsById.size > 0
+      || ['running', 'scheduled', 'waiting_permission'].includes(stored.session.status);
+  }
+
+  /**
+   * Whether a warm prompt now would change the session beyond the warm turn: it would end an
+   * undo's redo history, or wait for a reversion or a slash command to settle.
+   */
+  private isHeld(state: IStorageState, stored: IStoredSessionState): boolean {
+    return stored.pendingReversion !== undefined
+      || this.core.reversions.hasHiddenReversionSegments(stored)
+      || this.core.commands.activeSlashCommandExecutions.has(
+        this.core.commands.slashCommandSessionKey(state.storageKey, stored.session.sessionId),
+      );
+  }
+
+  /** Arms the warm timer of an idle session; a busy one arms it again when its run ends. */
+  private arm(entry: ISessionCacheWarm, state: IStorageState, stored: IStoredSessionState): void {
+    this.disarm(entry);
+    if (this.isBusy(state, stored)) return;
+    const mark = stored.lastCacheDispatch;
+    const base = mark?.at ?? entry.setAt;
+    const dueAt = base + (mark?.idleMs ?? cacheWarmIdleMs(undefined));
+    this.armAt(entry, dueAt);
+  }
+
+  private armAt(entry: ISessionCacheWarm, dueAt: number): void {
+    if (dueAt >= entry.warmUntil) return;
+    const now = this.options.clock.now();
+    entry.nextWarmAt = dueAt;
+    entry.warmTimer = this.options.clock.setTimeout(() => {
+      entry.warmTimer = undefined;
+      void this.fire(entry);
+    }, Math.max(0, dueAt - now));
+  }
+
+  private disarm(entry: ISessionCacheWarm): void {
+    if (entry.warmTimer !== undefined) this.options.clock.clearTimeout(entry.warmTimer);
+    entry.warmTimer = undefined;
+    delete entry.nextWarmAt;
+  }
+
+  private remove(entry: ISessionCacheWarm): void {
+    this.disarm(entry);
+    if (entry.deadlineTimer !== undefined) this.options.clock.clearTimeout(entry.deadlineTimer);
+    entry.deadlineTimer = undefined;
+    if (this.entries.get(entry.key) === entry) this.entries.delete(entry.key);
+  }
+
+  /** Whether the keeper's scope state is active and still holds its session. */
+  private holdsSession(entry: ISessionCacheWarm): boolean {
+    return entry.state.lifecycle === 'active'
+      && entry.state.sessions.get(entry.sessionId) === entry.stored
+      && !entry.state.tombstones.has(entry.sessionId);
+  }
+
+  private stopUnavailable(entry: ISessionCacheWarm, error?: unknown): void {
+    if (this.entries.get(entry.key) !== entry) return;
+    entry.firing = false;
+    this.remove(entry);
+    this.emit(entry.scopeId, entry.stored.session, {
+      type: 'cache.warm.stopped',
+      reason: 'unavailable',
+      ...(error === undefined ? {} : { error: errorToInfo(error) }),
+    });
+  }
+
+  private stopAtDeadline(entry: ISessionCacheWarm): void {
+    entry.deadlineTimer = undefined;
+    if (this.entries.get(entry.key) !== entry) return;
+    if (!this.holdsSession(entry)) {
+      this.stopUnavailable(entry);
+      return;
+    }
+    this.remove(entry);
+    this.emit(entry.scopeId, entry.stored.session, { type: 'cache.warm.stopped', reason: 'deadline' });
+  }
+
+  private async fire(entry: ISessionCacheWarm): Promise<void> {
+    delete entry.nextWarmAt;
+    if (this.entries.get(entry.key) !== entry || entry.firing || this.core.closed) return;
+    if (this.options.clock.now() >= entry.warmUntil) {
+      this.stopAtDeadline(entry);
+      return;
+    }
+    if (!this.holdsSession(entry)) {
+      this.stopUnavailable(entry);
+      return;
+    }
+    const { state, stored } = entry;
+    // A busy session arms the timer again when its run ends, through `onPromptFinished`.
+    if (this.isBusy(state, stored)) return;
+    const idleMs = stored.lastCacheDispatch?.idleMs ?? cacheWarmIdleMs(undefined);
+    if (this.isHeld(state, stored)) {
+      this.armAt(entry, this.options.clock.now() + idleMs);
+      return;
+    }
+    entry.firing = true;
+    entry.firedAfterIdleMs = this.options.clock.now() - (stored.lastCacheDispatch?.at ?? entry.setAt);
+    try {
+      await this.core.prompts.enqueuePromptInternal(
+        entry.scopeId,
+        entry.sessionId,
+        FLEX_CACHE_WARM_PROMPT,
+        { ...(stored.cacheWarmPromptOptions ?? {}), maxSteps: cacheWarmMaxSteps },
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        false,
+        true,
+      );
+    } catch (error) {
+      if (this.entries.get(entry.key) !== entry) return;
+      entry.firing = false;
+      if (error instanceof FlexHarnessSessionBusyError) {
+        // Work arrived meanwhile: its run end arms the timer again, as does a later idle check.
+        this.armAt(entry, this.options.clock.now() + idleMs);
+        return;
+      }
+      this.stopUnavailable(entry, error);
+    }
+  }
+
+  private emit(scopeId: string, session: IFlexSession, details: TEventDetails): void {
+    this.core.emitEvent(scopeId, session, details);
+  }
+}

package/ts/classes.flexharness.callbacks.ts

@@ -455,6 +455,7 @@ export class FlexHarnessRunCallbacks<TScope> {
         ...(generationId === undefined ? {} : { runId: generationId }),
         source,
         ...call,
+        ...(run?.cacheWarm ? { cacheWarm: true } : {}),
       });
     } catch (error) {
       // AgentSession isolates the entire callback, including event/context failures. Join it later.