What changed, release by release.

Types

• changed ButtonProps type extended

  The props of Button, every surface's pressable leaf: an address, a label, the closure a press runs, and the label styles a hover overrides.

      plain?: true;    dimColor?: boolean;    variant?: 'primary' | 'secondary';    role?: 'dismiss';    autoFocus?: true;    hover?: TextHoverProps;    onPress: () => void;

• changed RenderElement type extended

  What a render hook returns, and what next(e) resolves to: a plain-data tree of elements (a Box or Text is a StyledElement), strings as children.

          plain?: true;        dimColor?: TextProps['dimColor'];        variant?: ButtonProps['variant'];        role?: ButtonProps['role'];        autoFocus?: true;    };    press: {

Types

• changed ButtonProps type extended

  The props of Button, every surface's pressable leaf: an address, a label, the closure a press runs, and the label styles a hover overrides.

      action?: string;    plain?: true;    dimColor?: boolean;    variant?: 'primary' | 'secondary';    autoFocus?: true;    hover?: TextHoverProps;    onPress: () => void;

• changed PromptFillResult type extended

  What a prompt.fill hook returns and what next(e) resolves to: whether the text went into the prompt box.

  export type PromptFillResult = {    isFilled: boolean;    refusal?: 'no_composer' | 'dialog';};

• changed PromptFilled type extended

  What $.prompt.fill resolves to: whether the box took the text, and the box afterwards (PromptBox) as the caller's own $.prompt.read() reads it.

  export type PromptFilled = {    isFilled: boolean;    refusal?: 'no_composer' | 'dialog';    text: string;    cursor: number;};

• changed RenderElement type extended

  What a render hook returns, and what next(e) resolves to: a plain-data tree of elements (a Box or Text is a StyledElement), strings as children.

          action?: string;        plain?: true;        dimColor?: TextProps['dimColor'];        variant?: ButtonProps['variant'];        autoFocus?: true;    };    press: {

• changed SessionReceiveEvent type extended

  An external-event wake the delivery's text parsed as (a GitHub relay event, a signal's notice): the envelope's attributes and its JSON body.

  export type SessionReceiveEvent = {    source: string;    kind: string;    from?: string;    data: Record<string, unknown>;    untrustedKeys: readonly string[];};

The engine

• added $.session.version verb

  Returns the version of the engine the session runs on, the release it is built from, and when it was built.

• added $.state noun

  Named values held by the host for the session, each with a version: plain data that survives a hot reload of the plugin's code.

• added $.state.get verb

  Resolves the value under ref and the version it stands at; a value never written is undefined at version 0.

• added $.state.set verb

  Writes value under ref, which must be this plugin's own; the sites that read it while drawing are drawn again, at the redraw rate.

Events

• added session.version event

  The argument of $.session.version().

• added state.get event

  The argument of $.state.get(ref): the reference itself, plugin, key and a family member's id; identity, pinned.

• added state.set event

  The argument of $.state.set(ref, value, { ifVersion }): the reference, the value, the condition, and previous, what stood there (the host's).

Types

• changed OpValueOf type extended

  What each call on $ answers (the value of its event's result), by event name.

      'session.surfaces': readonly RenderSurface[];    'session.authorize': SessionAuthorization;    'session.usage': SessionUsage;    'session.version': SessionVersion;    'turn.abort': void;    'prompt.read': PromptBox;    'tool.list': ToolInfo[];…    'store.set': void;    'store.delete': void;    'store.keys': string[];    'state.get': StateRead;    'state.set': StateSetResult;    'clock.now': number;    'clock.sleep': void;    'clock.after': void;

• changed PluginRegisterUses type extended

  What a hooks module uses, as the host scanned its source before loading it: the same lists claude plugin validate prints and the host's rule reads.

          reads: readonly string[];        writes: readonly string[];    };    state?: {        reads: readonly StateName[];        writes: readonly StateName[];    };};

• added Atom type

  A named value with its initial, as atom(ref, initial) makes it: read, it is never undefined; while nothing is written it reads as the initial.

• added AtomFunction type

  atom(ref, initial): a named value with its initial, so a read is never undefined; given { shape }, for a key declared Shaped<T>.

• added AtomOptions type

  The options of atom: shape, a tag the value is kept under, so a reload of the plugin's code that names another tag finds the value absent.

• added DeclaredEvents type

  The state events of each declared value in a union of [plugin, key] pairs, one variant per pair (it distributes), so a matcher narrows e.

