@intentic/sandbox-contract 1.311.0 → 1.313.0

package/src/state/fix-stance.ts

@@ -1,5 +1,5 @@
 import { turnedAwayCode } from "../policy/turned-away.js";
-import type { AgentSummary } from "../schemas/agents.js";
+import { type AgentSummary, awaitsWake } from "../schemas/agents.js";
 
 /* WHAT BECAME OF THE AGENT A SURFACE SENT AFTER A FAILURE — a red pipeline row, a refused push. */
 
@@ -130,8 +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),
+    // It runs again by itself (a watch, a waiting wake), so neither what it holds nor holding nothing is its last word yet.
+    (agent) => (awaitsWake(agent) ? WORKING : undefined),
     (agent) => (holdingWork(agent) ? READY : undefined),
     (agent) => (agent.status === "landed" ? LANDED : undefined),
 ];

package/src/state/history-state.ts

@@ -22,6 +22,9 @@ export const HISTORY_STATE_FILES: readonly StateFile[] = [
     // conversation's own runtime session store (what `.intentic/records/sessions/claude/` holds for every other).
     // Carried whole, like the conversation it is.
     { path: "conversations/", portability: "carry" },
+    // The long tool outputs those transcripts name rather than hold, stored once by content for every record naming
+    // them; a transcript without them keeps only each output's start.
+    { path: "blobs/", portability: "carry" },
     // Index of published-page conversations; the pages travel with /work anyway, this makes one withdrawable.
     { path: "shares.json", portability: "carry" },
     { path: "activity.jsonl", portability: "carry" },
@@ -67,8 +70,14 @@ export const HISTORY_STATE_FILES: readonly StateFile[] = [
     { path: ".isolation-probe", portability: "derived" },
     // Finished bundles, excluded so an export doesn't pack every prior export in; kept off /work, unwatched.
     { path: "exports/", portability: "derived" },
+    // Each transcript as it was before this format converted it, zstd-compressed: a local way back, never read here.
+    { path: "backups/", portability: "derived" },
     // Bundles being taken in, mid-review; excluded as someone else's. Deleted on apply/abandon, swept after a crash.
     { path: "arrivals/", portability: "derived" },
+    // The agent engines this sandbox installed beside the image's own, each with its pointer file; reinstalled on demand.
+    { path: "engines/", portability: "derived" },
+    // An update the host downloaded and built for this sandbox (`ic sandbox prepare`); about this machine only.
+    { path: "update-staged.json", portability: "derived" },
 
     /* ---- credentials ---- */
 
@@ -120,4 +129,14 @@ export const HISTORY_STATE_FILES: readonly StateFile[] = [
     // The owner's yes to each workspace extension's declared powers, decided again by the target's owner.
     { path: "extension-approvals.json", portability: "identity", note: "Approve the extensions written in this workspace again from Extensions." },
     { path: "local-cert/", portability: "identity" },
+
+    /* ---- the state engine's own bookkeeping (the daemon's store/evolution/state-journal.ts) ---- */
+
+    // Pre-images of the history files an update's conversions changed; `secret` since identity files are among them.
+    { path: "converting/", portability: "secret", note: "An update's undo record stays with the sandbox it happened on." },
+    // Which conversion episodes are open or recently committed, and earlier addresses awaiting removal.
+    { path: "state-journal.json", portability: "derived" },
+    // Every conversation the import of the pre-1.308 layout settled (the daemon's conversations/registry/pre-1308-import.ts),
+    // so one deleted after its import is not brought back from the old files still on disk. About this volume only.
+    { path: "pre-1308-import.json", portability: "derived" },
 ];

package/src/state/landed-commit.test.ts

@@ -1,4 +1,4 @@
-import { declaredTestNote, landedCommitMessage } from "./landed-commit.js";
+import { declaredAllows, 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
 // the trip from the conversation's last word into the message a land commits under.
@@ -15,3 +15,14 @@ test("a Test-Note is read only from a line that starts with one and says somethi
     expect(declaredTestNote("I kept a Test-Note: nowhere near the start")).toBeUndefined();
     expect(declaredTestNote("Test-Note:   \n")).toBeUndefined();
 });
+
+// An exception a conversation declared rides its land's commit, one trailer per line, for the checks that read them.
+test("an Allow line is read from each line that starts with one, and each commits as its own trailer", () => {
+    const said = "Done.\n\nAllow: layout — the fixtures folder is one suite's data\nAllow: paths — the test spells a root on purpose\nI would Allow: nothing here";
+    const allows = declaredAllows(said);
+    expect(allows).toEqual(["layout — the fixtures folder is one suite's data", "paths — the test spells a root on purpose"]);
+    expect(declaredAllows("Allow:   \n")).toEqual([]);
+    expect(landedCommitMessage({ subject: "fix: tabs", testNote: "Rows became a table.", allows })).toBe(
+        "fix: tabs\n\nTest-Note: Rows became a table.\nAllow: layout — the fixtures folder is one suite's data\nAllow: paths — the test spells a root on purpose",
+    );
+});

package/src/state/landed-commit.ts

@@ -7,6 +7,7 @@ export const landedCommitMessage = (landed: LandedMessage): string => {
         landed.note === undefined ? "" : `Release-Note: ${landed.note}`,
         landed.breaking === undefined ? "" : `Breaking-Note: ${landed.breaking}`,
         landed.testNote === undefined ? "" : `Test-Note: ${landed.testNote}`,
+        ...(landed.allows ?? []).map((allow) => `Allow: ${allow}`),
     ]
         .filter((line) => line !== "")
         .join("\n");
@@ -15,3 +16,7 @@ export const landedCommitMessage = (landed: LandedMessage): string => {
 
 // The `Test-Note:` line a conversation ended its last message with, when it declared a weakened test on purpose.
 export const declaredTestNote = (said: string): string | undefined => /^Test-Note:[ \t]*(\S.*)$/m.exec(said)?.[1]?.trim();
+
+// The `Allow: <check> — <reason>` lines a conversation ended its last message with, each an exception it declared for
+// its change on purpose; the check after the land and the push read them off the landed commit.
+export const declaredAllows = (said: string): string[] => [...said.matchAll(/^Allow:[ \t]*(\S.*)$/gm)].map((match) => match[1]!.trim());

package/src/state/red-streak.test.ts

@@ -0,0 +1,28 @@
+import { headStreak, nextStreak } from "./red-streak.js";
+
+// The five places that asked "is this still the same red" asked it five ways; these are the two answers they share.
+
+describe(`a streak followed one observation at a time`, () => {
+    test(`begins at the first red, keeps that start through every red after it, and ends at anything else`, () => {
+        const first = nextStreak(undefined, true, 10);
+        expect(first).toEqual({ since: 10, count: 1 });
+        const second = nextStreak(first, true, 20);
+        expect(second).toEqual({ since: 10, count: 2 });
+        expect(nextStreak(second, false, 30)).toBeUndefined();
+        expect(nextStreak(undefined, false, 30)).toBeUndefined();
+    });
+
+    test(`begins again when the red is a different failure`, () => {
+        expect(nextStreak({ since: 10, count: 3 }, true, 40, false)).toEqual({ since: 40, count: 1 });
+    });
+});
+
+describe(`a streak read off a history`, () => {
+    test(`is the unbroken run of red at the head, newest first`, () => {
+        const history = [`red-3`, `red-2`, `green-1`, `red-0`];
+        expect(headStreak(history, (item) => item.startsWith(`red`))).toEqual([`red-3`, `red-2`]);
+        expect(headStreak([`green`, `red`], (item) => item === `red`)).toEqual([]);
+        expect(headStreak([`red`, `red`], (item) => item === `red`)).toEqual([`red`, `red`]);
+        expect(headStreak([], () => true)).toEqual([]);
+    });
+});

package/src/state/red-streak.ts

@@ -0,0 +1,28 @@
+// ONE DEFINITION OF A RED STREAK, for every source that goes red: a land check's project (verify-store.ts), main's CI
+// (repair-gate.ts), a pipeline branch on the board (the pipelines extension's ciStreaks.ts) and the Main line's older
+// daemons (the editor's mainlineView.ts). A streak is the unbroken run of red at the head: a red extends it, anything
+// else ends it, and `since` is where it began, which is what names one failure across every red that continues it.
+
+export interface Streak {
+    // When (or at which run) the streak began: the first red of the unbroken run.
+    readonly since: number;
+    // How many reds in a row it holds.
+    readonly count: number;
+}
+
+/**
+ * One observation's effect on the streak before it. A red continues it, unless `continues` says this red is a different
+ * failure (CI: no failed job repeats), which begins one of its own; anything else ends it.
+ */
+export const nextStreak = (previous: Streak | undefined, red: boolean, at: number, continues = true): Streak | undefined => {
+    if (!red) {
+        return undefined;
+    }
+    return previous !== undefined && continues ? { since: previous.since, count: previous.count + 1 } : { since: at, count: 1 };
+};
+
+/** The streak a newest-first history stands on: its unbroken run of red at the head, newest first; empty when the head is not red. */
+export const headStreak = <T>(newestFirst: readonly T[], isRed: (item: T) => boolean): T[] => {
+    const end = newestFirst.findIndex((item) => !isRed(item));
+    return end === -1 ? [...newestFirst] : newestFirst.slice(0, end);
+};

package/src/state/runtime-state.ts

@@ -58,6 +58,10 @@ const RUNTIME_DOMAINS = [
 
     // The audit log grew or a gateway's status moved or aged out; the log lives outside /work, so no file push carries it.
     { domain: "activity", invalidates: [["activity"], ["activity-status"]] },
+
+    // The main tree's own check after a land: queued, started, settled, or its red handed to somebody. Held in the
+    // daemon's memory as much as in a file, so a push is the only way a watcher hears it move.
+    { domain: "mainline", invalidates: [["mainline"]] },
 ] as const satisfies readonly RuntimeDomainBinding[];
 
 export const RUNTIME_DOMAIN_BINDINGS: readonly RuntimeDomainBinding[] = RUNTIME_DOMAINS;

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

@@ -1,4 +1,4 @@
-import { STATE_DIR } from "@intentic/constants";
+import { HISTORY_ROOT, STATE_DIR } from "@intentic/constants";
 import type { FileContribution } from "@intentic/extension-manifest";
 import {
     BACKED_UP_STATE_PATHS,
@@ -129,6 +129,12 @@ describe(`isReportedManifest`, () => {
         // What `relative` gives the daemon for a manifest kept under /history.
         expect(isReportedManifest(`../../history/settings.json`)).toBe(false);
     });
+
+    it(`reports the conversation registry on the daemon's volume by its absolute path, and nothing else there`, () => {
+        expect(isReportedManifest(`${HISTORY_ROOT}/conversations.db`)).toBe(true);
+        expect(isReportedManifest(`${HISTORY_ROOT}/state-journal.json`)).toBe(false);
+        expect(isReportedManifest(`../history/conversations.db`)).toBe(false);
+    });
 });
 
 describe(`WORKSPACE_STATE_FILES`, () => {

package/src/state/workspace-state.ts

@@ -1,4 +1,4 @@
-import { STATE_DIR } from "@intentic/constants";
+import { HISTORY_ROOT, STATE_DIR } from "@intentic/constants";
 import type { FileContribution } from "@intentic/extension-manifest";
 import type { StateFile } from "./state-portability.js";
 
@@ -267,6 +267,14 @@ const STATE_FILES = [
     // Per-extension update/advisory/health findings, written by the periodic check and by update/revert. Pushed live
     // so an auto-disabling advisory doesn't wait for a reload.
     { path: ".intentic/records/extension-updates.json", invalidates: ["extensions"], portability: "carry" },
+    // Every conversion an update ran over this workspace's files, newest last and capped (the daemon's
+    // state-convergence.ts). `carry`: what happened to the owner's files is their history, wherever it goes next.
+    {
+        path: ".intentic/records/conversions.json",
+        invalidates: [],
+        why: "Written once per update that converted something, at boot before any browser is connected; the update card reads the plan from the new image instead.",
+        portability: "carry",
+    },
     // Owner's per-extension update posture (notify/agent/auto, advisory opt-out). `carry`: a decision about the
     // extension, not the machine.
     { path: ".intentic/config/extension-update-policy.json", invalidates: ["extensions"], portability: "carry", versioned: true },
@@ -348,6 +356,14 @@ const STATE_FILES = [
         why: "Scratch that agents and tools leave behind (build logs, demo checkouts); nothing reads it after the turn that wrote it. The state janitor empties it at boot.",
         portability: "derived",
     },
+    // What the file view deleted, one folder per delete, kept so Undo can put it back. A day is longer than any undo
+    // stack lives in a browser tab; the hourly janitor sweep drops what's older.
+    {
+        path: ".intentic/local/trash/",
+        invalidates: [],
+        why: "Entries deleted from the file view, held for a day so Undo can restore them; nothing renders it, and the janitor expires it.",
+        portability: "derived",
+    },
     // Account for the pnpm store even though pnpm creates it, not the daemon.
     {
         path: ".intentic/local/.pnpm-store/",
@@ -366,7 +382,13 @@ const STATE_FILES = [
     {
         path: ".intentic/records/verify.json",
         invalidates: [],
-        why: "The dependency verifier's verdict memory; nothing renders it directly, outcomes reach the owner as activity entries and workspace events.",
+        why: "The main-line check's memory: each project's last verdict and red streak, and the latest runs with what became of each red one. Read through GET /workspace/mainline, which the daemon pushes itself (the `mainline` runtime domain), so no file watch is needed.",
+        portability: "carry",
+    },
+    {
+        path: ".intentic/records/push-checks.json",
+        invalidates: [],
+        why: "What each push check found and let through, per project, and what became of every finding: still open, measured gone, or dismissed. Filed from the report the pre-push hook leaves in the repository's git dir; read through GET /workspace/mainline, which the daemon pushes itself (the `mainline` runtime domain).",
         portability: "carry",
     },
     {
@@ -375,6 +397,16 @@ const STATE_FILES = [
         why: "A running check's wrapper artifacts (log + exit status), read once by the daemon when the panel finishes.",
         portability: "derived",
     },
+    // What an update converted before it booted all the way (the sandbox daemon's state-journal.ts): a copy of every
+    // file the new version changed, kept until it commits and for a grace window after. `secret` whatever the source
+    // was, since a vault's copy is a vault; locked below for the same reason.
+    {
+        path: ".intentic/secrets/converting/",
+        invalidates: [],
+        why: "Pre-images of the files an update's conversions changed; only the boot step reads them, to put a rolled-back version's files back.",
+        portability: "secret",
+        note: "An export does not carry an update's undo record; the target converts its own files.",
+    },
     {
         path: ".intentic/secrets/ci.json",
         invalidates: [],
@@ -569,9 +601,17 @@ export const REPORTED_MANIFEST_PATHS: readonly string[] = WORKSPACE_STATE_FILES.
     (file) => file.path,
 );
 
+// Files on the daemon's own volume whose unreadable records are reported too, named by their absolute path there: the
+// conversation registry's rows, one of which this build could not read costs that conversation until a build that can
+// runs. Reported, never repaired from the card (no route edits them), and refreshed whenever the card is fetched.
+export const REPORTED_VOLUME_FILES: readonly string[] = [`${HISTORY_ROOT}/conversations.db`];
+
 // Accepts either separator; the daemon holds these as platform paths and normalizing at every call site is what
 // eventually gets forgotten.
-export const isReportedManifest = (relPath: string): boolean => REPORTED_MANIFEST_PATHS.includes(relPath.replaceAll("\\", "/"));
+export const isReportedManifest = (relPath: string): boolean => {
+    const path = relPath.replaceAll("\\", "/");
+    return REPORTED_MANIFEST_PATHS.includes(path) || REPORTED_VOLUME_FILES.includes(path);
+};
 
 // Entries directly under `.intentic/` the file API refuses to read, write, move or delete for anyone, owner
 // included (workspace/workspace-files.ts enforces it). Declared here so the browser can draw the same rule instead
@@ -588,6 +628,8 @@ export const LOCKED_STATE_ENTRIES: ReadonlySet<string> = new Set([
     "secrets/ci.json",
     "secrets/doors.json",
     "secrets/auth",
+    // An update's pre-images: copies of whatever it converted, vaults included.
+    "secrets/converting",
     "records/sessions",
     "local/browser",
     // The provider CLI's own home, undeclared in the table above and so without a group; stays at the state dir root.

package/src/text/shell-regions.test.ts

@@ -0,0 +1,38 @@
+import { heredocBodies } from "./shell-regions.js";
+
+// The one heredoc scan the policy classifier and the daemon's command readers share, pinned by exact offset.
+
+const bodiesOf = (command: string): string[] => heredocBodies(command).map(({ start, end }) => command.slice(start, end));
+
+test("a body starts on the line after its opener, not at the newline, and ends where its terminator's line starts", () => {
+    expect(heredocBodies("cat <<EOF\nx\nEOF")).toEqual([{ start: 10, end: 12 }]);
+    const command = "cat > f <<'EOF'\nline one\nline two\nEOF\nls";
+    expect(heredocBodies(command)).toEqual([{ start: command.indexOf("line one"), end: command.indexOf("EOF\nls") }]);
+    expect(bodiesOf(command)).toEqual(["line one\nline two\n"]);
+});
+
+test("`<<` ends only at a terminator in the first column: an indented one is body, as bash reads it", () => {
+    const command = "cat <<EOF\n  x\n  EOF\n\tEOF\nrm -rf /";
+    expect(heredocBodies(command)).toEqual([{ start: 10, end: command.length }]);
+});
+
+test("`<<-` ends at a tab-indented terminator", () => {
+    const command = "cat <<-EOF\n\tx\n\tEOF\nls";
+    expect(heredocBodies(command)).toEqual([{ start: 11, end: 14 }]);
+    expect(bodiesOf(command)).toEqual(["\tx\n"]);
+});
+
+test("the terminator is the whole word on its line, quoted delimiters included", () => {
+    expect(bodiesOf("cat <<EOF\nEOFX\nxEOF\nEOF\nls")).toEqual(["EOFX\nxEOF\n"]);
+    expect(bodiesOf(`cat <<'END'\n$HOME\nEND`)).toEqual(["$HOME\n"]);
+    expect(bodiesOf(`cat <<"END"\n$HOME\nEND`)).toEqual(["$HOME\n"]);
+});
+
+test("an unterminated body runs to the end of the command, and an opener with no line after it has none", () => {
+    expect(heredocBodies("cat <<'EOF'\nrm -rf /")).toEqual([{ start: 12, end: 20 }]);
+    expect(heredocBodies("cat <<EOF")).toEqual([]);
+});
+
+test("every heredoc in the command is found, in order", () => {
+    expect(bodiesOf("cat <<A >a\n1\nA\ncat <<-B >b\n\t2\n\tB\nls")).toEqual(["1\n", "\t2\n"]);
+});

package/src/text/shell-regions.ts

@@ -30,9 +30,8 @@ const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
 // `<<EOF`, `<<-EOF`, quoted or not; the delimiter's quoting only affects expansion, not classification here.
 const HEREDOC_OPEN = /<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1/g;
 
-// Found in their own pass, first: a heredoc body is line-oriented and can hold anything, an odd quote count in it would
-// desync the word scanner.
-const heredocBodies = (command: string): CommandSpan[] => {
+// Heredoc bodies in order, each from the line after its opener to its terminator's line; as in bash, only `<<-` indents that.
+export const heredocBodies = (command: string): CommandSpan[] => {
     const bodies: CommandSpan[] = [];
     for (const open of command.matchAll(HEREDOC_OPEN)) {
         const indented = command.slice(open.index, open.index + 3).startsWith("<<-");
@@ -158,6 +157,7 @@ const scanWords = (command: string, skip: readonly CommandSpan[]): ShellWord[] =
 // Unsorted and possibly overlapping; callers only ask containment of them. Computed once per command by the classifier
 // and shared across every table.
 export const inertRegions = (command: string): CommandSpan[] => {
+    // First, in a pass of their own: a body can hold anything, and an odd quote count in it would desync the word scanner.
     const bodies = heredocBodies(command);
     const regions: CommandSpan[] = [...bodies];
     const words = scanWords(command, bodies);

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

@@ -2,6 +2,8 @@ import { STATE_DIR } from "@intentic/constants";
 import type { AgentEvent } from "../events/agent-events.js";
 import type { TranscriptPatch, TranscriptRow } from "../events/transcript.js";
 import { watchWakePrompt } from "../events/watch-wake.js";
+import { LAND_CONFLICT_OPENING } from "../events/land-conflict.js";
+import { RESUME_NOTES } from "../events/resume.js";
 import { childReportPrompt, peerMessagePrompt } from "../events/agent-words.js";
 import { applyTranscriptPatch, foldTurn, TranscriptFold, userRow } from "./transcript-fold.js";
 
@@ -41,6 +43,19 @@ describe("foldTurn", () => {
         ]);
     });
 
+    // The sandbox's composed words (a land's breakage sent back into the live turn) are not the owner's: the row says who
+    // spoke them and what for, and a person's steer carries neither.
+    it("writes the sandbox's steer down with its speaker and errand, and a person's with neither", () => {
+        const events: AgentEvent[] = [
+            { kind: "steer", text: "the land broke main", sentAt: SENT_AT + 1, voice: "sandbox", errand: "land-breakage" },
+            { kind: "steer", text: "and the docs", sentAt: SENT_AT + 2 },
+        ];
+        expect(foldOf("ship it", events).slice(1)).toEqual([
+            { role: "user", text: "the land broke main", sentAt: SENT_AT + 1, speaker: { kind: "sandbox" }, errand: "land-breakage" },
+            { role: "user", text: "and the docs", sentAt: SENT_AT + 2 },
+        ]);
+    });
+
     it("does not retire a bubble that has written no prose", () => {
         const events: AgentEvent[] = [
             { kind: "tool_call", id: "t1", name: "Read", category: "read", status: "completed" },
@@ -249,6 +264,25 @@ describe("foldTurn", () => {
         );
     });
 
+    // A resolve turn exists because the branch couldn't rebase; its own opening rebase failing the same way is that
+    // errand said twice, one row under itself. Any other turn still hears it, and a resolve turn still hears what moved.
+    it("leaves the blocked rebase out of a land-conflict turn's notice, and only that", () => {
+        const blocked: AgentEvent = { kind: "worktree", branch: "agent/x", base: "abc1234", sync: { commits: 0, blocked: ["intentic"] } };
+        const resolve = `${LAND_CONFLICT_OPENING}\n\n1. \`git add -A && git commit\``;
+        expect(foldOf(resolve, [blocked])).toEqual(openingOf(resolve));
+        expect(foldOf(`${RESUME_NOTES.restart}\n\n${resolve}`, [blocked]).slice(1)).toEqual([]);
+        expect(foldOf("go", [blocked]).slice(1)).toEqual([
+            {
+                role: "notice",
+                text: "Couldn't rebase onto your workspace in intentic: the turn is running from the older base, so its land may need a resolve.",
+            },
+        ]);
+        const mixed: AgentEvent = { kind: "worktree", branch: "agent/x", base: "abc1234", sync: { commits: 3, blocked: ["intentic"] } };
+        expect(foldOf(resolve, [mixed]).slice(1)).toEqual([
+            { role: "notice", text: "Your workspace moved on while this agent waited, its branch was rebased onto your latest 3 commits." },
+        ]);
+    });
+
     it("stamps the checkpoint and the preamble's notes on the turn's user row", () => {
         const events: AgentEvent[] = [
             { kind: "checkpoint", id: "snap-1", index: 4 },
@@ -451,6 +485,18 @@ describe("patches", () => {
         ]);
     });
 
+    // A subagent thinks a token at a time; sending the spawning card whole each time would resend every child it holds.
+    it("sends a subagent's reasoning as its words alone, onto the card that spawned it", () => {
+        const fold = new TranscriptFold(openingOf("go"));
+        fold.apply({ kind: "tool_call", id: "task-1", name: "Agent", category: "other", status: "in_progress" });
+        fold.apply({ kind: "tool_call", id: "t2", name: "Read", category: "read", status: "completed", parentToolUseId: "task-1" });
+        expect(fold.apply({ kind: "thinking", text: "the handler", parentToolUseId: "task-1" })).toEqual([
+            { op: "toolThinking", index: 1, id: "task-1", text: "the handler" },
+        ]);
+        expect(fold.apply({ kind: "thinking", text: "", parentToolUseId: "task-1" })).toEqual([]);
+        expect(fold.rows[1]?.tools?.[0]?.thinking).toBe("the handler");
+    });
+
     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" },

package/src/text/transcript-fold.ts

@@ -12,6 +12,7 @@ import {
 } from "../events/transcript.js";
 import { contextTrimLine } from "../schemas/context-trim.js";
 import { keptWarmLine } from "../schemas/keep-warm.js";
+import { isLandConflict } from "../events/land-conflict.js";
 import { turnedAwayCode } from "../policy/turned-away.js";
 import { mentionedPathTokens } from "./mentions.js";
 import { unspokenPromptRow } from "../events/agent-words.js";
@@ -128,7 +129,7 @@ const undelivered = (unattended: boolean): string =>
 const memoryPress = (event: Extract<AgentEvent, { kind: "error" }>): "sendAnyway" | "sandboxMemory" =>
     event.memory === undefined ? "sendAnyway" : "sandboxMemory";
 
-// A memory hold is asked once and never again that spell (memory-admission.ts), so the next send always runs. A turn the
+// A memory hold is asked once and never again that spell (resource-budget.ts), so the next send always runs. A turn the
 // sandbox started itself (a fix press, a peer's message, a re-run) was never in a composer: its message stays above, and
 // the press asks the sandbox to run the turn it kept rather than sending a queue that holds nothing.
 const heldRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow => {
@@ -344,7 +345,7 @@ export class TranscriptFold {
                 // and the fold beside the message only ever lists notes that actually rode.
                 return this.pushRow({ role: "notice", text: contextTrimLine(event) });
             case "worktree":
-                return event.sync === undefined ? [] : this.pushRow({ role: "notice", text: syncLine(event.sync) });
+                return event.sync === undefined ? [] : this.synced(event.sync);
             case "landed":
                 return this.pushRow(landedRow(event));
             case "compact":
@@ -454,13 +455,22 @@ export class TranscriptFold {
             return this.pushRow(unspoken);
         }
         // A steer also closes the bubble, or the next answer would print over it mid-call.
-        const patches = this.pushRow({
-            role: "user",
-            text: event.text,
-            sentAt: event.sentAt,
-            ...(event.attachments === undefined ? {} : { attachments: [...event.attachments] }),
-            ...(event.messageId === undefined ? {} : { messageId: event.messageId }),
-        });
+        const row: TranscriptRow = { role: "user", text: event.text, sentAt: event.sentAt };
+        if (event.attachments !== undefined) {
+            row.attachments = [...event.attachments];
+        }
+        if (event.messageId !== undefined) {
+            row.messageId = event.messageId;
+        }
+        // The sandbox's own words say so on the row, so a reader never shows them as the owner's; an agent's words
+        // come as their own card (agentWords), which names the agent.
+        if (event.voice === "sandbox") {
+            row.speaker = { kind: "sandbox" };
+        }
+        if (event.errand !== undefined) {
+            row.errand = event.errand;
+        }
+        const patches = this.pushRow(row);
         // Anchors pair by position with the checkpoints only a person's steer reserves.
         if (event.voice === undefined) {
             this.steerRows.push(this.rows.length - 1);
@@ -539,7 +549,11 @@ export class TranscriptFold {
         if (place === undefined || parent === undefined) {
             return [];
         }
+        // Only the new words travel: the card whole, children and all, would go out again for every token.
         if (event.kind === "thinking") {
+            if (event.text.length === 0) {
+                return [];
+            }
             place.tool.thinking = `${place.tool.thinking ?? ""}${event.text}`;
             return [{ op: "toolThinking", index: place.row, id: parent, text: event.text }];
         }
@@ -613,6 +627,14 @@ export class TranscriptFold {
         return [{ op: "tool", index: place.row, tool: structuredClone(ownFields(place.tool)), ...(place.parent === undefined ? {} : { parent: place.parent }) }];
     }
 
+    // The rebase notice, less what a resolve turn was sent to fix: that turn opens because the branch couldn't rebase, so
+    // saying so again one row under its own errand only repeats it. What did move is still told.
+    private synced(sync: { commits: number; blocked: readonly string[] }): TranscriptPatch[] {
+        const opener = this.opener === undefined ? undefined : this.rows[this.opener];
+        const text = syncLine(opener !== undefined && isLandConflict(opener.text) ? { ...sync, blocked: [] } : sync);
+        return text === "" ? [] : this.pushRow({ role: "notice", text });
+    }
+
     private stampOpener(mutate: (row: TranscriptRow) => void): TranscriptPatch[] {
         if (this.opener === undefined) {
             return [];

package/dist/chores/fix-deps.d.ts

@@ -1,10 +0,0 @@
-export declare const FIX_DEPS_AUTOMATION: {
-    readonly id: "fix-dependency-breakage";
-    readonly title: "Fix what a dependency change broke";
-    readonly event: "deps.broken";
-    readonly holdForSeconds: 60;
-    readonly guard: `test "$(printf '%s' "$AUTOMATION_PAYLOAD" | jq -r '.deps.attempt // 1')" -le 2`;
-    readonly guardNote: "stops after 2 attempts";
-    readonly prompt: string;
-};
-//# sourceMappingURL=fix-deps.d.ts.map

package/dist/chores/fix-deps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fix-deps.d.ts","sourceRoot":"","sources":["../../src/chores/fix-deps.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB;aAC5B,EAAE,EAAE,yBAAyB;aAC7B,KAAK,EAAE,oCAAoC;aAC3C,KAAK,EAAE,aAAa;aACpB,cAAc,EAAE,EAAE;aAClB,KAAK,EAAE,gFAAgF;aACvF,SAAS,EAAE,wBAAwB;aACnC,MAAM;CAUA,CAAC"}

package/dist/chores/fix-deps.js

@@ -1,18 +0,0 @@
-export const FIX_DEPS_AUTOMATION = {
-    id: "fix-dependency-breakage",
-    title: "Fix what a dependency change broke",
-    event: "deps.broken",
-    holdForSeconds: 60,
-    guard: `test "$(printf '%s' "$AUTOMATION_PAYLOAD" | jq -r '.deps.attempt // 1')" -le 2`,
-    guardNote: "stops after 2 attempts",
-    prompt: "A landed change drifted this workspace's dependencies; the daemon reinstalled them and ran the project's own checks, " +
-        "and they failed. The payload names the project (`deps.project`), the check command (`deps.command`), how it exited " +
-        "(`deps.exitCode`) and the tail of its output (`deps.logTail`); the full log is in the project's `--verify` terminal.\n\n" +
-        "Re-run the check yourself to see the failure first-hand, then fix the ROOT CAUSE. That usually means updating call " +
-        "sites, types or tests to match what actually changed: never loosening or deleting the checks, pinning or downgrading " +
-        "dependencies just to silence them, or editing generated files. If the breakage needs a decision only the owner can " +
-        "make (an intentional breaking upgrade, a license change, a dependency that should be dropped), stop and say exactly " +
-        "that instead of guessing.\n\n" +
-        "Finish by running the same check command and reporting what was broken, what you changed, and whether it is green now.",
-};
-//# sourceMappingURL=fix-deps.js.map

package/dist/chores/fix-deps.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fix-deps.js","sourceRoot":"","sources":["../../src/chores/fix-deps.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAC/B,EAAE,EAAE,yBAAyB;IAC7B,KAAK,EAAE,oCAAoC;IAC3C,KAAK,EAAE,aAAa;IACpB,cAAc,EAAE,EAAE;IAClB,KAAK,EAAE,gFAAgF;IACvF,SAAS,EAAE,wBAAwB;IACnC,MAAM,EACF,uHAAuH;QACvH,qHAAqH;QACrH,0HAA0H;QAC1H,qHAAqH;QACrH,uHAAuH;QACvH,qHAAqH;QACrH,sHAAsH;QACtH,+BAA+B;QAC/B,wHAAwH;CACtH,CAAC"}

package/dist/protocol/ingress-protocol.d.ts

@@ -1,30 +0,0 @@
-import { type IncomingMessage, type ServerResponse } from "node:http";
-import { Duplex } from "node:stream";
-export declare const INITIAL_WINDOW_SIZE: number;
-export declare const CONNECTION_WINDOW_SIZE: number;
-export interface IngressSession {
-    readonly forwardRequest: (request: IncomingMessage, response: ServerResponse) => Promise<void>;
-    readonly forwardUpgrade: (request: IncomingMessage, socket: Duplex, head: Buffer) => Promise<void>;
-    readonly close: () => void;
-}
-export declare const openIngressSession: (duplex: Duplex) => Promise<IngressSession>;
-export interface ServeIngressSessionOptions {
-    readonly targetPort: number;
-}
-export interface IngressSessionServer {
-    readonly close: () => void;
-}
-export declare const serveIngressSession: (duplex: Duplex, options: ServeIngressSessionOptions) => Promise<IngressSessionServer>;
-export interface TunnelWebSocket {
-    readonly send: (data: Buffer, options: {
-        binary: boolean;
-    }, callback: (error?: Error) => void) => void;
-    readonly close: () => void;
-    readonly on: {
-        (event: `message`, listener: (data: unknown) => void): unknown;
-        (event: `close`, listener: () => void): unknown;
-        (event: `error`, listener: (error: Error) => void): unknown;
-    };
-}
-export declare const webSocketDuplex: (socket: TunnelWebSocket) => Duplex;
-//# sourceMappingURL=ingress-protocol.d.ts.map

package/dist/protocol/ingress-protocol.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ingress-protocol.d.ts","sourceRoot":"","sources":["../../src/protocol/ingress-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,eAAe,EAA4B,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAU7H,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAuGrC,eAAO,MAAM,mBAAmB,QAAc,CAAC;AAK/C,eAAO,MAAM,sBAAsB,QAA0B,CAAC;AAyE9D,MAAM,WAAW,cAAc;IAI3B,QAAQ,CAAC,cAAc,EAAE,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAG/F,QAAQ,CAAC,cAAc,EAAE,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnG,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC9B;AAID,eAAO,MAAM,kBAAkB,WAAkB,MAAM,KAAG,OAAO,CAAC,cAAc,CAuG/E,CAAC;AAIF,MAAM,WAAW,0BAA0B;IAEvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,oBAAoB;IAGjC,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC9B;AAID,eAAO,MAAM,mBAAmB,WAAkB,MAAM,WAAW,0BAA0B,KAAG,OAAO,CAAC,oBAAoB,CA4G3H,CAAC;AAKF,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,EAAE,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,KAAK,IAAI,CAAC;IACvG,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE;QACT,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC;QAC/D,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC;QAChD,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC;KAC/D,CAAC;CACL;AAED,eAAO,MAAM,eAAe,WAAY,eAAe,KAAG,MAoBzD,CAAC"}