@intentic/sandbox-contract 1.344.0 → 1.345.0

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

@@ -113,6 +113,22 @@ describe("foldTurn", () => {
         ]);
     });
 
+    // What a reader needs once nothing in memory remembers the subagent: the card the turn settles into keeps it.
+    it("keeps where the runtime holds an in-process subagent's own record on its card", () => {
+        const events: AgentEvent[] = [
+            { kind: "tool_call", id: "task-1", name: "Agent", category: "other", status: "in_progress" },
+            { kind: "subagent", id: "task-1", subagentKind: "subagent", agentType: "Explore" },
+            { kind: "subagent_update", id: "task-1", sdk: { sessionId: "ses-1", agentId: "a1b2" } },
+            { kind: "subagent_update", id: "task-1", status: "completed" },
+        ];
+        expect(foldOf("delegate", events).at(-1)?.tools?.[0]?.subagent).toEqual({
+            kind: "subagent",
+            agentType: "Explore",
+            status: "completed",
+            sdk: { sessionId: "ses-1", agentId: "a1b2" },
+        });
+    });
+
     // A spawned subagent is named by its own conversation, not the call that started it; the spawn answers with that
     // name, which is how its card is found, so it reads on its card exactly as an in-process one does.
     it("puts a spawned subagent on the card of the call whose result names it", () => {
@@ -931,6 +947,57 @@ describe(`a refusal that ran nothing`, () => {
         expect(fold.ranNothing).toBe(false);
     });
 
+    // The reported row (onboarding review 2026-10-18, F07): the trial ran out on a later step of a turn that had already
+    // edited a file, and the row said the message was not delivered and held to send again. Neither was true: the turn
+    // ran, nothing holds its words (turn-runs keeps only a turn turned away at the door), and a resend repeats its edits.
+    describe(`arriving after the turn already ran`, () => {
+        const SPENT = {
+            kind: `error`,
+            code: `trial-exhausted`,
+            message: `Free trial used up for today: every free agent step is spent. Connect a model to keep going.`,
+        } as const satisfies AgentEvent;
+        const EDITED: readonly AgentEvent[] = [
+            { kind: `tool_call`, id: `t1`, name: `Edit`, category: `edit`, status: `completed`, target: `src/page.tsx` },
+        ];
+
+        it(`says the run stopped partway with its changes kept, and offers another model rather than a resend`, () => {
+            const fold = new TranscriptFold(openingOf(`change the heading`));
+            for (const event of EDITED) {
+                fold.apply(event);
+            }
+            fold.apply(SPENT);
+
+            expect(fold.rows.map((row) => row.role)).toEqual([`user`, `assistant`, `notice`]);
+            expect(fold.rows.at(-1)).toEqual({
+                role: `notice`,
+                text: `${SPENT.message} The run stopped partway. The changes it made so far are kept: continue with another model to pick up from here.`,
+                noticeAction: `switchModel`,
+                noticeCode: { code: `stoppedPartway`, params: { message: SPENT.message, error: `trial-exhausted`, switchModel: true } },
+            });
+            expect(fold.ranNothing).toBe(false);
+        });
+
+        // Another model does not clear a full disk; the row still never claims the words are held.
+        it(`offers no model switch for a refusal another model would not get past`, () => {
+            const disk = { kind: `error`, code: `sandbox-disk-low`, message: `The sandbox's disk is full.` } as const satisfies AgentEvent;
+            expect(foldOf(`change the heading`, [...EDITED, disk]).at(-1)).toEqual({
+                role: `notice`,
+                text: `${disk.message} The run stopped partway. The changes it made so far are kept: send a message to pick up from here.`,
+                noticeCode: { code: `stoppedPartway`, params: { message: disk.message, error: `sandbox-disk-low` } },
+            });
+        });
+
+        it(`keeps the not-delivered row for the same refusal when nothing had run`, () => {
+            expect(foldOf(`change the heading`, [SPENT])).toEqual([
+                {
+                    role: `notice`,
+                    text: `${SPENT.message} Your message was not delivered: it is held for you to send again.`,
+                    noticeCode: { code: `undelivered`, params: { message: SPENT.message, error: `trial-exhausted` } },
+                },
+            ]);
+        });
+    });
+
     // The sandbox, not a composer, keeps a turn it started itself (a fix press, a peer's message): the frame says so
     // with `held`. The bug this exists for: such a refusal took the fix prompt out, and no queue anywhere held a copy.
     describe(`of a turn the sandbox keeps`, () => {

package/src/text/transcript-fold.ts

@@ -15,8 +15,8 @@ import { contextTrimLine, contextTrimNotice } from "../schemas/context-trim.js";
 import { keptWarmLine, keptWarmNotice } from "../schemas/keep-warm.js";
 import { handedOffLine, handedOffNotice } from "../schemas/providers/handoff.js";
 import { isLandConflict } from "../events/land-conflict.js";
-import { turnedAwayCode } from "../policy/turned-away.js";
-import { undeliveredRow } from "../events/undelivered.js";
+import { anotherModelClears, turnedAwayCode } from "../policy/turned-away.js";
+import { stoppedPartwayRow, undeliveredRow } from "../events/undelivered.js";
 import { mentionedPathTokens } from "./mentions.js";
 import { unspokenPromptRow } from "../events/agent-words.js";
 import { needRowText } from "../events/need-wake.js";
@@ -239,8 +239,8 @@ const RENEWAL_WITHDRAWN =
     "The credential was being renewed, but the turn stopped before it could continue: it will not carry on by itself, so press Continue to pick it back up.";
 
 // Row for a turn-ending error: the provider's own message plus one clause on what happens next. The live wait itself is
-// drawn by the chat, not stored here.
-const errorRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow => {
+// drawn by the chat, not stored here. `ran`: an assistant row stands, so a door refusal stopped the turn partway.
+const errorRow = (event: Extract<AgentEvent, { kind: "error" }>, ran: boolean): TranscriptRow => {
     const { message, code } = event;
     const said = failureOf(event);
     switch (code) {
@@ -281,7 +281,7 @@ const errorRow = (event: Extract<AgentEvent, { kind: "error" }>): TranscriptRow
         // provider's own uncoded words are only ever themselves.
         return code === undefined ? { role: "notice", text: message } : { role: "notice", text: message, noticeCode: noticeCode({ code: "failed", params: said }) };
     }
-    return heldRow(event);
+    return ran && event.held === undefined ? stoppedPartwayRow(said, anotherModelClears(code)) : heldRow(event);
 };
 
 // What a laddered wall's automatic re-runs are doing, said on the failure's own row so the count stays in the record.
@@ -488,7 +488,7 @@ export class TranscriptFold {
             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.
-                return [...this.retract(event), ...this.withdrawRenewal(event), ...this.pushRow(errorRow(event))];
+                return [...this.retract(event), ...this.withdrawRenewal(event), ...this.pushRow(errorRow(event, this.rows.some((row) => row.role === "assistant")))];
             case "plan": {
                 // Folds a plan into an identical retired prose bubble instead of drawing the same markdown twice.
                 const adjacent = this.rows.at(-1);

package/src/webext/index.ts

@@ -9,3 +9,5 @@ export * from "../protocol/doors/webext-protocol.js";
 export * from "../schemas/webext.js";
 export * from "../schemas/loopback-catch.js";
 export * from "../schemas/peer-enrollment.js";
+// What the extension says to `intentic-keyring native-host` (the Passwords app's browser capture and fill).
+export * from "../schemas/keyring-native.js";