@intentic/sandbox-contract 1.310.0 → 1.311.0

package/src/schemas/devices.ts

@@ -9,6 +9,14 @@ import { DEV_VERSION } from "../state/versions.js";
 // One sandbox's resource share as docker currently enforces it, read off the container by the machine agent.
 // `overlayRuntime` is the environment's locked demand; `hostRuntime` is the owner's addition; `privileged`/`gpu` are
 // docker's enforced truth.
+// Reshape request, turned into `ic sandbox reshape` flags: absent means leave it, `null` on the two caps means back to
+// the default; at least one key must be set.
+export const SandboxResourcesAskFieldsSchema = z.object({
+    memoryGib: z.int().positive().nullable().optional(),
+    cpus: z.int().positive().nullable().optional(),
+    privileged: z.boolean().optional(),
+    gpu: z.boolean().optional(),
+});
 export const SandboxResourcesSchema = z.object({
     // The cgroup memory ceiling in bytes; absent when docker imposes none (the hosted shape).
     memoryBytes: z.number().optional(),
@@ -18,17 +26,12 @@ export const SandboxResourcesSchema = z.object({
     gpu: z.boolean(),
     hostRuntime: z.array(z.string()),
     overlayRuntime: z.array(z.string()),
+    // A reshape saved for the sandbox's next restart (`ic sandbox reshape --later`) and not yet in force: the next
+    // update, rollback, rebuild, reshape or Restart applies it. Absent when nothing is saved.
+    saved: SandboxResourcesAskFieldsSchema.optional(),
 });
 export type SandboxResources = z.infer<typeof SandboxResourcesSchema>;
 
-// Reshape request, turned into `ic sandbox reshape` flags: absent means leave it, `null` on the two caps means back to
-// the default; at least one key must be set.
-export const SandboxResourcesAskFieldsSchema = z.object({
-    memoryGib: z.int().positive().nullable().optional(),
-    cpus: z.int().positive().nullable().optional(),
-    privileged: z.boolean().optional(),
-    gpu: z.boolean().optional(),
-});
 // Fields also exported separately for callers that compose them and enforce the at-least-one rule themselves.
 export const SandboxResourcesAskSchema = SandboxResourcesAskFieldsSchema.refine((ask) => Object.values(ask).some((value) => value !== undefined), {
     message: "a reshape must change at least one thing",
@@ -81,8 +84,12 @@ export const DeviceSandboxFlowSchema = z.object({
     slug: z.string().min(1),
     // Approved overlay's sha256, required only by `rebuild`; only content matching it is ever built.
     hash: z.string().optional(),
-    // What `reshape` should change, required by it and meaningless to the rest.
+    // What `reshape` should change, meaningless to the rest. Absent on a reshape applies what is saved for the next
+    // restart now; absent with `later` forgets what is saved.
     resources: SandboxResourcesAskSchema.optional(),
+    // `reshape` only: save `resources` for the sandbox's next restart instead of restarting it now, replacing
+    // whatever was saved before (`ic sandbox reshape --later`).
+    later: z.boolean().optional(),
     // `runner-up` only, daemon-filled, never by the caller: the browser never holds the pairing credential.
     parentUrl: z.string().optional(),
     pair: z.string().optional().meta({ secret: true }),

package/src/schemas/keep-warm.test.ts

@@ -0,0 +1,68 @@
+import { TranscriptFold } from "../text/transcript-fold.js";
+import {
+    changedParts,
+    keepWarmCap,
+    keepWarmDueAt,
+    keepWarmHorizon,
+    keepWarmLeadMs,
+    keepWarmMaxRefreshes,
+    keepWarmRefreshes,
+    keptWarmLine,
+} from "./keep-warm.js";
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+
+// The arithmetic both the daemon and every press read, so the price shown before a press is the price the daemon keeps.
+describe("keep-warm economics", () => {
+    test("refreshes a fifth of an entry's life early, never under a minute or over ten", () => {
+        expect(keepWarmLeadMs(HOUR)).toBe(10 * MINUTE);
+        expect(keepWarmLeadMs(5 * MINUTE)).toBe(MINUTE);
+    });
+
+    test("spends at most half of what a cold resume would rewrite", () => {
+        // A 1h rewrite costs 2x base input and a read 0.1x: nineteen reads break even, so nine.
+        expect(keepWarmMaxRefreshes(HOUR)).toBe(9);
+        // A 5m rewrite costs 1.25x: eleven reads break even, so five.
+        expect(keepWarmMaxRefreshes(5 * MINUTE)).toBe(5);
+    });
+
+    test("counts the refreshes that keep an entry alive through the deadline", () => {
+        const cache = { at: 0, ttlMs: HOUR };
+        expect(keepWarmRefreshes(cache, HOUR)).toBe(0);
+        expect(keepWarmRefreshes(cache, 4 * HOUR)).toBe(4);
+        expect(keepWarmDueAt(cache)).toBe(50 * MINUTE);
+    });
+
+    test("reaches no further than the horizon, or the date change when that comes first", () => {
+        const cache = { at: 0, ttlMs: HOUR };
+        expect(keepWarmHorizon(cache)).toBe(HOUR + 9 * 50 * MINUTE);
+        expect(keepWarmCap(cache, 3 * HOUR)).toBe(3 * HOUR);
+        expect(keepWarmCap({ at: 0, ttlMs: 5 * MINUTE }, undefined)).toBe(5 * MINUTE + 5 * 4 * MINUTE);
+    });
+
+    test("names the parts two fingerprints disagree on", () => {
+        const before = { hash: "a", parts: { version: "1", model: "m", day: "d1" } };
+        expect(changedParts(before, { hash: "b", parts: { version: "2", model: "m", day: "d2" } })).toEqual(["day", "version"]);
+        expect(changedParts(before, before)).toEqual([]);
+    });
+});
+
+describe("the receipt a kept conversation's turn leaves", () => {
+    test("says it picked up warm, and for how long it was kept", () => {
+        expect(keptWarmLine({ readTokens: 251_000, writtenTokens: 3_000, kept: { forMs: 3 * HOUR + 12 * MINUTE, refreshes: 4 } })).toBe(
+            "Picked up warm: 251k tokens read from the cache, kept warm for 3h 12m with 4 refreshes.",
+        );
+    });
+
+    test("says so plainly when the turn went cold anyway", () => {
+        expect(keptWarmLine({ readTokens: 0, writtenTokens: 250_000, kept: { forMs: 40 * MINUTE, refreshes: 1 } })).toContain("Picked up cold");
+    });
+
+    test("is a notice row in the transcript, and nothing for a turn nobody kept", () => {
+        const fold = new TranscriptFold([]);
+        expect(fold.apply({ kind: "prompt_cache", readTokens: 10, writtenTokens: 200_000 })).toEqual([]);
+        fold.apply({ kind: "prompt_cache", readTokens: 251_000, writtenTokens: 3_000, kept: { forMs: HOUR, refreshes: 1 } });
+        expect(fold.rows.at(-1)).toMatchObject({ role: "notice", text: expect.stringContaining("Picked up warm") });
+    });
+});

package/src/schemas/keep-warm.ts

@@ -0,0 +1,124 @@
+// keep-warm: holding an idle conversation's prompt cache open by re-reading it shortly before it expires.
+
+import { z } from "zod";
+
+const HOUR_MS = 3_600_000;
+
+// Anthropic's price multipliers on base input: a read costs 0.1x, a write 2x under the 1h TTL and 1.25x under 5m.
+const READ_COST = 0.1;
+const writeCost = (ttlMs: number): number => (ttlMs >= HOUR_MS ? 2 : 1.25);
+
+// A cache clock as the daemon publishes it: the last request that touched the entry, and the entry's lifetime.
+export interface CacheClock {
+    readonly at: number;
+    readonly ttlMs: number;
+}
+
+/** How long before expiry a refresh starts: a fifth of the entry's life, never under a minute or over ten. */
+export const keepWarmLeadMs = (ttlMs: number): number => Math.min(10 * 60_000, Math.max(60_000, Math.round(ttlMs / 5)));
+
+/** Refreshes one hold may spend: half of what a cold resume rewrites, the other half left for each refresh's own tail. */
+export const keepWarmMaxRefreshes = (ttlMs: number): number => Math.floor((writeCost(ttlMs) - READ_COST) / READ_COST / 2);
+
+/** How many refreshes keep an entry alive through `until`. */
+export const keepWarmRefreshes = (cache: CacheClock, until: number): number => {
+    const beyond = until - (cache.at + cache.ttlMs);
+    return beyond <= 0 ? 0 : Math.ceil(beyond / (cache.ttlMs - keepWarmLeadMs(cache.ttlMs)));
+};
+
+/** The latest instant a hold may reach, given the refreshes it already spent: past it, refreshing costs more than the cold resume it saves. */
+export const keepWarmHorizon = (cache: CacheClock, spent = 0): number =>
+    cache.at + cache.ttlMs + Math.max(0, keepWarmMaxRefreshes(cache.ttlMs) - spent) * (cache.ttlMs - keepWarmLeadMs(cache.ttlMs));
+
+/** When the next refresh is due for an entry last touched at `cache.at`. */
+export const keepWarmDueAt = (cache: CacheClock): number => cache.at + cache.ttlMs - keepWarmLeadMs(cache.ttlMs);
+
+/** The furthest `until` a hold can honestly promise: the economic horizon, or the date change, whichever comes first. */
+export const keepWarmCap = (cache: CacheClock, rollsAt: number | undefined, spent = 0): number =>
+    rollsAt === undefined ? keepWarmHorizon(cache, spent) : Math.min(keepWarmHorizon(cache, spent), rollsAt);
+
+// Why a hold ended before anyone picked the conversation up. `elapsed` is the one ending that is not a problem.
+export const KeepWarmEndSchema = z.enum(["elapsed", "allowance", "limited", "changed", "rewrote", "cold", "failed", "midnight", "moved"]);
+export type KeepWarmEnd = z.infer<typeof KeepWarmEndSchema>;
+
+export const KeepWarmSchema = z.object({
+    since: z.number().describe("When keeping it warm started, in milliseconds."),
+    until: z
+        .number()
+        .describe(
+            "When it stops by itself, in milliseconds: the time asked for, shortened to what the sandbox can honestly keep, which is never past the point where refreshing costs more than re-reading, nor past the date change that rewrites the prompt.",
+        ),
+    auto: z.boolean().optional().describe("Started by the sandbox-wide setting after a turn, rather than by a press on this conversation."),
+    refreshes: z.number().int().min(0).describe("Refreshes sent so far."),
+    readTokens: z
+        .number()
+        .optional()
+        .describe("How much the last refresh read back from the provider's cache, in tokens: the proof the cache was still there."),
+    ended: z
+        .object({
+            at: z.number().describe("When it stopped, in milliseconds."),
+            reason: KeepWarmEndSchema.describe(
+                "Why: `elapsed` the time asked for ran out; `allowance` the account reached the reserve kept for real work; `limited` the provider refused a refresh; `changed` what the next turn would send no longer matches the cache; `rewrote` a refresh found the cache already gone; `cold` it expired before a refresh could run; `failed` a refresh failed; `midnight` the date in the prompt changed; `moved` the conversation's session or account changed.",
+            ),
+            detail: z.string().optional().describe("The specifics, when there are any: which parts of the prompt changed, or the failure's own words."),
+        })
+        .optional()
+        .describe("Why keeping it warm stopped before anyone picked the conversation up. Absent while it is still being kept."),
+});
+export type KeepWarm = z.infer<typeof KeepWarmSchema>;
+
+export const AgentKeepWarmSchema = z.object({
+    id: z.string().min(1).describe("Which conversation."),
+    until: z
+        .number()
+        .nullable()
+        .describe(
+            "Keep its prompt cache warm until this instant, in milliseconds; shortened to what the sandbox can honestly keep. Null stops keeping it warm.",
+        ),
+});
+export type AgentKeepWarm = z.infer<typeof AgentKeepWarmSchema>;
+
+// What a turn's first request found in the cache, and how long it had been kept warm for it when it was.
+export const PromptCacheOpeningSchema = z.object({
+    readTokens: z.number().describe("Tokens the turn's first request read from the provider's cache."),
+    writtenTokens: z.number().describe("Tokens it wrote to the cache, which is what it paid full price for."),
+    kept: z
+        .object({
+            forMs: z.number().describe("How long the cache had been kept warm for this turn, in milliseconds."),
+            refreshes: z.number().int().min(0).describe("How many refreshes that took."),
+        })
+        .optional()
+        .describe("Present when this turn picked up a conversation the sandbox had been keeping warm."),
+});
+export type PromptCacheOpening = z.infer<typeof PromptCacheOpeningSchema>;
+
+const tokensLabel = (tokens: number): string => (tokens >= 1_000 ? `${Math.round(tokens / 1_000)}k` : String(tokens));
+
+const spanLabel = (ms: number): string => {
+    const minutes = Math.max(1, Math.round(ms / 60_000));
+    const hours = Math.floor(minutes / 60);
+    return hours === 0 ? `${minutes}m` : `${hours}h ${minutes % 60}m`;
+};
+
+/** The transcript's line for a turn that picked up a conversation kept warm for it; undefined for any other turn. */
+export const keptWarmLine = (opening: PromptCacheOpening): string | undefined => {
+    const { kept } = opening;
+    if (kept === undefined) {
+        return undefined;
+    }
+    const held = `kept warm for ${spanLabel(kept.forMs)} with ${kept.refreshes} ${kept.refreshes === 1 ? "refresh" : "refreshes"}`;
+    return opening.readTokens >= opening.writtenTokens
+        ? `Picked up warm: ${tokensLabel(opening.readTokens)} tokens read from the cache, ${held}.`
+        : `Picked up cold despite being ${held}: ${tokensLabel(opening.writtenTokens)} tokens sent again, because this turn's prompt no longer matched the cache.`;
+};
+
+// A turn's prefix, part by part, so two turns that should share a cache can say which part stopped matching.
+export const PromptFingerprintSchema = z.object({
+    hash: z.string().describe("One short hash over every part."),
+    parts: z.record(z.string(), z.string()).describe("Each part's own short hash or value, by name."),
+});
+export type PromptFingerprint = z.infer<typeof PromptFingerprintSchema>;
+
+/** Which parts differ between two fingerprints, by name; empty when they match. */
+export const changedParts = (before: PromptFingerprint, after: PromptFingerprint): string[] =>
+    [...new Set([...Object.keys(before.parts), ...Object.keys(after.parts)])].filter((name) => before.parts[name] !== after.parts[name]).toSorted();

package/src/schemas/providers/provider-oauth.ts

@@ -22,6 +22,12 @@ export const OauthAccountSchema = z.object({
         .optional()
         .describe("Its stored credential can no longer be renewed and somebody has to sign in again. Absent means healthy, or not checked yet."),
     detail: z.string().optional().describe("Why, in words a person can act on."),
+    seatRefusal: z
+        .string()
+        .optional()
+        .describe(
+            "Its organisation has switched it off for this harness (no seat): it still signs in and its plan limits may still read, but no turn can run on it until an admin gives access back. The provider's own sentence; cleared by the next turn that runs on it. Absent means no refusal is on file.",
+        ),
     usage: AccountUsageSchema.optional().describe(
         "How full its plan limits were when last measured, so a picker can show what is left before committing work to it. Absent until a reading exists, which reads as unknown rather than as nothing left.",
     ),

package/src/schemas/providers/usage.ts

@@ -103,6 +103,13 @@ export const UsageTurnSchema = z.object({
     compactions: z.number().optional(),
     contextTokens: z.number().optional(),
     contextWindow: z.number().optional(),
+    // Absent is a turn; `keep-warm` is a cache refresh sent while the conversation sat idle, billed but not a turn.
+    purpose: z.enum(["keep-warm"]).optional().describe("What the row is when it is not a turn: `keep-warm` is a cache refresh sent while the conversation sat idle."),
+    // The first request alone: a warm resume reads nearly the whole context here, a cold one writes it.
+    openingCacheReadTokens: z.number().optional().describe("Tokens the turn's first request read from the provider's cache."),
+    openingCacheCreationTokens: z.number().optional().describe("Tokens the turn's first request wrote to the provider's cache."),
+    // Equal on two turns means the prefix both sent was assembled from the same parts (PromptFingerprintSchema).
+    promptFingerprint: z.string().optional().describe("A short hash over the parts of the prompt a cache is keyed on; a change between two turns names why the second could not reuse the first's cache."),
     // This turn's model was chosen by the Auto judge reading the conversation's opening message, not picked by hand.
     // Marked on that one turn only; a later row of the same conversation naming a different model is the user
     // overruling it, which is the escalation rate this feature has to be able to answer for.

package/src/schemas/settings.ts

@@ -387,6 +387,36 @@ export const SandboxSettingsSchema = z.object({
         .describe(
             "When a spent usage limit moves a turn to another account, carry the provider session (the model keeps everything, and re-reads all of it once on the other account) while the conversation's context is under this many tokens; at or above it, start a fresh session with the sandbox's measured brief instead. Zero always starts fresh.",
         ),
+    // Off by default: every refresh spends the account's own allowance on a conversation nobody is using yet.
+    keepWarm: z
+        .boolean()
+        .default(false)
+        .describe(
+            "Keep a Claude conversation's prompt cache warm after each turn a person asked for, so coming back to it hours later costs a cache read instead of re-sending everything. Each refresh re-reads the cached context at the cache price and adds nothing to the conversation. Any one conversation can be kept warm or let cool by hand either way.",
+        ),
+    keepWarmHours: z
+        .number()
+        .min(1)
+        .max(8)
+        .default(4)
+        .describe(
+            "How long an idle conversation is kept warm after its last turn, in hours. Shortened where refreshing would cost more than the cold resume it saves, and at midnight where the agent runs, when the date in its prompt changes.",
+        ),
+    keepWarmMinTokens: z
+        .number()
+        .int()
+        .min(0)
+        .default(100_000)
+        .describe("Only conversations at least this large, in tokens, are kept warm by themselves: a small one is cheap to re-read anyway."),
+    keepWarmReserve: z
+        .number()
+        .int()
+        .min(0)
+        .max(90)
+        .default(15)
+        .describe(
+            "How much of an account's usage limit, in percent, keeping conversations warm must leave untouched for real work. Refreshing stops once any limit that account's model spends is fuller than that.",
+        ),
     // Worth it since the container is recreated on every update or environment approval — otherwise approving a
     // Dockerfile change costs the run that asked for it.
     // What happens to breakage found after the work that caused it has left the turn: a land that turns the main tree's own

package/src/state/fix-stance.test.ts

@@ -45,6 +45,20 @@ test("held work reads as a fix to review, whether the fleet called it ready or l
     expect(fixStance(agent({ status: `idle`, diff: { files: 4, insertions: 120, deletions: 8 } })).kind).toBe(`ready`);
 });
 
+test.each([
+    ["holding work", { files: 4, insertions: 120, deletions: 8 }],
+    ["holding nothing yet", undefined],
+] as const)("a turn that ended waiting on its own watch, %s, is still working", (_case, diff) => {
+    const watches = [{ id: `watch-a1b2`, note: `CI on the pushed branch`, intervalSeconds: 60, deadlineAt: 9_000 }];
+    expect(fixStance(agent({ status: `idle`, watches, ...(diff === undefined ? {} : { diff }) }))).toStrictEqual({
+        kind: `working`,
+        ongoing: true,
+        retry: false,
+        label: `Agent working`,
+        hint: `An agent is already working on this failure. Open the conversation to watch it.`,
+    });
+});
+
 // Diff present doesn't change a failed status to ready; it only earns a mention in the hint.
 test("an agent that failed after writing files still reads as failed", () => {
     const stance = fixStance(agent({ status: `error`, diff: { files: 2, insertions: 34, deletions: 6 } }));

package/src/state/fix-stance.ts

@@ -130,6 +130,8 @@ const RULES: readonly ((agent: AgentSummary) => FixStance | undefined)[] = [
             ? needsYou("Needs you", "The fix agent has stopped and is waiting on you.")
             : undefined,
     (agent) => (IN_FLIGHT.has(agent.status) ? WORKING : undefined),
+    // An armed watch wakes it again by itself, so neither what it holds nor holding nothing is its last word yet.
+    (agent) => ((agent.watches?.length ?? 0) > 0 ? WORKING : undefined),
     (agent) => (holdingWork(agent) ? READY : undefined),
     (agent) => (agent.status === "landed" ? LANDED : undefined),
 ];

package/src/state/runtime-state.ts

@@ -27,6 +27,10 @@ const RUNTIME_DOMAINS = [
     // The agent's Chromiums and open pages, daemon-held, minted from its own browser tool-call hooks.
     { domain: "browsers", invalidates: [["browsers"]] },
 
+    // A connection's status as its last probe found it: pushed when a probe behind a served answer finds another one, and
+    // when a browser sign-in is saved or cleared, which is what moves an account's card off "log in".
+    { domain: "capabilities", invalidates: [["capabilities"]] },
+
     // Daemon-held; changes continuously (tokens, tool uses), so it's rate-limited rather than pushed per mutation.
     { domain: "subagents", invalidates: [["subagents"]] },
 

package/src/text/transcript-fold.test.ts

@@ -439,7 +439,7 @@ describe("patches", () => {
             "append",
             "tool",
             "tool",
-            "tool",
+            "toolThinking",
             "tool",
             "replace",
             "append",
@@ -451,6 +451,25 @@ describe("patches", () => {
         ]);
     });
 
+    it("send a delegation's card without its subtree or thinking, and a client keeps the ones it has", () => {
+        const events: AgentEvent[] = [
+            { kind: "tool_call", id: "task-1", name: "Agent", category: "other", status: "in_progress" },
+            { kind: "tool_call", id: "t2", name: "Read", category: "read", status: "in_progress", parentToolUseId: "task-1" },
+            { kind: "thinking", text: "in", parentToolUseId: "task-1" },
+            { kind: "thinking", text: "ner", parentToolUseId: "task-1" },
+            { kind: "tool_call_update", id: "task-1", status: "completed" },
+        ];
+        const { folded, applied, patches } = replay(openingOf("go"), events);
+        expect(applied).toEqual(folded);
+        expect(patches.filter((patch) => patch.op === "toolThinking")).toEqual([
+            { op: "toolThinking", index: 1, id: "task-1", text: "in" },
+            { op: "toolThinking", index: 1, id: "task-1", text: "ner" },
+        ]);
+        const update = patches.at(-1);
+        expect(update?.op === "tool" ? update.tool : undefined).toEqual({ id: "task-1", name: "Agent", category: "other", status: "completed" });
+        expect(applied[1]?.tools?.[0]).toMatchObject({ status: "completed", thinking: "inner", children: [{ id: "t2" }] });
+    });
+
     // The other half of the wake's delivery: a live turn takes it as a steer. It is the daemon's own words either way,
     // so it must not become a user row here, and must not leave a rewind anchor pointing at a message nobody sent.
     it("writes a watch's wake into a live turn as a notice, and never as a steer to rewind to", () => {

package/src/text/transcript-fold.ts

@@ -11,6 +11,7 @@ import {
     type TranscriptTool,
 } from "../events/transcript.js";
 import { contextTrimLine } from "../schemas/context-trim.js";
+import { keptWarmLine } from "../schemas/keep-warm.js";
 import { turnedAwayCode } from "../policy/turned-away.js";
 import { mentionedPathTokens } from "./mentions.js";
 import { unspokenPromptRow } from "../events/agent-words.js";
@@ -21,6 +22,9 @@ import { unspokenPromptRow } from "../events/agent-words.js";
 
 export type TurnEnding = "settled" | "stopped";
 
+// A compaction's row, live and restored from the provider's store alike.
+export const COMPACTED_NOTICE = "Context compacted to free up space.";
+
 // Where a tool card lives: its row, and the parent card it nests under when it's a helper's own call.
 interface CardPlace {
     readonly tool: TranscriptTool;
@@ -32,6 +36,9 @@ interface CardPlace {
 const defined = <T extends object>(value: T): Partial<T> =>
     Object.fromEntries(Object.entries(value).filter(([, field]) => field !== undefined)) as Partial<T>;
 
+// A card's own fields: what a `tool` patch carries, so a delegation's growing subtree never rides one.
+const ownFields = ({ children: _children, thinking: _thinking, ...own }: TranscriptTool): TranscriptTool => own;
+
 const cardOf = (event: Extract<AgentEvent, { kind: "tool_call" }>): TranscriptTool => ({
     id: event.id,
     name: event.name,
@@ -296,7 +303,16 @@ export class TranscriptFold {
             }
             case "usage": {
                 // Lands on the last assistant bubble and closes it: a steered turn's stream can carry several turns.
-                const { kind: _kind, account: _account, cacheReadTokens: _read, cacheCreationTokens: _written, ...usage } = event;
+                const {
+                    kind: _kind,
+                    account: _account,
+                    cacheReadTokens: _read,
+                    cacheCreationTokens: _written,
+                    openingCacheReadTokens: _openingRead,
+                    openingCacheCreationTokens: _openingWritten,
+                    promptFingerprint: _fingerprint,
+                    ...usage
+                } = event;
                 const index = this.rows.findLastIndex((row) => row.role === "assistant");
                 const closed = this.closeBubble();
                 if (index === -1) {
@@ -318,6 +334,11 @@ export class TranscriptFold {
             case "preamble":
                 // Collapses the daemon's preamble notes onto the user row; an empty note list is not a disclosure.
                 return event.notes.length === 0 ? [] : this.stampOpener((row) => (row.notes = [...event.notes]));
+            case "prompt_cache": {
+                // Only a conversation the sandbox kept warm gets a row: every other turn's cache is its own business.
+                const line = keptWarmLine(event);
+                return line === undefined ? [] : this.pushRow({ role: "notice", text: line });
+            }
             case "context_trim":
                 // A row of its own rather than a stamp on the message: what was left out is not part of what was sent,
                 // and the fold beside the message only ever lists notes that actually rode.
@@ -327,7 +348,7 @@ export class TranscriptFold {
             case "landed":
                 return this.pushRow(landedRow(event));
             case "compact":
-                return this.pushRow({ role: "notice", text: `Context compacted to free up space.` });
+                return this.pushRow({ role: "notice", text: COMPACTED_NOTICE });
             case "error":
                 // Keeps a refusal (no prose from the provider) from reading as a session that ended mid-question.
                 // A refusal that ran nothing takes its message back out ahead of the notice standing in for it.
@@ -519,9 +540,8 @@ export class TranscriptFold {
             return [];
         }
         if (event.kind === "thinking") {
-            return this.patchCard(parent, (tool) => {
-                tool.thinking = `${tool.thinking ?? ""}${event.text}`;
-            });
+            place.tool.thinking = `${place.tool.thinking ?? ""}${event.text}`;
+            return [{ op: "toolThinking", index: place.row, id: parent, text: event.text }];
         }
         if (event.kind === "tool_call") {
             const child = cardOf(event);
@@ -590,7 +610,7 @@ export class TranscriptFold {
             return [];
         }
         mutate(place.tool);
-        return [{ op: "tool", index: place.row, tool: structuredClone(place.tool), ...(place.parent === undefined ? {} : { parent: place.parent }) }];
+        return [{ op: "tool", index: place.row, tool: structuredClone(ownFields(place.tool)), ...(place.parent === undefined ? {} : { parent: place.parent }) }];
     }
 
     private stampOpener(mutate: (row: TranscriptRow) => void): TranscriptPatch[] {
@@ -637,15 +657,25 @@ export const applyTranscriptPatch = (rows: readonly TranscriptRow[], patch: Tran
             return rows.map((row, index) => (index === patch.index ? { ...row, text: `${row.text}${patch.text}` } : row));
         case "thinking":
             return rows.map((row, index) => (index === patch.index ? { ...row, thinking: `${row.thinking ?? ""}${patch.text}` } : row));
+        case "toolThinking":
+            return rows.map((row, index) => (index === patch.index ? { ...row, tools: [...appendToolThinking(row.tools ?? [], patch.id, patch.text)] } : row));
         case "tool":
             return rows.map((row, index) => (index === patch.index ? { ...row, tools: upsertTool(row.tools ?? [], patch.tool, patch.parent) } : row));
     }
 };
 
-// Replaces the tool with this id anywhere in the tree, or appends it under `parent`, or at top level with no parent or
-// no match.
+// Appends a delegated subagent's reasoning onto the card with this id, wherever it nests.
+export const appendToolThinking = (tools: readonly TranscriptTool[], id: string, text: string): readonly TranscriptTool[] =>
+    mapTool(tools, id, (card) => ({ ...card, thinking: `${card.thinking ?? ""}${text}` }));
+
+// Replaces the tool with this id anywhere in the tree, keeping the nested calls and thinking it already holds, or appends
+// it under `parent`, or at top level with no parent or no match.
 export const upsertTool = (tools: readonly TranscriptTool[], tool: TranscriptTool, parent: string | undefined): TranscriptTool[] => {
-    const replaced = mapTool(tools, tool.id, () => tool);
+    const replaced = mapTool(tools, tool.id, (current) => ({
+        ...tool,
+        ...(current.children === undefined ? {} : { children: current.children }),
+        ...(current.thinking === undefined ? {} : { thinking: current.thinking }),
+    }));
     if (replaced !== tools) {
         return [...replaced];
     }

package/src/time/zone.ts

@@ -108,6 +108,13 @@ const offsetMinutes = (at: number, zone: Zone): number => {
     return (match[1] === "-" ? -1 : 1) * (Number(match[2]) * 60 + Number(match[3]));
 };
 
+/** The instant the calendar day after the one `at` falls on begins, in a named zone: where `civilDayIn` next changes. */
+export const nextDayStartIn = (at: number, zone: Zone): number => {
+    const [year = 0, month = 1, day = 1] = civilDayIn(at, zone).split("-").map(Number);
+    const midnightUtc = Date.UTC(year, month - 1, day + 1);
+    return midnightUtc - offsetMinutes(midnightUtc, zone) * 60_000;
+};
+
 /** Whether two zones are showing the same wall clock right now — which is when naming one on screen would be noise. */
 export const sameClock = (a: Zone, b: Zone, at: number = Date.now()): boolean => a === b || offsetMinutes(at, a) === offsetMinutes(at, b);
 

package/src/webext/index.ts

@@ -2,7 +2,7 @@
 // `src/index.ts` reaches every schema and contract in the repo, and the extension's bundle is uploaded to a store,
 // where ~400 kB of the daemon's unrelated wire surface is both dead weight and something a reviewer has to account for.
 // Nothing here may import that barrel, or the saving is silently undone — `pnpm --filter @intentic/webext build`
-// prints the bundle size, and _devices/webext/README.md records what it should be.
+// checks the bundle against the ceiling in _devices/webext/scripts/size-budget.mjs.
 export { webextContract } from "../contracts/webext.contract.js";
 export * from "../protocol/webext-links.js";
 export * from "../protocol/webext-protocol.js";