What changed, release by release.

Events

• added prompt.mention event

  Fires once per path a prompt names after an @, a directory aside, before the engine reads it; next(e) reads it and resolves { type }.

• added prompt.mention result

  { type, context? } (null when nothing was attached) or { deny }.

Types

• changed AgentTeammateRecord type may break

  What an Agent call that started a teammate answers as result at tool.call: the started teammate's two ids, its name and its model.

  export type AgentTeammateRecord = {    status: 'teammate_spawned';    agentId?: string;    agent_id: string;    teammate_id: string;    agent_id: string;    name: string;    team_name?: string;    agent_type?: string;    resolvedModel?: string;    model?: string;    prompt: string;};

• changed BoxHoverProps type may break

  The Box props a hover may override, none of which moves the Box's siblings, and scope, which names the hover group the Box joins.

  export type BoxHoverProps = {    scope?: string;    borderStyle?: string;    borderColor?: string;    borderColor?: Color;    borderDimColor?: boolean;    backgroundColor?: string;    backgroundColor?: Color;    display?: 'flex';    top?: number;    left?: number;

• changed BoxProps type may break

  The props of Box: the layout, position, margin, padding and border props of Ink's Box a tree may set, and the two of hover.

      paddingLeft?: number;    paddingRight?: number;    borderStyle?: string;    borderColor?: string;    borderColor?: Color;    borderDimColor?: boolean;    backgroundColor?: string;    backgroundColor?: Color;    overflow?: 'visible' | 'hidden';    display?: 'flex' | 'none';};

