What changed, release by release.

The engine

• added $.prompt.compose verb

  Returns the system prompt's sections for facts: the event prompt.compose, the call the engine makes for every prompt it sends.

Events

• added prompt.compose event

  Fires when the engine renders a system prompt; next(e) resolves to { sections }, each { id, text, scope }, in the order they are sent.

• added prompt.compose result

  { sections }, every shared one ahead of every session one (a section left out is not sent).

Types

• 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.

          section: (input: PromptSectionInput) => Promise<PromptSectionResult>;        context: (input: PromptContextInput) => Promise<PromptContextResult>;        attachment: (input: PromptAttachmentInput) => Promise<PromptAttachmentResult>;        compose: (input?: PromptComposeArgs) => Promise<PromptComposeResult>;    };    skill: {        prompt: (input: SkillPromptInput) => Promise<SkillPromptResult>;

• changed PromptOrigin type extended

  Where a prompt.submit submission came from, as the engine knows it at the site it was queued from; a closed set, never a text prefix.

  } | {    kind: 'plugin';    name: string;    asUser?: true;};

• changed PromptSubmitArgs type may break

  prompt.submit's input as a plugin's call takes it: origin, turnId and wait are the engine's to set, context the hooks' to attach.

  export type PromptSubmitArgs = Omit<PromptSubmitInput, 'origin' | 'turnId' | 'wait' | 'context'>;export type PromptSubmitArgs = Omit<PromptSubmitInput, 'origin' | 'turnId' | 'wait' | 'context'> & {    asUser?: true;};

• changed RenderPropsOf type extended

  The plain-data props of each renderable component, as ui.render sees them under e.props; a hook rewrites them with next({ ...e, props }).

          isDraft: boolean;        isWorking: boolean;        hint: string;        tail?: string;    };    AbovePrompt: {        hasSurvey: boolean;

• added PromptComposeArgs type

  What a plugin passes $.prompt.compose: the facts it wants composed for, each one it leaves out read off the session (its model, its tools).

• added PromptComposeInput type

  The input of prompt.compose: the facts a system prompt is composed from, each already resolved by the engine, at the moment it renders one.

• added PromptComposeResult type

  What a prompt.compose hook returns: the sections of the system prompt, in order, every shared one ahead of every session one.

• added PromptComposeScope type

  Which side of the prompt cache's boundary a section of the system prompt sits on: shared before it, session after it.

• added PromptComposeSection type

  One section of the system prompt as prompt.compose answers it: a stable id, the text the model reads, and the side of the cache boundary it is on.

• added PromptComposeTrait type

  One branch the engine's own composition of the system prompt takes on the request or the session before it computes any section: a closed set.

The engine

• added $.mcp.connect verb

  Connects one of the MCP servers this plugin's own manifest lists; a server already connected answers at once.

• added $.session.append verb

  Appends a row to a conversation of the session: the event session.append, the engine's own call for every row it keeps.

Events

• added session.append event

  Fires once per row a conversation of this session keeps (a prompt, a response block, a tool result, a notice), before it is stored.

• added session.append result

  { message, uuid }, the row as stored.

Types

• 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>;        append: (input: SessionAppendInput) => Promise<SessionAppendResult>;        send: (input: SessionSendArgs) => Promise<SessionSendResult>;        compact: (input?: SessionCompactArgs) => Promise<SessionCompactResult>;        attach: (input: SessionAttachInput) => Promise<SessionAttachResult>;

• changed OpValueOf type extended

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

      'audio.play': void;    'audio.speak': SpeakResult;    'mcp.call': McpToolResult;    'mcp.connect': McpConnectResult;    'session.cwd': string;    'session.root': string;    'session.model': string;

• changed PromptEditResult type may break

  What a prompt.edit hook returns and what next(e) resolves to: the box after the edit (PromptBox), which the editor then shows.

  export type PromptEditResult = PromptBox;export type PromptEditResult = PromptBox & {    decorations?: PromptDecoration[];};

• changed PromptFillArgs type extended

  prompt.fill's input as a plugin's $.prompt.fill(args) takes it: no origin (the engine sets the calling plugin's), mode optional.

  export type PromptFillArgs = {    text: string;    mode?: PromptFillMode;    decorations?: PromptDecoration[];};

• changed PromptFillInput type extended

  The input of prompt.fill (prompt-fill/): a text about to be put in the prompt box as the person's draft, over it, after it, or at the cursor.

      text: string;    mode: PromptFillMode;    origin: PromptFillOrigin;    decorations?: PromptDecoration[];};

• added McpConnectRefusal type

  Why $.mcp.connect left a server unconnected, in one word.

• added McpConnectResult type

  What $.mcp.connect resolves to and what an mcp.connect hook's { value } holds: the server connected, or why not.

• added PromptDecoration type

  One styled run a surface paints over the prompt draft: [start, end) of a text, in UTF-16 code units like PromptBox cursor. Paint only.

• added SessionAppendArgs type

  session.append's input as a plugin's $.session.append(args) takes it: the row's kind and text, and the loop it joins.

• added SessionAppendDoor type

  Which door a row came in by, decided from the row alone; a closed set, pinned on the event and the key a matcher narrows on.

• added SessionAppendInput type

  The input of session.append: one row being appended to a conversation of this session, by the engine site that originates it or by a plugin's call.

• added SessionAppendMessage type

  One row of a conversation as session.append hands it: how the transcript files it, under which role a request carries it, and its blocks.

• added SessionAppendOrigin type

  Who caused a row, as the engine knows it from the row itself: a submission's sender, an injected row's author, the model, or the tool that was called.

• added SessionAppendResult type

  What a session.append hook returns and what next(e) resolves to: the row as the session stored it, or { deny: reason } for a plugin's own call.

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<ModelCompleteResult>(request: ModelCompleteRequest, options?: ModelCompleteOptions) => Promise<ModelCompleteResult>

• added $.telemetry noun

  Analytics: first-party rows and feature marks for Anthropic, and records for the telemetry collector the session's operator configured.

• added $.telemetry.log verb

  Logs one record to the destination entry.to names, the event telemetry.log; e.to is pinned, and anthropic when left out.

• added $.telemetry.mark verb

  Marks one use of a feature as the CLI's own feature events do, the event telemetry.mark; it takes no to and always means anthropic.

Events

• added telemetry.log event

  Fires when a record is about to be logged to the destination e.to names: a built-in's $.telemetry.log, or the engine's own events.

• added telemetry.log result

  { value: undefined }, or { deny }.

• added telemetry.mark event

  Fires when one use of a feature is marked ($.telemetry.mark), as the CLI's own feature events mark one; always for anthropic, no to.

• added telemetry.mark result

  { value: undefined }, or { deny }.

Types

• changed ButtonProps type may break

  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.

      role?: 'dismiss';    autoFocus?: true;    hover?: TextHoverProps;    onPress: () => void;    onPress: (e: UiPressArgument) => void;};

