@threadbase-sh/streamer 1.63.0 → 1.64.0

package/dist/index.d.ts

@@ -1,2571 +1,18 @@
-import { Client } from '@temporalio/client';
-import { UserInputSignal, Stage } from '@threadbase-sh/agent-types';
-import * as hono_types from 'hono/types';
-import { Hono } from 'hono';
-import { Logger as Logger$1 } from 'pino';
-import { HttpBindings } from '@hono/node-server';
-import { ServerResponse, IncomingMessage } from 'http';
-import { WebSocket } from 'ws';
-import { ConversationMessage, FileStatEntry, ConversationMeta } from '@threadbase-sh/scanner';
-import Database from 'better-sqlite3';
-import { Stats } from 'fs';
-import { z } from 'zod';
-import { Pool } from 'pg';
-
-interface AgentClient {
-    startSession(sessionId: string): Promise<string>;
-    sendUserInput(sessionId: string, payload: UserInputSignal): Promise<void>;
-    endSession(sessionId: string): Promise<void>;
-    getSessionStage(sessionId: string): Promise<string>;
-}
-interface AgentClientOpts {
-    temporalClient: Client;
-    taskQueue: string;
-}
-declare function createAgentClient({ temporalClient, taskQueue }: AgentClientOpts): AgentClient;
-
-interface AgentConfig {
-    enabled: boolean;
-    temporal: {
-        address: string;
-        namespace: string;
-        taskQueue: string;
-    };
-    webhook: {
-        hmacSecret: string;
-        timestampSkewSeconds: number;
-    };
-    dedupe: {
-        perSessionCapacity: number;
-    };
-    payload: {
-        limitBytes: number;
-        trajectoryLogBytes: number;
-        trajectoryLogTurns: number;
-    };
-    sessionBusyRetryMs: number;
-    conversationsDir: string;
-}
-declare function readAgentConfig(env?: NodeJS.ProcessEnv): AgentConfig;
-
-interface AppendArgs {
-    sessionId: string;
-    turnId: string;
-    content: string;
-    reviewerOverruled?: boolean;
-}
-interface ConversationWriter {
-    appendAssistantTurn(args: AppendArgs): Promise<void>;
-}
-declare function createConversationWriter(opts: {
-    baseDir: string;
-}): ConversationWriter;
-
-interface ProgressDedupeLRU {
-    hasSeen(eventId: string): boolean;
-    readonly size: number;
-}
-declare function createProgressDedupeLRU(capacity: number): ProgressDedupeLRU;
-
-type LogDest = "console" | "pino" | "both";
-type LogLevel = "debug" | "info" | "warn" | "error";
-interface Logger {
-    debug(msg: string, fields?: Record<string, unknown>, dest?: LogDest): void;
-    info(msg: string, fields?: Record<string, unknown>, dest?: LogDest): void;
-    warn(msg: string, fields?: Record<string, unknown>, dest?: LogDest): void;
-    error(msg: string, fields?: Record<string, unknown>, dest?: LogDest): void;
-    log(level: LogLevel, msg: string, fields?: Record<string, unknown>, dest?: LogDest): void;
-    pino: Logger$1;
-}
-
-/** Claude Code `--permission-mode` values, as accepted by CLI v2.1.x. */
-declare const PERMISSION_MODES: readonly ["acceptEdits", "auto", "bypassPermissions", "manual", "dontAsk", "plan"];
-type PermissionMode = (typeof PERMISSION_MODES)[number];
-/** Claude Code `--effort` levels, as accepted by CLI v2.1.x. */
-declare const EFFORT_LEVELS: readonly ["low", "medium", "high", "xhigh", "max"];
-type EffortLevel = (typeof EFFORT_LEVELS)[number];
-type FlagValueType = "boolean" | "string" | "enum" | "list";
-/** How risky enabling a flag is. Drives the client's confirmation UX. */
-type FlagRisk = "low" | "elevated" | "dangerous";
-interface FlagDefinition {
-    /** Stable config/wire key. Never the CLI spelling. */
-    id: string;
-    /** The literal CLI token, e.g. "--add-dir". */
-    flag: string;
-    valueType: FlagValueType;
-    /** Allowed values when valueType === "enum". */
-    enumValues?: readonly string[];
-    /**
-     * Baseline risk. `permissionMode` is the exception: it is only dangerous for
-     * the values in DANGEROUS_PERMISSION_MODES, so clients must call
-     * `flagValueRisk()` rather than reading this field directly.
-     */
-    risk: FlagRisk;
-}
-type ClaudeFlagValue = string | string[] | boolean;
-type ClaudeFlagValues = Record<string, ClaudeFlagValue>;
-
-/** Spec for one flag in the keyed registry. The id is the object key, not a field. */
-interface FeatureFlagSpec {
-    /** Shipped to clients alongside the values so a UI can render it. */
-    description: string;
-    default: boolean;
-    /** Full env var name. */
-    env: string;
-}
-/** Wire shape: the keyed spec plus its id, for GET /api/config/feature-flags. */
-interface FeatureFlagDefinition extends FeatureFlagSpec {
-    /** Stable config/wire key. Used in server.yaml, on the CLI, and over HTTP. */
-    id: FeatureFlagId;
-}
-/**
- * Values arriving from a config source. PARTIAL on purpose: server.yaml, the
- * CLI and ServerConfig each speak about the flags they mention and stay silent
- * on the rest, which is what lets the precedence chain fall through.
- */
-type FeatureFlagValues = Partial<Record<FeatureFlagId, boolean>>;
-/** Every flag, resolved. Total — see resolveFeatureFlags(). */
-type ResolvedFeatureFlags = Record<FeatureFlagId, boolean>;
-/**
- * Which rung of the precedence chain decided a flag.
- *
- * Kept because the resolved boolean alone cannot answer "why is this on?", and
- * that is the first question asked of a flag that is on when nobody expected it.
- * `override` is the legacy ServerConfig field (see resolveFeatureFlags).
- */
-type FeatureFlagSource = "override" | "env" | "cli" | "yaml" | "default";
-/**
- * The registry, keyed by flag name.
- *
- * Prefer `FEATURE_FLAGS.ptyHost` over a string lookup. A typo is a compile
- * error; `findFeatureFlag("…")` is only for untrusted yaml/CLI tokens.
- *
- * `as const` + `keyof` is what makes `flags.ptyHsot` a compile error instead of
- * `undefined`. A TS enum would add a runtime object without a stronger type.
- */
-declare const FEATURE_FLAGS: {
-    readonly codexSystemPrompt: {
-        readonly description: string;
-        readonly default: false;
-        readonly env: "THREADBASE_FEATURE_CODEX_SYSTEM_PROMPT";
-    };
-    readonly sessionRehydration: {
-        readonly description: string;
-        readonly default: true;
-        readonly env: "THREADBASE_FEATURE_SESSION_REHYDRATION";
-    };
-    readonly liveActivityPush: {
-        readonly description: string;
-        readonly default: false;
-        readonly env: "THREADBASE_FEATURE_LIVE_ACTIVITY_PUSH";
-    };
-    readonly e2ee: {
-        readonly description: string;
-        readonly default: false;
-        readonly env: "THREADBASE_FEATURE_E2EE";
-    };
-    readonly ptyHost: {
-        readonly description: string;
-        readonly default: false;
-        readonly env: "THREADBASE_FEATURE_PTY_HOST";
-    };
-};
-/**
- * The registry's ids as a union, derived rather than declared.
- *
- * This is what makes `flags.ptyHsot` a compile error instead of `undefined`.
- * Under the old `Record<string, boolean>` an index signature accepted any key,
- * so a typo in a consumer read as falsy and silently disabled the feature it
- * was meant to gate — the exact failure the "total map" contract exists to
- * prevent, reachable through the one door that contract left open.
- */
-type FeatureFlagId = keyof typeof FEATURE_FLAGS;
-
-declare const CLAUDE_CODE_PROVIDER: "claude-code";
-declare const CODEX_CLI_PROVIDER: "codex-cli";
-type ProviderName = typeof CLAUDE_CODE_PROVIDER | typeof CODEX_CLI_PROVIDER;
-declare function isProviderName(value: unknown): value is ProviderName;
-declare function isProviderResumable(_provider: string | null | undefined, availabilityResumable: boolean): boolean;
-
-type SessionStatus = "running" | "waiting_input" | "idle";
-/**
- * Phase axis *inside* `status === "running"` — what the agent is doing during a
- * turn. Deliberately a separate field rather than new SessionStatus members:
- * VALID_STATUSES rejects unknown values and the store drops sessions outside
- * the requested set, so a new status string would make those sessions vanish
- * from already-shipped apps. Additive fields are safe; additive values in a
- * union a shipped client filters on are not.
- *
- * The full set is defined here even though Codex only ever emits `working`
- * (its status bar is binary — Ready/Working, and claiming otherwise would be
- * invention). Defining it up front keeps a two-valued provider from fixing the
- * field's shape before Claude's richer footer lands. Consumers must ignore an
- * unrecognised value rather than coerce it.
- *
- * This union lives in exactly one place. Two independently-maintained copies of
- * a TUI-derived grammar have already drifted once (tb-mobile PR #647).
- */
-type AgentPhase = "thinking" | "streaming" | "hooks" | "acting" | "working";
-/**
- * Process-lifetime axis for a managed session (C1 durable session runtime).
- * Orthogonal to SessionStatus — see SessionResponse.lifecycle for why the two
- * are separate, and docs/architecture/2026-07-24-durable-session-runtime.md.
- */
-type SessionLifecycle = "attached" | "starting" | "detached" | "orphaned" | "resumable" | "completed" | "failed";
-/**
- * How a SessionStatus was derived (C3).
- * See docs/architecture/2026-07-24-session-state-confidence.md.
- *
- * The runners already compute this at every transition — it was written to a log
- * line and discarded, so a status reached by a timer expiring was indistinguishable
- * on the wire from one reached by observing a prompt marker.
- */
-type StatusSource$1 = "spawn" | "prompt-marker" | "screen-marker" | "user-input" | "process-exit" | "timeout-fallback" | "quiet-fallback" | "shutdown";
-/**
- * How much to trust the status.
- *
- * `observed` — something in the stream or the process told us.
- * `inferred` — a timer expired and we picked the most likely state.
- *
- * Deliberately two buckets rather than a numeric score: a percentage would imply
- * a calibration we have no data to support. The point is that a guess must never
- * be presented as an observation.
- */
-type StatusConfidence = "observed" | "inferred";
-/** Confidence implied by each source. Inference is exactly the timer-driven paths. */
-declare function confidenceForSource(source: StatusSource$1): StatusConfidence;
-interface ManagedSession {
-    id: string;
-    provider?: ProviderName;
-    projectId?: string;
-    projectPath: string;
-    projectName: string;
-    branch: string;
-    status: SessionStatus;
-    startedAt: Date;
-    completedAt: Date | null;
-    promptCount: number;
-    lastOutput: string;
-    failureReason?: string;
-    /**
-     * Machine-readable companion to `failureReason`, set only when the runner
-     * recognised the failure. Currently just `codex_active_writer` (Codex's
-     * single-writer lock), which the resume path maps to a structured 409 rather
-     * than reporting a spawn as successful. Absent for every other failure.
-     */
-    failureCode?: string;
-    sessionName?: string;
-    model?: string;
-    account?: string;
-    messageCount?: number;
-    preview?: string;
-    firstMessageText?: string;
-    firstMessageAt?: Date;
-    lastMessageText?: string;
-    lastMessageAt?: Date;
-    lastActivityAt?: Date;
-    /**
-     * How `status` was derived, and when (C3). Confidence is derived from the
-     * source via confidenceForSource — storing both would let them disagree.
-     */
-    statusSource?: StatusSource$1;
-    statusUpdatedAt?: Date;
-    /**
-     * Agent phase within a running turn, scraped from the rendered screen.
-     * Optional internally (every existing construction site predates it), but
-     * managedToResponse emits it unconditionally as `?? null` — on the wire
-     * absence must never be a third state, because the client merges session
-     * frames and a merge cannot express a removed key.
-     *
-     * Cleared in markReady() for the running -> waiting_input turn end, which is
-     * the only exit a runner observes on screen. Every other way out of `running`
-     * — handleExit, putOnHold, failStartup — is enforced by SessionStore
-     * .updateManaged() instead: a phase exists only while the status is
-     * `running`, so leaving it clears the field.
-     */
-    subStatus?: AgentPhase | null;
-    filePath?: string;
-    resumedFromConversationId?: string;
-    /**
-     * This session was seeded from the durable registry at boot, not spawned by
-     * this run — there is no PTY behind it and never was one in this process.
-     *
-     * INTERNAL. It never reaches the wire: `managedToResponse` translates it into
-     * the already-defined `ownership: "historical"` + `lifecycle: "resumable"`
-     * pair, so no client needs to learn a new field to render a recovered session.
-     * Cleared implicitly when a resume overwrites the stub with a real session.
-     */
-    rehydrated?: boolean;
-    /**
-     * This live session was re-adopted from the pty-host during boot rather than
-     * spawned by this streamer process. Internal lifecycle provenance only.
-     */
-    reconciled?: boolean;
-    /**
-     * What this session was doing when the streamer stopped it, for a stub whose
-     * `status` had to flatten to `idle`. Only ever set from a registry row whose
-     * `status_source` is `shutdown` — the one source that means "we ended this",
-     * as opposed to the agent finishing or a crash freezing the row mid-turn.
-     */
-    interruptedStatus?: "running" | "waiting_input";
-    /**
-     * Set once a live session's underlying persisted conversation file is
-     * discovered after the fact (currently: fresh Codex sessions, whose
-     * rollout id isn't known until the CLI creates its own JSONL). Distinct
-     * from `resumedFromConversationId` (resume flow) and `conversationId` on
-     * `SessionResponse` (stable mobile deep-link alias, always === id for the
-     * lifetime of a live PTY) — must never be written into either of those.
-     */
-    boundConversationId?: string;
-    /**
-     * Source conversation this session was FORKED from (`codex fork`). Distinct
-     * from `resumedFromConversationId`: a resume continues one conversation, a
-     * fork starts a second one whose history diverges from the source at the fork
-     * point — and the source keeps its own owner, which is the entire point.
-     */
-    forkedFromConversationId?: string;
-    /**
-     * Multi-agent mode only. Per-session in-memory LRU of progress event ids
-     * seen by the webhook receiver. Used to drop Temporal-replay duplicates
-     * before they reach the WebSocket. See spec §7.1.
-     */
-    progressDedupeIds?: ProgressDedupeLRU;
-    /** Multi-agent: current stage of the active turn (advisory; advisory wire field). */
-    stage?: Stage | string;
-    /** Multi-agent: ms since the session last emitted a stage transition. */
-    stalledSinceMs?: number;
-    /** Multi-agent: 1 or 2 when stage === "rework". */
-    reworkAttempt?: number;
-    /**
-     * Multi-agent: id of the in-flight turn, or null when idle. Set when
-     * `POST /api/sessions/:id/input` accepts a request; cleared by the webhook
-     * receiver on stage=done or terminal_failure. Undefined in PTY mode.
-     */
-    currentTurnId?: string | null;
-    /**
-     * Multi-agent resume: stable identity of the underlying conversation
-     * (the JSONL filename), distinct from `id` which is per-orchestrator-instance.
-     * Undefined in PTY mode (PTY uses `resumedFromConversationId` instead).
-     */
-    conversationId?: string;
-}
-interface DiscoveredProcess {
-    pid: number;
-    projectPath: string;
-    projectName: string;
-    branch: string;
-    conversationId: string | null;
-    startedAt: Date;
-}
-interface AskOption {
-    label: string;
-    description: string;
-    preview?: string;
-}
-interface AskQuestion {
-    question: string;
-    header: string;
-    multiSelect: boolean;
-    options: AskOption[];
-}
-interface PermissionOption {
-    index: number;
-    label: string;
-    answerKeys?: string;
-}
-interface UserMessage {
-    text: string;
-    ts: number;
-}
-type WSMessage = {
-    type: "terminal_output";
-    sessionId: string;
-    data: string;
-    seq?: number;
-} | {
-    type: "session_update";
-    session?: SessionResponse;
-    sessionId?: string;
-    turnId?: string;
-    stage?: Stage | string;
-    stalledSinceMs?: number;
-    reworkAttempt?: number;
-}
-/**
- * Agent phase changed within a running turn. Scoped to that session's
- * subscribers, like terminal_output and user_message.
- *
- * A minimal frame rather than a SessionResponse copy, deliberately:
- * managedToResponse recomputes `elapsedMs` from `new Date()` on every call
- * for a live session, so a session copy would differ on every tick whether
- * or not the phase changed — and a client that merges frames would get a
- * fresh object identity several times a second, re-rendering every consumer
- * for the whole turn.
- *
- * `phase` is always present and is `null` when there is no phase. Absence
- * must never carry meaning: clients merge session state, and a merge cannot
- * express a removed key, so an omitted field would keep its previous value
- * and the indicator would latch on a finished turn.
- */
- | {
-    type: "session_phase";
-    sessionId: string;
-    phase: AgentPhase | null;
-    updatedAt: string;
-} | {
-    type: "session_list";
-    sessions: readonly SessionResponse[];
-} | {
-    type: "conversation_event";
-    sessionId: string;
-    line: string;
-} | {
-    type: "conversation_events";
-    sessionId: string;
-    lines: string[];
-    seqs?: (number | null)[];
-} | {
-    type: "conversation_updated";
-    conversationId: string;
-    messageCount: number;
-    lastActivity: string;
-    ownership: "external" | "managed";
-} | {
-    type: "question";
-    sessionId: string;
-    toolUseId: string;
-    questions: AskQuestion[];
-} | {
-    type: "question_cancelled";
-    sessionId: string;
-    toolUseId: string;
-} | {
-    type: "permission";
-    sessionId: string;
-    prompt?: string;
-    detail?: string;
-    options: PermissionOption[];
-    cursor?: number;
-} | {
-    type: "permission_cancelled";
-    sessionId: string;
-} | {
-    type: "ping";
-    ts: number;
-} | {
-    type: "user_message";
-    sessionId: string;
-    text: string;
-    ts: number;
-} | {
-    type: "terminal_replay";
-    sessionId: string;
-    lines: string[];
-    userMessages?: UserMessage[];
-    seq?: number;
-} | {
-    type: "session_ready";
-    session: SessionResponse;
-} | {
-    type: "agent_output";
-    sessionId: string;
-    turnId: string;
-    role: "worker" | "reviewer" | "signoff";
-    content: string;
-    partial?: boolean;
-    reviewerOverruled?: boolean;
-    stage?: Stage | string;
-    reworkAttempt?: number;
-} | {
-    type: "turn_failure";
-    sessionId: string;
-    turnId: string;
-    reason: string;
-} | {
-    type: "cache_ready";
-} | {
-    type: "scan_progress";
-    scanned: number;
-    total: number;
-} | {
-    type: "cache_alert";
-    fingerprint: string;
-    severity: "high" | "low";
-    missingCount: number;
-    totalRows: number;
-    detectedAt: string;
-    sample: {
-        id: string;
-        title?: string;
-    }[];
-} | {
-    type: "cache_alert_resolved";
-    fingerprint: string;
-    action: CacheAlertResolveAction;
-};
-/** The four cache-integrity resolution actions (POST /api/cache/alert/resolve). */
-type CacheAlertResolveAction = "prune_all" | "prune_selected" | "ignore" | "reset_rescan";
-type ServerWarmupState = "startup" | "cache_reset" | "conversation_refresh";
-interface ServerWarmingUpResponse {
-    error: "Server is warming up";
-    code: "SERVER_WARMING_UP";
-    warmupState: ServerWarmupState;
-}
-interface SessionResponse {
-    id: string;
-    conversationId: string;
-    provider?: ProviderName;
-    projectId?: string;
-    status: SessionStatus;
-    projectPath: string;
-    projectName: string;
-    branch: string;
-    lastOutput: string;
-    elapsedMs: number;
-    promptCount: number;
-    startedAt: string;
-    completedAt: string | null;
-    ptyAttached: boolean;
-    /**
-     * Process-lifetime axis, orthogonal to `status` (C1).
-     *
-     * `status` answers "what is the agent doing" (running / waiting_input /
-     * idle); `lifecycle` answers "does this process still exist and do we own
-     * it". They were conflated before: `idle` meant finished, killed-to-save-
-     * resources, and externally-discovered all at once, so a client could not
-     * tell a completed session from one we terminated.
-     *
-     * Additive and optional — `ptyAttached` keeps its meaning (=== "attached"),
-     * so a client that ignores this behaves exactly as it did before. `"starting"`
-     * is additive in the same way: a session we hold no PTY for and have observed
-     * no exit for reports it instead of the `"completed"` it used to, so a client
-     * can tell "not attached yet" from "ended" (tb-mobile #508).
-     */
-    /**
-     * How `status` was derived and how far to trust it (C3). Additive: `status`
-     * keeps its exact meaning, so a client ignoring these behaves as before.
-     * An `inferred` confidence means a timer expired and we assumed — not that
-     * anything in the stream confirmed the state.
-     */
-    statusSource?: StatusSource$1;
-    statusConfidence?: StatusConfidence;
-    statusUpdatedAt?: string;
-    lifecycle?: SessionLifecycle;
-    /** How `lifecycle` was determined, so stale values are visible not implied. */
-    lifecycleSource?: "spawn" | "exit" | "probe" | "reconcile";
-    lifecycleUpdatedAt?: string;
-    /**
-     * ADDITIVE (plan Phase 5). What a recovered session was doing when the
-     * streamer stopped it, so a client can say "interrupted mid-response" instead
-     * of the `idle` its `status` is forced to report — a stub holds no PTY, and a
-     * novel SessionStatus value would be dropped by `?status=` filtering on
-     * already-shipped clients. Present only on rows whose `status_source` was
-     * `shutdown`; older clients ignore it.
-     */
-    interruptedStatus?: "running" | "waiting_input";
-    failureReason?: string;
-    pid?: number;
-    sessionName?: string;
-    model?: string;
-    /**
-     * Reasoning-effort tier scraped from the live PTY status line (e.g. "high").
-     * Live sessions only — absent for historical/resumable conversations.
-     */
-    effort?: string;
-    /**
-     * Active permission mode from the live PTY status line (e.g. "accept edits on").
-     * Live sessions only.
-     */
-    permissionMode?: string;
-    /**
-     * Agent phase within a running turn, scraped from the rendered PTY screen.
-     *
-     * NOT optional, and always serialised — `null` when there is no phase. A
-     * client that merges session frames (`{...prev, ...next}`) cannot express a
-     * removed key, so an omitted field would keep its previous value and the
-     * indicator would latch on a finished turn. That is the bug tb-mobile PR #647
-     * shipped; absence must never carry meaning here.
-     *
-     * Consequently this must NOT be moved into the `...(x != null && { x })`
-     * guard block in managedToResponse: `!= null` catches null and undefined
-     * alike and would convert an explicit clear back into absence.
-     */
-    subStatus: AgentPhase | null;
-    account?: string;
-    messageCount?: number;
-    preview?: string;
-    firstMessageText?: string;
-    firstMessageAt?: string;
-    lastMessageText?: string;
-    lastMessageAt?: string;
-    lastActivityAt?: string;
-    filePath?: string;
-    resumedFromConversationId?: string;
-    /** See `ManagedSession.forkedFromConversationId`. Additive; older clients ignore it. */
-    forkedFromConversationId?: string;
-    /** See `ManagedSession.boundConversationId` — never repurposes `conversationId`. */
-    boundConversationId?: string;
-    /**
-     * Who owns the underlying process. Additive — older clients ignore it, and it
-     * deliberately does NOT introduce a new `status` value: `VALID_STATUSES`
-     * rejects unknown values in `?status=` and the store drops sessions outside
-     * the requested set, so a new status string would make these sessions vanish
-     * from already-shipped apps.
-     *   managed    — this streamer spawned and holds the PTY
-     *   external   — a process we discovered but do not own (read-only)
-     *   historical — a cached conversation, no process known
-     */
-    ownership?: SessionOwnership;
-    /**
-     * Whether the process is believed to be running. Only ever "alive" when
-     * discovery actually saw it; never guessed from file activity.
-     */
-    processLiveness?: ProcessLiveness;
-    /**
-     * INFERRED from JSONL writes, never authoritative: "active_writing" means the
-     * transcript grew recently, which cannot distinguish a generating agent from
-     * one blocked on a permission gate (gates are screen-only). Absent for
-     * sessions we own — their `status` is the authoritative signal.
-     */
-    activity?: SessionActivity;
-}
-type SessionOwnership = "managed" | "external" | "historical";
-type ProcessLiveness = "alive" | "gone" | "unknown";
-interface SessionActivity {
-    state: "active_writing" | "quiet";
-    lastEventAt: string;
-    source: "jsonl";
-}
-interface ConversationListResponse {
-    conversations: unknown[];
-    hasMore: boolean;
-    offset: number;
-    total: number;
-}
-type SessionSortKey = "startedAt" | "lastActivityAt" | "projectName" | "status";
-type SortOrder = "asc" | "desc";
-interface SessionListPage {
-    /** Response copies, like `SessionStore.list()` — see the note there. */
-    sessions: readonly Readonly<SessionResponse>[];
-    nextCursor: string | null;
-    total: number;
-}
-interface SessionListQuery {
-    limit: number;
-    cursor?: string;
-    sortBy: SessionSortKey;
-    order: SortOrder;
-    status?: SessionStatus[];
-}
-interface SessionCursor {
-    k: string | number;
-    id: string;
-}
-interface ServerConfig {
-    port: number;
-    host?: string;
-    apiKey?: string;
-    /** 'cli' when --api-key was passed; rotation persists in-memory only and reverts on restart */
-    apiKeySource?: "config" | "cli";
-    localNoAuth?: boolean;
-    verbose?: boolean;
-    logMenubarRequests?: boolean;
-    browseRoot?: string;
-    publicUrl?: string;
-    browserCors?: string;
-    disableDb?: boolean;
-    scanProfiles?: Array<{
-        id: string;
-        label: string;
-        configDir: string;
-        enabled: boolean;
-        emoji: string;
-    }>;
-    codexRoots?: string[];
-    scannerPersistent?: boolean;
-    skipStartupWarmup?: boolean;
-    ptyGracePeriodMs?: number;
-    /**
-     * Re-start interrupted sessions at boot instead of listing them for the user
-     * to tap (plan Phase 7). A boolean here rather than the tri-state the loader
-     * returns: by the time a ServerConfig is built the "never asked" case has
-     * already resolved to false. Precedence: explicit here → `auto_resume_on_boot`
-     * in server.yaml → false. Never enabled implicitly — it is the one setting
-     * that starts an agent nobody asked for in that moment.
-     */
-    autoResumeOnBoot?: boolean;
-    cacheDir?: string;
-    runtimeDbPath?: string;
-    tailSize?: number;
-    directoryScanDebounceMs?: number;
-    defaultSystemPrompt?: string;
-    codexSystemPromptEnabled?: boolean;
-    featureFlags?: FeatureFlagValues;
-    defaultPermissionMode?: PermissionMode;
-    defaultModel?: string;
-    defaultEffort?: EffortLevel;
-    claudeFlags?: ClaudeFlagValues;
-    claudeExtraArgs?: string;
-}
-interface PTYManagerOptions {
-    onOutput?: (sessionId: string, data: string) => void;
-    onStatusChange?: (session: ManagedSession) => void;
-    onReady?: (session: ManagedSession) => void;
-    onPermissionChange?: (sessionId: string, gate: {
-        prompt?: string;
-        detail?: string;
-        options: PermissionOption[];
-        cursor?: number;
-    } | null) => void;
-    /**
-     * Fired when the agent's phase within a running turn changes, including to
-     * `null` at turn end. Additive; absent in tests that omit it.
-     *
-     * Deliberately NOT routed through onStatusChange, even though that callback
-     * already exists and is already relayed across the pty-host boundary. Its
-     * handler writes a DB row per invocation with no same-status guard, refreshes
-     * the scanner index, broadcasts globally, and pokes the APNs and push
-     * notifiers — machinery built for a handful of transitions per session, not
-     * for a signal that can fire every SCRAPE_THROTTLE_MS.
-     *
-     * The server must broadcast this to that session's subscribers only
-     * (wsHub.broadcastToClients), as a minimal frame rather than a SessionResponse
-     * copy: managedToResponse recomputes elapsedMs on every call, so a session
-     * copy would differ every tick and re-render every client consumer of that
-     * session for the whole turn.
-     */
-    onPhaseChange?: (sessionId: string, phase: AgentPhase | null) => void;
-    onLiveQuestion?: (sessionId: string, questions: AskQuestion[]) => void;
-    onLiveQuestionGone?: (sessionId: string) => void;
-    onUserMessage?: (sessionId: string, text: string, ts: number) => void;
-    logger?: Logger;
-}
-interface StartSessionOptions {
-    projectPath: string;
-    projectName?: string;
-    branch?: string;
-    /**
-     * Provider-side id to resume from, when it differs from `sessionId`. Codex
-     * keys a fresh session by a local placeholder UUID and only learns its real
-     * rollout id once it writes the file, so resuming needs the rollout id in
-     * argv while the session keeps the placeholder the client navigated to.
-     * Absent means "resume by the session id", which is what every Claude session
-     * does — PTYManager ignores this field entirely.
-     */
-    resumeId?: string;
-    permissionMode?: PermissionMode;
-    model?: string;
-    effort?: EffortLevel;
-    claudeFlags?: ClaudeFlagValues;
-    claudeExtraArgs?: string;
-}
-interface StartForkSessionOptions {
-    /**
-     * Provider-side id of the conversation to fork FROM (for Codex, the rollout
-     * id — never a local placeholder). The forked session gets its own id; the
-     * two identities are deliberately kept distinct.
-     */
-    forkFromId: string;
-    projectPath: string;
-    projectName?: string;
-    branch?: string;
-}
-interface StartFreshSessionOptions {
-    projectPath: string;
-    projectName?: string;
-    systemPrompt?: string;
-    permissionMode?: PermissionMode;
-    model?: string;
-    effort?: EffortLevel;
-    claudeFlags?: ClaudeFlagValues;
-    claudeExtraArgs?: string;
-}
-interface SessionRunner {
-    start(sessionId: string, options: StartSessionOptions): Promise<ManagedSession>;
-    startFresh(options: StartFreshSessionOptions): Promise<ManagedSession>;
-    sendInput(sessionId: string, input: string): number;
-    sendKeys(sessionId: string, keys: string): void;
-    cancel(sessionId: string): void;
-    killPid(pid: number): void;
-    putOnHold(sessionId: string): void;
-    getOutput(sessionId: string): string;
-    getOutputLines(sessionId: string, maxLines: number): Promise<string[]>;
-    getInputHistory(sessionId: string): UserMessage[];
-    getPid(sessionId: string): number | null;
-    getSession(sessionId: string): ManagedSession | null;
-    hasSession(sessionId: string): boolean;
-    listSessions(): ManagedSession[];
-    dispose(): void;
-}
-
-/**
- * Scoped device capabilities (C5).
- * See docs/architecture/2026-07-24-device-identity-and-capabilities.md.
- *
- * Authorization was all-or-nothing: authMiddleware asked one question — is this
- * token the API key — and answered 401 or full access. A device paired merely to
- * glance at session status held exactly the authority of the one driving the
- * agent, because there was only ever one credential and no principal to scope.
- */
-declare const CAPABILITIES: readonly ["history:read", "session:control", "fs:browse", "fs:upload", "notifications", "admin"];
-type Capability = (typeof CAPABILITIES)[number];
-type CapabilityPreset = "full" | "read-only";
-/**
- * The principal behind a request.
- *
- * `legacy` is the shared API key: it predates device identity, so it carries the
- * full preset and no device id. Keeping it working is what lets this ship
- * without breaking every already-paired device.
- */
-interface Principal {
-    kind: "device" | "legacy";
-    deviceId?: string;
-    capabilities: Capability[];
-}
-
-interface LineSpan {
-    /** Absolute byte offset of the line's first byte in the file. */
-    byteOffset: number;
-    /** Byte length of the line content, excluding the trailing "\n". */
-    byteLength: number;
-    /** The decoded line text (no trailing "\n"). */
-    text: string;
-}
-
-interface ConversationCacheOptions {
-    filterAgentConversations?: boolean;
-    agentEntrypoints?: ReadonlySet<string>;
-    onAgentFileDetected?: (filePath: string) => void;
-}
-interface ConversationListItem {
-    id: string;
-    filePath: string;
-    projectId: string | null;
-    projectPath: string | null;
-    projectName: string | null;
-    title: string | null;
-    model: string | null;
-    account: string | null;
-    branch: string | null;
-    messageCount: number;
-    lastActivity: string;
-    firstMessage: string | null;
-    lastMessage: string | null;
-    preview: string | null;
-    source: string | null;
-    provider: "claude-code" | "codex-cli";
-}
-interface CachedTailMessage {
-    role: string;
-    timestamp: string;
-    text: string;
-    content?: unknown[];
-}
-interface CachedTail {
-    conversationId: string;
-    messages: CachedTailMessage[];
-    tailSize: number;
-}
-/** A row of `conversation_file_state` — per-file offset-index resume state. */
-interface FileStateRow {
-    path: string;
-    identity: string;
-    size: number;
-    mtime_ms: number;
-    byte_offset: number;
-    last_message_index: number;
-}
-/** A row of `conversation_message_index` — one indexed message's byte span. */
-interface MessageIndexRow {
-    conversation_id: string;
-    message_index: number;
-    byte_offset: number;
-    byte_length: number;
-    uuid: string | null;
-    role: string | null;
-    ts: number | null;
-}
-interface ScannerMeta {
-    id: string;
-    sessionId?: string;
-    filePath: string;
-    projectPath?: string;
-    projectName?: string;
-    title?: string;
-    sessionName?: string;
-    model?: string;
-    account?: string;
-    gitBranch?: string;
-    messageCount?: number;
-    timestamp?: string;
-    firstMessage?: unknown;
-    lastMessage?: unknown;
-    preview?: string;
-    provider?: "claude-code" | "codex-cli";
-}
-declare class ConversationCache {
-    private db;
-    private tailSize;
-    private fileIndex;
-    private fileIndexLoaded;
-    private indexParseState;
-    private backfillInFlight;
-    private tailSeq;
-    private nameSeq;
-    private stmts;
-    private migrationsDir?;
-    private filterAgentConversations;
-    private agentEntrypoints;
-    private onAgentFileDetected?;
-    private constructor();
-    /**
-     * Expose the underlying handle so projects/cache_metadata repositories can
-     * share the same connection. Internal API; not part of the public surface.
-     */
-    getDatabase(): Database.Database;
-    getFileState(path: string): FileStateRow | null;
-    upsertFileState(row: FileStateRow): void;
-    /** Drop a file's index rows + file_state (truncation / identity change). */
-    deleteFileIndex(path: string, conversationId: string): void;
-    /** Append/replace index rows in one transaction. */
-    appendMessageIndexRows(rows: MessageIndexRow[]): void;
-    /** Rows for message_index in [fromIndex, toIndex), ordered ascending. */
-    getMessageIndexWindow(conversationId: string, fromIndex: number, toIndex: number): MessageIndexRow[];
-    getIndexedMessageCount(conversationId: string): number;
-    /**
-     * Conversation id for a JSONL path — the filename stem (matches the pseudo-id
-     * updateFromLine derives and the uuid the detail read path resolves). The
-     * offset index keys on this so the window select and the cursor agree.
-     */
-    static conversationIdForFile(filePath: string): string;
-    private isIndexableFile;
-    /**
-     * Incremental offset-index writer: extend the index for a burst of appended
-     * lines (one watcher read) using their byte spans. Each line is classified
-     * with the scanner's parseJsonlLine (a running per-file reducer state), so the
-     * message ordering can never drift from the scanner's. Message lines get an
-     * index row at the next message_index; non-message lines (summary/sidecar)
-     * get no row but still advance byte_offset. file_state is updated to the end
-     * of the last consumed span.
-     *
-     * Requires an up-to-date `stat` (identity/size/mtime) for the file so the read
-     * path can detect truncation/replacement.
-     *
-     * `readFrom` is the absolute byte offset the watcher read started at, and
-     * `endOffset` is where it ended (readFrom + consumed, i.e. the watcher's new
-     * entry.offset). CONTIGUITY GUARD: the read must begin exactly where the index
-     * left off (`readFrom === existing.byte_offset`, or 0 with no state). If it
-     * doesn't — the watcher attached at EOF after the server was down, or an
-     * append raced an in-flight backfill — extending would assign wrong
-     * message_index values over a hole. In that case this writes nothing and
-     * returns null so the caller drops the index and backfills.
-     *
-     * On success returns the message_index assigned to each input span (null for a
-     * non-message line) so the caller can stamp WS `seq`. Empty array when spans
-     * is empty. `endOffset` is stored verbatim as byte_offset so the watcher's
-     * offset and file_state.byte_offset are the same number by construction.
-     */
-    extendMessageIndex(filePath: string, spans: LineSpan[], stat: Stats, readFrom: number, endOffset: number): (number | null)[] | null;
-    clearIndexParseState(filePath: string): void;
-    /**
-     * On-demand full backfill of the offset index for a file with no/stale
-     * file_state (cold conversation, or after a truncation/replacement). Rebuilds
-     * from byte 0: drops any existing rows, walks the whole file in chunks with a
-     * running parse state, yields to the event loop every ~1000 lines so a large
-     * file never blocks, and writes index rows + file_state.
-     *
-     * Single-flighted per path: concurrent callers await the same walk. The
-     * triggering detail request is served by the scanner fallback while this runs.
-     */
-    backfillIndex(filePath: string): Promise<void>;
-    private runBackfill;
-    /**
-     * Windowed detail read straight from the offset index — the hot path.
-     * Returns the parsed messages for message_index in [fromIndex, toIndex) plus
-     * the total indexed count, or null when the index can't serve this file (no
-     * file_state, identity/size mismatch = truncation/replacement, or cold index)
-     * so the caller falls back to the scanner and enqueues a backfill.
-     *
-     * On a match it SQL-selects the window's byte ranges and preads exactly those
-     * ranges from the JSONL (never the whole file), parsing only the sliced lines.
-     * Returns messages in the same ConversationMessage shape parseJsonlLine
-     * produces during a scan, so the payload is identical to the scanner path.
-     */
-    readMessageWindow(filePath: string, fromIndex: number, toIndex: number): {
-        messages: ConversationMessage[];
-        total: number;
-        fromIndex: number;
-    } | null;
-    private agentEntrypointsKey;
-    private classifyAgentFile;
-    isAgentFileCached(filePath: string): boolean;
-    static open(dbPath: string, tailSize?: number, migrationsDir?: string, options?: ConversationCacheOptions): ConversationCache;
-    close(): void;
-    getPopularProjects(limit: number): Array<{
-        path: string;
-        name: string;
-        sessionCount: number;
-    }>;
-    /** Every project with at least one cached conversation, most recently active
-     *  first. Paths are the raw `project_path` values, which is what
-     *  /api/conversations?project= matches on exactly — so a summary row is
-     *  always joinable against the page it describes. */
-    listProjectSummaries(opts: {
-        limit: number;
-        offset: number;
-    }): {
-        projects: Array<{
-            path: string;
-            name: string;
-            conversationCount: number;
-            lastActivity: string;
-        }>;
-        total: number;
-    };
-    private ensureFileIndex;
-    updateFromLine(filePath: string, rawLine: string): void;
-    /**
-     * Batched form of updateFromLine: applies a burst of newly-appended lines
-     * (one chokidar read) in a single transaction with one message_count bump,
-     * one meta write, and one tail read/write — instead of 2-4 synchronous
-     * writes per line. Semantics are identical to replaying each line through
-     * updateFromLine in order: the agent filter short-circuits the whole batch,
-     * project context is backfilled last-wins, message_count increases by the
-     * number of surviving message lines, and last_activity/last_message reflect
-     * the newest message line by timestamp (a monotonic guard keeps them from
-     * moving backward when an interleaved writer appends an older line — P0.3).
-     */
-    updateFromLines(filePath: string, rawLines: string[]): void;
-    upsertFromScannerMeta(metas: ScannerMeta[]): string[];
-    deleteByFilePath(filePath: string): boolean;
-    populateTailFromFile(convId: string, filePath: string): boolean;
-    listConversations(opts: {
-        project?: string;
-        provider?: string;
-        limit: number;
-        offset: number;
-    }): {
-        conversations: ConversationListItem[];
-        total: number;
-    };
-    /** Returns a map of filePath → { mtimeMs, size } for all rows that have
-     *  stat data stored. Used by the server to build the statCache passed to
-     *  ConversationScanner.scan() so unchanged files are skipped. */
-    getFileStats(): Map<string, {
-        mtimeMs: number;
-        size: number;
-    }>;
-    getScannerStatCache(): Map<string, {
-        stat: FileStatEntry;
-        meta: ConversationMeta;
-    }>;
-    /**
-     * Conversation id for a JSONL path, or null when no row exists yet. Resolves
-     * by file_path (NOT conversationIdForFile) so codex rollout files — named
-     * rollout-<ts>-<uuid>.jsonl, whose stem is not the row id — resolve correctly.
-     */
-    getIdByFilePath(filePath: string): string | null;
-    getMetaById(id: string): ConversationListItem | null;
-    setConversationProjectId(conversationId: string, projectId: string): void;
-    markAsStreamer(id: string): void;
-    getLatestConversation(): {
-        id: string;
-        lastActivity: string | null;
-    } | null;
-    hasOrphanProjectId(): boolean;
-    listConversationsForProjectBackfill(): Array<{
-        id: string;
-        projectPath: string | null;
-        projectId: string | null;
-        lastActivity: string | null;
-    }>;
-    getConversationTail(id: string): CachedTail | null;
-    hasConversation(id: string): boolean;
-    upsertSessionName(sessionId: string, name: string): void;
-    getSessionName(sessionId: string): string | null;
-    listSessionNames(): Record<string, string>;
-    invalidate(id?: string): void;
-    /**
-     * Drop the cached row for a file. Two callers with opposite intent:
-     *  - a directory-watch "change" event (the file was appended to) — pass
-     *    `skipIfTailed: true`, which NEVER deletes (upsert-or-leave). A change
-     *    event fires on every external append; deleting here flickers the
-     *    conversation out of /api/conversations — whether it's a live-tailed row
-     *    the updateFromLines/warm-up path just wrote (CRITICAL #2; both watchers
-     *    fire on the same append with no ordering guarantee) OR a refresh-created
-     *    untailed row (a ?refresh=1 upsert never populates a tail, so the old
-     *    "delete when untailed" behavior made it vanish on its next append with no
-     *    client action). The live-tail path owns the row's content and the
-     *    debounced rescan re-derives metadata, so leaving the row loses nothing.
-     *  - a genuine unlink (the file is gone) — leave `skipIfTailed` false so the
-     *    row is always removed, otherwise a deleted session ghosts in the cache.
-     */
-    invalidateByFilePath(filePath: string, opts?: {
-        skipIfTailed?: boolean;
-    }): string | null;
-    /**
-     * Drop rows whose `file_path` no longer exists on disk AND which have no
-     * cached tail to fall back to. Rows with a tail are left alone so
-     * `handleGetConversation` can still serve the cached tail even when the
-     * JSONL has been deleted.
-     */
-    pruneGhostFiles(exists?: (filePath: string) => boolean): string[];
-    /**
-     * Reconcile the cache against the authoritative set of conversation file
-     * paths a fresh scan surfaced: drop any cached row whose `file_path` is not
-     * in `livePaths` (removed from disk, or now filtered out — e.g. became an
-     * agent JSONL). This is the "removed conversations" half of a ?refresh=1
-     * reconcile; the additions/updates half is upsertFromScannerMeta.
-     *
-     * Skip semantics depend on whether the file still exists on disk:
-     *  - File GONE from disk → always removed, tail or not. This matches the old
-     *    invalidate()+rebuild behavior (a deleted conversation must disappear on
-     *    refresh) and keeps refresh=1 truthful about removals. NOTE: this is an
-     *    INTENTIONAL divergence from pruneGhostFiles(), which KEEPS tailed ghosts
-     *    so their cached history stays viewable on a background prune. refresh=1
-     *    has the opposite contract (mobile relies on removals being reflected), so
-     *    do not "unify" the two — they serve different purposes.
-     *  - File STILL on disk but absent from `livePaths` → the CRITICAL #2 race:
-     *    the scan snapshot predates a just-created (and now live-tailed) file.
-     *    A tailed row here is actively maintained from real content, so it is
-     *    kept — dropping it would flicker the active conversation out of
-     *    /api/conversations. An untailed on-disk row not in the snapshot is a
-     *    transient scan/discovery gap; it is left alone (not removed) and the
-     *    next reconcile picks it up, rather than risk removing a real file the
-     *    scan simply hasn't surfaced yet.
-     * Returns the removed IDs.
-     */
-    reconcileDeletions(livePaths: Set<string>, opts?: {
-        exists?: (filePath: string) => boolean;
-    }): string[];
-    /**
-     * Read-only: list cached rows whose `file_path` no longer exists on disk.
-     * Unlike pruneGhostFiles/reconcileDeletions this mutates nothing — it just
-     * reports drift for the CacheIntegrityMonitor to classify. `tailed` flags
-     * rows that still have cached history (which pruneGhostFiles would keep).
-     */
-    listMissingFiles(exists?: (filePath: string) => boolean): {
-        id: string;
-        filePath: string;
-        title: string | null;
-        tailed: boolean;
-    }[];
-    /**
-     * Drop the given conversation ids outright — main row, tail, and message
-     * index — regardless of whether they have a tail. Used by the cache-integrity
-     * resolution actions (prune_all / prune_selected). Returns the count dropped.
-     */
-    dropRowsById(ids: string[]): number;
-    /**
-     * Wipe all cached conversation state — meta, tails, and message index — and
-     * reset the in-memory file index. Only called by the `reset_rescan`
-     * resolution action, which repopulates from a fresh disk scan afterward.
-     */
-    clearAll(): void;
-}
-
-type CacheMetadataKey = "last_conversation_id" | "last_conversation_created_at" | "projects_last_indexed_at" | "conversations_last_indexed_at" | "conversations_dirty";
-declare class CacheMetadataRepository {
-    private get;
-    private upsert;
-    private del;
-    constructor(db: Database.Database);
-    getCacheMetadata(key: CacheMetadataKey): string | null;
-    setCacheMetadata(key: CacheMetadataKey, value: string): void;
-    deleteCacheMetadata(key: CacheMetadataKey): void;
-}
-
-/**
- * Thin repository wrapper around ConversationCache for the project-id flow.
- * The cache is the source of truth for conversation rows; this just exposes
- * a stable, repo-style API for services that don't want to know about the
- * cache class directly.
- */
-declare class ConversationsRepository {
-    private cache;
-    constructor(cache: ConversationCache);
-    updateConversationProjectId(args: {
-        conversationId: string;
-        projectId: string;
-    }): void;
-    listConversationsForProjectBackfill(): {
-        id: string;
-        projectPath: string | null;
-        projectId: string | null;
-        lastActivity: string | null;
-    }[];
-    getLatestConversation(): {
-        id: string;
-        lastActivity: string | null;
-    } | null;
-    hasOrphanRows(): boolean;
-}
-
-/**
- * Paired-device registry (C5).
- * See docs/architecture/2026-07-24-device-identity-and-capabilities.md.
- *
- * Stores identity and authority for each paired device. Never stores a usable
- * credential: only the SHA-256 of a device token, so reading this table cannot
- * impersonate a device.
- */
-interface DeviceRow {
-    device_id: string;
-    public_key: string;
-    token_hash: string;
-    name: string | null;
-    capabilities: string;
-    created_at: number;
-    last_seen_at: number | null;
-    revoked_at: number | null;
-    /** Noise static public key, base64. Null on every row that predates E2EE. */
-    e2ee_static_pub: string | null;
-    /** The downgrade lock. 1 once this device has completed a handshake. */
-    e2ee_required: number;
-    e2ee_version: number | null;
-}
-/** A device as reported over the API. Deliberately carries no credential. */
-interface DeviceView {
-    deviceId: string;
-    name: string | null;
-    capabilities: Capability[];
-    createdAt: number;
-    lastSeenAt: number | null;
-    revokedAt: number | null;
-    /**
-     * Whether this device is pinned to encryption.
-     *
-     * A boolean, never the key and never a hash of it: `GET /api/devices` exists
-     * so a user can spot a device they did not pair, and answering "is this one
-     * encrypted" needs no key material to do it. Publishing the static key would
-     * hand an attacker who reached this endpoint the value that identifies a
-     * device.
-     */
-    e2ee: boolean;
-}
-interface RegisteredDevice {
-    deviceId: string;
-    /** Returned to the client exactly once, at pairing. Never persisted raw. */
-    deviceToken: string;
-    capabilities: Capability[];
-}
-declare class DevicesRepository {
-    private insertStmt;
-    private byTokenHashStmt;
-    private byIdStmt;
-    private listStmt;
-    private revokeStmt;
-    private touchStmt;
-    private deleteStmt;
-    private deleteRevokedStmt;
-    private byE2eeStaticPubStmt;
-    private repairStmt;
-    constructor(db: Database.Database);
-    /**
-     * Record a newly paired device and mint its token.
-     *
-     * The raw token is returned to the caller and never stored — this is the only
-     * moment it exists outside the client.
-     */
-    register(args: {
-        publicKey: string;
-        name?: string | null;
-        preset?: CapabilityPreset;
-        now?: number;
-        /**
-         * The device's Noise static public key, base64, when pairing completed a
-         * handshake. Absent on a plaintext pairing, which stays exactly as it is
-         * today: no key, no pin, no behaviour change.
-         */
-        e2eeStaticPub?: string;
-        e2eeVersion?: number;
-    }): RegisteredDevice;
-    /** The device that owns a Noise static key, or null. */
-    getByE2eeStaticPub(staticPub: string): DeviceRow | null;
-    /**
-     * Resolve a presented token to a device, or null.
-     *
-     * Returns null for a revoked device, so revocation takes effect on the very
-     * next request with no cache to go stale.
-     */
-    authenticate(token: string): DeviceRow | null;
-    get(deviceId: string): DeviceRow | null;
-    /** All devices, including revoked ones — an audit surface needs the history. */
-    list(): DeviceView[];
-    /** Revoke one device. Others are untouched — no key rotation, no collateral. */
-    revoke(deviceId: string, now?: number): boolean;
-    /**
-     * Erase one device's record outright.
-     *
-     * Deliberately separate from `revoke`, which is a soft delete that keeps the
-     * row so `list()` can show what happened. That audit trail is the right
-     * default — but it meant a `devices` row, including the user-supplied `name`
-     * ("Ronen's iPhone"), had no removal path at all once the registry moved to
-     * runtime.db, which no command deletes. This is that path.
-     *
-     * Erasure is NOT revocation: deleting a row frees its `token_hash`, so a
-     * device whose token is still on a phone somewhere stops being *known* rather
-     * than being *refused*. Revoke first, delete second, is the safe order, and
-     * `deleteRevoked()` exists so that is the easy thing to do.
-     */
-    delete(deviceId: string): boolean;
-    /**
-     * Erase every already-revoked device. The bulk companion to `delete`, and the
-     * one that is safe by construction: a revoked device is already refused, so
-     * removing its row cannot restore access to anything.
-     *
-     * Returns the number of rows removed.
-     */
-    deleteRevoked(): number;
-    touch(deviceId: string, now?: number): void;
-}
-
-/**
- * Durable registry of managed sessions (C1 Phase 2).
- * See docs/architecture/2026-07-24-durable-session-runtime.md.
- *
- * Distinct from SessionsRepository, which wraps the in-memory SessionStore for
- * the live request path. This one exists so session identity and provenance
- * outlive the streamer process: without it, a restart loses startedAt,
- * promptCount, sessionName, the Codex rollout binding, and failureReason, and
- * the boot reconciler has nothing to reconcile against.
- *
- * Deliberately not stored here: the PTY output ring buffer and xterm screen.
- * Their authoritative copy is the provider's JSONL, and writing 64KiB of ANSI
- * on every chunk to duplicate it would be a write storm for no gain.
- */
-/** How a persisted status was obtained — never inferred, always recorded. */
-type StatusSource = "spawn" | "transition" | "exit" | "shutdown" | "probe" | "reconcile";
-
-interface ManagedSessionRow {
-    session_id: string;
-    provider: string;
-    pid: number | null;
-    cmdline: string | null;
-    project_path: string;
-    project_name: string;
-    branch: string;
-    status: string;
-    status_source: string;
-    status_updated_at: number;
-    started_at: number;
-    completed_at: number | null;
-    last_activity_at: number | null;
-    prompt_count: number;
-    session_name: string | null;
-    project_id: string | null;
-    bound_conversation_id: string | null;
-    resumed_from_conversation_id: string | null;
-    failure_reason: string | null;
-    streamer_instance_id: string;
-    /**
-     * Which machine boot `pid` was recorded during (migration 002). Optional
-     * because rows written before it exists read back as null/absent, which the
-     * reconciler treats exactly like a mismatch — never like a match.
-     */
-    boot_token?: string | null;
-}
-interface RecordSpawnInput {
-    session: ManagedSession;
-    pid: number | null;
-    cmdline: string | null;
-    streamerInstanceId: string;
-}
-declare class ManagedSessionsRepository {
-    private upsertStmt;
-    private updateStatusStmt;
-    private bindStmt;
-    private getStmt;
-    private listNonTerminalStmt;
-    private listAllStmt;
-    private pruneTerminalStmt;
-    private listRecoverableStmt;
-    private deleteStmt;
-    constructor(db: Database.Database);
-    /** Record a session at spawn, or refresh every field of an existing row. */
-    recordSpawn({ session, pid, cmdline, streamerInstanceId }: RecordSpawnInput): void;
-    /**
-     * Persist a status transition. `source` is required rather than defaulted:
-     * a status whose provenance is unknown is the thing this table exists to
-     * prevent, and the reconciler reads it to decide how much to trust the value.
-     */
-    recordStatus(sessionId: string, status: SessionStatus, source: StatusSource, fields?: {
-        completedAt?: Date | null;
-        lastActivityAt?: Date | null;
-        promptCount?: number;
-        failureReason?: string | null;
-        /** Null/omitted keeps whatever is stored — it never clears a known name. */
-        sessionName?: string | null;
-    }): void;
-    /**
-     * Persist the Codex rollout id discovered after spawn.
-     *
-     * Its own statement rather than a `recordSpawn` re-run: the binding arrives
-     * while the session is live, and re-upserting would also rewrite `cmdline`
-     * with an id that is *not* in a fresh Codex process's argv, turning the
-     * reconciler's identity check into a false `orphaned`. Without this write the
-     * binding lives only in memory and dies with the streamer — which is the
-     * whole reason a restarted Codex session could not be resumed (G6).
-     */
-    recordBinding(sessionId: string, boundConversationId: string): void;
-    get(sessionId: string): ManagedSessionRow | null;
-    /**
-     * Rows with no recorded completion — the reconciler's probe set.
-     *
-     * Capped. Callers must compare the result length against the limit and say so
-     * when it clips: a silently truncated probe set reads as "we checked
-     * everything" when it did not.
-     */
-    listNonTerminal(limit?: number): ManagedSessionRow[];
-    /** Every row, most recently touched first, for the diagnostics surface. */
-    listAll(limit?: number): ManagedSessionRow[];
-    /**
-     * Delete terminal rows older than `olderThanMs`, returning how many went.
-     *
-     * Only rows carrying a `completed_at` are eligible, so nothing the reconciler
-     * or rehydrator might still want is reachable from here — a row without one
-     * is by definition unfinished business, however old it looks.
-     */
-    pruneTerminal(olderThanMs?: number): number;
-    /**
-     * Rows a restart could bring back: still open, or closed by our own shutdown,
-     * and touched no longer ago than `sinceMs`. Newest first, capped — the caller
-     * decides which of these actually deserve rehydrating (`shouldRehydrate`).
-     */
-    listRecoverable({ sinceMs, limit }: {
-        sinceMs: number;
-        limit: number;
-    }): ManagedSessionRow[];
-    delete(sessionId: string): void;
-}
-
-/**
- * Persisted Project row. Mirrors the projects SQLite table.
- */
-declare const ProjectSchema: z.ZodObject<{
-    id: z.ZodString;
-    path: z.ZodString;
-    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    lastConversationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    lastConversationCreatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    lastIndexedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    latestMessageAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    latestMessageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, z.core.$strip>;
-type Project = z.infer<typeof ProjectSchema>;
-
-interface UpsertProjectInput {
-    lastConversationId?: string | null;
-    lastConversationCreatedAt?: string | null;
-    latestMessageAt?: string | null;
-    latestMessageId?: string | null;
-    name?: string | null;
-}
-declare class ProjectsRepository {
-    private getByPath;
-    private getById;
-    private listAll;
-    private insert;
-    private update;
-    constructor(db: Database.Database);
-    getProjectByPath(rawPath: string): Project | null;
-    getProjectById(id: string): Project | null;
-    listProjects(): Project[];
-    /**
-     * Insert a project at the given canonical path, or update its metadata
-     * if one already exists. Returns the persisted Project row.
-     *
-     * Idempotent: passing the same path twice returns the same project id.
-     */
-    upsertProjectByPath(rawPath: string, input?: UpsertProjectInput): Project;
-}
-
-/**
- * Token kinds. A device supplies three non-interchangeable types, and
- * conflating them fails only at send time with no signal at registration:
- *
- * - `expo` — Expo relay token, for ordinary push notifications.
- * - `liveactivity_start` — ActivityKit push-to-start token. App-wide, one per
- *   device, long-lived. Starts an activity when none exists.
- * - `liveactivity_update` — ActivityKit per-activity update token, issued by
- *   iOS after an activity starts, scoped to that one activity, short-lived.
- */
-declare const PUSH_TOKEN_KINDS: readonly ["expo", "liveactivity_start", "liveactivity_update"];
-type PushTokenKind = (typeof PUSH_TOKEN_KINDS)[number];
-interface PushTokenRow {
-    token: string;
-    platform: string;
-    device_id: string | null;
-    registered_at: number;
-    last_success_at: number | null;
-    last_failure_at: number | null;
-    last_failure_code: string | null;
-    failure_streak: number;
-    revoked_at: number | null;
-    kind: PushTokenKind;
-    activity_id: string | null;
-    session_id: string | null;
-    expires_at: number | null;
-    stale_date: number | null;
-    started_at: number | null;
-    renewed_at: number | null;
-}
-/**
- * Health as reported to a client. Deliberately omits the token itself — a push
- * token is a delivery credential, and a health endpoint has no reason to echo
- * one back.
- */
-interface PushTokenHealth {
-    platform: string;
-    deviceId: string | null;
-    registeredAt: number;
-    lastSuccessAt: number | null;
-    lastFailureAt: number | null;
-    lastFailureCode: string | null;
-    failureStreak: number;
-    revokedAt: number | null;
-    /**
-     * Never delivered vs delivering vs failing vs revoked vs expired. The
-     * distinction the user actually needs: "not yet" and "broken" look identical
-     * without it.
-     */
-    state: "never-delivered" | "healthy" | "failing" | "dead" | "revoked" | "expired";
-    kind: PushTokenKind;
-    /** Present only for per-activity Live Activity tokens. */
-    activityId: string | null;
-    sessionId: string | null;
-    expiresAt: number | null;
-}
-declare class PushRepository {
-    private upsertStmt;
-    private getStmt;
-    private listActiveStmt;
-    private listAllStmt;
-    private successStmt;
-    private failureStmt;
-    private revokeStmt;
-    private claimEventStmt;
-    private markDeliveredStmt;
-    private listByKindSessionStmt;
-    private listByKindStmt;
-    private listRenewableStmt;
-    private claimRenewalStmt;
-    private expireStmt;
-    private expireSessionActivitiesStmt;
-    constructor(db: Database.Database);
-    /**
-     * Register or refresh a token.
-     *
-     * `kind` defaults to Expo so a released client posting `{ token, platform }`
-     * keeps working — tb-mobile cannot be force-updated, and every client
-     * predating Live Activities is registering an Expo relay token.
-     *
-     * Several rows per device is normal and intended: a device runs one activity
-     * per live session, each with its own update token. The token itself is the
-     * primary key, so distinct activities never collide.
-     */
-    register(args: {
-        token: string;
-        platform: string;
-        deviceId?: string | null;
-        kind?: PushTokenKind;
-        activityId?: string | null;
-        sessionId?: string | null;
-        expiresAt?: number | null;
-        staleDate?: number | null;
-        startedAt?: number | null;
-        now?: number;
-    }): void;
-    get(token: string): PushTokenRow | null;
-    /**
-     * Expo tokens eligible for delivery — not revoked, not past the failure limit.
-     *
-     * Deliberately Expo-only. ActivityKit tokens go over direct APNs with a
-     * different topic and are rejected by Expo's relay, so the ordinary
-     * notification fan-out must not see them.
-     */
-    listDeliverable(): PushTokenRow[];
-    /** Live-activity tokens for one session, eligible for delivery. */
-    listForSession(kind: PushTokenKind, sessionId: string, now?: number): PushTokenRow[];
-    /**
-     * Every deliverable token of one kind.
-     *
-     * Used for push-to-start, which is app-wide rather than session-scoped: the
-     * activity does not exist yet, so there is no per-activity token to look up.
-     */
-    listByKind(kind: PushTokenKind, now?: number): PushTokenRow[];
-    /** Unrenewed activities with a renewal deadline, soonest first. */
-    listRenewable(): PushTokenRow[];
-    /**
-     * Claim a row for renewal.
-     *
-     * Returns true exactly once per row. A restart re-arms timers from the
-     * persisted deadline, so the same renewal can be attempted twice; the loser
-     * gets false and must not send. Doing this as a conditional UPDATE rather
-     * than read-then-write avoids the race where both attempts observe
-     * "not yet renewed".
-     */
-    claimRenewal(token: string, now?: number): boolean;
-    /** Mark one token expired, so it stops being a delivery target. */
-    expire(token: string, now?: number): void;
-    /**
-     * Expire every live activity for a session.
-     *
-     * Called when the session ends. Without this, a per-activity token outlives
-     * its session and a later renewal sweep would resurrect an activity for a
-     * session that is already gone.
-     */
-    expireSessionActivities(sessionId: string, now?: number): void;
-    /** Every token, including dead and revoked ones, for the health report. */
-    listHealth(now?: number): PushTokenHealth[];
-    recordSuccess(token: string, now?: number): void;
-    recordFailure(token: string, code: string, now?: number): void;
-    revoke(token: string, now?: number): boolean;
-    /**
-     * Claim an event id for delivery.
-     *
-     * Returns true exactly once per event id. A retry, a reconnect
-     * reconciliation, or two triggers firing for the same underlying event all
-     * get false and must not notify — the user should never be told twice about
-     * one thing.
-     */
-    claimEvent(eventId: string, sessionId: string | null, now?: number): boolean;
-    markDelivered(eventId: string, now?: number): void;
-}
-
-declare class SessionStore {
-    private managed;
-    private discovered;
-    addManaged(session: ManagedSession): void;
-    /**
-     * Multi-agent mode only. Attach a dedupe LRU to a session record. Idempotent —
-     * calling twice keeps the existing LRU (and its contents).
-     */
-    initAgentSession(sessionId: string, dedupeCapacity: number): void;
-    updateManaged(sessionId: string, updates: Partial<ManagedSession>): ManagedSession | null;
-    removeManaged(sessionId: string): boolean;
-    /**
-     * The **live** stored record — mutating it mutates the store. Paired with
-     * `get()`, which hands back a throwaway response copy. Prefer
-     * `updateManaged()` for writes; this is for readers that need the internal
-     * shape (Date fields, `rehydrated`, …) rather than the wire shape.
-     */
-    getManaged(sessionId: string): ManagedSession | null;
-    setDiscovered(processes: DiscoveredProcess[]): void;
-    /**
-     * The **live** stored records — mutating an element mutates the store. Paired
-     * with `list()`, which hands back throwaway response copies.
-     */
-    listManaged(): ManagedSession[];
-    list(ptyAttachedIds: Set<string>): readonly Readonly<SessionResponse>[];
-    get(sessionId: string, ptyAttachedIds: Set<string>): Readonly<SessionResponse> | null;
-    paginate(ptyAttachedIds: Set<string>, query: SessionListQuery): SessionListPage;
-}
-
-/**
- * Sessions live in-memory in SessionStore (Postgres-backed persistence
- * was dropped per the SQLite-only direction). This repository wraps the
- * store with a stable, project-id-aware API for the new services.
- */
-declare class SessionsRepository {
-    private store;
-    constructor(store: SessionStore);
-    updateSessionProjectId(args: {
-        sessionId: string;
-        projectId: string;
-    }): void;
-    listManagedSessions(): ManagedSession[];
-}
-
-/**
- * `~/.threadbase/runtime.db` — the authoritative, non-derived half of the
- * streamer's SQLite state.
- *
- * Deliberately a separate file from `cache/cache.db`, and deliberately not
- * under `cache/`. The conversation cache is rebuildable from the provider
- * JSONLs at any time, which is why "delete the cache and restart" is reasonable
- * support advice and why the integrity monitor offers a reset-and-rescan
- * action. The managed-session registry is not rebuildable from anything on
- * disk, so it must not sit one plausible instruction away from deletion — nor
- * share a handle whose failure (a better-sqlite3 ABI mismatch, most commonly)
- * would silently disable session persistence along with the cache.
- *
- * Runs its own migrations from `src/db/runtime-migrations/`, tracked in this
- * file's own `schema_migrations` table.
- */
-declare class RuntimeStore {
-    private readonly db;
-    private constructor();
-    static open(dbPath: string, migrationsDir?: string): RuntimeStore;
-    getDatabase(): Database.Database;
-    /**
-     * One-time move of `managed_sessions` rows out of a pre-split `cache.db`.
-     *
-     * Returns the number of rows copied.
-     */
-    importLegacyManagedSessions(source: Database.Database): number;
-    /**
-     * One-time move of `devices` rows out of `cache.db`, where the registry used
-     * to live (migration `011_create_devices.sql`).
-     *
-     * Losing this table invalidates every device token ever issued, and cache.db
-     * is the file `tb-streamer cache clear` deletes and the integrity monitor
-     * rebuilds — see `runtime-migrations/003_create_devices.sql`.
-     *
-     * Unlike `managed_sessions`, this one MOVES rather than copies: the source
-     * rows are deleted once the copy is verified. A `devices` row carries a
-     * user-supplied label ("Ronen's iPhone"), and leaving a second copy of that
-     * on disk indefinitely — in the one file the user is told to delete when
-     * something goes wrong — is more retained personal data than the rollback
-     * path is worth. Recovering from a rollback is re-scanning a pairing QR.
-     *
-     * The delete is conditional on the copy being complete: `INSERT OR IGNORE`
-     * can silently skip a row, so the destination count must match what was read
-     * before anything is removed. A mismatch keeps the source and reports
-     * `purged: false` rather than throwing — the import itself still succeeded,
-     * and keeping data is the safe direction to fail in.
-     */
-    importLegacyDevices(source: Database.Database): {
-        copied: number;
-        purged: boolean;
-    };
-    /**
-     * Copy a whole table out of a pre-split `cache.db` into this file.
-     *
-     * The copy itself is non-destructive — the source is left in place, so an
-     * older streamer rolled back onto the same machine still finds its data.
-     * `importLegacyDevices` deletes the source afterwards for its own reasons;
-     * `managed_sessions` does not. Runs only when this file's table is empty, so
-     * a second boot is a no-op rather than a re-copy that would resurrect rows
-     * deleted since.
-     *
-     * The table name is interpolated into SQL, so it is typed as a closed union
-     * rather than `string` — the set of tables that can ever be lifted is known
-     * at compile time, and that is what keeps a caller from making this a hole.
-     */
-    private importLegacyTable;
-    close(): void;
-}
-
-interface HostHeartbeatState {
-    registryState: "known" | "unknown";
-    referencedSessionIds: string[];
-}
-/**
- * A duplex line channel. Deliberately not a socket: the runner is tested
- * against an in-memory pair, and PR 7 supplies the real one over a unix socket
- * (POSIX) or named pipe (Windows).
- */
-interface HostTransport {
-    send(line: string): void;
-    onLine(handler: (line: string) => void): void;
-    onClose(handler: () => void): void;
-    close(): void;
-}
-
-declare class LiveSessionManager {
-    private runners;
-    private remoteRunner;
-    private options;
-    constructor(options?: PTYManagerOptions);
-    useRemoteRunner(transport: HostTransport): Promise<ManagedSession[]>;
-    isRemote(): boolean;
-    startRemoteHeartbeat(getState: () => HostHeartbeatState): void;
-    start(sessionId: string, options: StartSessionOptions & {
-        provider?: ProviderName;
-    }): Promise<ManagedSession>;
-    startFresh(options: StartFreshSessionOptions & {
-        provider?: ProviderName;
-    }): Promise<ManagedSession>;
-    /**
-     * Fork an existing conversation into a new session. Codex-only: `codex fork`
-     * has no Claude Code equivalent, and there is no safe generic fallback — a
-     * silent downgrade to resume would attach to the very writer the caller is
-     * trying to leave alone.
-     */
-    startFork(options: StartForkSessionOptions & {
-        provider?: ProviderName;
-    }): Promise<ManagedSession>;
-    sendInput(sessionId: string, input: string): number;
-    sendKeys(sessionId: string, keys: string): void;
-    cancel(sessionId: string): void;
-    killPid(pid: number): void;
-    putOnHold(sessionId: string): void;
-    getOutput(sessionId: string): string;
-    getOutputLines(sessionId: string, maxLines: number): Promise<string[]>;
-    getInputHistory(sessionId: string): UserMessage[];
-    getSession(sessionId: string): ManagedSession | null;
-    getPid(sessionId: string): number | null;
-    hasSession(sessionId: string): boolean;
-    listSessions(): ManagedSession[];
-    dispose(): void;
-    private runnerFor;
-    /**
-     * Refuse before spawning when the provider's CLI is not on this machine.
-     *
-     * Without this the spawn "succeeds": on POSIX execvp fails inside the forked
-     * child, so a session appears, exits ~12ms later with code 1 and no output,
-     * and the caller is told only that it "exited before becoming ready" — or,
-     * on the Claude resume path, is told nothing at all, since that path answers
-     * 200 before the process has had a chance to die. Every start route funnels
-     * through here, so one check covers start, resume, adopt and fork.
-     *
-     * 503, not 500: the request was well-formed and the fault is this machine's
-     * environment. `code` is what mobile branches on (it reads `errBody.code`),
-     * and `PROVIDER_NOT_INSTALLED` is a remediation string it already knows.
-     */
-    private assertProviderInstalled;
-    private assertSupportedProvider;
-    private activeRunners;
-}
-
-declare class WSHub {
-    private clients;
-    private pingTimer;
-    private pongTimers;
-    addClient(ws: WebSocket): void;
-    broadcast(message: WSMessage): void;
-    broadcastToClients(clients: Iterable<WebSocket>, message: WSMessage): void;
-    unicast(ws: WebSocket, message: WSMessage): void;
-    get connectionCount(): number;
-    dispose(): void;
-    private startPing;
-}
-
-/** One missing conversation the alert covers. */
-interface MissingEntry {
-    id: string;
-    filePath: string;
-    title: string | null;
-    tailed: boolean;
-}
-interface PendingAlert {
-    fingerprint: string;
-    severity: "high" | "low";
-    detectedAt: string;
-    missingCount: number;
-    totalRows: number;
-    backupPath?: string;
-    /** Capped at 1000 entries in the persisted file. */
-    missing: MissingEntry[];
-}
-
-type ResolveAction = CacheAlertResolveAction;
-/** The `cache_alert` WS variant, narrowed from the WSMessage union. */
-type CacheAlertWsMessage = Extract<WSMessage, {
-    type: "cache_alert";
-}>;
-type ResolveResult = {
-    ok: true;
-    action: ResolveAction;
-    pruned?: number;
-    backupPath?: string;
-} | {
-    alreadyResolved: true;
-} | {
-    conflict: true;
-    currentFingerprint: string;
-};
-declare class CacheIntegrityMonitor {
-    private readonly cache;
-    private readonly wsHub;
-    private readonly log;
-    private readonly cacheDir;
-    private readonly rescan?;
-    private readonly runDuringReset?;
-    private _pending;
-    private ignoredIds;
-    private deferredUnlinks;
-    private unlinkTimes;
-    constructor(cache: ConversationCache, wsHub: WSHub, log: Logger, cacheDir: string, rescan?: (() => Promise<ScannerMeta[]>) | undefined, runDuringReset?: (<T>(operation: () => Promise<T>) => Promise<T>) | undefined);
-    get pending(): PendingAlert | null;
-    private persist;
-    private classifySeverity;
-    private sampleOf;
-    private buildWsMessage;
-    wsMessage(): CacheAlertWsMessage | null;
-    healthzField(): {
-        severity: "high" | "low";
-        missingCount: number;
-        fingerprint: string;
-        detectedAt: string;
-    } | undefined;
-    /**
-     * Scan the cache for rows whose file is gone, excluding ids the user chose to
-     * ignore. If none remain, clear any stale pending alert and return (the caller
-     * decides whether to run pruneGhostFiles). Otherwise classify severity, persist
-     * the pending record, back up on high severity, and broadcast the alert.
-     */
-    runDetection(detectedAt?: string): Promise<void>;
-    /** Queue an unlink while an alert is pending — the row is not invalidated. */
-    deferUnlink(filePath: string): void;
-    /**
-     * Record a live unlink while NO alert is pending. Crossing the storm threshold
-     * (>= 10 unlinks within 30s) re-triggers detection.
-     */
-    recordUnlink(filePath: string): void;
-    private ensureBackup;
-    private clearPending;
-    private applyDeferredUnlinks;
-    private broadcastResolved;
-    /**
-     * Apply the human's chosen resolution. Idempotent per fingerprint: no pending
-     * alert → alreadyResolved; a different fingerprint → conflict. See the spec's
-     * four-action semantics.
-     */
-    resolve(fingerprint: string, action: ResolveAction, ids?: string[]): Promise<ResolveResult>;
-}
-
-/** Result for a single registry row. Pure data — nothing here acts. */
-interface ReconcileVerdict {
-    sessionId: string;
-    lifecycle: SessionLifecycle;
-    /** Why this verdict was reached, for logs and the diagnostics surface. */
-    reason: string;
-}
-
-type ApiDeps = {
-    apiKey: string;
-    localNoAuth: boolean;
-    logMenubarRequests: boolean;
-    rotateApiKey: () => {
-        newKey: string;
-        persisted: boolean;
-    };
-    claudeFlagsConfig: () => {
-        registry: readonly FlagDefinition[];
-        values: ClaudeFlagValues;
-        extraArgs: string | null;
-        persisted: boolean;
-    };
-    setClaudeFlagsConfig: (values: ClaudeFlagValues, extraArgs: string | undefined) => {
-        values: ClaudeFlagValues;
-        extraArgs: string | null;
-        persisted: boolean;
-    };
-    featureFlagsConfig: () => {
-        registry: readonly FeatureFlagDefinition[];
-        values: ResolvedFeatureFlags;
-        sources: Record<FeatureFlagId, FeatureFlagSource>;
-    };
-    publicUrl: string | null;
-    browseRoot: string | null;
-    browserCors: string | undefined;
-    ptyManager: LiveSessionManager;
-    sessionStore: SessionStore;
-    wsHub: WSHub;
-    cache: () => ConversationCache | null;
-    cacheMonitor: () => CacheIntegrityMonitor | null;
-    /** Push registration + delivery state (C7). Null when the cache DB is unavailable. */
-    pushRepo: () => PushRepository | null;
-    /**
-     * Whether Live Activity push is actually running on this server — the same
-     * fact the boot log reports as `live_activity.enabled`. Asked of the server
-     * rather than re-derived from the environment, because APNs credentials alone
-     * do not enable it: the sender is only wired when the token store opened too.
-     */
-    liveActivityPushEnabled: () => boolean;
-    /** Paired-device registry (C5). Null when the cache DB is unavailable. */
-    devicesRepo: () => DevicesRepository | null;
-    projectsRepo: () => ProjectsRepository | null;
-    conversationsRepo: () => ConversationsRepository | null;
-    sessionsRepo: () => SessionsRepository | null;
-    cacheMetadataRepo: () => CacheMetadataRepository | null;
-    /** Authoritative session registry (~/.threadbase/runtime.db). Null when it failed to open. */
-    runtimeStore: () => RuntimeStore | null;
-    /** Rows of that registry. Null when it failed to open. */
-    managedSessionsRepo: () => ManagedSessionsRepository | null;
-    /** This boot's reconcile verdicts, by session id. Empty before it has run. */
-    sessionVerdicts: () => Map<string, ReconcileVerdict>;
-    ptyAttachedIds: () => Set<string>;
-    handleListSessions: (url: URL, res: ServerResponse) => Promise<void>;
-    handleSessionsCount: (res: ServerResponse) => void;
-    handleGetRecentSessions: (url: URL, res: ServerResponse) => void;
-    handleGetSessionNames: (res: ServerResponse) => void;
-    handleGetSession: (sessionId: string, res: ServerResponse) => Promise<void>;
-    handleGetOutput: (sessionId: string, res: ServerResponse) => void;
-    handleSendInput: (sessionId: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleSendAnswer: (sessionId: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleCancel: (sessionId: string, res: ServerResponse) => void;
-    handleStopSession: (sessionId: string, res: ServerResponse) => Promise<void>;
-    handleSetSessionName: (sessionId: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleSetSessionModel: (sessionId: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleSetSessionEffort: (sessionId: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleUploadFile: (sessionId: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleAdopt: (sessionId: string, res: ServerResponse) => Promise<void>;
-    handleFork: (sessionId: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleResume: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleStartSession: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleListConversations: (url: URL, res: ServerResponse) => Promise<void>;
-    handleConversationsCount: (url: URL, res: ServerResponse) => Promise<void>;
-    handleGetConversation: (id: string, url: URL, res: ServerResponse, ifNoneMatch?: string) => Promise<void>;
-    handleSearch: (url: URL, res: ServerResponse) => Promise<void>;
-    handleSearchTarget: (id: string, req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleListProjects: (url: URL, res: ServerResponse) => void;
-    handleGetPopularProjects: (url: URL, res: ServerResponse) => void;
-    handleGetProjectSummaries: (url: URL, res: ServerResponse) => void;
-    handlePairStart: (res: ServerResponse) => void;
-    handlePairExchange: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleBrowse: (url: URL, res: ServerResponse) => Promise<void>;
-    handleMkdir: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-    handleWsOpen: (ws: WebSocket) => void;
-    handleWsMessage: (ws: WebSocket, raw: unknown, principal: Principal | null) => void;
-    handleWsClose: (ws: WebSocket) => void;
-    agentClient: AgentClient | null;
-    conversationWriter: ConversationWriter | null;
-    agentConfig: AgentConfig;
-};
-
-type AppEnv = {
-    Bindings: HttpBindings;
-    Variables: {
-        requestId?: string;
-        validatedBody?: unknown;
-        validatedQuery?: unknown;
-        /** Who is making this request (C5). Set by authMiddleware. */
-        principal?: Principal;
-    };
-};
-
-interface AgentDeps {
-    sessionStore: {
-        getManaged: (sessionId: string) => {
-            id: string;
-            progressDedupeIds?: {
-                hasSeen: (id: string) => boolean;
-            };
-            currentTurnId?: string | null;
-        } | null;
-    };
-    wsHub: {
-        broadcast: (m: WSMessage) => void;
-    };
-    conversationWriter: {
-        appendAssistantTurn: (a: {
-            sessionId: string;
-            turnId: string;
-            content: string;
-            reviewerOverruled?: boolean;
-        }) => Promise<void>;
-    } | null;
-    agentConfig: {
-        enabled: boolean;
-        webhook: {
-            hmacSecret: string;
-            timestampSkewSeconds: number;
-        };
-        dedupe: {
-            perSessionCapacity: number;
-        };
-    };
-}
-declare const createProgressRoutes: (deps: ApiDeps & AgentDeps) => Hono<AppEnv, hono_types.BlankSchema, "/">;
-
-declare function generateApiKey(): string;
-declare function validateApiKey(provided: string, expected: string): boolean;
-declare function loadOrCreateApiKey(): string;
-
-interface DbConfig {
-    connectionString: string;
-    max: number;
-    ssl?: string;
-    statementTimeout?: number;
-    instanceId: string;
-}
-declare function isDbEnabled(): boolean;
-declare function getDbConfig(): DbConfig | null;
-
-declare function maskConnectionString(url: string): string;
-declare function createPool(config: DbConfig): Promise<Pool>;
-
-declare function discoverClaudeProcesses(): Promise<DiscoveredProcess[]>;
-
-declare class PTYManager implements SessionRunner {
-    private sessions;
-    private onOutput;
-    private onStatusChange;
-    private onReady;
-    private onPermissionChange;
-    private onPhaseChange;
-    private onLiveQuestion;
-    private onLiveQuestionGone;
-    private onUserMessage;
-    private permissionOpen;
-    private oscTail;
-    private lastDetectAt;
-    private lastScreenQuestionKey;
-    private shellPromptOpen;
-    private closedGateKey;
-    private pendingReady;
-    private queuedInputs;
-    private log;
-    private firstChunkAt;
-    private chunkIndex;
-    private lastChunkAt;
-    private quietCheckers;
-    private readyFallbackTimers;
-    private startPromises;
-    constructor(options?: PTYManagerOptions);
-    start(sessionId: string, options: StartSessionOptions): Promise<ManagedSession>;
-    private doStart;
-    startFresh(options: StartFreshSessionOptions): Promise<ManagedSession>;
-    sendKeys(sessionId: string, keys: string): void;
-    sendInput(sessionId: string, input: string): number;
-    private writeSubmit;
-    private flushQueuedInputs;
-    cancel(sessionId: string): void;
-    killPid(pid: number): void;
-    putOnHold(sessionId: string): void;
-    getOutput(sessionId: string): string;
-    getOutputLines(sessionId: string, maxLines: number): Promise<string[]>;
-    getInputHistory(sessionId: string): UserMessage[];
-    getPid(sessionId: string): number | null;
-    private recordUserMessage;
-    getSession(sessionId: string): ManagedSession | null;
-    hasSession(sessionId: string): boolean;
-    listSessions(): ManagedSession[];
-    dispose(): void;
-    private handleOutput;
-    private detectLivePrompts;
-    private handleQuiet;
-    private recheckReadyFromScreen;
-    private armReadyFallback;
-    private clearReadyFallback;
-    /**
-     * Record the agent's phase and notify only on a real change.
-     *
-     * The change guard is load-bearing, not an optimisation: the scrape pass runs
-     * on every chunk, so an unguarded setter would fire the callback — and the
-     * WS frame behind it — several times a second for the entire duration of a
-     * turn while reporting the same value.
-     */
-    private setPhase;
-    private markReady;
-    private handleExit;
-}
-
-interface ConversationWatcherEvents {
-    /** Fires once per new newline-terminated line appended to a watched file. */
-    onNewLine?: (filePath: string, line: string) => void;
-    /**
-     * Fires once per chokidar read with ALL new lines from that read, batched.
-     * When set, it REPLACES the per-line onNewLine dispatch for that file —
-     * callers pick one. Lets a burst of appended lines collapse into a single
-     * downstream cache write + WebSocket broadcast.
-     */
-    onNewLines?: (filePath: string, lines: string[]) => void;
-    /**
-     * Like onNewLines but also carries each line's absolute byte span in the
-     * file (for the offset index). Fires ALONGSIDE onNewLines/onNewLine (it does
-     * not replace them) so the cache tail write and the index extend can both
-     * consume the same read. `readFrom` is the absolute byte offset the read
-     * started at; `spans` are complete lines only (a torn trailing line is held
-     * for the next read).
-     */
-    onNewLineSpans?: (filePath: string, spans: LineSpan[], readFrom: number, endOffset: number) => void;
-    /** Fires when chokidar reports an add/change/unlink at the directory level. */
-    onConversationChanged?: (filePath: string) => void | Promise<void>;
-    /** Fires when a tailed file is deleted (per-file watcher unlink event). */
-    onFileDeleted?: (filePath: string) => void;
-    /**
-     * Fires when a tailed file shrank below our read offset (in-place truncation
-     * or replacement by a shorter file). The tail has already reset to byte 0;
-     * the consumer must discard any byte-offset index built for the old content,
-     * which no longer describes this file.
-     */
-    onTruncated?: (filePath: string) => void;
-    /** Reported errors per file. */
-    onError?: (filePath: string, error: Error) => void;
-}
-/**
- * Chokidar-backed replacement for src/file-watcher.ts.
- *
- *   - watch(filePath)      → tail a single JSONL file, emitting onNewLine
- *                            for each appended line.
- *   - watchDirectory(dir)  → mark cache dirty on add/change/unlink events
- *                            for any file inside the directory.
- *
- * Per the refactor plan, file watching is an OPTIMIZATION; correctness
- * still relies on refresh=1 / the latest HDD conversation id check.
- */
-declare class ConversationWatcher {
-    private files;
-    private directories;
-    private onNewLine;
-    private onNewLines;
-    private onNewLineSpans;
-    private onConversationChanged;
-    private onFileDeleted;
-    private onTruncated;
-    private onError;
-    constructor(events?: ConversationWatcherEvents);
-    watch(filePath: string): void;
-    unwatch(filePath: string): void;
-    /**
-     * Re-drive the tail read for a file that's already being tailed. A per-file
-     * chokidar handle can die silently (fs.watch stops firing after inode churn)
-     * while the coarser directory watcher keeps reporting changes — calling this
-     * from the directory-event path makes the tail self-healing. Reads are
-     * offset-based and coalesced, so a redundant poke after a normal change
-     * event is a cheap stat + no-op. Returns false for untailed paths.
-     */
-    poke(filePath: string): boolean;
-    /**
-     * Watch a directory of conversation JSONL files. Fires
-     * onConversationChanged for any add/change/unlink event so the caller
-     * can mark the cache dirty without scanning everything immediately.
-     *
-     * **This costs one OS watch handle per file under `directory`, not one per
-     * directory.** chokidar recurses the tree and registers a separate fs.watch
-     * per entry, because a directory watch alone does not report writes to files
-     * inside it — and per-file `change` events are exactly what the caller needs
-     * (they drive poke()'s tail self-heal and the external-tail attach). So the
-     * handle count tracks the size of the conversation corpus on disk, not the
-     * number of live sessions, and it does not shrink until transcripts are
-     * deleted. `ignoreInitial` suppresses the startup *events*, not the walk.
-     *
-     * Measured 2026-08-09 on the live macOS instance: 2131 open .jsonl fds
-     * against 2133 files under the watched roots — 1:1, ~88% of all fds on the
-     * process, at 2.0% of that box's 122 880 per-process ceiling. Comfortable
-     * there. **Linux is the tight one**: these are inotify watches billed to the
-     * per-user `max_user_watches`, which can be 8192 and is shared with every
-     * other watcher the user runs. Exhaustion surfaces as ENOSPC on the `error`
-     * event — which is why server.ts wires onError rather than leaving it unset.
-     *
-     * Before trading handles for a bound here, note the regression it invites: a
-     * conversation excluded from the walk (by age or by an LRU cap) is one whose
-     * external appends produce no event at all, and that failure is silent.
-     */
-    watchDirectory(directory: string): void;
-    unwatchDirectory(directory: string): void;
-    dispose(): void;
-    private readNewLines;
-}
-
-declare class StreamerServer {
-    private httpServer;
-    private ptyManager;
-    private sessionStore;
-    private wsHub;
-    private fileWatcher;
-    private sessionFileMap;
-    private externalTails;
-    private externalTailManager;
-    private pendingLineSeqs;
-    private pendingQuestions;
-    private contendedSessions;
-    private selfPtyEndedAt;
-    private pendingQuestionKey;
-    private pendingPermission;
-    private pendingPermissionKey;
-    private scannerManager;
-    private sessionWatchers;
-    private registryBoot;
-    private conversationHandlers;
-    private sessionHandlers;
-    private binding;
-    private activeWarmups;
-    private nextWarmupId;
-    private inFlightCacheWrites;
-    private apiKey;
-    private apiKeySource;
-    private localNoAuth;
-    private logMenubarRequests;
-    private verbose;
-    private scanProfiles;
-    private dbPool;
-    private dbInstanceId;
-    private disableDb;
-    private host;
-    private skipStartupWarmup;
-    private autoResumeOnBoot;
-    private browseRoot;
-    private publicUrl;
-    private browserCors;
-    private pairTokens;
-    private exchangeAttempts;
-    private sessionStartAttempts;
-    private sessionInputAttempts;
-    private ptyGracePeriodMs;
-    private defaultSystemPrompt;
-    private featureFlags;
-    private featureFlagSources;
-    private codexSystemPromptEnabled;
-    private defaultPermissionMode;
-    private defaultModel;
-    private defaultEffort;
-    private claudeFlags;
-    private claudeExtraArgs;
-    private claudeFlagsPersistable;
-    private ptyGraceTimers;
-    private ptyGraceDeferCounts;
-    private sessionSubscribers;
-    private lastAgentChunkAt;
-    private terminalSeq;
-    private idempotency;
-    private sessionVerdicts;
-    private idleReaperTimer;
-    private clientIdToWs;
-    private wsToClientId;
-    private cache;
-    private cacheMonitor;
-    private projectsRepo;
-    private conversationsRepo;
-    private sessionsRepo;
-    private managedSessionsRepo;
-    private runtimeStore;
-    private readonly streamerInstanceId;
-    private cacheMetadataRepo;
-    private pushRepo;
-    private devicesRepo;
-    private apnsClient;
-    private liveActivityNotifier;
-    private liveActivityRenewal;
-    private waitingInputNotifier;
-    private discoveryCache;
-    private discoveryInFlight;
-    private cacheDir;
-    private runtimeDbPath;
-    private tailSize;
-    private directoryDebounceMs;
-    private codexRoots;
-    private includeAgents;
-    private agentEntrypoints;
-    private honoApp;
-    private log;
-    private agentConfig;
-    private agentClient;
-    private sessionStatusBus;
-    constructor(config: ServerConfig & {
-        apiKey: string;
-    });
-    private ptyAttachedIds;
-    private rememberSelfPtyEnded;
-    /**
-     * Send a session_list to only the client that triggered this HTTP request
-     * (identified by X-Client-Id header → registered WS socket). Falls back to
-     * a full broadcast if no match exists (old clients, or no WS registered yet).
-     */
-    private broadcastOrUnicastSessionList;
-    private sessionListPayload;
-    /**
-     * Overlay boot-reconciliation verdicts onto session responses.
-     *
-     * A session left by a previous run is not in the in-memory store, so
-     * SessionStore cannot classify it — it only ever sees what this run spawned.
-     * Discovery may still surface the process, in which case the reconciler knows
-     * strictly more about it than discovery does: it can tell `detached` (alive
-     * and confirmed ours) from `orphaned` (alive but identity unconfirmed), which
-     * a pid enumeration alone cannot.
-     *
-     * Only applied when the session is NOT live here: a session this run owns has
-     * an authoritative lifecycle already, and a stale verdict must never override
-     * it.
-     */
-    private withReconciledLifecycle;
-    private addSessionSubscriber;
-    /**
-     * Bring up Live Activity push, if credentials are present (Feature 12).
-     *
-     * APNS_KEY absent is the ordinary case on a dev machine and in CI, so this
-     * logs once at info and leaves the feature off rather than failing: the server
-     * must not refuse to boot over a missing optional push credential.
-     *
-     * The key is read from the environment as PEM contents and never from a path
-     * on disk; neither it nor any device token is ever logged.
-     */
-    private initLiveActivityPush;
-    /**
-     * Bring up "your turn" notifications over Expo's relay (#528).
-     *
-     * Unconditional, unlike Live Activity push: Expo holds the app's APNs and FCM
-     * credentials, so a self-hosted streamer needs no credential of its own. The
-     * access token is optional and only relevant if the Expo project has enhanced
-     * security enabled — requiring one would lock out every self-hoster, since
-     * they do not own the project. It is never logged.
-     */
-    private initWaitingInputPush;
-    /** Whether any live socket is subscribed to this session — "someone is looking". */
-    private hasSessionSubscriber;
-    /**
-     * Release PTYs whose agent has been silent past IDLE_REAP_AFTER_MS.
-     *
-     * This is the bound that lets handleWsClose stop arming kill timers. The
-     * distinction that matters: the old timer measured how long nobody was
-     * *watching*, which is uncorrelated with whether work is in flight. This
-     * measures how long the *agent* has produced nothing, and only ever considers
-     * sessions that are already settled — a `running` PTY is skipped regardless of
-     * age, so a long silent turn is never interrupted.
-     *
-     * Exposed (not private) so tests can drive one sweep deterministically instead
-     * of waiting on the interval.
-     */
-    reapIdleSessions(now?: number): string[];
-    private startGraceTimer;
-    get port(): number;
-    private currentWarmupState;
-    private beginWarmup;
-    private finishWarmup;
-    private withWarmup;
-    private rejectIfWarmingUp;
-    /**
-     * Say which provider CLIs this machine can actually launch.
-     *
-     * The operator cannot discover this case unaided: under launchd/Task
-     * Scheduler the service inherits a stripped PATH, so a CLI that works
-     * perfectly in their terminal is invisible to the service, and every session
-     * start dies milliseconds in. `/api/diagnostics` answers it too, but only for
-     * someone who already suspects it.
-     *
-     * Availability only, never a version — `--version` costs a process spawn per
-     * provider (85ms for claude here) and belongs on the first request that wants
-     * it, not on boot.
-     *
-     * Called AFTER the port is bound, which is not cosmetic. This is the first
-     * caller of the exe resolvers in the process, so the memo is cold by
-     * definition and each provider pays one synchronous `which` / `where.exe`
-     * (platform.ts) with a 3s timeout. On POSIX that is 3ms found, 7ms missing.
-     * Windows is the risk — `where.exe` is slower, `execFileSync` blocks the
-     * event loop, and Task Scheduler's stripped PATH is exactly where a miss
-     * pays the full timeout — so the worst case is ~6s of two blocking lookups.
-     * After `listen()` that delays the first requests on a box that cannot start
-     * a session anyway; before it, it would have delayed binding the port.
-     */
-    private logProviderAvailability;
-    listen(port: number, opts?: {
-        awaitReady?: boolean;
-    }): Promise<void>;
-    private bindWithRetry;
-    private bindWithRetryLoop;
-    private trackCacheWrite;
-    close(): Promise<void>;
-    private handleRequest;
-    private handlePairStart;
-    private handlePairExchange;
-    private rotateApiKey;
-    /**
-     * The registry ships with the values so a client renders the list from one
-     * round-trip, same as getClaudeFlagsConfig().
-     *
-     * Deliberately no `persisted` field: unlike claude-flags there is no PUT, and
-     * the absence of that field is the signal that this endpoint is read-only.
-     */
-    private getFeatureFlagsConfig;
-    private getClaudeFlagsConfig;
-    /**
-     * Replace the per-server flag set. Applies to the NEXT spawn — a live PTY
-     * keeps the argv it was started with.
-     *
-     * Mirrors rotateApiKey(): when the values were pinned by a CLI flag we still
-     * apply them in memory but skip the server.yaml write, because the flag would
-     * win again on restart and silently revert them.
-     *
-     * Logged with old→new at info level on purpose: this can disable the
-     * permission prompts entirely, so it needs a forensic trail.
-     */
-    private setClaudeFlagsConfig;
-    /**
-     * The three spawn options that a configured claude-flag can override, with
-     * the boot-time CLI/yaml default as the fallback. Spread into every
-     * start/resume/adopt call so all three paths agree.
-     *
-     * These ids are excluded from buildFlagArgs (SPAWN_POSITIONAL_FLAG_IDS)
-     * precisely because they arrive here instead — the PTY spawn paths pass them
-     * as explicit positionals, so emitting them from the allowlist too would
-     * duplicate the flag.
-     *
-     * Narrowed with the type guards rather than cast: ClaudeFlagValues is a loose
-     * Record by design, and while validateFlagValues already guarantees the shape
-     * on the way in, TypeScript cannot see that through the record.
-     */
-    private spawnFlagOverrides;
-    private checkRateLimit;
-    private checkExchangeRateLimit;
-    private checkSessionStartRateLimit;
-    private checkSessionInputRateLimit;
-    private handleSessionsCount;
-    /**
-     * Live Codex sessions keep `SessionResponse.conversationId === managed.id`
-     * (stable deep-link / PTY key) and store the rollout UUID separately as
-     * `boundConversationId`. REST history is indexed under the rollout UUID, so
-     * resolve the placeholder → bound id before looking up the scanner.
-     */
-    private resolveConversationLookupId;
-    /** File path for a live managed session (placeholder id or bound Codex id). */
-    private findLiveSessionFilePath;
-    /** True when a conversation UUID is the bound rollout of a live PTY session. */
-    private isBoundConversationLive;
-    /**
-     * Broadcast conversation JSONL lines to WS clients. Codex rollout lines are
-     * normalized to the Claude `type:user|assistant` shape mobile understands;
-     * Claude lines pass through unchanged so seq alignment stays intact.
-     */
-    private broadcastConversationLines;
-    /**
-     * Resolve a client-supplied session/conversation id into everything needed to
-     * launch against it: the id the PROVIDER filed the history under, that
-     * history's path, the project cwd, and which CLI owns it.
-     *
-     * Shared by resume and fork so the two can never disagree about identity —
-     * which for Codex is the whole difficulty: the id a client navigated to may
-     * be a local placeholder, and only the registry knows the rollout id behind
-     * it.
-     */
-    private resolveConversationTarget;
-    /**
-     * Block until a freshly spawned session reaches `waiting_input` (ready) or
-     * `idle` (failed), or until `timeoutMs` elapses with the process still alive.
-     *
-     * "timeout" is not an error: it is the pre-existing asynchronous contract —
-     * the session keeps booting and the caller answers with a pending shape.
-     */
-    private waitForStartupOutcome;
-    /**
-     * Drop every trace of a managed session: in-memory store, durable registry
-     * row, and the collision-probe markers that would otherwise outlive it.
-     *
-     * Used when a start never became usable (`abandonFailedStart`) and when stop
-     * is asked to discard an empty session that has no cached conversation. The
-     * registry delete is load-bearing — `rehydrateSessions` will bring the row
-     * back on the next boot if it remains.
-     *
-     * Callers that kill the PTY (`putOnHold`) must do that *first*: onStatusChange
-     * on idle writes `selfPtyEndedAt` and a registry status, and those have to
-     * be cleared here afterwards.
-     */
-    private forgetSession;
-    /**
-     * Drop every trace of a session that never became usable.
-     *
-     * The runner has already torn itself down (failStartup / handleExit); what
-     * remains is server-side bookkeeping that would otherwise leave a dead
-     * session in the list, a registry row claiming a spawn, and a `selfPtyEndedAt`
-     * marker that would suppress the mtime collision signal on the NEXT resume —
-     * i.e. it would help hide the very owner we just collided with.
-     */
-    private abandonFailedStart;
-    private enrichResumedSessionAsync;
-    private processJsonlQuestions;
-    private cancelPendingQuestion;
-    private handleBrowse;
-    private handleMkdir;
-    /**
-     * Retarget a LIVE session's model or effort by typing the corresponding
-     * Claude Code slash command into its PTY.
-     *
-     * There is no CLI or IPC channel for this — `--model`/`--effort` are spawn
-     * arguments — so the interactive `/model <x>` / `/effort <y>` commands are the
-     * only way to change a session already running. Both accept an argument and
-     * apply it without opening the picker (verified against Claude Code v2.1.220).
-     *
-     * Answers 202, not 200: the value is applied by the TUI on its next render, so
-     * there is nothing truthful to echo back synchronously. Clients confirm with
-     * `GET /api/sessions/:id`, which scrapes the applied value off the live status
-     * line.
-     */
-    private applyLiveSessionSetting;
-}
-
-export { type AgentClient, type AgentClientOpts, type AgentConfig, type AgentPhase, type AppendArgs, type AskOption, type AskQuestion, CLAUDE_CODE_PROVIDER, CODEX_CLI_PROVIDER, type CacheAlertResolveAction, type ConversationListResponse, ConversationWatcher, type ConversationWriter, type DbConfig, type DiscoveredProcess, LiveSessionManager, type ManagedSession, PTYManager, type PTYManagerOptions, type PermissionOption, type ProcessLiveness, type ProgressDedupeLRU, type ProviderName, type ServerConfig, type ServerWarmingUpResponse, type ServerWarmupState, type SessionActivity, type SessionCursor, type SessionLifecycle, type SessionListPage, type SessionListQuery, type SessionOwnership, type SessionResponse, type SessionRunner, type SessionSortKey, type SessionStatus, SessionStore, type SortOrder, type StartForkSessionOptions, type StartFreshSessionOptions, type StartSessionOptions, type StatusConfidence, type StatusSource$1 as StatusSource, StreamerServer, type UserMessage, WSHub, type WSMessage, confidenceForSource, createAgentClient, createConversationWriter, createPool, createProgressDedupeLRU, createProgressRoutes, discoverClaudeProcesses, generateApiKey, getDbConfig, isDbEnabled, isProviderName, isProviderResumable, loadOrCreateApiKey, maskConnectionString, readAgentConfig, validateApiKey };
+export { type AgentClient, type AgentClientOpts, createAgentClient, } from "./agent/agent-client";
+export { type AgentConfig, readAgentConfig } from "./agent/agent-config";
+export { type AppendArgs, type ConversationWriter, createConversationWriter, } from "./agent/conversation-writer";
+export { createProgressDedupeLRU, type ProgressDedupeLRU } from "./agent/dedupe";
+export { createProgressRoutes } from "./api/routes/progress.routes";
+export { generateApiKey, loadOrCreateApiKey, validateApiKey } from "./auth";
+export type { DbConfig } from "./db";
+export { createPool, getDbConfig, isDbEnabled, maskConnectionString } from "./db";
+export { LiveSessionManager } from "./live-session-manager";
+export { discoverClaudeProcesses } from "./process-discovery";
+export { CLAUDE_CODE_PROVIDER, CODEX_CLI_PROVIDER, isProviderName, isProviderResumable, type ProviderName, } from "./providers";
+export { PTYManager } from "./pty-manager";
+export { StreamerServer } from "./server";
+export { ConversationWatcher } from "./services/conversations/conversationWatcher";
+export { SessionStore } from "./session-store";
+export * from "./types";
+export { WSHub } from "./ws-hub";
+//# sourceMappingURL=index.d.ts.map