• 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>;        mention: (input: PromptMentionInput) => Promise<PromptMentionResult>;        compose: (input?: PromptComposeArgs) => Promise<PromptComposeResult>;    };    skill: {

• changed Frozen type may break

  T with every property read-only to every depth, arrays and tuples kept as declared: how a hook's e is typed.

  export type Frozen<T> = T extends (...args: never[]) => unknown ? T : T extends readonly unknown[] ? {export type Frozen<T> = T extends string | ((...args: never[]) => unknown) ? T : T extends readonly unknown[] ? {    [K in keyof T]: Frozen<T[K]>;} : T extends object ? {    readonly [K in keyof T]: Frozen<T[K]>;

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

      AssistantMessage: {        text: string;        isFirstOfReply: boolean;        isSummary?: true;        onScreen?: OnScreen | null;    };    ToolUse: {

• changed TextHoverProps type may break

  The Text props a hover may override (its colors and styles, not its wrapping) and scope, the hover group it joins; a Button's label too.

  export type TextHoverProps = {    scope?: string;    color?: string;    backgroundColor?: string;    color?: Color;    backgroundColor?: Color;    dimColor?: boolean;    bold?: boolean;    italic?: boolean;

• changed TextProps type may break

  The props of Text: the color and style props of Ink's Text a tree may set. Colors are a theme key or a raw color.

  export type TextProps = {    hover?: TextHoverProps;    color?: string;    backgroundColor?: string;    color?: Color;    backgroundColor?: Color;    dimColor?: boolean;    bold?: boolean;    italic?: boolean;

• changed ToolCheckInput type extended

  The input of tool.check: the tool, its arguments, the organization's ceiling if it set one, and on a real call its id and the loop's agentId.

      tool: string;    input: unknown;    tool_use_id?: string;    agentId?: string;    ceiling?: ToolCheckDecision;};

• changed ToolCheckResult type extended

  What a tool.check hook returns and what next(e) resolves to: the verdict, why, and the rule, classic hook or ceiling behind it, if any.

      reason?: string;    rule?: string;    hook?: string;    ceiling?: ToolCheckDecision;};

• changed TurnStepResult type extended

  What a turn.step hook returns and what next(e) resolves to: the model's response to the step's request, once its blocks are all in.

      index: number;    answer: string;    toolUses: readonly TurnStepToolUse[];    serverToolUses?: readonly TurnStepServerToolUse[];    stopReason: TurnStopReason;    usage: TurnUsage | null;};

• added Color type

  What a prop that paints may hold: a theme key, which follows the person's theme, or any other string, a raw color (a name such as "red", or hex).

• added PromptMentionAttached type

  How the engine attached a mentioned file, in the names prompt.attachment gives its type.

• added PromptMentionInput type

  The input of prompt.mention: one file a prompt names after an @, as the engine resolved it and before it is read for the model.

• added PromptMentionResult type

  What a prompt.mention hook returns and what next(e) resolves to: how the file was attached ({ type, context? }), or { deny: reason }.

• added ThemeKey type

  The theme keys named for what a color means: text, status, the prompt box and its modes, and diffs, as the custom theme reference lists them.

• added TurnStepServerToolUse type

  One tool call of a step that the API ran itself, inside the request (the advisor is one): the engine ran nothing for it.

Events

• added ui.fault event

  Fires when a Client THIS plugin drew failed on a surface: its module did not load, its drawing failed, or its code failed after it had drawn.

• added ui.fault result

  {}: the fault was heard.

Types

• changed AgentInfo type may break

  One agent loop of this session as $.agent.list() returns it: a subagent or a teammate.

  export type AgentInfo = {    id: string;    teammateId?: string;    description: string;    type: string;    status: string;    status: AgentStatus;    parentId?: string;    spawnedBy?: string;    name?: string;

• changed AgentSpawnInput type extended

  The input of agent.spawn: what the Agent tool decided about the agent it is about to start, a teammate included, before its model is resolved.

      permissionMode?: string;    background: boolean;    fork: boolean;    isTeammate?: true;    name?: string;    cwd?: string;};

• changed AgentSpawnResult type extended

  What an agent.spawn hook returns and what next(e) resolves to: the started subagent's { model, agentId }, or { deny: reason }, refusing it.

  export type AgentSpawnResult = {    model: string;    agentId?: string;    teammateId?: string;    deny?: undefined;} | {    deny: string;    model?: undefined;    agentId?: undefined;    teammateId?: undefined;};

• changed ToolCheckResult type extended

  What a tool.check hook returns and what next(e) resolves to: the verdict, why, and the settings rule or classic hook behind it, if any.

      decision: ToolCheckDecision;    reason?: string;    rule?: string;    hook?: string;};

• changed ToolResultOf type may break

  The structured result of the tool named Name: its BuiltinToolResults entry for a built-in tool, else unknown.

  export type ToolResultOf<Name extends string> = string extends Name ? unknown : Name extends keyof BuiltinToolResults & string ? BuiltinToolResults[Name] | (Name extends 'Agent' ? AgentCallRecord : never) : unknown;export type ToolResultOf<Name extends string> = string extends Name ? unknown : Name extends keyof BuiltinToolResults & string ? BuiltinToolResults[Name] | (Name extends 'Agent' ? AgentCallRecord | AgentTeammateRecord : never) : unknown;

• added AgentStatus type

  Where an agent's loop stands: pending (not started), running a turn, waiting (held), idle (between turns, until a message wakes it), or ended.

• added AgentTeammateRecord type

  What an Agent call that started a teammate answers as result at tool.call: the started teammate's address, its name and its model.

• added UiFaultInput type

  The input of ui.fault: a Client this plugin drew failed on a surface, addressed by where the instance is drawn.

• added UiFaultPhase type

  When a Client failed, as ui.fault names it; a closed set a matcher narrows on.

• added UiFaultResult type

  What a ui.fault hook returns and what next(e) resolves to: {}, the fault was heard.

The engine

• added $.ui.selection verb

  Returns what the person last selected with the mouse: the text as a copy would take it, and the transcript row it lies in.

Events

• added ui.selection event

  The argument of $.ui.selection().

Types

• changed OpValueOf type extended

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

      'ui.open': UiOpenResult;    'ui.close': void;    'ui.panes': readonly UiPane[];    'ui.selection': UiSelection | undefined;    'ui.copy': UiCopyResult;    'ui.blit': UiBlitResult;    'fs.read': string | FsBytes;

• added UiSelection type

  What the person has selected on screen, as $.ui.selection() answers it: the text, and the transcript row it lies in when it lies in one.

Types

• changed IsDiscriminant type may break

  Whether tag key K selects members of I: it does when each member gives it ONE literal (component: "ToolUse" on the ToolUse variant).

  type IsDiscriminant<I, K> = I extends unknown ? K extends KnownKeys<I> ? IsSingleLiteral<I[K]> : true : never;type IsDiscriminant<I, K> = I extends unknown ? K extends KnownKeys<I> ? IsSingleLiteral<I[K & keyof I]> : true : never;

• changed KnownKeys type may break

  The declared keys of T, the string and number index signatures left out.

  type KnownKeys<T> = keyof {    [K in keyof T as string extends K ? never : number extends K ? never : K]: 0;};type KnownKeys<T> = keyof (string extends keyof T ? IndexFree<T> : number extends keyof T ? IndexFree<T> : T);

• changed MatchedNames type may break

  The events a matched registration on P covers: the event named, or for a glob every selected event whose input has each key the matcher names.

  type MatchedNames<P, M = never> = P extends EventName ? P : {type MatchedNames<P, M = never> = (P extends EventName ? P : {    [N in Selected<P & string>]: [M] extends [never] ? N : keyof M extends AnyKeyOf<Args<N>> ? N : never;}[Selected<P & string>];}[Selected<P & string>]) extends infer Names extends EventName ? Names : never;

• changed Matcher type may break

  What on(event, matcher, hook) takes for an argument of type I: the shape of the e the hook wants, a partial of it at any depth.

  export type Matcher<I, All = I> = I extends unknown ? {    readonly [K in KnownKeys<I>]?: MatcherValue<I[K], MatcherValueOf<All, K>>;    readonly [K in KnownKeys<I>]?: MatcherValue<I[K & keyof I], MatcherValueOf<All, K>>;} & (string extends keyof I ? OpenMatcher<I, All> : unknown) : never;

• changed MatcherValueOf type may break

  The type of key K across the variants of I that declare it: one read of their table by key (MatcherValues), for a key some variant declares.

  type MatcherValueOf<I, K> = I extends unknown ? K extends KnownKeys<I> ? I[K] : never : never;type MatcherValueOf<I, K> = [I] extends [unknown] ? symbol extends K ? MatcherValueAcross<I, K> : MatcherValues<I>[K & PropertyKey] : never;

• changed On type may break

  Registers hook on the events pattern selects: one by name, every one under a namespace (classic.*), all (*), or all but some (!tool.*).

  export type On = {    <P extends Pattern>(pattern: P, hook: NoInfer<HookFor<P>>): Registration<HookFor<P>>;    <P extends Pattern, const M extends Matcher<Args<MatchedNames<P>>>>(pattern: P, matcher: M, hook: NoInfer<MatchedHook<P, M>>): Registration<MatchedHook<P, M>>;    <P extends Pattern, const M extends MatcherFor<P>>(pattern: P, matcher: M, hook: NoInfer<MatchedHook<P, M>>): Registration<MatchedHook<P, M>>;};

• changed OpenMatcher type may break

  The keys a variant with a string index signature (an MCP tool's input) takes beyond its own: another variant's key as typed there; others free.

  type OpenMatcher<I, All> = {    readonly [K in Exclude<MatcherKeys<All>, KnownKeys<I>>]?: MatcherValue<MatcherValueOf<All, K>>;    readonly [K in Exclude<MatcherKeys<All>, keyof IndexFree<I>>]?: MatcherValue<MatcherValueOf<All, K>>;} & Readonly<Record<string, unknown>>;

• changed PromptAttachmentInput type may break

  The input of prompt.attachment: one message the engine injects into the conversation for the model on its own, as a request is about to carry it.

  export type PromptAttachmentInput = {    type: string;    text: string;    origin: PromptAttachmentOrigin;    agentId?: string;};    [K in keyof PromptAttachmentDetailOf]: DeclaredAttachmentInput<K>;}[keyof PromptAttachmentDetailOf] | UndeclaredAttachmentInput;

• changed Selection type may break

  The literal each tag key of I is held to by matcher M: one-of arrays flattened, RegExps widened to unknown.

  type Selection<I, M> = {    [K in keyof M & TagKeys<I>]: Literal<M[K] extends readonly (infer One)[] ? One : M[K]>;    [K in keyof M & TagKeys<I, keyof M>]: Literal<M[K] extends readonly (infer One)[] ? One : M[K]>;};

• changed TagKeys type may break

  The keys among Among a matcher may select variants of I by: valued by literals in every variant, one literal per variant (IsDiscriminant).

  type TagKeys<I> = {    [K in MatcherKeys<I>]: IsLiteralValued<MatcherValueOf<I, K>> extends true ? IsDiscriminant<I, K> extends true ? K : never : never;}[MatcherKeys<I>];type TagKeys<I, Among> = Among extends MatcherKeys<I> ? IsLiteralValued<MatcherValueOf<I, Among>> extends true ? IsDiscriminant<I, Among> extends true ? Among : never : never : never;

• added DeclaredAttachmentInput type

  One prompt.attachment input of a type PromptAttachmentDetailOf names: the attachment's text, and under detail the facts it was rendered from.

• added IndexFree type

  An object with the declared keys of T and no other: its string and number index signatures are left out. What KnownKeys reads the keys of.

• added MatcherFor type

  The matcher type per pattern: a Matcher of the e of the event named, or of each event a glob or a negation selects.

• added MatcherValueAcross type

  The type of key K across the variants of I that declare it, read variant by variant: what MatcherValueOf reads for a key as wide as symbol.

• added MatcherValues type

  The type of each declared key of I across the variants that declare it, as one table by key: made once per I, then read at a key.

• added PlanModeDetail type

  What the engine knew as it made a plan-mode reminder: which of its two wordings the row carries, where the plan is kept, whether one is there.

• added PlanModeExitDetail type

  What the engine knew as it made the note that plan mode has ended: where the plan is kept, whether one is there.

• added PlanModeReentryDetail type

  What the engine knew as it made the note that plan mode is entered again: where the plan of the earlier planning is kept.

• added PromptAttachmentDetailOf type

  The facts prompt.attachment pins under e.detail, by attachment type: what the engine computed for the row, as it rendered the row's text.

• added UndeclaredAttachmentInput type

  One prompt.attachment input of every other type, the ones PromptAttachmentDetailOf does not name: the attachment's text alone.