@a-dray/aglib 0.1.0 → 0.1.1

package/dist/model/model.js.map

@@ -1 +1 @@
-{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/model/model.ts"],"names":[],"mappings":"AAyEA,wDAAwD;AACxD,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,UAAyE;IAEzE,IAAI,IAAI,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;IACnC,OAAO,CAAC,IAAI,CAAC,IAAI;QAAE,IAAI,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;IAClD,OAAO,IAAI,CAAC,KAAK,CAAC;AACpB,CAAC","sourcesContent":["import type { Content, ContentPart } from \"../content.js\";\nimport type { ToolCall, Usage } from \"../session/entry.js\";\nimport type { Message } from \"../session/messages.js\";\nimport type { ToolSpec } from \"../tools/tool.js\";\nimport type { Failure, Result } from \"../result.js\";\nimport type { JsonValue } from \"../json.js\";\n\n/**\n * One provider call.\n *\n * There is no model *name* here, and that is the point: a model is a value.\n * `createAnthropicModel({ apiKey, model })` is the provider, the credential and\n * the model together, and choosing a different one is choosing a different\n * `Model` — which is already how the loop passes a cheaper one to compaction.\n *\n * A name would have to be resolved, and resolving is what goes wrong. The one\n * application that had a name field to use encoded provider and model into it\n * as `provider/model`, then had to split it back out — ambiguously, because a\n * provider's own ids contain slashes (`z-ai/glm-5.2`), so the split was\n * \"up to the first one\" with a comment apologising for it. One field, two facts.\n * Names leave this library as observations — `ModelResponse.model` says what\n * actually served — and never enter it as selections.\n */\nexport interface ModelRequest {\n  messages: readonly Message[];\n  tools?: readonly ToolSpec[];\n  maxOutputTokens?: number;\n  /**\n   * Only for providers that still accept sampling controls. The current\n   * Anthropic models reject it outright, so that adapter does not send it —\n   * declaring the option here and dropping it there is the honest shape, since\n   * the alternative is a request the provider 400s.\n   */\n  temperature?: number;\n  /**\n   * How much the model should think before answering, where it can. Named\n   * levels rather than a token budget, because a budget is the one thing no\n   * two providers agree on — and the providers that had one have since removed\n   * it. Each adapter maps a level to its own control; one that has none\n   * ignores it rather than failing.\n   */\n  effort?: \"low\" | \"medium\" | \"high\" | \"xhigh\" | \"max\";\n  /** End the cacheable prefix after this many messages. A decision about one request only. */\n  cacheAfter?: number;\n  signal?: AbortSignal;\n}\n\nexport type ModelDelta =\n  | { type: \"text.delta\"; text: string }\n  | { type: \"reasoning.delta\"; text: string }\n  | { type: \"tool-call.delta\"; callId: string; arguments: string };\n\nexport interface ModelResponse {\n  message: { content: Content; calls?: readonly ToolCall[] };\n  finishReason: \"stop\" | \"tool-calls\" | \"length\" | \"refusal\";\n  usage: Usage;\n  model?: string;\n}\n\nexport interface ModelError extends Failure {\n  code: \"auth\" | \"rate-limit\" | \"context-length\" | \"cancelled\" | \"provider\" | \"failed\";\n}\n\n/**\n * One method. Streaming is not a second contract: a caller that wants the whole\n * response drains the generator and takes its return value, so no adapter has\n * to implement the same normalization twice.\n */\nexport interface Model {\n  readonly id: string;\n  generate(request: ModelRequest): AsyncGenerator<ModelDelta, Result<ModelResponse, ModelError>>;\n}\n\n/** Drains a generation and returns only its outcome. */\nexport async function collect(\n  generation: AsyncGenerator<ModelDelta, Result<ModelResponse, ModelError>>,\n): Promise<Result<ModelResponse, ModelError>> {\n  let step = await generation.next();\n  while (!step.done) step = await generation.next();\n  return step.value;\n}\n\n/**\n * The vocabulary an adapter needs, re-exported from the port it implements.\n * An adapter imports these from here rather than reaching into the modules that\n * own them, so the port is the whole of its surface — every one of them appears\n * in a type above, which is what makes this the place to get them.\n */\nexport type { ContentPart, Message, ToolCall, ToolSpec, Usage };\n"]}
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/model/model.ts"],"names":[],"mappings":"AAyEA;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,UAAyE;IAEzE,IAAI,IAAI,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;IACnC,OAAO,CAAC,IAAI,CAAC,IAAI;QAAE,IAAI,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;IAClD,OAAO,IAAI,CAAC,KAAK,CAAC;AACpB,CAAC","sourcesContent":["import type { Content, ContentPart } from \"../content.js\";\nimport type { ToolCall, Usage } from \"../session/entry.js\";\nimport type { Message } from \"../session/messages.js\";\nimport type { ToolSpec } from \"../tools/tool.js\";\nimport type { Failure, Result } from \"../result.js\";\nimport type { JsonValue } from \"../json.js\";\n\n/**\n * One provider call.\n *\n * There is no model *name* here, and that is the point: a model is a value.\n * `createAnthropicModel({ apiKey, model })` is the provider, the credential and\n * the model together, and choosing a different one is choosing a different\n * `Model` — which is already how the loop passes a cheaper one to compaction.\n *\n * A name would have to be resolved, and resolving is what goes wrong. The one\n * application that had a name field to use encoded provider and model into it\n * as `provider/model`, then had to split it back out — ambiguously, because a\n * provider's own ids contain slashes (`z-ai/glm-5.2`), so the split was\n * \"up to the first one\" with a comment apologising for it. One field, two facts.\n * Names leave this library as observations — `ModelResponse.model` says what\n * actually served — and never enter it as selections.\n */\nexport interface ModelRequest {\n  messages: readonly Message[];\n  tools?: readonly ToolSpec[];\n  maxOutputTokens?: number;\n  /**\n   * Only for providers that still accept sampling controls. The current\n   * Anthropic models reject it outright, so that adapter does not send it —\n   * declaring the option here and dropping it there is the honest shape, since\n   * the alternative is a request the provider 400s.\n   */\n  temperature?: number;\n  /**\n   * How much the model should think before answering, where it can. Named\n   * levels rather than a token budget, because a budget is the one thing no\n   * two providers agree on — and the providers that had one have since removed\n   * it. Each adapter maps a level to its own control; one that has none\n   * ignores it rather than failing.\n   */\n  effort?: \"low\" | \"medium\" | \"high\" | \"xhigh\" | \"max\";\n  /** End the cacheable prefix after this many messages. A decision about one request only. */\n  cacheAfter?: number;\n  signal?: AbortSignal;\n}\n\nexport type ModelDelta =\n  | { type: \"text.delta\"; text: string }\n  | { type: \"reasoning.delta\"; text: string }\n  | { type: \"tool-call.delta\"; callId: string; arguments: string };\n\nexport interface ModelResponse {\n  message: { content: Content; calls?: readonly ToolCall[] };\n  finishReason: \"stop\" | \"tool-calls\" | \"length\" | \"refusal\";\n  usage: Usage;\n  model?: string;\n}\n\nexport interface ModelError extends Failure {\n  code: \"auth\" | \"rate-limit\" | \"context-length\" | \"cancelled\" | \"provider\" | \"failed\";\n}\n\n/**\n * One method. Streaming is not a second contract: a caller that wants the whole\n * response drains the generator and takes its return value, so no adapter has\n * to implement the same normalization twice.\n */\nexport interface Model {\n  readonly id: string;\n  generate(request: ModelRequest): AsyncGenerator<ModelDelta, Result<ModelResponse, ModelError>>;\n}\n\n/**\n * Drains a generation and returns only its outcome.\n *\n * Not on the `aglib/model` subpath. It was, for a recipe that turned a `Model`\n * into an Anthropic response; when that went, nothing outside the package\n * consumed it. `Model`'s own contract above says what a caller who wants the\n * whole response does, and this is the four lines of doing it.\n */\nexport async function collect(\n  generation: AsyncGenerator<ModelDelta, Result<ModelResponse, ModelError>>,\n): Promise<Result<ModelResponse, ModelError>> {\n  let step = await generation.next();\n  while (!step.done) step = await generation.next();\n  return step.value;\n}\n\n/**\n * The vocabulary an adapter needs, re-exported from the port it implements.\n * An adapter imports these from here rather than reaching into the modules that\n * own them, so the port is the whole of its surface — every one of them appears\n * in a type above, which is what makes this the place to get them.\n */\nexport type { ContentPart, Message, ToolCall, ToolSpec, Usage };\n"]}

