@gajae-code/coding-agent 0.12.19 → 0.12.21

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

@@ -1,3 +1,4 @@
+import * as crypto from "node:crypto";
 import { type AgentMessage } from "@gajae-code/agent-core";
 import type { ConfiguredModelChainEntry as SharedConfiguredModelChainEntry } from "@gajae-code/agent-core/compaction";
 import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@gajae-code/ai/core";
@@ -7,7 +8,8 @@ import type { ManagedLegacyLocalMigrationSource } from "../internal-urls/local-p
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type ManagedMigrationPolicy } from "./internal/managed-session-scope";
-import { type ManagedDirectoryRoot, ManagedSessionDescendantStore } from "./internal/managed-session-storage";
+import { type ManagedBoundedAppendExpectation, type ManagedDirectoryRoot, ManagedSessionDescendantStore } from "./internal/managed-session-storage";
+import { type BaseAnchor, BoundedLabelsPinsStore, type CommittedTail, type DescriptorSnapshot, type DictionaryPartitionCommit, FixedCacheAccount, type MetadataDeltaValue, type ParentBucketCommit, type ReducerState, type ReopenClassification, SessionMemoryAccountant } from "./internal/session-memory-sidecar";
 import { type MemoryGuardCreateCheckpointInput, type MemoryGuardParticipantIngressLease, type MemoryGuardRestoreInput, type MemoryGuardRestoreResult, type MemoryGuardSessionManagerCheckpointV1 } from "./memory-guard-checkpoint-participant";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
 import { type SessionManagerReadAccess, sessionManagerReadCapability } from "./session-manager-internal";
@@ -84,6 +86,48 @@ export interface SessionManagerObservabilityStats {
     materializedCacheDemotedCount: number;
     pathOnlyContextBuildCount: number;
 }