• added DeclaredEventsOf type

  e of state.get and of state.set for one declared value: its typed reference, and for a write the change, of the declared type.

• added DeclaredPair type

  Every named value the enabled contracts declare, as one union of [plugin, key] pairs; never while PluginState is empty.

• added DeclaredStateChange type

  What a state.set on one declared value carries beside its reference: the value being written and the one that stood there, of the declared type.

• added DeriveFunction type

  derive(sources, fn): a value computed from atoms and references, cached by their versions: read runs fn again only when one moved.

• added Derived type

  A value computed from other values, as derive(sources, fn) makes it: read runs fn again only when a source's version moved.

• added MemberOfFunction type

  memberOf(family, e): the member of a family for the instance being drawn, keyed by e.requestId; of an atom over a family, that member's.

• added PluginState interface

  The named values plugins keep in the session ($.state), by plugin name then key, for declaration merging; empty by default.

• added ReadFunction type

  read($, source): the value of an atom (its initial while absent), of a derived value, or under a plain reference; one $.state.get per value.

• added SessionVersion type

  What $.session.version() answers: the version of the engine the session runs on, the release that version is built from, and when it was built.

• added Shaped type

  A value kept with a shape tag, as an atom given { shape } keeps it: a reload whose code names another tag reads the value as absent.

• added ShapedValue type

  What an atom given a shape reads and takes for a key declared Shaped<T>: T; never for a key declared otherwise, so that atom does not compile.

• added SourceValues type

  The values derive's function receives for its sources, in their order: an atom's or a derived value's own, a plain reference's or undefined.

• added StateAddress type

  Which named value a $.state call is about, as it crosses to the host: the owning plugin, the key, and a family member's id.

• added StateDollar type

  What the state library's read and update take of $: its state noun, on which they make the calls a hook would make itself.

• added StateFamily type

  A key of PluginState that holds one value of type T per id (one per drawn row, per worker): its reference must carry id: string.

• added StateGetEvent type

  e of state.get: one variant per value a contract declares, so a matcher on plugin and key narrows it; the untyped address while none does.

• added StateName type

  Which named value: the plugin that owns it and its key there, both literals where a contract declares the value.

• added StateRead type

  What $.state.get answers: the value and the version it stands at; a value never written is undefined at version 0.

• added StateRef type

  A typed reference to one named value: the owning plugin and the key, both literals, and for a StateFamily key the member's id.

• added StateSetEvent type

  e of state.set: one variant per value a contract declares, so a matcher on plugin and key narrows e.value; the untyped write while none does.

• added StateSetOptions type

  The options of $.state.set: ifVersion makes the write conditional on the value still standing at that version (compare-and-set).

• added StateSetResult type

  What $.state.set answers: whether the write landed, and the version the value stands at now (a landed write's own, a missed one's the current).

• added StateValue type

  The type of the value under key K of plugin P, as its contract declares it in PluginState; a StateFamily's member type for a family key.

• added StateWrite type

  A $.state.set as it crosses to the host and as its hooks see it when no contract declares the value: the address, the value, and the condition.

• added UpdateFunction type

  update($, target, fn): reads the value, applies fn here in the plugin's environment, writes with ifVersion, and tries again on a miss.

• added atom const

  A named value with its initial: read answers the initial while nothing is written, so never undefined. Pure; runs in the plugin's environment.

• added derive const

  A value computed from atoms and references, cached by their versions.

• added memberOf const

  A family's member for the instance being drawn, keyed by e.requestId.

• added read const

  Reads an atom, a derived value or a reference through $.state.get; while a ui.render hook draws, that subscribes the drawing.

• added update const

  Reads, applies fn in the plugin's environment, writes with ifVersion, and tries again on a miss: what a handler closure calls.

The engine

• changed $.model.complete verb may break

  Runs one text completion through the session's own API client and resolves a result: the reply's text and cost, or why there is no text.

  (request: ModelCompleteRequest) => Promise<string>(request: ModelCompleteRequest) => Promise<ModelCompleteResult>

• changed $.model.fork verb may break

  Runs one tool-less completion over the session's OWN transcript as the main thread last sent it, so the API serves that prefix from its cache.

  (request: ModelForkRequest) => Promise<ModelForkResult | null>(request: ModelForkRequest) => Promise<ModelForkResult>

• changed $.session.messages verb may break

  Returns the transcript so far, one SessionMessage per user or assistant message; progress rows, $.ui.log lines and notices are not messages.

  () => Promise<SessionMessage[]>SessionMessagesCall

