zidane 6.6.4 → 7.0.0

package/dist/ipc.d.ts

@@ -0,0 +1,849 @@
+import { Cd as ProviderKey, Cu as StreamEvent, Ha as ExtensionBus, Og as ThinkingLevel, Sg as SessionTurn, Zh as JsonValue, if as InteractionResponse, yp as ContextBreakdown } from "./index-B-FSaM3_.js";
+import { An as ChatHostEnvironment, Bn as RunningWorkItem, Cn as PendingAnnotation, Dn as ApprovalRequestInput, En as ApprovalHub, Fn as HostSettings, Gn as WireApprovalRequest, Hn as SerializedPreview, In as HostSignal, Ln as PendingInteraction, Mn as ApprovalOriginator, Nn as CommandArgSuggestionSummary, On as createApprovalHub, Pn as CommandSummary, Rn as PromptAttachment, Sn as EditOutcomeLedger, Tn as runCompaction, Un as SessionPresence, Vn as SendOptions, Wn as TodosSnapshot, _n as CreateWorkerParams, bn as InteractionHub, dn as readFileSafe, fn as resolveCwdPath, gn as createChatHost, hn as ContextSegmentsReport, jn as PendingApprovalsStore, kn as createMemoryApprovalsStore, mn as ChatHost, pn as serializePreview, un as extractEditPayloadForGate, v as SystemMdFile, vn as WorkerRow, wn as CompactionEntry, xn as createInteractionHub, yn as WorkerSummary, zn as QueuedItem } from "./index-DgdzXRPH.js";
+import { O as ResolvedConfig } from "./transcript-anchors-DXqWWGbq.js";
+import { p as TodoItem } from "./turn-operations-DKFYWP3O.js";
+import { T as SessionHistoryMatch, V as ApprovalDecision, w as SearchTurnResult } from "./tool-formatters-DO56YBBw.js";
+
+//#region src/ipc/attach.d.ts
+interface AttachOptions {
+  socketPath?: string;
+  /** Attach to this session id (prefix match against the list). */
+  sessionId?: string;
+  /** Create a fresh session instead of picking. */
+  createNew?: boolean;
+  cwd?: string;
+  appVersion?: string;
+  /** Spawn-on-demand command when no daemon is listening. */
+  spawnCommand?: string[];
+  /** Injectable streams for tests. */
+  stdin?: NodeJS.ReadableStream;
+  stdout?: NodeJS.WritableStream;
+}
+declare function runAttach(options?: AttachOptions): Promise<void>;
+//#endregion
+//#region src/ipc/daemon/lifecycle.d.ts
+/**
+ * Build fingerprint for the handshake — the mtime of this module's file
+ * at import time. Client and daemon load the same file from disk, so a
+ * daemon spawned before a rebuild (or a source edit in dev) reports a
+ * different id than a freshly-started client, and the client drains +
+ * respawns it. This closes the "same protocol version, different code"
+ * gap that a hand-bumped version constant can't: during development the
+ * daemon process is frozen at spawn while the tree keeps moving.
+ *
+ * Compiled binaries (`/$bunfs/…` virtual paths) can't be stat'ed and
+ * report `'unknown'`; the check is skipped when EITHER side is unknown,
+ * so released builds rely on `IPC_PROTOCOL_VERSION` alone — correct,
+ * since their code only changes when the version does.
+ */
+declare const IPC_BUILD_ID: string;
+declare function defaultSocketPath(): string;
+/**
+ * Spawn command that re-enters the CURRENT zidane program as `… daemon`.
+ *
+ * Three launch shapes:
+ *   - compiled Bun binary — `Bun.main` is the virtual `/$bunfs/…` entry the
+ *     binary self-inserts as argv[1], so the spawn must NOT repeat it
+ *     (verified: repeating it makes the child parse the junk path as its
+ *     subcommand and boot the full TUI instead of the daemon).
+ *   - dev (`bun run cli.ts`) — the script path must ride along.
+ *   - Node hosts (no `Bun` global) — fall back to the published bin.
+ */
+declare function selfDaemonSpawnCommand(): string[];
+/**
+ * True when something accepts connections on `socketPath`. Distinguishes a
+ * live daemon from a stale socket file left by a crashed one.
+ */
+declare function probeSocket(socketPath: string, timeoutMs?: number): Promise<boolean>;
+interface EnsureDaemonOptions {
+  socketPath?: string;
+  /**
+   * Command used to spawn the daemon when nothing is listening. Defaults to
+   * `['zidane-daemon']` (the published bin). The child is detached and
+   * unref'd — it outlives the spawning client by design.
+   */
+  spawnCommand?: string[];
+  /** Total time to wait for the daemon to accept connections. */
+  timeoutMs?: number;
+}
+/**
+ * Make sure a daemon is listening, spawning one if needed. Resolves with
+ * the socket path once a connection succeeds; rejects when the daemon
+ * failed to come up within `timeoutMs`.
+ */
+declare function ensureDaemonRunning(options?: EnsureDaemonOptions): Promise<string>;
+//#endregion
+//#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.
+ *   - 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.
+ */
+declare const IPC_PROTOCOL_VERSION = 8;
+/**
+ * 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;
+};
+/**
+ * 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;
+  };
+  'chat.steer': {
+    params: {
+      sessionId: string;
+      message: string;
+    };
+    result: void;
+  };
+  'chat.followUp': {
+    params: {
+      sessionId: string;
+      message: string;
+    };
+    result: void;
+  };
+  'chat.pushQueued': {
+    params: {
+      sessionId: string;
+      message: string;
+      activatedSkills?: string[];
+    };
+    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;
+  };
+  '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[];
+  };
+  'sessions.create': {
+    params: CreateSessionParams;
+    result: SessionRow;
+  };
+  'sessions.delete': {
+    params: {
+      sessionId: string;
+    };
+    result: void;
+  };
+  'sessions.setTitle': {
+    params: {
+      sessionId: string;
+      title: string;
+    };
+    result: void;
+  };
+  '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;
+  };
+  /**
+   * `fallbacks` (ordered, primary excluded) is PATCH-like: omitted
+   * leaves a persisted chain untouched; an explicit `[]` clears it;
+   * non-empty persists the canonical `metadata.modelChain`
+   * (`[primary, ...fallbacks]`, TUI byte format);
+   * see the patch-like semantics above.
+   */
+  'sessions.setModel': {
+    params: {
+      sessionId: string;
+      providerKey: ProviderKey;
+      modelId: string;
+      fallbacks?: ModelFallbackRef[];
+    };
+    result: void;
+  };
+  'sessions.setModelOptions': {
+    params: {
+      sessionId: string;
+      options: Record<string, boolean>;
+    };
+    result: void;
+  };
+  'sessions.loadEvents': {
+    params: {
+      sessionId: string;
+    };
+    result: StreamEvent[];
+  };
+  'sessions.getTurn': {
+    params: {
+      sessionId: string;
+      turnId: string;
+    };
+    result: SessionTurn | null;
+  };
+  'sessions.contextBreakdown': {
+    params: {
+      sessionId: string;
+    };
+    result: ContextBreakdown | 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;
+  };
+  'sessions.compact': {
+    params: {
+      sessionId: string;
+    };
+    result: void;
+  };
+  '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.
+   */
+  'todos.set': {
+    params: {
+      sessionId: string;
+      items: readonly TodoItem[];
+    };
+    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;
+    };
+    result: CommandSummary[];
+  };
+  /** Argument suggestions for `/name <prefix>` — best-effort, empty on failure. */
+  'commands.completeArgs': {
+    params: {
+      cwd: string;
+      name: string;
+      argsPrefix: 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[];
+  };
+  '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': {
+    params: {
+      sessionId: string;
+      text: string;
+      activatedSkills?: string[];
+      attachments?: PromptAttachment[];
+    };
+    result: {
+      delivered: 'queued' | 'sent';
+    };
+  };
+  'queue.remove': {
+    params: {
+      sessionId: string;
+      id: string;
+    };
+    result: boolean;
+  };
+  /** 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' | '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;
+  };
+  '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.
+   */
+  'daemon.shutdown': {
+    params: Record<string, never>;
+    result: void;
+  };
+}
+type IpcMethodName = keyof IpcMethods;
+type IpcParams<M extends IpcMethodName> = IpcMethods[M]['params'];
+type IpcResult<M extends IpcMethodName> = IpcMethods[M]['result'];
+/** 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[];
+}
+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[];
+  /** Mark as an extension-authoring session (auto-activates the docs skill). */
+  extensionEdit?: boolean;
+}
+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;
+}
+interface HelloResult {
+  protocolVersion: number;
+  appVersion: string;
+  pid: number;
+  startedAt: number;
+  buildId?: string;
+}
+//#endregion
+//#region src/ipc/client.d.ts
+declare class IpcVersionMismatchError extends Error {
+  readonly daemon?: HelloResult | undefined;
+  constructor(message: string, daemon?: HelloResult | undefined);
+}
+interface IpcClientOptions {
+  socketPath: string;
+  /** Client zidane version, surfaced in daemon diagnostics. */
+  appVersion?: string;
+  /** Called when the daemon connection drops (socket close/error). */
+  onClose?: () => void;
+  /**
+   * On a version/build mismatch, ask the stale daemon to drain before
+   * throwing (default). PASSIVE clients (the presence watcher) must set
+   * this false: they retry on a timer, and an old-build window left open
+   * across a protocol bump would otherwise drain the NEW daemon in a
+   * loop, aborting every other window's runs.
+   */
+  drainOnMismatch?: boolean;
+}
+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;
+  onSignal: (cb: (signal: HostSignal) => void) => () => void;
+  close: () => void;
+}
+declare function connectIpcClient(options: IpcClientOptions): Promise<IpcClient>;
+/**
+ * One-call convenience for windows: make sure a daemon is up (spawning if
+ * needed), connect, and — when the running daemon speaks an older protocol
+ * — drain it and spawn a fresh one before retrying once.
+ */
+declare function connectOrSpawnDaemon(options?: Omit<IpcClientOptions, 'socketPath'> & EnsureDaemonOptions): Promise<IpcClient>;
+//#endregion
+//#region src/ipc/daemon/environment.d.ts
+interface DaemonEnvironment extends ChatHostEnvironment {
+  writeSettings: (patch: Partial<HostSettings>) => HostSettings;
+  /** Drop the per-cwd runtime-config memo (settings changed). */
+  invalidateRuntime: () => void;
+  /** Base config resolved at daemon boot (paths, store, state). */
+  config: ResolvedConfig;
+  /**
+   * Shared extension bus for daemon-side registries (`ctx.bus`). The
+   * server delivers validated `extension.emit` notifications into it;
+   * daemon-side emits leave through its `onEmit` → `broadcast`. Optional:
+   * test environments without extensions omit it.
+   */
+  extensionBus?: ExtensionBus;
+}
+/**
+ * File-backed pending-approvals persistence (`pending-approvals.json` next
+ * to `state.json`). Small, rewritten atomically enough for its purpose —
+ * the queue holds at most a handful of rows.
+ */
+declare function createFileApprovalsStore(path: string): PendingApprovalsStore;
+declare function createDaemonEnvironment(options: {
+  broadcast: (signal: HostSignal) => void; /** Base cwd for boot-time config resolution. Default: `process.cwd()`. */
+  cwd?: string;
+  debugStream?: boolean;
+}): Promise<DaemonEnvironment>;
+//#endregion
+//#region src/ipc/daemon/server.d.ts
+interface IpcDaemonOptions {
+  socketPath: string;
+  /**
+   * Environment factory — the production daemon uses the disk-backed
+   * `createDaemonEnvironment`; tests inject an in-memory one. Receives the
+   * broadcast sink wired to peer fan-out.
+   */
+  createEnvironment?: (broadcast: (signal: HostSignal) => void) => DaemonEnvironment | Promise<DaemonEnvironment>;
+  appVersion?: string;
+  /**
+   * Called when the daemon has had zero peers for `idleShutdownMs` and no
+   * session is running. The CLI exits the process; embedded servers ignore.
+   */
+  idleShutdownMs?: number;
+  onIdle?: () => void;
+  onLog?: (line: string) => void;
+}
+interface IpcDaemon {
+  socketPath: string;
+  host: ChatHost;
+  peerCount: () => number;
+  close: () => Promise<void>;
+}
+declare function startIpcDaemon(options: IpcDaemonOptions): Promise<IpcDaemon>;
+//#endregion
+export { type ApprovalHub, type ApprovalOriginator, type ApprovalRequestInput, type AttachOptions, type ChatHost, type ChatHostEnvironment, type CompactionEntry, type CreateSessionParams, type DaemonEnvironment, EditOutcomeLedger, type EnsureDaemonOptions, type HelloParams, type HelloResult, type HostSettings, type HostSignal, IPC_BUILD_ID, IPC_PROTOCOL_VERSION, type InteractionHub, type IpcClient, type IpcClientOptions, type IpcDaemon, type IpcDaemonOptions, IpcErrorCode, type IpcMethodName, type IpcMethods, type IpcParams, type IpcResult, IpcVersionMismatchError, type PendingAnnotation, type PendingApprovalsStore, type PendingInteraction, type PromptAttachment, type QueuedItem, type RunningWorkItem, type SendOptions, type SerializedPreview, type SessionPresence, type SessionRow, type TodosSnapshot, type WireApprovalRequest, connectIpcClient, connectOrSpawnDaemon, createApprovalHub, createChatHost, createDaemonEnvironment, createFileApprovalsStore, createInteractionHub, createMemoryApprovalsStore, defaultSocketPath, ensureDaemonRunning, extractEditPayloadForGate, probeSocket, readFileSafe, resolveCwdPath, runAttach, runCompaction, selfDaemonSpawnCommand, serializePreview, startIpcDaemon };
+//# sourceMappingURL=ipc.d.ts.map