@artenx/dshb 0.1.18 → 0.1.20

package/lib/session-sync-g6qKZzjV.d.ts

@@ -0,0 +1,1252 @@
+import { o as NodeRegistry } from "./node-registry-BTnnM5-k.js";
+import { r as WorkspaceBindingsStore } from "./workspace-bindings-CsB0TIJB.js";
+import { r as SyncRevision } from "./revision-C9sOlDZ6.js";
+import { d as SyncSessionArchive, i as SyncOrigin, l as SyncRecordMetadata, r as SyncImportMethod } from "./model-BP7Gw1yk.js";
+import { n as SyncStateStore } from "./stores-CKyEt0yk.js";
+import { s as SyncNodeService } from "./node-sync-3Z9QLz2n.js";
+import { S as BrandedNumber, _ as FileAttachmentRef, a as SystemPromptUpdate, b as TypertResource, c as ToolSchema, d as Message, f as SystemMessage, g as ToolCallId, i as LlmFailure, l as AssistantMessage, m as UserMessage, n as LlmCallConfig, o as TokenUsage, p as ToolResultMessage, r as LlmCallConfigAdapterDefaults, s as ToolHistory, t as AssistantStreamRecord, u as DeveloperMessage, v as ImageAttachmentRef, x as Branded, y as TypertLookup } from "./index-VF8bcBeX.js";
+import { a as SessionInstructionSnapshotStore } from "./workspace-instructions-DirYYiku.js";
+import { t as SyncSessionJournalStore } from "./session-journal-pgPqcWn9.js";
+import { Context, Service } from "@deepseek-ai/cordis";
+//#region ../../node_modules/@deepseek-ai/dsh-scope/lib/types/index.d.ts
+declare const ScopedBrand: unique symbol;
+/**
+ * A routing-only event receiver built by {@link scopeTarget}. The type
+ * parameter records the subject type for dispatch checking; the carrier does
+ * not expose the subject's properties. Event payloads carry the real subject.
+ */
+type Scoped<T extends object> = object & {
+  readonly [ScopedBrand]: T;
+};
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-util-values/lib/types/index.d.ts
+/** Duplicate-install-safe JSON and immutable-value helpers. @module @deepseek-ai/dsh-util-values */
+/** A value that round-trips through JSON without loss. */
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-session/lib/types/types.d.ts
+/** Identifies one session in the store (and its persistence artifacts). */
+type SessionId = Branded<'SessionId'>;
+/**
+ * Brand a string as a {@link SessionId}.
+ * @param id - the raw session id string.
+ * @returns the same string with the session-id brand.
+ */
+declare function SessionId(id: string): SessionId;
+/** Sequence number of one existing event in a Session log. */
+type SessionSeq = BrandedNumber<'SessionSeq'>;
+/**
+ * Admit a numeric value as an existing Session event position.
+ * @param value - non-negative safe integer admitted by the owning log operation.
+ * @returns the same number with the Session-sequence brand.
+ */
+declare function SessionSeq(value: number): SessionSeq;
+/** A Session log gap, prefix length, or read offset, which may equal the event count. */
+type SessionLogOffset = BrandedNumber<'SessionLogOffset'>;
+/**
+ * Admit a numeric value as a Session log offset.
+ * @param value - non-negative safe integer used as a gap or prefix length.
+ * @returns the same number with the Session-log-offset brand.
+ */
+declare function SessionLogOffset(value: number): SessionLogOffset;
+/**
+ * Current logical Session format version, stamped into every newly written
+ * {@link SessionHeader}. Current Session and persistence code accept only this
+ * value; header-only readers classify supported historical formats, while an
+ * event-body read composes the build-static adjacent chain and publishes only
+ * this final generation before constructing a Session.
+ *
+ * The version is a single monotonic integer with no major/minor split. Retain
+ * it when older readers resume correctly, preserve safely ignorable records,
+ * or refuse required features before execution, mutation, or tail repair.
+ * New readers must preserve historical meanings, including logs mixing old
+ * and new record representations. Bump when an existing discriminator cannot
+ * prevent unsafe interpretation; a structural difference alone is insufficient.
+ * Unknown fields and values require evidence of the released reader's actual
+ * admission behavior. The per-event {@link SessionEvent.ignorable} marker
+ * governs unknown event types, not arbitrary nested payload changes.
+ * Same-version readers retain earlier representations: the adjacent migration
+ * chain does not run when stored and current versions match. A subsequent
+ * migration must account for all supported representations of its source.
+ * Compatibility review and the retained migration obligations are recorded in
+ * `.agents/notes/implemented/process/2026-10-08-session-reader-compatibility-review.md`.
+ */
+declare const SESSION_FORMAT_VERSION = 4;
+/**
+ * Immutable validated storage metadata, kept outside the conversation event log.
+ */
+interface SessionHeader {
+  /**
+   * Current logical format version, stamped from {@link SESSION_FORMAT_VERSION}.
+   * Historical physical headers are translated before entering this interface.
+   */
+  readonly version: typeof SESSION_FORMAT_VERSION;
+  /** The session's id (mirrors the {@link Session}'s id). */
+  readonly id: SessionId;
+  /** Non-negative safe-integer Unix epoch milliseconds when the session was created. */
+  readonly createdAt: number;
+  /** Absolute working directory the session was created in (if any). */
+  readonly cwd?: string;
+  /** The session this one was forked from (seed lineage), if any. */
+  readonly parentSession?: SessionId;
+  /**
+   * Whether this Session contains a fork-inherited event prefix. The exact prefix
+   * length is Session state rather than ordinary header metadata.
+   */
+  readonly isSeeded: boolean;
+  /**
+   * Coarse product classification for a session created as a subagent child.
+   * This is presentation metadata, not proof that the child is continuable.
+   */
+  readonly origin?: 'subagent';
+  /**
+   * Delegation depth: absent (zero) for a top-level session, parent depth + 1
+   * for a subagent child. Persisted so a recursion budget survives restart and
+   * resume — a runtime-only depth would reset a resumed child to top-level.
+   */
+  readonly delegationDepth?: number;
+  /**
+   * Id of the agent preset this session's agent was composed from, when the
+   * deployment composes per session. Durable because the preset decides the
+   * session's tools and prompt: a resume that restored a different composition
+   * would replay history the model can no longer act on.
+   */
+  readonly agentPreset?: string;
+}
+/**
+ * Options for creating a {@link Session} via the store. `seed` replays/forks
+ * an existing event log; `meta` carries the caller-supplied storage fields the
+ * store folds into a {@link SessionHeader}.
+ */
+interface CreateSessionOptions {
+  /** Initial replay or fork history supplied at construction. */
+  readonly seed?: readonly SessionEvent[];
+  /**
+   * Exact fork-inherited prefix length when `meta.isSeeded` is true. The
+   * constructor appends the child-owned tagged marker at the cut unless
+   * the seed already includes it followed by child-owned fork closers.
+   */
+  readonly inheritedEventCount?: SessionLogOffset;
+  /**
+   * Storage metadata read once before publication. `isSeeded` marks fork
+   * lineage; supplying replay history alone does not make it inherited.
+   */
+  readonly meta?: {
+    readonly cwd?: string;
+    readonly parentSession?: SessionId;
+    readonly createdAt?: number;
+    readonly isSeeded?: boolean;
+    readonly origin?: 'subagent';
+    readonly delegationDepth?: number;
+    readonly agentPreset?: string;
+  };
+}
+/**
+ * Aliasing state of an adoptable Session seed. `shared-frozen` permits deeply
+ * frozen aliases plus independently owned unfrozen values in the same seed.
+ */
+type SessionSeedEventState = 'detached' | 'shared-frozen';
+/**
+ * Adoptable storage values transferred to {@link SessionStore.prepare}
+ * without another copy or freeze pass.
+ */
+interface RestoredSessionOptions {
+  /** Events that are independently owned or already deeply frozen. */
+  readonly seed: SessionEvent[];
+  /** Independently owned storage metadata to validate and freeze in place. */
+  readonly meta: SessionHeader;
+  /** Exact number of fork-inherited leading events decoded from storage. */
+  readonly inheritedEventCount: SessionLogOffset;
+  /** Aliasing state carried from the operation that produced the seed. */
+  readonly eventState: SessionSeedEventState;
+}
+/** Inputs accepted while constructing an unpublished Session. */
+type PrepareSessionOptions = (CreateSessionOptions & {
+  readonly eventState?: undefined;
+}) | RestoredSessionOptions;
+/** Why an active agent driver was cancelled. */
+type AgentCancelCause = {
+  readonly kind: 'user';
+} | {
+  readonly kind: 'parent';
+} | {
+  readonly kind: 'hook';
+  readonly reason: string;
+} | {
+  readonly kind: 'disposed';
+};
+/** Durable cancellation cause, including imports whose original coarse record carried no cause. */
+type TurnEndCancelCause = AgentCancelCause | {
+  readonly kind: 'legacy';
+};
+/**
+ * Why a turn ended. Merge-extensible sum type.
+ */
+interface TurnEndReasonMap {
+  completed: {
+    kind: 'completed';
+  };
+  /** A cancellation request interrupted the live turn. */
+  aborted: {
+    kind: 'aborted';
+    reason: TurnEndCancelCause;
+  };
+  blocked: {
+    kind: 'blocked';
+  };
+  /**
+   * The turn failed. `error` is always a structured failure: the `LlmError`
+   * facts verbatim, or `{ message: errorChain(error), code: 'UNKNOWN' }`
+   * flattened from any other error.
+   */
+  error: {
+    kind: 'error';
+    error: LlmFailure;
+  };
+  /** At least one step reached its output-token ceiling, even if a plugin continued the turn. */
+  'max-tokens': {
+    kind: 'max-tokens';
+  };
+  /**
+   * A crash-orphaned turn was closed after the fact: agent-loop resume appends
+   * this closer for a stored log whose last turn never ended, and session-query
+   * synthesizes it on cold reads. The loop never emits this marker live, and
+   * the events recorded before the crash remain intact.
+   */
+  interrupted: {
+    kind: 'interrupted';
+  };
+  /**
+   * Fork-seed construction closed a turn that was still open at the fork
+   * boundary in the source session. Only fork seeds carry this marker — the
+   * loop never emits it — and the source events before the boundary remain
+   * intact in the child.
+   */
+  forked: {
+    kind: 'forked';
+  };
+}
+/** The union over {@link TurnEndReasonMap} — why a turn ended; plugins extend it by merging variants into the map. */
+type TurnEndReason = TurnEndReasonMap[keyof TurnEndReasonMap];
+/**
+ * Logged request state outside derived history: call config and tools. The
+ * system prompt is derived history — surface node 0, a `system/message` event.
+ * The latest full `request/header` snapshot reconstructs the header; canonical
+ * empty optional fields are absent.
+ */
+interface EpochHeader {
+  /** The conversation's call configuration (provider, model, reasoning effort, and sampling scalars). */
+  config: LlmCallConfig;
+  /** Effective config fields materialized from the exact adapter rather than proposed by a caller. */
+  adapterDefaults?: LlmCallConfigAdapterDefaults;
+  /** Assembled tool schemas; absent for a tool-less request. */
+  tools?: ToolSchema[];
+  /** Retired request text; system prompts belong to system/message events.
+   * @persistenceReserved
+   */
+  system?: never;
+}
+/** Registration-bound metadata for one resolved model route. */
+interface RequestContext {
+  /** Registered provider route the metadata belongs to. */
+  provider: string;
+  /** Provider-owned model id the metadata belongs to. */
+  model: string;
+  /** Maximum combined request and response context in tokens, when advertised. */
+  contextWindow?: number;
+  /** `'in-history'` when the route reads the latest `system` message at any position as the effective system prompt. */
+  systemPromptUpdate?: SystemPromptUpdate;
+}
+/**
+ * Why a `request/header` snapshot was appended: `'initial'` — the log's first
+ * header (a new conversation); `'resume'` — a loop instance's first request
+ * over a log that already has header events (process restart, fork seed);
+ * `'change'` — a later request used a different header; `'series'` — an unchanged
+ * header began an explicitly distinct message series or followed a surface
+ * replacement. Other reasons carry `startsSeries` when a new series coincides.
+ */
+type RequestHeaderReason = 'initial' | 'resume' | 'change' | 'series';
+/**
+ * The merge-extensible, append-only source of truth for an agent interaction.
+ * Message history is derived from this log. Every event is lossless JSON and
+ * sequence numbers stay contiguous. Assistant attempt events embed their exact
+ * compact raw streams so persistence stores one durable settlement per attempt.
+ */
+interface SessionEventMap {
+  /**
+   * Opens turn `turn` before the loop claims queued input or runs pre-step.
+   * Rejection, empty input, cancellation, or failure may close it with no
+   * step; otherwise the following identified `user/message` event or batch
+   * records the messages entering the step.
+   */
+  'turn/start': {
+    turn: number;
+  };
+  /**
+   * Closes turn `turn` with the {@link TurnEndReason} that ended it. A turn
+   * with no entered step has no `step/start` or `step/end`. The loop does not await a
+   * flush at turn boundaries: `dsh-session-checkpoint-policy` owns the
+   * per-request durability checkpoint, and consumers that read storage after
+   * `whenIdle()` flush themselves. Success commits the turn; rejection is
+   * reported live and does not prevent later work.
+   */
+  'turn/end': {
+    turn: number;
+    reason: TurnEndReason;
+  };
+  /** Opens step `step` of turn `turn` — one model call plus the tool executions it requested. */
+  'step/start': {
+    turn: number;
+    step: number;
+  };
+  /** Closes step `step` of turn `turn`. */
+  'step/end': {
+    turn: number;
+    step: number;
+  };
+  /**
+   * A user-role message on the model-visible surface: a direct human prompt
+   * (the queued message claimed for this turn), a synthetic `agent.inject()`
+   * context (file-change notices, subdir AGENTS.md, skill content, cron
+   * notifications, …), or an entered goal continuation round. All three
+   * project their `content` verbatim; `source` tells them apart.
+   */
+  'user/message': UserMessage;
+  /** An incremental agent session change admitted at the named turn and step. */
+  'developer/message': {
+    turn: number;
+    step: number;
+    message: DeveloperMessage;
+    /** Earlier request/header defining every tool addition; required exactly when additions are present. */
+    headerSeq?: SessionSeq;
+  };
+  /**
+   * The rendered system prompt on the model-visible surface. The loop appends
+   * the first one as surface node 0 before the step's first `user/message`.
+   * A prepared in-history route can append nonempty changes in a continuing
+   * series. An incapable route or new series normalizes text to the first system
+   * node. Normalization empties nonempty later nodes, then rewrites the head if
+   * needed, through logged per-node replacements. An empty rendering always
+   * clears all active system nodes, leaving no older instructions model-visible.
+   * Empty later nodes are dormant and project to no message; an empty head with
+   * no active later node records "no system prompt". Restored nonempty text follows
+   * the same route and series rule; empty nodes never restore older text.
+   */
+  'system/message': {
+    turn: number;
+    step: number;
+    message: SystemMessage;
+  };
+  /**
+   * Assembled assistant message for one step (derived history uses this).
+   * Carries the step's `usage` when the adapter reported token accounting, so
+   * the model output and its accounting travel together (there is no separate
+   * usage record). `usage` is absent when the adapter reported none. A turn
+   * cancelled mid-stream finalizes its delivered text/reasoning prefix as this
+   * event with `interrupted: true`; undispatched tool calls are absent. The
+   * marker distinguishes that prefix without re-deriving interruption from turn
+   * boundaries. An aborted turn with no such event streamed no visible content.
+   */
+  'assistant/message': {
+    turn: number;
+    step: number;
+    message: AssistantMessage;
+    /** Exact timed model stream, compacted without joining delta boundaries. */
+    stream: AssistantStreamRecord[];
+    usage?: TokenUsage;
+    interrupted?: true;
+  };
+  /**
+   * One model attempt that committed no surface message. The embedded stream
+   * preserves a failed, retried, cancelled, or stream-error attempt that
+   * reached settlement without fabricating model-visible history.
+   */
+  'assistant/attempt': {
+    turn: number;
+    step: number;
+    stream: AssistantStreamRecord[];
+  };
+  /**
+   * The model requested one tool invocation: `name` with the raw `arguments`
+   * JSON string exactly as the model produced it (unparsed). `callId` pairs the
+   * call with its `tool/result`.
+   */
+  'tool/call': {
+    turn: number;
+    step: number;
+    callId: ToolCallId;
+    name: string;
+    arguments: string;
+  };
+  /**
+   * A completed tool call's model-facing result, optional internal failure
+   * identity and user-facing reason, and optional tool-private `meta`
+   * presentation payload. The reason remains outside the model-facing message.
+   * `meta` is
+   * opaque to the core (the producing tool owns its shape and reads it back in
+   * `presentResult`) but MUST be JSON-serializable: `Session.append`
+   * runtime-validates all event data with `isJsonValue`, so a non-serializable
+   * `meta` is rejected at the source, and the durable log reproduces the
+   * identical card on replay. Absent
+   * unless the tool attaches one (e.g. `dsh-tool-fs` carries its result-time
+   * contextual diff here).
+   */
+  'tool/result': {
+    turn: number;
+    step: number;
+    message: ToolResultMessage;
+    /**
+     * Optional failure identity and raw user-facing reason, outside model content;
+     * allowed only when the message has `isError: true`.
+     */
+    error?: {
+      name: string;
+      code: string;
+      reason?: string;
+    };
+    meta?: JsonValue;
+  };
+  /**
+   * Full header for the next request, appended inside its step before dispatch.
+   * It is log-only; the latest snapshot reconstructs the request header.
+   */
+  'request/header': {
+    header: EpochHeader;
+    reason: RequestHeaderReason;
+    /** This request begins a distinct model-message series, independently of the header reason. */
+    startsSeries?: true;
+  };
+  /**
+   * Route metadata for the next request, logged only when the route, capacity,
+   * or system prompt update mode changes. It does not participate in request
+   * reconstruction or header equality. Prompt admission uses the bound prepared
+   * call's capability, not this snapshot from an earlier request.
+   */
+  'request/context': RequestContext;
+  /**
+   * Separates inherited or restored history from later lifecycle-owned work.
+   * This log-only marker need not be at {@link Session.firstLiveSeq}: a fork
+   * seed can already contain its tagged marker and child-owned synthetic
+   * closers before construction.
+   *
+   * A fresh fork child owns one `{ inherited: true }` marker at its exact
+   * inherited-prefix cut, even when that prefix ends in an ancestor marker.
+   * `buildForkSeed` appends that marker before any synthetic closers; the
+   * `Session` constructor supplies it when given only the inherited prefix.
+   * The last tagged marker is the current Session's cut; untagged markers
+   * keep ordinary restore and replay lifecycle boundaries.
+   *
+   * Only the `Session` constructor and `buildForkSeed` may create this marker.
+   * Session append does not reject other writers, so a plugin appending one
+   * would silently classify every live bracket before it as seed history.
+   *
+   * An owner of a standalone open/close bracket (`compaction/start` …
+   * `compaction/end`) reads it because seed history and live work are otherwise
+   * byte-identical: an unmatched opening marker before this event belongs to
+   * an ended lifecycle, whatever ended it. NOT a liveness signal about other
+   * writers — a concurrently live session holds its own boundary elsewhere,
+   * so tolerating concurrent writers needs a signal beyond the log.
+   */
+  'session/end-seed': {
+    inherited?: true;
+  };
+}
+/** The appendable event-type keys of {@link SessionEventMap}, plugin-merged extensions included. */
+type SessionEventType = keyof SessionEventMap;
+/**
+ * The subset of {@link SessionEventType} values whose events produce LLM
+ * messages and are eligible to appear on the ordered surface. Only these
+ * event types may carry {@link SurfaceOp}; system, user, and tool events may also cite
+ * earlier sources through {@link SessionEvent.sourceEventSeqs}.
+ */
+type SurfaceEventType = 'system/message' | 'developer/message' | 'user/message' | 'assistant/message' | 'tool/result';
+/**
+ * How a session event entered the ordered surface. Only valid on
+ * {@link SurfaceEventType} events.
+ *
+ * - `'append'`: added to the tail — normal path for user/assistant/tool
+ *   messages.
+ * - `{ op: 'replace', startSeq, endSeq }`: replaces surface nodes from `startSeq`
+ *   (inclusive) through `endSeq` (inclusive) with this node. Both must exist as
+ *   surface nodes in the current surface. `startSeq === endSeq` replaces a single
+ *   node. The node's {@link SessionEvent.sourceEventSeqs} must include every
+ *   shadowed surface node. Used by compaction; any surface-replacing producer
+ *   may use it.
+ */
+type SurfaceOp = 'append' | {
+  op: 'replace';
+  startSeq: SessionSeq;
+  endSeq: SessionSeq;
+};
+/**
+ * Surface placement and cited source-event seqs for {@link Session.append}. Required on
+ * message-producing events and forbidden on log-only events.
+ */
+type SurfaceIntent<T extends SurfaceEventType = SurfaceEventType> = {
+  surfaceOp: SurfaceOp;
+} & (T extends 'assistant/message' ? {
+  /** Assistant messages embed their provider stream instead of citing source events. */
+  sourceEventSeqs?: never;
+} : {
+  /** Complete non-empty set of known earlier source-event seqs. */
+  sourceEventSeqs?: SessionSeq[];
+});
+/**
+ * One immutable entry in the session log.
+ *
+ * A proper discriminated union over `type` (not independent `type`/`data`
+ * unions), so `switch (event.type)` narrows `event.data` without casts.
+ *
+ * The {@link sourceEventSeqs} and {@link surfaceOp} fields are conditional:
+ * they only exist on {@link SurfaceEventType} variants (`system/message`, `user/message`,
+ * `assistant/message`, `tool/result`).
+ * Non-surface events (boundary markers, attempts, errors) never carry
+ * surface metadata — the compiler enforces this at `Session.append()`
+ * call sites.
+ */
+type SessionEvent<T extends SessionEventType = SessionEventType> = { [K in SessionEventType]: {
+  type: K;
+  /** Monotonic sequence number within the session. */
+  seq: SessionSeq;
+  /** Unix epoch milliseconds. */
+  time: number;
+  data: SessionEventMap[K];
+  /**
+   * Marks an event a reader may safely skip when it does not recognize
+   * `type`. Absent means required: a reader meeting an unrecognized type
+   * without this marker MUST refuse to reconstruct the session instead of
+   * silently dropping the event, because an unrecognized required event may
+   * change how the rest of the log is interpreted. A writer sets `true` only
+   * on purely informational records whose loss cannot affect reconstruction;
+   * defaulting to required means a forgotten marker over-refuses (an
+   * inconvenience) rather than silently resuming a gutted session.
+   */
+  ignorable?: true;
+} & (K extends SurfaceEventType ? SurfaceIntent<K> : {
+  surfaceOp?: never;
+  sourceEventSeqs?: never;
+}); }[T];
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertResourceMap {
+    /** One Session; the Session Controller registers its default `sessionId` wire field. */
+    session: TypertResource<SessionId>;
+  }
+  interface RemoteErrorDetailsMap {
+    /** The named Session does not exist; produced by every layer that resolves a SessionId. */
+    'session/not-found': {
+      readonly sessionId: SessionId;
+    };
+  }
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-session/lib/types/surface.d.ts
+/** Readonly history immediately before a message-projection event. */
+interface SessionMessageProjectionContext {
+  /** Current message-producing event sequences in model-visible order. */
+  nodes: readonly SessionSeq[];
+  /** Contiguous event window; entries at or beyond the candidate seq are not committed inputs. */
+  events: readonly SessionEvent[];
+  /** Absolute sequence of the window's first event. */
+  baseSeq: SessionLogOffset;
+  /** Previously projected messages keyed by their original event sequences. */
+  messages: ReadonlyMap<SessionSeq, Message>;
+}
+/** Pure interpretation of one plugin-owned event that changes existing message content. */
+interface SessionMessageProjection<T extends SessionEventType = SessionEventType> {
+  /** Event interpreted by this definition; declare it with `@messageProjection` in SessionEventMap. */
+  type: T;
+  /**
+   * Validate the complete durable decision before returning any updates. Preserve
+   * message identities and publish immutable copies without mutating the input.
+   * @param event - candidate event, not yet applied to the supplied history.
+   * @param context - history preceding this decision.
+   * @returns changed current messages keyed by their original sequences.
+   * @throws when the durable decision cannot be applied to this history.
+   */
+  project(event: SessionEvent<T>, context: SessionMessageProjectionContext): ReadonlyMap<SessionSeq, Message>;
+}
+/** Readonly live projection of the message-producing session events. */
+interface SessionSurface {
+  /** Current surface event sequences in model-visible order. */
+  readonly nodes: readonly SessionSeq[];
+  /** Monotonic count of committed positional replacements. */
+  readonly replaceGeneration: number;
+  /** Monotonic count of committed replacements and plugin-owned message changes. */
+  readonly contentGeneration: number;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-session/lib/types/index.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    sessions: SessionStore;
+  }
+  interface Events {
+    /**
+     * Creation announcement during session publication. A synchronous throw vetoes and rolls
+     * back with a paired disposal; detach requested during dispatch is deferred.
+     * A returned-promise rejection is logged but cannot retroactively veto this
+     * synchronous boundary.
+     * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners
+     * receive only sessions entered through that agent's context.
+     * @param session - the session just entered and announced.
+     * @mode emit
+     */
+    'session/created'(this: Scoped<Session>, session: Session): void;
+    /**
+     * Emitted once when an announced session leaves the store, including
+     * publication rollback, but never for an entry whose creation announcement
+     * did not begin. Listener failures are logged and contained.
+     * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`) reuses the owner scope.
+     * @param session - the session that is no longer live in the store.
+     * @mode emit
+     */
+    'session/disposed'(this: Scoped<Session>, session: Session): void;
+    /**
+     * Post-commit, fire-and-forget append feed. The listener snapshot resolves
+     * before the log push, but callbacks run after it; observer failures are
+     * logged and contained without making the committed append fail.
+     * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners
+     * receive only events from sessions entered through that agent's context.
+     * @param session - the session whose log grew.
+     * @param event - the appended event, exactly as recorded.
+     * @mode emit
+     */
+    'session/event'(this: Scoped<Session>, session: Session, event: SessionEvent): void;
+    /**
+     * Awaited parallel durability checkpoint: every listener runs and the
+     * caller awaits all of them, with no waterfall veto. Scope-filtered dispatch
+     * (`@deepseek-ai/dsh-scope`) reuses the session's owner scope.
+     * @param session - the session whose buffered events must reach durable storage.
+     * @mode parallel
+     */
+    'session/flush'(this: Scoped<Session>, session: Session): Promise<void> | void;
+  }
+}
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertLookupMap {
+    session: TypertLookup<Session, SessionId>;
+  }
+}
+/**
+ * An event-sourced session: an append-only log of {@link SessionEvent}s.
+ *
+ * Plain class (not a Service) — create live instances via
+ * `ctx.sessions.create()` and detached instances via {@link create}.
+ * Seeding with an existing event log replays/forks a session.
+ * @typert object
+ */
+declare class Session {
+  #private;
+  private log;
+  /** Single incremental owner of surface acceptance and projection state. */
+  private readonly surfaceManager;
+  /** The ordered surface over this session's event log. */
+  get surface(): SessionSurface;
+  /**
+   * Detached, deep-frozen creation metadata (format version, cwd, lineage,
+   * and whether fork history exists). Supplied by the store via `ctx.sessions.create()`. When a
+   * `Session` is created without a store-owned header, a minimal header is
+   * synthesized (stamped with the current {@link SESSION_FORMAT_VERSION}) so
+   * `session.header` is always present. Kept out of the event log — it is a
+   * storage concern, not replayable conversation state.
+   */
+  readonly header: SessionHeader;
+  /** Number of leading events inherited from this Session's fork parent. */
+  readonly inheritedEventCount: SessionLogOffset;
+  /** The session identity, derived from its durable header's single copy. */
+  get id(): SessionId;
+  /**
+   * The constructor seed length (0 without one), before any marker appended
+   * during construction. Seed events never publish on `session/event`. A
+   * marker appended before the store attaches occupies this seq without
+   * publishing either; otherwise this seq is available for the next append.
+   *
+   * This in-process offset is not persisted. A fork seed can already contain
+   * the child's inherited marker and synthetic closers, so its child-owned
+   * history starts at {@link inheritedEventCount}, before this offset. A
+   * resumed Session's seed contains its full stored log, while its inherited
+   * count keeps the durable fork cut. Consumers needing complete canonical
+   * history start at seq 0.
+   */
+  readonly firstLiveSeq: SessionLogOffset;
+  /**
+   * First event produced for this object lifecycle. A new fork includes its
+   * child-owned seed marker and closers; a restored Session starts after its
+   * complete stored prefix. This in-process capture offset is not persisted.
+   */
+  readonly firstLifecycleSeq: SessionLogOffset;
+  /**
+   * Create a detached session by validating and snapshotting borrowed seed
+   * events and storage metadata.
+   * @param id - session identity.
+   * @param seed - optional borrowed replay or fork events.
+   * @param header - optional borrowed storage metadata.
+   * @param inheritedEventCount - exact fork-inherited prefix length for a seeded header.
+   * @param projections - pure interpreters for plugin-owned message changes.
+   * @returns a detached session.
+   * @throws when a seed event requires a missing message interpreter or fails validation.
+   */
+  static create(id: SessionId, seed?: readonly SessionEvent[], header?: SessionHeader, inheritedEventCount?: SessionLogOffset, projections?: readonly SessionMessageProjection[]): Session;
+  /**
+   * Restore a detached session by adopting an independently owned or deeply frozen seed.
+   * Runtime-required event fields, event envelopes, sequence continuity, surface
+   * transitions, and header fields are validated without copying or freezing events.
+   * Embedded Assistant streams remain opaque until a stream consumer or storage
+   * verifier reads them.
+   * @param id - restored session identity.
+   * @param seed - independently owned or deeply frozen events.
+   * @param header - independently owned storage metadata.
+   * @param inheritedEventCount - exact fork-inherited prefix length decoded from storage.
+   * @param eventState - aliasing state carried from the operation that produced the seed.
+   * @param projections - pure interpreters for plugin-owned message changes.
+   * @returns a restored detached session.
+   * @throws when a seed event requires a missing message interpreter or fails validation.
+   */
+  static fromRestore(id: SessionId, seed: readonly SessionEvent[], header: SessionHeader, inheritedEventCount: SessionLogOffset, eventState: SessionSeedEventState, projections?: readonly SessionMessageProjection[]): Session;
+  private constructor();
+  /** Cached immutable full snapshot of the private append-only log. */
+  private eventsSnapshot;
+  /**
+   * Return the immutable event stored at one exact sequence number.
+   * @deprecated Existing logic may remain unmigrated for now, but new calls are prohibited.
+   * See the [Agent Note](../../../../.agents/notes/implemented/architecture/2026-09-09-deprecate-synchronous-session-event-reads.md).
+   * @param seq - event sequence number.
+   * @returns the accepted event, or undefined when the log does not contain it.
+   */
+  eventAt(seq: SessionSeq): SessionEvent | undefined;
+  /**
+   * Materialize an immutable snapshot of a half-open event sequence range.
+   * A full current snapshot is reused until the next append; every previously
+   * returned snapshot remains stable after later appends.
+   * @deprecated Existing logic may remain unmigrated for now, but new calls are prohibited.
+   * See the [Agent Note](../../../../.agents/notes/implemented/architecture/2026-09-09-deprecate-synchronous-session-event-reads.md).
+   * @param fromSeq - non-negative inclusive sequence number; defaults to the log start.
+   * @param toSeqExclusive - non-negative exclusive sequence number; defaults to the current end.
+   * @returns a frozen array of the selected deeply frozen events.
+   */
+  snapshotEvents(fromSeq?: SessionLogOffset, toSeqExclusive?: SessionLogOffset): readonly SessionEvent[];
+  /**
+   * Return this Session's events after its fork-inherited prefix.
+   * @deprecated Existing logic may remain unmigrated for now, but new calls are prohibited.
+   * See the [Agent Note](../../../../.agents/notes/implemented/architecture/2026-09-09-deprecate-synchronous-session-event-reads.md).
+   * @returns a fresh array containing child-owned events in log order.
+   */
+  ownEvents(): readonly SessionEvent[];
+  /**
+   * Whether one existing event position is outside the fork-inherited prefix.
+   * @param seq - event position in this Session.
+   * @returns true when the event belongs to this Session rather than its parent.
+   */
+  isOwnSeq(seq: SessionSeq): boolean;
+  /** The next event's sequence number — always the log length (the `seq = log.length` contiguity contract). */
+  get seq(): SessionLogOffset;
+  /**
+   * Append one typed event to the log and synchronously notify observers via
+   * the store-owned, module-private publication hooks. The hot path never blocks
+   * on I/O — persistence plugins buffer asynchronously. Once the event enters
+   * the log, the append is committed: observer failures are logged and
+   * contained per listener, so they do not change the return value or prevent
+   * later listeners from observing the same accepted event.
+   *
+   * @param type - The event type (key of {@link SessionEventMap}).
+   * @param data - The event payload; must be JSON-serializable.
+   * @param opts - Surface metadata: `surfaceOp` controls how the event enters
+   *   the ordered surface; `sourceEventSeqs` lists the seq numbers of earlier
+   *   events this one derives from. REQUIRED for
+   *   {@link SurfaceEventType} events (every message-producing event must
+   *   declare how it joins the surface, the sole source of derived model
+   *   history) and
+   *   rejected by the compiler for non-surface types like `turn/start` or
+   *   `assistant/attempt`. Assistant messages embed their exact provider
+   *   stream and cannot cite top-level source events.
+   * @returns the logged event — its assigned `seq`/`time` plus the SNAPSHOT of
+   *   `data` that entered the log, so reading `event.data` back sees the logged
+   *   value, never the caller's still-mutable input.
+   * @throws if `data` or surface metadata is not losslessly JSON-serializable
+   *   (BigInt, function, symbol, undefined, negative zero, non-finite number,
+   *   circular reference, sparse array, or an exotic object such as
+   *   Map/Set/Date/class instance), or when the candidate violates the
+   *   request-header empty-field or tool-error consistency rules, or the
+   *   canonical surface contract (marker shape and eligibility, unique
+   *   earlier source-event references, positional replacement validity, and complete
+   *   shadowed-node coverage). One iterative pass reads, validates, and
+   *   copies each nested value once, so a stateful getter cannot supply one value
+   *   to validation and another to storage. The event log is the durable source
+   *   of truth, so a bad event fails at the append site rather than later during
+   *   a backend flush. A synchronous internal dispatch validation failure or an
+   *   append reentered while this acceptance/publication boundary is open also
+   *   rejects before the log changes.
+   */
+  append<T extends SessionEventType>(type: T, data: SessionEventMap[T], ...opts: T extends SurfaceEventType ? [opts: SurfaceIntent<T>] : []): SessionEvent<T>;
+  /**
+   * Read the store attachment for one append, refusing an append that
+   * reenters while another append is being published.
+   * @returns the attachment, or undefined for a detached Session.
+   */
+  private publicationEntry;
+  /**
+   * Accept one frozen candidate at the next sequence number, enter it into the
+   * log, and notify `session/event` observers with per-listener containment.
+   * @param event - the candidate built at the current log length.
+   * @param entry - the attachment read before the candidate was built.
+   */
+  private commit;
+  /** Cached fold of the request-header events — see {@link requestHeader}. */
+  private headerFold;
+  /** Log position (events consumed) the header fold has reached. */
+  private headerFoldSeq;
+  /**
+   * The {@link EpochHeader} in force after the log's last header event — the
+   * header the NEXT request will be compared against — or undefined before
+   * the first `request/header` snapshot. The live, incrementally-maintained
+   * form of `foldRequestHeader(session.snapshotEvents())`: each header event is folded
+   * once, when first seen, so a per-step read costs O(new events).
+   * @returns the folded header, or undefined when no header event exists yet.
+   */
+  requestHeader(): EpochHeader | undefined;
+  /** Cached fold of `request/context` events. */
+  private contextFold;
+  private contextFoldSeq;
+  /**
+   * Return the latest resolved route metadata, or `undefined` before the first
+   * `request/context` event. Each event is folded once.
+   * @returns the latest immutable route metadata.
+   */
+  requestContext(): RequestContext | undefined;
+  /** Cached historical tool definitions and updates for request projection. */
+  private readonly toolHistoryProjection;
+  /** Index of the next committed event not yet consumed by the tool-history fold. */
+  private toolHistorySeq;
+  /**
+   * Fold unseen committed events into capability-independent tool history.
+   * Initial access reconstructs inherited history; later reads consume only new events.
+   * @returns an immutable snapshot for LLM request projection, including historical addition definitions.
+   */
+  toolHistory(): ToolHistory;
+  /** The derived-message cache: frozen projections, extended per unseen node. */
+  private derived;
+  /** Surface position (nodes projected) the cache has reached. */
+  private derivedNodes;
+  /** {@link SurfaceManager.contentGeneration} the cache was built under. */
+  private derivedGeneration;
+  /**
+   * Derive the LLM message history by walking the ordered sequences of
+   * message-producing events maintained by `surfaceOp` markers. The
+   * surface is the single source of derived history: every message-producing
+   * append records its `surfaceOp`, so a raw event with no marker (a chunk, a
+   * turn boundary) is correctly absent, and a compaction `replace` deletes the
+   * shadowed nodes from the derivation. The projection rules are
+   * {@link deriveEventMessage}, with logged message projections applied
+   * without changing node membership or message identity.
+   *
+   * CACHED: pure tail growth costs O(new nodes); a replacement or message projection
+   * ({@link SessionSurface.contentGeneration}) rebuilds. The returned array is
+   * a fresh snapshot per call (later appends never grow an array a caller
+   * already holds); the `Message` objects in it are SHARED and **deep-frozen**.
+   * Unchanged content reuses frozen event data; projected blocks are frozen
+   * derived copies. Consumers cannot mutate the log through either form.
+   * @returns a fresh array of the shared, frozen derived history.
+   */
+  deriveMessages(): Message[];
+  /**
+   * Project one event with all committed message projections applied.
+   * The original durable event remains unchanged.
+   * @param event - the event to project.
+   * @returns the derived message, or null when the event produces none.
+   */
+  deriveEventMessage(event: SessionEvent): Message | null;
+}
+/** A fork source: either the live session object or its live store id. */
+type SessionForkSource = Session | SessionId;
+/**
+ * In-memory session store (`ctx.sessions`).
+ *
+ * Persistence is intentionally not implemented here — the agent lifecycle
+ * attaches a session-log writer to each published session's write handle;
+ * a session published outside that lifecycle persists nothing.
+ */
+declare class SessionStore extends Service {
+  private store;
+  private counter;
+  private readonly projections;
+  /** Borrowed definitions for detached replay; contributions live until their registering fibers unload. */
+  get messageProjections(): readonly SessionMessageProjection[];
+  /**
+   * Register one event interpreter for live creation, restore, and fork.
+   * Disposing the contribution makes sessions that used it refuse further derivation.
+   * @param projection - pure definition owned by the event's plugin.
+   * @returns the fiber-owned disposer.
+   * @throws when another definition already owns this event type.
+   */
+  registerMessageProjection(projection: SessionMessageProjection): () => Promise<void>;
+  constructor(ctx: Context);
+  /**
+   * Create a session owned by the calling fiber: disposing that fiber stops
+   * event notification and removes the session from the store. `options.seed`
+   * populates the session with a copy of those events (replay/fork);
+   * `options.meta` attaches creation metadata (validated absolute `cwd`, seed
+   * and parent lineage, and delegation depth) as the immutable
+   * {@link SessionHeader} (the store fills `version`/`id`/`createdAt`).
+   *
+   * For an agent whose session must be torn down IN ORDER with its loop (so the
+   * loop's final events are published before the store attachment ends), do NOT use this
+   * — fold the session lifecycle into the agent's own effect via
+   * {@link prepare} + {@link enter} + {@link announce} (see
+   * `dsh-agent-loop`'s creation transaction).
+   *
+   * @param id - the session id; omitted, the store mints `session-<n>`.
+   * @param options - seed events and/or creation metadata for the header.
+   * @returns the live session, already entered and announced.
+   * @throws if a session with `id` already exists, metadata is not a plain
+   *   lossless-JSON record with valid scalar fields, or `meta.cwd` is a
+   *   non-absolute path (storage backends key directories off it).
+   */
+  create(id?: SessionId, options?: CreateSessionOptions): Session;
+  /**
+   * Build a session WITHOUT entering it into the store — validate the id/cwd and
+   * construct the {@link Session} (with its immutable {@link SessionHeader}).
+   * Pairs with {@link enter} + {@link announce}: a caller that owns a composite
+   * `ctx.effect` (the agent factory) folds the session lifecycle into that ONE
+   * effect so a fiber unload tears the session + agent down as a single ORDERED
+   * chain rather than as racing sibling effects — which would remove the publication hooks
+   * before the driver's closing events commit, dropping them.
+   *
+   * @param id - the session id; omitted, the store mints `session-<n>`.
+   * @param options - seed events and/or creation metadata for the header. With
+   *   `eventState`, every seed event is either independently owned or any
+   *   shared value is deeply frozen; {@link Session.fromRestore} validates and
+   *   adopts those values without copying or freezing them.
+   * @returns the constructed session, NOT yet in the store.
+   * @throws if a session with `id` already exists, metadata is not a plain
+   *   lossless-JSON record with valid scalar fields, or `meta.cwd` is a
+   *   non-absolute path.
+   */
+  prepare(id?: SessionId, options?: PrepareSessionOptions): Session;
+  /**
+   * Enter a {@link prepare}d session into the store: install the module-private
+   * append publication hooks and add it to the store. Returns the DETACH
+   * disposer (hooks + store removal). Does NOT emit `session/created` —
+   * the caller yields this disposer inside its effect and THEN calls
+   * {@link announce}, so a throwing `session/created` listener rolls the attach
+   * back instead of leaking it.
+   *
+   * Re-checks the id for a duplicate: `prepare` and `enter` are public
+   * cross-package primitives and a caller may interleave arbitrary work (or
+   * another create) between them, so a stale prepared session must NOT overwrite
+   * a live store entry of the same id — its detach disposer would later delete
+   * the REAL session. The {@link create} convenience and the agent factory call
+   * the two back-to-back so they never trip this, but the public API cannot
+   * assume that.
+   *
+   * @param session - a {@link prepare}d session not yet in the store.
+   * @returns the detach disposer (publication hooks + store removal). When called from
+   *   a synchronous `session/created` listener, removal and disposal wait until
+   *   that creation dispatch unwinds.
+   * @throws if a session with this id is already in the store.
+   */
+  enter(session: Session): () => void;
+  /** Remove one exact entered session and emit its paired disposal when announced. */
+  private detachEntered;
+  /** Emit `session/created` exactly once for an {@link enter}ed session (with
+   * the carrier {@link enter} captured). Separate from {@link enter} so the
+   * caller can yield the detach disposer first (rollback safety — see
+   * {@link enter}).
+   * @param session - the entered session to announce to listeners.
+   * @throws if the session is not live or its announcement already began,
+   *   including a reentrant call from a creation listener. */
+  announce(session: Session): void;
+  /** Emit the paired teardown notification with per-listener containment. */
+  private emitDisposed;
+  /**
+   * Dispatch the awaited `session/flush` durability checkpoint for `session`,
+   * with the carrier captured at {@link enter}. THE flush entry point: the
+   * store owns the carrier, so callers (the checkpoint policy's per-request
+   * barrier, goal-round-driver's idle checkpoint, teardown drains, and consumers
+   * that flush themselves before reading storage) must come through here
+   * rather than dispatch a raw `ctx.parallel('session/flush', …)` — one owner
+   * and one spelling.
+   * @param session - the session whose buffered events must reach durable storage.
+   * @returns whether at least one durability listener participated, after every
+   *   listener has settled successfully.
+   * @throws the first registered listener failure after every listener settles.
+   */
+  flush(session: Session): Promise<boolean>;
+  /** Return the exact live entry; detached/prepared objects reject. */
+  private liveEntryFor;
+  /**
+   * Look up a live session.
+   * @param id - the session id to look up.
+   * @returns the session, or undefined when no live session has that id.
+   */
+  get(id: SessionId): Session | undefined;
+  /**
+   * All live sessions, in creation order.
+   * @returns a fresh array; mutating it does not affect the store.
+   */
+  list(): Session[];
+  /**
+   * Create a live child session from an exact prefix of a live source.
+   * `boundary` is an inclusive source event seq; omitted means the source's
+   * current last event. An open tail receives synthetic tool results and
+   * step/turn closers with the forked cause. Closed steps and turns remain
+   * unchanged, including any failed tool calls already missing results.
+   * `inheritedEventCount` counts only copied source events, excluding these closers.
+   *
+   * @param source - Live source session object or id.
+   * @param boundary - Inclusive source event seq to fork through; omitted means
+   *   the source's current last event, and omitted on an empty source forks an
+   *   empty child.
+   * @param childSessionId - Optional child session id; omitted delegates to
+   *   `SessionStore`'s id policy.
+   * @returns The created live child session.
+   */
+  fork(source: SessionForkSource, boundary?: SessionSeq, childSessionId?: SessionId): Session;
+  private _forkBoundary;
+  private _resolveForkSource;
+}
+//#endregion
+//#region src/core/sync/session-sync.d.ts
+interface SpillTransferReference {
+  owner: {
+    sessionId: string;
+  };
+  source: {
+    toolName: string;
+    callId: string;
+    label: string;
+  };
+  suggestedName: string;
+  ref: {
+    locator: string;
+    bytes?: number;
+    retrievalHint: string;
+  };
+}
+interface SyncSessionWorkspace {
+  originInstanceId: string;
+  originWorkspaceId: string;
+  nodeOrigin: SyncOrigin;
+  remotePath: string;
+  title: string;
+  revision: SyncRevision;
+  contentDigest: string;
+}
+interface SyncSessionInstructionSnapshot {
+  text: string;
+  capturedAt: string;
+  workspaceOrigin?: SyncOrigin;
+  workspaceRemotePath?: string;
+  workspaceRevision?: number;
+  digest?: string;
+  inheritedFromOrigin?: SyncOrigin;
+}
+type SyncSessionObject = {
+  id: string;
+  kind: 'image';
+  ref: ImageAttachmentRef;
+  bytes: number;
+  digest: string;
+  data: string;
+} | {
+  id: string;
+  kind: 'file';
+  ref: FileAttachmentRef;
+  bytes: number;
+  digest: string;
+  data: string;
+} | {
+  id: string;
+  kind: 'spill';
+  reference: SpillTransferReference;
+  bytes: number;
+  digest: string;
+  data: string;
+  unavailable?: boolean;
+};
+interface SyncSessionEntry {
+  metadata: SyncRecordMetadata;
+  branchId?: string;
+  sourceLocalSessionId?: string;
+  header?: SessionHeader;
+  inheritedEventCount?: number;
+  parentOrigin?: SyncOrigin;
+  workspace?: SyncSessionWorkspace;
+  workspacePosition?: number;
+  archived?: boolean;
+  pinned?: boolean;
+  instructionSnapshot?: SyncSessionInstructionSnapshot;
+  events?: SessionEvent[];
+  objects?: SyncSessionObject[];
+}
+interface SyncSessionBundle {
+  protocolVersion: 1;
+  instanceId: string;
+  entries: SyncSessionEntry[];
+  skipped: Array<{
+    sessionId: string;
+    reason: string;
+  }>;
+  digest: string;
+}
+interface SyncSessionApplyResult {
+  created: number;
+  updated: number;
+  archived: number;
+  deleted: number;
+  skipped: number;
+  unmapped: number;
+}
+interface SyncSessionApplyOptions {
+  importedVia?: SyncImportMethod;
+  allowSameInstance?: boolean;
+}
+interface SyncSessionTransferPlan {
+  toLocal: SyncSessionEntry[];
+  toRemote: SyncSessionEntry[];
+  skipped: number;
+}
+declare class SyncSessionError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, cause?: unknown);
+}
+interface SessionSnapshotLike {
+  header: SessionHeader;
+  formatStatus?: 'current' | 'migration-required';
+  revision: unknown;
+  eventCount?: number;
+}
+interface SessionHandleLike {
+  readonly id: SessionId;
+  readonly header: SessionHeader;
+  readonly inheritedEventCount: number;
+  read(offset?: number, length?: number): Promise<{
+    events: readonly SessionEvent[];
+  }>;
+  append(events: readonly SessionEvent[]): Promise<void>;
+  flush(): Promise<void>;
+  close(): Promise<void>;
+}
+interface SessionPersistenceLike {
+  flush(): Promise<void>;
+  list(): Promise<readonly SessionSnapshotLike[]>;
+  stat(id: SessionId): Promise<SessionSnapshotLike | undefined>;
+  open(id: SessionId, access: 'read' | 'write'): Promise<SessionHandleLike>;
+  create(header: SessionHeader, options?: {
+    inheritedEventCount?: number;
+  }): Promise<SessionHandleLike>;
+}
+interface WorkspaceLike {
+  id: string;
+  path: string;
+  title: string;
+  sessionIds: readonly SessionId[];
+  setTitle(title: string): Promise<void>;
+  attachSession(sessionId: SessionId): Promise<void>;
+  insertSessionBefore(sessionId: SessionId, beforeSessionId?: SessionId): Promise<void>;
+}
+interface WorkspaceRegistryLike {
+  list(): WorkspaceLike[];
+  get(id: string): WorkspaceLike | undefined;
+  create(path: string, title?: string): Promise<WorkspaceLike>;
+  archiveSession(sessionId: SessionId, options?: {
+    stopActivity?: boolean;
+  }): Promise<void>;
+  unarchiveSession(sessionId: SessionId): Promise<void>;
+  pinSession?(sessionId: SessionId): Promise<void>;
+  unpinSession?(sessionId: SessionId): Promise<void>;
+  readonly archivedSessionIds: readonly SessionId[];
+  readonly pinnedSessionIds?: readonly SessionId[];
+}
+interface AttachmentStoreLike {
+  readImage(ref: ImageAttachmentRef): Promise<{
+    ref: ImageAttachmentRef;
+    data: Uint8Array;
+  }>;
+  saveImage(input: {
+    data: Uint8Array;
+    mediaType: ImageAttachmentRef['mediaType'];
+    name?: string;
+  }): Promise<ImageAttachmentRef>;
+  readFileStream(ref: FileAttachmentRef): AsyncIterable<Uint8Array>;
+  saveFileStream(input: {
+    data: AsyncIterable<Uint8Array>;
+    name?: string;
+  }): Promise<FileAttachmentRef>;
+}
+interface SpillStoreLike {
+  root?: string;
+  readTextStream?(input: {
+    owner: {
+      sessionId: SessionId;
+    };
+    ref: SpillTransferReference['ref'];
+  }): AsyncIterable<Uint8Array>;
+  saveTextStream?(input: {
+    owner: {
+      sessionId: SessionId;
+    };
+    source: SpillTransferReference['source'];
+    suggestedName: string;
+    transferId: string;
+    bytes: number;
+    digest: string;
+    content: AsyncIterable<Uint8Array>;
+  }): Promise<SpillTransferReference['ref']>;
+}
+declare function planSessionTransfers(direction: 'pull' | 'bidirectional', localEntries: readonly SyncSessionEntry[], remoteEntries: readonly SyncSessionEntry[]): SyncSessionTransferPlan;
+declare function validateSyncSessionBundle(value: unknown): SyncSessionBundle;
+declare function makeSyncSessionBundle(instanceId: string, entries: SyncSessionEntry[], skipped?: Array<{
+  sessionId: string;
+  reason: string;
+}>): SyncSessionBundle;
+declare class SyncSessionService {
+  private readonly state;
+  private readonly nodes;
+  private readonly registry;
+  private readonly bindings;
+  private readonly getWorkspaces;
+  private readonly getPersistence;
+  private readonly getAttachments;
+  private readonly getSpills;
+  private readonly instructions;
+  private readonly journal;
+  private readonly now;
+  private operationTail;
+  constructor(state: SyncStateStore, nodes: SyncNodeService, registry: NodeRegistry, bindings: WorkspaceBindingsStore, getWorkspaces: () => WorkspaceRegistryLike | undefined, getPersistence: () => SessionPersistenceLike | undefined, getAttachments: () => AttachmentStoreLike | undefined, getSpills: () => SpillStoreLike | undefined, instructions: SessionInstructionSnapshotStore, journal?: SyncSessionJournalStore, now?: () => number);
+  exportBundle(): Promise<SyncSessionBundle>;
+  applyBundle(value: unknown, sourceName: string, peerId?: string, options?: SyncSessionApplyOptions): Promise<SyncSessionApplyResult>;
+  preflightBundle(value: unknown, options?: SyncSessionApplyOptions): void;
+  pendingPeerIds(): string[];
+  recoverPending(): Promise<void>;
+  cleanupOrphanedStaging(): void;
+  listArchives(): SyncSessionArchive[];
+  restoreArchive(branchId: string): Promise<SessionId>;
+  private exportBundleNow;
+  private applyBundleNow;
+  private prepareEntry;
+  private ensureWorkspace;
+  private importObjects;
+  private rewriteEvents;
+  private validatePrepared;
+  private applyPrepared;
+  private applyMembershipOnly;
+  private applyArchiveStateOnly;
+  private archiveCurrent;
+  private applyTombstone;
+  private restoreArchiveNow;
+  private orderWorkspaceSessions;
+  private localSessionIdForOrigin;
+  private localWorkspaceIdForOrigin;
+  private writeSession;
+  private workspaceDescriptor;
+  private exportSessionEntry;
+  private readStableSession;
+  private exportObjects;
+  private requirePersistence;
+  private serializeMutation;
+}
+//#endregion
+export { SyncSessionError as a, SyncSessionService as c, WorkspaceRegistryLike as d, makeSyncSessionBundle as f, SyncSessionEntry as i, SyncSessionTransferPlan as l, validateSyncSessionBundle as m, SyncSessionApplyResult as n, SyncSessionInstructionSnapshot as o, planSessionTransfers as p, SyncSessionBundle as r, SyncSessionObject as s, SyncSessionApplyOptions as t, SyncSessionWorkspace as u };
+//# sourceMappingURL=session-sync-g6qKZzjV.d.ts.map