+export interface SessionMemoryStats {
+    sidecarEnabled: boolean;
+    coldRetirementActive: boolean;
+    sidecarIneligible: boolean;
+    hotRegionBytes: number;
+    metaDescriptorBytes: number;
+    totalAccountedBytes: number;
+    lastReopenTransition: ReopenClassification | undefined;
+    currentCommitTransition: ReopenClassification | undefined;
+    lazyReopenAttempted: boolean;
+    lazyReopenSucceeded: boolean;
+    lazyReopenFallbackReason: string | undefined;
+    retirementFallbackReason: string | undefined;
+    autoDisabledReason: string | undefined;
+    consecutiveBuildFailures: number;
+    /** Persistent bounded parent→children artifact is adopted and usable. */
+    parentArtifactEnabled: boolean;
+    /** Persistent bounded dictionary artifact is adopted and usable. */
+    dictionaryArtifactEnabled: boolean;
+    /** Reducer-bucket bytes retained by metadata-delta descriptors (fixed accounting). */
+    metadataDeltaDescriptorBytes: number;
+    /** Live cold index bytes (descriptor size when proven, else 0). */
+    coldIndexBytes: number;
+    /** Live cold block-cache allocated bytes. */
+    coldIndexBlockCacheBytes: number;
+    /** Live cold entry-cache allocated bytes. */
+    coldEntryCacheBytes: number;
+    /** Live observability counters (P7 contract). */
+    coldEntriesRetired: number;
+    coldEntriesReloaded: number;
+    rangeReadCount: number;
+    rangeReadGenerationMismatchCount: number;
+    sidecarRebuildCount: number;
+    coldMutationPromotions: number;
+    hotOverflowTransitions: number;
+    labelDiskFallbackCount: number;
+    /** Shadow-mode eager-vs-sidecar parity mismatches observed at build time (AC10 telemetry). */
+    shadowParityMismatchCount: number;
+    /** Shadow-mode parity comparisons performed at build time (AC10 telemetry). */
+    shadowParityCheckCount: number;
+    transcriptGeneration: number;
+}
 export interface SessionMessageEntry extends SessionEntryBase {
     type: "message";
     message: AgentMessage;
@@ -256,14 +300,179 @@ export interface EntryPatchRecord {
 export type SessionPatchRecord = HeaderPatchRecord | EntryPatchRecord;
 /** Resolved file entries; patch records are applied by parseSessionEntries(). */
 export type FileEntry = SessionHeader | SessionEntry;
+/**
+ * Cold-region placeholder envelope for a retired entry. The heavy payload was moved
+ * out of RAM into the disposable `.spill.idx`/`.spill.tail` cold region; the exact
+ * transcript byte range is recorded so the entry can be lazily resolved by
+ * `ordinal`/`id`. Never persisted; used only while a cold sidecar region is active.
+ */
+export interface SessionColdRefEntry extends SessionEntryBase {
+    type: "session_cold_ref";
+    ordinal: number;
+    seq: number;
+    byteOffset: number;
+    byteLength: number;
+}
+/** One cold entry's transcript location, keyed by entry id. */
+export interface ColdEntryIndex {
+    ordinal: number;
+    seq: number;
+    byteOffset: number;
+    byteLength: number;
+    recordDigest: string;
+    parentId?: string | null;
+    entryType?: string;
+}
+export interface SessionMemorySidecarRuntime {
+    /** Transcript v5 remains authoritative; sidecars are disposable/rebuildable. */
+    enabled: boolean;
+    /** Set when duplicate record IDs were detected; session stays eager. */
+    sidecarIneligible: boolean;
+    base: BaseAnchor;
+    tail: CommittedTail;
+    /** Bounded hot index cache; authoritative lookup falls back to the disk index. */
+    coldEntries: Map<string, ColdEntryIndex>;
+    indexPath: string;
+    tailPath: string;
+    commitPath: string;
+    /** Directory prefix of the persistent `.spill.parent-<bucket>` bucket files. */
+    parentPathPrefix: string;
+    /** Directory prefix of the persistent `.spill.dict-part-<partition>` partition files. */
+    dictionaryPathPrefix: string;
+    /** Path of the persistent `.spill.dict-meta` finalization file. */
+    dictionaryMetaPath: string;
+    /** Path of the persistent `.spill.metadata-delta` section. */
+    metadataDeltaPath: string;
+    retirementFirstKeptEntryId: string | undefined;
+    /** Hot-suffix byte total (accountant-bounded to ≤ 16 MiB). */
+    hotSuffixBytes: number;
+    accountant: SessionMemoryAccountant;
+    reducer: ReducerState;
+    /** Resident inline provider-affecting entries (merged order minus demoted slots). */
+    providerStateEntries: SessionEntry[];
+    /** Merged provider-list order as keys (inline + demoted); reopened/appended slots stay exact. */
+    providerStateOrder: string[];
+    blockCache: FixedCacheAccount;
+    parentChildrenCache: Map<string, {
+        ids: readonly string[];
+        bytes: number;
+        descriptor: SessionStorageStat;
+        bucketDescriptor?: SessionStorageStat;
+        bucketIndex?: number;
+    }>;
+    entryCache: FixedCacheAccount;
+    tailCache: FixedCacheAccount;
+    labelsPins: BoundedLabelsPinsStore;
+    terminalTransition: ReopenClassification | undefined;
+    reopenTransition: ReopenClassification | undefined;
+    /** SHA-256 over the exact `.spill.idx` bytes this runtime has written/adopted ("" until proven). */
+    indexDigest: string;
+    /** Descriptor of the exact index bytes whose digest was validated for cache use. */
+    validatedIndexDescriptor?: SessionStorageStat;
+    /** Live running hash of the index bytes; updated on every index append. */
+    indexHash: crypto.Hash;
+    /** Persistent bounded parent→children artifact state; absent = parent lookups fail closed. */
+    parentArtifact?: ParentArtifactRuntimeState;
+    /** Persistent bounded dictionary artifact state; absent = dictionary lookups fail closed to the cold scan. */
+    dictionary?: DictionaryArtifactRuntimeState;
+    /** Persistent metadata-delta section state; absent = no demoted provider values. */
+    metadataDelta?: MetadataDeltaArtifactRuntimeState;
+    /** Lazily built 24-bit fingerprints for O(1) fail-closed ID generation when no persistent dictionary exists. */
+    coldIdHashes?: BoundedColdIdHashSet;
+    coldIdHashesDescriptor?: SessionStorageStat;
+    /** Live observability counters (P7 live-only contract). */
+    coldEntriesRetired: number;
+    coldEntriesReloaded: number;
+    rangeReadCount: number;
+    rangeReadGenerationMismatchCount: number;
+    sidecarRebuildCount: number;
+    coldMutationPromotions: number;
+    hotOverflowTransitions: number;
+    labelDiskFallbackCount: number;
+    /** Shadow-mode eager-vs-sidecar parity mismatches observed at build time (AC10 telemetry). */
+    shadowParityMismatchCount: number;
+    /** Shadow-mode parity comparisons performed at build time (AC10 telemetry). */
+    shadowParityCheckCount: number;
+    transcriptGeneration: number;
+}
+/** Retained runtime state of the disposable parent→children artifact (block-cache charged). */
+interface ParentArtifactRuntimeState {
+    /** Exact `.spill.idx` digest the artifact covers; artifact lookups require `indexDigest === runtime.indexDigest`. */
+    indexDigest: string;
+    /** Committed per-bucket exact-byte size + sha256, updated incrementally on append. */
+    buckets: ParentBucketCommit[];
+    /** Total artifact bytes (sum of bucket sizes). */
+    totalBytes: number;
+    /** Block-cache bytes charged for this retained state; released on invalidation/wholesale release. */
+    chargedBytes: number;
+    /** On-disk byte cap enforced on append; fixed at `PARENT_CHILDREN_BUDGET_BYTES` unless a test shrinks it. */
+    budgetBytes: number;
+}
+/** Retained runtime state of the disposable dictionary artifact (block-cache charged). */
+interface DictionaryArtifactRuntimeState {
+    /** Exact `.spill.idx` digest the artifact covers; lookups require `indexDigest === runtime.indexDigest`. */
+    indexDigest: string;
+    /** Committed per-partition exact-byte size + sha256, updated incrementally on append. */
+    partitions: DictionaryPartitionCommit[];
+    /** Exact `.spill.dict-meta` bytes (size + digest). */
+    metaSize: number;
+    metaDigest: string;
+    recordCount: number;
+    uniqueTerms: number;
+    totalBytes: number;
+    /** Bounded duplicate-id diagnostics; non-empty ⇒ the artifact is never adopted. */
+    duplicateIds: readonly string[];
+    sidecarIneligible: boolean;
+    /** Block-cache bytes charged for this retained state; released on invalidation. */
+    chargedBytes: number;
+    /** On-disk byte cap for a single partition append; fixed unless a test shrinks it. */
+    budgetBytes: number;
+    /** Running per-partition hashes/sizes/records for append-time rebinding. */
+    partitionHashes: crypto.Hash[];
+    partitionSizes: number[];
+    partitionRecords: number[];
+    /** Descriptor of the exact meta bytes whose digest was validated for artifact use. */
+    validatedDescriptor?: SessionStorageStat;
+}
+/** Retained runtime state of the disposable metadata-delta section (reducer-bucket accounting). */
+interface MetadataDeltaArtifactRuntimeState {
+    /** Exact `.spill.idx` digest the sidecar set was built with. */
+    indexDigest: string;
+    /** Exact bytes of the `.spill.metadata-delta` file. */
+    size: number;
+    sha256: string;
+    /** Live running hash of the delta bytes; updated on every value append. */
+    hash: crypto.Hash;
+    /** Demoted value descriptors keyed by provider key (positions derived at marker time). */
+    byKey: Map<string, Omit<MetadataDeltaValue, "key" | "position">>;
+    /** Reducer-bucket bytes retained by the descriptors (fixed accounting, reported in stats). */
+    descriptorBytes: number;
+    /** Fixed on-disk byte cap for the section. */
+    budgetBytes: number;
+    /** Descriptor of the exact delta bytes whose digest was validated. */
+    validatedDescriptor?: SessionStorageStat;
+}
+declare class BoundedColdIdHashSet {
+    #private;
+    has(value: string): boolean;
+    add(value: string): boolean;
+    addUnique(value: string): boolean;
+}
 export type DefaultModelSelectionStage = {
     readonly entryRevision: number;
+    readonly leafRevision: number;
     readonly headerExportRevision: number;
     readonly sessionId: string;
     readonly sessionFile: string | undefined;
     readonly entries: readonly FileEntry[];
     readonly tempPath: string | undefined;
     readonly persistsToExistingFile: boolean;
+    readonly boundedCold: boolean;
+    readonly appendEntries: readonly SessionEntry[];
+    readonly sourceDescriptor: DescriptorSnapshot | undefined;
+    readonly sourceStat: SessionStorageStat | undefined;
+    readonly sourceSha256: string | undefined;
+    readonly managedAppendExpectation: ManagedBoundedAppendExpectation | undefined;
 };
 export interface SessionManagerRevisionSnapshot {
     entry: number;
@@ -346,18 +555,12 @@ export interface ResumeTailTerminal {
 }
 export interface ResumeTailError {
     kind: "error";
-    reason: "missing" | "malformed" | "unstable" | "read-failed" | "legacy_migration_disabled" | "oversized";
+    reason: "missing" | "malformed" | "unstable" | "read-failed" | "legacy_migration_disabled" | "oversized" | "context_too_large";
     size?: number;
 }
 export type SessionDirectoryMigrationPolicy = ManagedMigrationPolicy;
 export type SessionAppendPersistenceFailurePhase = "current_append" | "prior_failure";
-/**
- * Safety bound for resuming a single transcript file. Matches the managed-storage
- * per-file artifact limit (`MANAGED_ARTIFACT_MAX_FILE_BYTES`): transcripts at or above
- * this size are not loaded into memory wholesale because the decode + per-line JSON
- * parse + identity hash would OOM or stall the process (#3851). The bound is a
- * load-time guard only; it does not raise the on-disk managed-storage limit.
- */
+/** Safety bound for eager resume compatibility and managed per-file artifacts. */
 export declare const RESUME_TRANSCRIPT_MAX_BYTES: number;
 export declare const SESSION_OVERSIZED_RECOVERY_MESSAGE = "The selected session transcript is too large to resume safely. Use `gjc export <session-file>` to export its content into a new session, or remove/archive it after confirming its content is no longer needed.";
 export declare class SessionAppendPersistenceError extends Error {
@@ -383,6 +586,21 @@ export declare class SessionTranscriptOversizedError extends Error {
     readonly size: number;
     constructor(size: number);
 }
+/** Operation-peak budget for one synchronous session-context materialization. */
+export declare const SESSION_CONTEXT_MATERIALIZATION_BUDGET_BYTES: number;
+/**
+ * Thrown by the synchronous session-context builders when the materialized graph
+ * exceeds the operation budget. `instanceof`-stable across module boundaries:
+ * consumers map with `error instanceof SessionContextTooLargeError`, never by name
+ * string. The over-budget graph is never retained — the builder releases scratch
+ * before throwing and public synchronous signatures are unchanged.
+ */
+export declare class SessionContextTooLargeError extends Error {
+    readonly code: "context_too_large";
+    readonly measuredBytes: number;
+    readonly budgetBytes: number;
+    constructor(measuredBytes: number, budgetBytes?: number, options?: ErrorOptions);
+}
 export type ResumeTailInspection = ResumeTailResumable | ResumeTailTerminal | ResumeTailError;
 export interface StrictSessionOpenSuccess {
     kind: "opened";
@@ -394,16 +612,42 @@ export interface StrictSessionOpenFailure {
     message?: string;
     size?: number;
 }
-/** Exact transcript bytes and authority captured from one descriptor-bound read. */
-export interface CapturedSessionTranscriptSnapshot {
-    sourcePath: string;
-    identity: ResumeSessionIdentity;
-    content: Uint8Array;
-    storage: SessionStorage;
+/**
+ * Descriptor-bound strict-capture handle. Bounded recorded-length range reads
+ * revalidate the live source against the captured identity on every pass; no
+ * whole-transcript buffer is ever materialized by capture or fork.
+ */
+export interface TranscriptSnapshotHandle {
+    readonly sourcePath: string;
+    readonly identity: ResumeSessionIdentity;
+    readonly storage: SessionStorage;
+    /**
+     * Iterate every transcript line in bounded recorded-length reads. Each line
+     * is delivered without its trailing newline; returning `false` aborts the
+     * pass. A completed pass re-validates the running content hash against the
+     * captured identity and throws `identity-mismatch` on divergence.
+     */
+    forEachLine(callback: (line: Uint8Array) => boolean | undefined): boolean;
+    /** Descriptor captured after the most recent complete line pass, when supported. */
+    getLastReadStat(): SessionStorageStat | undefined;
+    /** Revalidate the live source against the captured identity (bounded). */
+    revalidate(): {
+        kind: "valid";
+    } | StrictSessionOpenFailure;
+    /** Idempotent close; subsequent reads throw. */
+    close(): void;
+    /**
+     * Rehydrate the full transcript bytes for bounded-full-return consumers.
+     * This is an explicit compatibility escape hatch, never used by fork/capture
+     * publication itself.
+     */
+    materialize(): Uint8Array;
 }
+/** @deprecated Use {@link TranscriptSnapshotHandle}; retained for call-site compatibility. */
+export type CapturedSessionTranscriptSnapshot = TranscriptSnapshotHandle;
 export type StrictSessionCaptureResult = {
     kind: "captured";
-    snapshot: CapturedSessionTranscriptSnapshot;
+    snapshot: TranscriptSnapshotHandle;
 } | ResumeTailError;
 export type StrictSessionForkResult = {
     kind: "forked";
@@ -521,11 +765,6 @@ export declare function migrateSessionEntries(entries: FileEntry[]): void;
 /** Exported for compaction.test.ts */
 export declare function parseSessionEntries(content: string): FileEntry[];
 export declare function getLatestCompactionEntry(entries: SessionEntry[]): CompactionEntry | null;
-/**
- * Build the session context from entries using tree traversal.
- * If leafId is provided, walks from that entry to root.
- * Handles compaction and branch summaries along the path.
- */
 export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>, sessionIdentityNamespace?: string): SessionContext;
 /** A session directory's authority is distinct from its string path. */
 export type SessionDestination = {
@@ -550,6 +789,7 @@ type ForkArtifactPublication = {
 };
 /** Exported for testing */
 export declare function loadEntriesFromFile(filePath: string, storage?: SessionStorage): Promise<FileEntry[]>;
+export declare const TRANSCRIPT_CAPTURE_CHUNK_BYTES: number;
 declare class RecentSessionInfo {
     #private;
     readonly path: string;
@@ -640,8 +880,29 @@ export declare const SessionManagerTestHooks: {
     materializedCacheMaxBytesOverride?: number;
     beforeResidentTransitionIndexBuild?: () => void;
     afterForkSnapshot?: () => void | Promise<void>;
+    afterForkTranscriptPublished?: () => void | Promise<void>;
     beforeEphemeralArtifactManagerInstall?: (dir: string) => void | Promise<void>;
+    beforePersistPatchFence?: (attempt: number) => void;
 };
+/**
+ * Freshness snapshot captured with every async whole-session persistence
+ * preparation. Immediately before the synchronous persistence transaction, the
+ * live values are compared: a `sessionFile`/`lifecycleId` change aborts (lifecycle
+ * switch); a revision change discards the prepared bytes and re-prepares (bounded),
+ * so a stale snapshot is never published.
+ */
+export interface PersistenceInputToken {
+    /** Canonical session file path the prepared bytes target. */
+    sessionFile: string;
+    /** Per-manager lifecycle identity (`sessionId@sessionFile`); changes on switch/open/reset. */
+    lifecycleId: string;
+    /** Revision of #fileEntries affecting persisted bytes. */
+    entryRevision: number;
+    /** Header/version revision affecting persisted bytes. */
+    headerRevision: number;
+    /** Resident/blob store revision affecting persisted bytes. */
+    residentBlobRevision: number;
+}
 export declare class SessionManager {
     #private;
     private cwd;
@@ -753,6 +1014,8 @@ export declare class SessionManager {
     listForResumePickerReadOnly(): Promise<SessionInfo[]>;
     getSessionId(): string;
     getSessionFile(): string | undefined;
+    getSessionMemoryStats(): SessionMemoryStats;
+    setSessionMemoryMode(mode: "off" | "shadow" | "enabled"): void;
     acquireMemoryGuardParticipantIngressLease(): MemoryGuardParticipantIngressLease;
     createMemoryGuardCheckpoint(input: MemoryGuardCreateCheckpointInput): Promise<MemoryGuardSessionManagerCheckpointV1>;
     /**
@@ -938,10 +1201,21 @@ export declare class SessionManager {
     /**
      * Get the most recent model role from the current session path.
      * Returns undefined if no model change has been recorded.
+     *
+     * R1: keyed ONLY on the nearest `model_change` on the leaf→root path — never on
+     * `hasExplicitDefaultModel`, which gates only legacy assistant inference into
+     * `models.default` inside `buildSessionContext`. Six parity cases (D1): reviewer-
+     * only → "reviewer"; temporary-only → "temporary"; interleaved → nearest;
+     * no model_change → undefined; legacy-only inference → undefined; explicit
+     * default then legacy inference → "default".
      */
     getLastModelChangeRole(): string | undefined;
     evictCompactedContent(firstKeptEntryId: string, compactionEntryId: string): EvictCompactedContentResult;
     getObservabilityStatsForTests(): SessionManagerObservabilityStats;
+    setSidecarHotSuffixBudgetForTests(bytes: number): void;
+    parentChildrenCacheKeysForTests(): string[];
+    parentArtifactEnabledForTests(): boolean;
+    setParentArtifactBudgetForTests(bytes: number): void;
     hotRetainedMessageCharsForTests(): number;
     getCanonicalEntryForTests(id: string): SessionEntry | undefined;
     getEntryForFidelity(id: string): SessionEntry | undefined;
@@ -952,6 +1226,7 @@ export declare class SessionManager {
      * sync; callers must not mutate returned entries.
      */
     getActivePathEntriesCanonical(fromId?: string): SessionEntry[];
+    visitEntriesForExport(visitor: (entry: SessionEntry) => void): void;
     getEntriesForExport(): SessionEntry[];
     getEntry(id: string): SessionEntry | undefined;
     /**
@@ -1046,14 +1321,14 @@ export declare class SessionManager {
      * Fork a session into the current project directory.
      * Copies history from another session file while creating a new session file in the current sessionDir.
      */
-    static forkFrom(sourcePath: string, cwd: string, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<SessionManager>;
+    static forkFrom(sourcePath: string, cwd: string, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy, sessionMemoryMode?: "off" | "shadow" | "enabled"): Promise<SessionManager>;
     /**
      * Open a specific session file.
      * @param path Path to session file
      * @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
      */
-    static open(filePath: string, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<SessionManager>;
-    static openNestedManaged(filePath: string, destination: SessionDestination, store: ManagedSessionDescendantStore, storage?: SessionStorage, cwdOverride?: string): Promise<SessionManager>;
+    static open(filePath: string, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy, sessionMemoryMode?: "off" | "shadow" | "enabled"): Promise<SessionManager>;
+    static openNestedManaged(filePath: string, destination: SessionDestination, store: ManagedSessionDescendantStore, storage?: SessionStorage, cwdOverride?: string, sessionMemoryMode?: "off" | "shadow" | "enabled"): Promise<SessionManager>;
     /**
      * List default-managed sessions for the resume picker without recovery or other
      * maintenance writes. This is the only picker inventory that includes legacy
@@ -1075,7 +1350,7 @@ export declare class SessionManager {
      * revalidate captured authority before destination initialization and transcript
      * persistence; destination history always comes from the captured bytes.
      */
-    static forkFromCaptured(snapshot: CapturedSessionTranscriptSnapshot, cwd: string, destinationInput?: SessionDestinationInput, _migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<StrictSessionForkResult>;
+    static forkFromCaptured(snapshot: CapturedSessionTranscriptSnapshot, cwd: string, destinationInput?: SessionDestinationInput, _migrationPolicy?: SessionDirectoryMigrationPolicy, sessionMemoryMode?: "off" | "shadow" | "enabled"): Promise<StrictSessionForkResult>;
     static restoreMemoryGuardCheckpoint(input: MemoryGuardRestoreInput): Promise<MemoryGuardRestoreResult>;
     /** Inspect a selected session without acquiring write-capable ownership. */
     static inspectSessionTailReadOnly(filePath: string, storage?: SessionStorage): Promise<ResumeTailInspection>;
@@ -1096,13 +1371,13 @@ export declare class SessionManager {
      * the returned discriminant; an error result never creates, rewrites, or adopts
      * the selected path. Breadcrumb ownership begins only after `kind: "opened"`.
      */
-    static openExistingStrict(identity: ResumeSessionIdentity, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<StrictSessionOpenResult>;
+    static openExistingStrict(identity: ResumeSessionIdentity, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy, sessionMemoryMode?: "off" | "shadow" | "enabled"): Promise<StrictSessionOpenResult>;
     /**
      * Continue the most recent session, or create new if none.
      * @param cwd Working directory
      * @param sessionDir Optional session directory. If omitted, uses default (~/.gjc/agent/sessions/<encoded-cwd>/).
      */
-    static continueRecent(cwd: string, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<SessionManager>;
+    static continueRecent(cwd: string, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy, sessionMemoryMode?: "off" | "shadow" | "enabled"): Promise<SessionManager>;
     /** Create an in-memory session (no file persistence) */
     static inMemory(cwd?: string, storage?: SessionStorage): SessionManager;
     /**