@intentic/sandbox-contract 1.344.0 → 1.345.0

package/src/contracts/workspace.contract.ts

@@ -25,6 +25,8 @@ import {
     WorkspaceDerivedQuerySchema,
     WorkspaceDerivedSchema,
     WorkspaceDeletedSchema,
+    WorkspaceDimensionsQuerySchema,
+    WorkspaceDimensionsSchema,
     WorkspaceDirSchema,
     WorkspaceExtractSchema,
     WorkspaceRestoredSchema,
@@ -110,6 +112,20 @@ export const workspaceContract = {
         .meta({ floor: "viewer", guest: true })
         .input(WorkspaceDerivedQuerySchema)
         .output(WorkspaceDerivedSchema),
+    // A folder's pictures measured at once, so a gallery lays out its rows before the pictures themselves arrive. A body,
+    // not a query: the paths are a folder's worth.
+    dimensions: procedure
+        .route({
+            method: "POST",
+            path: "/workspace/dimensions",
+            summary: "Measure pictures and videos",
+            description:
+                "The width and height each picture or video is shown at, and a video's running time, for a list of workspace files. Only the files' headers are read, so a folder's worth costs little; a gallery uses it to lay out its rows before any picture has loaded. A file that is not a picture, or cannot be read, is simply left out.",
+        })
+        // Measuring is reading a file's header, and the answer is a few numbers per file.
+        .meta({ floor: "viewer", guest: true })
+        .input(WorkspaceDimensionsQuerySchema)
+        .output(WorkspaceDimensionsSchema),
     // Mints the ticket GET /workspace/media (a plain Hono byte-range route, no oRPC shape) requires to stream.
     mediaTicket: procedure
         .route({

package/src/events/agent-events.ts

@@ -8,7 +8,7 @@ import { FastModeStateSchema } from "../schemas/providers/fast-mode.js";
 import { NeedSchema } from "../schemas/needs.js";
 import { PromptCacheOpeningSchema, PromptFingerprintSchema } from "../schemas/keep-warm.js";
 import { AgentReplySchema, UsageWindowSchema } from "../schemas/providers/plan-limits.js";
-import { SubagentKindSchema, SubagentStatusSchema, SubagentVerificationSchema } from "../schemas/terminal.js";
+import { SubagentKindSchema, SubagentSdkRecordSchema, SubagentStatusSchema, SubagentVerificationSchema } from "../schemas/terminal.js";
 import { RetryLadderSchema } from "../schemas/turn-break.js";
 import { HandedOffSchema, HandoffOfferSchema } from "../schemas/providers/handoff.js";
 import { AgentCommandSchema, browserHelpRequest, capabilityOfferRequest, CapabilityOutcomeSchema, ContextUsageSchema, credentialOfferRequest, CredentialReceiptSchema, pageAskRequest, PageSchema, paymentOfferRequest, PaymentReceiptSchema, PermissionRequestSchema, PlanRequestSchema, QuestionRequestSchema, terminalHelpRequest, TodoItemSchema, ToolCallContentSchema, ToolCallLocationSchema, ToolCallStatusSchema, ToolKindSchema } from "./requests.js";
@@ -142,6 +142,9 @@ export const AgentEventSchema = z.discriminatedUnion("kind", [
         error: z.string().optional(),
         // Whether anything checked the work this report describes; rides the frame that ends the child.
         verification: SubagentVerificationSchema.optional(),
+        // Where the Claude runtime keeps an in-process child's own record, said once the daemon has paired it, so the
+        // card the turn settles into can name it after a restart.
+        sdk: SubagentSdkRecordSchema.optional(),
     }),
     z.object({ kind: z.literal("todos"), items: z.array(TodoItemSchema) }),
     // The provider's own slash commands, replaced whole each time; the composer's `/` popover lists them, invoking one

package/src/events/agent-transcript.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { AgentHarnessSchema, AgentProviderSchema } from "../schemas/agent.js";
+import { SessionTranscriptSchema, TurnEndingSchema } from "./transcript.js";
+
+// The record a reopened tab rebuilds from: messages plus what the session is bound to (provider, runtime, account). A
+// client can't derive these: after a mid-chat switch, its own picks belong to a different session.
+export const AgentTranscriptSchema = SessionTranscriptSchema.extend({
+    sessionId: z.string().optional().describe("The provider session behind the last turn, when there is one."),
+    provider: AgentProviderSchema.optional().describe("Which provider minted that session."),
+    harness: AgentHarnessSchema.optional().describe("Which runtime minted it: a session resumes only on the loop that opened it."),
+    account: z
+        .string()
+        .optional()
+        .describe("Which stored account it belongs to, as the daemon resolved it. Absent when no stored account paid for the turn."),
+    // How the last turn ended, for endings that leave a live session with just a press to offer; absent otherwise.
+    ending: TurnEndingSchema.optional().describe(
+        "How the last turn ended, when it left work behind that one press finishes. Absent for a conversation whose last turn ended on its own, and for the failures that name something to repair first.",
+    ),
+    // `from` offsets every `rewindIndex` here, and is the `before` for the page above; `more` flags older messages.
+    from: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe("Where the first message sits in the whole record, and the `before` that asks for the page above this one."),
+    more: z.boolean().describe("Whether older messages precede this page."),
+    // The cursor a reader keeps between reads: `through` (with the id of the row just before it) is the `after` of its
+    // next read, which then carries only what the record gained since.
+    through: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe(
+            "The position just past this page's last message: pass it back as `after`, with that message's `rowId` as `afterRow`, to read only what the record gains from here on. Absent from a sandbox older than reading forward.",
+        ),
+    continuous: z
+        .boolean()
+        .optional()
+        .describe(
+            "Answered to a read with `after`: true when these messages carry on exactly from there, to be added to what the reader holds; false when the record no longer runs through that point (a rewind since, or more written than one page carries), so this is its latest page instead, to replace what the reader holds.",
+        ),
+    live: z
+        .string()
+        .optional()
+        .describe(
+            "The run going on in this conversation right now, which the record does not hold yet: attach to it for its rows as they are drawn. Absent when nothing runs.",
+        ),
+});

package/src/events/agent-words.ts

@@ -48,8 +48,20 @@ export interface ChildReportFields {
     // Where its work went, in the daemon's words: into the parent's own checkout, or held off it by a clash. Undefined
     // for a child whose work lands as any conversation's does.
     readonly landing?: string | undefined;
+    // For a child spawned with a result schema: the value it handed back, written out as JSON, or why it handed none.
+    readonly result?: { readonly json: string } | { readonly missing: string } | undefined;
 }
 
+// The result a child spawned with a schema handed back, in words; nothing for a child spawned without one.
+const resultLines = (result: ChildReportFields["result"]): readonly string[] => {
+    if (result === undefined) {
+        return [];
+    }
+    return "json" in result
+        ? ["", "Result (it matches the schema you gave it):", "```json", result.json, "```"]
+        : ["", `Result: none. ${result.missing} Ask it for one with send.`];
+};
+
 // The wait tool's `verification` field, in words.
 const verificationLine = (verification: SubagentVerification | undefined): string | undefined => {
     if (verification === undefined) {
@@ -76,6 +88,7 @@ export const childReportPrompt = (fields: ChildReportFields): string => {
         ...(verification === undefined ? [] : [verification]),
         "",
         fields.report.trim() === "" ? "(It ended without a closing report.)" : fields.report.trim(),
+        ...resultLines(fields.result),
         "",
         `${fields.landing ?? "Its changes are in its own worktree and land the way any agent's do."} Its account of its own work is a claim, not ` +
             "a result: check what matters before you build on it, and follow up with the subagents tools as you would mid-turn.",

package/src/events/requests.ts

@@ -371,8 +371,10 @@ export const CredentialReceiptSchema = z.object({
 });
 export type CredentialReceipt = z.infer<typeof CredentialReceiptSchema>;
 
-// The three requests a turn journal can restore verbatim after a daemon restart. `browser_help`/`terminal_help` are
-// excluded: their Chromium/waiting command dies with the container, so those can only be reported, not restored.
+// The requests a turn journal can restore verbatim after a daemon restart, raised by the turn itself or by a gate it
+// called. `browser_help`/`terminal_help` are excluded: their Chromium/waiting command dies with the container, so those
+// can only be reported, not restored. A gate's offer comes back as a card whose answer is told to a turn of its own,
+// since the call that raised it died with the daemon: a yes is the agent's to act on by asking again.
 export const PlanRequestSchema = z.object({
     kind: z.literal("plan").describe("The agent has written a plan and is waiting for a yes."),
     ...planRequest,
@@ -385,5 +387,41 @@ export const PermissionRequestSchema = PermissionAskSchema.extend({
     kind: z.literal("permission").describe("The agent wants to use a tool it needs permission for."),
     ...permissionRequest,
 });
-export const ParkedRequestSchema = z.discriminatedUnion("kind", [PlanRequestSchema, QuestionRequestSchema, PermissionRequestSchema]);
+export const PageAskRequestSchema = z.object({
+    kind: z.literal("page_ask").describe("The agent has shown a page to be answered on and is waiting."),
+    ...pageAskRequest,
+});
+export const CapabilityOfferRequestSchema = z.object({
+    kind: z.literal("capability_offer").describe("The agent asks for something to be connected."),
+    ...capabilityOfferRequest,
+});
+export const PaymentOfferRequestSchema = z.object({
+    kind: z.literal("payment_offer").describe("The agent asks to pay for something."),
+    ...paymentOfferRequest,
+});
+export const CredentialOfferRequestSchema = z.object({
+    kind: z.literal("credential_offer").describe("The agent asks a named person to release a credential."),
+    ...credentialOfferRequest,
+});
+export const ParkedRequestSchema = z.discriminatedUnion("kind", [
+    PlanRequestSchema,
+    QuestionRequestSchema,
+    PermissionRequestSchema,
+    PageAskRequestSchema,
+    CapabilityOfferRequestSchema,
+    PaymentOfferRequestSchema,
+    CredentialOfferRequestSchema,
+]);
+// Whether a frame is a card the journal keeps for a restart to put back; a record, so a kind added above fails to compile
+// until it is named here.
+const RESTORABLE = {
+    plan: true,
+    question: true,
+    permission: true,
+    page_ask: true,
+    capability_offer: true,
+    payment_offer: true,
+    credential_offer: true,
+} as const satisfies Record<ParkedRequest["kind"], true>;
+export const isRestorableRequest = (event: { readonly kind: string }): event is ParkedRequest => Object.hasOwn(RESTORABLE, event.kind);
 export type ParkedRequest = z.infer<typeof ParkedRequestSchema>;

package/src/events/sandbox-notice.ts

@@ -63,6 +63,9 @@ export const SandboxNoticeSchema = z.discriminatedUnion("code", [
     z.object({ code: z.literal("renewalWithdrawn"), params: z.object(failure) }),
     z.object({ code: z.literal("reconnect"), params: z.object(failure) }),
     z.object({ code: z.literal("undelivered"), params: z.object({ ...failure, unattended: z.boolean().optional() }) }),
+    // A door refusal that came after the turn had already run (a trial spent mid-turn): what it did stays, nothing is
+    // held, and `switchModel` when another model gets past the refusal.
+    z.object({ code: z.literal("stoppedPartway"), params: z.object({ ...failure, switchModel: z.boolean().optional() }) }),
     // A turn the sandbox kept whole, its message above; `memory` when a memory hold kept it.
     z.object({ code: z.literal("kept"), params: z.object({ ...failure, memory: z.boolean().optional() }) }),
     z.object({ code: z.literal("memoryHeld"), params: z.object(failure) }),

package/src/events/transcript.ts

@@ -1,8 +1,7 @@
 import { z } from "zod";
-import { AgentHarnessSchema, AgentProviderSchema } from "../schemas/agent.js";
 import { ShareDetailSchema } from "../schemas/share.js";
 import { TurnErrandSchema, TurnSpeakerSchema } from "../schemas/speaker.js";
-import { SubagentKindSchema, SubagentStatusSchema, SubagentVerificationSchema } from "../schemas/terminal.js";
+import { SubagentKindSchema, SubagentSdkRecordSchema, SubagentStatusSchema, SubagentVerificationSchema } from "../schemas/terminal.js";
 import { NeedSchema } from "../schemas/needs.js";
 import { HeldEndingSchema, RetryLadderSchema } from "../schemas/turn-break.js";
 import { HandoffOfferSchema } from "../schemas/providers/handoff.js";
@@ -172,6 +171,9 @@ export const TranscriptSubagentSchema = z.object({
     summary: z.string().optional(),
     error: z.string().optional(),
     verification: SubagentVerificationSchema.optional(),
+    sdk: SubagentSdkRecordSchema.optional().describe(
+        "Where the Claude runtime keeps this in-process subagent's own record, so its whole run reads back once nothing in memory remembers it. Absent for every other kind, and until the daemon has paired it.",
+    ),
 });
 export type TranscriptSubagent = z.infer<typeof TranscriptSubagentSchema>;
 // Mutable, unlike most of this file: the fold settles a card in place when its result lands turns later, saving a
@@ -269,6 +271,15 @@ export const TranscriptRowSchema = z.object({
             "Who said it. A notice is neither side: it is something that happened to the turn, recorded so a reopened conversation can say it. Without those, a turn a provider refused ends on the user's message and reads as broken.",
         ),
     text: z.string().describe("The words."),
+    // The row's own name, minted once where the row is made (the live fold, or the record for a row written outside a
+    // run) and carried on every copy: the live head's, each patch's, the record's, a client's mirror. Positions move
+    // under a rewind and contents grow while a run streams, so this is how a reader says "this row" across all of them.
+    rowId: z
+        .string()
+        .optional()
+        .describe(
+            "The row's own id: the same on the live turn's copy, every change to it, the record, and a reader's own copy, so a reader updates the row it already holds instead of matching it by content. Rows recorded before rows had ids are named by their position (`@12`). Absent from a sandbox older than ids.",
+        ),
     // Which run produced this row, carried on every copy of it: the live head's, the record's, a client's mirror.
     // It is how a client says "I am already showing this run" without comparing content, which cannot answer that
     // while the run's last row is still growing.
@@ -339,9 +350,10 @@ export const TranscriptRowSchema = z.object({
         ),
     // The follow-up this notice offers, by name; the chat decides what it does, and whether it stands. `sendAnyway` sends
     // the held message; `sandboxMemory` offers that and a raise of the sandbox's memory; `sendAgain` sends a turn the
-    // sandbox kept after a refusal no raise would clear.
+    // sandbox kept after a refusal no raise would clear; `switchModel` opens the model list for a turn a model's refusal
+    // stopped partway, so the same conversation carries on with another.
     noticeAction: z
-        .enum(["landHold", "depsInstall", "watchStop", "sandboxMemory", "sendAnyway", "sendAgain"])
+        .enum(["landHold", "depsInstall", "watchStop", "sandboxMemory", "sendAnyway", "sendAgain", "switchModel"])
         .optional()
         .describe("A one-press follow-up this notice offers, by name. The chat decides what it does and whether it still applies."),
     // Where a refused turn's words wait decides what the notice's press does: the conversation's queue, or the sandbox.
@@ -416,33 +428,45 @@ export const holdsRequest = (row: TranscriptRequests): boolean => REQUEST_FIELDS
 // Whether a row is holding the turn open on a card nobody has answered.
 export const isAwaitingDecision = (row: TranscriptRequests): boolean => REQUEST_FIELDS.some((field) => row[field]?.status === "pending");
 
+// The row a patch changes, by its own id, beside the index older readers count from.
+const patchRowId = z
+    .string()
+    .optional()
+    .describe("The id of the row this changes. A reader holding a row by that id changes it there, wherever it sits; `index` is for one that does not.");
+
 // One change to a run's rows, so a client keeps rows rather than frames. Prose/thinking append to a row or a card; a
 // `tool` card replaces its own fields by id, never its nested calls or thinking, which arrive by their own patches;
-// everything else replaces its row; `drop` removes a row that opened and never wrote.
+// everything else replaces its row; `drop` removes a row that opened and never wrote. Each names its row twice: by
+// `index` from where the run's rows start, and by `rowId`, which needs no counting and survives a row dropped above it.
 export const TranscriptPatchSchema = z.discriminatedUnion("op", [
     z.object({ op: z.literal("append").describe("A new row at the end."), row: TranscriptRowSchema }),
     z.object({
         op: z.literal("replace").describe("This row, whole, in place of the one at that index."),
         index: z.number().int().nonnegative(),
+        rowId: patchRowId,
         row: TranscriptRowSchema,
     }),
     z.object({
         op: z.literal("drop").describe("The row at that index is gone: it was opened and never written into."),
         index: z.number().int().nonnegative(),
+        rowId: patchRowId,
     }),
     z.object({
         op: z.literal("text").describe("More of the agent's prose, onto that row's text."),
         index: z.number().int().nonnegative(),
+        rowId: patchRowId,
         text: z.string(),
     }),
     z.object({
         op: z.literal("thinking").describe("More of the agent's reasoning, onto that row's thinking."),
         index: z.number().int().nonnegative(),
+        rowId: patchRowId,
         text: z.string(),
     }),
     z.object({
         op: z.literal("toolThinking").describe("More of a delegated subagent's reasoning, onto the thinking of the card that started it."),
         index: z.number().int().nonnegative(),
+        rowId: patchRowId,
         id: z.string().describe("The card's id, matched wherever it nests."),
         text: z.string(),
     }),
@@ -453,6 +477,7 @@ export const TranscriptPatchSchema = z.discriminatedUnion("op", [
                 "A tool card's own fields: new, or the latest state of one already there, matched by id wherever it nests. Carries no `children` or `thinking`; a card already there keeps its own.",
             ),
         index: z.number().int().nonnegative(),
+        rowId: patchRowId,
         tool: TranscriptToolSchema,
         parent: z.string().optional().describe("The card this one nests under, when it is a delegated subagent's own call."),
     }),
@@ -527,29 +552,6 @@ export const TurnEndingSchema = z.object({
 });
 export type TurnEnding = z.infer<typeof TurnEndingSchema>;
 
-// The record a reopened tab rebuilds from: messages plus what the session is bound to (provider, runtime, account). A
-// client can't derive these: after a mid-chat switch, its own picks belong to a different session.
-export const AgentTranscriptSchema = SessionTranscriptSchema.extend({
-    sessionId: z.string().optional().describe("The provider session behind the last turn, when there is one."),
-    provider: AgentProviderSchema.optional().describe("Which provider minted that session."),
-    harness: AgentHarnessSchema.optional().describe("Which runtime minted it: a session resumes only on the loop that opened it."),
-    account: z
-        .string()
-        .optional()
-        .describe("Which stored account it belongs to, as the daemon resolved it. Absent when no stored account paid for the turn."),
-    // How the last turn ended, for endings that leave a live session with just a press to offer; absent otherwise.
-    ending: TurnEndingSchema.optional().describe(
-        "How the last turn ended, when it left work behind that one press finishes. Absent for a conversation whose last turn ended on its own, and for the failures that name something to repair first.",
-    ),
-    // `from` offsets every `rewindIndex` here, and is the `before` for the page above; `more` flags older messages.
-    from: z
-        .number()
-        .int()
-        .nonnegative()
-        .describe("Where the first message sits in the whole record, and the `before` that asks for the page above this one."),
-    more: z.boolean().describe("Whether older messages precede this page."),
-});
-
 // A delegation's own run, fetched when its card opens; empty when the record no longer holds it.
 export const AgentToolChildrenSchema = z.object({
     children: z.array(TranscriptToolSchema).describe("The calls the delegated agent made, in the order it made them."),

package/src/events/undelivered.ts

@@ -6,6 +6,24 @@ import type { TranscriptRow } from "./transcript.js";
 // automation, a loop, a watch wake) has no typed message and nobody watching, so promising a resend there names a
 // composer the reader is not looking at. Neither version promises a retry: whether one comes is the scheduler's
 // decision, not this row's to state. The code carries the same fact, so the editor's localized line agrees.
+// The row the same refusal leaves once the turn had already run: a trial spent, or a model refused, on a later step. The
+// message was read and acted on, so it is neither undelivered nor held (turn-runs keeps only a turn turned away at the
+// door), and saying so invited a resend of something that had already changed files (onboarding review 2026-10-18,
+// F07). What it did stays in the conversation's copy; the press, when another model gets past the refusal, carries on there.
+export const stoppedPartwayRow = (said: { readonly message: string; readonly error?: string }, switchModel: boolean): TranscriptRow => {
+    const row: TranscriptRow = {
+        role: "notice",
+        text: switchModel
+            ? `${said.message} The run stopped partway. The changes it made so far are kept: continue with another model to pick up from here.`
+            : `${said.message} The run stopped partway. The changes it made so far are kept: send a message to pick up from here.`,
+        noticeCode: noticeCode({ code: "stoppedPartway", params: { ...said, switchModel: switchModel || undefined } }),
+    };
+    if (switchModel) {
+        row.noticeAction = "switchModel";
+    }
+    return row;
+};
+
 export const undeliveredRow = (said: { readonly message: string; readonly error?: string }, unattended: boolean): TranscriptRow => ({
     role: "notice",
     text: unattended

package/src/ids/conversation-ids.ts

@@ -8,6 +8,13 @@ export const CONVERSATION_ID = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
 // Safe to interpolate into a path or a branch name. `false` for anything else, including the empty string.
 export const isConversationId = (value: string): boolean => CONVERSATION_ID.test(value);
 
+// The longest title a conversation opens with (AgentTurn.title). A title made by joining words (a fresh session's
+// "Code review: " and its origin's whole title) runs past it easily, and a turn naming one is refused outright, so a
+// sender clips it first rather than lose the turn to its name.
+export const CONVERSATION_TITLE_MAX = 80;
+export const clipTitle = (title: string): string =>
+    title.length <= CONVERSATION_TITLE_MAX ? title : `${title.slice(0, CONVERSATION_TITLE_MAX - 1).trimEnd()}…`;
+
 // Short (nothing over seven letters) and visually distinct: no near-rhymes, no shared first syllable.
 const ADJECTIVES = [
     "amber",

package/src/ids/row-ids.ts

@@ -0,0 +1,20 @@
+// A transcript row's own name (TranscriptRow.rowId). Minted once, where the row is made: the live fold for a run's rows,
+// the record for a row written outside a run. Random rather than counted, since two makers (a run and a placed line) can
+// write into one conversation without asking each other, and nothing reads order out of it: position is the record's.
+
+const ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+// Twelve characters of base 36, about 62 bits: unique within any conversation by a wide margin, and short, since every
+// row of every record carries one.
+const LENGTH = 12;
+
+export const newRowId = (): string => {
+    let id = "";
+    for (const byte of globalThis.crypto.getRandomValues(new Uint8Array(LENGTH))) {
+        id += ALPHABET[byte % ALPHABET.length];
+    }
+    return id;
+};
+
+// The name of a row recorded before rows had ids: its position, which never moves for a row that stays (a rewind only
+// drops rows after the point it keeps, and what is written after gets minted ids). The `@` keeps it apart from a minted id.
+export const positionRowId = (position: number): string => `@${position}`;

package/src/models/agent-lanes.ts

@@ -23,11 +23,15 @@ import {
 // reader's once it no longer does: nothing running there to hear it and nothing armed to wake it, which is a parent out
 // of Active. That holds only until the parent moves past it (heardByParent). After that the stop is the family's
 // history, drawn in the tray, and no longer something the reader owes a press. The sandbox draws the same line for a
-// child's land news (subagents/child-lands.ts): the parent's while it has a live turn, the owner's after.
+// child's land news (subagents/child-lands.ts): the parent's while it has a live turn, the owner's after. A fresh
+// session is the exception: its parent never supervises it (nothing it does is reported there), so whatever it stops on
+// is the reader's from the start, through its parent's card, however busy the parent is.
 export const callsOwner = (
     child: AgentStanding & { readonly updatedAt: number },
     family: { readonly child: FleetLane; readonly parent: FleetLane; readonly parentAt: number },
-): boolean => onlyOwnerCanAnswer(child) || (family.child === "attention" && family.parent !== "active" && !heardByParent(child, family.parentAt));
+): boolean =>
+    onlyOwnerCanAnswer(child) ||
+    (family.child === "attention" && (family.parent !== "active" || child.fresh !== undefined) && !heardByParent(child, family.parentAt));
 
 export type FleetLane = "attention" | "active" | "finished";
 
@@ -127,7 +131,9 @@ export const attentionCalls = (agents: readonly CallerStanding[]): readonly { re
     const calls: { readonly id: string; readonly card: string }[] = [];
     for (const agent of agents) {
         const parent = parentIn(agent);
-        if (parent === undefined || agent.unsent === true) {
+        // Words left in a child's composer give it a card of its own (childFold.standsAlone), except a fresh session's:
+        // its composer is the person's anyway, and it rides its origin's card whatever it holds.
+        if (parent === undefined || (agent.unsent === true && agent.fresh === undefined)) {
             if (laneOf(agent) === "attention") {
                 calls.push({ id: agent.id, card: agent.id });
             }

package/src/models/agent-standing.ts

@@ -55,6 +55,8 @@ export interface AgentStanding {
     readonly limitScheduled?: boolean | undefined;
     /** The account the owner's policy is moving the held turn to, while that move is booked (a scheduled card's sentence). */
     readonly limitMoving?: string | undefined;
+    /** When the booked re-run goes, in epoch SECONDS, while one is booked (limitScheduled): the pass's own instant. */
+    readonly limitNextAt?: number | undefined;
     // A land that broke (AgentSummary.landFailure), standing until one goes through whatever turns run after it. Absent
     // from a sandbox older than it, where only a turn's own `failure` can say so.
     readonly landFailure?: LandFailure | undefined;
@@ -62,6 +64,10 @@ export interface AgentStanding {
     // themselves at a time or once another agent's work lands (`scheduled`), which make the conversation one that runs
     // again by itself. Never the words.
     readonly queue?: QueueHold | undefined;
+    // The conversation whose work this one was opened on, for a fresh session (AgentSummary.fresh): a person's own
+    // review, test or ask, which hangs under that conversation's card and is never reported to it
+    // (subagents/child-report.ts), so nothing it stops on is that conversation's news. Absent for every other one.
+    readonly fresh?: { readonly of: string } | undefined;
 }
 
 // The part of a conversation's queue the board reads: why it holds, and what a scheduled hold waits for. A queue-level
@@ -282,9 +288,11 @@ export const onlyOwnerCanAnswer = (agent: AgentStanding): boolean =>
 // an orchestrator that worked around three spent allowances and landed is done, not stuck. Only a turn's ending
 // counts. A question is still parked and waits for an answer whoever has moved since, and a land refused or broken
 // leaves work stuck on the child's branch that no report settles. A turn a person ran in the child's own chat is never
-// reported to the parent, and it ends after the parent's last move, so it still reads as unheard here.
+// reported to the parent, and it ends after the parent's last move, so it still reads as unheard here. Nor is anything a
+// fresh session does, whenever its origin moved: it is the person's, so its stops are never the origin's to have heard.
 // `updatedAt` is the clock on both sides: a rename keeps it (agents-registry), and reading does not move it.
 export const heardByParent = (child: AgentStanding & { readonly updatedAt: number }, parentAt: number): boolean =>
+    child.fresh === undefined &&
     BLOCKING_ENDINGS.has(child.status) &&
     // Still unwinding: its ending has not reached anyone yet.
     child.status !== "stopping" &&