package/dist/render.d.ts

@@ -0,0 +1,100 @@
+/**
+ * A run, as lines someone can read.
+ *
+ * A root file rather than a module, and a projection rather than a port: this
+ * is `textOf` one level out. `toMessages` folds committed entries into what a
+ * model is shown; this folds the update stream into what a person is shown. No
+ * adapter has to prove anything about it, so there is nothing here for a
+ * conformance suite to hold, and nothing below it to rank against.
+ *
+ * **It is not a channel, and the difference is worth stating because it is
+ * subtle.** A channel does three jobs: decide which session a person is talking
+ * to, deliver a message exactly once, and put the result in a medium's own
+ * shape. The first two are an application's — a mail thread maps to a session,
+ * a webhook may arrive twice. Only the third is the same work for every medium,
+ * and only the third is here. Email is a channel with no projection at all: it
+ * sends `RunResult.output` and never looks at the stream. A terminal is the
+ * other extreme — its identity is "the one session" and its delivery is a pipe
+ * that cannot fail, so a terminal channel is *nothing but* this projection.
+ *
+ * **The answer and the stream are different things, and only one is a message.**
+ * `RunResult.output` is what `finished` hands to `Delivery.input`: the same
+ * `Content`, whether the recipient is a person or another session. The stream
+ * is not a message and never becomes one — a `cancelled` or `failed` result has
+ * no `output` field at all, so a run can stream a paragraph and produce nothing
+ * that could be delivered.
+ *
+ * Showing that paragraph is not a mistake. Watching what an agent was saying
+ * when it was cancelled is most of what debugging one is. What would be a
+ * mistake is leaving the outcome implicit, so the text reads as an answer that
+ * was never given — which is why `finish` always states it, and takes it from
+ * the result rather than from whatever happened to stream.
+ *
+ * **`detail` is the knob that makes one projection serve every medium.** Three
+ * levels, because what the knob is graduated in is the *internal stream* and
+ * not the conversation: a tool call is the agent talking to itself, while a
+ * message arriving from a subagent, a peer or a person is the conversation
+ * happening. The log keeps those apart — one is an entry the loop wrote, the
+ * other came through `enqueue` — so the projection does too.
+ *
+ * There is no level below `"minimal"`, and there was one. A medium with no
+ * second channel says so by having no `status`, which drops the account
+ * entirely; a `detail` that meant the same thing was a second way to state a
+ * fact the `Sink` already stated. Failures are not behind a level either — an
+ * agent that silently did nothing is the one outcome a reader cannot diagnose
+ * from what they were shown.
+ *
+ * Two channels out, because they answer different questions. `write` carries
+ * the answer, so redirecting it captures the answer and nothing else. `status`
+ * carries what the agent did on the way — tools, provenance, what it spent.
+ */
+import type { AgentRun, RunResult } from "./agent.js";
+import type { Update } from "./harness/harness.js";
+import type { ToolCall, Usage } from "./session/entry.js";
+export interface Sink {
+    /** The answer: assistant text, exactly as it streamed. */
+    write(text: string): void;
+    /**
+     * Everything else: tools, provenance, what the run spent.
+     *
+     * Omit it and that account is **dropped**, not folded into `write`. Falling
+     * back would break the one promise `write` makes — that it holds the answer
+     * and nothing else — for every caller who only wanted the answer and did not
+     * think to say so.
+     */
+    status?(line: string): void;
+    /** Enables colour and the elapsed-time ticker. A caller without a terminal leaves it off. */
+    tty?: boolean;
+    /**
+     * How much of the run to show.
+     *
+     * `"minimal"` is the conversation: the answer, input that arrived from
+     * somewhere else, and anything that failed. `"standard"` adds the internal
+     * stream — tool calls, their results, and what the run spent. `"detailed"`
+     * adds what it was thinking, arguments as they form, and the structured
+     * `details` a tool returned.
+     *
+     * For the answer and nothing whatever beside it, give a sink with no
+     * `status`.
+     */
+    detail?: "minimal" | "standard" | "detailed";
+    /**
+     * Marks a run being watched rather than driven — a subagent taken off the
+     * queue, most often. A labelled run has no answer channel: nobody asked it
+     * anything, so everything it says is an account of what the run it belongs
+     * to is doing, and all of it is prefixed and sent to `status`.
+     */
+    label?: string;
+    /** Milliseconds, for durations. Supplied by a test so its output is exact. */
+    now?(): number;
+}
+/**
+ * Render a run to its end, and answer what it did.
+ *
+ * The loop every application writes by hand, with the two things a hand-written
+ * one keeps getting wrong: everything the stream carries besides text, and an
+ * outcome taken from the result rather than from whatever happened to stream.
+ */
+export declare function renderRun(run: AgentRun, sink: Sink): Promise<RunResult>;
+/** Re-exported so a caller composing a sink imports one thing. */
+export type { Update, RunResult, Usage, ToolCall };