• changed $.ui.open verb may break

  Opens a pane, a framed region the surface places and this plugin draws by hooking ui.render for { component: "Pane" }; says if it is drawn.

  (pane: PaneOpenArgs) => Promise<void>(pane: PaneOpenArgs) => Promise<UiOpenResult>

• added $.process.spawn verb

  Starts a command on the host by its argument vector (no shell) and streams what it writes, piece by piece, then how it ended.

• added $.session.send verb

  Sends a plain-text message to another agent or session: the event session.send, the model's SendMessage tool's own call and delivery.

• added $.ui.copy verb

  Puts text on the clipboard of a surface the session draws on, as the DOM's navigator.clipboard.writeText, and says whether it took.

Events

• changed session.messages event may break

  The argument of $.session.messages(args): {} for the main conversation, { agentId } for one of its agents, as for the form.

  NoArgsSessionMessagesArgs

• added process.spawn event

  The argument of $.process.spawn(request): the request itself.

• added session.send event

  Fires when a plain-text message is about to leave this conversation for another agent or session (the SendMessage tool, or $.session.send).

• added session.send result

  { isDelivered: true }, or { isDelivered: false, reason }.

• added ui.copy event

  The argument of $.ui.copy({ text, surface }), surface filled with the session's first when left out; rewritable, deniable, answerable.

Types

• removed ContextApiUsage type breaking

  The token counts the last API response of the live window reported, as the API spells them; the breakdown's Messages row is reconciled to it.

• removed ModelForkUsage type breaking

  What one fork cost, as the API counted it: the four token counts of the fork's completions summed.

• changed ChunkOf type extended

  The chunk type of each streaming event, by name: what its stream yields.

  export type ChunkOf = {    'turn.step': TurnStepChunk;    'process.spawn': ProcessSpawnChunk;};

• changed Engine type may break

  What a test holds as $, the engine's own: every call on it is made as the REPL, the query loop and the render sites make theirs, over every plugin.

  export type Engine = {    [N in keyof EventCalls]: N extends 'ui' ? EngineNoun<N> & EnginePress & EngineMount : EngineNoun<N>;    [N in keyof EventCalls]: N extends 'ui' ? EngineNoun<N> & EnginePress & EngineInput & EngineSelect & EngineMount : EngineNoun<N>;} & {    classic: EngineClassic;};

• changed EventCalls type extended

  The engine's own events as calls on $, one signature each: $.<noun>.<event>(input) resolves to its result, or to its stream.

      session: {        start: (input: SessionStartInput) => Promise<SessionStartResult>;        receive: (input: SessionReceiveInput) => Promise<SessionReceiveResult>;        send: (input: SessionSendArgs) => Promise<SessionSendResult>;        compact: (input?: SessionCompactArgs) => Promise<SessionCompactResult>;        attach: (input: SessionAttachInput) => Promise<SessionAttachResult>;        detach: (input: SessionDetachInput) => Promise<SessionDetachResult>;

• changed ModelCompleteRequest type extended

  What $.model.complete takes.

      prompt: string;    system?: string;    maxTokens?: number;    effort?: ModelEffort;    timeoutMs?: number;};

