@xrkseek/harness 0.4.12 → 0.5.1

package/node_modules/@xrkseek/server-face/dist/index.d.mts

@@ -0,0 +1,3734 @@
+import { AdmitReceipt, SessionDrainCancelOptions, SessionRecord, SessionStore } from "@xrkseek/core-session";
+import { ApprovalPolicy, FeedbackCategory, PermissionKnobState, PlanProjection, SandboxMode, SessionEvent, TodoItem, WorkspaceChangesSummary } from "@xrkseek/protocol";
+import { AuthMode, ProtocolId, ProviderBinding, ProviderRegistry, RoutingLlmAdapter } from "@xrkseek/llm-registry";
+import { ProjectionCheckpoint, ProjectionDefinition, ProjectionSnapshot, ProjectionWire, SessionProjectionRegistry, SessionProjectionRegistryOptions } from "@xrkseek/session-projection";
+import { ApprovalHandler, PresentToolLookup, PresentToolLookup as PresentToolLookup$1, SESSION_QUERY_ROUTING_PROMPT_TEXT, SUBAGENT_ROUTING_PROMPT_TEXT, ToolCallPairing, ToolCallPairing as ToolCallPairing$1, ToolDefinition, ToolEventView, ToolEventView as ToolEventView$1, ToolPipelineContext, ToolRegistry } from "@xrkseek/core-tools";
+import { ProposeSkillDraft, Recipe } from "@xrkseek/workspace";
+import { DISABLED_PLUGINS_FILE, ManagedPackageIndex, ManagedPluginPackageMeta, PermissionRequestDecision, atomicWriteText, clearSoftDisabledIdsAt, isPluginSoftDisabledAt, lookupManagedPluginSourceAt, readDisabledPluginIdsAt, readManagedPackageIndexAt, readManagedPluginPackagesAt, reconcileManagedProcessPlugins, setSoftDisabledAt, writeDisabledPluginIdsAt } from "@xrkseek/server-loader";
+import { spawn } from "node:child_process";
+import { PolicyEngine } from "@xrkseek/policy";
+import { AttachmentStore, FileAttachmentLimits, ImageAttachmentLimits } from "@xrkseek/attachment";
+import { GitRunner, WorkspaceCheckpointRecord, WorkspaceCheckpointStore } from "@xrkseek/checkpoint";
+import { ShellService } from "@xrkseek/exec-shell";
+import { IncomingMessage, Server, ServerResponse } from "node:http";
+import WebSocket, { WebSocketServer } from "ws";
+import { AgentHandle } from "@xrkseek/core-agent";
+import { LlmAdapter } from "@xrkseek/llm";
+//#region src/types.d.ts
+type RpcId = string;
+interface FaceRpcRequest<P = unknown> {
+  readonly rpcId: RpcId;
+  readonly payload: P;
+}
+/** Handler-side fail. Wire always gets `details` via `errResponse`. */
+type FaceRpcFail = {
+  readonly code: string;
+  readonly message: string;
+  readonly details?: Record<string, unknown>;
+};
+/** 产品壳 Zod 要求：线上错误必须有 `details`。 */
+type FaceRpcError = {
+  readonly code: string;
+  readonly message: string;
+  readonly details: Record<string, unknown>;
+};
+type FaceRpcResult<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly error: FaceRpcFail;
+};
+/** Unary response — Face `type: server-response`. */
+interface FaceRpcResponse<T = unknown> {
+  readonly type: "server-response";
+  readonly rpcId: RpcId;
+  readonly result: {
+    readonly ok: true;
+    readonly value: T;
+  } | {
+    readonly ok: false;
+    readonly error: FaceRpcError;
+  };
+}
+/** DSH `POST /api/respond` 回执。 */
+type FaceRpcReceipt = {
+  readonly accepted: true;
+} | {
+  readonly accepted: false;
+  readonly reason: "not-pending" | "bad-response";
+};
+type MuxFrame = {
+  readonly type: "session/event";
+  readonly sessionId: string;
+  readonly event: unknown;
+  readonly seq: number;
+  /** Host-computed, non-persisted tool card (optional). */
+  readonly view?: unknown;
+} | {
+  readonly type: "session/projection";
+  readonly sessionId: string;
+  readonly key: string;
+  readonly value: unknown;
+  readonly seq: number;
+} | {
+  readonly type: "session/subscribed";
+  readonly sessionId: string;
+  readonly lastSeq: number;
+} | {
+  readonly type: "session/queue";
+  readonly sessionId: string;
+  readonly items: readonly unknown[];
+} |
+/** DSH `session/jobs` — whole-set snapshot; omit baseline when empty. */
+{
+  readonly type: "session/jobs";
+  readonly sessionId: string;
+  readonly jobs: readonly unknown[];
+} |
+/** 产品壳可应答审批（稳定 rpcId 在 server-request 信封上）。 */
+{
+  readonly type: "approval/requested";
+  readonly sessionId: string;
+  readonly approvalId: string;
+  readonly toolName: string;
+  readonly callId?: string;
+  readonly reason?: string;
+  /** tool · network · escalation (Codex-style UX split). */
+  readonly category?: "tool" | "network" | "escalation";
+  readonly networkHost?: string;
+  readonly networkProtocol?: string;
+} | {
+  readonly type: "approval/resolved";
+  readonly sessionId: string;
+  readonly approvalId: string;
+  readonly outcome: "allowed-once" | "rejected" | "cancelled" | "unavailable";
+} |
+/** Face `question/requested` — answerable server-request (rpcId on envelope). */
+{
+  readonly type: "question/requested";
+  readonly sessionId: string;
+  readonly questions: readonly FaceQuestionItem[];
+} | {
+  readonly type: "question/resolved";
+  readonly sessionId: string;
+  readonly questionRpcId: string;
+  readonly outcome: "answered" | "cancelled";
+};
+/** Face `AskUserQuestionItem` (product-shell Zod). */
+interface FaceQuestionItem {
+  readonly id: string;
+  readonly question: string;
+  readonly header?: string;
+  readonly detail?: string;
+  readonly options?: readonly {
+    readonly label: string;
+    readonly description?: string;
+  }[];
+  readonly multiSelect?: boolean;
+  readonly intent?: {
+    readonly kind: "plan-review";
+    readonly approve: string;
+  };
+}
+/** Face `AskUserQuestionAnswer`. */
+interface FaceQuestionAnswer {
+  readonly answers: readonly FaceQuestionAnswerItem[];
+}
+interface FaceQuestionAnswerItem {
+  readonly id: string;
+  readonly selected: readonly string[];
+  readonly custom?: string;
+}
+type HostFrame = {
+  readonly type: "host/session-added";
+  readonly sessionId: string;
+  readonly blank: boolean;
+  readonly agentPreset?: string;
+  readonly cwd?: string;
+  readonly parentSessionId?: string;
+  readonly origin?: "subagent" | "fork";
+} | {
+  readonly type: "host/session-removed";
+  readonly sessionId: string;
+} | {
+  readonly type: "host/session-status";
+  readonly sessionId: string;
+  readonly running: boolean;
+} | {
+  readonly type: "host/agent-error";
+  readonly sessionId: string;
+  readonly message: string;
+} | {
+  readonly type: "host/workspace-changed";
+  readonly workspace: {
+    readonly workspaceId: string;
+    readonly path: string;
+    readonly title: string;
+    readonly sessionIds: readonly string[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+  };
+} | {
+  readonly type: "host/workspace-removed";
+  readonly workspaceId: string;
+} | {
+  readonly type: "host/workspace-order-changed";
+  readonly workspaceIds: readonly string[];
+} | {
+  readonly type: "host/archived-sessions-changed";
+  readonly archivedSessionIds: readonly string[];
+} | {
+  readonly type: "host/pinned-sessions-changed";
+  readonly pinnedSessionIds: readonly string[];
+} | {
+  /** DSH `host/remote-event` — allowlisted Host events for `ctx.remote.$dispatch`. */
+  readonly type: "host/remote-event";
+  readonly event: string;
+  readonly args: readonly unknown[];
+};
+//#endregion
+//#region src/wire/envelope.d.ts
+/**
+ * 解析 unary body。接受 DSH `{ type: client-request }` 与瘦形 `{ rpcId, payload }`。
+ */
+declare function parseFaceRpcRequest(body: unknown): FaceRpcRequest;
+/** DSH unary 成功信封。 */
+declare function okResponse<T>(rpcId: RpcId, value: T): FaceRpcResponse<T>;
+/** DSH unary 失败信封；必含 `details`。 */
+declare function errResponse(rpcId: RpcId, code: string, message: string, details?: unknown): FaceRpcResponse<never>;
+/** DSH WS 下行：`server-request`，method = payload.type。 */
+declare function serverRequestFrame(rpcId: RpcId, payload: {
+  readonly type: string;
+} & Record<string, unknown>): {
+  readonly type: "server-request";
+  readonly rpcId: RpcId;
+  readonly method: string;
+  readonly payload: typeof payload;
+};
+//#endregion
+//#region src/wire/rpc-error.d.ts
+/** 产品壳浏览器客户端接受的 code（RpcErrorDetailsMap 键）。 */
+declare const FACE_RPC_ERROR_CODES: readonly ["bad-request", "cancelled", "session-not-found", "model-unavailable", "session-conflict", "invalid-time-zone", "workspace-attach-failed", "workspace-not-found", "workspace-invalid-path", "workspace-name-conflict", "workspace-move-invalid", "directory-unreadable", "directory-exists", "directory-create-failed", "directory-picker-unavailable", "agent-preset-read-only", "agent-preset-locked", "agent-preset-conflict", "agent-preset-not-found", "agent-preset-invalid", "agent-busy", "attachment-error", "queue-item-not-found", "steer-unavailable", "command-error", "unknown-command", "settings-rejected", "settings-conflict", "credential-rejected", "model-discovery-failed", "title-invalid", "fork-unavailable", "subagent-parent-unavailable", "subagent-not-found", "subagent-catalog-diagnostic", "subagent-not-resumable", "subagent-unauthorized", "subagent-delivery-unavailable", "job-not-found", "job-host-unavailable", "job-not-foreground", "policy-denied", "policy-ask", "internal"];
+type FaceRpcErrorCode = (typeof FACE_RPC_ERROR_CODES)[number];
+/**
+ * 把 handler 错误归一成产品壳可解析的 RpcError。
+ * 未知 / 仅 XRK 的 code 折到最近壳侧码或 `internal`。
+ */
+declare function mapFaceRpcError(code: string, message: string, details?: unknown): FaceRpcError;
+//#endregion
+//#region src/wire/paths.d.ts
+/**
+ * Face HTTP/WS 路径：与产品壳 apiproxy 同形。
+ *
+ * Unary 两类：
+ * - 点号方法：`/api/session.prompt`（须含 `.`，避免抢走 REST `/api/sessions`）
+ * - Typert Remote：`/api/commands/execute`（`ns/method`；白名单 namespace）
+ */
+declare const FACE_WS_PATHS: readonly ["/api/face/events.mux", "/api/face/events.host", "/api/events.mux", "/api/events.host"];
+declare const FACE_RESPOND_PATHS: readonly ["/api/respond", "/api/face/respond"];
+/**
+ * 产品壳 `connection.rpc.call("/api", endpoint)` 会打的 Remote namespace。
+ * 未实现的 endpoint 仍要认领，回合法 Face 信封，禁止 HTTP 404。
+ */
+declare const FACE_REMOTE_NAMESPACES: Set<string>;
+declare function isFaceRespondPath(pathname: string): boolean;
+declare function isFaceWsPath(pathname: string): boolean;
+declare function isFaceHttpPath(pathname: string): boolean;
+/**
+ * 从 pathname 解析 unary method。
+ * - `/api/face/session.prompt`（U1 前缀）
+ * - `/api/session.prompt`（DSH 点号形）
+ * - `/api/commands/execute`（DSH Typert Remote）
+ */
+declare function faceMethodFromPath(pathname: string): string | undefined;
+//#endregion
+//#region src/wire/loopback.d.ts
+/**
+ * 本机回环判定：产品壳同源 fetch/WS 不带 Authorization。
+ */
+declare function isLoopbackAddress(address: string | undefined): boolean;
+//#endregion
+//#region src/adapt/job-view.d.ts
+/**
+ * Wire `JobView` (copied from `@xrkseek/xrk-host-apiproxy` `api/jobs.ts`).
+ * Registry internals (`ownerSession`, `reported`, `outputLimitBytes`) stay off
+ * the wire — the mux frame's `sessionId` is the owner. Optional `foreground`
+ * marks a yield-attached wait.
+ */
+type JobViewStatus = "running" | "stopping" | "completed" | "killed" | "failed";
+interface JobView {
+  readonly id: string;
+  readonly kind: string;
+  readonly label: string;
+  readonly status: JobViewStatus;
+  readonly detail?: string;
+  readonly startedAt: number;
+  readonly finishedAt?: number;
+  readonly foreground?: boolean;
+}
+/**
+ * Project snapshots onto the wire view, dropping internal fields.
+ * Copied from apiproxy `jobViews`.
+ */
+declare function jobViews(snapshots: readonly JobView[]): JobView[];
+interface FaceJobsSource {
+  list(): readonly JobView[];
+  onJobsChanged(listener: () => void): () => void;
+}
+/** Face tool-jobs `fitCompletionNotice` (optional UTF-8 cap). */
+declare function formatJobCompletionNotice(job: JobView, maxBytes?: number): string;
+declare function isSettledJobStatus(status: JobViewStatus): boolean;
+/** Face `maxConsecutiveWakes` default. */
+declare const JOB_COMPLETION_MAX_WAKES = 3;
+//#endregion
+//#region src/bus.d.ts
+interface FaceBus {
+  subscribeMux(listener: (rpcId: string, frame: MuxFrame) => void): () => void;
+  subscribeHost(listener: (rpcId: string, frame: HostFrame) => void): () => void;
+  publishMux(frame: MuxFrame, rpcId?: string): void;
+  publishHost(frame: HostFrame, rpcId?: string): void;
+}
+declare function createFaceBus(): FaceBus;
+//#endregion
+//#region src/seq.d.ts
+/**
+ * Face mux wire sequence brands — independent of Session log sequence brands.
+ * Runtime values remain plain numbers; brands stop mixing mux clocks with log offsets.
+ */
+declare const FACE_MUX_SEQ: unique symbol;
+/** Per-session Face mux frame sequence (1-based after the first `next`). */
+type FaceMuxSeq = number & {
+  readonly [FACE_MUX_SEQ]: void;
+};
+/** Admit a numeric value as a Face mux sequence. */
+declare function FaceMuxSeq(value: number): FaceMuxSeq;
+interface FaceSeqClock {
+  next(sessionId: string): FaceMuxSeq;
+  last(sessionId: string): FaceMuxSeq;
+  /**
+   * Raise the mux watermark to at least `seq` without walking `next` one-by-one.
+   * Used when replaying history so long sessions do not O(maxSeq) spin.
+   */
+  ensureAtLeast(sessionId: string, seq: number): FaceMuxSeq;
+}
+declare function createFaceSeqClock(): FaceSeqClock;
+//#endregion
+//#region src/face-schema.d.ts
+/** Same preset ids as the permission-presets settings row enum. */
+declare const FACE_PERMISSION_PRESETS: readonly ["read-only", "workspace-write", "danger-full-access"];
+type FacePermissionPreset = (typeof FACE_PERMISSION_PRESETS)[number];
+//#endregion
+//#region src/permissions.d.ts
+declare const CUSTOM_PERMISSION_PRESET: "custom";
+interface PermissionPresetSpec {
+  readonly sandbox: SandboxMode;
+  readonly approval: ApprovalPolicy;
+  readonly name: string;
+  readonly description: string;
+}
+interface PermissionSelectOption {
+  readonly value: string;
+  readonly name: string;
+  readonly description?: string;
+}
+interface PermissionSelect {
+  readonly options: readonly PermissionSelectOption[];
+  readonly currentValue: string;
+}
+/** Same table ids as settings `permission.defaultPreset`. */
+declare const FACE_PERMISSION_TABLE: Readonly<Record<FacePermissionPreset, PermissionPresetSpec>>;
+/**
+ * Derive select currentValue from folded knobs + composition defaults.
+ * Defaults match a coding harness (workspace-write + ask).
+ */
+declare function derivePermissionSelect(state: PermissionKnobState, defaults?: {
+  readonly sandbox?: SandboxMode;
+  readonly approval?: ApprovalPolicy;
+}): PermissionSelect;
+declare function permissionSelectFromEvents(events: readonly SessionEvent[]): PermissionSelect;
+declare function defaultPermissionPreset(runtime: FaceRuntime): FacePermissionPreset;
+/** Pin durable knobs on a fresh session (settings defaultPreset). */
+declare function pinInitialPermission(store: SessionStore, sessionId: string, preset: FacePermissionPreset): void;
+/**
+ * Switch preset: append changed knobs only. Selecting the effective preset
+ * again appends nothing.
+ *
+ * Optional `hasPtyActivity` fences sandbox mode changes while **Agent**
+ * `terminal_*` PTY sessions are open or spawning (CV DSH terminal-bash
+ * `ensureSandboxModeFence` / `@xrkseek/exec-pty` `sandboxModeChangeBlockedMessage`).
+ * Sidebar user terminals are independent and must not be reported here.
+ */
+declare function applyPermissionPreset(store: SessionStore, sessionId: string, name: string, options?: {
+  readonly hasPtyActivity?: () => boolean;
+}): {
+  readonly ok: true;
+  readonly changed: boolean;
+} | {
+  readonly ok: false;
+  readonly message: string;
+};
+/**
+ * Settings `permission.defaultPreset` is `applies: live`. Push the new default
+ * onto sessions still on the previous default (not manually customized via
+ * Access / `/permission`), then invalidate so sandbox/approval rebuild.
+ */
+declare function applyLivePermissionDefaultPreset(runtime: FaceRuntime, previousUser: unknown, nextValue: unknown): Promise<void>;
+//#endregion
+//#region src/projections/units/auto-review.d.ts
+interface AutoReviewProjection {
+  readonly enabled: boolean;
+  readonly verdictsUsed: number;
+  readonly failuresUsed: number;
+  readonly allows: number;
+  readonly denies: number;
+  readonly fallbacks: number;
+  readonly neverRejects: number;
+  readonly avgDurationMs: number;
+  readonly circuit: null | {
+    readonly trip: {
+      readonly kind: string;
+      readonly count: number;
+    };
+    readonly action: string;
+  };
+  readonly recentDenies: ReadonlyArray<{
+    readonly reviewId: string;
+    readonly toolName: string;
+  }>;
+  readonly recent: ReadonlyArray<Record<string, unknown>>;
+}
+//#endregion
+//#region src/projections/units/turn-outline.d.ts
+/** One started turn's outline facts served on the wire. */
+interface TurnOutlineEntry {
+  /** Face wire turn number (order of first-seen `turnId`). */
+  readonly turn: number;
+  /** Face seq of this turn's `turn/start` (loadThrough target). */
+  readonly seq: number;
+  /** Bounded first-human-prompt preview; `''` until an eligible prompt lands. */
+  readonly prompt: string;
+  /** Bounded final-response preview; `''` until turn/end commits assistant text. */
+  readonly response: string;
+}
+//#endregion
+//#region src/projections/units/workspace-changes.d.ts
+/** Wire view: durable summary plus Face 1-based seq of the announcing event. */
+type WorkspaceChangesProjected = WorkspaceChangesSummary & {
+  readonly seq: number;
+};
+//#endregion
+//#region src/projections/registry.d.ts
+/** Well-known projection keys owned by Face default units (client views). */
+interface FaceProjectionMap {
+  /** Latest title, or null while untitled. */
+  readonly title: string | null;
+  /** Sidebar list hint. */
+  readonly sessionListMetadata: SessionListMetadata;
+  /** Standing plan (TodoDock); null before first write; persists across turns. */
+  readonly todos: TodoItem[] | null;
+  /** Permission select (DSH Access chip); folded from knob events. */
+  readonly permissions: PermissionSelect;
+  /** Plan-mode chip: logged active + pending `/plan` selection. */
+  readonly plan: PlanProjection;
+  /** dsh-auto-review session header panel. */
+  readonly autoReview: AutoReviewProjection;
+  /**
+   * Attachment intake limits (DSH InputBar pre-check). Present only while
+   * Face has an AttachmentStore; constant per boot — no change frames.
+   */
+  readonly imageLimits: ImageAttachmentLimits;
+  /**
+   * Generic-file intake limits. Present only while Face has an AttachmentStore;
+   * constant per boot — no change frames.
+   */
+  readonly fileLimits: FileAttachmentLimits;
+  /**
+   * Whole-log turn outline for the chat rail (DSH turnOutline): every started
+   * turn with its `turn/start` Face seq and bounded previews. Paging cannot
+   * shrink the ladder — unloaded marks jump via loadThrough.
+   */
+  readonly turnOutline: readonly TurnOutlineEntry[];
+  /**
+   * Whole-log turn/step counts and wall times (DSH sessionStats).
+   * StatsLine reads this so paging cannot change the strip.
+   */
+  readonly sessionStats: {
+    readonly turns: number;
+    readonly steps: number;
+    readonly llmMs: number;
+    readonly toolMs: number;
+    readonly ttftMs: number;
+    readonly ttftSteps: number;
+    readonly decodeMs: number;
+    readonly decodeTokens: number;
+  };
+  /** Cumulative provider token buckets (DSH tokenUsage; StatsLine). */
+  readonly tokenUsage: {
+    readonly uncachedInputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+  };
+  /** Per-session token buckets for dsh-cost-meter (`useProjection('costUsage')`). */
+  readonly costUsage: {
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly reasoning: number;
+    readonly cost: number;
+    readonly byModel: Record<string, unknown>;
+    readonly byProviderModel: Record<string, unknown>;
+  };
+  /** Newest prompt pressure + route capacity (DSH contextPressure; ContextMeter). */
+  readonly contextPressure: {
+    readonly pressureTokens?: number;
+    readonly projectedTokens?: number;
+    readonly contextWindow?: number;
+  };
+  /** Heuristic system/tools/message composition (DSH contextBreakdown). */
+  readonly contextBreakdown: {
+    readonly systemTokens: number;
+    readonly toolsTokens: number;
+    readonly messageTokens: number;
+  };
+  /**
+   * Minimal timeline for community `dsh-context` (DSH contextTimeline).
+   * Always present so the Context tab does not hang on null.
+   */
+  readonly contextTimeline: {
+    readonly current: {
+      readonly system: number;
+      readonly tools: number;
+      readonly user: number;
+      readonly inject: number;
+      readonly assistant: number;
+      readonly tool: number;
+      readonly total: number;
+    };
+    readonly toolList: readonly unknown[];
+    readonly requests: readonly unknown[];
+    readonly events: readonly unknown[];
+    readonly nodes: readonly unknown[];
+    readonly archive: readonly unknown[];
+    readonly droppedNodes: number;
+    readonly model?: string;
+    readonly provider?: string;
+    readonly contextWindow?: number;
+  };
+  /** Header snapshots for dsh-context browser (may be empty). */
+  readonly contextHeaders: {
+    readonly headers: readonly {
+      readonly seq: number;
+      readonly system?: string;
+      readonly tools: readonly unknown[];
+    }[];
+  };
+  /**
+   * Turn-end changed-files card (DSH workspace/changes). One summary per
+   * `turnId` (same-turn replace), each stamped with the announcing Face `seq`
+   * for `changes.fileDiff`.
+   */
+  readonly workspaceChanges: readonly WorkspaceChangesProjected[];
+}
+interface SessionListMetadata {
+  readonly blank: boolean;
+  readonly lastPromptAt: number | null;
+}
+declare module "@xrkseek/session-projection" {
+  interface SessionProjectionMap extends FaceProjectionMap {}
+}
+type FaceProjectionRegistryOptions = SessionProjectionRegistryOptions;
+/** Face carrier registry (same contract as the seam). */
+type FaceProjectionRegistry = SessionProjectionRegistry;
+declare function createFaceProjectionRegistry(options: FaceProjectionRegistryOptions): FaceProjectionRegistry;
+//#endregion
+//#region src/projections/units/title.d.ts
+interface TitleProjectionState {
+  readonly title: string | null;
+  /** User rename pins — automatic fallback must not overwrite. */
+  readonly pinned: boolean;
+}
+declare function createTitleProjectionUnit(): ProjectionDefinition<"title", TitleProjectionState, string | null>;
+//#endregion
+//#region src/projections/units/session-list-metadata.d.ts
+declare function createSessionListMetadataUnit(): ProjectionDefinition<"sessionListMetadata", SessionListMetadata, SessionListMetadata>;
+//#endregion
+//#region src/projections/units/image-limits.d.ts
+/**
+ * DSH `imageLimits` constant projection (api-proxy pattern).
+ *
+ * Boot-constant: `apply` keeps the same state reference so no
+ * `session/projection` change frames are ever pushed. Baselines alone
+ * (history tail / list) carry the value for InputBar intake pre-check.
+ * Register only while an AttachmentStore is composed — absent key =
+ * attachment service not available (shell hides upload affordances).
+ */
+declare function createImageLimitsProjectionUnit(limits: ImageAttachmentLimits): ProjectionDefinition<"imageLimits", null, ImageAttachmentLimits>;
+//#endregion
+//#region src/projections/units/file-limits.d.ts
+/**
+ * Face `fileLimits` constant projection (mirrors imageLimits).
+ *
+ * Boot-constant: `apply` keeps the same state reference so no
+ * `session/projection` change frames are ever pushed. Baselines alone
+ * (history tail / list) carry the value for InputBar intake pre-check.
+ * Register only while an AttachmentStore is composed.
+ */
+declare function createFileLimitsProjectionUnit(limits: FileAttachmentLimits): ProjectionDefinition<"fileLimits", null, FileAttachmentLimits>;
+//#endregion
+//#region src/projections/units/context-timeline.d.ts
+/** Compaction trigger mirrored from `context/compaction.reason`. */
+type ContextTimelineCompactReason = "auto" | "overflow" | "manual";
+//#endregion
+//#region src/projections/title-normalize.d.ts
+declare function normalizeSessionTitle(input: string, maxBytes: number): string;
+declare function fallbackSessionTitle(input: string, maxWords: number, maxBytes: number): string;
+//#endregion
+//#region src/projections/title-controller.d.ts
+declare class SessionTitleInvalidError extends Error {
+  readonly name = "SessionTitleInvalidError";
+}
+interface TitleControllerOptions {
+  readonly maxTitleBytes?: number;
+  readonly fallbackMaxWords?: number;
+  readonly fallbackMaxBytes?: number;
+  append(sessionId: string, event: SessionEvent): SessionEvent;
+  getEvents(sessionId: string): readonly SessionEvent[];
+  readonly projections: FaceProjectionRegistry;
+}
+/**
+ * Appends log-only `session/title` events (rename + first-prompt fallback).
+ * Projection units fold those events; this controller never mutates projection cells directly.
+ */
+declare class FaceTitleController {
+  private readonly maxTitleBytes;
+  private readonly fallbackMaxWords;
+  private readonly fallbackMaxBytes;
+  private readonly append;
+  private readonly getEvents;
+  private readonly projections;
+  constructor(options: TitleControllerOptions);
+  /** Explicit user rename — pins title; returns accepted title + Face seq. */
+  rename(sessionId: string, raw: string): {
+    title: string;
+    seq: number;
+  };
+  /**
+   * After a committed `user/message` at `messageSeq`, append fallback title
+   * iff the session still has no title event and projection title is null.
+   */
+  maybeFallbackFromUserMessage(sessionId: string, messageSeq: number, content: string): void;
+}
+//#endregion
+//#region src/projections/install-defaults.d.ts
+interface InstallDefaultFaceProjectionsOptions {
+  /**
+   * When set, register DSH `imageLimits` (boot-constant). Omit when no
+   * AttachmentStore — shell treats missing key as no upload surface.
+   */
+  readonly imageLimits?: ImageAttachmentLimits;
+  /**
+   * When set, register `fileLimits` (boot-constant). Usually paired with
+   * imageLimits while an AttachmentStore is composed.
+   */
+  readonly fileLimits?: FileAttachmentLimits;
+}
+/** Register Face default projection units. */
+declare function installDefaultFaceProjections(registry: FaceProjectionRegistry, options?: InstallDefaultFaceProjectionsOptions): {
+  dispose(): void;
+};
+//#endregion
+//#region src/projections/list-checkpoint-cache.d.ts
+interface FaceListProjectionCache {
+  /** Capture list-tier rows from a live registry checkpoint before eviction. */
+  remember(sessionId: string, checkpoint: ProjectionCheckpoint): void;
+  /** Wire block for a cold row, or undefined on miss / version mismatch. */
+  cachedSnapshot(sessionId: string, registry: FaceProjectionRegistry): ProjectionSnapshot | undefined;
+  /** Drop one session (optional; eviction keeps the row). */
+  forget(sessionId: string): void;
+  /** Persist to disk when a path is configured. */
+  flush(): void;
+}
+//#endregion
+//#region src/plugin-inventory.d.ts
+/** DSH `pluginInventory/list` fiber phase. */
+type FacePluginFiberPhase = "pending" | "loading" | "active" | "failed" | "unloading" | null;
+interface FacePluginInventoryEntry {
+  readonly entryId: string;
+  readonly moduleName: string;
+  readonly enabled: boolean;
+  readonly fiberPhase: FacePluginFiberPhase;
+  /**
+   * User-installed (CLI inventory / community cordis) — Settings may offer
+   * edit / disable / delete. Built-in product-shell and MCP rows stay false.
+   */
+  readonly managed: boolean;
+  /** CLI inventory version when known (Codex-style plugin summary). */
+  readonly version?: string;
+  /** `client` | `process` | `both` | `mcp` | `cordis` | `builtin`. */
+  readonly kind?: string;
+  /** Original `plugin add` spec when managed. */
+  readonly source?: string;
+  /**
+   * Soft-disable / re-enable / install changed disk state but this Host
+   * process still has the opposite live set — restart to apply.
+   */
+  readonly needsRestart?: boolean;
+}
+interface FaceWebPlugin {
+  readonly id: string;
+  readonly moduleName?: string;
+}
+interface FacePluginCommandResult {
+  readonly kind: "success" | "error";
+  readonly text?: string;
+}
+interface FacePluginCommand {
+  readonly name: string;
+  readonly description: string;
+  readonly input?: {
+    readonly hint: string;
+  };
+  readonly handler: (ctx: {
+    sessionId: string;
+    rawInput: string;
+    commandId: string;
+  }) => FacePluginCommandResult | Promise<FacePluginCommandResult>;
+}
+/** Process plugin snapshot Face reads for inventory + slash. */
+interface FaceProcessPlugin {
+  readonly id: string;
+  readonly kind: string;
+  readonly commands?: readonly FacePluginCommand[];
+  /** `kind: tools` contributions — Face `viewFor` standing lookup. */
+  readonly tools?: readonly ToolDefinition[];
+  /** `kind: channel` IM / notification descriptors (process plugin discover). */
+  readonly channels?: readonly {
+    readonly channelId: string;
+    readonly displayName?: string;
+  }[];
+  /** MCP supervisor health (Host `mcp:*` plugins). */
+  readonly mcpHealth?: "connected" | "reconnecting" | "gave-up";
+}
+/**
+ * Managed plugins root: Host `pluginsDir` (incl. `XRK_PLUGINS_DIR`) wins;
+ * otherwise `{harnessHome}/plugins`.
+ */
+declare function resolveManagedPluginsDir(runtime: Pick<FaceRuntime, "productDir" | "hostPublic">): string;
+/**
+ * Reinstall/update spec: keep registry / github sources; local path installs
+ * are cwd-sensitive after Host restart → fall back to `name@latest`.
+ */
+declare function resolveManagedPluginUpdateSpec(entryId: string, source: string | undefined): string;
+/** Absolute install directory for a managed plugin, if it exists on disk. */
+declare function resolveManagedPluginDir(runtime: Pick<FaceRuntime, "productDir" | "hostPublic">, entryId: string, moduleName?: string): string | undefined;
+/**
+ * Rewrite `{pluginsDir}/web/boot.json` from inventory client rows.
+ * Delegates to shared {@link reconcileClientBootAt} (stable rev · atomic write).
+ */
+declare function reconcileManagedClientBoot(runtime: Pick<FaceRuntime, "productDir" | "hostPublic">): void;
+/**
+ * Host process plugins first (user-managed sorted ahead), then product-shell
+ * boot entries, then CLI inventory packages missing from live boot.
+ *
+ * Soft-disabled client packages are dropped from `web/boot.json` (and thus from
+ * Host `webPlugins`) so they do not load — but Settings must still list them
+ * from `.xrk-plugins.json`, otherwise there is no row to re-enable.
+ */
+declare function listFacePluginInventory(runtime: Pick<FaceRuntime, "plugins" | "webPlugins" | "hostPublic" | "productDir">): FacePluginInventoryEntry[];
+//#endregion
+//#region src/slash.d.ts
+type SlashRecipesLoader = () => Promise<readonly Recipe[]> | readonly Recipe[];
+//#endregion
+//#region src/settings-credentials.d.ts
+/** Fill empty vault slots from the OS keyring / memory SecretStore when available. */
+declare function hydrateCredentialsFromSecretStore(runtime: FaceRuntime): Promise<void>;
+type UiTheme = "system" | "light" | "dark";
+interface FaceUiSettings {
+  theme: UiTheme;
+  locale: string;
+}
+interface FaceHostPublicSettings {
+  readonly host: string;
+  readonly port: number;
+  readonly workspaceRoot: string;
+  readonly preset: string;
+  readonly corsOrigin: string;
+  readonly rateLimitPerMinute: number;
+  readonly pluginsDir?: string;
+  readonly webDistConfigured: boolean;
+  /** Community packages whose `host.mjs` apply succeeded via dsh-compat. */
+  readonly cordisHostApplied?: readonly string[];
+  /** Per-package RPC channels from successful host.mjs apply. */
+  readonly cordisHostPackages?: readonly {
+    readonly packageName: string;
+    readonly rpcChannels: readonly string[];
+  }[];
+  /** Process `kind: channel` rows wired on Host spawn (inventory). */
+  readonly processChannels?: readonly {
+    readonly pluginId: string;
+    readonly channelId: string;
+    readonly displayName?: string;
+  }[];
+  /**
+   * Cordis WorkflowEngine Host default (Isolating + Face createAgent + tools.*).
+   * Full sandboxed Node PTC process confinement is not claimed.
+   */
+  readonly workflowEngine?: {
+    readonly provider: "isolating";
+    readonly createAgentBridged: true;
+    readonly toolsBridged: boolean;
+  };
+}
+interface FaceCordisHostBridge {
+  readonly applyHostHalf?: (packageName: string) => Promise<{
+    readonly ok: boolean;
+    readonly message?: string;
+  }>;
+  readonly invokeRpc?: (channel: string, endpoint: string, payload: Record<string, unknown>) => Promise<unknown>;
+  readonly stopHostHalf?: (packageName: string) => Promise<void>;
+}
+interface CredentialSlotView {
+  readonly id: string;
+  readonly label: string;
+  readonly envVar?: string;
+  /** True if env or in-memory vault has a non-empty value. Never returns the value. */
+  readonly configured: boolean;
+  readonly source: "env" | "vault" | "file" | "none";
+}
+declare function defaultUiSettings(): FaceUiSettings;
+declare class FaceCredentialVault {
+  private readonly overrides;
+  /** Values loaded from `.credentials.yaml` (reported as `source: file`). */
+  private readonly fileBacked;
+  peek(slotId: string): string | undefined;
+  hasOverride(slotId: string): boolean;
+  isFileBacked(slotId: string): boolean;
+  setFromFile(slotId: string, value: string): void;
+  set(slotId: string, value: string | null): void;
+  listFileBackedSlots(): {
+    slotId: string;
+    value: string | null;
+  }[];
+  /** Every in-memory override eligible for `.credentials.yaml` persistence. */
+  listPersistedSlots(): {
+    slotId: string;
+    value: string | null;
+  }[];
+  /** Test / diagnostics — never expose via Face RPC. */
+  size(): number;
+}
+declare function listCredentialSlots(runtime: FaceRuntime, env?: NodeJS.ProcessEnv): CredentialSlotView[];
+/** Effective Host API key: vault override wins, else bootstrap env/config value. */
+declare function effectiveHostApiKey(runtime: FaceRuntime): string;
+declare function settingsGet(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function settingsSet(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function credentialsList(runtime: FaceRuntime): Promise<FaceRpcResult<unknown>>;
+/** Face `credentials.describe({ refs })` — never returns secret values. */
+declare function credentialsDescribe(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function credentialsSet(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+/** Face `credentials.unset({ ref })` → empty object. */
+declare function credentialsUnset(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+/** Face SettingsNamespaceView (minimal fields the product shell reads). */
+interface FaceSettingsNamespaceView {
+  readonly ns: string;
+  readonly schema: unknown;
+  readonly value: unknown;
+  readonly base?: unknown;
+  readonly user?: unknown;
+  readonly applies: "live" | "restart";
+  readonly secrets: readonly {
+    readonly path: string[];
+    readonly set: boolean;
+  }[];
+  readonly revision: number;
+}
+type FaceSettingsPathOp = {
+  readonly op: "set";
+  readonly path: string[];
+  readonly value: unknown;
+} | {
+  readonly op: "unset";
+  readonly path: string[];
+};
+/**
+ * Process-memory settings namespaces for Face (welcome notice, etc.).
+ * Most ns stay in memory; `mcp.servers` also persist to host-settings.json
+ * (and live-remount when Host wires `syncMcpServers`).
+ */
+declare class FaceSettingsNamespaces {
+  private readonly map;
+  ensure(ns: string): {
+    user: Record<string, unknown>;
+    revision: number;
+    base: Record<string, unknown>;
+    schema: unknown;
+    applies: "live" | "restart";
+  };
+  view(ns: string, base?: Record<string, unknown>, schema?: unknown, applies?: "live" | "restart"): FaceSettingsNamespaceView;
+  mutate(ns: string, ops: readonly FaceSettingsPathOp[], expectedRevision?: number): {
+    ok: true;
+    view: FaceSettingsNamespaceView;
+  } | {
+    ok: false;
+    code: string;
+    message: string;
+  };
+}
+interface FaceMcpServerDraft {
+  readonly serverName: string;
+  readonly command?: string;
+  readonly url?: string;
+  readonly args?: readonly string[];
+  readonly cwd?: string;
+  /** Required when `cwd` resolves under the Host workspace. */
+  readonly cwdAllowWorkspace?: boolean;
+  /** Proxy-only env (HTTP_PROXY / …); secrets stay in Credentials. */
+  readonly env?: Readonly<Record<string, string>>;
+}
+/** Parse Face/host-settings MCP drafts. Proxy env kept; other env keys rejected. */
+declare function parseFaceMcpServers(raw: unknown): FaceMcpServerDraft[];
+/** Face `settings.describe` — namespaces[] for welcome / forms. */
+declare function settingsDescribeFace(runtime: FaceRuntime): Promise<FaceRpcResult<unknown>>;
+/** Face `settings.mutate` — path ops (welcome notice ack). */
+declare function settingsMutateFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+/** Face `settings.update` — merge patch into namespace user layer. */
+declare function settingsUpdateFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+/** Face `settings.replace` — replace entire user section for ns. */
+declare function settingsReplaceFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+/** Slash `/mcp` inventory text (desired servers + live mount status). */
+declare function formatMcpInventoryText(runtime: FaceRuntime, options?: {
+  readonly verbose?: boolean;
+}): string;
+/** Test helper — clear host-settings last-good cache. */
+declare function resetLastGoodHostMcpCache(): void;
+/** Load `~/.xrk/host-settings.json` mcp.servers (+ allowConnect) into the namespace user layer. */
+declare function hydrateFaceHostSettings(runtime: FaceRuntime): void;
+/**
+ * Face pathless `settings.openDocument`.
+ * Wire value is only `{ opened: true }` (DSH schema); non-desktop → NI.
+ */
+declare function settingsOpenDocument(runtime: FaceRuntime): Promise<FaceRpcResult<{
+  opened: true;
+}>>;
+//#endregion
+//#region src/approval-category.d.ts
+/**
+ * Classify human-approval asks for UX (Codex network vs escalation vs tool).
+ * Heuristic only — never a security boundary by itself.
+ */
+type ApprovalCategory = "tool" | "network" | "escalation";
+type NetworkApprovalProtocol = "http" | "https" | "ws" | "wss" | "other";
+interface NetworkApprovalContext {
+  readonly host: string;
+  readonly protocol: NetworkApprovalProtocol;
+}
+interface ApprovalClassification {
+  readonly category: ApprovalCategory;
+  readonly network?: NetworkApprovalContext;
+}
+/** Best-effort URL/host extraction from tool args or summaries. */
+declare function extractNetworkContext(args: unknown): NetworkApprovalContext | undefined;
+/**
+ * Map tool / host-gate name + args onto an approval UX category.
+ */
+declare function classifyApproval(input: {
+  readonly toolName: string;
+  readonly args?: unknown;
+  readonly reason?: string;
+}): ApprovalClassification;
+//#endregion
+//#region src/approvals.d.ts
+type ApprovalOutcomeWire = "allowed-once" | "rejected" | "cancelled" | "unavailable";
+interface PendingApprovalItem {
+  /** Stable server-request rpcId for product-shell `/api/respond`. */
+  readonly rpcId: string;
+  readonly approvalId: string;
+  readonly sessionId: string;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly reason: string;
+  readonly askedAt: number;
+  readonly argsSummary?: string;
+  /** UX category: ordinary tool · network · sandbox escalation. */
+  readonly category: ApprovalCategory;
+  readonly network?: NetworkApprovalContext;
+}
+interface FaceApprovalHooks {
+  onRequested(item: PendingApprovalItem): void;
+  onResolved(sessionId: string, approvalId: string, outcome: ApprovalOutcomeWire): void;
+}
+type PermissionRequestGate = (args: {
+  readonly toolName: string;
+  readonly toolInput?: unknown;
+  readonly toolUseId?: string;
+  readonly category?: string;
+  readonly signal?: AbortSignal;
+}) => Promise<PermissionRequestDecision | undefined>;
+declare class FaceApprovalBroker {
+  private readonly store;
+  private readonly hooks;
+  private readonly waiters;
+  private readonly byRpcId;
+  private permissionGate;
+  constructor(store: SessionStore, hooks: FaceApprovalHooks);
+  /** Optional Claude/Codex PermissionRequest hooks (run before the human UI). */
+  setPermissionRequestGate(gate: PermissionRequestGate | undefined): void;
+  listPending(sessionId?: string): readonly PendingApprovalItem[];
+  /**
+   * Host sidebar / Office policy `ask` — synthetic tool name so the existing
+   * approval UI / `/api/respond` path works without a live tool call.
+   */
+  requestHostGate(sessionId: string, gate: {
+    readonly kind: string;
+    readonly reason: string;
+    readonly summary?: string;
+  }, signal?: AbortSignal): Promise<boolean>;
+  /** Pipeline `ApprovalHandler` bound to a session. */
+  handlerFor(sessionId: string): ApprovalHandler;
+  request(sessionId: string, ctx: Pick<ToolPipelineContext, "call" | "args" | "signal">, reason: string): Promise<boolean>;
+  respond(sessionId: string, approvalId: string, decision: "allow" | "deny"): {
+    readonly ok: true;
+  } | {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+  };
+  /**
+   * Settle via DSH `POST /api/respond` (rpcId correlation).
+   * @returns receipt shape consumed by the Web client.
+   */
+  respondByRpcId(rpcId: string, value: unknown): FaceRpcReceipt;
+  private decide;
+}
+/** mux `approval/requested` 载荷（rpcId 走 bus/信封，不在 payload 里）。 */
+declare function approvalRequestedFrame(item: PendingApprovalItem): Extract<MuxFrame, {
+  type: "approval/requested";
+}>;
+declare function approvalResolvedFrame(sessionId: string, approvalId: string, outcome: ApprovalOutcomeWire): Extract<MuxFrame, {
+  type: "approval/resolved";
+}>;
+//#endregion
+//#region src/questions.d.ts
+declare class FaceQuestionError extends Error {
+  readonly code: "ASK_CANCELLED" | "ASK_ABORTED" | "EMPTY_QUESTIONS";
+  constructor(message: string, code: "ASK_CANCELLED" | "ASK_ABORTED" | "EMPTY_QUESTIONS");
+}
+interface PendingQuestionItem {
+  readonly rpcId: string;
+  readonly sessionId: string;
+  readonly questions: readonly FaceQuestionItem[];
+}
+interface FaceQuestionHooks {
+  onRequested(item: PendingQuestionItem): void;
+  onResolved(sessionId: string, questionRpcId: string, outcome: "answered" | "cancelled"): void;
+}
+declare function formatQuestionAnswer(answer: FaceQuestionAnswer): string;
+declare class FaceQuestionBroker {
+  private readonly hooks;
+  private readonly waiters;
+  constructor(hooks: FaceQuestionHooks);
+  listPending(sessionId?: string): readonly PendingQuestionItem[];
+  hasRpcId(rpcId: string): boolean;
+  ask(sessionId: string, questions: readonly FaceQuestionItem[], signal?: AbortSignal): Promise<FaceQuestionAnswer>;
+  askText(sessionId: string, question: string, signal?: AbortSignal): Promise<string>;
+  /**
+   * DSH `/api/respond` after approvals miss. `result` is the client-response
+   * `result` object (`ok` + `value` or `error`).
+   */
+  respondByRpcId(rpcId: string, result: unknown): FaceRpcReceipt;
+  private claim;
+}
+declare function questionRequestedFrame(item: PendingQuestionItem): Extract<MuxFrame, {
+  type: "question/requested";
+}>;
+declare function questionResolvedFrame(sessionId: string, questionRpcId: string, outcome: "answered" | "cancelled"): Extract<MuxFrame, {
+  type: "question/resolved";
+}>;
+/**
+ * Coerce `ask_user` args to DSH `AskUserQuestionItem[]`.
+ * Accepts free-text `{ question }` or `{ questions: [...] }` (`multi_select` → multiSelect).
+ */
+declare function coerceAskUserQuestions(args: unknown): FaceQuestionItem[] | undefined;
+/** Point `ask_user` execute at Face questions (DSH web provider). */
+declare function bindAskUserTool(tools: ToolRegistry, ask: (questions: readonly FaceQuestionItem[], signal?: AbortSignal) => Promise<string>): void;
+/** Point `exit_plan_mode` at Face questions + session fold. Always registered. */
+declare function bindExitPlanModeTool(tools: ToolRegistry, store: SessionStore, sessionId: string, ask: (questions: readonly FaceQuestionItem[], signal?: AbortSignal) => Promise<FaceQuestionAnswer>): void;
+//#endregion
+//#region src/workspace-registry.d.ts
+/**
+ * Workspace registry for Face (list/create/rename/archive).
+ * Persists to `{harnessHome}/workspaces.json` via workspace-store.
+ */
+interface FaceWorkspaceView {
+  readonly workspaceId: string;
+  readonly path: string;
+  title: string;
+  readonly sessionIds: string[];
+  readonly createdAt: string;
+  updatedAt: string;
+}
+declare class FaceWorkspaceRegistry {
+  private readonly root;
+  private readonly workspaces;
+  private readonly order;
+  private readonly membership;
+  /** workspaceId → session ids in sidebar order. */
+  private readonly sessionOrder;
+  private readonly archived;
+  /** Registry-global pin order (newest pin first). Mutually exclusive with archive. */
+  private pinned;
+  private seq;
+  constructor(root: string);
+  defaultId(): string;
+  /** Live (non-archived) workspace owning this session, if any. */
+  workspaceIdOf(sessionId: string): string | undefined;
+  get(workspaceId: string): Omit<FaceWorkspaceView, "sessionIds"> | undefined;
+  findByPath(absPath: string): Omit<FaceWorkspaceView, "sessionIds"> | undefined;
+  attachSession(sessionId: string, workspaceId: string): FaceWorkspaceView | undefined;
+  /** Resolve workspaceId or adopt/create by cwd path. */
+  resolveAttachTarget(opts: {
+    workspaceId?: string;
+    cwd?: string;
+  }): {
+    workspaceId?: string;
+    cwd: string;
+  } | {
+    error: string;
+  };
+  create(absPath: string): {
+    workspace: FaceWorkspaceView;
+    created: boolean;
+  };
+  rename(workspaceId: string, title: string): FaceWorkspaceView | undefined;
+  /**
+   * Archive one session into the registry-global set. Membership and sidebar
+   * order stay so a later unarchive restores the same workspace slot (dsh
+   * parity). Already-archived ids are idempotent. Pin and archive are
+   * mutually exclusive — archive drops any pin (DSH parity).
+   */
+  archiveSession(sessionId: string): {
+    archivedSessionIds: string[];
+    pinnedSessionIds: string[];
+  };
+  /**
+   * Drop one session from the archive set. Accounting was never cleared on
+   * archive, so the session reappears in its recorded workspace order. An id
+   * that is not archived resolves without writing.
+   */
+  unarchiveSession(sessionId: string): string[];
+  /**
+   * Pin one session to the front of the registry-global pin order (newest
+   * first). Unarchives first when needed so pin and archive stay exclusive.
+   */
+  pinSession(sessionId: string): {
+    archivedSessionIds: string[];
+    pinnedSessionIds: string[];
+  };
+  /**
+   * Drop one session from the pin order. Unknown ids resolve without writing.
+   */
+  unpinSession(sessionId: string): string[];
+  /**
+   * Remove one workspace registration (including the bootstrap default).
+   * Sessions lose their accounting slot and appear under Ungrouped; logs and
+   * directories stay untouched.
+   */
+  delete(workspaceId: string): {
+    ok: true;
+    movedSessionIds: string[];
+  } | {
+    ok: false;
+    reason: string;
+  };
+  /** Reorder workspaces so `workspaceId` sits immediately before `beforeId`. */
+  insertBefore(workspaceId: string, beforeId: string): FaceWorkspaceView[] | undefined;
+  /**
+   * Reorder (and optionally move) a session so it sits before `beforeSessionId`.
+   * Both must be live (not archived).
+   */
+  insertSessionBefore(sessionId: string, beforeSessionId: string): FaceWorkspaceView | undefined;
+  list(allSessionIds: readonly string[]): {
+    items: FaceWorkspaceView[];
+    archivedSessionIds: string[];
+    pinnedSessionIds: string[];
+  };
+  private removeFromOrder;
+  private view;
+  exportState(): {
+    order: string[];
+    entries: Record<string, {
+      path: string;
+      title: string;
+      createdAt: string;
+      updatedAt: string;
+    }>;
+    seq: number;
+    membership: Record<string, string>;
+    sessionOrder: Record<string, string[]>;
+    archivedSessionIds: string[];
+    pinnedSessionIds: string[];
+  };
+  /** All live session → workspace bindings. */
+  listMembership(): readonly (readonly [string, string])[];
+  importState(doc: {
+    order: readonly string[];
+    entries: Readonly<Record<string, {
+      path: string;
+      title: string;
+      createdAt: string;
+      updatedAt: string;
+    }>>;
+    seq: number;
+    membership?: Readonly<Record<string, string>>;
+    sessionOrder?: Readonly<Record<string, readonly string[]>>;
+    archivedSessionIds?: readonly string[];
+    pinnedSessionIds?: readonly string[];
+  }, fallbackRoot: string): void;
+}
+//#endregion
+//#region src/subagent-registry.d.ts
+type SubagentMode = "one-shot" | "continuable" | "fork";
+interface FaceSubagentLink {
+  readonly parentSessionId: string;
+  readonly childSessionId: string;
+  readonly mode: SubagentMode;
+  readonly label: string;
+}
+/**
+ * Parent → direct children. Optional JSON sidecar for JSONL session dir.
+ * Does not invent session events.
+ */
+declare class FaceSubagentRegistry {
+  private readonly hooks?;
+  private readonly byParent;
+  private readonly byChild;
+  private readonly persistPath;
+  constructor(persistPath?: string, hooks?: {
+    onAttach?: (link: FaceSubagentLink) => void;
+    /** Observe-only: child stretch idle / one-shot settle (shell SubagentStop). */
+    onStop?: (link: FaceSubagentLink) => void;
+  } | undefined);
+  getByChild(childSessionId: string): FaceSubagentLink | undefined;
+  get(parentSessionId: string, childSessionId: string): FaceSubagentLink | undefined;
+  list(parentSessionId: string): readonly FaceSubagentLink[];
+  entries(): readonly FaceSubagentLink[];
+  /** Tool-delegated children only (excludes UI/rewind `fork` lineage). */
+  listDelegated(parentSessionId: string): readonly FaceSubagentLink[];
+  hasChildren(sessionId: string): boolean;
+  hasDelegatedChildren(sessionId: string): boolean;
+  attach(link: FaceSubagentLink): FaceSubagentLink;
+  /** Fire SubagentStop observers (idempotent callers should gate themselves). */
+  notifyStop(link: FaceSubagentLink): void;
+  private load;
+  private save;
+}
+//#endregion
+//#region src/external-agent-runtime.d.ts
+type ExternalAgentKind = "acp" | "app-server" | "claude-code";
+type ExternalSpawn = typeof spawn;
+/** Face `external-agent` product (Settings → Plugins). */
+interface ExternalAgentProductConfig {
+  readonly acpAgent?: string;
+  readonly codexAppServer?: string;
+  readonly claudeCode?: string;
+}
+interface RunExternalAgentOptions {
+  readonly kind: ExternalAgentKind;
+  readonly cwd: string;
+  readonly prompt: string;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly product?: ExternalAgentProductConfig;
+  readonly signal?: AbortSignal;
+  readonly spawnImpl?: ExternalSpawn;
+}
+declare class ExternalAgentError extends Error {
+  readonly code: string;
+  constructor(message: string, code?: string);
+}
+declare function resolveExternalAgentLaunch(kind: ExternalAgentKind, env: NodeJS.ProcessEnv, prompt: string, product?: ExternalAgentProductConfig): {
+  command: string;
+  args: string[];
+  protocol: "acp" | "app-server" | "print";
+};
+/** Normalize Face `external-agent` section into launch product fields. */
+declare function parseExternalAgentProduct(raw: unknown): ExternalAgentProductConfig | undefined;
+/**
+ * Hand one prompt to an external agent subprocess.
+ * Does not create an in-process child session.
+ */
+declare function runExternalAgentTurn(options: RunExternalAgentOptions): Promise<{
+  readonly text: string;
+  readonly kind: ExternalAgentKind;
+}>;
+declare function parseExternalAgentKind(raw: unknown): ExternalAgentKind | "in-process" | undefined;
+/** ACP / app-server keep a live process; claude-code print is one-shot only. */
+type ContinuableExternalKind = "acp" | "app-server";
+declare function supportsExternalContinuable(kind: ExternalAgentKind): kind is ContinuableExternalKind;
+interface ExternalAgentLiveSession {
+  readonly kind: ContinuableExternalKind;
+  readonly remoteId: string;
+  isBusy(): boolean;
+  lastText(): string | undefined;
+  prompt(text: string, signal?: AbortSignal): Promise<string>;
+  interrupt(): Promise<void>;
+  dispose(): void;
+}
+interface OpenExternalLiveOptions {
+  readonly kind: ContinuableExternalKind;
+  readonly cwd: string;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly product?: ExternalAgentProductConfig;
+  readonly spawnImpl?: ExternalSpawn;
+  /**
+   * Cold-resume remote id (ACP sessionId / app-server thread id). When set,
+   * prefer resume/load over a fresh session/thread.
+   */
+  readonly resumeRemoteId?: string;
+}
+declare function openExternalAgentLiveSession(options: OpenExternalLiveOptions): Promise<ExternalAgentLiveSession>;
+/** Durable handle for cold resume after Host restart / process dispose. */
+interface ExternalAgentHandleRecord {
+  readonly faceSessionId: string;
+  readonly kind: ContinuableExternalKind;
+  readonly remoteId: string;
+  readonly cwd: string;
+  readonly updatedAt: number;
+}
+declare function externalAgentHandlesPath(subagentPersistPath?: string): string | undefined;
+/** Face child session id → live ACP / app-server handle (+ optional cold sidecar). */
+declare class ExternalAgentSessionRegistry {
+  private readonly map;
+  private readonly handles;
+  private readonly persistPath;
+  constructor(persistPath?: string);
+  has(faceSessionId: string): boolean;
+  get(faceSessionId: string): ExternalAgentLiveSession | undefined;
+  isBusy(faceSessionId: string): boolean;
+  kind(faceSessionId: string): ContinuableExternalKind | undefined;
+  /** Sidecar handle when process is gone but remote id is still known. */
+  getHandle(faceSessionId: string): ExternalAgentHandleRecord | undefined;
+  /**
+   * Status badge: `live` while process attached; `cold` when only the sidecar
+   * remains (Host restart / dispose) so UI / follow-up can attempt reopen.
+   */
+  resumeState(faceSessionId: string): "live" | "cold" | undefined;
+  attach(faceSessionId: string, session: ExternalAgentLiveSession, meta?: {
+    readonly cwd?: string;
+  }): void;
+  detach(faceSessionId: string): void;
+  /** Drop live + cold handle (interrupt dispose path that should not resume). */
+  clearHandle(faceSessionId: string): void;
+  disposeAll(): void;
+  private loadHandles;
+  private saveHandles;
+}
+/** Narrow host surface for external continuable (avoids FaceRuntime import cycle). */
+interface ExternalAgentHost {
+  readonly store: SessionStore;
+  readonly drain: {
+    isActive(sessionId: string): boolean;
+  };
+  readonly externalAgents: ExternalAgentSessionRegistry;
+  onSessionDrainStatus(sessionId: string, running: boolean): void;
+  suppressOwnedSubagentCompletion(childSessionId: string): void;
+}
+/** True when Face drain or an external live session is mid-turn. */
+declare function isChildSessionActive(runtime: ExternalAgentHost, sessionId: string): boolean;
+interface StartExternalContinuableOptions {
+  readonly runtime: ExternalAgentHost;
+  readonly faceSessionId: string;
+  readonly kind: ContinuableExternalKind;
+  readonly cwd: string;
+  readonly prompt: string;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly product?: ExternalAgentProductConfig;
+  readonly spawnImpl?: ExternalSpawn;
+  readonly signal?: AbortSignal;
+  /** When true, return after spawn + first turn kickoff (do not await answer). */
+  readonly background: boolean;
+}
+/**
+ * Open ACP / app-server live session, attach to Face child id, run first prompt.
+ * Background: kicks the turn and returns; completion steers parent via drain hooks.
+ */
+declare function startExternalContinuable(options: StartExternalContinuableOptions): Promise<{
+  readonly text?: string;
+  readonly kind: ContinuableExternalKind;
+}>;
+/**
+ * Follow-up prompt on an attached external live session (send_message / followup_task).
+ * When the live process is gone but a cold sidecar handle remains, reopen via
+ * ACP session/load or app-server thread/resume before prompting.
+ */
+declare function promptExternalContinuable(runtime: ExternalAgentHost, faceSessionId: string, message: string, opts?: {
+  readonly signal?: AbortSignal;
+  readonly steer?: boolean;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly product?: ExternalAgentProductConfig;
+  readonly spawnImpl?: ExternalSpawn;
+}): Promise<string>;
+declare function interruptExternalContinuable(runtime: ExternalAgentHost, faceSessionId: string, opts?: {
+  readonly dispose?: boolean;
+}): Promise<void>;
+//#endregion
+//#region src/agent-team-graph.d.ts
+type AgentTeamEdgeKind = "delegates" | "peer";
+/**
+ * Team role for one node.
+ * - `delegator` — hands work to a child (outgoing `delegates` edge).
+ * - `worker` — the child that received the delegation.
+ * - `observer` — linked by `peer` only; reads/coordinates, owns no delegation.
+ * Derived from edges unless an explicit override is set.
+ */
+type AgentTeamRole = "delegator" | "worker" | "observer";
+declare const AGENT_TEAM_ROLES: readonly AgentTeamRole[];
+declare function isAgentTeamRole(value: unknown): value is AgentTeamRole;
+interface AgentTeamNode {
+  readonly id: string;
+  readonly label: string;
+  /** Effective role: explicit override when set, else derived from edges. */
+  readonly role?: AgentTeamRole;
+  /**
+   * Delegation depth from the `view`/`depthFrom` root along `delegates` edges
+   * (root = 0). Omitted when the node is only peer-linked to the component.
+   */
+  readonly depth?: number;
+}
+interface AgentTeamEdge {
+  readonly from: string;
+  readonly to: string;
+  readonly kind: AgentTeamEdgeKind;
+  readonly label?: string;
+}
+/** One adjacency hop from `neighbors()`. */
+interface AgentTeamNeighbor {
+  readonly id: string;
+  readonly kind: AgentTeamEdgeKind;
+  /** `out` = this node is edge.from; `in` = this node is edge.to (peer always sorted). */
+  readonly direction: "in" | "out";
+  readonly label?: string;
+}
+declare class AgentTeamGraph {
+  private readonly nodes;
+  private readonly edges;
+  private readonly roles;
+  private readonly persistPath;
+  constructor(persistPath?: string);
+  recordDelegation(link: FaceSubagentLink): void;
+  /** Replace delegation edges from the live registry; peer links stay. */
+  rebuildDelegations(links: readonly FaceSubagentLink[]): void;
+  linkPeers(from: string, to: string, label?: string): AgentTeamEdge | undefined;
+  /** Drop a peer edge (no-op when missing). Returns whether an edge was removed. */
+  unlinkPeers(from: string, to: string): boolean;
+  /**
+   * Remove peer edges touching `nodeId`, clear its role override, and drop the
+   * node when no `delegates` edge remains. Delegation edges stay owned by
+   * `rebuildDelegations` / the live registry.
+   */
+  removeNode(nodeId: string): boolean;
+  /**
+   * Adjacent nodes. `kind` defaults to any; peer hops are undirected
+   * (`direction` still reports sorted from→to orientation).
+   */
+  neighbors(nodeId: string, kind?: AgentTeamEdgeKind): readonly AgentTeamNeighbor[];
+  /**
+   * BFS depth along `delegates` from `rootId` (root = 0). Undefined when the
+   * target is unreachable via delegation (peer-only nodes).
+   */
+  depthFrom(rootId: string, nodeId: string): number | undefined;
+  /** Effective role for one node (explicit override, else derived from edges). */
+  roleOf(nodeId: string): AgentTeamRole;
+  /**
+   * Override a node's role. Pass `undefined` to clear the override and fall
+   * back to the derived role. Returns the effective role afterwards.
+   */
+  setRole(nodeId: string, role?: AgentTeamRole): AgentTeamRole | undefined;
+  /** Explicit overrides only (derived roles are recomputed on read). */
+  roleOverrides(): Readonly<Record<string, AgentTeamRole>>;
+  private deriveRole;
+  /** Connected component around `rootId` (delegation + peer). */
+  view(rootId: string): {
+    readonly nodes: readonly AgentTeamNode[];
+    readonly edges: readonly AgentTeamEdge[];
+  };
+  private upsertNode;
+  private upsertEdge;
+  private load;
+  private save;
+}
+declare function agentTeamGraphPath(subagentPersistPath?: string): string | undefined;
+//#endregion
+//#region src/agent-team-roles.d.ts
+/**
+ * Spawn-time role templates for Agent Teams (Codex agent_type · Hermes leaf/orchestrator).
+ * Graph `delegator|worker|observer` stays a UI label; these prefix the child prompt.
+ */
+type AgentTeamSpawnRole = "default" | "worker" | "researcher" | "reviewer" | "lead";
+declare const AGENT_TEAM_SPAWN_ROLES: readonly AgentTeamSpawnRole[];
+declare function isAgentTeamSpawnRole(value: unknown): value is AgentTeamSpawnRole;
+/** Resolve a spawn role string (aliases: agent_type · role). Unknown → undefined. */
+declare function parseAgentTeamSpawnRole(value: unknown): AgentTeamSpawnRole | undefined;
+/** Prepend the role reminder when non-empty. */
+declare function applySpawnRoleReminder(prompt: string, role: AgentTeamSpawnRole | undefined): string;
+declare function listSpawnRoleIds(): readonly AgentTeamSpawnRole[];
+//#endregion
+//#region src/agent-team-tasks.d.ts
+type AgentTeamTaskStatus = "pending" | "in_progress" | "completed" | "failed" | "paused";
+interface AgentTeamTask {
+  readonly id: string;
+  readonly parentSessionId: string;
+  readonly title: string;
+  readonly status: AgentTeamTaskStatus;
+  readonly revision: number;
+  readonly createdAt: number;
+  readonly updatedAt: number;
+  readonly childSessionId?: string;
+  readonly role?: AgentTeamSpawnRole;
+  /** Managed worktree checkout path when spawn used worktree isolation. */
+  readonly worktreePath?: string;
+  readonly worktreeBranch?: string;
+  readonly worktreeId?: string;
+  /** Human owns the child after interrupt takeover (suppress auto-steer). */
+  readonly humanOwned?: boolean;
+  readonly resultPreview?: string;
+  readonly schemaValid?: boolean;
+  readonly schemaErrors?: readonly string[];
+}
+declare class AgentTeamTaskBoard {
+  private readonly tasks;
+  /** In-memory only — schemas are large and session-scoped. */
+  private readonly schemas;
+  private readonly persistPath;
+  constructor(persistPath?: string);
+  get(taskId: string): AgentTeamTask | undefined;
+  list(parentSessionId: string): readonly AgentTeamTask[];
+  /** Create a pending/in_progress task when spawning a teammate. */
+  open(input: {
+    readonly parentSessionId: string;
+    readonly title: string;
+    readonly childSessionId?: string;
+    readonly role?: AgentTeamSpawnRole;
+    readonly taskId?: string;
+    readonly now?: number;
+  }): AgentTeamTask;
+  /** Bind a child session after create (when id was known before spawn). */
+  bindChild(taskId: string, childSessionId: string, now?: number): AgentTeamTask | undefined;
+  findByChild(childSessionId: string): AgentTeamTask | undefined;
+  /** Attach managed worktree lease fields to a Teams task. */
+  bindWorktree(taskId: string, worktree: {
+    readonly path: string;
+    readonly branch: string;
+    readonly id?: string;
+  }, now?: number): AgentTeamTask | undefined;
+  /** Attach an output_schema for later validation (not persisted). */
+  setOutputSchema(taskId: string, schema: Readonly<Record<string, unknown>>): void;
+  outputSchemaOf(taskId: string): Readonly<Record<string, unknown>> | undefined;
+  outputSchemaForChild(childSessionId: string): Readonly<Record<string, unknown>> | undefined;
+  /**
+   * Soft-pause / human takeover after interrupt.
+   * Marks the task paused + humanOwned (completion steer already suppressed).
+   */
+  markTakeover(childSessionId: string, now?: number): AgentTeamTask | undefined;
+  /** Resume after send_message — clear humanOwned, back to in_progress. */
+  markResumed(childSessionId: string, now?: number): AgentTeamTask | undefined;
+  complete(taskId: string, input: {
+    readonly ok: boolean;
+    readonly preview?: string;
+    readonly schemaValid?: boolean;
+    readonly schemaErrors?: readonly string[];
+    readonly now?: number;
+  }): AgentTeamTask | undefined;
+  /** Complete by child session id (foreground wait / idle notice). */
+  completeByChild(childSessionId: string, input: {
+    readonly ok: boolean;
+    readonly preview?: string;
+    readonly schemaValid?: boolean;
+    readonly schemaErrors?: readonly string[];
+    readonly now?: number;
+  }): AgentTeamTask | undefined;
+  private load;
+  private save;
+}
+declare function agentTeamTasksPath(subagentPersistPath?: string): string | undefined;
+//#endregion
+//#region src/subagent-worktree.d.ts
+interface SubagentWorktreeResult {
+  path: string;
+  branch: string;
+  commits: number;
+  dirty: boolean;
+  pruned: boolean;
+  inspection_failed?: boolean;
+  note?: string;
+}
+interface GitRunResult {
+  readonly code: number;
+  readonly stdout: string;
+  readonly stderr: string;
+}
+type GitRunner$1 = (args: readonly string[], cwd: string) => GitRunResult;
+//#endregion
+//#region src/managed-worktree.d.ts
+declare const MANAGED_WORKTREE_OWNER_VERSION: 1;
+declare const MANAGED_WORKTREE_OWNER_FILENAME = "xrk-managed-worktree.json";
+type ManagedWorktreeStatus = "active" | "reclaimed" | "retained";
+/**
+ * How to fold a managed worktree branch back into the parent checkout.
+ * Only `ff-only` is implemented (matches Codex “clean merge or keep retained”).
+ * Conflict / diverged history → retain the lease; no auto conflict UI.
+ */
+type ManagedWorktreeMergeStrategy = "ff-only";
+interface ManagedWorktreeMergeResult {
+  readonly ok: boolean;
+  readonly strategy: ManagedWorktreeMergeStrategy;
+  readonly leaseId: string;
+  readonly branch: string;
+  readonly repoRoot: string;
+  /** True when `git merge --ff-only` succeeded. */
+  readonly merged: boolean;
+  readonly reason?: string;
+  readonly stdout?: string;
+  readonly stderr?: string;
+  /** Present when `pruneAfter` ran after a successful merge. */
+  readonly reclaim?: SubagentWorktreeResult;
+}
+/** Durable owner record written beside each checkout (git admin or `.xrk/`). */
+interface ManagedWorktreeOwnerRecord {
+  readonly version: typeof MANAGED_WORKTREE_OWNER_VERSION;
+  /** Child session that owns the checkout (Codex ownerThreadId analogue). */
+  readonly ownerSessionId: string;
+  readonly parentSessionId?: string;
+  readonly teamTaskId?: string;
+  readonly branch?: string;
+  readonly baseCommit?: string;
+  readonly boundAt: number;
+}
+interface ManagedWorktreeLease {
+  readonly id: string;
+  readonly path: string;
+  readonly branch: string;
+  readonly repoRoot: string;
+  readonly baseCommit: string;
+  readonly parentSessionId: string;
+  readonly createdAt: number;
+  readonly status: ManagedWorktreeStatus;
+  readonly childSessionId?: string;
+  readonly teamTaskId?: string;
+  readonly reclaim?: SubagentWorktreeResult;
+}
+/** Read owner metadata; `null` when missing or invalid. */
+declare function readManagedWorktreeOwner(checkout: string, git?: GitRunner$1): ManagedWorktreeOwnerRecord | null;
+/**
+ * Bind ownership atomically. Re-binding the same owner is a no-op;
+ * a different owner throws.
+ */
+declare function bindManagedWorktreeOwner(checkout: string, record: Omit<ManagedWorktreeOwnerRecord, "version" | "boundAt"> & {
+  readonly boundAt?: number;
+}, git?: GitRunner$1): ManagedWorktreeOwnerRecord;
+declare function managedWorktreesPath(subagentPersistPath: string | undefined): string | undefined;
+/** Face-scoped registry of managed worktree leases. */
+declare class ManagedWorktreeManager {
+  private readonly leases;
+  private readonly persistPath;
+  private readonly git;
+  constructor(persistPath?: string, options?: {
+    readonly git?: GitRunner$1;
+  });
+  get(id: string): ManagedWorktreeLease | undefined;
+  list(parentSessionId?: string): readonly ManagedWorktreeLease[];
+  findByChild(childSessionId: string): ManagedWorktreeLease | undefined;
+  findByTask(teamTaskId: string): ManagedWorktreeLease | undefined;
+  /**
+   * Allocate a git worktree and register an active lease (unbound until
+   * {@link bind}).
+   */
+  allocate(input: {
+    readonly parentCwd: string;
+    readonly parentSessionId: string;
+    readonly subagentId?: string;
+    readonly now?: number;
+  }): ManagedWorktreeLease | null;
+  /** Bind lease to child session (+ optional Teams task) and write owner file. */
+  bind(leaseId: string, input: {
+    readonly childSessionId: string;
+    readonly teamTaskId?: string;
+    readonly now?: number;
+  }): ManagedWorktreeLease | undefined;
+  /**
+   * Merge the lease branch into the parent repo's current HEAD (`ff-only`).
+   * Editing in the child stays isolated (session cwd = worktree); this is the
+   * explicit fold-back step — never runs on reclaim by default.
+   * Diverged / dirty parent → `{ ok:false, merged:false }` and lease stays.
+   */
+  mergeIntoParent(leaseId: string, options?: {
+    readonly strategy?: ManagedWorktreeMergeStrategy;
+    /** After a successful ff merge, reclaim (prune-if-clean). Default false. */
+    readonly pruneAfter?: boolean;
+  }): ManagedWorktreeMergeResult | undefined;
+  /** Reclaim (prune-if-clean) and update lease status. */
+  reclaim(leaseId: string, options?: {
+    readonly prune?: boolean;
+  }): SubagentWorktreeResult | undefined;
+  /** Convenience: reclaim by child session id. */
+  reclaimByChild(childSessionId: string, options?: {
+    readonly prune?: boolean;
+  }): SubagentWorktreeResult | undefined;
+  private load;
+  private save;
+}
+//#endregion
+//#region src/message-feedback.d.ts
+declare const MESSAGE_FEEDBACK_NOTE_MAX_BYTES = 4096;
+type MessageFeedbackRating = "positive" | "negative";
+interface MessageFeedbackItem {
+  readonly messageId: string;
+  readonly rating: MessageFeedbackRating;
+  readonly note?: string;
+  readonly version: string;
+  readonly createdAt: number;
+  readonly updatedAt: number;
+}
+type TypertOk$1<T> = {
+  readonly ok: true;
+  readonly value: T;
+};
+type TypertFail$1 = {
+  readonly ok: false;
+  readonly error: Record<string, unknown> & {
+    readonly code: string;
+  };
+};
+declare class FaceMessageFeedbackStore {
+  private readonly bySession;
+  list(store: SessionStore, sessionId: string): FaceRpcResult<TypertOk$1<{
+    items: MessageFeedbackItem[];
+  }> | TypertFail$1>;
+  put(store: SessionStore, input: {
+    readonly sessionId: string;
+    readonly messageId: string;
+    readonly rating: unknown;
+    readonly note?: unknown;
+    readonly notePresent: boolean;
+    readonly ifVersion: unknown;
+  }): FaceRpcResult<TypertOk$1<MessageFeedbackItem> | TypertFail$1>;
+  delete(store: SessionStore, input: {
+    readonly sessionId: string;
+    readonly messageId: string;
+    readonly ifVersion: unknown;
+  }): FaceRpcResult<TypertOk$1<{
+    absent: true;
+  }> | TypertFail$1>;
+  private bucket;
+}
+//#endregion
+//#region src/goal-store.d.ts
+declare const DEFAULT_MAX_GOAL_ROUNDS = 16;
+declare const GOAL_OBJECTIVE_MAX_CHARS = 4000;
+type GoalPhase = "active" | "paused" | "blocked" | "complete";
+type GoalActivation = "armed" | "disarmed";
+interface GoalRef {
+  readonly id: string;
+  readonly revision: number;
+}
+interface GoalView {
+  readonly id: string;
+  readonly revision: number;
+  readonly objective: string;
+  readonly phase: GoalPhase;
+  readonly activation: GoalActivation;
+  readonly maxGoalRounds: number;
+  readonly roundsStarted: number;
+  readonly createdAt: number;
+  readonly updatedAt: number;
+  readonly blockedReason?: {
+    readonly code: string;
+    readonly message: string;
+  };
+}
+type GoalProjectionValue = {
+  readonly goal: GoalView;
+} | null;
+declare class FaceGoalStore {
+  private readonly bySession;
+  private readonly persistPath;
+  private runtime;
+  constructor(persistPath?: string);
+  bind(runtime: FaceRuntime): void;
+  get(sessionId: string): GoalView | undefined;
+  onTurnEnd(sessionId: string, turnReasonKind?: string): void;
+  create(sessionId: string, objective: string, maxGoalRounds?: number): FaceRpcResult<{
+    ref: GoalRef;
+  }>;
+  edit(sessionId: string, ref: GoalRef, patch: {
+    objective?: string;
+    maxGoalRounds?: number;
+  }): FaceRpcResult<GoalView>;
+  pause(sessionId: string, ref: GoalRef): FaceRpcResult<GoalView>;
+  resume(sessionId: string, ref: GoalRef): FaceRpcResult<GoalView>;
+  complete(sessionId: string, ref: GoalRef): FaceRpcResult<GoalView>;
+  /** Model / Host: mark blocked and disarm automatic rounds. */
+  block(sessionId: string, ref: GoalRef, reason: {
+    readonly code: string;
+    readonly message: string;
+  }): FaceRpcResult<GoalView>;
+  clear(sessionId: string, ref: GoalRef): FaceRpcResult<GoalRef>;
+  private startRound;
+  private mutate;
+  private publish;
+  private load;
+  private save;
+  private requireRuntime;
+}
+//#endregion
+//#region src/adapt/wire-ids.d.ts
+/**
+ * Session-scoped turn/step counters for Face wire (numeric, order of first seen).
+ * Prefer this over hashing string ids so trajectory location math stays monotonic.
+ */
+declare class FaceWireIdMaps {
+  private readonly turns;
+  private readonly steps;
+  private readonly turnCount;
+  private readonly stepCount;
+  turn(sessionId: string, turnId: string): number;
+  step(sessionId: string, turnId: string, stepId: string): number;
+  /**
+   * Drop every session-scoped bucket for one session. Called on session
+   * eviction so long-running hosts do not retain turn/step counters for
+   * evicted sessions (per-session entries would otherwise accumulate forever).
+   */
+  clear(sessionId: string): void;
+}
+//#endregion
+//#region src/adapt/inbox-wire.d.ts
+type InboxTarget = "next-turn" | "next-step";
+interface FaceWireUserMessage {
+  readonly id: string;
+  readonly role: "user";
+  readonly content: readonly ({
+    readonly type: "text";
+    readonly text: string;
+  } | {
+    readonly type: "image";
+    readonly attachment: {
+      readonly attachmentId: string;
+      readonly mediaType: string;
+      readonly bytes: number;
+      readonly width: number;
+      readonly height: number;
+      readonly name?: string;
+    };
+  } | {
+    readonly type: "file";
+    readonly attachment: {
+      readonly attachmentId: string;
+      readonly name: string;
+      readonly bytes: number;
+      readonly mediaType?: string;
+    };
+  })[];
+  readonly source: {
+    readonly kind: "user";
+    readonly rpcId?: string;
+  };
+}
+interface FaceInboxSplice {
+  readonly target: InboxTarget;
+  readonly start: number;
+  readonly removedCount?: number;
+  readonly inserted: readonly FaceWireUserMessage[];
+  readonly outcome?: "canceled";
+}
+/**
+ * Incremental projector: apply one prompt event → one normalized splice.
+ * Callers must feed events in session log order.
+ */
+declare class FaceInboxWireProjector {
+  private readonly admitToRpc;
+  private readonly nextTurn;
+  private readonly nextStep;
+  constructor(admitToRpc?: ReadonlyMap<string, string>);
+  /** Project one XRK prompt event into a Face inbox splice, mutating pending lists. */
+  project(event: SessionEvent): FaceInboxSplice | undefined;
+  private locate;
+}
+/** Per-session projectors for live mux fan-out. */
+declare class FaceInboxWireMaps {
+  private readonly admitToRpc;
+  private readonly bySession;
+  constructor(admitToRpc: ReadonlyMap<string, string>);
+  forSession(sessionId: string): FaceInboxWireProjector;
+  /** Fresh projector for history rebuild (does not touch live mux state). */
+  fresh(): FaceInboxWireProjector;
+  clear(sessionId: string): void;
+}
+//#endregion
+//#region src/host-directory.d.ts
+interface DirectoryEntryView {
+  readonly name: string;
+  readonly path: string;
+  readonly hidden: boolean;
+}
+interface DirectoryListingView {
+  readonly path: string;
+  readonly home: string;
+  readonly crumbs: readonly DirectoryEntryView[];
+  readonly entries: readonly DirectoryEntryView[];
+  readonly truncated: boolean;
+}
+/** Same predicate as DSH `fullyQualified` (browse picker). */
+declare function fullyQualified(path: string, platform?: NodeJS.Platform): boolean;
+declare function hostListDirectory(payload: unknown): Promise<FaceRpcResult<DirectoryListingView>>;
+declare function hostCreateDirectory(payload: unknown): Promise<FaceRpcResult<{
+  path: string;
+}>>;
+//#endregion
+//#region src/context.d.ts
+/**
+ * When Host runs with SSH remote cwd, Web browse RPCs use this backend
+ * instead of the local filesystem (paths are remote POSIX coordinates).
+ */
+interface FaceDirectoryBackend {
+  list(payload: unknown): Promise<FaceRpcResult<DirectoryListingView>>;
+  create(payload: unknown): Promise<FaceRpcResult<{
+    path: string;
+  }>>;
+}
+interface FaceDrain {
+  wake(sessionId: string): void;
+  cancel(sessionId: string, options?: SessionDrainCancelOptions): Promise<void>;
+  isActive(sessionId: string): boolean;
+  /** Wait until the session drain settles (Host hub.run). */
+  run?(sessionId: string): Promise<void>;
+}
+interface FaceRuntime {
+  /** Durable image blobs; omit → image prompt / session.attachment unavailable. */
+  readonly attachments?: AttachmentStore;
+  /**
+   * Declared input modalities for Host precheck (DSH-aligned).
+   * Default `["text"]` — images rejected before save unless `"image"` is listed.
+   */
+  readonly inputModalities?: readonly ("text" | "image")[];
+  readonly store: SessionStore;
+  ensureSession(id?: string): string;
+  resolveAgent(sessionId: string): Promise<AgentHandle>;
+  readonly drain: FaceDrain;
+  readonly registry: ProviderRegistry;
+  readonly workspaceRoot: string;
+  /**
+   * True when tool cwd / fs / bash ride SSH (`XRK_SSH_*`).
+   * Native openPath · OS folder picker · sidebar PTY stay host-local and are gated off.
+   */
+  readonly remoteExecution?: boolean;
+  /**
+   * Local Host cwd before SSH workspace swap (settings / product home anchor).
+   * Absent when not remote.
+   */
+  readonly localHostRoot?: string;
+  /** SSH-backed `host.listDirectory` / `host.createDirectory` (remote POSIX). */
+  readonly directoryBackend?: FaceDirectoryBackend;
+  /** Product inject dir override for tests; Host leaves unset → `{workspace}/.xrk`. Settings/creds use `resolveHarnessHome` (`~/.xrk`). */
+  readonly productDir?: string;
+  readonly version: string;
+  readonly defaultAgentPreset?: string;
+  readonly bus: FaceBus;
+  readonly seq: FaceSeqClock;
+  readonly projections: FaceProjectionRegistry;
+  /**
+   * Cold list column for `title` / `sessionListMetadata` (Codex-style).
+   * Written on list-key changes and before SQLite LRU eviction.
+   */
+  readonly listProjectionCache: FaceListProjectionCache;
+  readonly titles: FaceTitleController;
+  /** rpcId (unary) → admitId */
+  readonly rpcAdmitMap: Map<string, string>;
+  /** admitId → rpcId (reverse for queue / stamp) */
+  readonly admitRpcMap: Map<string, string>;
+  /** Next user/message for session should carry this rpcId */
+  readonly pendingUserRpc: Map<string, string>;
+  readonly sessionModels: Map<string, {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+  }>;
+  /** sessionId → agentPreset id */
+  readonly sessionAgentPresets: Map<string, string>;
+  /** sessionId → project cwd (DSH session.list / blank reuse). */
+  readonly sessionCwds: Map<string, string>;
+  /**
+   * Sessions known to contain image-bearing user/admit content.
+   * Maintained on append; first miss may scan once then mark {@link sessionImageScanned}.
+   */
+  readonly sessionHasImage: Set<string>;
+  /** Sessions whose image presence has been resolved (hit or miss). */
+  readonly sessionImageScanned: Set<string>;
+  /** In-memory workspace registry for the product shell. */
+  readonly workspaces: FaceWorkspaceRegistry;
+  /** Direct subagent children (fork / create-with-parent). */
+  readonly subagents: FaceSubagentRegistry;
+  /**
+   * Live ACP / app-server subprocesses keyed by Face child session id.
+   * Same list / send / interrupt / wait surface as in-process continuable.
+   */
+  readonly externalAgents: ExternalAgentSessionRegistry;
+  /** Delegation + peer team graph (persisted next to the subagent sidecar). */
+  readonly agentTeams: AgentTeamGraph;
+  /** Thin task board (delivery · result · pause/takeover) beside the graph. */
+  readonly agentTeamTasks: AgentTeamTaskBoard;
+  /** Managed git worktree leases (allocate / reclaim / Teams bind). */
+  readonly managedWorktrees: ManagedWorktreeManager;
+  /** Per-session assistant-message ratings (process-local CAS). */
+  readonly messageFeedback: FaceMessageFeedbackStore;
+  /**
+   * Directory for conversation-slice JSON on session feedback
+   * (`feedback/record` · `sessionFeedback/record`).
+   */
+  readonly feedbackSlicesDir?: string;
+  /** Per-session Goal sidecar (projection key `goal`). */
+  readonly goals: FaceGoalStore;
+  /** Session-scoped turn/step numbers for DSH wire events. */
+  readonly wireIds: FaceWireIdMaps;
+  /** Session-scoped inbox splice projectors for live mux. */
+  readonly inboxWire: FaceInboxWireMaps;
+  readonly loadSlashRecipes?: SlashRecipesLoader;
+  /** Process plugins (`XRK_PLUGINS_DIR` / MCP) for inventory + slash. */
+  readonly plugins?: readonly FaceProcessPlugin[];
+  /**
+   * Host live-applies Face MCP desired servers when sourced from
+   * host-settings.json (env empty). Absent → mutate stays `applies: restart`.
+   * Returns per-server connect failures and parked names.
+   */
+  readonly syncMcpServers?: (servers: readonly FaceMcpServerDraft[], options?: {
+    readonly allowConnect?: boolean;
+  }) => Promise<{
+    readonly failures: readonly {
+      readonly serverName: string;
+      readonly message: string;
+    }[];
+    readonly parked?: readonly string[];
+  }>;
+  /**
+   * Last `syncMcpServers` overlay (parked / connectFailures). Mutate writes;
+   * describe/get read so Settings UI does not reclassify failures as parked.
+   */
+  mcpSyncOverlay: {
+    connectFailures: readonly {
+      readonly serverName: string;
+      readonly message: string;
+    }[];
+    parked: readonly string[];
+  };
+  /** Standing / remembered tool presenters (wire tools get). */
+  readonly getTool?: (sessionId: string, name: string) => Pick<ToolDefinition, "presentCall" | "presentResult"> | undefined;
+  /** Product-shell `boot.json` entries (assembled client plugins). */
+  readonly webPlugins?: readonly FaceWebPlugin[];
+  /** Mutable UI prefs (theme/locale) — not secrets. */
+  readonly uiSettings: FaceUiSettings;
+  /** Read-only host public snapshot (from host spawn). */
+  readonly hostPublic?: FaceHostPublicSettings;
+  /** On-demand Cordis `host.mjs` apply (Host wires after dsh-compat prewarm). */
+  readonly cordisHostBridge?: FaceCordisHostBridge;
+  /** In-memory credential overrides — never session-logged. */
+  readonly credentials: FaceCredentialVault;
+  /**
+   * Optional OS keyring / memory SecretStore overlay (`XRK_SECRETS_BACKEND`).
+   * Face `.credentials.yaml` remains the default durable SoT.
+   */
+  readonly secretStore?: import("@xrkseek/secrets").SecretStore;
+  /** Face settings namespaces (welcome notice, etc.). */
+  readonly settingsNamespaces: FaceSettingsNamespaces;
+  /** Bootstrap Host API key from env/config (before vault override). */
+  readonly bootstrapApiKey?: string;
+  /** Optional policy engine (e.g. from XRK_POLICY_FILE) for provider.use gates. */
+  readonly policy?: PolicyEngine;
+  /**
+   * Absolute path to a local settings/policy document.
+   * Opened by `settings.openDocument` — request carries no filesystem path.
+   */
+  readonly settingsDocumentPath?: string;
+  /** Native opener; default platform `openNativePath`. */
+  openNativePath?(target: string): Promise<void>;
+  /** Native folder chooser; default platform `pickNativeDirectory`. Cancel → `null`. */
+  pickNativeDirectory?(signal: AbortSignal): Promise<string | null>;
+  /**
+   * Remove a user-installed plugin (`xrkh plugin remove`). Host wires
+   * CLI mutate; absent → inventory remove returns a CLI hint.
+   */
+  removeUserPlugin?(spec: string): Promise<{
+    readonly ok: boolean;
+    readonly error?: string;
+  }>;
+  /**
+   * Reinstall / bump a user plugin (`xrkh plugin add <spec>`). Spec is the
+   * inventory `source` when known, else `name@latest`.
+   */
+  updateUserPlugin?(spec: string): Promise<{
+    readonly ok: boolean;
+    readonly error?: string;
+  }>;
+  /**
+   * After soft-disable / remove / update mutates disk: Host reconciles the
+   * in-process plugin loader (unload disabled / missing, load newly enabled).
+   * Client half still needs a browser reload (`needsRestart`).
+   */
+  syncManagedProcessPlugins?(): Promise<void>;
+  /**
+   * Standing tool registry (preset layer) when no live agent is remembered.
+   * Host wires Isolating WorkflowEngine `tools.*` from this.
+   */
+  readonly tools?: ToolRegistry;
+  /** Human approval waiters (tool policy `ask`). */
+  readonly approvals: FaceApprovalBroker;
+  /** DSH user-questions (`question/requested` + `/api/respond`). */
+  readonly questions: FaceQuestionBroker;
+  /** Drop cached agent when preset changes (host wires). May be async (compose dispose). */
+  invalidateAgent?(sessionId: string): void | Promise<void>;
+  /**
+   * Session leaving the live set (archive / Host stop). Host may run curated-memory
+   * Phase1 consolidate. Best-effort; failures must not block Face.
+   */
+  onSessionFinalize?(sessionId: string): void | Promise<void>;
+  /**
+   * Last curated-memory consolidate report (Host updates after Phase1/2).
+   * Optional — Status / `/status` surface when present.
+   */
+  curatedMemoryConsolidate?: {
+    sessionId: string;
+    at: number;
+    phase1Written: number;
+    phase2: string;
+    phase2Written: number;
+    skipped?: string;
+    providerKind?: string;
+  };
+  /** When true, `/permission` refuses sandbox mode changes while **Agent**
+   * `terminal_*` PTY sessions are open or spawning (CV DSH terminal-bash
+   * sandbox fence). Sidebar user terminals must not be reported here.
+   */
+  hasPtyActivity?(): boolean;
+  /** Host persists `/auto-review` slash to dsh-compat HTTP store (~/.xrk). */
+  autoReviewSlashPersist?(args: string): void;
+  /** Publish store appends as mux session/event. */
+  watchSession(sessionId: string): void;
+  publishQueue(sessionId: string): void;
+  publishApprovals(sessionId: string): void;
+  /**
+   * DSH `session/jobs`. `undefined` = no registry (emit nothing).
+   * Empty array is a live set that just cleared (still pushed on change).
+   */
+  jobViewsFor(sessionId: string): JobView[] | undefined;
+  publishJobs(sessionId: string, opts?: {
+    baseline?: boolean;
+  }): void;
+  /**
+   * Copy parent log into a new session without inventing title/fallback rows
+   * (replay path).
+   */
+  forkSession(sourceId: string, boundaryIndex?: number, childId?: string): SessionRecord;
+  /**
+   * Host drain status hook. Continuable children notify the parent on idle
+   * (same wake budget as job completions). Idle notifies are epoch-scoped:
+   * a later `running:true` drops in-flight stale delivers; transient resolve
+   * failures retry once on the same idle stretch.
+   */
+  onSessionDrainStatus(sessionId: string, running: boolean): void;
+  /**
+   * Suppress the parent completion steer for a continuable child (interrupt /
+   * cancel). Must be called *before* draining the child to idle so the
+   * cancel→idle race cannot re-admit a "finished a turn" notice.
+   * Cleared when the child drain goes running again (resume via send_message).
+   */
+  suppressOwnedSubagentCompletion(childSessionId: string): void;
+  /** Shared shell registry for session-scoped job kill / background RPC. */
+  readonly shell?: ShellService;
+}
+//#endregion
+//#region src/wire/respond.d.ts
+type ParsedClientResponse = {
+  readonly ok: true;
+  readonly rpcId: string;
+  readonly value: unknown;
+} | {
+  readonly ok: false;
+  readonly reason: "bad-response";
+};
+/** 解析 `{ type: client-response, rpcId, result }`（ok:true 路径，审批用）。 */
+declare function parseClientResponse(body: unknown): ParsedClientResponse;
+/** 把 client-response 交给审批或提问 broker，返回 DSH 回执。 */
+declare function settleFaceRespond(runtime: FaceRuntime, body: unknown): FaceRpcReceipt;
+//#endregion
+//#region src/runtime.d.ts
+interface CreateFaceRuntimeOptions {
+  readonly store: SessionStore;
+  readonly resolveAgent: (sessionId: string) => Promise<AgentHandle>;
+  readonly drain: FaceDrain;
+  readonly workspaceRoot: string;
+  /** SSH remote execution world — see {@link FaceRuntime.remoteExecution}. */
+  readonly remoteExecution?: boolean;
+  /** Local Host cwd before SSH swap — see {@link FaceRuntime.localHostRoot}. */
+  readonly localHostRoot?: string;
+  /** SSH-backed directory browse — see {@link FaceRuntime.directoryBackend}. */
+  readonly directoryBackend?: FaceDirectoryBackend;
+  /** Override harness home for settings/creds (default `~/.xrk`). Workspace inject stays `{workspaceRoot}/.xrk`. */
+  readonly productDir?: string;
+  readonly version?: string;
+  readonly defaultAgentPreset?: string;
+  readonly registry?: ProviderRegistry;
+  readonly bus?: FaceBus;
+  readonly seq?: FaceSeqClock;
+  readonly projections?: FaceProjectionRegistry;
+  readonly skipDefaultProjections?: boolean;
+  readonly loadSlashRecipes?: SlashRecipesLoader;
+  /** Process plugins for `pluginInventory/list` + `commands/*`. */
+  readonly plugins?: readonly FaceProcessPlugin[];
+  /**
+   * Host live-applies Face `mcp.servers` when MCP is sourced from
+   * host-settings.json (env empty).
+   */
+  readonly syncMcpServers?: (servers: readonly FaceMcpServerDraft[]) => Promise<{
+    readonly failures: readonly {
+      readonly serverName: string;
+      readonly message: string;
+    }[];
+  }>;
+  /** Product-shell boot entries listed in inventory. */
+  readonly webPlugins?: readonly FaceWebPlugin[];
+  readonly invalidateAgent?: (sessionId: string) => void | Promise<void>;
+  /**
+   * Host Phase1 / teardown hook when a session leaves the live set
+   * (archive). Optional — Host may also run consolidate on stop.
+   */
+  readonly onSessionFinalize?: (sessionId: string) => void | Promise<void>;
+  /** Public host runtime snapshot for settings.get (no secrets). */
+  readonly hostPublic?: FaceHostPublicSettings;
+  /** Cordis panel `runHostHalf` → dsh-compat `host.mjs` apply. */
+  readonly cordisHostBridge?: FaceCordisHostBridge;
+  /** Initial Host API key from env (vault may override). */
+  readonly bootstrapApiKey?: string;
+  /** Optional SecretStore overlay (OS keyring / memory). */
+  readonly secretStore?: import("@xrkseek/secrets").SecretStore;
+  readonly uiSettings?: FaceUiSettings;
+  readonly policy?: PolicyEngine;
+  /**
+   * Host-resolved settings document (e.g. `XRK_POLICY_FILE`).
+   * `settings.openDocument` never takes a browser path.
+   */
+  readonly settingsDocumentPath?: string;
+  /** Inject native opener (tests). Default `openNativePath`. */
+  readonly openNativePath?: (target: string) => Promise<void>;
+  /** Inject native folder chooser (tests). Default `pickNativeDirectory`. */
+  readonly pickNativeDirectory?: (signal: AbortSignal) => Promise<string | null>;
+  /** Host wires `xrkh plugin remove` for Settings inventory. */
+  readonly removeUserPlugin?: (spec: string) => Promise<{
+    readonly ok: boolean;
+    readonly error?: string;
+  }>;
+  /** Host wires `xrkh plugin add` for Settings inventory update. */
+  readonly updateUserPlugin?: (spec: string) => Promise<{
+    readonly ok: boolean;
+    readonly error?: string;
+  }>;
+  /**
+   * Live-reconcile process plugins after inventory soft-disable / remove /
+   * update (Host). Client boot still needs a page reload.
+   */
+  readonly syncManagedProcessPlugins?: () => Promise<void>;
+  /** Durable image store (default none → image RPCs unavailable). */
+  readonly attachments?: AttachmentStore;
+  /** Standing tool registry (preset layer) when no live agent is remembered. */
+  readonly tools?: ToolRegistry;
+  /** Standing / unowned jobs (DSH `ctx.jobs` without an owner). */
+  readonly jobs?: FaceJobsSource;
+  /**
+   * When true, `/permission` refuses sandbox mode changes while **Agent**
+   * `terminal_*` PTY sessions are open or spawning (CV DSH terminal-bash
+   * sandbox fence). Sidebar user terminals must not be reported here.
+   */
+  readonly hasPtyActivity?: () => boolean;
+  /** Host input modalities; default text-only. */
+  readonly inputModalities?: readonly ("text" | "image")[];
+  /** Host persists `/auto-review` slash to dsh-compat store (DSH panel HTTP). */
+  readonly autoReviewSlashPersist?: (args: string) => void;
+  /** Optional JSON sidecar for parent→child links (sessions directory). */
+  readonly subagentPersistPath?: string;
+  /** Optional JSON sidecar for Face goals (sessions directory). */
+  readonly goalPersistPath?: string;
+  /**
+   * Directory for conversation-slice JSON written on session feedback
+   * (`{sessionsDir}/feedback-slices`).
+   */
+  readonly feedbackSlicesDir?: string;
+  /**
+   * Cold `session.list` projection column (`title` · `sessionListMetadata`).
+   * Typical path: `{sessionsDir}/projection-list-cache.json`.
+   */
+  readonly listProjectionCachePath?: string;
+  /** Shared shell job registry (harness/server preset). */
+  readonly shell?: ShellService;
+}
+/**
+ * Builds Face runtime and patches `store.append` in-place so REST + Face share
+ * one log; mux receives adapted session/event (+ tool view) and projections.
+ */
+declare function createFaceRuntime(options: CreateFaceRuntimeOptions): FaceRuntime;
+//#endregion
+//#region src/plugin-boot.d.ts
+interface ClientBootEntry {
+  readonly id: string;
+  readonly url: string;
+  readonly rev: string;
+  readonly inject: readonly string[];
+  readonly immediately?: boolean;
+}
+interface ClientBootReconcileResult {
+  readonly rev: string;
+  readonly entries: readonly ClientBootEntry[];
+  /** False when on-disk boot already matched (no rewrite / no cache bust). */
+  readonly wrote: boolean;
+  /** True when disabled file was rewritten (orphan prune and/or canonicalize). */
+  readonly prunedDisabled: boolean;
+}
+/**
+ * Rewrite `{pluginsDir}/web/boot.json` from `.xrk-plugins.json` client rows,
+ * omitting soft-disabled ids and pruning/canonicalizing the disabled file.
+ */
+declare function reconcileClientBootAt(pluginsDir: string): ClientBootReconcileResult;
+//#endregion
+//#region src/session-feedback.d.ts
+/** Product taxonomy in presentation order (durable log vocabulary). */
+declare const FEEDBACK_CATEGORIES: readonly ["task-result", "instruction-following", "product-interaction", "service-stability", "resource-cost", "security-privacy-permission", "other"];
+declare const FEEDBACK_TEXT_MAX_CHARS = 8192;
+type SessionFeedbackEntry = {
+  readonly text?: string;
+  readonly category?: FeedbackCategory;
+};
+type TypertOk<T> = {
+  readonly ok: true;
+  readonly value: T;
+};
+type TypertFail = {
+  readonly ok: false;
+  readonly error: Record<string, unknown> & {
+    readonly code: string;
+  };
+};
+declare function isFeedbackCategory(value: unknown): value is FeedbackCategory;
+/**
+ * Normalize human input: trim text (blank → absent); keep category when valid.
+ */
+declare function normalizeFeedbackEntry(entry: SessionFeedbackEntry): SessionFeedbackEntry;
+/**
+ * Persist a conversation-prefix sidecar next to sessions; returns sliceId or
+ * undefined when the directory is unset or write fails (record still succeeds).
+ */
+declare function writeFeedbackConversationSlice(slicesDir: string | undefined, sessionId: string, events: readonly SessionEvent[]): string | undefined;
+/**
+ * Append one `feedback/record` (log-only). Blank text is omitted; category-only
+ * and empty drafts are valid. Optionally attaches a conversation-slice id.
+ */
+declare function recordSessionFeedback(store: SessionStore, sessionId: string, entry: SessionFeedbackEntry, options?: {
+  readonly slicesDir?: string;
+  readonly ts?: number;
+}): {
+  readonly recorded: true;
+  readonly sliceId?: string;
+};
+/**
+ * Face Typert `sessionFeedback/record` — nested `{ ok, value|error }` like
+ * messageFeedback (carrier ok wraps business result).
+ */
+declare function sessionFeedbackRecord(store: SessionStore, input: {
+  readonly sessionId: string;
+  readonly text?: unknown;
+  readonly category?: unknown;
+}, options?: {
+  readonly slicesDir?: string;
+}): FaceRpcResult<TypertOk<{
+  recorded: true;
+  sliceId?: string;
+}> | TypertFail>;
+//#endregion
+//#region src/goal-round-driver.d.ts
+/**
+ * Same-session goal round driver helpers (dsh goal-round-driver semantics,
+ * without Cordis). FaceGoalStore owns state; this module owns the retained
+ * continuation prompt and turn/end scheduling decisions.
+ */
+/** Minimal goal fields the driver needs. */
+interface GoalRoundSnapshot {
+  readonly objective: string;
+  readonly phase: "active" | "paused" | "blocked" | "complete";
+  readonly activation: "armed" | "disarmed";
+  readonly maxGoalRounds: number;
+  readonly roundsStarted: number;
+}
+type GoalTurnEndDecision = {
+  readonly kind: "noop";
+} | {
+  readonly kind: "wake-pending";
+} | {
+  readonly kind: "continue";
+  readonly round: number;
+  readonly prompt: string;
+} | {
+  readonly kind: "block";
+  readonly code: string;
+  readonly message: string;
+} | {
+  readonly kind: "disarm";
+  readonly code: string;
+  readonly message: string;
+};
+/**
+ * Render the retained `<goal_round>` user prompt for one automatic round.
+ * Round is 1-based and must equal `roundsStarted + 1` at admission time.
+ */
+declare function renderGoalRoundPrompt(goal: Pick<GoalRoundSnapshot, "objective" | "maxGoalRounds">, round: number): string;
+/** First-round / resume prompt (still tags `<goal_round>` for model consistency). */
+declare function renderGoalStartPrompt(goal: Pick<GoalRoundSnapshot, "objective" | "maxGoalRounds">, round: number, lead: "start" | "resume"): string;
+/**
+ * Decide what happens after `turn/end` for an armed active goal.
+ * @param hasPendingAdmits - session already has queued admits (wake only).
+ * @param turnReasonKind - `turn/end.reason.kind` when present.
+ */
+declare function decideGoalTurnEnd(input: {
+  readonly goal: GoalRoundSnapshot;
+  readonly hasPendingAdmits: boolean;
+  readonly turnReasonKind?: string;
+}): GoalTurnEndDecision;
+//#endregion
+//#region src/goal-tools.d.ts
+interface BindGoalToolsOptions {
+  readonly runtime: FaceRuntime;
+  readonly sessionId: string;
+}
+/** Register `get_goal` + `update_goal` on the session tool registry. */
+declare function bindGoalTools(tools: ToolRegistry, options: BindGoalToolsOptions): void;
+//#endregion
+//#region src/propose-skill.d.ts
+declare const PROPOSE_SKILL_APPROVE_LABEL = "Write skill";
+declare const PROPOSE_SKILL_REJECT_LABEL = "Reject";
+declare const PROPOSE_SKILL_QUESTION_ID = "propose-skill";
+declare function proposeSkillQuestions(draft: ProposeSkillDraft): FaceQuestionItem[];
+interface BindProposeSkillToolOptions {
+  readonly workspaceRoot: string;
+  readonly sessionId: string;
+  readonly skillsRoot?: string;
+  readonly ask: (questions: readonly FaceQuestionItem[], signal?: AbortSignal) => Promise<FaceQuestionAnswer>;
+}
+/** Register / replace `propose_skill` with Face confirm → write. */
+declare function bindProposeSkillTool(tools: ToolRegistry, options: BindProposeSkillToolOptions): void;
+//#endregion
+//#region src/session-export.d.ts
+declare const SESSION_EXPORT_PATHS: readonly ["/api/session.export", "/api/face/session.export"];
+declare function isSessionExportPath(pathname: string): boolean;
+declare function sessionExportFilename(sessionId: string): string;
+//#endregion
+//#region src/handlers/types.d.ts
+type FaceHandler = (runtime: FaceRuntime, rpcId: string, payload: unknown) => Promise<FaceRpcResult<unknown>>;
+//#endregion
+//#region src/dispatch.d.ts
+declare function getHandler(method: string): FaceHandler | undefined;
+declare function dispatchFaceMethod(runtime: FaceRuntime, method: string, rpcId: string, payload: unknown): Promise<FaceRpcResponse>;
+//#endregion
+//#region src/remote-event.d.ts
+declare const FACE_HOST_REMOTE_EVENTS: readonly ["agent-preset/selected", "commands/change", "credentials/updated", "llm/adapters-updated", "settings/document-updated"];
+type FaceHostRemoteEvent = (typeof FACE_HOST_REMOTE_EVENTS)[number];
+type FaceRemoteArg = string | number | boolean | null;
+declare function publishRemoteEvent(bus: Pick<FaceBus, "publishHost">, event: FaceHostRemoteEvent, args?: readonly FaceRemoteArg[]): void;
+//#endregion
+//#region src/plan-mode.d.ts
+type PlanSetOutcome = "committed" | "queued" | "cancelled" | "noop";
+declare function planWantedFromArgs(rawInput: string): boolean;
+/**
+ * Decide a `/plan` selection against the log *before* this command/run.
+ * Caller logs `command/run` first, then appends `plan/mode` only when
+ * this returns `committed`.
+ */
+declare function previewPlanSet(events: readonly import("@xrkseek/protocol").SessionEvent[], active: boolean): PlanSetOutcome;
+declare function commitPlanMode(store: SessionStore, sessionId: string, active: boolean): void;
+declare function narratePlanCommand(outcome: PlanSetOutcome, wanted: boolean, loggedActive: boolean): string;
+/** Optional `/plan <message>` suffix becomes the next user prompt. */
+declare function steerPlanMessage(store: SessionStore, sessionId: string, rawInput: string): string | undefined;
+//#endregion
+//#region src/attach-http.d.ts
+interface AttachFaceOptions {
+  readonly apiKey: string;
+  checkAuth(req: IncomingMessage): boolean;
+  /**
+   * Mux/host WebSocket Ping cadence (ms). Defaults to
+   * {@link FACE_WS_HEARTBEAT_INTERVAL_MS}; tests may shorten it.
+   */
+  readonly heartbeatIntervalMs?: number;
+}
+/**
+ * 若路径是 Face unary 或 `/api/respond`，接管响应并返回 true。
+ */
+declare function tryHandleFaceHttp(req: IncomingMessage, res: ServerResponse, runtime: FaceRuntime, options: AttachFaceOptions): boolean;
+declare function attachFaceUpgrades(server: Server, runtime: FaceRuntime, options: AttachFaceOptions): {
+  close(): void;
+};
+/** 仅 Face 的测试/边车服务器。 */
+declare function createFaceOnlyServer(runtime: FaceRuntime, options: AttachFaceOptions & {
+  host?: string;
+  port?: number;
+}): {
+  listen(): Promise<{
+    host: string;
+    port: number;
+  }>;
+  close(): Promise<void>;
+  readonly server: Server;
+};
+declare function handleFaceHttpRequest(runtime: FaceRuntime, method: string, body: unknown): Promise<unknown>;
+//#endregion
+//#region src/ws-heartbeat.d.ts
+/** Default interval between Ping control frames (ms). */
+declare const FACE_WS_HEARTBEAT_INTERVAL_MS = 2000;
+/**
+ * Missed Ping answers before terminate. DSH gateway uses 2; Face mux shares
+ * the Host event loop with tool / projection work (no per-stream uplink byte
+ * window), so 5 ≈ 10s at the default interval avoids mid-turn false kills.
+ */
+declare const FACE_WS_HEARTBEAT_MAX_MISSED = 5;
+interface WsHeartbeat {
+  /** Arm Ping tracking for one accepted socket; starts the shared timer. */
+  watch(ws: WebSocket): void;
+  /** Clear the shared timer (call from Face upgrade close). */
+  stop(): void;
+}
+/**
+ * Shared Ping/Pong watchdog across one or more `noServer` WebSocketServers.
+ * @param servers - Face mux and/or host acceptors.
+ * @param intervalMs - Ping cadence and per-miss deadline (default 2s).
+ */
+declare function startWsHeartbeat(servers: readonly WebSocketServer[], intervalMs?: number): WsHeartbeat;
+//#endregion
+//#region src/adapt/tool-view.d.ts
+declare class FaceToolArgMaps {
+  private readonly sessions;
+  remember(sessionId: string, event: SessionEvent): void;
+  forSession(sessionId: string): Map<string, ToolCallPairing$1>;
+  /**
+   * Drop a session's arg-pairing map entirely (outer entry included). Called
+   * on session eviction; clearing only the inner map would leave the outer
+   * `sessions` entry behind and grow without bound across evictions.
+   */
+  clear(sessionId: string): void;
+}
+declare function collectToolCallArgs(events: readonly SessionEvent[]): Map<string, ToolCallPairing$1>;
+declare function faceToolLookup(getTool: PresentToolLookup$1["getTool"], argsByCallId?: ReadonlyMap<string, ToolCallPairing$1>): PresentToolLookup$1;
+/** Face `viewFor` — missing lookup / pairing / presenter → no view. */
+declare function presentToolView(event: SessionEvent, lookup?: PresentToolLookup$1): ToolEventView$1 | undefined;
+//#endregion
+//#region src/adapt/model-route.d.ts
+/**
+ * Assistant wire `message.source` attribution (Face mux / history).
+ * Prefer the live `request/header` route; fall back to session model selection.
+ */
+interface FaceModelRoute {
+  readonly provider: string;
+  readonly model: string;
+}
+/** Wire source when no route is known yet (unit tests / cold sessions). */
+declare const FACE_ASSISTANT_SOURCE_PLACEHOLDER: {
+  readonly kind: "model";
+  readonly provider: "xrk";
+  readonly model: "unknown";
+};
+/** Cost-ledger key when usage arrives before any request/header. */
+declare const FACE_USAGE_ROUTE_PLACEHOLDER: FaceModelRoute;
+/**
+ * Normalize an optional route into Face assistant `message.source`.
+ * Empty strings fall back to the placeholder so token-meter never sees blanks.
+ */
+declare function assistantMessageSource(route?: FaceModelRoute | null): {
+  readonly kind: "model";
+  readonly provider: string;
+  readonly model: string;
+};
+/** `provider:model` map key for costUsage / cost-meter buckets. */
+declare function providerModelKey(route: FaceModelRoute): string;
+declare function routeFromRequestHeader(event: {
+  readonly type: string;
+  readonly header?: {
+    readonly config?: {
+      readonly provider?: string;
+      readonly model?: string;
+    };
+  };
+}): FaceModelRoute | undefined;
+//#endregion
+//#region src/adapt/wire-event.d.ts
+/** Published isomorphism keys (XRK type → wire role). */
+declare const EVENT_ISOMORPHISM: {
+  readonly "user/message": "user";
+  readonly "assistant/chunk": "assistant.delta";
+  readonly "assistant/message": "assistant.message";
+  readonly "tool/call": "tool.call";
+  readonly "tool/result": "tool.result";
+  readonly "turn/start": "turn.start";
+  readonly "turn/end": "turn.end";
+  readonly "step/start": "step.start";
+  readonly "step/end": "step.end";
+  readonly "prompt/admitted": "agent/inbox/spliced";
+  readonly "prompt/promoted": "agent/inbox/spliced";
+  readonly "prompt/withdrawn": "agent/inbox/spliced";
+  readonly "safety/notice": "safety";
+  readonly "context/compaction": "compaction";
+  readonly "session/title": "title";
+  readonly "approval/asked": "approval.asked";
+  readonly "approval/decided": "approval.decided";
+  readonly "command/run": "command/run";
+  readonly "command/done": "command/done";
+  readonly "todo/write": "todo/write";
+  readonly "permission/preset": "permission/preset";
+  readonly "sandbox/mode": "sandbox/mode";
+  readonly "approval/policy": "approval/policy";
+  readonly "plan/mode": "plan/mode";
+  readonly "feedback/record": "feedback/record";
+  readonly "request/header": "request.header";
+  readonly "llm/retry": "llm.retry";
+  readonly "llm/retry-started": "llm.retry-started";
+  readonly "image/offload": "image/offload";
+  readonly "workspace/changes": "workspace/changes";
+  readonly "deliverables/presented": "deliverables/presented";
+};
+/** SessionEvent envelope on the Face wire. */
+interface FaceWireSessionEvent {
+  readonly type: string;
+  readonly seq: number;
+  readonly time: number;
+  readonly data: unknown;
+  /**
+   * Face surface marker. Client conversation fold only updates
+   * `assistant/message` / `tool/result` / `user/message` when this is `append`
+   * (see `isAppendSurfaceEvent`). XRK protocol events have no surfaceOp — Face
+   * stamps append on the three model-visible types at the wire boundary.
+   */
+  readonly surfaceOp?: "append" | {
+    readonly op: "replace";
+    readonly start: number;
+    readonly end: number;
+  };
+  /** When true, product-shell fold may skip unknown / non-product events. */
+  readonly ignorable?: true;
+}
+interface WireHistoryEntry {
+  readonly event: FaceWireSessionEvent;
+  readonly view?: ToolEventView;
+}
+interface WireAdaptContext {
+  readonly sessionId: string;
+  readonly ids?: FaceWireIdMaps;
+  /**
+   * Ordered inbox projector. Required for prompt/* ? `agent/inbox/spliced`.
+   * History builds a fresh projector; mux reuses the per-session instance.
+   */
+  readonly inbox?: FaceInboxWireProjector;
+  /**
+   * Call-id ? { name, args } pairing for result-time presenters (wire `argsFor`).
+   * History precomputes from the log; mux uses FaceToolArgMaps.
+   */
+  readonly toolArgs?: ReadonlyMap<string, {
+    readonly name: string;
+    readonly args: unknown;
+  }>;
+  /** Tool presenter lookup (standing tools get). Omit ? no view. */
+  readonly getTool?: PresentToolLookup["getTool"];
+  /**
+   * LLM route for this session's current attempt (`request/header` / session
+   * model). Used as `assistant/message` wire `source`; omit → placeholder.
+   */
+  readonly modelRoute?: FaceModelRoute;
+}
+/**
+ * Fallback when no FaceWireIdMaps (unit tests). Prefer maps in production path.
+ */
+declare function wireNumericId(id: string): number;
+/** Map XRK flat event → Face `{ type, seq, time, data }`. */
+declare function toFaceWireSessionEvent(event: SessionEvent, seq: number, ctx?: WireAdaptContext): FaceWireSessionEvent;
+declare function toWireHistoryEntry(event: SessionEvent, seq: number, ctx?: WireAdaptContext): WireHistoryEntry;
+declare function toMuxSessionEvent(sessionId: string, event: SessionEvent, seq: number, ctx?: WireAdaptContext): {
+  readonly type: "session/event";
+  readonly sessionId: string;
+  readonly event: FaceWireSessionEvent;
+  readonly seq: number;
+  readonly view?: ToolEventView;
+};
+//#endregion
+//#region src/adapt/subagent-notice.d.ts
+/**
+ * Child body text for parent-facing completion / tool results.
+ *
+ * Only `assistant/message.content` (or text `assistant/chunk`s). Never
+ * `reasoning` / reasoning chunks — parent providers must not receive the
+ * child's CoT in the next request (DSH settlement keeps text blocks only;
+ * Codex: reasoning never enters the parent session).
+ */
+declare function lastAssistantBodyText(events: readonly SessionEvent[]): string;
+/**
+ * Parent inbox notice when a background (continuable) child drain goes idle.
+ * Mirrors job completion copy: short status + how to follow up.
+ */
+declare function formatSubagentCompletionNotice(link: FaceSubagentLink, events: readonly SessionEvent[], maxPreviewChars?: number): string;
+//#endregion
+//#region src/presets-catalog.d.ts
+/** Catalog of Face-exposed session agent presets (tool composition badges). */
+type AgentToolComposition = "minimal" | "harness";
+/**
+ * Built-in session badges (five tiers).
+ * Plan mode is `/plan` / `exit_plan_mode`, not a badge.
+ * Order matches product picker: lighter → fuller.
+ */
+type CatalogAgentPresetId = "minimal" | "shell" | "frugal" | "shallow" | "harness";
+/** Subagent policy for a session badge (Host binds tools from this). */
+interface AgentSubagentPolicy {
+  readonly mode: "off" | "on";
+  /**
+   * Optional badge ceiling on nesting depth when mode is on.
+   * Live cap is Face `agent-loop.maxSubagentDepth` (default
+   * {@link DEFAULT_MAX_DEPTH}); effective = min(face, this) when set.
+   */
+  readonly maxDepth?: number;
+  /**
+   * Optional badge ceiling on concurrent active children under one parent.
+   * Live cap is Face `agent-loop.maxActiveSubagents` (default
+   * {@link DEFAULT_MAX_ACTIVE_CHILDREN}).
+   */
+  readonly maxActiveChildren?: number;
+}
+/** Harness-plane tool switches (ignored when composition is minimal). */
+interface AgentToolFlags {
+  readonly web: boolean;
+  readonly lsp: boolean;
+  readonly pty: boolean;
+}
+interface AgentPresetProfile {
+  readonly id: CatalogAgentPresetId;
+  readonly composition: AgentToolComposition;
+  readonly tools: AgentToolFlags;
+  readonly subagents: AgentSubagentPolicy;
+  /** Skip harness `tool:subagent` routing prompt when subagents are off. */
+  readonly subagentRouting: boolean;
+  /**
+   * Seed `plan/mode` active on session.create.
+   * Prefer `/plan` for collaboration mode; badges keep this false.
+   */
+  readonly planModeDefault: boolean;
+}
+interface AgentPresetInfo {
+  readonly id: CatalogAgentPresetId;
+  readonly displayName: string;
+  readonly description: string;
+  readonly profile: AgentPresetProfile;
+}
+/** Face / tool default: nesting depth cap (Hermes-style tighter than historical 3). */
+declare const DEFAULT_MAX_DEPTH = 2;
+/** Face / tool default: concurrent active children under one parent. */
+declare const DEFAULT_MAX_ACTIVE_CHILDREN = 2;
+/**
+ * Session badges offered in the product UI.
+ * Host CLI also accepts `server` (same as harness) — see {@link resolveAgentPresetProfile}.
+ */
+declare const FACE_AGENT_PRESETS: readonly AgentPresetInfo[];
+/** Host `--preset` / env ids (includes legacy `server` / `plan` → harness). */
+declare const HOST_CLI_PRESET_IDS: readonly [...CatalogAgentPresetId[], "server", "plan"];
+/** Ids accepted on the wire (includes legacy `server` / `plan` → harness). */
+declare const FACE_AGENT_PRESET_IDS: Set<string>;
+/**
+ * Normalize wire / Host `--preset` to a catalog profile.
+ * Unknown ids fall back to `hostFallback` (default harness).
+ * Legacy `server` and `plan` map to harness tools (`/plan` owns collaboration mode).
+ */
+declare function resolveAgentPresetProfile(agentPreset: string | undefined, hostFallback?: string): AgentPresetProfile;
+/**
+ * Map session badge / Host `--preset` to the tool composition package.
+ * `server` is the Host-plane CLI name; tools match harness.
+ */
+declare function resolveToolPreset(agentPreset: string | undefined, hostFallback?: string): AgentToolComposition;
+/** Persist only catalog ids (legacy `server` → `harness`). */
+declare function canonicalAgentPresetId(id: string): CatalogAgentPresetId;
+//#endregion
+//#region src/queue.d.ts
+/**
+ * Authoritative `session/queue` item: id · placement · message.
+ */
+type QueuePlacement = "queued" | "steering" | "context";
+interface FaceQueueMessage {
+  readonly id: string;
+  readonly role: "user";
+  readonly content: readonly ({
+    readonly type: "text";
+    readonly text: string;
+  } | {
+    readonly type: "image";
+    readonly attachment: {
+      readonly attachmentId: string;
+      readonly mediaType: string;
+      readonly bytes: number;
+      readonly width: number;
+      readonly height: number;
+      readonly name?: string;
+    };
+  } | {
+    readonly type: "file";
+    readonly attachment: {
+      readonly attachmentId: string;
+      readonly name: string;
+      readonly bytes: number;
+      readonly mediaType?: string;
+    };
+  })[];
+  readonly source: {
+    readonly kind: "user";
+    readonly rpcId?: string;
+  };
+}
+interface FaceQueueItem {
+  readonly id: string;
+  readonly placement: QueuePlacement;
+  readonly message: FaceQueueMessage;
+}
+declare function toQueueItems(pending: readonly AdmitReceipt[], admitToRpc: ReadonlyMap<string, string>): FaceQueueItem[];
+//#endregion
+//#region src/workspace-face.d.ts
+declare function resolveProductDir(root: string): string;
+/** Ensure candidate resolves under root (or equals root). */
+declare function assertUnderRoot(root: string, candidate: string): string;
+declare class PathEscapeError extends Error {
+  constructor(message: string);
+}
+interface WorkspaceProductEntry {
+  readonly path: string;
+  readonly kind: "file" | "dir";
+  readonly bytes?: number;
+}
+declare function listProductTree(productDir: string, options?: {
+  maxEntries?: number;
+  maxDepth?: number;
+}): Promise<{
+  readonly entries: WorkspaceProductEntry[];
+  readonly truncated: boolean;
+  readonly exists: boolean;
+}>;
+declare function workspaceDescribe(runtime: FaceRuntime, _rpcId?: string, payload?: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspaceListProduct(runtime: FaceRuntime, _rpcId?: string, payload?: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspacePreviewInject(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+/**
+ * Face `workspace.list` — registry of workspaces + archived sessions.
+ */
+declare function workspaceListFace(runtime: FaceRuntime): Promise<FaceRpcResult<unknown>>;
+declare function workspaceCreateFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspaceRenameFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspaceArchiveSessionFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspaceUnarchiveSessionFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspacePinSessionFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspaceUnpinSessionFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspaceDeleteFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspaceInsertBeforeFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+declare function workspaceInsertSessionBeforeFace(runtime: FaceRuntime, payload: unknown): Promise<FaceRpcResult<unknown>>;
+//#endregion
+//#region src/workspace-paths.d.ts
+/**
+ * Workspace path title helper (Host Face).
+ * Drive roots (`C:\`) keep the complete root spelling; ordinary dirs use basename.
+ * Absolute-path acceptance for create reuses {@link fullyQualified} (browse picker).
+ */
+/**
+ * Derive a non-empty default title from a workspace path.
+ * @param path - Workspace path (typically already absolute).
+ * @param platform - Host platform; injectable for deterministic path tests.
+ */
+declare function defaultWorkspaceTitle(path: string, platform?: NodeJS.Platform): string;
+//#endregion
+//#region src/ralph-tool.d.ts
+/** Product default / call ceiling (DSH default 256 is too large for Face). */
+declare const RALPH_DEFAULT_MAX_ROUNDS = 8;
+declare const RALPH_HARD_MAX_ROUNDS = 32;
+declare const RALPH_MAX_HANDOFF_CHARS = 16384;
+/** Parent-facing terminal text ceiling (DSH tool-ralph default). */
+declare const RALPH_MAX_RESULT_CHARS = 16384;
+type RalphRoundStatus = "continue" | "complete" | "blocked";
+interface RalphRoundReport {
+  readonly status: RalphRoundStatus;
+  readonly summary: string;
+  readonly evidence: readonly string[];
+  readonly nextSteps: readonly string[];
+  readonly blocker: string;
+}
+type RalphTerminalStatus = "complete" | "blocked" | "budget-limited" | "round-failed";
+/** Validate a worker report (DSH status-specific rules + size ceiling). */
+declare function validateRalphReport(raw: unknown, maxHandoffChars?: number): RalphRoundReport;
+interface BindRalphToolOptions {
+  readonly runtime: FaceRuntime;
+  readonly parentSessionId: string;
+  readonly maxDepth?: number;
+  readonly maxActiveChildren?: number;
+  /** Override default/ceiling for tests. */
+  readonly maxRoundsCeiling?: number;
+}
+declare function createRalphTool(options: BindRalphToolOptions): ToolDefinition;
+declare function bindRalphTool(tools: ToolRegistry, options: BindRalphToolOptions): void;
+//#endregion
+//#region src/agent-team-output.d.ts
+/**
+ * Hermes-style optional output_schema contract for delegated tasks.
+ * Appends an OUTPUT CONTRACT block; validates final JSON with a light check
+ * (no jsonschema dependency). One correction turn is the caller's job.
+ */
+type OutputSchemaObject = Readonly<Record<string, unknown>>;
+/** Coerce model-supplied schema; `(schema, undefined)` or `(undefined, error)`. */
+declare function coerceOutputSchema(raw: unknown): {
+  readonly schema: OutputSchemaObject;
+  readonly error?: undefined;
+} | {
+  readonly schema?: undefined;
+  readonly error: string;
+} | {
+  readonly schema?: undefined;
+  readonly error?: undefined;
+};
+/** Append the machine-validated OUTPUT CONTRACT block (Hermes wording). */
+declare function appendOutputContract(prompt: string, schema: OutputSchemaObject): string;
+/** Strip fences / prose; return outermost `{…}` or `[…]` that parses as JSON. */
+declare function extractJsonCandidate(text: string): string | undefined;
+interface OutputSchemaValidation {
+  readonly valid: boolean;
+  readonly errors: readonly string[];
+  readonly candidate?: string;
+}
+/**
+ * Light validation: parse JSON candidate; when schema.required is a string[],
+ * require those keys on object results. Type mismatches are best-effort only.
+ */
+declare function validateOutputAgainstSchema(text: string, schema: OutputSchemaObject): OutputSchemaValidation;
+/** One correction turn (Hermes: do not re-paste the schema). */
+declare function buildOutputSchemaRetryMessage(errors: readonly string[]): string;
+//#endregion
+//#region src/session-status.d.ts
+interface SessionStatusJobRow {
+  readonly id: string;
+  readonly status: string;
+  readonly label?: string;
+}
+interface SessionStatusSubagentLive {
+  readonly id: string;
+  readonly label?: string;
+  readonly activity: "running" | "inactive";
+  readonly mode: string;
+  readonly liveText?: string;
+  readonly liveTool?: string;
+  /** Child inbox admits waiting as queue (not yet drained). */
+  readonly queued?: number;
+  /** Child inbox admits waiting as steer. */
+  readonly steering?: number;
+  /** External runtime kind when this child is ACP / app-server backed. */
+  readonly externalKind?: "acp" | "app-server";
+  /**
+   * `live` = process handle attached; `cold` = sidecar handle only (Host
+   * restart / dispose) — follow-up may attempt reopen via thread/resume.
+   */
+  readonly externalResume?: "live" | "cold";
+}
+/** Depth / concurrency caps for Status + model `analytics`. */
+interface SessionStatusSubagentQuota {
+  readonly depth: number;
+  readonly maxDepth: number;
+  readonly active: number;
+  readonly maxActive: number;
+  readonly delegated: number;
+  readonly slotsFree: number;
+}
+interface SessionStatusGraph {
+  readonly nodes: readonly {
+    readonly id: string;
+    readonly label: string;
+    readonly role?: string;
+    /** Delegation depth from the status session root (0 = root). */
+    readonly depth?: number;
+    /** Joined from `subagents.live` when the node is a registered child. */
+    readonly activity?: "running" | "inactive";
+  }[];
+  readonly edges: readonly {
+    readonly from: string;
+    readonly to: string;
+    readonly kind: string;
+    readonly label?: string;
+  }[];
+}
+interface SessionStatusCostBuckets {
+  readonly input: number;
+  readonly output: number;
+  readonly cacheRead: number;
+  readonly cacheWrite: number;
+  readonly reasoning: number;
+  readonly cost: number;
+}
+/** Per-session costUsage totals + model breakdown (Face projection). */
+interface SessionStatusCost extends SessionStatusCostBuckets {
+  readonly byModel: Readonly<Record<string, SessionStatusCostBuckets>>;
+  readonly byProviderModel: Readonly<Record<string, SessionStatusCostBuckets>>;
+}
+/** One ranked row for Overview / `/status` (session or ledger). */
+interface SessionStatusCostModelRow {
+  readonly key: string;
+  readonly input: number;
+  readonly output: number;
+  readonly cost: number;
+}
+/**
+ * Cross-session cost-meter ledger fold (today / month / total + top models).
+ * Same file ledger as `costMeter/getState` · tokenledger — not a second SoT.
+ */
+interface SessionStatusBilling {
+  readonly todayCost: number;
+  readonly monthCost: number;
+  readonly totalCost: number;
+  readonly todayTokens: number;
+  readonly monthTokens: number;
+  /** Month window, ranked by cost then tokens (max 8). */
+  readonly byModel: readonly SessionStatusCostModelRow[];
+  /** Month window `provider:model`, ranked (max 8). */
+  readonly byProviderModel: readonly SessionStatusCostModelRow[];
+  /** Recent daily points from ledger history (Hermes insights / dsh-wallet). */
+  readonly dailyTrend: readonly SessionStatusBillingDay[];
+}
+/** One day on the billing trend sparkline. */
+interface SessionStatusBillingDay {
+  readonly date: string;
+  readonly cost: number;
+  readonly tokens: number;
+}
+/**
+ * Fleet health for Status (subagents · jobs · channels) — Hermes StatusPage
+ * style operator glance, not a separate monitoring product.
+ */
+type SessionStatusFleetHealth = "ok" | "warn" | "critical";
+interface SessionStatusFleetAlert {
+  readonly id: string;
+  readonly severity: "info" | "warn" | "critical";
+  readonly message: string;
+}
+interface SessionStatusFleet {
+  readonly health: SessionStatusFleetHealth;
+  readonly runningJobs: number;
+  readonly runningSubagents: number;
+  readonly slotsFree: number;
+  readonly queuedInbox: number;
+  readonly channelAlerts: number;
+  readonly alerts: readonly SessionStatusFleetAlert[];
+}
+interface SessionStatusChannels {
+  readonly process: readonly {
+    readonly pluginId: string;
+    readonly channelId: string;
+    readonly displayName?: string;
+  }[];
+  readonly im: readonly {
+    readonly channelId: string;
+    readonly displayName: string;
+    readonly wired: string;
+  }[];
+  readonly note: string;
+  /** Discover stubs / bridge-only IM that need operator attention. */
+  readonly alerts: readonly SessionStatusFleetAlert[];
+}
+interface SessionStatusTimeline {
+  readonly total: number;
+  readonly system: number;
+  readonly tools: number;
+  readonly user: number;
+  readonly inject: number;
+  readonly assistant: number;
+  readonly tool: number;
+  readonly requestCount: number;
+  readonly eventCount: number;
+  readonly model?: string;
+  readonly provider?: string;
+  readonly contextWindow?: number;
+  /** Distinct inject source labels (kind · form · plugin name). */
+  readonly injectSources: readonly string[];
+  /** Latest compaction reason when any compaction event exists. */
+  readonly lastCompactReason?: ContextTimelineCompactReason;
+  /** Latest shadowedTokenCount from compaction (when logged). */
+  readonly lastShadowedTokens?: number;
+  /** Count of prune events that cite a spill path. */
+  readonly spillCount: number;
+  /** Count of tool-result prune / spill boundary events. */
+  readonly pruneCount: number;
+}
+/** Soft-budget / overflow stage chain folded from durable timeline events. */
+type SessionStatusCompactionPipeline = "none" | "prune" | "summary" | "prune→summary";
+type SessionStatusCompactionStage = "prune" | "summary";
+/**
+ * Prune-first then summary observability (DSH-aligned stages on the Status
+ * surface — no extra protocol events; folds existing prune + compaction rows).
+ */
+interface SessionStatusCompaction {
+  /** Last completed stage chain within one turn (or across latest markers). */
+  readonly pipeline: SessionStatusCompactionPipeline;
+  /** Ordered stages for that last pipeline (empty when `none`). */
+  readonly stages: readonly SessionStatusCompactionStage[];
+  /**
+   * Configured soft-budget strategy (Face `agent-loop.compactionStrategy`).
+   * Distinct from last-turn `pipeline` (what actually ran).
+   */
+  readonly strategy?: "prune-summary" | "prune-only" | "summary-only" | "off";
+  readonly lastReason?: ContextTimelineCompactReason;
+  readonly lastShadowedTokens?: number;
+  readonly pruneCount: number;
+  /** Count of `context/compaction` (summary) timeline rows. */
+  readonly summaryCount: number;
+  readonly spillCount: number;
+  /**
+   * Recent unique spill files (newest last; capped). Each row may include
+   * basename · bytes · head/tail preview when the file is still on disk.
+   */
+  readonly spillPaths?: readonly SessionStatusSpillEntry[];
+  /**
+   * Live latch: turn or manual `/compact` holds the agent busy bit
+   * (compact and turn are mutually exclusive on the same latch).
+   */
+  readonly phase: "idle" | "busy";
+  /** Thin Guardian fragment registered (Settings `guardianFragments`). */
+  readonly guardian?: boolean;
+}
+/** One tool-result spill file surfaced on Status / Context browse. */
+interface SessionStatusSpillEntry {
+  readonly path: string;
+  /** Basename for the overview list. */
+  readonly name: string;
+  /** On-disk UTF-8 byte length when the file is readable. */
+  readonly bytes?: number;
+  /** Head/tail peek (capped); absent when the file is missing. */
+  readonly preview?: string;
+  /** Tool name from the prune/spill timeline row when known. */
+  readonly tool?: string;
+}
+/**
+ * Queue vs turn mutual exclusion facts for the Overview Status column.
+ * Compact shares the agent latch with the turn — queue still FIFO-accepts.
+ */
+interface SessionStatusDelivery {
+  readonly turnActive: boolean;
+  readonly queued: number;
+  readonly steering: number;
+  /** True when the latch is held — `/compact` returns busy. */
+  readonly compactBlockedByTurn: boolean;
+  /** Admits with delivery=queue still land while the latch is held. */
+  readonly queueAcceptedWhileBusy: true;
+  /** Steer placement only applies while a turn is active. */
+  readonly steerRequiresActiveTurn: true;
+  /** One-line operator note (slash + Overview). */
+  readonly note: string;
+}
+interface SessionStatusTeamTask {
+  readonly id: string;
+  readonly title: string;
+  readonly status: string;
+  readonly revision: number;
+  readonly childSessionId?: string;
+  readonly role?: string;
+  readonly humanOwned?: boolean;
+  readonly schemaValid?: boolean;
+  readonly worktreePath?: string;
+  readonly worktreeBranch?: string;
+  readonly worktreeId?: string;
+  /** Managed lease status (`active` · `retained` · `reclaimed`) when known. */
+  readonly worktreeLeaseStatus?: string;
+  /** Truncated completion / failure preview from the task board. */
+  readonly resultPreview?: string;
+  /**
+   * External-agent resume surface for the bound child (`live` process vs
+   * `cold` sidecar-only). Same values as `subagents.live[].externalResume`.
+   */
+  readonly externalResume?: "live" | "cold";
+}
+/** Structured Status facts shared by slash `/status` and Overview. */
+interface SessionStatusSnapshot {
+  readonly sessionId: string;
+  readonly badge: string;
+  readonly permission: string;
+  readonly plan: "on" | "off";
+  readonly theme: string;
+  readonly model: {
+    readonly provider: string;
+    readonly model: string;
+  };
+  readonly cwd: string;
+  readonly events: number;
+  readonly jobs: readonly SessionStatusJobRow[];
+  readonly subagents: {
+    readonly live: readonly SessionStatusSubagentLive[];
+    readonly graph: SessionStatusGraph;
+    /** Face agent-loop ∩ badge ceilings + live active count. */
+    readonly quota: SessionStatusSubagentQuota;
+  };
+  /** Agent Teams task board (delivery · result · pause/takeover). */
+  readonly teamTasks: readonly SessionStatusTeamTask[];
+  readonly cost: SessionStatusCost;
+  /** Host-wide ledger fold (cross-session · cross-model). */
+  readonly billing: SessionStatusBilling;
+  /** Subagent / job / channel health glance. */
+  readonly fleet: SessionStatusFleet;
+  readonly timeline: SessionStatusTimeline;
+  /** Prune → summary stage fold + live busy phase. */
+  readonly compaction: SessionStatusCompaction;
+  /** Queue / steer / turn latch mutual exclusion. */
+  readonly delivery: SessionStatusDelivery;
+  readonly channels: SessionStatusChannels;
+  /** Last curated-memory consolidate (Host pipeline; optional). */
+  readonly curatedMemory?: SessionStatusCuratedMemory;
+}
+/** Host curated-memory consolidate glance (Hermes memory_status-style). */
+interface SessionStatusCuratedMemory {
+  readonly sessionId: string;
+  readonly at: number;
+  readonly phase1Written: number;
+  readonly phase2: string;
+  readonly phase2Written: number;
+  readonly skipped?: string;
+  readonly providerKind?: string;
+}
+/** Rank map rows by cost, then tokens (Hermes insights-style top models). */
+declare function rankCostModelRows(map: Readonly<Record<string, SessionStatusCostBuckets>>, limit?: number): SessionStatusCostModelRow[];
+/**
+ * Peek a spill file for Status/Context browse (basename · bytes · head/tail).
+ * Missing files still return a path+name row so the operator can see the locator.
+ */
+declare function peekSpillEntry(filePath: string, options?: {
+  readonly tool?: string;
+  readonly previewBudget?: number;
+}): SessionStatusSpillEntry;
+/**
+ * Build the Status snapshot for one session.
+ * Same facts feed `/status` text and Face `session.status`.
+ */
+declare function buildSessionStatusSnapshot(runtime: FaceRuntime, sessionId: string): SessionStatusSnapshot;
+/** Format the shared snapshot as `/status` command text. */
+declare function formatSessionStatusText(snap: SessionStatusSnapshot): string;
+//#endregion
+//#region src/rollout-trace.d.ts
+type RolloutTraceEdgeKind = "spawn" | "message" | "tool";
+type RolloutTraceNodeKind = "session" | "turn" | "tool_call" | "message";
+interface RolloutTraceNode {
+  readonly id: string;
+  readonly kind: RolloutTraceNodeKind;
+  readonly sessionId: string;
+  readonly label?: string;
+  readonly turnId?: string;
+  readonly toolName?: string;
+}
+interface RolloutTraceEdge {
+  readonly id: string;
+  readonly kind: RolloutTraceEdgeKind;
+  readonly from: string;
+  readonly to: string;
+  readonly label?: string;
+}
+interface RolloutTraceLink {
+  readonly parentSessionId: string;
+  readonly childSessionId: string;
+  readonly mode?: string;
+  readonly label?: string;
+}
+interface RolloutTraceState {
+  readonly version: 1;
+  /** Local debug only — never treat as telemetry upload payload. */
+  readonly purpose: "local-debug";
+  readonly rootSessionId: string;
+  readonly sessions: readonly string[];
+  readonly nodes: readonly RolloutTraceNode[];
+  readonly edges: readonly RolloutTraceEdge[];
+  readonly counts: {
+    readonly nodes: number;
+    readonly edges: number;
+    readonly spawn: number;
+    readonly message: number;
+    readonly tool: number;
+  };
+}
+interface BuildRolloutTraceInput {
+  readonly rootSessionId: string;
+  /** Session id → append-only events (order preserved). */
+  readonly eventsBySession: Readonly<Record<string, readonly SessionEvent[]>>;
+  /** Parent→child registry (Face subagents); drives spawn edges. */
+  readonly links?: readonly RolloutTraceLink[];
+}
+/**
+ * Reduce session events + subagent links into a local debug graph.
+ * Edges: spawn (registry), message (user/assistant turns), tool (call→result).
+ */
+declare function buildRolloutTraceState(input: BuildRolloutTraceInput): RolloutTraceState;
+//#endregion
+//#region src/host-pick-directory.d.ts
+/**
+ * Whether Face may run the OS directory picker.
+ * Same Desktop override as {@link canOpenNativePath}: `XRK_NATIVE_OPEN=1`.
+ */
+declare function canPickNativeDirectory(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): boolean;
+/** Testable command boundary; implementations should not invoke a shell. */
+type DirectoryPickerRunner = (command: string, args: readonly string[], signal: AbortSignal) => Promise<{
+  readonly stdout: string;
+}>;
+interface DirectoryPickerInternals {
+  readonly platform?: NodeJS.Platform;
+  readonly run?: DirectoryPickerRunner;
+}
+/** STA FolderBrowserDialog — no koffi; cancel exits 1. */
+declare const WIN32_POWERSHELL_PICK: string;
+/**
+ * Open the platform directory picker.
+ * @returns selected path, or `null` when the user cancels.
+ */
+declare function pickNativeDirectory(signal: AbortSignal, internals?: DirectoryPickerInternals): Promise<string | null>;
+type NativeDirectoryPicker = (signal: AbortSignal) => Promise<string | null>;
+/**
+ * Face RPC wrapper. Inject `pickNativeDirectory` on the runtime in tests —
+ * never pop a real dialog in CI.
+ */
+declare function hostPickDirectoryRpc(runtime: {
+  pickNativeDirectory?: NativeDirectoryPicker;
+}): Promise<FaceRpcResult<{
+  path: string | null;
+}>>;
+//#endregion
+//#region src/host-open-path.d.ts
+/**
+ * Whether Face may advertise `canOpenPath` / run `host.openPath`.
+ * Desktop Host sets `XRK_NATIVE_OPEN=1` so the bit stays true without a second opener.
+ */
+declare function canOpenNativePath(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): boolean;
+/** Normalize trailing `.` / separator noise from client path joins. */
+declare function normalizeOpenPath(target: string): string;
+/**
+ * Win32 path for Explorer argv. Forward slashes must become `\`: Explorer
+ * treats `/seg` after `/select,` as another switch, so reveal silently no-ops.
+ * Must NOT be used on absolute URLs — that would turn `https://` into `https:\\`.
+ */
+declare function windowsExplorerPath(target: string): string;
+declare function openNativePath(target: string, platform?: NodeJS.Platform): Promise<void>;
+/**
+ * Reveal a path in the desktop file manager (select file when possible).
+ */
+declare function revealNativePath(target: string, platform?: NodeJS.Platform): Promise<void>;
+declare function hostOpenPath(payload: unknown): Promise<FaceRpcResult<{
+  opened: true;
+}>>;
+//#endregion
+//#region src/model-catalog.d.ts
+interface FaceModelSelection {
+  readonly provider: string;
+  readonly model: string;
+  readonly reasoningEffort?: string;
+}
+//#endregion
+//#region src/llm-resolve.d.ts
+interface ResolvedFaceLlm {
+  readonly binding: ProviderBinding;
+  readonly adapter: LlmAdapter;
+  readonly selection: FaceModelSelection;
+}
+declare class FaceLlmResolveError extends Error {
+  readonly code: "missing-credential" | "resolve-failed";
+  constructor(code: FaceLlmResolveError["code"], message: string);
+}
+/** Build adapter for an explicit selection (selectModel preflight + agent factory). */
+declare function resolveLlmForSelection(runtime: FaceRuntime, selection: FaceModelSelection): ResolvedFaceLlm;
+/** Session-scoped routing adapter (DSH hot model switch without agent invalidate). */
+declare function createSessionRoutingLlm(runtime: FaceRuntime, sessionId: string): RoutingLlmAdapter | undefined;
+/**
+ * Whether the live model route declares image input (DSH resolveModelInfo gate).
+ * Face `inputModalities` is intake-only and must not override this.
+ */
+declare function liveRouteAllowsImageInput(runtime: FaceRuntime, sessionId?: string): boolean;
+/** Build adapter for the session's selected provider/model when credentials exist. */
+declare function resolveLlmForSession(runtime: FaceRuntime, sessionId: string): ResolvedFaceLlm | undefined;
+//#endregion
+//#region src/llm-provider-context.d.ts
+interface ProviderRouteContext {
+  readonly baseUrl?: string;
+  readonly path?: string;
+  readonly authMode?: AuthMode;
+  /** Face `llm-pi-ai.providers.*.api` → Registry protocol. */
+  readonly protocol?: ProtocolId;
+}
+interface ProviderCredentialContext {
+  readonly apiKey?: string;
+  readonly source: "typed" | "vault" | "env" | "none";
+}
+/** One hand-declared `llm-pi-ai.providers.<id>` that is not a Registry brand. */
+type DeclaredPiAiProvider = {
+  readonly id: string;
+  readonly displayName: string;
+  readonly baseUrl?: string;
+  readonly api?: string;
+  readonly models: readonly {
+    readonly id: string;
+    readonly name?: string;
+    readonly inputModalities?: readonly ("text" | "image")[];
+    readonly contextWindow?: number;
+  }[];
+};
+/** Case-insensitive lookup into `llm-pi-ai.providers`. */
+declare function piAiProviderProfile(runtime: FaceRuntime, provider: string): Record<string, unknown> | undefined;
+/**
+ * Effective credential env name: brand → deepseek settings → pi-ai profile.
+ */
+declare function providerApiKeyEnv(runtime: FaceRuntime, provider: string): string | undefined;
+/**
+ * Settings-declared providers that name an `apiKeyEnv` (credential slots).
+ */
+declare function listSettingsProviderCredentialRefs(runtime: FaceRuntime): readonly {
+  readonly providerId: string;
+  readonly apiKeyEnv: string;
+}[];
+/**
+ * Settings-only routes (Custom provider card). Excludes Registry brands.
+ */
+declare function listDeclaredPiAiProviders(runtime: FaceRuntime): readonly DeclaredPiAiProvider[];
+/** Effective route overrides from `llm-deepseek` / `llm-pi-ai`. */
+declare function readProviderRoute(runtime: FaceRuntime, provider: string): ProviderRouteContext;
+/** Credential precedence: typed probe → vault → env. */
+declare function readProviderApiKey(runtime: FaceRuntime, provider: string, typed?: string): ProviderCredentialContext;
+/** Whether this provider can authenticate for a live adapter. */
+declare function providerHasUsableCredential(runtime: FaceRuntime, provider: string): boolean;
+/**
+ * Resolve Registry brand, or synthesize from `llm-pi-ai.providers.<id>`.
+ * Optional `route` overlays settings (e.g. discovery draft `baseURL`).
+ */
+declare function resolveProviderBinding(runtime: FaceRuntime, input: {
+  readonly provider: string;
+  readonly model: string;
+  readonly route?: ProviderRouteContext;
+}): ProviderBinding;
+/** Whether a provider id can resolve to a live binding (not API-key gated). */
+declare function providerRouteServed(runtime: FaceRuntime, provider: string): boolean;
+//#endregion
+//#region src/llm-api-key.d.ts
+/**
+ * API key validation — twin of `@xrkseek/xrk-llm` `normalizeApiKey` / client `apiKeyFailure`.
+ * Face cannot import xrk-llm; keep charset rule in sync with ui-settings-models.
+ */
+type ApiKeyRejection = "empty" | "illegalCharacters";
+type ApiKeyCheck = {
+  readonly ok: true;
+  readonly value: string;
+} | {
+  readonly ok: false;
+  readonly reason: ApiKeyRejection;
+};
+/** Trim and validate a credential before it enters an HTTP header. */
+declare function normalizeApiKey(raw: string): ApiKeyCheck;
+//#endregion
+//#region src/session-cwd.d.ts
+declare function resolveSessionCwd(runtime: FaceRuntime, sessionId: string): string;
+//#endregion
+//#region src/settings-document.d.ts
+/** Harness home: explicit `productDir` (tests isolate settings/workspaces), else `XRK_HOME` / `~/.xrk`.
+ * Not the workspace product tree — that is always `{workspaceRoot}/.xrk` via `resolveProductDir`.
+ */
+declare function resolveHarnessHome(runtime: FaceRuntime): string;
+declare function settingsYamlPath(runtime: FaceRuntime): string;
+/** Test helper — clear last-good caches between isolated productDir cases. */
+declare function resetLastGoodConfigCaches(): void;
+declare function validateSettingsNamespace(ns: string, merged: Record<string, unknown>): string | undefined;
+/**
+ * Sync peek of one namespace's user layer from `{harnessHome}/settings.yaml`.
+ * Used by Host before Face exists (SSH world must bind workspaceRoot at spawn).
+ */
+declare function peekSettingsYamlSection(harnessHome: string, ns: string): Record<string, unknown> | undefined;
+//#endregion
+//#region src/settings-agent-tools.d.ts
+declare function bindSettingsTools(tools: ToolRegistry, runtime: FaceRuntime): void;
+//#endregion
+//#region src/session-query-tools.d.ts
+/** Tool-side UTF-8 budget for one `session_read` snapshot (same default as prepare). */
+declare const SESSION_READ_MAX_BYTES = 65536;
+/** Max ancestor / descendant rows returned by `session_trace`. */
+declare const SESSION_TRACE_MAX_NODES = 32;
+interface BindSessionQueryToolsOptions {
+  readonly runtime: FaceRuntime;
+  readonly parentSessionId: string;
+  readonly maxSearchResults?: number;
+  readonly maxReadBytes?: number;
+}
+declare function createSessionSearchTool(options: BindSessionQueryToolsOptions): ToolDefinition;
+declare function createSessionReadTool(options: BindSessionQueryToolsOptions): ToolDefinition;
+declare function createSessionTraceTool(options: BindSessionQueryToolsOptions): ToolDefinition;
+/** Register session_search / session_read / session_trace on a live agent. */
+declare function bindSessionQueryTools(tools: ToolRegistry, options: BindSessionQueryToolsOptions): void;
+//#endregion
+//#region src/subagent-tools.d.ts
+/** Effective Face + badge ceilings for subagent depth / concurrency. */
+interface SubagentQuotaCaps {
+  readonly depth: number;
+  readonly maxDepth: number;
+  readonly active: number;
+  readonly maxActive: number;
+  readonly delegated: number;
+  readonly slotsFree: number;
+}
+/**
+ * Resolve live quota for Status / `analytics` (Face agent-loop ∩ badge ceiling).
+ */
+declare function resolveSubagentQuota(runtime: FaceRuntime, sessionId: string): SubagentQuotaCaps;
+declare function subagentDepth(runtime: FaceRuntime, sessionId: string): number;
+interface BindSubagentToolsOptions {
+  readonly runtime: FaceRuntime;
+  readonly parentSessionId: string;
+  readonly maxDepth?: number;
+  /**
+   * Max concurrent *active* (draining) direct children under this parent.
+   * Omit → {@link DEFAULT_MAX_ACTIVE_CHILDREN} (4).
+   */
+  readonly maxActiveChildren?: number;
+  /** Override spawn for external runtimes (tests). */
+  readonly externalSpawn?: ExternalSpawn;
+  /** Override env for external launch resolution (tests). */
+  readonly externalEnv?: NodeJS.ProcessEnv;
+}
+/** Register model-facing subagent tools on a live Agent tool registry. */
+declare function bindSubagentTools(tools: ToolRegistry, options: BindSubagentToolsOptions): void;
+//#endregion
+//#region src/cost-meter-balance.d.ts
+interface DeepSeekBalanceSnapshot {
+  readonly status: "ok" | "err" | "off";
+  readonly message: string;
+  readonly fetchedAt: number;
+  readonly currency: string;
+  readonly totalBalance: number;
+  readonly grantedBalance: number;
+  readonly toppedUpBalance: number;
+}
+//#endregion
+//#region src/cost-meter-go-quota.d.ts
+interface GoQuotaWindow {
+  readonly percent: number;
+  readonly resetsAt: string;
+}
+interface GoQuotaSnapshot {
+  readonly status: "ok" | "err" | "off";
+  readonly message: string;
+  readonly fetchedAt: number;
+  readonly rolling: GoQuotaWindow | null;
+  readonly weekly: GoQuotaWindow | null;
+  readonly monthly: GoQuotaWindow | null;
+}
+//#endregion
+//#region src/cost-meter-coding-plan-service.d.ts
+interface CodingPlanSnapshot {
+  readonly status: "ok" | "err" | "off" | "error";
+  readonly message: string;
+  readonly fetchedAt: number;
+  readonly windows: Record<string, unknown>;
+}
+//#endregion
+//#region src/cost-meter-custom-balance.d.ts
+interface CustomBalanceSnapshot {
+  readonly status: "ok" | "err" | "off";
+  readonly message: string;
+  readonly fetchedAt: number;
+  readonly label: string;
+  readonly unit: string;
+  readonly remaining: number;
+  readonly maxBudget: number | null;
+  readonly spend: number | null;
+}
+//#endregion
+//#region src/cost-meter-store.d.ts
+interface CostMeterBuckets {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  reasoning: number;
+  cost: number;
+}
+interface CostMeterDay {
+  date: string;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  reasoning: number;
+  calls: number;
+  cost: number;
+  byModel: Record<string, CostMeterBuckets>;
+  byProviderModel: Record<string, CostMeterBuckets>;
+  sessions: Array<Record<string, unknown>>;
+}
+interface CostMeterState {
+  today: CostMeterDay;
+  month: CostMeterDay;
+  total: CostMeterDay;
+  budgetUsed?: number;
+  balance: Record<string, unknown>;
+  goQuota: Record<string, unknown>;
+  customBalance: Record<string, unknown>;
+  codingPlans: Record<string, unknown>;
+  history: CostMeterDay[];
+  config: Record<string, unknown>;
+  priceCatalog: Record<string, unknown> | null;
+  meta: {
+    now: number;
+    timezoneOffsetMinutes: number;
+    dayKey: string;
+    monthKey: string;
+  };
+}
+type LedgerFile = {
+  config: Record<string, unknown>;
+  history: CostMeterDay[];
+  pendingByKey?: Record<string, CostMeterUsageSample>;
+  balanceCache?: DeepSeekBalanceSnapshot;
+  goQuotaCache?: GoQuotaSnapshot;
+  customBalanceCache?: CustomBalanceSnapshot;
+  codingPlansCache?: Record<string, CodingPlanSnapshot>;
+};
+interface CostMeterRefreshResult {
+  readonly ok: boolean;
+  readonly message: string;
+  readonly state: CostMeterState;
+}
+interface CostMeterUsageSample {
+  readonly sessionId: string;
+  readonly turnId: string;
+  readonly stepId: string;
+  readonly ts: number;
+  readonly provider: string;
+  readonly model: string;
+  readonly input: number;
+  readonly output: number;
+  readonly cacheRead: number;
+  readonly cacheWrite: number;
+  readonly reasoning: number;
+  /** USD estimate at record time (from bundled / configured prices). */
+  readonly cost: number;
+}
+/** Align ledger path with Face `productDir` (~/.xrk). */
+declare function configureCostMeterHome(home?: string): void;
+/** Absolute path of the Host cost-meter ledger (doctor / integrators). */
+declare function costMeterLedgerPath(): string;
+/**
+ * Upgrade V3-era bundled tables to V4 flash/pro and recompute every stored cost
+ * from disjoint token buckets (dsh-cost-meter costOf). Returns true when ledger mutated.
+ */
+declare function migrateAndRepriceLedger(ledger: LedgerFile): boolean;
+declare function costMeterGetState(): CostMeterState;
+declare function costMeterRefreshBalance(): Promise<CostMeterRefreshResult>;
+/** DSH tokenledger / usage-stats aggregate from persisted ledger history. */
+declare function costMeterAggregateUsage(query?: {
+  readonly days?: number;
+}): Record<string, unknown>;
+interface CostMeterSessionTotals {
+  readonly uncachedInputTokens: number;
+  readonly outputTokens: number;
+  readonly cacheReadTokens: number;
+  readonly cacheWriteTokens: number;
+  readonly costUsd: number;
+}
+/** Sum ledger session rows for a Face session id (live cost-meter data). */
+declare function costMeterSessionTotals(sessionId: string): CostMeterSessionTotals | null;
+/** dsh-wallet usage panel: recent daily cost from ledger (CNY display). */
+declare function costMeterDisplayExchangeRate(): number;
+/** Recent daily cost for dsh-wallet (CNY). */
+declare function costMeterWalletUsage(days?: number): {
+  readonly today: {
+    date: string;
+    cost: number;
+  };
+  readonly days: Array<{
+    date: string;
+    cost: number;
+  }>;
+  readonly ready: boolean;
+  readonly degraded: boolean;
+};
+//#endregion
+//#region src/cost-meter-pricing.d.ts
+interface ModelPriceTier {
+  readonly cacheHit: number;
+  readonly cacheMiss: number;
+  readonly output: number;
+  /** Extra reasoning rate; default 0 — reasoning is usually already in output. */
+  readonly reasoning?: number;
+}
+interface ModelPriceRow extends ModelPriceTier {
+  readonly peak?: ModelPriceTier;
+  readonly offPeak?: ModelPriceTier;
+  readonly legacyBase?: ModelPriceTier;
+}
+/** DeepSeek + aliases (per-million USD). Keys are lowercase product ids. */
+declare const BUNDLED_MODEL_PRICES: Readonly<Record<string, ModelPriceRow>>;
+declare function bundledCostMeterPriceConfig(): Record<string, unknown>;
+/**
+ * Estimate USD cost. `sample.input` must be **uncached** (disjoint from cacheRead).
+ */
+declare function estimateUsageCostUsd(sample: Pick<CostMeterUsageSample, "provider" | "model" | "input" | "output" | "cacheRead" | "cacheWrite" | "reasoning"> & {
+  readonly ts?: number;
+}, config: Record<string, unknown>): number;
+/** Recompute a CostMeterBuckets-shaped cost from stored token counts. */
+declare function estimateBucketsCostUsd(buckets: {
+  readonly input: number;
+  readonly output: number;
+  readonly cacheRead: number;
+  readonly cacheWrite: number;
+  readonly reasoning: number;
+}, provider: string, model: string, config: Record<string, unknown>, ts?: number): number;
+//#endregion
+//#region src/workspace-checkpoint.d.ts
+/**
+ * Upper bound for one `snapshotSessionWorkspace` call. The store's per-command
+ * timeout should win first; this races the whole call so a runner that never
+ * settles (or a hung fs call) still degrades to "no checkpoint" instead of
+ * blocking the drain queue. Skips the turn's point, never the turn.
+ */
+declare const SNAPSHOT_TIMEOUT_MS = 20000;
+/**
+ * Soft budget for Host drain pre-turn snapshots when the tool barrier must
+ * wait (LLM returned tools before git finished). Overlaps the model call via
+ * `beforeTools`; prefer skip over stalling Queue/Steer. Manual
+ * `session.checkpoint.snapshot` still uses {@link SNAPSHOT_TIMEOUT_MS}.
+ */
+declare const SNAPSHOT_DRAIN_BUDGET_MS = 5000;
+/** Test seam: replace the process git runner (or clear with `undefined`). */
+declare function setWorkspaceCheckpointGitRunner(runner: GitRunner | undefined): void;
+/** Drop cached stores (tests / Host cwd swap). */
+declare function clearWorkspaceCheckpointStores(): void;
+/**
+ * Resolve (and cache) the checkpoint store for a workspace directory.
+ * Shadow git lives under `{XRK_HOME}/checkpoints/<workspace-id>` — product
+ * data is gathered in the XRK home, never inside the workspace.
+ */
+declare function workspaceCheckpointStoreFor(workspaceDir: string, runGit?: GitRunner): WorkspaceCheckpointStore;
+declare function workspaceCheckpointStoreForSession(runtime: FaceRuntime, sessionId: string, runGit?: GitRunner): WorkspaceCheckpointStore;
+/**
+ * Host / Face: snapshot worktree before a turn mutates files.
+ * Best-effort — git missing or snapshot failure must not block the turn.
+ * Disabled when `XRK_CHECKPOINTS=0`.
+ *
+ * Hard deadline: race the snapshot against `opts.budgetMs` (default
+ * {@link SNAPSHOT_TIMEOUT_MS}). Host drain should pass
+ * {@link SNAPSHOT_DRAIN_BUDGET_MS} so large worktrees cannot pin Queue/Steer.
+ */
+declare function snapshotSessionWorkspace(runtime: FaceRuntime, sessionId: string, opts?: {
+  readonly label?: string;
+  readonly seq?: number;
+  /** Whole-call race budget; default {@link SNAPSHOT_TIMEOUT_MS}. */
+  readonly budgetMs?: number;
+}): Promise<WorkspaceCheckpointRecord | undefined>;
+/**
+ * Newest checkpoint for this session whose `seq` is ≤ `atSeq`
+ * (Face 1-based history seq of the message / turn tail).
+ */
+declare function findCheckpointAtOrBefore(store: WorkspaceCheckpointStore, sessionId: string, atSeq: number): WorkspaceCheckpointRecord | undefined;
+/** Resolve `/rollback` target: bare index (1-based newest-last list), id prefix, or `seq:N`. */
+declare function resolveRollbackTarget(store: WorkspaceCheckpointStore, sessionId: string, token: string): WorkspaceCheckpointRecord | undefined;
+//#endregion
+export { AGENT_TEAM_ROLES, AGENT_TEAM_SPAWN_ROLES, type AgentPresetInfo, type AgentPresetProfile, type AgentSubagentPolicy, type AgentTeamEdge, type AgentTeamEdgeKind, AgentTeamGraph, type AgentTeamNeighbor, type AgentTeamNode, type AgentTeamRole, type AgentTeamSpawnRole, type AgentTeamTask, AgentTeamTaskBoard, type AgentTeamTaskStatus, type AgentToolComposition, type AgentToolFlags, type ApiKeyCheck, type ApprovalCategory, type ApprovalClassification, type ApprovalOutcomeWire, type AttachFaceOptions, BUNDLED_MODEL_PRICES, type BindGoalToolsOptions, type BindProposeSkillToolOptions, type BindRalphToolOptions, type BindSessionQueryToolsOptions, type BindSubagentToolsOptions, type BuildRolloutTraceInput, CUSTOM_PERMISSION_PRESET, type CatalogAgentPresetId, type ClientBootEntry, type ClientBootReconcileResult, type ContinuableExternalKind, type CreateFaceRuntimeOptions, type CredentialSlotView, DEFAULT_MAX_ACTIVE_CHILDREN, DEFAULT_MAX_DEPTH, DEFAULT_MAX_GOAL_ROUNDS, DISABLED_PLUGINS_FILE, type DeclaredPiAiProvider, type DirectoryEntryView, type DirectoryListingView, type DirectoryPickerInternals, type DirectoryPickerRunner, EVENT_ISOMORPHISM, ExternalAgentError, type ExternalAgentHandleRecord, type ExternalAgentKind, type ExternalAgentLiveSession, type ExternalAgentProductConfig, ExternalAgentSessionRegistry, type ExternalSpawn, FACE_AGENT_PRESETS, FACE_AGENT_PRESET_IDS, FACE_ASSISTANT_SOURCE_PLACEHOLDER, FACE_HOST_REMOTE_EVENTS, FACE_PERMISSION_TABLE, FACE_REMOTE_NAMESPACES, FACE_RESPOND_PATHS, FACE_RPC_ERROR_CODES, FACE_USAGE_ROUTE_PLACEHOLDER, FACE_WS_HEARTBEAT_INTERVAL_MS, FACE_WS_HEARTBEAT_MAX_MISSED, FACE_WS_PATHS, FEEDBACK_CATEGORIES, FEEDBACK_TEXT_MAX_CHARS, FaceApprovalBroker, type FaceApprovalHooks, type FaceBus, FaceCredentialVault, type FaceDirectoryBackend, type FaceDrain, FaceGoalStore, type FaceHostPublicSettings, type FaceHostRemoteEvent, type FaceInboxSplice, FaceInboxWireMaps, FaceInboxWireProjector, type FaceJobsSource, FaceLlmResolveError, type FaceMcpServerDraft, FaceMessageFeedbackStore, type FaceModelRoute, FaceMuxSeq, type FacePluginInventoryEntry, type FaceProcessPlugin, type FaceProjectionMap, type FaceProjectionRegistry, type FaceQuestionAnswer, type FaceQuestionAnswerItem, FaceQuestionBroker, FaceQuestionError, type FaceQuestionHooks, type FaceQuestionItem, type FaceQueueItem, type FaceQueueMessage, type FaceRemoteArg, type FaceRpcError, type FaceRpcErrorCode, type FaceRpcFail, type FaceRpcReceipt, type FaceRpcRequest, type FaceRpcResponse, type FaceRpcResult, type FaceRuntime, type FaceSeqClock, type FaceSettingsNamespaceView, FaceSettingsNamespaces, type FaceSettingsPathOp, type FaceSubagentLink, FaceSubagentRegistry, FaceTitleController, FaceToolArgMaps, type FaceUiSettings, type FaceWebPlugin, FaceWireIdMaps, type FaceWireSessionEvent, type FaceWireUserMessage, FaceWorkspaceRegistry, type FaceWorkspaceView, GOAL_OBJECTIVE_MAX_CHARS, type GoalActivation, type GoalPhase, type GoalProjectionValue, type GoalRef, type GoalRoundSnapshot, type GoalTurnEndDecision, type GoalView, HOST_CLI_PRESET_IDS, type HostFrame, JOB_COMPLETION_MAX_WAKES, type JobView, MANAGED_WORKTREE_OWNER_FILENAME, MANAGED_WORKTREE_OWNER_VERSION, MESSAGE_FEEDBACK_NOTE_MAX_BYTES, type ManagedPackageIndex, type ManagedPluginPackageMeta, type ManagedWorktreeLease, ManagedWorktreeManager, type ManagedWorktreeMergeResult, type ManagedWorktreeMergeStrategy, type ManagedWorktreeOwnerRecord, type ManagedWorktreeStatus, type MessageFeedbackItem, type MessageFeedbackRating, type MuxFrame, type NativeDirectoryPicker, type NetworkApprovalContext, type NetworkApprovalProtocol, type OutputSchemaObject, type OutputSchemaValidation, PROPOSE_SKILL_APPROVE_LABEL, PROPOSE_SKILL_QUESTION_ID, PROPOSE_SKILL_REJECT_LABEL, type ParsedClientResponse, PathEscapeError, type PendingApprovalItem, type PendingQuestionItem, type PermissionPresetSpec, type PermissionRequestGate, type PermissionSelect, type PermissionSelectOption, type PlanSetOutcome, type PresentToolLookup, type ProjectionSnapshot, type ProjectionWire, type ProviderRouteContext, type QueuePlacement, RALPH_DEFAULT_MAX_ROUNDS, RALPH_HARD_MAX_ROUNDS, RALPH_MAX_HANDOFF_CHARS, RALPH_MAX_RESULT_CHARS, type RalphRoundReport, type RalphRoundStatus, type RalphTerminalStatus, type ResolvedFaceLlm, type RolloutTraceEdge, type RolloutTraceEdgeKind, type RolloutTraceLink, type RolloutTraceNode, type RolloutTraceNodeKind, type RolloutTraceState, type RpcId, type RunExternalAgentOptions, SESSION_EXPORT_PATHS, SESSION_QUERY_ROUTING_PROMPT_TEXT, SESSION_READ_MAX_BYTES, SESSION_TRACE_MAX_NODES, SNAPSHOT_DRAIN_BUDGET_MS, SNAPSHOT_TIMEOUT_MS, SUBAGENT_ROUTING_PROMPT_TEXT, type SessionFeedbackEntry, type SessionListMetadata, type SessionStatusBilling, type SessionStatusBillingDay, type SessionStatusChannels, type SessionStatusCompaction, type SessionStatusCompactionPipeline, type SessionStatusCompactionStage, type SessionStatusCost, type SessionStatusCostBuckets, type SessionStatusCostModelRow, type SessionStatusCuratedMemory, type SessionStatusDelivery, type SessionStatusFleet, type SessionStatusFleetAlert, type SessionStatusFleetHealth, type SessionStatusGraph, type SessionStatusJobRow, type SessionStatusSnapshot, type SessionStatusSpillEntry, type SessionStatusSubagentLive, type SessionStatusTeamTask, type SessionStatusTimeline, SessionTitleInvalidError, type SubagentMode, type ToolCallPairing, type ToolEventView, type UiTheme, WIN32_POWERSHELL_PICK, type WireAdaptContext, type WireHistoryEntry, type WorkspaceProductEntry, type WsHeartbeat, agentTeamGraphPath, agentTeamTasksPath, appendOutputContract, applyLivePermissionDefaultPreset, applyPermissionPreset, applySpawnRoleReminder, approvalRequestedFrame, approvalResolvedFrame, assertUnderRoot, assistantMessageSource, atomicWriteText, attachFaceUpgrades, bindAskUserTool, bindExitPlanModeTool, bindGoalTools, bindManagedWorktreeOwner, bindProposeSkillTool, bindRalphTool, bindSessionQueryTools, bindSettingsTools, bindSubagentTools, buildOutputSchemaRetryMessage, buildRolloutTraceState, buildSessionStatusSnapshot, bundledCostMeterPriceConfig, canOpenNativePath, canPickNativeDirectory, canonicalAgentPresetId, classifyApproval, clearSoftDisabledIdsAt, clearWorkspaceCheckpointStores, coerceAskUserQuestions, coerceOutputSchema, collectToolCallArgs, commitPlanMode, configureCostMeterHome, costMeterAggregateUsage, costMeterDisplayExchangeRate, costMeterGetState, costMeterLedgerPath, costMeterRefreshBalance, costMeterSessionTotals, costMeterWalletUsage, createFaceBus, createFaceOnlyServer, createFaceProjectionRegistry, createFaceRuntime, createFaceSeqClock, createFileLimitsProjectionUnit, createImageLimitsProjectionUnit, createRalphTool, createSessionListMetadataUnit, createSessionReadTool, createSessionRoutingLlm, createSessionSearchTool, createSessionTraceTool, createTitleProjectionUnit, credentialsDescribe, credentialsList, credentialsSet, credentialsUnset, decideGoalTurnEnd, defaultPermissionPreset, defaultUiSettings, defaultWorkspaceTitle, derivePermissionSelect, dispatchFaceMethod, effectiveHostApiKey, errResponse, estimateBucketsCostUsd, estimateUsageCostUsd, externalAgentHandlesPath, extractJsonCandidate, extractNetworkContext, faceMethodFromPath, faceToolLookup, fallbackSessionTitle, findCheckpointAtOrBefore, formatJobCompletionNotice, formatMcpInventoryText, formatQuestionAnswer, formatSessionStatusText, formatSubagentCompletionNotice, fullyQualified, getHandler, handleFaceHttpRequest, hostCreateDirectory, hostListDirectory, hostOpenPath, hostPickDirectoryRpc, hydrateCredentialsFromSecretStore, hydrateFaceHostSettings, installDefaultFaceProjections, interruptExternalContinuable, isAgentTeamRole, isAgentTeamSpawnRole, isChildSessionActive, isFaceHttpPath, isFaceRespondPath, isFaceWsPath, isFeedbackCategory, isLoopbackAddress, isPluginSoftDisabledAt, isSessionExportPath, isSettledJobStatus, jobViews, lastAssistantBodyText, listCredentialSlots, listDeclaredPiAiProviders, listFacePluginInventory, listProductTree, listSettingsProviderCredentialRefs, listSpawnRoleIds, liveRouteAllowsImageInput, lookupManagedPluginSourceAt, managedWorktreesPath, mapFaceRpcError, migrateAndRepriceLedger, narratePlanCommand, normalizeApiKey, normalizeFeedbackEntry, normalizeOpenPath, normalizeSessionTitle, okResponse, openExternalAgentLiveSession, openNativePath, parseAgentTeamSpawnRole, parseClientResponse, parseExternalAgentKind, parseExternalAgentProduct, parseFaceMcpServers, parseFaceRpcRequest, peekSettingsYamlSection, peekSpillEntry, permissionSelectFromEvents, piAiProviderProfile, pickNativeDirectory, pinInitialPermission, planWantedFromArgs, presentToolView, previewPlanSet, promptExternalContinuable, proposeSkillQuestions, providerApiKeyEnv, providerHasUsableCredential, providerModelKey, providerRouteServed, publishRemoteEvent, questionRequestedFrame, questionResolvedFrame, rankCostModelRows, readDisabledPluginIdsAt, readManagedPackageIndexAt, readManagedPluginPackagesAt, readManagedWorktreeOwner, readProviderApiKey, readProviderRoute, reconcileClientBootAt, reconcileManagedClientBoot, reconcileManagedProcessPlugins, recordSessionFeedback, renderGoalRoundPrompt, renderGoalStartPrompt, resetLastGoodConfigCaches, resetLastGoodHostMcpCache, resolveAgentPresetProfile, resolveExternalAgentLaunch, resolveHarnessHome, resolveLlmForSelection, resolveLlmForSession, resolveManagedPluginDir, resolveManagedPluginUpdateSpec, resolveManagedPluginsDir, resolveProductDir, resolveProviderBinding, resolveRollbackTarget, resolveSessionCwd, resolveSubagentQuota, resolveToolPreset, revealNativePath, routeFromRequestHeader, runExternalAgentTurn, serverRequestFrame, sessionExportFilename, sessionFeedbackRecord, setSoftDisabledAt, setWorkspaceCheckpointGitRunner, settingsDescribeFace, settingsGet, settingsMutateFace, settingsOpenDocument, settingsReplaceFace, settingsSet, settingsUpdateFace, settingsYamlPath, settleFaceRespond, snapshotSessionWorkspace, startExternalContinuable, startWsHeartbeat, steerPlanMessage, subagentDepth, supportsExternalContinuable, toFaceWireSessionEvent, toMuxSessionEvent, toQueueItems, toWireHistoryEntry, tryHandleFaceHttp, validateOutputAgainstSchema, validateRalphReport, validateSettingsNamespace, windowsExplorerPath, wireNumericId, workspaceArchiveSessionFace, workspaceCheckpointStoreFor, workspaceCheckpointStoreForSession, workspaceCreateFace, workspaceDeleteFace, workspaceDescribe, workspaceInsertBeforeFace, workspaceInsertSessionBeforeFace, workspaceListFace, workspaceListProduct, workspacePinSessionFace, workspacePreviewInject, workspaceRenameFace, workspaceUnarchiveSessionFace, workspaceUnpinSessionFace, writeDisabledPluginIdsAt, writeFeedbackConversationSlice };
+//# sourceMappingURL=index.d.mts.map