package/dist/render.js

@@ -0,0 +1,370 @@
+import { textOf } from "./content.js";
+/**
+ * The one animation, and it is data rather than a dependency.
+ *
+ * Braille dots because they are one column wide in every terminal that has the
+ * font and degrade to boxes rather than to a broken layout in the ones that do
+ * not. Written to `status`, so the answer channel stays something a pipe can
+ * read.
+ */
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const DIM = "\x1b[2m";
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const RESET = "\x1b[0m";
+/** One line, however long the thing being described is. */
+const oneLine = (text, limit = 96) => {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > limit ? `${flat.slice(0, limit - 1)}…` : flat;
+};
+const round = (count) => count >= 1000 ? `${(count / 1000).toFixed(1)}k` : `${count}`;
+const seconds = (ms) => `${(ms / 1000).toFixed(1)}s`;
+/**
+ * Content as the model sees it, plus a marker for every part it cannot.
+ *
+ * `textOf` drops images, files and opaque blocks, which is right for a model
+ * and wrong for a person: a screen showing less than the log holds, silently,
+ * is the omission this package refuses everywhere else.
+ */
+function readable(content) {
+    if (typeof content === "string")
+        return content;
+    return content.map((part) => part.type === "text" ? part.text
+        : part.type === "image" ? `[image ${part.mediaType}]`
+            : part.type === "file" ? `[file ${part.name ?? part.mediaType}]`
+                : `[opaque ${part.provider}]`).join("\n");
+}
+function createRenderer(sink) {
+    const status = sink.status ?? (() => { });
+    const detail = sink.detail ?? "standard";
+    const debugging = detail === "detailed";
+    /** The agent talking to its own tools, as opposed to the conversation. */
+    const internal = debugging || detail === "standard";
+    const now = sink.now ?? (() => Date.now());
+    const label = sink.label ? `${sink.label} ` : "";
+    const started = now();
+    const dim = (text) => (sink.tty ? `${DIM}${text}${RESET}` : text);
+    const mark = (glyph, bad) => sink.tty ? `${bad ? RED : GREEN}${glyph}${RESET}` : glyph;
+    /** Names by call id. A tool entry carries only the id; the assistant entry above holds the name. */
+    const names = new Map();
+    /** When each call started, so a result can say how long it took. */
+    const clocks = new Map();
+    /**
+     * What has been streamed since the last assistant entry.
+     *
+     * The harnesses disagree about deltas — some stream tokens, some emit one
+     * delta per whole message, and some emit none at all. The entry stream is
+     * the one channel every harness fills, so
+     * the entry decides what is shown and the deltas decide how much of it
+     * already has been.
+     *
+     * The rule the port does not state, and this therefore does not assume:
+     * deltas preceding an assistant entry *ought* to concatenate to its text.
+     * Where they do, the remainder is printed and nothing appears twice. Where
+     * they are absent, the whole entry is printed. Where they are neither — a
+     * harness that streamed something else, or stopped halfway — the entry is
+     * printed in full on a fresh line, because showing a reader the same words
+     * twice is a smaller failure than silently dropping the half nobody streamed.
+     */
+    let streamed = "";
+    let turns = 0;
+    /** Whether the last thing written ended mid-line, so a status line can open a fresh one. */
+    let open = false;
+    let thinking = false;
+    /**
+     * The calls in flight, and the one status line describing all of them.
+     *
+     * One ticker for the renderer rather than one per call. A tool call is not
+     * exclusive — a harness may start four at once, and Pi does — and a per-call
+     * interval meant each `tool.started` overwrote the last without clearing it:
+     * the orphans kept drawing to the same line for the life of the process,
+     * fighting each other and interleaving with committed lines. A terminal has
+     * one status line, so there is one thing drawing it.
+     *
+     * No `at` is kept here. `clocks` already holds when each call started, and a
+     * second copy is a second answer.
+     */
+    const running = new Set();
+    let ticker;
+    /** Whether the status line currently holds a spinner that must be erased before anything else. */
+    let drawn = false;
+    /**
+     * Erase the spinner, leaving the cursor at the start of a clean line.
+     *
+     * Called before *every* write, because `\r` returns to the start of whatever
+     * line is current and half a streamed sentence is as much a casualty as a
+     * status line. The ticker redraws on its next tick if work is still in
+     * flight, so this costs nothing but a frame.
+     */
+    const clearSpinner = () => {
+        if (!drawn)
+            return;
+        drawn = false;
+        status("\r\x1b[K");
+    };
+    const line = (text) => {
+        clearSpinner();
+        if (open) {
+            sink.write("\n");
+            open = false;
+        }
+        status(`${label}${text}\n`);
+    };
+    const stopTicker = () => {
+        if (ticker) {
+            clearInterval(ticker);
+            ticker = undefined;
+        }
+        clearSpinner();
+    };
+    /**
+     * What is running, in the width of one line.
+     *
+     * The oldest call names itself and carries the clock, because it is the one a
+     * reader is waiting on; the rest are a count. Naming all four would be a
+     * line that changes width every time one finishes.
+     */
+    const inFlight = (glyph) => {
+        const oldest = [...running].sort((a, b) => (clocks.get(a) ?? 0) - (clocks.get(b) ?? 0))[0];
+        if (oldest === undefined)
+            return "";
+        const name = names.get(oldest) ?? oldest.slice(0, 8);
+        const others = running.size - 1;
+        return `${label}${glyph} ${name}${others ? ` +${others}` : ""} ${seconds(now() - (clocks.get(oldest) ?? now()))}`;
+    };
+    /**
+     * The one piece of cursor control in this file, and the only reason a long
+     * command is not silence. Unref'd so it can never hold a process open.
+     *
+     * It does not draw over an open line: `say` leaves the cursor mid-sentence
+     * while text streams, and `\r` there would eat the sentence. Nothing is lost
+     * — the next tick after the newline draws it.
+     */
+    const startTicker = () => {
+        if (ticker || !sink.tty)
+            return;
+        let frame = 0;
+        ticker = setInterval(() => {
+            if (open || !running.size)
+                return;
+            const text = inFlight(SPINNER[frame++ % SPINNER.length]);
+            if (!text)
+                return;
+            drawn = true;
+            status(`\r${DIM}${text}${RESET}\x1b[K`);
+        }, 90);
+        ticker.unref?.();
+    };
+    /** Partial line held back while a labelled run streams, so the prefix stays whole. */
+    let held = "";
+    /**
+     * Write text for the reader. The primitive; `say` is the streaming door to it.
+     *
+     * Only a delta counts as *streamed*. An entry printed through here must not
+     * be added to `streamed`, or its own words become the "already shown" prefix
+     * the next entry is measured against — and since a second turn's text does
+     * not begin with a first turn's, `startsWith` failed and the whole turn was
+     * printed again under the half that had already streamed.
+     */
+    const emit = (text) => {
+        clearSpinner();
+        if (thinking) {
+            thinking = false;
+        }
+        if (!sink.label) {
+            sink.write(text);
+            open = !text.endsWith("\n");
+            return;
+        }
+        // A prefix cannot be applied to half a line, so a labelled run buffers to
+        // the newline. Nothing is lost: `finish` flushes whatever is left.
+        held += text;
+        let cut = held.indexOf("\n");
+        while (cut !== -1) {
+            line(held.slice(0, cut));
+            held = held.slice(cut + 1);
+            cut = held.indexOf("\n");
+        }
+    };
+    /** A delta: written, and recorded as the part of the coming entry already shown. */
+    const say = (text) => { streamed += text; emit(text); };
+    const entry = (stored) => {
+        if (stored.type === "run.started") {
+            // Input with no `from` is what the caller just passed in. Echoing it says
+            // everything twice. Input *with* one came from somewhere else — a
+            // subagent's report, a peer, a person on a channel — and saying so is the
+            // only way that arrival is visible as itself.
+            if (stored.from) {
+                line(dim(`◦ from ${stored.from.kind} ${stored.from.id.slice(0, 8)} · ${oneLine(readable(stored.input), 72)}`));
+            }
+            return;
+        }
+        if (stored.type === "assistant") {
+            turns += 1;
+            const said = readable(stored.content);
+            if (said) {
+                const shown = streamed;
+                // Cleared first: `say` appends to it, and what matters is what had been
+                // streamed *before* this entry arrived.
+                streamed = "";
+                if (!shown)
+                    emit(said.endsWith("\n") ? said : `${said}\n`);
+                else if (said.startsWith(shown)) {
+                    const rest = said.slice(shown.length);
+                    if (rest)
+                        emit(rest.endsWith("\n") ? rest : `${rest}\n`);
+                    else if (open)
+                        emit("\n");
+                }
+                else {
+                    if (open)
+                        sink.write("\n");
+                    emit(said.endsWith("\n") ? said : `${said}\n`);
+                }
+            }
+            else {
+                streamed = "";
+            }
+            for (const call of stored.calls ?? []) {
+                // The name is recorded whatever the level: a result rendered later
+                // reads it, and a reader who turns detail up mid-run should not meet a
+                // call id where every other line has a name.
+                names.set(call.callId, call.name);
+                if (internal)
+                    line(dim(`→ ${call.name} ${oneLine(call.arguments, 72)}`));
+            }
+            return;
+        }
+        if (stored.type === "tool.started") {
+            clocks.set(stored.callId, now());
+            // At every level, unlike everything else about a call. A spinner is not
+            // an account of what the agent did — it leaves no trace, and it is the
+            // only thing between a reader and thirty seconds of silence.
+            running.add(stored.callId);
+            startTicker();
+            return;
+        }
+        if (stored.type === "tool.finished") {
+            running.delete(stored.callId);
+            if (!running.size)
+                stopTicker();
+            const at = clocks.get(stored.callId);
+            clocks.delete(stored.callId);
+            const name = names.get(stored.callId) ?? stored.callId.slice(0, 8);
+            const took = at === undefined ? "" : ` · ${seconds(now() - at)}`;
+            const body = oneLine(readable(stored.result.content), 64);
+            const failed = stored.result.isError === true;
+            // A success is the agent working; a failure is something the reader has
+            // to know about whatever they asked to be shown.
+            if (failed || internal) {
+                line(`${mark(failed ? "✗" : "✓", failed)} ${dim(`${name}${took}${body ? ` · ${body}` : ""}`)}`);
+            }
+            // `details` is the structured channel for an application's own UI and
+            // holds whatever that application put there — which may include a
+            // credential. Asked for explicitly it is shown; it is never volunteered.
+            if (debugging && stored.result.details !== undefined) {
+                line(dim(`  ${oneLine(JSON.stringify(stored.result.details), 96)}`));
+            }
+            return;
+        }
+        if (stored.type === "summary") {
+            if (internal)
+                line(dim(`· compacted through seq ${stored.replaces}`));
+        }
+        // `run.finished` is not rendered here. `finish` owns the last line, because
+        // `RunResult` carries what the entry cannot: what the run spent, on every
+        // outcome including the ones with no answer.
+    };
+    return {
+        update(next) {
+            if (next.type === "text.delta") {
+                say(next.text);
+                return;
+            }
+            if (next.type === "reasoning.delta") {
+                // Reasoning can outweigh the answer several times over, so it is behind
+                // `"detailed"` rather than dimmed and always present.
+                if (!debugging)
+                    return;
+                if (!thinking) {
+                    line(dim("· thinking"));
+                    thinking = true;
+                }
+                clearSpinner();
+                status(dim(next.text));
+                return;
+            }
+            // A harness that reports progress reports it several times per call, in
+            // whatever shape its protocol happens to use — ACP forwards its whole
+            // `session/update`. That is a debugging channel, not a reading one: the
+            // call itself is announced by the entry that carries it, and the name is
+            // not even known yet on the first of these. So it sits behind `"detailed"`
+            // beside `tool-call.delta`, for the same reason.
+            if (next.type === "tool.progress") {
+                if (!debugging)
+                    return;
+                const name = names.get(next.callId) ?? next.callId.slice(0, 8);
+                line(dim(`⋯ ${name} ${oneLine(JSON.stringify(next.data), 64)}`));
+                return;
+            }
+            // Arguments as they form are unparseable until complete and only one
+            // harness emits them, so they are worth nothing to a reader and
+            // everything to someone asking why a call came out the way it did.
+            if (next.type === "tool-call.delta") {
+                if (debugging)
+                    line(dim(`  ${next.callId.slice(0, 8)} ${oneLine(next.arguments, 64)}`));
+                return;
+            }
+            if (next.type === "entry")
+                entry(next.entry);
+        },
+        finish(result) {
+            running.clear();
+            stopTicker();
+            if (held) {
+                line(held);
+                held = "";
+            }
+            if (open) {
+                sink.write("\n");
+                open = false;
+            }
+            const spent = [
+                result.usage.inputTokens !== undefined ? `${round(result.usage.inputTokens)} in` : undefined,
+                result.usage.cacheReadTokens ? `${round(result.usage.cacheReadTokens)} cached` : undefined,
+                result.usage.outputTokens !== undefined ? `${round(result.usage.outputTokens)} out` : undefined,
+            ].filter((part) => part !== undefined);
+            // A count nobody reported is not a zero, so an absent one is left out
+            // rather than printed as 0.
+            const parts = [
+                seconds(now() - started),
+                `${turns} ${turns === 1 ? "turn" : "turns"}`,
+                ...spent,
+            ].join(" · ");
+            if (result.status === "failed") {
+                line(`${mark("✗", true)} ${dim(`failed (${result.error.code}): ${oneLine(result.error.message, 80)} · ${parts}`)}`);
+                return;
+            }
+            // `cancelled` is an ending nobody asked for, so it is said at every
+            // level that says anything. A clean completion is an accounting line.
+            if (result.status === "cancelled" || internal)
+                line(dim(`— ${result.status} · ${parts}`));
+        },
+    };
+}
+/**
+ * Render a run to its end, and answer what it did.
+ *
+ * The loop every application writes by hand, with the two things a hand-written
+ * one keeps getting wrong: everything the stream carries besides text, and an
+ * outcome taken from the result rather than from whatever happened to stream.
+ */
+export async function renderRun(run, sink) {
+    const renderer = createRenderer(sink);
+    for await (const update of run)
+        renderer.update(update);
+    const result = await run.result;
+    renderer.finish(result);
+    return result;
+}
+//# sourceMappingURL=render.js.map

