zidane 7.2.5 → 8.0.4

package/dist/client-core-BQSyDALT.d.ts

@@ -0,0 +1,2115 @@
+import { Eg as ContextBreakdown, Gy as SessionTurn, Jx as SessionArtifact, Kh as ProviderKey, Lp as SessionEnvironmentSummary, Mh as EnvironmentVerifyResult, Qb as SessionData, Qd as CommandOutputBlock, Rp as SessionHeader, Vp as StreamEvent, _f as InteractionResponse, by as JsonValue, eb as ThinkingLevel, eh as EnvironmentDescriptor, gh as EnvironmentActionSummary, hh as EnvironmentActionResult, ih as EnvironmentSettingsChange, jh as EnvironmentTeardownResult, kh as EnvironmentRequest, xy as McpServerConfig, zp as SessionMeta } from "./index-BGe1fQT7.js";
+import { m as ExecResult, v as ListFilesEntry } from "./isolation-D9L650W5.js";
+import { Cn as ContextSegmentsReport, Dn as WorkerRow, En as CreateWorkerParams, On as WorkerSummary, Tn as WorkspaceListFilesOptions, ar as PendingInteraction, bn as CompactionReport, cr as QueuedItem, fr as SessionPresence, hr as WireApprovalRequest, ir as HostSignal, kn as SessionLaunchOverrides, lr as RunningWorkItem, mr as TodosSnapshot, nr as CommandSummary, or as PromptAttachment, rr as HostSettings, tr as CommandArgSuggestionSummary, ur as SendOptions, vr as SystemMdFile } from "./index-CHABJd-L.js";
+import "./types-IqegbJEE.js";
+import { Cn as MachineInfo, Kt as TodoItem, On as MachineRegisterParams, Tn as MachineLinksStatus, fn as TerminalAttachResult, hn as TerminalOpenInput, mn as TerminalInfo, mr as SessionHistoryMatch, nr as BrowserResponse, pr as SearchTurnResult, vn as TerminalSessionState, xi as ApprovalDecision } from "./turn-operations-DQX5ZZni.js";
+import { c as SyncClaimResult, d as SyncPushResult, p as SyncStatus, s as SyncCategory, u as SyncPayload } from "./types-C7ZFOztE.js";
+//#region src/ipc/protocol.d.ts
+/**
+ * v6 (changes since v5):
+ *   - `event` signals carry an optional `echo` flag marking host-generated
+ *     SEND/STEER echoes of the user's own message.
+ *   - `chat.pushQueued` result gained the `'queued'` delivered variant.
+ *   - `sessions.setModel` now honors `fallbacks`: it persists the canonical
+ *     `metadata.modelChain` and CLEARS a previously persisted chain when
+ *     omitted/empty. It also accepts `effort` / `modelOptions` and resets
+ *     both when omitted (a pick is atomic — no stale per-model knobs).
+ *   - additive: `extension.emit` notification + `extension:signal` fan-out
+ *     (the permission-gated per-extension cross-window bus, `ctx.bus`).
+ *     Older daemons ignore the unknown notification; older clients drop the
+ *     unknown signal kind — no version bump needed.
+ *   - additive: `extension.emit` / `extension:signal` carry an optional
+ *     `nonce` (the emitter's per-process random id) so receivers dedupe on
+ *     `(extensionId, nonce, seq)` instead of the collision-prone
+ *     `(extensionId, seq)`. Older peers omit it and fall back to the
+ *     seq-only key — no version bump needed.
+ *   - `SessionRow.modelFallbacks` is now populated from the session's
+ *     persisted `metadata.modelChain`.
+ *   - Default socket path moved from `<stateDir>/daemon.sock` to the
+ *     dedicated `<stateDir>/daemon/daemon.sock` (dir chmod'd 0700) so the
+ *     daemon can harden its socket dir without touching shared state files.
+ *   - ADDITIVE (no version bump — older daemons answer "method not
+ *     found", clients degrade to local compute): `suggest.resolve` RPC
+ *     resolves inline ghost-text autocomplete daemon-side, and the
+ *     `suggest:changed` signal fans the result out to every OTHER peer
+ *     on the session so mirroring windows paint the same ghost without
+ *     recomputing.
+ *   - ADDITIVE (no version bump — optional field, older daemons simply
+ *     omit it and clients fall back to the single `suggestion`):
+ *     `suggest.resolve` results and `suggest:changed` signals carry the
+ *     resolver's full ordered `candidates` list so daemon mode keeps
+ *     ↑/↓ candidate rotation instead of degrading to one suggestion.
+ *   - ADDITIVE (no version bump — `optional()` swallows "method not
+ *     found" on an older daemon, which then simply keeps its stale
+ *     registries as before): `runtime.reload` RPC drops the daemon's
+ *     cached extension registries and retires live agents after a window
+ *     reloaded its extensions.
+ *   - ADDITIVE (no version bump): `terminal.registerViewer` /
+ *     `terminal.unregisterViewer`. The desktop app registers as a client that
+ *     can show terminals; agents only get terminal tools while one is
+ *     attached. An older daemon answers "method not found" (and keeps giving
+ *     every agent the tools, as before); an older desktop app on a newer
+ *     daemon never registers, so its agents run without terminal tools.
+ *   - ADDITIVE (no version bump): `queue.attachments` returns a queued
+ *     entry's attachments with their bytes, and `queue.update` accepts
+ *     `attachments` to replace them. An older daemon answers "method not
+ *     found" / ignores the field: the entry's attachments stay as queued.
+ *   - ADDITIVE (no version bump): `chat.steer` / `chat.followUp` resolve to
+ *     whether the message reached a live run. Older daemons resolve `null`,
+ *     which clients treat as delivered (the pre-existing behavior).
+ *   - ADDITIVE (no version bump): `sessions.fork`, `sessions.deleteTurn`,
+ *     `sessions.editTurnText`, `sessions.setFolder`, `sessions.appendTurns`.
+ *     History and folder edits run in the host instead of being written to
+ *     the store by the client (then `sessions.touch` + `chat.rebuildAgent`).
+ *     Older clients keep the old path, which still works on a shared disk.
+ *     A newer client only meets an older daemon while it retires (the
+ *     release fence drains it otherwise), and then gets "method not found".
+ *   - ADDITIVE (no version bump): `sessions.listMeta`, `sessions.getMeta`,
+ *     `sessions.get`, `sessions.setExtensionState` serve a client the
+ *     session data it used to read and write in its own store, so a window
+ *     on another machine sees the host's sessions. `sessions.create` accepts `id`, `effort`, `modelOptions` and
+ *     `pinnedSkills`; `todos.set` accepts `persistIdle`. An older host answers
+ *     "method not found" / ignores the fields: a window falls back to the
+ *     store it shares with a local daemon, and refuses a remote host.
+ */
+declare const IPC_PROTOCOL_VERSION = 13;
+/**
+ * JSON-RPC error codes specific to the zidane daemon. Lives here (not in
+ * `daemon/server.ts`) so clients can import the codes without pulling the
+ * server's module graph.
+ */
+declare const IpcErrorCode: {
+  readonly VersionMismatch: -32010;
+  readonly NotHandshaken: -32011;
+  /** A network transport's per-connection request budget is spent; retry later. */
+  readonly RateLimited: -32012;
+  /**
+   * The reply would exceed the transport's message size: nothing was sent
+   * but this error (the connection stays). Ask for less (a transcript: a
+   * smaller page, see {@link loadAllEvents}).
+   */
+  readonly ResponseTooLarge: -32013;
+  /**
+   * The handler threw: the host refused or failed the call (`message` says
+   * why). Hosts before it answered -32000, which ACP uses for
+   * `AuthenticationRequired`; clients treat both as a plain remote error.
+   */
+  readonly HandlerFailed: -32014;
+};
+/**
+ * Session-scoped signals fanned out to every peer carry their number in
+ * their session as this extra field on the `ipc.signal` params (clients
+ * predating it ignore it; `IpcClient` strips it and hands it to listeners as
+ * {@link SignalMeta}). Per session, from 1, gap-free within one host process.
+ */
+declare const SIGNAL_SEQ_FIELD = "$seq";
+/** What a signal listener gets beside the signal: its number in its session, when it has one. */
+interface SignalMeta {
+  seq: number;
+}
+interface SequencedSignal {
+  seq: number;
+  signal: HostSignal;
+}
+type SessionResumeResult = {
+  ok: true;
+  signals: SequencedSignal[];
+} |
+/** `epoch`: another host process numbered them. `gap`: the log no longer covers the position. */
+{
+  ok: false;
+  reason: 'epoch' | 'gap';
+};
+/**
+ * Typed method map for the daemon transport. Keys are JSON-RPC method
+ * names; each entry pins params/result so both the daemon dispatch table
+ * and the client proxy are checked against the same contract.
+ *
+ * Scope: the chat core every client needs. Host-UI-specific surfaces
+ * (folder pickers, themes, keybindings) intentionally stay client-local.
+ */
+interface IpcMethods {
+  /** `wake` is host-internal (see `SendOptions.wake`) — not accepted over the wire. */
+  'chat.send': {
+    params: Omit<SendOptions, 'wake'>;
+    result: {
+      runId: string;
+    };
+  };
+  'chat.interrupt': {
+    params: {
+      sessionId: string;
+    };
+    result: void;
+  };
+  /** `true` when the message reached a live run; `false` when nothing was running (it was not delivered). */
+  'chat.steer': {
+    params: {
+      sessionId: string;
+      message: string;
+    };
+    result: boolean;
+  };
+  'chat.followUp': {
+    params: {
+      sessionId: string;
+      message: string;
+    };
+    result: boolean;
+  };
+  'chat.pushQueued': {
+    params: {
+      sessionId: string;
+      message: string;
+      activatedSkills?: string[];
+      keepDraft?: boolean;
+    };
+    result: {
+      delivered: 'steer' | 'send' | 'command' | 'queued';
+    };
+  };
+  'chat.isRunning': {
+    params: {
+      sessionId: string;
+    };
+    result: boolean;
+  };
+  /**
+   * Retire the session's live agent so the next run rebuilds against
+   * fresh config/credentials (MCP login, extension reload). Run-end
+   * deferred when a run is in flight; HITL/queue state survives.
+   */
+  'chat.rebuildAgent': {
+    params: {
+      sessionId: string;
+    };
+    result: void;
+  };
+  /**
+   * `zidane run --system / --mcp` for a host-backed window: launch overrides
+   * for the session's agent (`ChatHost.setLaunchOverrides`), owned by the
+   * calling client and dropped when it disconnects. A call with neither field clears them.
+   */
+  'sessions.setLaunchOverrides': {
+    params: {
+      sessionId: string;
+    } & SessionLaunchOverrides;
+    result: void;
+  };
+  /**
+   * Drop the daemon's cached runtime configs (extension registries, per
+   * cwd) and retire every live agent so the next command or run rebuilds
+   * against what is on disk now. Sent by a window after it reloaded its
+   * own extensions (install, update, remove, `/reload`): extension `/`
+   * commands execute daemon-side, so without this the daemon keeps
+   * running the code it loaded at boot. Busy sessions rebuild at run end.
+   */
+  'runtime.reload': {
+    params: Record<string, never>;
+    result: void;
+  };
+  'chat.listWork': {
+    params: {
+      sessionId: string;
+    };
+    result: RunningWorkItem[];
+  };
+  'chat.cancelWork': {
+    params: {
+      sessionId: string;
+      id: string | 'all';
+      reason?: string;
+    };
+    result: boolean;
+  };
+  'sessions.list': {
+    params: {
+      projectRoot?: string | null;
+      archive?: 'active' | 'archived' | 'all';
+    };
+    result: SessionRow[];
+  };
+  /**
+   * The session list as a window renders it (`SessionMeta`: title, turn /
+   * message / run counts, project, cwd, environment, artifact count, the
+   * orchestration main flag), newest first. `projectRoot`: omitted = every
+   * project, `null` = untagged sessions.
+   */
+  'sessions.listMeta': {
+    params: {
+      projectRoot?: string | null;
+    };
+    result: SessionMeta[];
+  };
+  /** One `SessionMeta` by id (rows a filtered list can't return, e.g. the main); `null` when unknown. */
+  'sessions.getMeta': {
+    params: {
+      sessionId: string;
+    };
+    result: SessionMeta | null;
+  };
+  /**
+   * The whole session document as the host holds it: the live copy when an
+   * agent is live (turns persisted mid-run, todos kept in memory), else the
+   * stored one, a stale `running` marker demoted. `null` when unknown.
+   */
+  'sessions.get': {
+    params: {
+      sessionId: string;
+      turns?: boolean;
+    };
+    result: SessionDocumentHead | null;
+  };
+  /**
+   * A slice of a session's turns, `[from, from + limit)` (default from 0,
+   * {@link SESSION_TURNS_PAGE} turns, at most {@link SESSION_TURNS_MAX_PAGE}),
+   * from the same copy `sessions.get` reads, and how many turns it has: a
+   * client reads a long session's document a page at a time
+   * ({@link loadSessionDocument}) instead of in one reply. With
+   * `sessions.get` `turns: false` (the document without its turns), what an
+   * export needs. Pages and that head come from one snapshot of the
+   * document per content version (read once, not per page), and name it
+   * (`version`): a client that sees it change mid-load starts over rather
+   * than mix two versions ({@link loadSessionDocument}). `null` when
+   * unknown. Additive: an older host answers "method not found", ignores
+   * `turns: false`, and names no version.
+   */
+  'sessions.getTurns': {
+    params: {
+      sessionId: string;
+      from?: number;
+      limit?: number;
+    };
+    result: {
+      turns: SessionTurn[];
+      total: number;
+      version?: string;
+    } | null;
+  };
+  /**
+   * The full text of one tool result (`callId`; `turnId`, when known, the
+   * turn that holds it): what a clipped tool row shows on expand, without
+   * the session crossing the wire. `null` when no such result. Additive.
+   */
+  'sessions.getToolResult': {
+    params: {
+      sessionId: string;
+      callId: string;
+      turnId?: string;
+    };
+    result: string | null;
+  };
+  /**
+   * One session's header: its list row plus metadata, profile and status,
+   * without turns or runs (the live copy when an agent holds it). What a
+   * window re-reads on `sessions:changed`. Additive. `usage: true` adds the
+   * footer's numbers, computed host-side from the turns and runs
+   * (`contextTokens`, `costUsd`): a client needs no document for its context
+   * gauge or cost pill. Older hosts ignore it.
+   */
+  'sessions.getHeader': {
+    params: {
+      sessionId: string;
+      usage?: boolean;
+    };
+    result: SessionHeader | null;
+  };
+  /**
+   * One key of an extension's per-session state (`metadata.extensions`, the
+   * bag `ctx.session` and renderer `useSessionState` share), written by the
+   * host into its copy of the session. `value` omitted deletes the key.
+   */
+  'sessions.setExtensionState': {
+    params: {
+      sessionId: string;
+      extension: string;
+      key: string;
+      value?: JsonValue;
+    };
+    result: void;
+  };
+  'sessions.create': {
+    params: CreateSessionParams;
+    result: SessionRow;
+  };
+  /** Resolves with what happened to the session's environment (a provider may keep it). */
+  'sessions.delete': {
+    params: {
+      sessionId: string;
+    };
+    result: {
+      environment?: EnvironmentTeardownResult;
+    };
+  };
+  /** Provision a failed (or restart-stranded) environment again. */
+  'sessions.retryEnvironment': {
+    params: {
+      sessionId: string;
+    };
+    result: void;
+  };
+  /** The per-session commands the session's environment offers right now (push, open PR, …). */
+  'sessions.environmentActions': {
+    params: {
+      sessionId: string;
+    };
+    result: EnvironmentActionSummary[];
+  };
+  /** Run one of them in the session's environment (resumed when suspended). */
+  'sessions.runEnvironmentAction': {
+    params: {
+      sessionId: string;
+      actionId: string;
+    };
+    result: EnvironmentActionResult;
+  };
+  /**
+   * The session's workspace (`ChatHost.workspace*`): its execution context,
+   * rooted inside the environment when the files live there, else at the
+   * session's cwd. Paths and exec `cwd` resolve against the root as the
+   * execution context resolves them; containment is the context's own.
+   * `cwd` / `env` on exec and the list / size methods are additive: an
+   * older daemon ignores the former and answers "method not found" to the
+   * latter (active clients are build-fenced, so this is a transient case).
+   */
+  'sessions.workspaceExec': {
+    params: {
+      sessionId: string;
+      command: string;
+      cwd?: string;
+      env?: Record<string, string>;
+      timeoutSeconds?: number;
+    };
+    result: ExecResult;
+  };
+  /**
+   * The same command, streamed (`!` on a remote host): the reply names the
+   * exec, its output follows as `workspace:exec:data` signals and ends with
+   * one `workspace:exec:exit`, all to this connection only (signals may
+   * precede the reply). Bounded per connection (concurrent commands, chunk
+   * size, total output: past it the process is stopped and the exit says
+   * `truncated`). A dropped connection kills what it started. Additive: an
+   * older host answers "method not found" and clients use `workspaceExec`.
+   */
+  'sessions.workspaceExecStream': {
+    params: {
+      sessionId: string;
+      command: string;
+      cwd?: string;
+    };
+    result: {
+      execId: string;
+    };
+  };
+  /** Kill a streamed command's process group (this connection's only; `cancelled: false` otherwise or when it already ended). */
+  'sessions.workspaceExecCancel': {
+    params: {
+      execId: string;
+    };
+    result: {
+      cancelled: boolean;
+    };
+  };
+  'sessions.workspaceReadFile': {
+    params: {
+      sessionId: string;
+      path: string;
+    };
+    result: string;
+  };
+  'sessions.workspaceWriteFile': {
+    params: {
+      sessionId: string;
+      path: string;
+      content: string;
+    };
+    result: void;
+  };
+  'sessions.workspaceListFiles': {
+    params: {
+      sessionId: string;
+      path: string;
+      options?: WorkspaceListFilesOptions;
+    };
+    result: ListFilesEntry[];
+  };
+  'sessions.workspaceFileSize': {
+    params: {
+      sessionId: string;
+      path: string;
+    };
+    result: number | null;
+  };
+  /**
+   * Every environment kind the host can create, described for a new session
+   * in `cwd` (availability, default, branch suggestion, options — secrets
+   * only as "configured"). What pickers and the Environments settings render.
+   * `kind`: a machine kind (`local@laptop`) says `cwd` is that machine's
+   * folder, checked against its roots instead of this host's
+   * (`docs/MACHINES.md` § Folders); the same on `commands.*`, `catalog.*`
+   * and `models.list`. Additive.
+   */
+  'environments.list': {
+    params: {
+      cwd?: string;
+      kind?: string;
+    };
+    result: EnvironmentDescriptor[];
+  };
+  /**
+   * Apply one Environments-settings edit (enable, default, options,
+   * secrets), validated against the kind's schema. Settings changes fan out
+   * as `settings:changed`; secrets are stored host-side and never returned.
+   */
+  'environments.update': {
+    params: EnvironmentSettingsChange;
+    result: void;
+  };
+  /** "Test connection" for a kind with its current options. */
+  'environments.verify': {
+    params: {
+      kind: string;
+    };
+    result: EnvironmentVerifyResult;
+  };
+  'sessions.setTitle': {
+    params: {
+      sessionId: string;
+      title: string;
+    };
+    result: void;
+  };
+  /**
+   * Title the session ON the host: its providers and credentials (a server
+   * session's transcript never goes to the window's provider), the same
+   * generator (`generateSessionTitle`), written as `sessions.setTitle` does.
+   * `providerKey` / `model`: the window's pick, used when the host has that
+   * provider; otherwise the session's own provider and model. The Main
+   * session is refused (it keeps its name). Additive: an older host answers
+   * "method not found".
+   */
+  'sessions.generateTitle': {
+    params: {
+      sessionId: string;
+      providerKey?: string;
+      model?: string;
+    };
+    result: {
+      title: string;
+    };
+  };
+  'sessions.setArchived': {
+    params: {
+      sessionId: string;
+      archived: boolean;
+    };
+    result: void;
+  };
+  'sessions.setAgentId': {
+    params: {
+      sessionId: string;
+      agentId: string;
+    };
+    result: void;
+  };
+  'sessions.setEffort': {
+    params: {
+      sessionId: string;
+      effort: ThinkingLevel;
+    };
+    result: void;
+  };
+  /**
+   * The one model-swap contract (`ChatHost.setSessionModel`). A pick is a
+   * whole: `fallbacks` (ordered, primary excluded) REPLACES the persisted
+   * `metadata.modelChain` (omitted/empty clears it); `effort` and
+   * `modelOptions` are reset to the supplied values (omitted clears them —
+   * per-model knobs never leak onto the new model). The live agent is
+   * retired so the next run rebuilds on the new pick (run-end deferred
+   * while a run is in flight).
+   */
+  'sessions.setModel': {
+    params: {
+      sessionId: string;
+      providerKey: ProviderKey;
+      modelId: string;
+      fallbacks?: ModelFallbackRef[];
+      effort?: ThinkingLevel;
+      modelOptions?: Record<string, boolean>;
+    };
+    result: void;
+  };
+  'sessions.setModelOptions': {
+    params: {
+      sessionId: string;
+      options: Record<string, boolean>;
+    };
+    result: void;
+  };
+  /**
+   * The session's transcript as canonical events. Without `before` / `limit`:
+   * every turn, as a plain array (the shape every client predating paging
+   * reads). With either: one page, `{ events, cursor? }`, the last `limit`
+   * turns (default {@link LOAD_EVENTS_PAGE_TURNS}, at most
+   * {@link LOAD_EVENTS_MAX_PAGE_TURNS}) before turn position `before`
+   * (default: the end), its start moved back to an exchange boundary when one
+   * is near so a tool call is never cut from its result. `cursor`: the
+   * `before` of the previous page, absent at the first turn. Typed here as
+   * the unpaged call every client makes; a paged call goes through
+   * {@link loadEventsPage}. Paging is additive: an older host ignores the
+   * fields and answers the whole array.
+   */
+  'sessions.loadEvents': {
+    params: {
+      sessionId: string;
+    };
+    result: StreamEvent[];
+  };
+  /**
+   * Reattach without a reload: the session's signals numbered after
+   * `afterSeq` (see {@link SIGNAL_SEQ_FIELD}), in order, as long as this host
+   * process (`epoch`, from `HelloResult.signalEpoch`) still holds them all.
+   * Otherwise refused, and the client reloads with `sessions.loadEvents`.
+   * Additive: an older host answers "method not found", same fallback.
+   */
+  'sessions.resume': {
+    params: {
+      sessionId: string;
+      epoch: string;
+      afterSeq: number;
+    };
+    result: SessionResumeResult;
+  };
+  'sessions.getTurn': {
+    params: {
+      sessionId: string;
+      turnId: string;
+    };
+    result: SessionTurn | null;
+  };
+  'sessions.contextBreakdown': {
+    params: {
+      sessionId: string;
+    };
+    result: ContextBreakdown | null;
+  };
+  /**
+   * Artifacts one session recorded (PRs, branches, commits, files,
+   * extension kinds — see `session/artifacts.ts`), newest first. Empty on
+   * stores without artifact support. Additive; pre-artifact daemons
+   * reject the method and clients treat that as empty.
+   */
+  'sessions.artifacts': {
+    params: {
+      sessionId: string;
+      kind?: string;
+      limit?: number;
+    };
+    result: SessionArtifact[];
+  };
+  /**
+   * Artifacts across sessions, filtered by project root (`null` = untagged
+   * sessions, omitted = every project) and/or kind/uri (reverse lookup).
+   */
+  'artifacts.list': {
+    params: {
+      projectRoot?: string | null;
+      kind?: string;
+      uri?: string;
+      since?: number;
+      limit?: number;
+    };
+    result: SessionArtifact[];
+  };
+  /** Remove one artifact. `false` when the store has no artifact support. Fans out `artifact:changed`. */
+  'artifacts.delete': {
+    params: {
+      sessionId: string;
+      artifactId: string;
+    };
+    result: boolean;
+  };
+  /**
+   * Upsert an artifact — the lazy `resolve()` write-back (refreshed
+   * `label` / `meta`). Same merge semantics as `SessionStore.upsertArtifact`;
+   * `null` when the session is unknown or the store lacks support.
+   */
+  'artifacts.upsert': {
+    params: {
+      artifact: SessionArtifact;
+    };
+    result: SessionArtifact | null;
+  };
+  /**
+   * Transcript search over ONE session, daemon-side. The daemon owns the
+   * authoritative turns (live wrapper when an agent is active — fresh
+   * mid-run, which a window's load-time snapshot is not) and an LRU index
+   * cache shared by every window, so repeat queries pay match cost only.
+   * Results come back in TURN ORDER (search is a transcript filter).
+   */
+  'history.searchSession': {
+    params: {
+      sessionId: string;
+      query: string;
+      limit?: number;
+    };
+    result: SearchTurnResult[];
+  };
+  /**
+   * Cross-session content search, daemon-side. One RPC replaces a
+   * window's per-session index/build/search round-trips — indexes are
+   * built once in the daemon and shared by every window.
+   */
+  'history.searchAll': {
+    params: {
+      query: string;
+      sessionIds: string[];
+      excerptLimit?: number;
+    };
+    result: Record<string, SessionHistoryMatch>;
+  };
+  /**
+   * A window appended transcript content OUT-OF-BAND (local `/` command
+   * output, `!` shell turns — written straight to the shared store, not
+   * through a host run). The daemon fans out `sessions:changed` so every
+   * window (issuer included) re-converges on the canonical replay NOW
+   * instead of at the next run end. Sent as a notification.
+   */
+  'sessions.touch': {
+    params: {
+      sessionId: string;
+    };
+    result: void;
+  };
+  /** Fork at `turnId` into a new session (`ChatHost.forkSession`); announced as a `sessions:changed` create. */
+  'sessions.fork': {
+    params: {
+      sessionId: string;
+      turnId: string;
+      title?: string;
+    };
+    result: {
+      id: string;
+    };
+  };
+  /** History edits (`ChatHost.deleteTurn` / `editTurnText`): refused while the session runs. */
+  'sessions.deleteTurn': {
+    params: {
+      sessionId: string;
+      turnId: string;
+    };
+    result: void;
+  };
+  'sessions.editTurnText': {
+    params: {
+      sessionId: string;
+      turnId: string;
+      text: string;
+    };
+    result: void;
+  };
+  /** Bind to a folder, or back to a plain chat with `cwd: ''` (`ChatHost.setSessionFolder`). */
+  'sessions.setFolder': {
+    params: {
+      sessionId: string;
+      cwd: string;
+    };
+    result: void;
+  };
+  /** Turns written outside a run, e.g. `!` shell output (`ChatHost.appendTurns`). */
+  'sessions.appendTurns': {
+    params: {
+      sessionId: string;
+      turns: SessionTurn[];
+    };
+    result: void;
+  };
+  /**
+   * `ctx.appendNote` outside a run: a display-only note, rendered live and
+   * persisted (`ChatHost.appendNote`). False for an unknown session or no blocks.
+   */
+  'sessions.appendNote': {
+    params: {
+      sessionId: string;
+      blocks: CommandOutputBlock[];
+    };
+    result: boolean;
+  };
+  /** Compact now (`ChatHost.compactSessionNow`): what was done, `null` when nothing was. Older daemons resolve `null`. */
+  'sessions.compact': {
+    params: {
+      sessionId: string;
+    };
+    result: CompactionReport | null;
+  };
+  'todos.get': {
+    params: {
+      sessionId: string;
+    };
+    result: TodosSnapshot | null;
+  };
+  /**
+   * Apply a user todo edit (add / edit / remove / cycle / clear) to the
+   * session the MODEL reads.
+   *
+   * Required because todos live in `session.metadata` and `todowrite` reads
+   * them off the daemon agent's in-memory `Session`. A window writing its own
+   * `Session` instance persisted an edit that the daemon never observed, so the
+   * model's next `todowrite` silently overwrote it.
+   *
+   * Sends the whole list rather than a delta: the mutators in
+   * `chat/todo-edits.ts` are already whole-list transforms, and a delta would
+   * need conflict rules against a list the model rewrites concurrently.
+   *
+   * `null` = no live agent (or no run owns a todo slot), and the caller should
+   * apply its own store-level write — race-free, since nothing is appending.
+   */
+  /**
+   * `persistIdle`: with no live agent, the host applies the edit to the stored
+   * session itself (the run the list belongs to must exist) instead of
+   * answering `null`. Older hosts ignore it.
+   */
+  'todos.set': {
+    params: {
+      sessionId: string;
+      items: readonly TodoItem[];
+      persistIdle?: boolean;
+    };
+    result: TodosSnapshot | null;
+  };
+  /** The main session id, creating it (directory-less) when the setting is on and none exists. */
+  'orchestration.main': {
+    params: Record<string, never>;
+    result: string | null;
+  };
+  'orchestration.createWorker': {
+    params: {
+      mainId: string;
+    } & CreateWorkerParams;
+    result: string;
+  };
+  'orchestration.list': {
+    params: {
+      mainId: string;
+      limit?: number;
+    };
+    result: WorkerRow[];
+  };
+  'orchestration.read': {
+    params: {
+      mainId: string;
+      sessionId: string;
+    };
+    result: WorkerSummary | null;
+  };
+  /** `wake` (default true): whether that run finishing wakes the main. */
+  'orchestration.send': {
+    params: {
+      mainId: string;
+      sessionId: string;
+      prompt: string;
+      wake?: boolean;
+    };
+    result: void;
+  };
+  'orchestration.steer': {
+    params: {
+      mainId: string;
+      sessionId: string;
+      message: string;
+    };
+    result: void;
+  };
+  'orchestration.cancel': {
+    params: {
+      mainId: string;
+      sessionId: string;
+    };
+    result: void;
+  };
+  'orchestration.transcript': {
+    params: {
+      mainId: string;
+      sessionId: string;
+      limit?: number;
+    };
+    result: string;
+  };
+  /** Extension-contributed `/` commands discovered for `cwd`. */
+  'commands.list': {
+    params: {
+      cwd: string;
+      kind?: string;
+    };
+    result: CommandSummary[];
+  };
+  /** Argument suggestions for `/name <prefix>` — best-effort, empty on failure. */
+  'commands.completeArgs': {
+    params: {
+      cwd: string;
+      name: string;
+      argsPrefix: string;
+      kind?: string;
+    };
+    result: CommandArgSuggestionSummary[];
+  };
+  'interactions.list': {
+    params: {
+      sessionId?: string;
+    };
+    result: PendingInteraction[];
+  };
+  'interactions.respond': {
+    params: {
+      requestId: string;
+      response: InteractionResponse;
+    };
+    result: {
+      ok: boolean;
+    };
+  };
+  'interactions.cancel': {
+    params: {
+      requestId: string;
+      reason?: string;
+    };
+    result: {
+      ok: boolean;
+    };
+  };
+  'interactions.rehydrate': {
+    params: {
+      sessionId: string;
+    };
+    result: PendingInteraction[];
+  };
+  /**
+   * Dev browser: a window offers to host the pages the agent's `browser_*`
+   * tools drive (the GUI's main process). Released when the connection
+   * drops. It then answers each `browser:request` signal addressed to it.
+   */
+  'browser.registerHost': {
+    params: {
+      hostId: string;
+    };
+    result: {
+      ok: boolean;
+    };
+  };
+  'browser.unregisterHost': {
+    params: {
+      hostId: string;
+    };
+    result: {
+      ok: boolean;
+    };
+  };
+  'browser.respond': {
+    params: {
+      requestId: string;
+      response: BrowserResponse;
+    };
+    result: {
+      ok: boolean;
+    };
+  };
+  /**
+   * Terminals, run by the host in the session's environment. `clientId`
+   * names one view (a window's drawer or panel); views attached through a
+   * connection are detached when it drops. Output arrives as
+   * `terminal:output` signals; `ack` what was written to keep it flowing.
+   */
+  'terminal.state': {
+    params: {
+      sessionId: string;
+    };
+    result: TerminalSessionState;
+  };
+  'terminal.open': {
+    params: TerminalOpenInput;
+    result: TerminalInfo;
+  };
+  'terminal.attach': {
+    params: {
+      terminalId: string;
+      clientId: string;
+    };
+    result: TerminalAttachResult;
+  };
+  'terminal.detach': {
+    params: {
+      terminalId: string;
+      clientId: string;
+    };
+    result: void;
+  };
+  /** `clientId` + `response`: bytes the view's emulator generated (DSR/DA replies), dropped unless that view owns the size. */
+  'terminal.write': {
+    params: {
+      terminalId: string;
+      data: string;
+      clientId?: string;
+      response?: boolean;
+    };
+    result: void;
+  };
+  'terminal.resize': {
+    params: {
+      terminalId: string;
+      clientId: string;
+      cols: number;
+      rows: number;
+      claim?: boolean;
+    };
+    result: void;
+  };
+  'terminal.ack': {
+    params: {
+      terminalId: string;
+      clientId: string;
+      offset: number;
+    };
+    result: void;
+  };
+  'terminal.restart': {
+    params: {
+      terminalId: string;
+    };
+    result: TerminalInfo;
+  };
+  'terminal.close': {
+    params: {
+      terminalId: string;
+    };
+    result: void;
+  };
+  'terminal.setHidden': {
+    params: {
+      terminalId: string;
+      hidden: boolean;
+    };
+    result: void;
+  };
+  /**
+   * This connection can show terminals (the desktop app). While at least one
+   * viewer is attached, agents get the terminal tools; the registration is
+   * dropped with the connection.
+   */
+  'terminal.registerViewer': {
+    params: {
+      viewerId: string;
+    };
+    result: {
+      ok: boolean;
+    };
+  };
+  'terminal.unregisterViewer': {
+    params: {
+      viewerId: string;
+    };
+    result: {
+      ok: boolean;
+    };
+  };
+  'approvals.resolve': {
+    params: {
+      requestId: string;
+      decision: ApprovalDecision;
+    };
+    result: void;
+  };
+  'approvals.denyAll': {
+    params: {
+      sessionId?: string;
+    };
+    result: void;
+  };
+  'approvals.listPending': {
+    params: Record<string, never>;
+    result: WireApprovalRequest[];
+  };
+  /**
+   * Type-ahead queue, host-owned so every window sees and can manipulate
+   * the same list. `queue.add` queues when a run is in flight and sends
+   * immediately otherwise; the host auto-drains the queue FIFO at run end.
+   */
+  'queue.list': {
+    params: {
+      sessionId: string;
+    };
+    result: QueuedItem[];
+  };
+  /**
+   * Which `SYSTEM.md` override composes this session's prompt, for windows
+   * attaching to an already-warm agent.
+   *
+   * The `system-md` signal fires once per agent BUILD and the daemon caches
+   * agents, so the normal multi-window case (daemon already running, open a
+   * second terminal or the GUI) would otherwise never learn that the built-in
+   * safety and git doctrine has been replaced. `null` = no live agent yet, in
+   * which case the next build broadcasts it.
+   */
+  'sessions.systemMd': {
+    params: {
+      sessionId: string;
+    };
+    result: {
+      file: SystemMdFile | null;
+      shadowed: readonly SystemMdFile[];
+    } | null;
+  };
+  /**
+   * Every chunk of the session's system prompt with provenance — the
+   * Instructions tab. Built from the live agent's assembly, so it reflects
+   * MCP instructions, extension fragments and the resolved `SYSTEM.md`.
+   */
+  'sessions.contextSegments': {
+    params: {
+      sessionId: string;
+    };
+    result: ContextSegmentsReport | null;
+  };
+  /** Seed a user-scope `SYSTEM.md` from the session's doctrine; throws when an override could not apply. */
+  'sessions.createSystemOverride': {
+    params: {
+      sessionId: string;
+    };
+    result: {
+      path: string;
+      created: boolean;
+    };
+  };
+  'queue.add': {
+    /**
+     * `asCommand`: see `SendOptions.asCommand` — the host refuses when it cannot resolve it.
+     * `keepDraft`: see `SendOptions.keepDraft` — a prompt from outside the composer.
+     */
+    params: {
+      sessionId: string;
+      text: string;
+      activatedSkills?: string[];
+      attachments?: PromptAttachment[];
+      asCommand?: string;
+      keepDraft?: boolean;
+    };
+    result: {
+      delivered: 'queued' | 'sent' | 'steer';
+    };
+  };
+  'queue.remove': {
+    params: {
+      sessionId: string;
+      id: string;
+    };
+    result: boolean;
+  };
+  /**
+   * Edit a queued entry in place; order is kept. `attachments` replaces the
+   * entry's list when given. `false` when already sent / dropped.
+   */
+  'queue.update': {
+    params: {
+      sessionId: string;
+      id: string;
+      text: string;
+      attachments?: PromptAttachment[];
+    };
+    result: boolean;
+  };
+  /** A queued entry's attachments with their bytes; `null` when already sent / dropped. */
+  'queue.attachments': {
+    params: {
+      sessionId: string;
+      id: string;
+    };
+    result: PromptAttachment[] | null;
+  };
+  /** Steer a queued entry into the live run now (falls back to send when idle). */
+  'queue.pushNow': {
+    params: {
+      sessionId: string;
+      id: string;
+    };
+    result: {
+      delivered: 'steer' | 'send' | 'queued' | 'missing';
+    };
+  };
+  /** Current shared draft for a session — backfill on window attach. */
+  'drafts.get': {
+    params: {
+      sessionId: string;
+    };
+    result: {
+      text: string;
+      shell?: boolean;
+      attachments?: PromptAttachment[];
+      search?: {
+        active: boolean;
+        query: string;
+      };
+    };
+  };
+  /**
+   * Replace the session's shared draft. Fans out `draft:changed` to every
+   * OTHER peer. Ephemeral daemon state — drafts don't survive a daemon
+   * restart and are cleared when any window submits the prompt.
+   */
+  /**
+   * `shell` carries the prompt's shell mode OUT OF BAND — never encoded
+   * into the text, so a literal leading `!` in a normal draft can't flip
+   * other windows into shell-execution semantics.
+   */
+  'drafts.set': {
+    params: {
+      sessionId: string;
+      text: string;
+      shell?: boolean;
+    };
+    result: void;
+  };
+  /** Replace the shared draft's composing attachments (notification). */
+  'drafts.setAttachments': {
+    params: {
+      sessionId: string;
+      attachments: PromptAttachment[];
+    };
+    result: void;
+  };
+  /** Replace the shared transcript-search state (notification, per keystroke). */
+  'search.set': {
+    params: {
+      sessionId: string;
+      active: boolean;
+      query: string;
+    };
+    result: void;
+  };
+  /**
+   * Extension bus emit from a wire client whose extensions run CLIENT-side
+   * (TUI daemon mode — the extension has no host to broadcast through).
+   * Sent as a notification. The daemon validates the extension id against
+   * the session cwd's registry (boot registry when no `sessionId`) and the
+   * `'ipc'` permission, re-validates the 64 KiB payload cap, delivers to
+   * its own subscribers, and fans out `extension:signal` to every OTHER
+   * peer (origin excluded — the emitter already delivered locally).
+   */
+  'extension.emit': {
+    params: {
+      extensionId: string;
+      sessionId?: string;
+      payload: JsonValue;
+      seq: number;
+      nonce?: string;
+    };
+    result: void;
+  };
+  /**
+   * Resolve inline ghost-text autocomplete daemon-side (the typing
+   * window's request IS the single computation): canonical resolver
+   * against the session cwd's extension registry. Latest-wins per
+   * session — a `seq` older than the newest seen returns
+   * `{ suggestion: null }` without computing, and a newer request
+   * aborts an in-flight compute. The result additionally fans out as
+   * `suggest:changed` to every OTHER peer.
+   */
+  'suggest.resolve': {
+    params: {
+      sessionId: string;
+      text: string;
+      caret: number;
+      seq: number;
+    };
+    result: {
+      suggestion: string | null;
+      seq: number;
+      candidates?: string[];
+    };
+  };
+  'settings.get': {
+    params: Record<string, never>;
+    result: HostSettings;
+  };
+  'settings.set': {
+    params: {
+      patch: Partial<HostSettings>;
+    };
+    result: HostSettings;
+  };
+  /** Current presence snapshot — backfill for a freshly opened session list. */
+  'presence.list': {
+    params: Record<string, never>;
+    result: SessionPresence[];
+  };
+  /**
+   * Tag the calling peer as watching a session (one per connection; the
+   * TUI opens one connection per activated session). Sent as a
+   * notification right after the handshake. Detach is implicit — the
+   * daemon recomputes presence when the socket drops.
+   */
+  'presence.watch': {
+    params: {
+      sessionId: string;
+    };
+    result: void;
+  };
+  /**
+   * Where this host lets a session's folder be: a server's workspace roots
+   * (`confined`: `sessions.create` / `setFolder` refuse anything outside),
+   * or the user's home on a local host (unconfined). Additive.
+   */
+  'fs.roots': {
+    params: Record<string, never>;
+    result: FsRoots;
+  };
+  /**
+   * The folders in `path` (default: the first root), for a folder picker on
+   * the host's machine. Only inside the roots (real paths: `..` and
+   * symlinks out are refused), no dotfiles. Additive.
+   */
+  'fs.listDirs': {
+    params: {
+      path?: string;
+    };
+    result: FsDirListing;
+  };
+  /**
+   * The host's provider credentials, as the host's agents use them (its
+   * data dir's `credentials.json` and environment): per provider, whether
+   * something is configured, its stored API key / OAuth accounts (labels,
+   * which is active) and an env var it reads. Never a secret. Additive.
+   */
+  'auth.status': {
+    params: Record<string, never>;
+    result: {
+      providers: HostProviderAuth[];
+    };
+  };
+  /**
+   * Store an API key for one of the host's providers as its active
+   * credential, apply it to the host's environment, and rebuild agents
+   * (idle now, busy ones at run end). Returns the provider's new status.
+   * OAuth sign-in goes through `auth.oauth.*`. Additive.
+   */
+  'auth.setApiKey': {
+    params: {
+      provider: string;
+      key: string;
+    };
+    result: HostProviderAuth;
+  };
+  /**
+   * Remove one stored credential (`account`: its key from `auth.status`) or,
+   * without one, every stored credential of the provider; then as
+   * `auth.setApiKey`. A key the host only has from its own environment is
+   * left alone. Additive.
+   */
+  'auth.remove': {
+    params: {
+      provider: string;
+      account?: string;
+    };
+    result: {
+      removed: boolean;
+      provider: HostProviderAuth;
+    };
+  };
+  /**
+   * OAuth sign-in with the browser on the CLIENT and the tokens on the host:
+   * the host starts a provider's login (`provider`) or an MCP server's
+   * (`mcpServer`, found in `cwd`'s catalog, as `catalog.mcps`), keeping the
+   * PKCE verifier and `state`, and answers with the authorization URL.
+   * `mode: 'loopback'`: the client listens at `redirectUri` (a provider's
+   * fixed port; for an MCP server the loopback URI the client passed) and
+   * forwards the code; `'browser'`: the client opens `url` (pasting a code if
+   * the page shows one); `'device'`: shows `userCode`. The flow belongs to
+   * this connection, is single-use and expires (`expiresAt`). Additive.
+   */
+  'auth.oauth.begin': {
+    params: {
+      provider?: string;
+      mcpServer?: string;
+      cwd?: string;
+      kind?: string;
+      redirectUri?: string;
+    };
+    result: HostOAuthBegin;
+  };
+  /**
+   * Deliver the code (`code` + `state` from the loopback, or `input`: what
+   * the user pasted) once, then wait for the host's token exchange; without
+   * either, just wait (device and polling flows). A wrong `state` or another
+   * connection's flow is refused. Tokens stay on the host: the result says
+   * what changed, never a secret.
+   */
+  'auth.oauth.complete': {
+    params: {
+      flowId: string;
+      code?: string;
+      state?: string;
+      input?: string;
+    };
+    result: HostOAuthComplete;
+  };
+  /**
+   * Answer the step a flow is waiting on (`HostOAuthBegin.step` before its
+   * URL, `HostOAuthComplete.step` after): a select's option id (none:
+   * cancel), a prompt's text. Answers with where the flow is now: its URL, or
+   * the next step. Then `complete` as before. Additive.
+   */
+  'auth.oauth.respond': {
+    params: {
+      flowId: string;
+      stepId: string;
+      value?: string;
+    };
+    result: HostOAuthBegin;
+  };
+  /** Abandon a flow of this connection. */
+  'auth.oauth.cancel': {
+    params: {
+      flowId: string;
+    };
+    result: {
+      cancelled: boolean;
+    };
+  };
+  /**
+   * What the host discovered for the settings tabs, each entry with whether
+   * the host's settings enable it (an unset allowlist enables everything).
+   * `cwd` adds the project scope of that folder (inside the workspace roots
+   * on a server); without it, the user scope (the host user's home). The
+   * enabled lists are written with `settings.set`. Installing, removing and
+   * MCP sign-in stay on the host's machine. Additive.
+   */
+  'catalog.skills': {
+    params: {
+      cwd?: string;
+      kind?: string;
+    };
+    result: {
+      skills: HostCatalogSkill[];
+    };
+  };
+  /** MCP servers: `env` and `headers` values, URL credentials and query values are redacted. */
+  'catalog.mcps': {
+    params: {
+      cwd?: string;
+      kind?: string;
+    };
+    result: {
+      servers: HostCatalogMcp[];
+      errors: HostCatalogError[];
+    };
+  };
+  'catalog.extensions': {
+    params: {
+      cwd?: string;
+      kind?: string;
+    };
+    result: {
+      extensions: HostCatalogExtension[];
+    };
+  };
+  'catalog.plugins': {
+    params: {
+      cwd?: string;
+      kind?: string;
+    };
+    result: {
+      plugins: HostCatalogPlugin[];
+    };
+  };
+  /**
+   * Install a skill or an extension on the host, in its user's scope only
+   * (`scope` may only be `'user'`): a GitHub (`owner/repo[#ref][:dir]`, a
+   * GitHub URL, a skills.sh URL) or npm spec; paths are refused. `skills` /
+   * `all` pick from a multi-skill source (the `multiple-candidates` error
+   * lists them), `extension` from a multi-extension one. Runs the host's
+   * package managers and fetches code there: a zidane-server's
+   * `allowRemoteInstalls` gates it, every attempt is audited. Bounded in
+   * time; the progress lines come back with the result. Every window gets
+   * `catalog:changed`. Additive (`remoteInstalls` on `ipc.hello`).
+   */
+  'catalog.install': {
+    params: {
+      kind: HostInstallKind;
+      spec: string;
+      scope?: 'user';
+      skills?: string[];
+      all?: boolean;
+      extension?: string;
+      overwrite?: boolean;
+    };
+    result: {
+      installed: string[];
+      message: string;
+      progress: string[];
+    };
+  };
+  /** Remove a user-scope skill or extension of the host by name (its directory). As `catalog.install`. */
+  'catalog.remove': {
+    params: {
+      kind: HostInstallKind;
+      name: string;
+    };
+    result: {
+      removed: string;
+      message: string;
+    };
+  };
+  /** Update a user-scope extension installed from a source. As `catalog.install`. */
+  'catalog.update': {
+    params: {
+      kind: HostInstallKind;
+      name: string;
+    };
+    result: {
+      updated: string;
+      upToDate: boolean;
+      message: string;
+    };
+  };
+  /**
+   * Add or replace an MCP server in the host user's `mcps.json`. Its `env` /
+   * `headers` values are stored there and never come back (`catalog.mcps`
+   * redacts them, the reply names the server only). As `catalog.install`.
+   */
+  'mcp.upsert': {
+    params: {
+      config: McpServerConfig;
+    };
+    result: {
+      name: string;
+      created: boolean;
+    };
+  };
+  /** Remove an MCP server from the host user's `mcps.json`; `removed: false` when it has none. As `catalog.install`. */
+  'mcp.remove': {
+    params: {
+      name: string;
+    };
+    result: {
+      removed: boolean;
+    };
+  };
+  /**
+   * The host's credentialed providers (what its agents can run) and their
+   * models, for a model picker of a session on that host. `cwd` adds the
+   * providers its extensions contribute there. Additive.
+   */
+  'models.list': {
+    params: {
+      cwd?: string;
+      kind?: string;
+    };
+    result: {
+      providers: HostModelProvider[];
+    };
+  };
+  /**
+   * The machines this host knows (`docs/MACHINES.md`), online or not, and
+   * forgetting one (it disconnects; its `local@` / `worktree@` kinds stop
+   * resolving). Additive.
+   */
+  'machines.list': {
+    params: Record<string, never>;
+    result: MachineInfo[];
+  };
+  'machines.forget': {
+    params: {
+      machineId: string;
+    };
+    result: {
+      forgotten: boolean;
+    };
+  };
+  /**
+   * Folders of a machine, for a client's folder picker: the host proxies a
+   * listing to the machine (`fs.list`, confined to its roots there): the
+   * folders in `path` (absent: its first root), and every root. Additive.
+   */
+  'machines.listDirs': {
+    params: {
+      machineId: string;
+      path?: string;
+    };
+    result: {
+      path: string;
+      dirs: string[];
+      roots: string[];
+    };
+  };
+  /**
+   * A local host's machine links (`docs/MACHINES.md` § Client UI), behind
+   * remote hosts: share this computer with a saved server (the machine agent
+   * runs in this host's process, with the machine token `token` or the one
+   * already stored for that server), stop sharing, use a saved server as a
+   * machine (reverse direction), and read their state. Refused while remote
+   * hosts are off. Additive.
+   */
+  'machines.share.start': {
+    params: {
+      hostId: string;
+      name: string;
+      roots: string[];
+      token?: string;
+    };
+    result: MachineLinksStatus;
+  };
+  'machines.share.stop': {
+    params: {
+      hostId: string;
+    };
+    result: MachineLinksStatus;
+  };
+  'machines.useServer': {
+    params: {
+      hostId: string;
+      enabled: boolean;
+    };
+    result: MachineLinksStatus;
+  };
+  'machines.links.status': {
+    params: Record<string, never>;
+    result: MachineLinksStatus;
+  };
+  /**
+   * Reverse direction (`docs/MACHINES.md` § Reverse direction): a client asks
+   * this server to lend itself as a machine over this very connection
+   * (`allowAsMachine` on, else refused). `hostId` names the asking host, so
+   * a reconnect finds its tasks and terminals again. Then `machine.call`
+   * carries each host→machine request (`MachineMethods`), answered by the
+   * server's confined executor; machine notifications come back as
+   * `machine:notification` signals on this connection only.
+   */
+  'machine.attach': {
+    params: {
+      hostId: string;
+    };
+    result: MachineRegisterParams;
+  };
+  'machine.call': {
+    params: {
+      method: string;
+      params?: JsonValue;
+    };
+    result: JsonValue;
+  };
+  'machine.detach': {
+    params: Record<string, never>;
+    result: {
+      detached: boolean;
+    };
+  };
+  /**
+   * Mint a `machine`-scoped token on this server (a zidane-server only), so
+   * a window can share its computer in one step. Any client may: in the
+   * single-user model a client token is already an admin's. Audited.
+   */
+  'tokens.createMachineToken': {
+    params: {
+      name: string;
+    };
+    result: {
+      id: string;
+      name: string;
+      token: string;
+    };
+  };
+  'sync.status': {
+    params: Record<string, never>;
+    result: SyncStatus;
+  };
+  'sync.claim': {
+    params: {
+      deviceId: string;
+      deviceName: string;
+      takeover?: boolean;
+      categories?: SyncCategory[];
+      keys?: string[];
+    };
+    result: SyncClaimResult;
+  };
+  'sync.push': {
+    params: {
+      deviceId: string;
+      category: SyncCategory;
+      payload: SyncPayload;
+    };
+    result: SyncPushResult;
+  };
+  'sync.reset': {
+    params: {
+      field: string;
+    };
+    result: {
+      reset: boolean;
+    };
+  };
+  'sync.release': {
+    params: {
+      deviceId: string;
+    };
+    result: {
+      released: boolean;
+    };
+  };
+  'daemon.info': {
+    params: Record<string, never>;
+    result: HelloResult;
+  };
+  /**
+   * Graceful drain: deny pending approvals, abort live runs, close the
+   * socket. Used by clients that detect a protocol-version mismatch and
+   * need the stale daemon gone before respawning.
+   *
+   * `whenIdle` (version-skew retirement): a daemon with active work does
+   * NOT abort it. It answers `{ deferred: true }` and exits once idle.
+   * Explicit stops (`zidane daemon stop`) omit it and drain immediately.
+   * Daemons predating the flag ignore it and drain immediately.
+   */
+  'daemon.shutdown': {
+    params: {
+      whenIdle?: boolean;
+    };
+    result: {
+      deferred?: boolean;
+    } | void;
+  };
+}
+/** The host's identity from a hello (or `daemon.info`) reply; `null` from a host that predates it. */
+declare function hostRefOf(hello: HelloResult): HostRef | null;
+type IpcMethodName = keyof IpcMethods;
+type IpcParams<M extends IpcMethodName> = IpcMethods[M]['params'];
+type IpcResult<M extends IpcMethodName> = IpcMethods[M]['result'];
+/** Turns per `sessions.loadEvents` page when only `before` is given. */
+declare const LOAD_EVENTS_PAGE_TURNS = 200;
+/** Largest `limit` a host honors. */
+declare const LOAD_EVENTS_MAX_PAGE_TURNS = 1000;
+interface LoadEventsPaging {
+  /** Turn position (exclusive) the page ends at: a previous page's `cursor`. */
+  before?: number;
+  /** Turns in the page. */
+  limit?: number;
+}
+interface SessionEventsPage {
+  events: StreamEvent[];
+  /** Pass as `before` for the page before this one; absent once the first turn is in. */
+  cursor?: number;
+  /**
+   * The events are this page's slice of the whole replay, so pages
+   * concatenate to exactly one whole `loadEvents`. Absent from an older
+   * host, whose pages replay on their own ({@link loadAllEvents} restores
+   * the exchange separator at their joins).
+   */
+  exact?: true;
+  /**
+   * With `exact`: how many events of the whole replay come before this
+   * page. Lets a client open on the tail of a long transcript and still
+   * say how much it left out ({@link loadEventsTail}). Absent from an
+   * older host.
+   */
+  start?: number;
+}
+/**
+ * One page of `sessions.loadEvents` (see its paging). An older host answers
+ * the whole transcript: it comes back as one page with no cursor.
+ */
+declare function loadEventsPage(request: (method: 'sessions.loadEvents', params: {
+  sessionId: string;
+}) => Promise<StreamEvent[]>, params: {
+  sessionId: string;
+} & LoadEventsPaging): Promise<SessionEventsPage>;
+/**
+ * A session's whole transcript, loaded a page at a time from the end so no
+ * single reply carries it all (a long session with images can outgrow a
+ * transport's message size). A page refused as too large is asked again at
+ * half the turns, down to one; a single turn that still doesn't fit fails
+ * the load. An older host answers the whole transcript to the first call.
+ */
+declare function loadAllEvents(request: (method: 'sessions.loadEvents', params: {
+  sessionId: string;
+}) => Promise<StreamEvent[]>, sessionId: string, options?: {
+  pageTurns?: number;
+}): Promise<StreamEvent[]>;
+/** Turns per `sessions.getTurns` page by default. */
+declare const SESSION_TURNS_PAGE = 200;
+/** Largest `limit` a host honors for `sessions.getTurns`. */
+declare const SESSION_TURNS_MAX_PAGE = 1000;
+type SessionDocumentRequest = <M extends 'sessions.get' | 'sessions.getTurns'>(method: M, params: IpcParams<M>) => Promise<IpcResult<M>>;
+/**
+ * What `sessions.get` answers: the document; with `turns: false`, the
+ * version of the snapshot it was cut from, the one `sessions.getTurns`
+ * pages carry.
+ */
+type SessionDocumentHead = SessionData & {
+  version?: string;
+};
+/**
+ * A session's whole document, read a page of turns at a time so no reply
+ * carries it all (`sessions.getTurns` pages, then the `sessions.get`
+ * `turns: false` head; a page refused as too large is asked again at half
+ * the turns). Every page and the head name the snapshot they come from: a
+ * version change mid-read (a turn appended, a compaction) starts the read
+ * over, so the result is one version, never pages of two. After
+ * {@link SESSION_DOCUMENT_RESTARTS} restarts (a session busier than the
+ * read), the whole document comes in one reply. A host that predates
+ * `sessions.getTurns` sends it that way too; one that names no version is
+ * read as before. `null` when the host doesn't know the session.
+ */
+declare function loadSessionDocument(request: SessionDocumentRequest, sessionId: string, options?: {
+  pageTurns?: number;
+}): Promise<SessionData | null>;
+/** A catalog entry's on/off state as the host's settings decide it. */
+interface HostCatalogToggle {
+  name: string;
+  /** The host's settings enable it (always `false` for an entry that cannot load). */
+  enabled: boolean;
+  /**
+   * Its own allowlist governs it (`enabledSkills`, …). `false`: contributed
+   * by a plugin or extension (their toggle governs it), or broken.
+   */
+  toggleable: boolean;
+}
+interface HostCatalogSkill extends HostCatalogToggle {
+  description: string;
+  source?: 'project' | 'user' | 'inline' | 'builtin';
+  /** `SKILL.md` on the host's machine. */
+  location?: string;
+  /** `disk`: a scan path; else the plugin or extension that contributes it (`contributedBy`). */
+  origin: 'disk' | 'plugin' | 'extension';
+  contributedBy?: string;
+}
+/** Every secret-bearing value of a catalog entry is replaced by this. */
+declare const REDACTED = "<redacted>";
+interface HostCatalogMcp extends HostCatalogToggle {
+  transport: 'stdio' | 'sse' | 'streamable-http';
+  source: 'project' | 'user';
+  /** The config file on the host's machine. */
+  path: string;
+  command?: string;
+  args?: string[];
+  /** Credentials and query values redacted. */
+  url?: string;
+  cwd?: string;
+  scope?: 'host' | 'context';
+  auth?: 'oauth';
+  /** Names only: every value is {@link REDACTED}. */
+  env?: Record<string, string>;
+  headers?: Record<string, string>;
+}
+/** A config file that failed to parse (or an informational skip). */
+interface HostCatalogError {
+  path: string;
+  source: 'project' | 'user';
+  message: string;
+  informational?: boolean;
+}
+interface HostCatalogExtension extends HostCatalogToggle {
+  source: 'user' | 'project' | 'inline' | 'builtin';
+  version?: string;
+  description?: string;
+  dir?: string;
+  /** Why it did not load. */
+  error?: string;
+  /** What it contributes: `tools`, `skills`, `mcps`, `commands`, … */
+  capabilities?: string[];
+}
+interface HostCatalogPlugin extends HostCatalogToggle {
+  origin: {
+    kind: 'disk';
+    scope: 'project' | 'user';
+    dir: string;
+  } | {
+    kind: 'extension';
+    extensionName: string;
+    dir: string;
+  };
+  /** `false`: the manifest was rejected (`error` says why). */
+  ok: boolean;
+  version?: string;
+  description?: string;
+  skills: string[];
+  mcpServers: string[];
+  error?: string;
+}
+/** One provider a host can run, with its models (`models.list`). */
+interface HostModelProvider {
+  key: string;
+  label: string;
+  models: HostModelInfo[];
+}
+/** `ModelInfo` as it crosses the wire. */
+interface HostModelInfo {
+  id: string;
+  name?: string;
+  contextWindow: number;
+  maxTokens?: number;
+  reasoning?: boolean;
+  input?: ('text' | 'image')[];
+  cost?: {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+  };
+  provider?: string;
+  options?: {
+    id: string;
+    label: string;
+    description?: string;
+    costMultiplier?: {
+      input?: number;
+      output?: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+    };
+  }[];
+}
+/** One credential source of a host's provider (`auth.status`); no secret. */
+interface HostAuthMethod {
+  source: 'apikey' | 'oauth' | 'env';
+  /** A stored credential the provider resolves (`env` never is). */
+  active: boolean;
+  /** Credentials-file key of a stored credential: the `account` of `auth.remove`. */
+  key?: string;
+  /** OAuth account name. */
+  label?: string;
+  /** Display detail: `credentials.json`, an OAuth account and its expiry, an env var name. */
+  detail: string;
+}
+/** `auth.oauth.begin`: what the client shows and where the code comes back. */
+/**
+ * A question the provider's sign-in asks before (or after) its URL: a choice
+ * between flows, or a free text. The client shows it and answers with
+ * `auth.oauth.respond`; the host never picks for the user.
+ */
+type HostOAuthStep = {
+  id: string;
+  kind: 'select';
+  message: string;
+  options: Array<{
+    id: string;
+    label: string;
+  }>;
+} | {
+  id: string;
+  kind: 'prompt';
+  message: string;
+  placeholder?: string;
+  allowEmpty?: boolean;
+};
+interface HostOAuthBegin {
+  /** Random, single-use, bound to the connection that began it. */
+  flowId: string;
+  /** The authorization URL (a device flow: its verification URL); `''` while a `step` comes first. */
+  url: string;
+  /** `step`: answer {@link step} (`auth.oauth.respond`) before the URL exists. */
+  mode: 'loopback' | 'browser' | 'device' | 'step';
+  step?: HostOAuthStep;
+  /** `loopback`: where the browser is sent back, on the client's machine. */
+  redirectUri?: string;
+  /** `device`: the code to enter at `url`. */
+  userCode?: string;
+  instructions?: string;
+  /** Epoch ms: the host forgets the flow after it. */
+  expiresAt: number;
+}
+/** `auth.oauth.complete`: the outcome, never a token. */
+interface HostOAuthComplete {
+  /** A provider sign-in: its new status. */
+  provider?: HostProviderAuth;
+  /** An MCP server sign-in: its name. */
+  mcpServer?: string;
+  /** Not finished: the sign-in asks this. Answer it (`auth.oauth.respond`), then `complete` again. */
+  step?: HostOAuthStep;
+}
+interface HostProviderAuth {
+  key: string;
+  label: string;
+  /** Some credential source is present. */
+  configured: boolean;
+  /** The provider signs in with OAuth (on the host's machine only). */
+  oauth: boolean;
+  /** The env var it reads, when it declares one. */
+  envKey?: string;
+  methods: HostAuthMethod[];
+}
+interface FsRoots {
+  /** Real paths, the default first. */
+  roots: string[];
+  /** Session folders must be inside `roots` (a server). */
+  confined: boolean;
+}
+interface FsDirEntry {
+  name: string;
+  /** Real path (a symlink resolved). */
+  path: string;
+  /** Holds a `.git`. */
+  isGitRepo: boolean;
+}
+interface FsDirListing {
+  roots: string[];
+  /** The listed folder, as a real path. */
+  path: string;
+  /** The folder above, or `null` at a root. */
+  parent: string | null;
+  /** Sorted by name. */
+  entries: FsDirEntry[];
+  /** More folders than the listing returns. */
+  truncated?: boolean;
+}
+/** One row in a cross-window session list. */
+/** One ordered model-fallback target (primary excluded). */
+interface ModelFallbackRef {
+  providerKey: ProviderKey;
+  modelId: string;
+}
+interface SessionRow {
+  id: string;
+  title: string;
+  projectRoot: string | null;
+  cwd: string;
+  agentId?: string;
+  status: 'idle' | 'running' | 'completed' | 'error';
+  createdAt: number;
+  updatedAt: number;
+  archived: boolean;
+  /** Orchestration main session — see `SessionMeta.isMain`. Additive. */
+  isMain?: boolean;
+  providerKey?: ProviderKey;
+  modelId?: string;
+  effort?: ThinkingLevel;
+  modelOptions?: Record<string, boolean>;
+  /** Validated (head-matched) fallback chain tail, for pickers/badges. */
+  modelFallbacks?: ModelFallbackRef[];
+  /** Non-local environment summary (kind, state, branch, error). */
+  environment?: SessionEnvironmentSummary;
+  /** The host serving this row (`HelloResult.hostId`). Additive: absent from older hosts. */
+  hostId?: string;
+}
+interface CreateSessionParams {
+  /** Tool-execution directory — `projectRoot` is derived from it host-side. */
+  cwd: string;
+  title?: string;
+  agentId?: string;
+  providerKey?: ProviderKey;
+  modelId?: string;
+  /** Seed an ordered fallback chain alongside the model pick. */
+  fallbacks?: ModelFallbackRef[];
+  /** The model pick's reasoning effort and options, stamped with it. */
+  effort?: ThinkingLevel;
+  modelOptions?: Record<string, boolean>;
+  /** Skills pinned from the first turn (an authoring session's docs skill). */
+  pinnedSkills?: string[];
+  /** Mark as an extension-authoring session (auto-activates the docs skill). */
+  extensionEdit?: boolean;
+  /** Mark as a skill-authoring session for the named skill (dir = `cwd`). */
+  skillEdit?: {
+    name: string;
+  };
+  /** Where the session's work happens. Omitted → local. */
+  environment?: EnvironmentRequest;
+}
+interface HelloParams {
+  protocolVersion: number;
+  /** Client's zidane version — surfaced in daemon diagnostics. */
+  appVersion: string;
+  pid: number;
+  /**
+   * Build fingerprint (module mtime; `'unknown'` in compiled binaries).
+   * When BOTH sides report a real id and they differ, the daemon rejects
+   * the handshake like a protocol-version mismatch — the client drains it
+   * and respawns. Closes same-version code drift during development.
+   */
+  buildId?: string;
+  /**
+   * Version of the zidane code the client runs (`ZIDANE_VERSION`, inlined at
+   * build). Unlike `buildId` this survives compiled binaries, so it closes
+   * the gap released builds had: same protocol version, older code. A
+   * client STRICTLY NEWER than the daemon is rejected like a build mismatch
+   * and the stale daemon is drained; an older client is accepted and
+   * degrades via `optional()`.
+   */
+  codeVersion?: string;
+}
+/**
+ * What a host process is: a window's own (`in-process`), the local shared
+ * daemon (`daemon`), or a remote `zidane-server` (`server`).
+ */
+type HostKind = 'in-process' | 'daemon' | 'server';
+/** Which host a client is talking to, as clients keep it (from `hostRefOf`). */
+interface HostRef {
+  /** Stable across restarts: persisted in the host's data dir. */
+  id: string;
+  kind: HostKind;
+  /** Display name: the machine's hostname by default. */
+  name: string;
+}
+interface HelloResult {
+  protocolVersion: number;
+  appVersion: string;
+  pid: number;
+  startedAt: number;
+  buildId?: string;
+  codeVersion?: string;
+  /**
+   * Host identity (additive). `hostId` is a UUID persisted once in the host's
+   * data dir, so it survives restarts; the in-process host and the local
+   * daemon share the data dir, and so the id: they are the same computer.
+   */
+  hostId?: string;
+  hostKind?: HostKind;
+  hostName?: string;
+  /**
+   * The daemon is older than a client that attached while it had active
+   * work: it accepted the handshake instead of draining (which would abort
+   * those runs) and exits once idle. Clients attach normally; their
+   * reconnect path lands on a fresh daemon after the exit.
+   */
+  retiring?: boolean;
+  /**
+   * Names this host process's signal numbering ({@link SIGNAL_SEQ_FIELD}):
+   * a position from another epoch cannot be resumed. Additive.
+   */
+  signalEpoch?: string;
+  /**
+   * This server lends itself as a machine to the hosts of its clients
+   * (`machine.attach`, `allowAsMachine` on). Absent: it doesn't. Additive.
+   */
+  machineServe?: boolean;
+  /**
+   * This server takes installs and removals from its clients (`catalog.install`
+   * / `remove` / `update`, `mcp.upsert` / `remove`; `allowRemoteInstalls` on).
+   * Absent: it doesn't (or predates them). Additive.
+   */
+  remoteInstalls?: boolean;
+  /** This server takes settings sync from a client's computer (`sync.*`). Absent: it doesn't. Additive. */
+  sync?: boolean;
+}
+/** `catalog.install` / `remove` / `update`: what is installed from a client, in the host user's scope. */
+type HostInstallKind = 'skill' | 'extension';
+//#endregion
+//#region src/ipc/transports/client-core.d.ts
+interface IpcClient {
+  hello: HelloResult;
+  request: <M extends IpcMethodName>(method: M, params: IpcParams<M>) => Promise<IpcResult<M>>;
+  /**
+   * Fire-and-forget notification — same method table as `request`, but no
+   * id, no response, no pending-promise bookkeeping. The hot path for
+   * high-frequency writes (per-keystroke draft sync). Daemons that don't
+   * know the method ignore it silently.
+   */
+  notify: <M extends IpcMethodName>(method: M, params: IpcParams<M>) => void;
+  /** Host signals, with their number in their session when they have one (`SignalMeta`). */
+  onSignal: (cb: SignalListener) => () => void;
+  close: () => void;
+}
+type SignalListener = (signal: HostSignal, meta?: SignalMeta) => void;
+declare class IpcVersionMismatchError extends Error {
+  readonly daemon?: HelloResult | undefined;
+  constructor(message: string, daemon?: HelloResult | undefined);
+}
+//#endregion
+export { LOAD_EVENTS_PAGE_TURNS as A, SessionResumeResult as B, IPC_PROTOCOL_VERSION as C, IpcParams as D, IpcMethods as E, SESSION_TURNS_PAGE as F, loadEventsPage as G, SignalMeta as H, SIGNAL_SEQ_FIELD as I, loadSessionDocument as K, SequencedSignal as L, ModelFallbackRef as M, REDACTED as N, IpcResult as O, SESSION_TURNS_MAX_PAGE as P, SessionDocumentHead as R, HostRef as S, IpcMethodName as T, hostRefOf as U, SessionRow as V, loadAllEvents as W, HostModelProvider as _, FsDirListing as a, HostOAuthStep as b, HelloResult as c, HostCatalogExtension as d, HostCatalogMcp as f, HostModelInfo as g, HostKind as h, FsDirEntry as i, LoadEventsPaging as j, LOAD_EVENTS_MAX_PAGE_TURNS as k, HostAuthMethod as l, HostCatalogSkill as m, IpcVersionMismatchError as n, FsRoots as o, HostCatalogPlugin as p, CreateSessionParams as r, HelloParams as s, IpcClient as t, HostCatalogError as u, HostOAuthBegin as v, IpcErrorCode as w, HostProviderAuth as x, HostOAuthComplete as y, SessionEventsPage as z };
+//# sourceMappingURL=client-core-BQSyDALT.d.ts.map