@intentic/sandbox-contract 1.309.0 → 1.311.0

package/src/schemas/settings.ts

@@ -13,39 +13,28 @@ export const SystemPromptModeSchema = z.enum(["intentic", "claude", "custom"]);
 export type SystemPromptMode = z.infer<typeof SystemPromptModeSchema>;
 // Excludes "custom": there is nothing to fetch, it's whatever the owner already typed into the settings field.
 export const BuiltinPromptSchema = z.object({ base: z.enum(["intentic", "claude"]) });
-// Rules: "at this moment, if this is true, do this" — one table replacing three settings that were the same idea built
-// three ways; a fourth is now a row here, not a release. Moments are named to match `WorkspaceEventKind`, so folding
-// chores in later won't rename what users wrote.
-
-// Five places the daemon already stops to decide something; this names those decisions rather than inventing new ones.
+// Rules: "at this moment, if this is true, do this". The owner's rules decide (land, hold, version) and switch the
+// daemon's built-in reviews; every command a moment runs is a repository's own check (`<repo>/.intentic/checks.json`),
+// compiled into this same table by the daemon, so no command lives in settings.
 export const RuleMomentSchema = z.enum([
     // A command here runs on the just-written file (`{file}` is its path); the cheapest moment to catch a defect.
     "file.edited",
     // The assistant is about to stop. A rule here can send it back to work, which is the only moment that can.
     "turn.ending",
-    // Code is about to leave the machine. A rule here gates the push on its own exit code.
-    "push.starting",
     // An agent's turn is over and its delta is sitting on its branch. A rule here decides whether it lands.
     "agent.finished",
     // An agent's delta has just reached the main tree. A rule here decides what becomes of it there.
     "agent.landed",
 ]);
 export type RuleMoment = z.infer<typeof RuleMomentSchema>;
-// What a rule does; the split is functional since the three settings this table replaces each needed a different shape.
-// command: runs a shell command; its exit code is the verdict.
-// instruct: says something to the assistant before it finishes.
-// verdict: allows or holds what is about to happen (a pass with nothing to run, told which way to go).
-// builtin: invokes a named daemon behaviour the table has no business expressing itself.
-// Each reads a record only the daemon keeps, which is what makes it a built-in rather than a command.
-// verify-edits: what a turn edited, against what it ran.
-// verify-removals: what a turn deleted, against the repo's own history (a `git log` question, not a shell one-liner).
+// command: a repository's check; its exit code is the verdict.
+// verdict: allows or holds what is about to happen.
+// builtin: a daemon behaviour that reads a record only the daemon keeps.
 // verify-ui-edits: rendered surfaces a turn changed, against whether it ever looked at one.
-// verify-tests: whether a touched test's assertions got weaker than at HEAD, or would have passed before its own
-// change.
 // version-landed: commits what a land brought, in the main tree, under the subject drafted for it, and the tree's own
 // remainder before the next isolated turn starts; the only way a person who never commits keeps every agent seeing
 // the latest tree, since worktrees are cut from HEAD.