package/dist/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A run, as lines someone can read.\n *\n * A root file rather than a module, and a projection rather than a port: this\n * is `textOf` one level out. `toMessages` folds committed entries into what a\n * model is shown; this folds the update stream into what a person is shown. No\n * adapter has to prove anything about it, so there is nothing here for a\n * conformance suite to hold, and nothing below it to rank against.\n *\n * **It is not a channel, and the difference is worth stating because it is\n * subtle.** A channel does three jobs: decide which session a person is talking\n * to, deliver a message exactly once, and put the result in a medium's own\n * shape. The first two are an application's — a mail thread maps to a session,\n * a webhook may arrive twice. Only the third is the same work for every medium,\n * and only the third is here. Email is a channel with no projection at all: it\n * sends `RunResult.output` and never looks at the stream. A terminal is the\n * other extreme — its identity is \"the one session\" and its delivery is a pipe\n * that cannot fail, so a terminal channel is *nothing but* this projection.\n *\n * **The answer and the stream are different things, and only one is a message.**\n * `RunResult.output` is what `finished` hands to `Delivery.input`: the same\n * `Content`, whether the recipient is a person or another session. The stream\n * is not a message and never becomes one — a `cancelled` or `failed` result has\n * no `output` field at all, so a run can stream a paragraph and produce nothing\n * that could be delivered.\n *\n * Showing that paragraph is not a mistake. Watching what an agent was saying\n * when it was cancelled is most of what debugging one is. What would be a\n * mistake is leaving the outcome implicit, so the text reads as an answer that\n * was never given — which is why `finish` always states it, and takes it from\n * the result rather than from whatever happened to stream.\n *\n * **`detail` is the knob that makes one projection serve every medium.** Three\n * levels, because what the knob is graduated in is the *internal stream* and\n * not the conversation: a tool call is the agent talking to itself, while a\n * message arriving from a subagent, a peer or a person is the conversation\n * happening. The log keeps those apart — one is an entry the loop wrote, the\n * other came through `enqueue` — so the projection does too.\n *\n * There is no level below `\"minimal\"`, and there was one. A medium with no\n * second channel says so by having no `status`, which drops the account\n * entirely; a `detail` that meant the same thing was a second way to state a\n * fact the `Sink` already stated. Failures are not behind a level either — an\n * agent that silently did nothing is the one outcome a reader cannot diagnose\n * from what they were shown.\n *\n * Two channels out, because they answer different questions. `write` carries\n * the answer, so redirecting it captures the answer and nothing else. `status`\n * carries what the agent did on the way — tools, provenance, what it spent.\n */\nimport type { AgentRun, RunResult } from \"./agent.js\";\nimport type { Update } from \"./harness/harness.js\";\nimport type { Content, ContentPart } from \"./content.js\";\nimport type { Stored, ToolCall, Usage } from \"./session/entry.js\";\nimport { textOf } from \"./content.js\";\n\nexport interface Sink {\n  /** The answer: assistant text, exactly as it streamed. */\n  write(text: string): void;\n  /**\n   * Everything else: tools, provenance, what the run spent.\n   *\n   * Omit it and that account is **dropped**, not folded into `write`. Falling\n   * back would break the one promise `write` makes — that it holds the answer\n   * and nothing else — for every caller who only wanted the answer and did not\n   * think to say so.\n   */\n  status?(line: string): void;\n  /** Enables colour and the elapsed-time ticker. A caller without a terminal leaves it off. */\n  tty?: boolean;\n  /**\n   * How much of the run to show.\n   *\n   * `\"minimal\"` is the conversation: the answer, input that arrived from\n   * somewhere else, and anything that failed. `\"standard\"` adds the internal\n   * stream — tool calls, their results, and what the run spent. `\"detailed\"`\n   * adds what it was thinking, arguments as they form, and the structured\n   * `details` a tool returned.\n   *\n   * For the answer and nothing whatever beside it, give a sink with no\n   * `status`.\n   */\n  detail?: \"minimal\" | \"standard\" | \"detailed\";\n  /**\n   * Marks a run being watched rather than driven — a subagent taken off the\n   * queue, most often. A labelled run has no answer channel: nobody asked it\n   * anything, so everything it says is an account of what the run it belongs\n   * to is doing, and all of it is prefixed and sent to `status`.\n   */\n  label?: string;\n  /** Milliseconds, for durations. Supplied by a test so its output is exact. */\n  now?(): number;\n}\n\n/**\n * Not exported, and that is the gate's doing rather than an oversight.\n *\n * `renderRun` is the whole of what a caller needs, and nothing here composes a\n * renderer by hand. A surface that pushes updates itself — an HTTP stream, a\n * Slack message it keeps editing — would want this, and it can be exported the\n * day one exists. Surface without a consumer is surface nobody is holding to\n * account.\n */\ninterface Renderer {\n  update(update: Update): void;\n  /** The outcome and what it spent. */\n  finish(result: RunResult): void;\n}\n\n/**\n * The one animation, and it is data rather than a dependency.\n *\n * Braille dots because they are one column wide in every terminal that has the\n * font and degrade to boxes rather than to a broken layout in the ones that do\n * not. Written to `status`, so the answer channel stays something a pipe can\n * read.\n */\nconst SPINNER = [\"⠋\", \"⠙\", \"⠹\", \"⠸\", \"⠼\", \"⠴\", \"⠦\", \"⠧\", \"⠇\", \"⠏\"] as const;\n\nconst DIM = \"\\x1b[2m\";\nconst RED = \"\\x1b[31m\";\nconst GREEN = \"\\x1b[32m\";\nconst RESET = \"\\x1b[0m\";\n\n/** One line, however long the thing being described is. */\nconst oneLine = (text: string, limit = 96): string => {\n  const flat = text.replace(/\\s+/g, \" \").trim();\n  return flat.length > limit ? `${flat.slice(0, limit - 1)}…` : flat;\n};\n\nconst round = (count: number): string =>\n  count >= 1000 ? `${(count / 1000).toFixed(1)}k` : `${count}`;\n\nconst seconds = (ms: number): string => `${(ms / 1000).toFixed(1)}s`;\n\n/**\n * Content as the model sees it, plus a marker for every part it cannot.\n *\n * `textOf` drops images, files and opaque blocks, which is right for a model\n * and wrong for a person: a screen showing less than the log holds, silently,\n * is the omission this package refuses everywhere else.\n */\nfunction readable(content: Content): string {\n  if (typeof content === \"string\") return content;\n  return content.map((part: ContentPart) =>\n    part.type === \"text\" ? part.text\n      : part.type === \"image\" ? `[image ${part.mediaType}]`\n      : part.type === \"file\" ? `[file ${part.name ?? part.mediaType}]`\n      : `[opaque ${part.provider}]`).join(\"\\n\");\n}\n\nfunction createRenderer(sink: Sink): Renderer {\n  const status = sink.status ?? (() => {});\n  const detail = sink.detail ?? \"standard\";\n  const debugging = detail === \"detailed\";\n  /** The agent talking to its own tools, as opposed to the conversation. */\n  const internal = debugging || detail === \"standard\";\n  const now = sink.now ?? (() => Date.now());\n  const label = sink.label ? `${sink.label} ` : \"\";\n  const started = now();\n\n  const dim = (text: string) => (sink.tty ? `${DIM}${text}${RESET}` : text);\n  const mark = (glyph: string, bad: boolean) =>\n    sink.tty ? `${bad ? RED : GREEN}${glyph}${RESET}` : glyph;\n\n  /** Names by call id. A tool entry carries only the id; the assistant entry above holds the name. */\n  const names = new Map<string, string>();\n  /** When each call started, so a result can say how long it took. */\n  const clocks = new Map<string, number>();\n  /**\n   * What has been streamed since the last assistant entry.\n   *\n   * The harnesses disagree about deltas — some stream tokens, some emit one\n   * delta per whole message, and some emit none at all. The entry stream is\n   * the one channel every harness fills, so\n   * the entry decides what is shown and the deltas decide how much of it\n   * already has been.\n   *\n   * The rule the port does not state, and this therefore does not assume:\n   * deltas preceding an assistant entry *ought* to concatenate to its text.\n   * Where they do, the remainder is printed and nothing appears twice. Where\n   * they are absent, the whole entry is printed. Where they are neither — a\n   * harness that streamed something else, or stopped halfway — the entry is\n   * printed in full on a fresh line, because showing a reader the same words\n   * twice is a smaller failure than silently dropping the half nobody streamed.\n   */\n  let streamed = \"\";\n  let turns = 0;\n  /** Whether the last thing written ended mid-line, so a status line can open a fresh one. */\n  let open = false;\n  let thinking = false;\n\n  /**\n   * The calls in flight, and the one status line describing all of them.\n   *\n   * One ticker for the renderer rather than one per call. A tool call is not\n   * exclusive — a harness may start four at once, and Pi does — and a per-call\n   * interval meant each `tool.started` overwrote the last without clearing it:\n   * the orphans kept drawing to the same line for the life of the process,\n   * fighting each other and interleaving with committed lines. A terminal has\n   * one status line, so there is one thing drawing it.\n   *\n   * No `at` is kept here. `clocks` already holds when each call started, and a\n   * second copy is a second answer.\n   */\n  const running = new Set<string>();\n  let ticker: ReturnType<typeof setInterval> | undefined;\n  /** Whether the status line currently holds a spinner that must be erased before anything else. */\n  let drawn = false;\n\n  /**\n   * Erase the spinner, leaving the cursor at the start of a clean line.\n   *\n   * Called before *every* write, because `\\r` returns to the start of whatever\n   * line is current and half a streamed sentence is as much a casualty as a\n   * status line. The ticker redraws on its next tick if work is still in\n   * flight, so this costs nothing but a frame.\n   */\n  const clearSpinner = () => {\n    if (!drawn) return;\n    drawn = false;\n    status(\"\\r\\x1b[K\");\n  };\n\n  const line = (text: string) => {\n    clearSpinner();\n    if (open) { sink.write(\"\\n\"); open = false; }\n    status(`${label}${text}\\n`);\n  };\n\n  const stopTicker = () => {\n    if (ticker) { clearInterval(ticker); ticker = undefined; }\n    clearSpinner();\n  };\n\n  /**\n   * What is running, in the width of one line.\n   *\n   * The oldest call names itself and carries the clock, because it is the one a\n   * reader is waiting on; the rest are a count. Naming all four would be a\n   * line that changes width every time one finishes.\n   */\n  const inFlight = (glyph: string): string => {\n    const oldest = [...running].sort((a, b) => (clocks.get(a) ?? 0) - (clocks.get(b) ?? 0))[0];\n    if (oldest === undefined) return \"\";\n    const name = names.get(oldest) ?? oldest.slice(0, 8);\n    const others = running.size - 1;\n    return `${label}${glyph} ${name}${others ? ` +${others}` : \"\"} ${seconds(now() - (clocks.get(oldest) ?? now()))}`;\n  };\n\n  /**\n   * The one piece of cursor control in this file, and the only reason a long\n   * command is not silence. Unref'd so it can never hold a process open.\n   *\n   * It does not draw over an open line: `say` leaves the cursor mid-sentence\n   * while text streams, and `\\r` there would eat the sentence. Nothing is lost\n   * — the next tick after the newline draws it.\n   */\n  const startTicker = () => {\n    if (ticker || !sink.tty) return;\n    let frame = 0;\n    ticker = setInterval(() => {\n      if (open || !running.size) return;\n      const text = inFlight(SPINNER[frame++ % SPINNER.length]!);\n      if (!text) return;\n      drawn = true;\n      status(`\\r${DIM}${text}${RESET}\\x1b[K`);\n    }, 90);\n    ticker.unref?.();\n  };\n\n  /** Partial line held back while a labelled run streams, so the prefix stays whole. */\n  let held = \"\";\n\n  /**\n   * Write text for the reader. The primitive; `say` is the streaming door to it.\n   *\n   * Only a delta counts as *streamed*. An entry printed through here must not\n   * be added to `streamed`, or its own words become the \"already shown\" prefix\n   * the next entry is measured against — and since a second turn's text does\n   * not begin with a first turn's, `startsWith` failed and the whole turn was\n   * printed again under the half that had already streamed.\n   */\n  const emit = (text: string) => {\n    clearSpinner();\n    if (thinking) { thinking = false; }\n    if (!sink.label) {\n      sink.write(text);\n      open = !text.endsWith(\"\\n\");\n      return;\n    }\n    // A prefix cannot be applied to half a line, so a labelled run buffers to\n    // the newline. Nothing is lost: `finish` flushes whatever is left.\n    held += text;\n    let cut = held.indexOf(\"\\n\");\n    while (cut !== -1) {\n      line(held.slice(0, cut));\n      held = held.slice(cut + 1);\n      cut = held.indexOf(\"\\n\");\n    }\n  };\n\n  /** A delta: written, and recorded as the part of the coming entry already shown. */\n  const say = (text: string) => { streamed += text; emit(text); };\n\n  const entry = (stored: Stored) => {\n    if (stored.type === \"run.started\") {\n      // Input with no `from` is what the caller just passed in. Echoing it says\n      // everything twice. Input *with* one came from somewhere else — a\n      // subagent's report, a peer, a person on a channel — and saying so is the\n      // only way that arrival is visible as itself.\n      if (stored.from) {\n        line(dim(`◦ from ${stored.from.kind} ${stored.from.id.slice(0, 8)} · ${oneLine(readable(stored.input), 72)}`));\n      }\n      return;\n    }\n    if (stored.type === \"assistant\") {\n      turns += 1;\n      const said = readable(stored.content);\n      if (said) {\n        const shown = streamed;\n        // Cleared first: `say` appends to it, and what matters is what had been\n        // streamed *before* this entry arrived.\n        streamed = \"\";\n        if (!shown) emit(said.endsWith(\"\\n\") ? said : `${said}\\n`);\n        else if (said.startsWith(shown)) {\n          const rest = said.slice(shown.length);\n          if (rest) emit(rest.endsWith(\"\\n\") ? rest : `${rest}\\n`);\n          else if (open) emit(\"\\n\");\n        } else {\n          if (open) sink.write(\"\\n\");\n          emit(said.endsWith(\"\\n\") ? said : `${said}\\n`);\n        }\n      } else {\n        streamed = \"\";\n      }\n      for (const call of stored.calls ?? []) {\n        // The name is recorded whatever the level: a result rendered later\n        // reads it, and a reader who turns detail up mid-run should not meet a\n        // call id where every other line has a name.\n        names.set(call.callId, call.name);\n        if (internal) line(dim(`→ ${call.name} ${oneLine(call.arguments, 72)}`));\n      }\n      return;\n    }\n    if (stored.type === \"tool.started\") {\n      clocks.set(stored.callId, now());\n      // At every level, unlike everything else about a call. A spinner is not\n      // an account of what the agent did — it leaves no trace, and it is the\n      // only thing between a reader and thirty seconds of silence.\n      running.add(stored.callId);\n      startTicker();\n      return;\n    }\n    if (stored.type === \"tool.finished\") {\n      running.delete(stored.callId);\n      if (!running.size) stopTicker();\n      const at = clocks.get(stored.callId);\n      clocks.delete(stored.callId);\n      const name = names.get(stored.callId) ?? stored.callId.slice(0, 8);\n      const took = at === undefined ? \"\" : ` · ${seconds(now() - at)}`;\n      const body = oneLine(readable(stored.result.content), 64);\n      const failed = stored.result.isError === true;\n      // A success is the agent working; a failure is something the reader has\n      // to know about whatever they asked to be shown.\n      if (failed || internal) {\n        line(`${mark(failed ? \"✗\" : \"✓\", failed)} ${dim(`${name}${took}${body ? ` · ${body}` : \"\"}`)}`);\n      }\n      // `details` is the structured channel for an application's own UI and\n      // holds whatever that application put there — which may include a\n      // credential. Asked for explicitly it is shown; it is never volunteered.\n      if (debugging && stored.result.details !== undefined) {\n        line(dim(`  ${oneLine(JSON.stringify(stored.result.details), 96)}`));\n      }\n      return;\n    }\n    if (stored.type === \"summary\") {\n      if (internal) line(dim(`· compacted through seq ${stored.replaces}`));\n    }\n    // `run.finished` is not rendered here. `finish` owns the last line, because\n    // `RunResult` carries what the entry cannot: what the run spent, on every\n    // outcome including the ones with no answer.\n  };\n\n  return {\n    update(next) {\n      if (next.type === \"text.delta\") { say(next.text); return; }\n      if (next.type === \"reasoning.delta\") {\n        // Reasoning can outweigh the answer several times over, so it is behind\n        // `\"detailed\"` rather than dimmed and always present.\n        if (!debugging) return;\n        if (!thinking) { line(dim(\"· thinking\")); thinking = true; }\n        clearSpinner();\n        status(dim(next.text));\n        return;\n      }\n      // A harness that reports progress reports it several times per call, in\n      // whatever shape its protocol happens to use — ACP forwards its whole\n      // `session/update`. That is a debugging channel, not a reading one: the\n      // call itself is announced by the entry that carries it, and the name is\n      // not even known yet on the first of these. So it sits behind `\"detailed\"`\n      // beside `tool-call.delta`, for the same reason.\n      if (next.type === \"tool.progress\") {\n        if (!debugging) return;\n        const name = names.get(next.callId) ?? next.callId.slice(0, 8);\n        line(dim(`⋯ ${name} ${oneLine(JSON.stringify(next.data), 64)}`));\n        return;\n      }\n      // Arguments as they form are unparseable until complete and only one\n      // harness emits them, so they are worth nothing to a reader and\n      // everything to someone asking why a call came out the way it did.\n      if (next.type === \"tool-call.delta\") {\n        if (debugging) line(dim(`  ${next.callId.slice(0, 8)} ${oneLine(next.arguments, 64)}`));\n        return;\n      }\n      if (next.type === \"entry\") entry(next.entry);\n    },\n\n    finish(result) {\n      running.clear();\n      stopTicker();\n      if (held) { line(held); held = \"\"; }\n      if (open) { sink.write(\"\\n\"); open = false; }\n\n      const spent = [\n        result.usage.inputTokens !== undefined ? `${round(result.usage.inputTokens)} in` : undefined,\n        result.usage.cacheReadTokens ? `${round(result.usage.cacheReadTokens)} cached` : undefined,\n        result.usage.outputTokens !== undefined ? `${round(result.usage.outputTokens)} out` : undefined,\n      ].filter((part): part is string => part !== undefined);\n\n      // A count nobody reported is not a zero, so an absent one is left out\n      // rather than printed as 0.\n      const parts = [\n        seconds(now() - started),\n        `${turns} ${turns === 1 ? \"turn\" : \"turns\"}`,\n        ...spent,\n      ].join(\" · \");\n\n      if (result.status === \"failed\") {\n        line(`${mark(\"✗\", true)} ${dim(`failed (${result.error.code}): ${oneLine(result.error.message, 80)} · ${parts}`)}`);\n        return;\n      }\n      // `cancelled` is an ending nobody asked for, so it is said at every\n      // level that says anything. A clean completion is an accounting line.\n      if (result.status === \"cancelled\" || internal) line(dim(`— ${result.status} · ${parts}`));\n    },\n  };\n}\n\n/**\n * Render a run to its end, and answer what it did.\n *\n * The loop every application writes by hand, with the two things a hand-written\n * one keeps getting wrong: everything the stream carries besides text, and an\n * outcome taken from the result rather than from whatever happened to stream.\n */\nexport async function renderRun(run: AgentRun, sink: Sink): Promise<RunResult> {\n  const renderer = createRenderer(sink);\n  for await (const update of run) renderer.update(update);\n  const result = await run.result;\n  renderer.finish(result);\n  return result;\n}\n\n/** Re-exported so a caller composing a sink imports one thing. */\nexport type { Update, RunResult, Usage, ToolCall };\n"]}