• changed ModelForkResult type may break

  What $.model.fork resolves to: a completion's result (ModelCompleteResult) or that there was nothing to fork yet.

  export type ModelForkResult = {    text: string;    usage: ModelForkUsage;export type ModelForkResult = ModelCompleteResult | {    isAnswered: false;    reason: 'nothing-to-fork';};

• changed OpValueOf type may break

  What each call on $ answers (the value of its event's result), by event name.

  export type OpValueOf = {    'model.complete': string;    'model.complete': ModelCompleteResult;    'model.classify': string | undefined;    'model.fork': ModelForkResult | null;    'model.fork': ModelForkResult;    'audio.play': void;    'audio.speak': SpeakResult;    'mcp.call': McpToolResult;…    'session.model': string;    'session.turns': number;    'session.id': string;    'session.messages': SessionMessage[];    'session.messages': SessionMessagesValue;    'session.repo': SessionRepo | null;    'session.surface': RenderSurface | null;    'session.surfaces': readonly RenderSurface[];…    'ui.log': void;    'ui.notice': void;    'ui.invalidate': void;    'ui.open': void;    'ui.open': UiOpenResult;    'ui.close': void;    'ui.panes': readonly UiPane[];    'ui.copy': UiCopyResult;    'ui.blit': UiBlitResult;    'fs.read': string | FsBytes;    'fs.write': void;…    'clock.every': void;    'http.fetch': HttpResponse;    'process.run': ProcessRunResult;    'process.spawn': ProcessSpawnResult;    'settings.read': Settings;    'env.get': string | undefined;    'env.set': void;

• changed SessionCompacted type extended

  A compaction that stands: the conversation as it reads afterwards, and the counts and request usage the engine recorded when it was the one compacting.

      messages: readonly SessionMessage[];    tokensBefore?: number;    tokensAfter?: number;    usage?: ModelUsage;    skip?: undefined;};

• changed SessionContextBreakdown type may break

  The context window broken down as /context breaks it down: the rows, the grid and the lists beneath it, in the SDK's get_context_usage shape.

      skills?: ContextSkills;    autoCompactThreshold?: number;    isAutoCompactEnabled: boolean;    apiUsage: ContextApiUsage | null;    apiUsage: ModelUsage | null;};

• changed SessionReceiveInput type extended

  The input of session.receive: one inbound delivery, sanitized, before it is queued (a relay's event, a peer's message, a message for an agent).

      origin: SessionReceiveOrigin;    text: string;    event?: SessionReceiveEvent;    agentId?: string;};

• changed SessionReceiveOrigin type may break

  Where an inbound delivery came from, as the bridge classified it from the server's stamps: prompt.submit's e.origin, less what never arrives.

  export type SessionReceiveOrigin = {    kind: 'bridge' | 'task-notification' | 'scheduled-trigger' | 'peer' | 'peer-send-message' | 'projects-relay' | 'slack-ping' | 'unclassified';    kind: 'bridge' | 'task-notification' | 'scheduled-trigger' | 'peer-send-message' | 'projects-relay' | 'slack-ping' | 'unclassified';} | {    kind: 'peer' | 'coordinator';    plugin?: string;} | {    kind: 'peer' | 'coordinator';    plugin?: string;    teammate: string;    isVerified: boolean;};