• changed CommandRunResult type extended

  What a command.run hook returns and what next(e) and $.command.run resolve to: the command's output text and the notes it leaves the model.

  export type CommandRunResult = {    text?: string;    context?: readonly string[];    exitCode?: number;    ref?: number;};

• 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.

          measure: (input: SessionMeasureInput) => Promise<SessionMeasureResult>;        end: (input: SessionEndInput) => Promise<SessionEndResult>;    };    telemetry: {        log: (input: TelemetryLogArgs) => Promise<TelemetryLogResult>;        mark: (input: TelemetryMarkInput) => Promise<TelemetryMarkResult>;    };    turn: {        start: (input: TurnStartInput) => Promise<TurnStartResult>;        step: (input: TurnStepInput) => HookStream<TurnStepChunk, TurnStepResult>;

• changed FsEntry type extended

  One entry of $.fs.list: the entry itself, a link not followed.

      name: string;    kind: 'file' | 'dir' | 'other';    size: number;    mtimeMs: number;    isLink: boolean;};

• changed ProcessRunResult type extended

  What $.process.run resolves with once the child has exited.

      exitCode: number;    stdout: string;    stderr: string;    isStdoutTruncated: boolean;    isStderrTruncated: boolean;};

• changed TestOptions type extended

  What test takes beside its name: the inline plugins it loads beside the one under test, and how long it may run (5000 ms when not given).

  export type TestOptions = {    plugins?: readonly Plugin[];    timeoutMs?: number;    options?: PluginOptions;};

• added ModelCompleteOptions type

  Options of $.model.complete: what is no part of the request, so no hook on model.complete reads it on e.

• added TelemetryAttribute type

  One attribute of a collector record, as the collector receives it.

• added TelemetryChoice type

  A string property of a first-party row: the value and the list it is chosen from, so no free text reaches a row.

• added TelemetryDestination type

  Where a telemetry record goes: anthropic, Anthropic's first-party analytics, or collector, the one the session's operator configured.

• added TelemetryLogArgs type

  What a call of $.telemetry.log passes: a first-party row, to optional, or a collector record.

• added TelemetryLogInput type

  The input of telemetry.log: one record about to be logged to the destination to names, which is always present and pinned.

• added TelemetryLogResult type

  What a telemetry.log hook returns and next(e) resolves to: { value: undefined }, or { deny }, which rejects the caller's promise.

• added TelemetryMarkInput type

  The input of telemetry.mark: one use of a feature, as the CLI's own feature events mark one.

• added TelemetryMarkKind type

  How one use of a feature went, as the CLI's own feature events count it.

• added TelemetryMarkResult type

  What a telemetry.mark hook returns and next(e) resolves to: { value: undefined }, or { deny }, which rejects the caller's promise.

• added TelemetryProp type

  One property of a first-party row or a mark: a number, a boolean, or a string chosen from a list (TelemetryChoice).

• added TelemetryRecordEntry type

  A record for the telemetry collector the session's operator configured.

• added TelemetryRowArgs type

  A first-party row as a call passes it: to left out reads as anthropic.

• added TelemetryRowEntry type

  A first-party row as a hook reads it: to is always present, the engine having completed it before any hook or matcher reads e.

• added TelemetrySpan type

  The span a collector record belongs to, as W3C trace context spells it: the ids in lowercase hex.

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[];};