@intentic/sandbox-contract 1.340.0 → 1.342.0

package/src/contracts/agent.contract.ts

@@ -18,6 +18,7 @@ import {
     ProviderRefusalsSchema,
     QueuedMessageRefSchema,
     QueueEditSchema,
+    QueueContinueSchema,
     QueueResumeSchema,
     QueueScheduleSchema,
     ResumeTurnSchema,
@@ -138,6 +139,18 @@ export const agentContract = {
         .meta({ floor: "collaborator", guest: true })
         .input(QueueScheduleSchema)
         .output(ConversationQueueSchema),
+    // NOT_FOUND for a conversation the sandbox does not have; BAD_REQUEST when the conversation named to wait for cannot land.
+    queueContinue: procedure
+        .route({
+            method: "POST",
+            path: "/agent/queue/continue",
+            summary: "Book a Continue for later",
+            description:
+                "Books the conversation to carry on from where its last turn stopped at an instant, or once another conversation has finished and its work has landed: a Continue that waits in the queue, drawn as scheduled, rather than words. Nothing is added to the conversation as your message. When it goes, a turn the sandbox still holds runs again as it was; otherwise the agent is told to continue in its own session. A turn that starts in the conversation before then makes it moot, and it is dropped. Take it back with queueRemove, send it sooner with queueResume, re-time it with queueSchedule.",
+        })
+        .meta({ floor: "collaborator", guest: true })
+        .input(QueueContinueSchema)
+        .output(ConversationQueueSchema),
     // CONFLICT while a turn already runs (the client follows it); NOT_FOUND when nothing is held (it falls back to `run`).
     resume: procedure
         .route({

package/src/contracts/git.contract.ts

@@ -45,6 +45,7 @@ import {
     StashPushSchema,
     StashRefParamSchema,
 } from "../schemas/git/git-history.js";
+import { IndexRunSchema, IndexRunStartSchema } from "../schemas/git/index-run.js";
 import { FileDiffSchema } from "../schemas/history.js";
 import { OkSchema, RepoParamSchema } from "../schemas/shared.js";
 
@@ -465,6 +466,38 @@ export const gitContract = {
         })
         .input(RepoParamSchema)
         .output(OkSchema),
+    // Stage-all and commit-all as runs (index-run.ts): a stage over tens of thousands of files outlives the browser's
+    // header deadline, so it starts, answers at once and is polled, like a push.
+    indexRunStart: procedure
+        .route({
+            method: "POST",
+            path: "/git/{repo}/index-run",
+            summary: "Start staging or committing",
+            description:
+                "Starts a stage or a commit and answers at once with the run; poll indexRunState for its progress and verdict. One per repository: starting the same thing again while it runs joins it, and starting something different is refused until it settles. A stage that would take thousands of files or hundreds of megabytes stops before touching the index and says what it found, unless `confirmed` is set.",
+        })
+        .input(IndexRunStartSchema)
+        .output(IndexRunSchema),
+    indexRunState: procedure
+        .route({
+            method: "GET",
+            path: "/git/{repo}/index-run",
+            summary: "How the stage or commit is going",
+            description:
+                "The repository's latest stage or commit run: its phase and file counts while it runs, then its verdict, the commit's answer, or what held it at the guardrail. Idle when none has been started since the sandbox last started.",
+        })
+        .input(RepoParamSchema)
+        .output(IndexRunSchema),
+    indexRunCancel: procedure
+        .route({
+            method: "POST",
+            path: "/git/{repo}/index-run/cancel",
+            summary: "Stop the stage or commit",
+            description:
+                "Kills the git the run is waiting on. It settles as cancelled; a stage stopped part way leaves the index as git last wrote it, which unstaging takes back, and a commit stopped before git recorded it records nothing.",
+        })
+        .input(RepoParamSchema)
+        .output(OkSchema),
     files: procedure
         .route({
             method: "GET",

package/src/contracts/workspace.contract.ts

@@ -35,6 +35,8 @@ import {
     WorkspaceMediaTicketQuerySchema,
     WorkspaceMediaTicketSchema,
     WorkspaceDownloadTicketQuerySchema,
+    WorkspacePreviewTicketQuerySchema,
+    WorkspacePreviewTicketSchema,
     WorkspaceDownloadTicketSchema,
     WorkspaceMoveSchema,
     WorkspaceResolveQuerySchema,
@@ -134,6 +136,19 @@ export const workspaceContract = {
         .meta({ floor: "viewer", guest: true })
         .input(WorkspaceDownloadTicketQuerySchema)
         .output(WorkspaceDownloadTicketSchema),
+    // Mints the ticket GET /workspace/preview/{ticket}/* (a plain Hono route serving a page and its files) requires.
+    previewTicket: procedure
+        .route({
+            method: "POST",
+            path: "/workspace/preview-ticket",
+            summary: "Get an address to preview a web page at",
+            description:
+                "Mints a short-lived address a frame loads a workspace web page from, so the page runs as it would on a static file server: its scripts, modules, fetches and links resolve against real addresses beside it. The address serves the files of the page's own repository, never hidden files or the sandbox's own state, and the page runs sandboxed, with no access to the editor or this API.",
+        })
+        // Previewing a page is reading it and the files beside it, and the ticket is narrower than the bearer.
+        .meta({ floor: "viewer", guest: true })
+        .input(WorkspacePreviewTicketQuerySchema)
+        .output(WorkspacePreviewTicketSchema),
     // Matches a prose-written path, often just a suffix, against the tree rather than trusting it as root-relative.
     resolve: procedure
         .route({

package/src/events/agent-events.ts

@@ -13,6 +13,7 @@ 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";
 import { TranscriptPatchSchema, TranscriptRowSchema, TurnNoteSchema } from "./transcript.js";
+import { ReviewFindingsSchema } from "./review.js";
 import { agentNoticeEvent, agentStatusEvent } from "./agent-ui.js";
 
 // Every frame an agent turn streams, as one `kind`-discriminated union: turn facts (session, standing, cost) and the
@@ -239,6 +240,9 @@ export const AgentEventSchema = z.discriminatedUnion("kind", [
     // A page the agent showed (its `show_page` tool): drawn inline where the turn stands, in a sealed frame. Parks
     // nothing. A page whose id an earlier one already holds is a redraw, and the earlier row folds to a line.
     z.object({ kind: z.literal("page"), page: PageSchema }),
+    // A code review's findings (events/review.ts), drawn inline as one card. A review whose id an earlier one holds is
+    // its re-report, its fixes applied, and the earlier card folds to a line, as a page's redraw does.
+    z.object({ kind: z.literal("review"), review: ReviewFindingsSchema }),
     // A page the agent showed to be answered (`ask_page`): parks the turn until the page sends its answer back, or the
     // person dismisses it. Not journalled for restore: the tool call waiting on it dies with the daemon.
     z.object({ kind: z.literal("page_ask"), ...pageAskRequest }),
@@ -279,6 +283,9 @@ export const AgentEventSchema = z.discriminatedUnion("kind", [
                 "claude-token-refused",
                 // The account authenticates and has real usage pools, but the org disabled Claude Code for this seat.
                 "claude-not-entitled",
+                // Any other provider's account signs in but is refused service outright, for every model (Cursor's
+                // `[role_forbidden]` for a non-billable admin): filed against the account, so placement skips it.
+                "account-not-entitled",
                 // The provider failed transiently and in-turn retries did not outlast it; the daemon retries on
                 // backoff.
                 "provider-outage",

package/src/events/agent-words.test.ts

@@ -21,6 +21,12 @@ describe("another agent's words", () => {
         expect(agentWordsOf(prompt)).toEqual({ kind: "peer", from: "sharp-shale-htw8", title: "Bun migration", sent: prompt });
     });
 
+    // 2026-10-17: a child its parent cancelled was reported to it as finished.
+    it("says a stopped child was stopped, and still reads it back as a child's report", () => {
+        expect(report({ stopped: true }).split("\n", 1)[0]).toMatch(/ was stopped\.$/u);
+        expect(agentWordsOf(report({ stopped: true }))).toMatchObject({ kind: "child" });
+    });
+
     it("round-trips a child's report, finished or failed", () => {
         expect(agentWordsOf(report())).toMatchObject({ kind: "child", from: "sub-x7", title: "Port the parser" });
         expect(agentWordsOf(report()) ?? {}).not.toHaveProperty("failed");

package/src/events/agent-words.ts

@@ -40,6 +40,8 @@ export interface ChildReportFields {
     readonly child: string;
     readonly title: string | undefined;
     readonly failed: boolean;
+    // Stopped by a person or its parent rather than ending by itself: said as such, never as finished.
+    readonly stopped?: boolean | undefined;
     readonly report: string;
     // Undefined when nothing of the child's work was seen, which is not a verdict.
     readonly verification: SubagentVerification | undefined;
@@ -70,7 +72,7 @@ const verificationLine = (verification: SubagentVerification | undefined): strin
 export const childReportPrompt = (fields: ChildReportFields): string => {
     const verification = verificationLine(fields.verification);
     return [
-        `${CHILD_OPENING}${senderOf(fields.child, fields.title)} ${fields.failed ? "failed" : "finished"}.`,
+        `${CHILD_OPENING}${senderOf(fields.child, fields.title)} ${fields.failed ? "failed" : fields.stopped === true ? "was stopped" : "finished"}.`,
         ...(verification === undefined ? [] : [verification]),
         "",
         fields.report.trim() === "" ? "(It ended without a closing report.)" : fields.report.trim(),
@@ -81,7 +83,7 @@ export const childReportPrompt = (fields: ChildReportFields): string => {
 };
 
 const PEER_LINE = /^Message from another conversation in this workspace: `([^`]+)`(?: \("(.*)"\))?\.$/u;
-const CHILD_LINE = /^Report from a (?:subagent|child agent) you started: `([^`]+)`(?: \("(.*)"\))? (finished|failed)\.$/u;
+const CHILD_LINE = /^Report from a (?:subagent|child agent) you started: `([^`]+)`(?: \("(.*)"\))? (finished|failed|was stopped)\.$/u;
 
 const peerOf = (first: string, prompt: string): TranscriptAgentWords | undefined => {
     const match = first.startsWith(PEER_OPENING) ? PEER_LINE.exec(first) : null;

package/src/events/review.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+
+// A code review's findings in one shape, whichever harness ran the review: Claude Code's `/code-review` reports them
+// through its ReportFindings tool, Codex's `review/start` ends on a review item whose comments are read into the same
+// rows. The chat draws one card per review (row.review), the same card for either; what the reviewer said around its
+// findings is prose on the bubble, never repeated on the card.
+
+// How hard Claude Code's review looked: from a few high-confidence findings (low) to every one it could verify (max).
+export const REVIEW_LEVELS = ["low", "medium", "high", "xhigh", "max"] as const;
+export const ReviewLevelSchema = z.enum(REVIEW_LEVELS);
+export type ReviewLevel = z.infer<typeof ReviewLevelSchema>;
+
+export const ReviewFindingSchema = z.object({
+    file: z.string().describe("The file the finding is in, as the reviewer named it: relative to the checkout, or absolute."),
+    line: z.number().int().positive().optional().describe("The 1-based line it anchors to."),
+    endLine: z.number().int().positive().optional().describe("The last line of the range it covers, where the reviewer named a range."),
+    summary: z.string().describe("The defect in one sentence."),
+    title: z.string().optional().describe("The finding as a short label, for a row that has no room for the sentence."),
+    scenario: z.string().optional().describe("The concrete inputs or state that lead to the wrong output or the crash."),
+    body: z.string().optional().describe("The reviewer's own explanation of the finding, where it wrote one beyond the summary."),
+    category: z.string().optional().describe("What kind of finding it is: correctness, simplification, efficiency, and so on."),
+    verdict: z.enum(["CONFIRMED", "PLAUSIBLE"]).optional().describe("Whether a verification pass reproduced it, or only found it believable."),
+    priority: z.number().int().min(0).max(3).optional().describe("How urgent the reviewer rated it: 0 is the most urgent, as Codex's P0 to P3."),
+    outcome: z
+        .enum(["fixed", "skipped", "no_change_needed"])
+        .optional()
+        .describe("What happened to it, on a review re-reported after its fixes were applied."),
+});
+export type ReviewFinding = z.infer<typeof ReviewFindingSchema>;
+
+export const ReviewFindingsSchema = z.object({
+    id: z.string().min(1).describe("The review's own id: a re-report of the same review (its fixes applied) carries it again and redraws the card."),
+    source: z.enum(["claude", "codex"]).describe("Which harness's reviewer reported it."),
+    level: ReviewLevelSchema.optional().describe("The effort the review ran at, where the reviewer has levels."),
+    findings: z.array(ReviewFindingSchema).describe("What it found, most severe first. Empty when nothing survived."),
+    superseded: z.boolean().optional().describe("A later report of this review stands further down the conversation, so this one is drawn folded."),
+});
+export type ReviewFindings = z.infer<typeof ReviewFindingsSchema>;
+
+// Each reviewer's own cap: ReportFindings takes 32; a Codex review's comments are not capped, so a card says how many
+// were left off rather than drawing a hundred rows.
+export const REVIEW_FINDINGS_MAX = 50;
+// Prose a finding carries is the model's, and unbounded: kept to what a card can draw.
+export const REVIEW_TEXT_MAX = 2000;

package/src/events/system-events.ts

@@ -58,6 +58,12 @@ export const HelloSchema = z.object({
     // `rawFingerprints` is what `shapes` is for a procedure, under the name the rest of the code gives it.
     rawRoutes: z.array(z.string()).optional(),
     rawFingerprints: z.record(z.string(), z.string()).optional(),
+    // The codings `POST /workspace/upload` and `POST /workspace/upload-archive` decode a request body from
+    // (`Content-Encoding`). Absent means a daemon that writes whatever bytes arrive, so the browser sends them plain.
+    uploadEncodings: z.array(z.string()).optional(),
+    // The codings the voice sockets speak besides PCM when asked (`codec=opus`, schemas/voice.ts). Absent or empty: PCM
+    // only, which is every daemon from before the field and one whose Opus binding did not load.
+    voiceCodecs: z.array(z.string()).optional(),
     // `<version>:<newest mtime of the compiled tree>`, as every release since 1.0.0 sends it. The version at its head
     // is what the browser holds against the oldest daemon it supports (state/daemon-floor.ts), so it stays first.
     build: z.string().optional(),

package/src/events/transcript.ts

@@ -8,6 +8,7 @@ import { HeldEndingSchema, RetryLadderSchema } from "../schemas/turn-break.js";
 import { HandoffOfferSchema } from "../schemas/providers/handoff.js";
 import { NoticeCodeSchema } from "./sandbox-notice.js";
 import { TranscriptAgentNoticeSchema } from "./agent-ui.js";
+import { ReviewFindingsSchema } from "./review.js";
 import type { ToolCallContent, ToolCallLocation, ToolCallStatus, ToolKind } from "./requests.js";
 import {
     browserHelpRequest,
@@ -387,6 +388,8 @@ export const TranscriptRowSchema = z.object({
     backgroundJob: TranscriptBackgroundJobSchema.optional().describe("The background job this row marks the start of."),
     // Not a card: a page parks nothing, it is part of what the agent said. On the bubble whose tool call showed it.
     page: PageSchema.optional().describe("A page the agent showed here, drawn inline."),
+    // Not a card either: a review's findings are what the agent said, drawn as one block on the bubble that reported them.
+    review: ReviewFindingsSchema.optional().describe("A code review's findings the agent reported here, drawn inline."),
     pageAsk: TranscriptPageAskSchema.optional().describe("A page the agent asked to be answered on, and what it sent back."),
     credentialOffer: TranscriptCredentialOfferSchema.optional().describe(
         "The gated credential this row asked to use, who may release it, and who did.",

package/src/events/undelivered.ts

@@ -0,0 +1,15 @@
+import { noticeCode } from "./sandbox-notice.js";
+import type { TranscriptRow } from "./transcript.js";
+
+// The row a refusal that ran nothing leaves when the conversation's queue holds the words (transcript-fold's heldRow).
+// A turn somebody typed is held in its conversation's queue for another press; a turn that started itself (an
+// 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.
+export const undeliveredRow = (said: { readonly message: string; readonly error?: string }, unattended: boolean): TranscriptRow => ({
+    role: "notice",
+    text: unattended
+        ? `${said.message} Nothing ran, and nothing is held: this run started on its own, so there is no message waiting to be sent again.`
+        : `${said.message} Your message was not delivered: it is held for you to send again.`,
+    noticeCode: noticeCode({ code: "undelivered", params: { ...said, unattended: unattended || undefined } }),
+});

package/src/models/agent-standing.ts

@@ -111,7 +111,8 @@ export const limited = (agent: AgentStanding): boolean => agent.status === "erro
 
 // A message held at the door because the sandbox is short of memory (turn-admission): nothing ran and nothing failed,
 // it waits for a person's "send anyway". The daemon files it as an `error`, so this is read off the code, as `limited`
-// is, and the chip and glyph say held rather than error; the lane stays Attention, since the press is the reader's.
+// is, and the chip and glyph say held rather than error; the lane stays Attention, since the press is the reader's,
+// until its words are booked for later (bookingAnswers).
 export const memoryHeld = (agent: Pick<AgentStanding, "status" | "failureCode">): boolean =>
     agent.status === "error" && agent.failureCode === "sandbox-memory-low";
 
@@ -218,13 +219,29 @@ export const writingNow = (agent: AgentStanding): boolean => agent.status === "r
 // `stopped`/`interrupted` leave a half-written worktree only a new message can carry forward; `stopping` is
 // counted the moment the press lands rather than once the unwind finishes, since it settles in the same lane
 // either way; `failed` is the same kind of dead end one step earlier, before a worktree existed. A spent allowance
-// counts until something is booked to carry it on (limitScheduled): a resend at the reset, or a move now.
+// counts until something is booked to carry it on (limitScheduled): a resend at the reset, or a move now. Any settled
+// dead end counts until a booking answers it (bookingAnswers).
 const BLOCKING_ENDINGS: ReadonlySet<AgentStatus | ClientAgentStatus> = new Set(["error", "interrupted", "stopping", "stopped", "failed"]);
 
 // A land that broke and still stands: its work is stuck on the branch, whatever the turn after it did, so the card is
 // the reader's to look at. Not while a turn or a land is under way, which ends in another land of its own.
 export const landBroken = (agent: AgentStanding): boolean => agent.landFailure !== undefined && !turnInFlight(agent);
 
+// The settled dead ends a booking can answer. Not `stopping`, which is still unwinding and rests in Attention whatever
+// waits behind it.
+const ANSWERABLE_ENDINGS: ReadonlySet<AgentStatus | ClientAgentStatus> = new Set(["error", "interrupted", "stopped", "failed"]);
+
+/**
+ * A turn that ended badly, with something booked to go by itself after it: a message for a time, a continuation at a
+ * spent allowance's reopen, words held for memory re-timed to that reopen. That booking is the person's answer to the
+ * ending, or the sandbox's on their standing word, so the next move is the sandbox's, at the booking, and the ending no
+ * longer calls the reader: the card is Active, and its corner says when it goes. Before 2026-10-18 only the sandbox's own
+ * booked resend after a spent allowance (limitScheduled) answered an ending, so an expired account's card stayed in
+ * Attention under a clock already saying "sends Sun 05:00", the reader's answer to it booked and not counted. Answers
+ * only the ending: an ask (a plan, a question, a permission, a land only the reader can clear) still calls them.
+ */
+export const bookingAnswers = (agent: AgentStanding): boolean => ANSWERABLE_ENDINGS.has(agent.status) && scheduledSend(agent);
+
 export const blocked = (agent: AgentStanding): boolean =>
     limitScheduled(agent)
         ? false
@@ -238,7 +255,7 @@ export const blocked = (agent: AgentStanding): boolean =>
           (agent.attention.need === true && agent.status !== "running") ||
           landBroken(agent) ||
           heldByPrompt(agent) ||
-          BLOCKING_ENDINGS.has(agent.status);
+          (BLOCKING_ENDINGS.has(agent.status) && !bookingAnswers(agent));
 
 // The half of `blocked` that is literally waiting on an answer (plan, question, permission, capability), narrower
 // than `blocked`: dead ends (a failed turn, an unlandable conflict) want looking at but owe the user nothing, so
@@ -273,6 +290,7 @@ export const heardByParent = (child: AgentStanding & { readonly updatedAt: numbe
     child.status !== "stopping" &&
     // Booked to run again by itself: not over, whatever its parent made of the pause.
     !limitScheduled(child) &&
+    !bookingAnswers(child) &&
     !child.attention.question &&
     !child.attention.conflict &&
     !landBroken(child) &&

package/src/models/plan-pools.test.ts

@@ -258,6 +258,18 @@ test("a refusal stands until a later reading contradicts it, and never past its
     expect(refusalVerdict(refusal({ kind: "limit", account: "a" }), [])).toBe("standing");
 });
 
+// 2026-10-17: Codex's team credit ran out while its weekly pool read 57% on the shared credential.
+test("an allowance no reading measures stands against every reading, until the provider's own reset", () => {
+    const room = at(Date.now() + 60_000, window({ kind: "seven_day", utilization: 43 }));
+    const credit = refusal({ kind: "limit", unmetered: true, at: Date.now(), resetsAt: Math.floor(Date.now() / 1000) + 3_600 });
+    expect(refusalVerdict(credit, [{ account: "a", usage: room }, { account: "b", usage: room }])).toBe("standing");
+    expect(refusalVerdict({ ...credit, resetsAt: Math.floor(Date.now() / 1000) - 1 }, [{ account: "a", usage: room }, { account: "b", usage: room }])).toBe(
+        "answered",
+    );
+    expect(refusalVerdict({ ...credit, resetsAt: undefined }, [{ account: "a", usage: room }])).toBe("standing");
+});
+
+
 // Codex's usage endpoint kept reading room while every turn was refused "try again at 3:38 PM": the provider's own
 // instant is what ends the refusal, where it is known which account it refused.
 test("a spent allowance with the provider's own reset stands until that instant, whatever a later reading says", () => {

package/src/models/plan-pools.ts

@@ -188,9 +188,10 @@ export interface ServiceFacts {
 
 // A spent allowance is over once a reading with room lands after it; a refused credential once any reading does (the
 // token worked). Nothing a reading says answers an entitlement refusal: a seatless account authenticates and reads fine.
+// Nor does any reading answer an allowance it does not measure (`unmetered`: an admin's credit).
 const answers = (refusal: ProviderRefusal, facts: ServiceFacts): boolean => {
     const measuredAt = facts.usage?.measuredAt;
-    if (refusal.kind === "entitlement" || measuredAt === undefined || measuredAt <= refusal.at) {
+    if (refusal.kind === "entitlement" || refusal.unmetered === true || measuredAt === undefined || measuredAt <= refusal.at) {
         return false;
     }
     if (refusal.kind === "auth") {
@@ -218,7 +219,7 @@ export const refusalVerdict = (
     // only one), its own words outrank a usage endpoint that kept showing room while it refused: over at that instant,
     // and not before. A nameless refusal over several accounts is still answered by any of them reading room, since the
     // translator benches the one it refused and routes on.
-    if (refusal.kind === "limit" && refusal.resetsAt !== undefined && (refusal.account !== undefined || accounts.length <= 1)) {
+    if (refusal.kind === "limit" && refusal.resetsAt !== undefined && (refusal.account !== undefined || accounts.length <= 1 || refusal.unmetered === true)) {
         return refusal.resetsAt * 1000 <= now ? "answered" : "standing";
     }
     return (refusal.account === undefined ? accounts : named).some((facts) => answers(refusal, facts)) ? "answered" : "standing";

package/src/netd/generated/browser-wire.json

@@ -152,6 +152,19 @@
             "type"
           ],
           "type": "object"
+        },
+        {
+          "description": "Every binary message after this one is the pane's bytes deflated, for a browser that asked with `deflate=1` in\nthe socket's query: its unpacked length (4 bytes, big-endian), then raw deflate (RFC 1951) through a sync flush,\nall of one socket's messages one deflate stream. Sent first, before any pane bytes; a browser that never sees it\nreads binary messages as the raw bytes they always were, which is what an older netd sends whatever was asked.",
+          "properties": {
+            "type": {
+              "const": "deflate",
+              "type": "string"
+            }
+          },
+          "required": [
+            "type"
+          ],
+          "type": "object"
         }
       ],
       "title": "TerminalServerMessage"

package/src/netd/generated/browser-wire.ts

@@ -54,7 +54,7 @@ export type TerminalClientMessage = { "type": "input", data: string, } | { "type
 /**
  * What a terminal socket sends as JSON text; the pane's own bytes travel as binary messages.
  */
-export type TerminalServerMessage = { "type": "grid", cols: number, rows: number, } | { "type": "exit", code: number, reason?: string, } | { "type": "pong" };
+export type TerminalServerMessage = { "type": "grid", cols: number, rows: number, } | { "type": "exit", code: number, reason?: string, } | { "type": "pong" } | { "type": "deflate" };
 
 /**
  * Where netd's tunnel stands.

package/src/protocol/peer-dial.ts

@@ -42,8 +42,10 @@ const OPEN = 1;
 // Structural interface a browser's WebSocket, node's global one, and a test's fake all satisfy without a cast.
 export interface SocketLike {
     readonly readyState: number;
-/* `message` is here for the watchdog alone, which needs no more than the fact that one arrived. */
-    addEventListener(type: "open" | "close" | "error" | "message", listener: (event: { readonly code?: number }) => void): void;
+/* `message` is here for the watchdog alone, which needs no more than the fact that one arrived. Two signatures, so a
+   socket typing its listeners per event (ws's) satisfies it as well as one with a single listener type. */
+    addEventListener(type: "close", listener: (event: { readonly code?: number }) => void): void;
+    addEventListener(type: "open" | "error" | "message", listener: () => void): void;
     send(data: string): void;
     close(code?: number, reason?: string): void;
 }

package/src/protocol/raw/raw-routes.ts

@@ -40,6 +40,9 @@ export const RAW_ROUTES = {
     "GET /workspace/media": { auth: "door", guest: true, lane: "bulk" },
     // Navigated to for a ZIP of a selection, so no header either: the ticket it carries names the selection.
     "GET /workspace/download": { auth: "door", guest: true, lane: "bulk" },
+    // A previewed web page and the files it names, loaded by a frame, which sends no header: the ticket is the path's
+    // first segment, so the page's relative addresses carry it, and it is checked in the handler.
+    "GET /workspace/preview/{ticket}/*": { auth: "door", guest: true },
     // An attachment is part of the message it rides with; any other target edits the shared tree.
     "POST /workspace/upload": { floor: "writer", attachmentFloor: "collaborator", lane: "bulk" },
     "POST /workspace/upload-diff": {},

package/src/schemas/agent.ts

@@ -533,6 +533,12 @@ export const QueuedMessageSchema = z.object({
     after: ConversationIdSchema.optional().describe(
         "The conversation whose finished work must land before this message goes out by itself, in place of `until`.",
     ),
+    continues: z
+        .literal(true)
+        .optional()
+        .describe(
+            "A continuation, not words: when it goes, the conversation carries on from where its last turn stopped, as `agent.run` with `continues` does, and nothing is added to it as anybody's message. `text` is empty. A turn that starts in the conversation before it goes makes it moot, and it is dropped.",
+        ),
 });
 export type QueuedMessage = z.infer<typeof QueuedMessageSchema>;
 // Why a queue holds its messages rather than letting them go when the conversation is free.

package/src/schemas/ci.ts

@@ -164,12 +164,27 @@ export type MainFailureDecision = z.infer<typeof MainFailureDecisionSchema>;
 
 // A main-line branch while its CI fails, as the daemon's one fix agent on it sees it (ci/main-fixer.ts): from the first
 // job that failed until a later run of every workflow that failed on it passes, whatever else failed along the way.
+// One workflow failing on a main-line branch, where a push starts several (GitHub): a later run of it passing takes it
+// off the failure, so a pass of any other says nothing of it. A scheduled one (a nightly) is the case that needs
+// spelling out: a push does not run it, and the board's own runs may all pass while it still fails.
+export const CiMainFailureWorkflowSchema = z.object({
+    name: z.string().describe("The workflow, by the name the forge gives it. `ci` on a forge that runs one pipeline per commit."),
+    runId: z.number().describe("Its newest run that failed."),
+    jobs: z.array(z.string()).describe("Its jobs failing now, by name."),
+});
+export type CiMainFailureWorkflow = z.infer<typeof CiMainFailureWorkflowSchema>;
 export const CiMainFailureSchema = z.object({
     repo: z.string().describe("Which workspace repository."),
     branch: z.string().describe("Which main-line branch."),
     since: z.number().describe("When its first job failed, in milliseconds."),
     runId: z.number().describe("The newest run that failed on it."),
     jobs: z.array(z.string()).describe("The jobs failing on it now, by name: the newest failed run's failures, and any that failed since."),
+    workflows: z
+        .array(CiMainFailureWorkflowSchema)
+        .optional()
+        .describe(
+            "Each workflow failing on it, in the order they began failing, with its newest failed run and its jobs: the branch passes again only once a later run of every one of them passes. Absent from a daemon from before workflows were told apart.",
+        ),
     fixer: z
         .string()
         .optional()

package/src/schemas/dev-rebuild-log.test.ts

@@ -1,4 +1,4 @@
-import { DEV_REBUILD_EXIT_MARK, DEV_REBUILD_QUIET_MARK, devRebuildLogPath, readDevRebuildLog } from "./devices.js";
+import { DEV_REBUILD_EXIT_MARK, DEV_REBUILD_QUIET_MARK, devRebuildLogPath, readDevRebuildLog } from "./dev-rebuild-log.js";
 
 // The one account a detached rebuild gives of itself. The daemon builds the shell that writes this text and the browser
 // draws what it means, so the grammar is pinned here, where both of them read it.

package/src/schemas/dev-rebuild-log.ts

@@ -0,0 +1,58 @@
+// What a detached `dev-rebuild` leaves behind on the machine that runs it, and how `dev-rebuild-log` reads it back.
+// devices.ts re-exports all of it beside the device commands that name it.
+
+// WHERE A DETACHED REBUILD REPORTS ITSELF. `dev-rebuild` returns the moment the build is under way and nothing streams
+// back from it — a cold build outruns any timeout this door has, and the container swap at the end kills the daemon that
+// would have read the answer — so the build writes here instead, in the folder ic logs its own recreates into, and
+// `dev-rebuild-log` reads it back. Spelled once, here, because the daemon builds both command lines from it and the
+// browser names the same path to a reader whose rebuild never came back.
+export const devRebuildLogPath = (slug: string): string => `~/.intentic/logs/dev-rebuild-${slug}.log`;
+
+// The build's own shell appends this when the build ends, with its exit status: since the log outlives the daemon, the
+// container and the page that started it, this mark is the only thing that can say a rebuild is OVER rather than slow.
+export const DEV_REBUILD_EXIT_MARK = "@intentic-rebuild-exit";
+// `dev-rebuild-log` prints this first, then how many seconds it is since the log last grew — `-` when there is no log on
+// that machine at all. A running build goes quiet for a minute at a time inside a docker layer; a build whose machine
+// slept never writes its exit mark, and only this tells the two apart.
+export const DEV_REBUILD_QUIET_MARK = "@intentic-rebuild-quiet";
+
+export interface DevRebuildLog {
+    /** Nothing has ever rebuilt this sandbox from a checkout on that machine. */
+    readonly missing: boolean;
+    /** Seconds since the log last grew; undefined when the machine's `stat` wouldn't say. */
+    readonly quietFor: number | undefined;
+    /** The build's own exit status, present only once it has ended. */
+    readonly exitCode: number | undefined;
+    /** The tail as the machine printed it, both marks removed. */
+    readonly lines: readonly string[];
+}
+
+// Reads `dev-rebuild-log`'s stdout. Shared rather than parsed at the reader, so the shell line that produces this and the
+// card that draws it cannot drift apart. Unparseable is never an error: an answer with no marks at all is simply a log
+// with nothing to say yet.
+const markValue = (line: string, mark: string): string | undefined => (line.startsWith(`${mark} `) ? line.slice(mark.length + 1).trim() : undefined);
+const wholeNumber = (value: string): number | undefined => (/^\d+$/.test(value) ? Number(value) : undefined);
+
+export const readDevRebuildLog = (text: string): DevRebuildLog => {
+    let missing = false;
+    let quietFor: number | undefined;
+    let exitCode: number | undefined;
+    const lines: string[] = [];
+    for (const line of text.split(/\r?\n/)) {
+        const quiet = markValue(line, DEV_REBUILD_QUIET_MARK);
+        const exit = markValue(line, DEV_REBUILD_EXIT_MARK);
+        if (quiet !== undefined) {
+            missing = quiet === "-";
+            quietFor = wholeNumber(quiet);
+        } else if (exit !== undefined) {
+            // A mark whose status is unreadable still means the build ENDED, and not well.
+            exitCode = wholeNumber(exit) ?? 1;
+        } else {
+            lines.push(line);
+        }
+    }
+    while (lines.at(-1)?.trim() === "") {
+        lines.pop();
+    }
+    return { missing, quietFor, exitCode, lines };
+};

package/src/schemas/devices.ts

@@ -266,61 +266,9 @@ export type DeviceCommand = z.infer<typeof DeviceCommandSchema>;
 export const DeviceSyncSwitchSchema = DeviceCommandSchema.exclude(["dev-restart", "dev-rebuild", "dev-rebuild-log", "sync-install", "sync-clean"]);
 export type DeviceSyncSwitch = z.infer<typeof DeviceSyncSwitchSchema>;
 
-// WHERE A DETACHED REBUILD REPORTS ITSELF. `dev-rebuild` returns the moment the build is under way and nothing streams
-// back from it — a cold build outruns any timeout this door has, and the container swap at the end kills the daemon that
-// would have read the answer — so the build writes here instead, in the folder ic logs its own recreates into, and
-// `dev-rebuild-log` reads it back. Spelled once, here, because the daemon builds both command lines from it and the
-// browser names the same path to a reader whose rebuild never came back.
-export const devRebuildLogPath = (slug: string): string => `~/.intentic/logs/dev-rebuild-${slug}.log`;
-
-// The build's own shell appends this when the build ends, with its exit status: since the log outlives the daemon, the
-// container and the page that started it, this mark is the only thing that can say a rebuild is OVER rather than slow.
-export const DEV_REBUILD_EXIT_MARK = "@intentic-rebuild-exit";
-// `dev-rebuild-log` prints this first, then how many seconds it is since the log last grew — `-` when there is no log on
-// that machine at all. A running build goes quiet for a minute at a time inside a docker layer; a build whose machine
-// slept never writes its exit mark, and only this tells the two apart.
-export const DEV_REBUILD_QUIET_MARK = "@intentic-rebuild-quiet";
-
-export interface DevRebuildLog {
-    /** Nothing has ever rebuilt this sandbox from a checkout on that machine. */
-    readonly missing: boolean;
-    /** Seconds since the log last grew; undefined when the machine's `stat` wouldn't say. */
-    readonly quietFor: number | undefined;
-    /** The build's own exit status, present only once it has ended. */
-    readonly exitCode: number | undefined;
-    /** The tail as the machine printed it, both marks removed. */
-    readonly lines: readonly string[];
-}
+// Where a detached rebuild reports itself, and the reader of that report (dev-rebuild-log.ts).
+export { DEV_REBUILD_EXIT_MARK, DEV_REBUILD_QUIET_MARK, type DevRebuildLog, devRebuildLogPath, readDevRebuildLog } from "./dev-rebuild-log.js";
 
-// Reads `dev-rebuild-log`'s stdout. Shared rather than parsed at the reader, so the shell line that produces this and the
-// card that draws it cannot drift apart. Unparseable is never an error: an answer with no marks at all is simply a log
-// with nothing to say yet.
-const markValue = (line: string, mark: string): string | undefined => (line.startsWith(`${mark} `) ? line.slice(mark.length + 1).trim() : undefined);
-const wholeNumber = (value: string): number | undefined => (/^\d+$/.test(value) ? Number(value) : undefined);
-
-export const readDevRebuildLog = (text: string): DevRebuildLog => {
-    let missing = false;
-    let quietFor: number | undefined;
-    let exitCode: number | undefined;
-    const lines: string[] = [];
-    for (const line of text.split(/\r?\n/)) {
-        const quiet = markValue(line, DEV_REBUILD_QUIET_MARK);
-        const exit = markValue(line, DEV_REBUILD_EXIT_MARK);
-        if (quiet !== undefined) {
-            missing = quiet === "-";
-            quietFor = wholeNumber(quiet);
-        } else if (exit !== undefined) {
-            // A mark whose status is unreadable still means the build ENDED, and not well.
-            exitCode = wholeNumber(exit) ?? 1;
-        } else {
-            lines.push(line);
-        }
-    }
-    while (lines.at(-1)?.trim() === "") {
-        lines.pop();
-    }
-    return { missing, quietFor, exitCode, lines };
-};
 // Machine's sandbox id (absent = every paired sandbox); must start alphanumeric, else it parses as a CLI flag.
 export const DeviceSandboxIdSchema = z
     .string()