-export const RuleBuiltinSchema = z.enum(["verify-edits", "verify-removals", "verify-ui-edits", "verify-tests", "version-landed"]);
+export const RuleBuiltinSchema = z.enum(["verify-ui-edits", "version-landed"]);
 export type RuleBuiltin = z.infer<typeof RuleBuiltinSchema>;
 export const RuleActionSchema = z.discriminatedUnion("kind", [
     z.object({
@@ -54,7 +43,6 @@ export const RuleActionSchema = z.discriminatedUnion("kind", [
         // Past this, the process group is killed and the run is `failed`, never a silent pass.
         timeoutMs: z.number().min(60_000).max(3_600_000).default(900_000),
     }),
-    z.object({ kind: z.literal("instruct"), text: z.string().min(1).max(4000) }),
     z.object({ kind: z.literal("verdict"), verdict: z.enum(["allow", "hold"]) }),
     z.object({ kind: z.literal("builtin"), name: RuleBuiltinSchema }),
 ]);
@@ -63,8 +51,7 @@ export type RuleAction = z.infer<typeof RuleActionSchema>;
 // defaults to HELD unless a rule explicitly allows it.
 export const RuleOutcomeSchema = z.enum(["clean", "error", "conflict", "checks-failed"]);
 export type RuleOutcome = z.infer<typeof RuleOutcomeSchema>;
-// Three keys covering "only this repo" and "skip docs-only changes" without a query language; every key absent means
-// the rule always matches.
+// Every key absent means the rule always matches.
 export const RuleConditionSchema = z.object({
     // A workspace repo id, or "root". Absent ⇒ any.
     repo: z.string().min(1).optional(),
@@ -80,15 +67,13 @@ export type RuleCondition = z.infer<typeof RuleConditionSchema>;
 // validated here, not left to the consumer — the alternative is a rule that saves cleanly and silently does nothing.
 const MOMENT_ACTIONS: Record<RuleMoment, readonly RuleAction["kind"][]> = {
     "file.edited": ["command"],
-    "turn.ending": ["builtin", "instruct", "command"],
-    "push.starting": ["command"],
+    "turn.ending": ["builtin", "command"],
     "agent.finished": ["verdict"],
     "agent.landed": ["builtin"],
 };
-// A built-in reads a record only one moment keeps, so it stands at that moment alone: the verifiers read a turn's
-// ledgers, the versioner reads a landing's claim.
+// A built-in reads a record only one moment keeps, so it stands at that moment alone.
 const MOMENT_BUILTINS: Partial<Record<RuleMoment, readonly RuleBuiltin[]>> = {
-    "turn.ending": ["verify-edits", "verify-removals", "verify-ui-edits", "verify-tests"],
+    "turn.ending": ["verify-ui-edits"],
     "agent.landed": ["version-landed"],
 };
 export const RuleSchema = z
@@ -402,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
@@ -429,14 +444,17 @@ export const SandboxSettingsSchema = z.object({
         .describe(
             "Which repositories may run the checks they declare for themselves, and exactly which version of those checks you agreed to. A repository's declaration does nothing until it appears here, the same rule git keeps for hooks, which are never cloned; and a declaration that changes afterwards is held until you look at it again.",
         ),
-    // Lives in the owner's own settings, not the workspace: a rule can hold work and gate a push, so it answers to the
-    // sandbox owner alone. A repository may declare a COMMAND of its own (see `adoptedChecks`), never a verdict.
+    // The owner's alone, since a rule can hold work. A command is refused here: it belongs to the repository it checks,
+    // in that repository's `.intentic/checks.json`, never in settings.
     rules: z
         .array(RuleSchema)
         .max(50)
         .default([])
+        .refine((rules) => rules.every((rule) => rule.action.kind !== "command"), {
+            message: "a command belongs in the repository's own .intentic/checks.json, not in settings",
+        })
         .describe(
-            "Standing instructions you give the sandbox about its own work: ask for proof before a turn ends, run something before a push, hold or release finished work. Empty is the default and is exactly the behaviour of a fresh sandbox, because each of those defaults is what no rule matched means at its own moment.",
+            "Standing decisions about the sandbox's own work: land or hold finished work, save a version of what landed, ask the assistant to look at an interface it changed. Empty is the default and is exactly the behaviour of a fresh sandbox, because each of those defaults is what no rule matched means at its own moment. A command to run is a repository's own check, declared in its .intentic/checks.json.",
         ),
     automationFailureLimit: z
         .number()
@@ -608,27 +626,23 @@ export type SavingsReport = z.infer<typeof SavingsReportSchema>;
 // spelling for the daemon that reads it, the screen that names it and the demo that mimics it.
 export const REPO_CHECKS_FILE = `${STATE_DIR}/checks.json`;
 
-// Named for the occasion as a repository would say it, not for the daemon's wire moment: `edit` is `file.edited`,
-// `turn` is `turn.ending` and `push` is `push.starting` (rules/repo-checks.ts maps them). Three, because these are the
-// occasions whose command a repository actually owns; a verdict moment has nothing here to express.
-//
-// `edit` is the cheapest of the three and the only one that reaches the model while it still holds the line it wrote:
-// the command runs on that one file (`{file}`), and its output rides back in the edit's own response. A repository
-// that declares a whole-tree command here pays it per edit, so the command has to take the file.
-export const RepoCheckMomentSchema = z.enum(["edit", "turn", "push"]);
+// Named for the occasion as a repository would say it: `edit` is `file.edited`, `turn` is `turn.ending`, and `land` is
+// the daemon's run over the main tree after an install a land caused (rules/repo-checks.ts maps them). A push is gated by
+// the repository's own git pre-push hook, which every push runs, the app's included.
+// `edit` runs on one file (`{file}`) and its output rides back in the edit's own response, so a command declared there is
+// paid per edit and has to take the file.
+export const RepoCheckMomentSchema = z.enum(["edit", "turn", "land"]);
 export type RepoCheckMoment = z.infer<typeof RepoCheckMomentSchema>;
 
 export const RepoCheckSchema = z.object({
     when: RepoCheckMomentSchema.describe(
-        "When to run it: `edit` on each file as it is written (`{file}` is its path), `turn` before the assistant finishes, `push` before code leaves the machine.",
+        "When to run it: `edit` on each file as it is written (`{file}` is its path), `turn` before the assistant finishes, `land` on the main tree after finished work lands (absent, the package's own verify or test script runs there).",
     ),
     run: z.string().min(1).max(500).describe("The command, run in this repository's own directory, so it reads as it would in a terminal there."),
     label: z.string().min(1).max(80).optional().describe("What to call it on screen. Absent names it after the command."),
-    // Same ceiling as a rule's own command; past it the process group is killed and the run is a failure, never a
-    // silent pass.
+    // Same ceiling as a rule's own command; past it the process group is killed and the run is a failure.
     timeoutMs: z.number().min(60_000).max(3_600_000).optional().describe("How long it may take before it is killed and counted as failed."),
-    // Repo-relative, as anybody reading this file would write them; the daemon prefixes the repo id before matching,
-    // since a rule's globs are workspace-relative.
+    // Repo-relative; the daemon prefixes the repo id before matching, since a rule's globs are workspace-relative.
     paths: z
         .array(z.string().min(1))
         .max(20)
@@ -638,7 +652,16 @@ export const RepoCheckSchema = z.object({
 export type RepoCheck = z.infer<typeof RepoCheckSchema>;
 
 // The file itself. One key, so a second concern can be added later without breaking a file anyone has written.
-export const RepoChecksFileSchema = z.object({ checks: z.array(RepoCheckSchema).max(10).default([]) });
+export const RepoChecksFileSchema = z.object({
+    checks: z
+        .array(RepoCheckSchema)
+        .max(10)
+        .default([])
+        // One land check per repository: it is THE verdict on the main tree the push hook replays, not one of several.
+        .refine((checks) => checks.filter((check) => check.when === "land").length <= 1, { message: "a repository declares at most one land check" })
+        // A land checks the whole tree an install settled, not a change, so there is nothing for a glob to narrow.
+        .refine((checks) => checks.every((check) => check.when !== "land" || check.paths === undefined), { message: "a land check takes no paths" }),
+});
 export type RepoChecksFile = z.infer<typeof RepoChecksFileSchema>;
 
 // One repository, as a screen reads it: what it declares, and where that stands with the owner.
@@ -646,6 +669,11 @@ export const RepoChecksSummarySchema = z.object({
     repo: z.string().describe('Which repository, by its workspace id ("root" is the workspace itself).'),
     path: z.string().describe("Where the declaration lives, relative to the workspace, whether or not the file exists yet."),
     checks: z.array(RepoCheckSchema).describe("What it declares, in the order the file lists them."),
+    fired: z
+        .array(z.number().nullable())
+        .describe(
+            "When each declared check last reported something, in the file's order, as epoch milliseconds; null for one that never has, or for the land check, whose verdict the activity feed records instead.",
+        ),
     adopted: z
         .boolean()
         .describe("Whether these are running. False means declared and inert: nothing a repository writes runs until the owner switches it on."),
@@ -655,10 +683,16 @@ export const RepoChecksSummarySchema = z.object({
             "Whether the declaration changed since it was adopted, which holds it until the owner looks again. True only for a repository that was adopted before.",
         ),
     error: z.string().optional().describe("Why the file could not be read, when it exists but does not parse. The checks list is empty in that case."),
+    landDefault: z
+        .string()
+        .optional()
+        .describe(
+            "What runs on the main tree after a land when the file declares no `land` check: the package's own verify or test script. Absent when the repository has neither.",
+        ),
 });
 export type RepoChecksSummary = z.infer<typeof RepoChecksSummarySchema>;
 export const RepoChecksListSchema = z.object({
-    repos: z.array(RepoChecksSummarySchema).describe("Every repository that declares checks, plus any the owner has adopted before, sorted by id."),
+    repos: z.array(RepoChecksSummarySchema).describe("Every repository that declares checks or has a package check that runs after a land, in id order."),
 });
 export type RepoChecksList = z.infer<typeof RepoChecksListSchema>;
 export const RepoChecksAdoptSchema = z.object({

package/src/schemas/version-seam.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { CapabilitiesListSchema } from "./capabilities.js";
 import { SandboxSettingsSchema } from "./settings.js";
 import { SmbNetdiskConfigSchema } from "./netdisk.js";

package/src/state/contract-lock.test.ts

@@ -1,7 +1,6 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { packageRoot } from "@intentic/constants/node";
-import { test, expect } from "bun:test";
 import { currentLock } from "./contract-lock.js";
 
 // contract.lock.json must match the exported schemas; the git-aware half of this check lives in contract-shrink.mjs.

package/src/state/fix-attempt-plan.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { ciFixConversationId, fixAttemptId } from "../ids/conversation-ids.js";
 import type { AgentSummary } from "../schemas/agents.js";
 import { planFixAttempt } from "./fix-attempt-plan.js";

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

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { fixStance } from "./fix-stance.js";
 import type { AgentSummary } from "../schemas/agents.js";
 
@@ -46,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/landed-commit.test.ts

@@ -1,4 +1,3 @@
-import { expect, test } from "bun:test";
 import { declaredTestNote, landedCommitMessage } from "./landed-commit.js";
 
 // The push gate reads a weakening's declaration off the commit (assertion-ratchet.mjs), so the trailer must survive

package/src/state/runtime-state.test.ts

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { RUNTIME_DOMAIN_BINDINGS, staleRuntimeQueryKeys } from "./runtime-state.js";
 
 describe(`staleRuntimeQueryKeys`, () => {

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/state/versions.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { DEV_VERSION, isBehind, isNewer } from "./versions.js";
 
 test("isNewer compares dotted numeric versions", () => {

package/src/state/workspace-state.test.ts

@@ -1,6 +1,5 @@
 import { STATE_DIR } from "@intentic/constants";
 import type { FileContribution } from "@intentic/extension-manifest";
-import { describe, it, expect } from "bun:test";
 import {
     BACKED_UP_STATE_PATHS,
     isLockedWorkspacePath,
@@ -346,8 +345,6 @@ describe(`VERSIONED_STATE_PATHS`, () => {
             // Which commands count as heavy, and how many may run at once; a shared-box decision worth a `git log`
             // line.
             `${STATE_DIR}/config/heavy-commands.json`,
-            // The exclude list carves entries out by name; an unlisted directory is invisible to git and to land.
-            `${STATE_DIR}/config/hooks/`,
             `${STATE_DIR}/config/loop-designs.json`,
             `${STATE_DIR}/config/personas.json`,
             // A persona's prompt and reachable skills: the text that decides how it behaves, same reason as its card.

package/src/state/workspace-state.ts

@@ -120,20 +120,6 @@ const STATE_FILES = [
     // Bash command. `carry`: a property of the workspace, not the machine. `versioned`: raising the limit is a decision
     // worth a diff.
     { path: ".intentic/config/heavy-commands.json", invalidates: ["settings"], portability: "carry", versioned: true },
-    // Scripts the rule table runs, one per reader (settings.json points at them per event, e.g. `file.edited`).
-    // `versioned`: this is code that runs against every file an agent writes, more consequential than the rule naming
-    // it. `carry`: authored text, no credential. Invalidates nothing: the settings screen renders the rules from
-    // settings.json, not these scripts.
-    {
-        path: ".intentic/config/hooks/",
-        invalidates: [],
-        why: "The settings screen renders the rules that name these scripts, out of settings.json; nothing in the browser reads the scripts themselves.",
-        portability: "carry",
-        versioned: true,
-        // The daemon only runs these scripts by path; it never builds them, so there's no `statePath` call for the
-        // coverage guard to find.
-        outsideWriter: "the owner or an agent, authoring them; the daemon only ever RUNS one, by the path a rule's command names",
-    },
     // Last-fired stamps for the rule table. `derived`: records what happened on this machine, not carried.
     {
         path: ".intentic/local/rule-firings.json",

package/src/text/archives.test.ts

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { archiveFormat, archivePrefixOf, archiveRootOf, archiveStem, isBrowsableArchive, wrapsItsOwnName } from "./archives.js";
 
 describe(`archive names`, () => {

package/src/text/documents.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "bun:test";
 import { documentOf, documentTitle, isDocumentPath, isPlanDocumentPath } from "./documents.js";
 import { PLAN_DOCUMENTS_DIR } from "../state/workspace-state.js";
 

package/src/text/embed.test.ts

@@ -1,5 +1,4 @@
 import { webcrypto } from "node:crypto";
-import { test, expect, beforeAll, mock } from "bun:test";
 import { stubGlobal, unstubAllGlobals } from "@intentic/testing/bun";
 import { EmbedError, embedFailure, embedUrl, fetchEmbedJson, solveProofOfWork } from "./embed.js";
 
@@ -40,12 +39,12 @@ test("a refusal carries the server's own sentence and status, and a bodyless one
 test("a JSON fetch answers the body or throws the refusal", async () => {
     stubGlobal(
         "fetch",
-        mock(async () => new Response(JSON.stringify({ ok: true }), { status: 200 })),
+        jest.fn(async () => new Response(JSON.stringify({ ok: true }), { status: 200 })),
     );
     expect(await fetchEmbedJson<{ ok: boolean }>("https://x/y")).toEqual({ ok: true });
     stubGlobal(
         "fetch",
-        mock(async () => new Response(JSON.stringify({ error: "rate limited" }), { status: 429 })),
+        jest.fn(async () => new Response(JSON.stringify({ error: "rate limited" }), { status: 429 })),
     );
     await expect(fetchEmbedJson("https://x/y")).rejects.toMatchObject({ message: "rate limited", status: 429 });
     unstubAllGlobals();

package/src/text/emoji.test.ts

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { isSingleEmoji } from "./emoji.js";
 
 describe("isSingleEmoji", () => {

package/src/text/mentions.test.ts

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { AgentTurnSchema } from "../schemas/agent.js";
 import { MENTION_LIMIT, mentionedPathTokens, mentionPaths } from "./mentions.js";
 

package/src/text/path-refs.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "bun:test";
 import { isTestPath, rankRefCandidates, referenceTails } from "./path-refs.js";
 
 describe("referenceTails", () => {

package/src/text/title.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { AgentTurnSchema } from "../schemas/agent.js";
 import { deriveTitle } from "./title.js";
 

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

@@ -1,5 +1,4 @@
 import { STATE_DIR } from "@intentic/constants";
-import { describe, it, expect } from "bun:test";
 import type { AgentEvent } from "../events/agent-events.js";
 import type { TranscriptPatch, TranscriptRow } from "../events/transcript.js";
 import { watchWakePrompt } from "../events/watch-wake.js";
@@ -213,9 +212,19 @@ describe("foldTurn", () => {
         });
         // An outage nobody armed says so, instead of promising the breaker's retry.
         const unarmed: AgentEvent[] = [
-            { kind: "error", code: "provider-outage", message: "Anthropic is down.", autoResume: "available", outage: { retryAt: 1 }, retries: { made: 0, max: 6 } },
+            {
+                kind: "error",
+                code: "provider-outage",
+                message: "Anthropic is down.",
+                autoResume: "available",
+                outage: { retryAt: 1 },
+                retries: { made: 0, max: 6 },
+            },
         ];
-        expect(foldOf("hi", unarmed).at(-1)).toEqual({ role: "notice", text: "Anthropic is down. Nothing is retrying it, so the turn is waiting here." });
+        expect(foldOf("hi", unarmed).at(-1)).toEqual({
+            role: "notice",
+            text: "Anthropic is down. Nothing is retrying it, so the turn is waiting here.",
+        });
     });
 
     it("writes the turn's own events down as notices", () => {
@@ -430,7 +439,7 @@ describe("patches", () => {
             "append",
             "tool",
             "tool",
-            "tool",
+            "toolThinking",
             "tool",
             "replace",
             "append",
@@ -442,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/text/whisper.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { cleanTranscription } from "./whisper.js";
 
 test("flattens whisper output onto one line", () => {

package/src/text/workflow-faults.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { type Workflow, WorkflowSchema, type WorkflowStep } from "../schemas/workflows.js";
 import { workflowFaults, workflowRunFaults } from "./workflow-faults.js";
 

package/src/time/zone.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "bun:test";
 import { asCivilDay, asZone, civilDayIn, cronOptions, isZone, sameClock, utcDayOf, UTC, zoneLabel } from "./zone.js";
 import type { Zone } from "./zone.js";