• changed SessionUsage type extended

  What $.session.usage() answers: when the session began, the context window's fill, the account's rate-limit windows and the session's cost.

  export type SessionUsage = {    startedAt: number;    context: SessionContextUsage;    rateLimits: SessionRateLimit[];    cost?: SessionCost;

• changed StreamNext type may break

  The rest of the chain as a hook on a streaming event receives it: Next, except that next(e) is the stream beneath (HookStream), not a promise.

  export type StreamNext<N extends StreamingEventName = StreamingEventName, E = Args<N>, O = NextResult<N>, S extends {export type StreamNext<N extends StreamingEventName = StreamingEventName, E = Args<N>, O = EventResult<N>, S extends {    [K in N]?: unknown;} = {    [K in N]: Args<K>;

• changed StreamingEventName type may break

  The events that stream: their hooks are async generators, next(e) is the stream of everything beneath, and the result is what it returns.

  export type StreamingEventName = 'turn.step';export type StreamingEventName = 'turn.step' | 'process.spawn';

• changed ToolCallResult type extended

  What a tool.call hook returns and what next(e) and $.tool.call(input) resolve to: the tool's result ({ result, context? }) or { deny }.

      ref?: undefined;    text?: undefined;    isError?: undefined;    isReadOnly?: undefined;} | {    result: ToolResultOf<Name>;    context?: readonly string[];    ref?: number;    text?: string;    isReadOnly?: true;    isError?: undefined;    deny?: undefined;} | {…    text?: string;    ref?: number;    context?: readonly string[];    isReadOnly?: true;    deny?: undefined;};

• changed ToolUseSummary type extended

  One tool_use block of an assistant message, with its outcome once the transcript holds the call's tool_result (paired by tool_use_id).

      result?: unknown;    text?: string;    isError?: true;    agentId?: string;    durationMs?: number;};

• changed TurnUsage type may break

  What a model turn, or one response inside it, cost as the API reported it: the four token counts (ModelUsage) and the model's id.

  export type TurnUsage = ModelForkUsage & {export type TurnUsage = ModelUsage & {    model: string;};

• added ApiContentBlock type

  One content block of an ApiMessage: type names its kind (text, tool_use, tool_result, image, document, thinking, ...).

• added ApiMessage type

  One message of the conversation in Messages API form, as $.session.messages({ as: "api" }) returns it.

• added ClassicEvent type

  A classic hook event the engine raises on its own, by its own name (SessionStart, Stop): all but PreToolUse, which rides tool.call.

• added ClassicFields type

  What $.classic.<Event> takes: the event's own fields as its hook sees them on e, less what the engine stamps at every call site.

• added EngineClassic type

  The classic (settings) hook events as the engine raises them: each a call running the classic.<Event> chain over every plugin hooked on it.

• added EngineInput type

  A surface typing into an Input a test rendered: the ui.input chain over every plugin hooked on it, the Input's own handler last.

• added EngineSelect type

  A surface picking an option of a Select a test rendered: the ui.select chain over every plugin hooked on it, the Select's own onSelect last.

• added InputTarget type

  What $.ui.input takes: the plugin whose hook drew the Input, its key, the field's text, which input it is, instance and surface when several.

• added ModelApiError type

  Which kind of API failure ended a model call (a completion, a fork), in the word Claude Code classifies every API error with (StopFailure's).

• added ModelCompleteResult type

  What one model call resolves to: the reply when the model answered (isAnswered), else which of three things left it without text (reason).

• added ModelEffort type

  How hard a request asks the model to think, by the levels the engine and turn.step name: low to max, xhigh between high and max.

• added ModelUsage type

  What one model call cost, as the API counted it: the four token counts in the API's spelling, summed over the call's responses when it made several.

• added ProcessSpawnChunk type

  One piece of a spawned child's output as $.process.spawn streams it: which pipe it came from, and the text.

• added ProcessSpawnRequest type

  The argument of $.process.spawn(request), and the e its hooks see: the command by its argument vector and how the child is started.

• added ProcessSpawnResult type

  How a spawned child ended, as the stream of $.process.spawn returns it once every piece has been read: its exit code, or the signal that did it.

• added SelectTarget type

  What $.ui.select takes: the plugin whose hook drew the Select, its key, the picked option's value, instance and surface when several.

• added SessionMessagesAgentArgs type

  A $.session.messages call for the rows (SessionMessage) of the main conversation or of one agent's: agentId alone, no as.

• added SessionMessagesApiArgs type

  A $.session.messages call for the Messages API form (ApiMessage) of the main conversation or, with agentId, of one of this session's agents'.

• added SessionMessagesApiResult type

  What $.session.messages({ as: "api", agentId }) resolves to: the agent's conversation as ApiMessage, or { deny } (SessionMessagesDeny).

• added SessionMessagesArgs type

  What $.session.messages(args) takes and a session.messages hook reads on e: whose conversation (agentId) and in which form (as).

• added SessionMessagesCall type

  $.session.messages: the main conversation's rows with no argument, with { as: "api" } its Messages API form; with agentId an agent's, or deny.

• added SessionMessagesDeny type

  What $.session.messages({ agentId }) resolves to when the id names no conversation this session can read: why not, in deny.

• added SessionMessagesMainApiArgs type

  A $.session.messages({ as: "api" }) call naming no agent: the main conversation, whose answer is always the messages (ApiMessage).

• added SessionMessagesResult type

  What $.session.messages({ agentId }) resolves to: the messages (SessionMessage), or { deny } (SessionMessagesDeny).

• added SessionMessagesValue type

  What a session.messages hook's { value } holds, for any call: the rows (SessionMessage), the Messages API form (ApiMessage), or { deny }.

• added SessionSendAddress type

  Whom $.session.send addresses: a recipient as the SendMessage tool names one (a string), or a session or an agent of this session by id.

• added SessionSendArgs type

  session.send's input as a plugin's $.session.send(args) takes it: origin (the calling plugin) and agentId are the engine's to set.

• added SessionSendInput type

  The input of session.send: one plain-text message about to leave this conversation for another agent or session; the dual of session.receive.

• added SessionSendOrigin type

  Who is sending at session.send: the model through its SendMessage tool, or a plugin through $.session.send; stamped by the engine, pinned.

• added SessionSendResult type

  What a session.send hook returns and next(e) and $.session.send resolve to: whether the message was delivered, and why not when not.

• added UiCopyArgs type

  The argument of $.ui.copy and the input of ui.copy: the text, and which surface's clipboard takes it, the caller's choice.

• added UiCopyResult type

  What $.ui.copy resolves to and what a ui.copy hook's { value } holds: whether the text reached a clipboard (isCopied), else why not.

• added UiOpenResult type

  What $.ui.open resolves to and what a ui.open hook's { value } holds.