@gajae-code/coding-agent 0.11.0 → 0.11.2

package/dist/types/session/agent-session.d.ts

@@ -33,6 +33,25 @@ export interface PurgeQueuedCustomMessagesResult {
     displayFollowUp: number;
     totalExecutable: number;
 }
+export type AbortOutcome = {
+    kind: "settled";
+} | {
+    kind: "timeout";
+} | {
+    kind: "error";
+    cause: unknown;
+};
+export type CancelAndSubmitOutcome = {
+    kind: "submitted";
+} | {
+    kind: "refused";
+    reason: "duplicate" | "compaction";
+} | {
+    kind: "rolled_back";
+    outcome: Extract<AbortOutcome, {
+        kind: "timeout" | "error";
+    }>;
+};
 export interface ForkContextSeed {
     messages: Message[];
     agentMessages: AgentMessage[];
@@ -43,6 +62,7 @@ export interface ForkContextSeed {
 export interface ForkContextSeedOptions {
     maxMessages: number;
     maxTokens: number;
+    preserveLatestUser?: boolean;
     cacheIdentity?: string;
     signal?: AbortSignal;
 }
@@ -68,7 +88,6 @@ import type { HindsightSessionState } from "../hindsight/state";
 import { type WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
 import type { PlanModeState } from "../plan-mode/state";
 import { type AgentRegistry } from "../registry/agent-registry";
-import { type DiscoverableMCPSearchIndex, type DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
 import { MCPManager } from "../runtime-mcp/manager";
 import type { NotificationSessionController } from "../sdk/bus/session-control";
 import { type SecretObfuscator } from "../secrets/obfuscator";
@@ -181,6 +200,10 @@ export interface AgentSessionConfig {
     slashCommands?: FileSlashCommand[];
     /** Extension runner (created in main.ts with wrapped tools) */
     extensionRunner?: ExtensionRunner;
+    /** Override first-party worker integration dispatch for embedded hosts and deterministic lifecycle tests. */
+    workerIntegrationRequest?: (signal: AbortSignal) => Promise<void>;
+    /** Bound terminal worker-integration settlement for embedded hosts and deterministic lifecycle tests. */
+    workerIntegrationTimeoutMs?: number;
     /** Loaded skills (already discovered by SDK) */
     skills?: Skill[];
     /** Skill loading warnings (already captured by SDK) */
@@ -219,15 +242,12 @@ export interface AgentSessionConfig {
     requestedToolNames?: ReadonlySet<string>;
     /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
     discoverableToolAllowedNames?: readonly string[];
-    /**
-     * Optional accessor for live MCP server instructions. Read by the session's
-     * `rebuildSystemPrompt`-skip optimization to detect server-side instruction
-     * changes (e.g. an MCP server upgrade) that would otherwise pass the tool-set
-     * signature comparison and silently keep a stale prompt cached.
-     */
+    /** Optional accessor for live MCP server instructions, injected as untrusted user-role request data. */
     getMcpServerInstructions?: () => Map<string, string> | undefined;
     /** Enable hidden-by-default MCP tool discovery for this session. */
     mcpDiscoveryEnabled?: boolean;
+    /** Effective discovery mode normalized by the session factory. */
+    discoveryMode?: "off" | "mcp-only" | "all";
     /** MCP tool names to activate for the current session when discovery mode is enabled. */
     initialSelectedMCPToolNames?: string[];
     /** Whether constructor-provided MCP defaults should be persisted immediately. */
@@ -348,6 +368,36 @@ export interface SessionStats {
     cost: number;
     costBreakdown?: Usage["cost"];
 }
+export type EphemeralTurnPurpose = "btw" | "background";
+interface EphemeralTurnBaseArgs {
+    promptText: string;
+    onTextDelta?: (delta: string) => void;
+    signal?: AbortSignal;
+}
+export type EphemeralTurnArgs = (EphemeralTurnBaseArgs & {
+    purpose: "btw";
+}) | (EphemeralTurnBaseArgs & {
+    purpose?: "background";
+    /** Internal caller-supplied, non-persistent context such as the IRC roster. */
+    prependMessages?: AgentMessage[];
+    /** Revalidates optional caller context after asynchronous boundaries. */
+    prependMessagesValid?: () => boolean;
+    /**
+     * An existing IRC roster claim owned by the caller. `undefined` makes this
+     * turn claim and commit its own roster candidate; `null` opts out.
+     */
+    ircRosterClaim?: IrcRosterClaim | null;
+});
+interface EphemeralTurnResult {
+    replyText: string;
+    assistantMessage: AssistantMessage;
+}
+type IrcRosterClaim = {
+    token: symbol;
+    signature: string;
+    epoch: number;
+    message: CustomMessage;
+};
 export type QueuedMessageEditMode = "steer" | "followUp";
 export interface QueuedMessageEditEntry {
     id: string;
@@ -369,8 +419,9 @@ export type BeforeAgentStartContributor = (event: {
 }) => Promise<BeforeAgentStartInternalMessage | undefined>;
 export declare class WorkerIntegrationRequestScheduler {
     #private;
-    readonly request: () => Promise<void>;
-    constructor(request: () => Promise<void>);
+    readonly request: (signal: AbortSignal) => Promise<void>;
+    readonly timeoutMs: number;
+    constructor(request: (signal: AbortSignal) => Promise<void>, timeoutMs?: number);
     enqueue(): void;
     flush(): Promise<void>;
 }
@@ -448,6 +499,7 @@ export declare class AgentSession {
     peekQueueInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     peekStandingResolveHandler(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     setStandingResolveHandler(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void;
+    setSdkPlanModeHandler(handler: ((on: boolean) => Promise<PlanModeState | undefined>) | null): void;
     /** Provider-scoped mutable state store for transport/session caches. */
     get providerSessionState(): Map<string, ProviderSessionState>;
     /** Suspend provider state without closing it while a temporary model is active. */
@@ -499,6 +551,8 @@ export declare class AgentSession {
      * react to (e.g. background queue flush failures).
      */
     emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
+    /** Await all transformations queued by externally emitted tool results. */
+    awaitPendingContextTransformations(): Promise<void>;
     /**
      * Subscribe to agent events.
      * Session persistence is handled internally (saves messages on message_end).
@@ -541,7 +595,7 @@ export declare class AgentSession {
     get serviceTier(): ServiceTier | undefined;
     /** Whether agent is currently streaming a response */
     get isStreaming(): boolean;
-    /** Wait until streaming and deferred recovery work are fully settled. */
+    /** Wait until streaming and session settlement work are fully settled. */
     waitForIdle(): Promise<void>;
     drainAsyncJobDeliveriesForAcp(options?: {
         timeoutMs?: number;
@@ -603,15 +657,7 @@ export declare class AgentSession {
      * Get all configured tool names (built-in via --tools or default, plus custom tools).
      */
     getAllToolNames(): string[];
-    isMCPDiscoveryEnabled(): boolean;
-    /** @deprecated Use {@link getDiscoverableTools} with `{ source: "mcp" }` instead.
-     *  Preserves the legacy `description`-bearing MCP shape for back-compat callers. */
-    getDiscoverableMCPTools(): DiscoverableMCPTool[];
-    /** @deprecated Use {@link getDiscoverableToolSearchIndex} instead.
-     *  Returns the legacy MCP search index whose documents expose `tool.description`. */
-    getDiscoverableMCPSearchIndex(): DiscoverableMCPSearchIndex;
     getSelectedMCPToolNames(): string[];
-    activateDiscoveredMCPTools(toolNames: string[]): Promise<string[]>;
     isToolDiscoveryEnabled(): boolean;
     getDiscoverableTools(filter?: {
         source?: DiscoverableTool["source"];
@@ -657,6 +703,7 @@ export declare class AgentSession {
     get hasPostPromptWork(): boolean;
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
+    get transcriptPromptGeneration(): number;
     /** Main startup calls this exactly once, after a strict open returned `kind: "opened"`. */
     continuePersistedHistory(): Promise<void>;
     buildDisplaySessionContext(): SessionContext;
@@ -689,7 +736,7 @@ export declare class AgentSession {
         args?: string;
         lineCount?: number;
     }>;
-    setSdkPlanMode(on: boolean): PlanModeState | undefined;
+    setSdkPlanMode(on: boolean): Promise<PlanModeState | undefined>;
     operateGoal(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
     getTranscript(): Array<{
         id: string;
@@ -755,6 +802,10 @@ export declare class AgentSession {
     followUp(text: string, images?: ImageContent[], options?: Pick<PromptOptions, "followUpQueuePolicy">): Promise<void>;
     queueDeferredMessage(message: CustomMessage): void;
     queueDeferredMessageForTests(message: CustomMessage, triggerTurn?: boolean): void;
+    /** Read-only test seam for the hidden next-turn context queue. */
+    getPendingNextTurnMessagesForTests(): readonly CustomMessage[];
+    /** Test-only abort outcome override; undefined retains the production abort race. */
+    setCancelAndSubmitAbortOutcomeProviderForTests(provider: (() => Promise<AbortOutcome>) | undefined): void;
     /**
      * Send a custom message to the session. Creates a CustomMessageEntry.
      *
@@ -835,19 +886,17 @@ export declare class AgentSession {
     runMidRunMaintenanceForTests(context: AgentContext, lifecycle?: MidRunMaintenanceLifecycle): Promise<MidRunMaintenanceOutcome>;
     /** Test seam: estimate mid-run context tokens for a given context view. */
     estimateMidRunContextTokensForTests(messages: readonly AgentMessage[]): number;
-    /**
-     * Abort current operation and wait for agent to become idle.
-     */
+    /** Abort current operation and preserve the established void/rethrow contract. */
     abort(options?: {
         goalReason?: "interrupted" | "internal";
         timeoutMs?: number;
         cause?: "user_interrupt" | "new_session" | "session_switch" | "compaction" | "handoff" | "tool_abort" | "internal";
-        /** Suppress the "Operation aborted" line on the resulting aborted message
-         *  by stamping `SILENT_ABORT_MARKER`. Used when Esc consumes a queued steer
-         *  and resumes via steer-on-interrupt, so the interrupt reads as a quiet
-         *  hand-off rather than a failure. */
         silent?: boolean;
     }): Promise<void>;
+    /** Atomically interrupt the active run and make text the next prompt. */
+    cancelAndSubmit(text: string, options?: {
+        queuedEntryId?: string;
+    }): Promise<CancelAndSubmitOutcome>;
     /**
      * Start a new session, optionally with initial messages and parent tracking.
      * Clears all messages and starts a new session.
@@ -948,6 +997,8 @@ export declare class AgentSession {
      * @returns The new model info, or undefined if only one model available
      */
     cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
+    /** Number of configured role-model candidates that can be cycled. */
+    getRoleModelCycleCandidateCount(roleOrder?: readonly string[]): number;
     /**
      * Cycle through configured role models in a fixed order.
      * Skips missing roles.
@@ -1193,27 +1244,11 @@ export declare class AgentSession {
     emitSubagentSteerRelayObservation(record: CustomMessage): void;
     /**
      * Run a single ephemeral side-channel turn against this session's current
-     * model + system prompt + history.  No tools are used; the side request
-     * does not block on, or interfere with, any in-flight main turn.  The
-     * session's history and persisted state are NOT modified by this call.
-     *
-     * Used by `respondAsBackground` (IRC) and `BtwController` (`/btw`) to share
-     * the snapshot + stream pipeline.  The snapshot includes any in-flight
-     * streaming assistant text so the model sees the half-finished response
-     * rather than missing context.
-     */
-    runEphemeralTurn(args: {
-        promptText: string;
-        onTextDelta?: (delta: string) => void;
-        signal?: AbortSignal;
-        /** Defer the successful roster-claim commit until the caller accepts its exchange. */
-        deferRosterCommit?: boolean;
-    }): Promise<{
-        replyText: string;
-        assistantMessage: AssistantMessage;
-        commitRosterClaim?: () => void;
-        releaseRosterClaim?: () => void;
-    }>;
+     * model + system prompt + history. No tools are used and session history is
+     * not modified. Background turns retain the IRC/session behavior used by
+     * autoreplies; `/btw` turns use an isolated committed-context policy.
+     */
+    runEphemeralTurn(args: EphemeralTurnArgs): Promise<EphemeralTurnResult>;
     /**
      * Reload the current session from disk.
      *

package/dist/types/session/agent-storage.d.ts

@@ -98,4 +98,11 @@ export declare class AgentStorage {
      * Deletes expired cache entries. Call periodically for cleanup.
      */
     cleanExpiredCache(): void;
+    /**
+     * Release prepared statements and the shared SQLite handle.
+     *
+     * AgentStorage instances are cached by path, so closing also evicts this
+     * instance and allows a later open() to create a fresh handle.
+     */
+    close(): void;
 }

package/dist/types/session/fallback-chain-controller.d.ts

@@ -1,4 +1,4 @@
-export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "server" | "other";
+import type { FallbackTriggerClass } from "@gajae-code/ai/utils/fallback-transport";
 /** Immutable configured fallback intent. Transient attempt state never belongs here. */
 export interface ConfiguredFallbackChain {
     role: string;
@@ -30,11 +30,14 @@ export declare class FallbackChainController {
     }>;
     exhaustedForTurn: boolean;
     constructor(chain: ConfiguredFallbackChain, maxAttempts: number);
+    get totalAttemptsUsed(): number;
     currentSelector(): string | undefined;
     onResolutionSkip(reason: string): boolean;
     /** Charge an upstream request at its concrete transport boundary. */
     onAttemptStarted(): void;
-    /** Start a logically new request without losing its sticky selected entry. */
+    /** Remove the current started request from fallback-policy accounting without erasing prior failures. */
+    discardStartedAttempt(): void;
+    /** Start a logically new request with a fresh fallback-chain budget. */
     resetAttemptBudget(): void;
     /** Seed a controller from auth-aware resolution without charging requests. */
     seedResolution(activeIndex: number, skips: Array<{
@@ -43,6 +46,11 @@ export declare class FallbackChainController {
     }>): void;
     onAttemptFailure(triggerClass: FallbackTriggerClass, reason: string): FallbackFailureResult;
     advance(): boolean;
+    /**
+     * Restore the entry that just advanced when credential rotation permits a retry.
+     * The chain-wide budget and failure history remain charged.
+     */
+    restorePreviousEntryForRetry(): boolean;
     isExhausted(): boolean;
     resetForNewTurn(): void;
     resetSticky(): void;

package/dist/types/session/internal/managed-session-scope.d.ts

@@ -0,0 +1,102 @@
+import type { ResumeSessionIdentity } from "../session-manager";
+export declare const MANAGED_SESSION_LAYOUT_VERSION: 2;
+export declare const MANAGED_SESSION_IDENTITY_VERSION: 1;
+export declare const MANAGED_SESSION_BINDING_FILE = ".gjc-managed-session-scope.v2.json";
+export interface ManagedScope {
+    apiVersion: 1;
+    layoutVersion: 2;
+    identityVersion: 1;
+    agentDir: string;
+    sessionsRoot: string;
+    canonicalCwd: string;
+    legacyLexicalCwd: string;
+    directoryName: string;
+    directoryPath: string;
+    platform: "posix" | "win32";
+}
+export type ManagedMigrationPolicy = "copy-retain" | "disabled";
+export type ManagedScopeErrorCode = "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid";
+export type ManagedScopeResolution = {
+    kind: "resolved";
+    scope: ManagedScope;
+} | {
+    kind: "error";
+    code: ManagedScopeErrorCode;
+    message: string;
+};
+export interface ManagedCandidate {
+    sessionId: string;
+    path: string;
+    cwd: string;
+    provenance: "v2" | "legacy";
+    identity: ResumeSessionIdentity;
+    migrationState: "native_v2" | "legacy_unmigrated" | "migrated_v2";
+}
+export type ManagedCandidateListing = {
+    kind: "complete";
+    scope: ManagedScope;
+    owned: readonly ManagedCandidate[];
+    foreignCount: number;
+    invalid: readonly {
+        code: string;
+    }[];
+} | {
+    kind: "error";
+    code: "scan_failed" | "unsafe_root" | "invalid_candidate";
+    message: string;
+};
+export type ManagedOpenFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "migration_retired" | "legacy_migration_disabled" | "managed_storage_unsupported";
+export type ManagedOpenCandidateResult = {
+    kind: "opened";
+    path: string;
+    candidate: ManagedCandidate;
+    migrated: boolean;
+} | {
+    kind: "error";
+    code: ManagedOpenFailure;
+    message: string;
+};
+export type ManagedDeleteCandidateResult = {
+    kind: "deleted";
+    tombstonePath: string;
+} | {
+    kind: "already_deleted";
+    tombstonePath: string;
+} | {
+    kind: "error";
+    code: ManagedOpenFailure;
+    message: string;
+};
+declare function scopeDigest(platform: "posix" | "win32", canonicalPath: string): string;
+export declare const computeManagedScopeDigest: typeof scopeDigest;
+/**
+ * Resolve benign symlinks in the deepest existing ancestor of a trusted storage
+ * root (e.g. macOS `/var -> /private/var`, or a symlinked `$HOME`) while keeping
+ * any not-yet-created tail verbatim. The native owner-only primitive and the
+ * session-storage reparse guard traverse with `O_NOFOLLOW` and reject every
+ * symlink component, so the trusted root must be canonical before it reaches
+ * them; canonicalizing only the existing prefix never follows an
+ * attacker-plantable component below the root.
+ */
+export declare function canonicalizeTrustedPath(target: string): string;
+export declare function resolveManagedScope(input: {
+    cwd: string;
+    agentDir: string;
+    sessionsRoot: string;
+}): ManagedScopeResolution;
+export declare function ensureManagedScope(scope: ManagedScope): Promise<ManagedScopeResolution>;
+/** Synchronously create and validate the v2 binding before a default session writer exists. */
+export declare function prepareManagedSessionScopeForWriteSync(scope: ManagedScope): ManagedScopeResolution;
+export declare function listManagedCandidates(scope: ManagedScope): ManagedCandidateListing;
+/** Resume tombstoned cleanup under its original operation lease without restoring retired candidates. */
+export declare function reconcileManagedTombstones(scope: ManagedScope): Promise<void>;
+/** Create the v2 binding and private write protocol directories before managed writes. */
+export declare function prepareManagedSessionScopeForWrite(scope: ManagedScope): Promise<ManagedScopeResolution>;
+/**
+ * Open a validated candidate for mutation. Legacy transcripts are copied exactly once
+ * into v2 and retained at their original location; no transcript data is merged.
+ */
+export declare function openManagedCandidateForWrite(scope: ManagedScope, candidate: ManagedCandidate, migrationPolicy?: ManagedMigrationPolicy): Promise<ManagedOpenCandidateResult>;
+/** Tombstone a verified managed candidate before exact-identity deletion. */
+export declare function deleteManagedSessionCandidate(scope: ManagedScope, candidate: ManagedCandidate): Promise<ManagedDeleteCandidateResult>;
+export {};

package/dist/types/session/internal/managed-session-storage.d.ts

@@ -0,0 +1,38 @@
+export declare const MANAGED_ARTIFACT_MAX_DEPTH = 32;
+export declare const MANAGED_ARTIFACT_MAX_FILES = 10000;
+export declare const MANAGED_ARTIFACT_MAX_FILE_BYTES: number;
+export declare const MANAGED_ARTIFACT_MAX_TOTAL_BYTES: number;
+export type ManagedStorageFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "migration_retired" | "managed_storage_unsupported";
+export interface ManagedStorageLock {
+    path: string;
+    attemptId: string;
+    assertOwned(): void;
+    release(): Promise<void>;
+}
+export interface ManagedFileSnapshot {
+    bytes: Buffer;
+    identity: {
+        dev: bigint;
+        ino: bigint;
+        size: number;
+        mtimeNs: bigint;
+    };
+}
+export declare function shouldFsyncManagedDirectory(platform?: NodeJS.Platform): boolean;
+/** Create a managed directory and fail closed unless its owner-only mode/ACL verifies. */
+export declare function ensureManagedDirectory(pathname: string): void;
+/** Captures header/hash/copy input from one no-follow descriptor and rechecks the pathname before use. */
+export declare function captureManagedFileNoFollow(pathname: string): ManagedFileSnapshot;
+/** Atomically publishes bytes without replacing an existing destination. */
+export declare function publishManagedFileNoReplace(destination: string, bytes: Uint8Array, assertOwned?: () => void): Promise<void>;
+export declare function publishManagedFileNoReplaceSync(destination: string, bytes: Uint8Array): void;
+/** Copy the exact bytes captured from one no-follow source descriptor. */
+export declare function copyManagedFileNoReplace(source: string, destination: string, snapshot?: ManagedFileSnapshot): Promise<void>;
+/** Acquire a lease lock with bounded wait, heartbeats, conservative stale reclaim, and fencing. */
+export declare function acquireManagedLock(locksDirectory: string, name: string): Promise<ManagedStorageLock>;
+/** Bounds a no-follow artifact tree before it can be copied or deleted. */
+export declare function validateManagedArtifactTree(root: string): void;
+/** Flush a copied managed artifact tree, including empty directories, before publishing its receipt. */
+export declare function fsyncManagedArtifactTree(root: string): void;
+export declare function publishManagedTombstone(destination: string, record: Record<string, unknown>, assertOwned?: () => void): Promise<void>;
+export declare function unlinkManagedFileVerified(pathname: string, expected: ManagedFileSnapshot["identity"]): Promise<void>;

package/dist/types/session/messages.d.ts

@@ -10,6 +10,14 @@ import type { AssistantMessage, ImageContent, Message, MessageAttribution, TextC
 export { type BranchSummaryMessage, type CompactionSummaryMessage, createBranchSummaryMessage, createCompactionSummaryMessage, } from "@gajae-code/agent-core/compaction/messages";
 import type { LoadedSubskillActivation } from "../extensibility/gjc-plugins";
 import type { OutputMeta } from "../tools/output-meta";
+/**
+ * Encode untrusted values embedded in prompt markup. Control and bidi characters become visible
+ * escape sequences so they cannot alter markup structure or display. Isolated UTF-16 surrogates
+ * are also escaped; valid Unicode pairs remain intact.
+ */
+export declare function escapePromptMetadata(value: string, options?: {
+    preserveNewlines?: boolean;
+}): string;
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 export interface SkillPromptDetails {
     name: string;
@@ -58,6 +66,14 @@ export declare const INTERNAL_DETAILS_FIELDS: readonly ["__pendingDisplayTag"];
  *  (null/non-object, or no listed fields present) so callers don't pay a
  *  clone cost on the common path. */
 export declare function stripInternalDetailsFields<T>(details: T | undefined): T | undefined;
+export declare const PRE_ADMISSION_ARTIFACT_SPILL_HEAD_BYTES = 4096;
+export declare const PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES = 4096;
+/**
+ * Build the deterministic inline receipt for a tool result saved before the
+ * next provider context is constructed. Byte boundaries never split UTF-8
+ * code points, so head/tail recovery remains readable for emoji and CJK text.
+ */
+export declare function createPreAdmissionArtifactSpillPreview(fullText: string, artifactId: string, digest: string): string;
 /**
  * Message type for bash executions via the ! command.
  */

package/dist/types/session/session-manager-internal.d.ts

@@ -0,0 +1,14 @@
+import type { SessionContext, SessionEntry, SessionManager, SessionTreeNode } from "./session-manager";
+/**
+ * Opaque capability for zero-copy session snapshots. This module is deliberately
+ * excluded from package exports; only trusted in-package readers may use it.
+ */
+export declare const sessionManagerReadCapability: unique symbol;
+export interface SessionManagerReadAccess {
+    getEntries(): readonly SessionEntry[];
+    getSessionContext(): Readonly<SessionContext>;
+    getTree(): SessionTreeNode[];
+}
+export declare function getEntriesForInternalRead(manager: SessionManager): readonly SessionEntry[];
+export declare function getSessionContextForInternalRead(manager: SessionManager): Readonly<SessionContext>;
+export declare function getTreeForInternalRead(manager: SessionManager): SessionTreeNode[];