package/dist/store/adapters/sqlite.js

@@ -1,5 +1,5 @@
 import { err, ok } from "../../result.js";
-const schema = `
+const tables = `
   CREATE TABLE IF NOT EXISTS sessions (
     id            TEXT PRIMARY KEY,
     agent_id      TEXT NOT NULL,
@@ -25,6 +25,20 @@ const schema = `
     at          TEXT NOT NULL,
     PRIMARY KEY (session_id, sender, delivery_id)
   );
+`;
+/**
+ * Columns added after a table had already shipped.
+ *
+ * `CREATE TABLE IF NOT EXISTS` is a no-op against a table that exists, so a
+ * column added later never appears in a database made by an older build — and
+ * the first index over it fails with a raw `SQLiteError` from inside `bun:sqlite`,
+ * which is no way to meet a store whose whole promise is that the log survives.
+ * Additive only: a column is added, nothing is dropped, rewritten or lost.
+ */
+const added = [
+    { table: "sessions", column: "running_since", type: "TEXT" },
+];
+const indexes = `
   CREATE INDEX IF NOT EXISTS sessions_by_key ON sessions (key, updated_at DESC, id DESC);
   CREATE INDEX IF NOT EXISTS sessions_runnable ON sessions (updated_at) WHERE pending <> '[]';
   DROP INDEX IF EXISTS sessions_stranded; -- sessions_interrupted under its former name
@@ -59,7 +73,16 @@ export function createSqliteStore(input) {
     const database = input.database;
     const claimMs = input.claimMs ?? DEFAULT_CLAIM_MS;
     const deliveryMemoryMs = input.deliveryMemoryMs ?? DEFAULT_DELIVERY_MEMORY_MS;
-    database.exec(schema);
+    // Tables, then the columns an older build's tables lack, then the indexes —
+    // which is the only order that works, because an index may be over a column
+    // the migration is about to add.
+    database.exec(tables);
+    for (const { table, column, type } of added) {
+        const present = database.query(`SELECT 1 FROM pragma_table_info(?) WHERE name = ?`).all(table, column);
+        if (!present.length)
+            database.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+    }
+    database.exec(indexes);
     const one = (sql, parameters) => database.query(sql).all(...parameters)[0];
     const run = (sql, parameters) => { database.query(sql).run(...parameters); };
     const notFound = (sessionId) => ({ code: "not-found", message: `No session ${sessionId}`, retryable: false });