@kodax-ai/kodax 0.7.78 → 0.7.80

package/dist/types-chunks/{public-api.d-B3AohsxN.d.ts → public-api.d-CewTvUKV.d.ts}

@@ -1,6 +1,6 @@
-import { a as BashPrefixExtractor, t as KodaXAgentMode } from './bash-prefix-extractor.d-uAe2Oqda.js';
-import { F as KodaXReasoningMode, k as KodaXMessage, S as KodaXTaskResultMetadata } from './types.d-DIpZJKUl.js';
-import { cP as LearningSurfaceSnapshot$1, cK as LearningQuery, cJ as LearningPage, cm as LearnedCapabilityRecord, cF as LearningEvent, cO as LearningSubscribeOptions, bP as KodaXSessionData, bU as KodaXSessionLineage, bZ as KodaXSessionNavigationOptions, b$ as KodaXSessionRuntimeInfo, c1 as KodaXSessionStorage, j as AgentActorSnapshot, aU as CompactionReport, bF as KodaXJsonValue } from './types.d-BA-Jwpfs.js';
+import { a as BashPrefixExtractor, t as KodaXAgentMode } from './bash-prefix-extractor.d-DStqKIlu.js';
+import { G as KodaXReasoningMode, k as KodaXMessage, T as KodaXTaskResultMetadata } from './types.d-CgrXrFrq.js';
+import { cY as LearningSurfaceSnapshot$1, cT as LearningQuery, cS as LearningPage, cv as LearnedCapabilityRecord, cO as LearningEvent, cX as LearningSubscribeOptions, bY as KodaXSessionData, c1 as KodaXSessionLineage, c6 as KodaXSessionNavigationOptions, c8 as KodaXSessionRuntimeInfo, ca as KodaXSessionStorage, bZ as KodaXSessionEntry, bU as KodaXSessionArtifactLedgerEntry, bC as KodaXExtensionSessionRecord, cc as KodaXSessionUiHistoryItem, c9 as KodaXSessionScope, k as AgentActorSnapshot, aX as CompactionReport, bO as KodaXJsonValue } from './controller.d-C2aHqzHj.js';
 
 /**
  * TextBuffer - Text buffer management class - 文本缓冲区管理类
@@ -266,19 +266,7 @@ interface ConfirmResult {
     always?: boolean;
     runtimeGrantKind?: 'session' | 'persistent';
 }
-/**
- * Tools that mutate the local filesystem AND accept a `path` input.
- * Eligible for plan-mode's path-aware escape (writes to
- * `.agent/plan_mode_doc.md` or the system temp dir are permitted; all
- * other paths block).
- *
- * Derived from metadata: `sideEffect === 'mutates-fs'` AND
- * `requiredParams.includes('path')`. Tools that mutate the FS without a
- * `path` input (`undo`, `worktree_*`, construction-staircase tools) are
- * NOT in this set — their plan-mode block reason is computed elsewhere
- * via `isToolPlanModeAllowed()` instead of a path check.
- */
-declare const FILE_MODIFICATION_TOOLS: Set<string>;
+
 interface PermissionContext {
     permissionMode: PermissionMode;
     confirmTools: Set<string>;
@@ -897,13 +885,182 @@ declare class MemorySessionStorage implements SessionStorage {
 }
 declare function createMemorySessionStorage(): SessionStorage;
 
+type SessionConversationHistoryStatus = 'resolved' | 'partial' | 'ambiguous';
+type SessionConversationHistoryIssueCode = 'active_entry_missing' | 'compaction_boundary_invalid' | 'compaction_predecessor_ambiguous' | 'compaction_predecessor_missing' | 'legacy_overlap_ambiguous' | 'lineage_path_incomplete' | 'lineage_unavailable' | 'logical_identity_conflict';
+interface SessionConversationHistoryIssue {
+    readonly code: SessionConversationHistoryIssueCode;
+    readonly message: string;
+    /** Number of diagnostics of this code represented by this bounded summary. */
+    readonly occurrenceCount: number;
+    /** Total evidence references before `entryIds` was bounded. */
+    readonly entryCount: number;
+    readonly entryIds: readonly string[];
+}
+/**
+ * One SDK-resolved conversation item. `auditEntryIds` names every proven
+ * physical copy represented by it; raw bodies remain in the audit API.
+ */
+interface SessionConversationHistoryEntry {
+    readonly boundaryId?: string;
+    readonly auditEntryIds: readonly string[];
+    readonly message: KodaXMessage;
+}
+interface SessionConversationHistoryData {
+    readonly sourceRevision: string;
+    readonly status: SessionConversationHistoryStatus;
+    readonly entries: readonly SessionConversationHistoryEntry[];
+    readonly issues: readonly SessionConversationHistoryIssue[];
+}
+declare function emptyConversationEntryChain(): string;
+declare function extendConversationEntryChain(previous: string, entries: readonly SessionConversationHistoryEntry[]): string;
+declare function createConversationEntryChain(entries: readonly SessionConversationHistoryEntry[]): string;
+declare function createSessionConversationHistoryRevision(history: SessionConversationHistoryData, entryChain?: string): string;
+
+type SessionSourceFileKind = 'main' | 'islands' | 'legacy_archive';
+interface SessionSourceFileRevisionState {
+    readonly kind: SessionSourceFileKind;
+    readonly relativePath: string;
+    readonly byteLength: number;
+    readonly chunkCount: number;
+    readonly chain: string;
+    /** Canonical base64 for the final incomplete source chunk. */
+    readonly tail: string;
+}
+interface SessionSourceRevisionState {
+    readonly version: 1;
+    readonly files: readonly SessionSourceFileRevisionState[];
+}
+
+interface ConversationPageCacheAdmission {
+    readonly surface?: string;
+    readonly profileId?: string;
+}
+interface ConversationPageCacheInput {
+    readonly expectedRevision?: string;
+    readonly end?: number;
+    readonly limit: number;
+    readonly maxPageBytes: number;
+    readonly maxInlineEntryBytes: number;
+    readonly reservedBytes: number;
+    readonly authorize?: (admission: ConversationPageCacheAdmission) => void | Promise<void>;
+    readonly signal?: AbortSignal;
+}
+interface ConversationPageCacheEntry {
+    readonly index: number;
+    readonly boundaryId?: string;
+    readonly byteLength: number;
+    readonly oversized: boolean;
+    readonly entry?: SessionConversationHistoryEntry;
+}
+interface ConversationPageCachePage {
+    readonly revision: string;
+    readonly sourceRevision: string;
+    readonly status: SessionConversationHistoryStatus;
+    readonly issues: readonly SessionConversationHistoryIssue[];
+    readonly entries: readonly ConversationPageCacheEntry[];
+    readonly hasMore: boolean;
+    readonly nextEnd?: number;
+}
+interface ConversationPageCacheChunkInput {
+    readonly revision: string;
+    readonly entryIndex: number;
+    readonly offset: number;
+    readonly authorize?: (admission: ConversationPageCacheAdmission) => void | Promise<void>;
+    readonly signal?: AbortSignal;
+}
+interface ConversationPageCacheChunk {
+    readonly revision: string;
+    readonly entryIndex: number;
+    readonly boundaryId?: string;
+    readonly data: Buffer;
+    readonly nextOffset?: number;
+}
+declare class ConversationPageCacheCapacityError extends Error {
+    constructor();
+}
+
 /**
  * KodaX session storage - filesystem implementation.
  */
 
+/**
+ * Opaque process-local boundary for a prepared, append-only Session write.
+ * Obtain a fresh value from {@link FileSessionStorage.prepareSessionAppend};
+ * a committed append consumes the boundary. It returns a reusable successor
+ * when that successor can be witnessed safely, or `null` when the caller must
+ * reload before another append.
+ */
+interface PreparedSessionAppendBaseline {
+    readonly sessionId: string;
+    readonly revision: string;
+    readonly lineageCount: number;
+    readonly artifactCount: number;
+    readonly extensionCount: number;
+    readonly activeEntryId: string | null;
+    readonly tag?: string;
+}
+/**
+ * An explicit append-only delta. Historical arrays are intentionally absent:
+ * callers that need to rewrite existing Session data must use
+ * {@link FileSessionStorage.appendSessionDelta}, which performs an exact merge.
+ */
+interface PreparedSessionTailDelta {
+    readonly baseline: PreparedSessionAppendBaseline;
+    readonly title: string;
+    readonly activeEntryId: string | null;
+    readonly lineageEntries: readonly KodaXSessionEntry[];
+    readonly artifactEntries?: readonly KodaXSessionArtifactLedgerEntry[];
+    readonly extensionRecords?: readonly KodaXExtensionSessionRecord[];
+    readonly uiHistory?: readonly KodaXSessionUiHistoryItem[];
+    readonly scope?: KodaXSessionScope;
+}
+type SessionReadErrorCode = 'data_corrupt' | 'data_changed' | 'version_incompatible' | 'read_timeout' | 'read_cancelled';
+declare class SessionReadError extends Error {
+    readonly code: SessionReadErrorCode;
+    constructor(code: SessionReadErrorCode, message: string);
+}
+interface SessionReadOptions {
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+/** Immutable read boundary used by conversation-history fork/rewind. */
+interface SessionHistoryBoundary {
+    readonly sourceRevision: string;
+}
+interface SessionReadSnapshot {
+    readonly data: SessionData;
+    readonly lineage: KodaXSessionLineage | null;
+    /** Exact identity of the immutable persisted bundle used for this capture. */
+    readonly sourceRevision: string;
+    /** Incrementally extendable witness for the exact persisted bundle revision. */
+    readonly sourceRevisionState: SessionSourceRevisionState;
+    /** Stat-derived witness for prepared-page validation at this exact capture. */
+    readonly boundaryRevision: string;
+}
+type StableFileIdentity = {
+    readonly dev: bigint;
+    readonly ino: bigint;
+    readonly size: bigint;
+    readonly mtimeNs: bigint;
+    readonly ctimeNs: bigint;
+};
+type SessionTopologyIdentity = {
+    readonly root: StableFileIdentity;
+    readonly epoch: string | null;
+    readonly writerScope: 'session' | 'global';
+    readonly writerIdentity: StableFileIdentity | null;
+    readonly activeWriterIdentity: StableFileIdentity | null;
+};
+type SessionLocationTraversalBoundary = {
+    readonly topologyBefore?: SessionTopologyIdentity;
+    readonly writerTopologyDigestBefore?: string;
+    readonly topologyMutationBefore: boolean;
+};
 declare class FileSessionStorage implements KodaXSessionStorage {
     private readonly sessionsDir;
     private readonly configHome;
+    private readonly sessionLocations;
+    private readonly verifiedLocationMisses;
     /**
      * v0.7.46 — optional explicit project cwd for in-process embedders
      * (KodaX Space) serving multiple projects from a single runtime.
@@ -933,21 +1090,50 @@ declare class FileSessionStorage implements KodaXSessionStorage {
     });
     /** Absolute session root used by this storage instance. */
     getSessionsDir(): string;
+    /**
+     * Return the current one-shot boundary for an explicit tail-only append.
+     * A full save/load initializes this boundary; every successful write rotates
+     * it so stale or concurrent deltas fail with `data_changed`.
+     */
+    private currentPreparedSessionAppend;
+    /**
+     * Prepare an authenticated one-shot boundary for a bounded tail append.
+     * Returns `null` when no canonical cache witness is available; callers must
+     * then load/rebuild or use the exact full-snapshot append path.
+     */
+    prepareSessionAppend(id: string): Promise<PreparedSessionAppendBaseline | null>;
+    /** @internal Register main paths found by one list traversal. */
+    indexSessionLocations(filePaths: readonly string[], globallyVerified: boolean, topologyIdentity?: SessionTopologyIdentity): void;
+    /** @internal Start an authoritative all-project locator traversal. */
+    beginSessionLocationTraversal(): SessionLocationTraversalBoundary;
+    /** @internal Commit locator hints only when the whole traversal was stable. */
+    completeSessionLocationTraversal(boundary: SessionLocationTraversalBoundary, filePaths: readonly string[], traversalComplete: boolean): void;
     private writeQueues;
     private serializedWrite;
+    private refreshSelfVerifiedLocationTopology;
     private sessionWriteLockPath;
+    private persistSessionLocationHint;
+    private resolveSessionLocationHint;
     private appendState;
-    private sessionDirCache;
+    private lineageIdentityFilterHashes;
     private projectJsonWritten;
     private migrationPromise?;
     private ensureMigrated;
-    /** Update watermarks. Only overwrites fields the caller actually provided. */
+    /** Update watermarks without retaining or serializing the full Session graph. */
     private syncAppendState;
+    private syncAppendStateFromFile;
     private legacyFlatPath;
     private legacyFlatArchivePath;
     private projectDir;
     /** Resolve (and cache) the project directory a write for `id` should land in. */
     private resolveWriteDir;
+    private isLocationGloballyVerified;
+    private verifiedLocationTopology;
+    private verifiedMissingLocationTopology;
+    private assertLocationTopologyUnchanged;
+    private readSessionTopologyIdentitySync;
+    private advanceSessionLocationTopology;
+    private withSessionLocationTopologyChange;
     private writeFilePath;
     /**
      * id-only locator (ADR-038 §7). Resolution order:
@@ -960,22 +1146,51 @@ declare class FileSessionStorage implements KodaXSessionStorage {
      * returns null with a warning rather than guessing.
      */
     private resolveSessionLocation;
+    private resolveAmbiguousSessionLocation;
     private readSession;
     private readArchivedEntries;
+    private completeConversationLineage;
     private appendIslandArchive;
     /** Write `<dir>/project.json` once per process per directory (best-effort). */
     private ensureProjectJson;
+    private rebuildConversationCache;
+    private updateConversationCacheAfterAppend;
     private writeSessionInternal;
     private mergeAndWriteInternal;
     appendSessionDelta(id: string, data: SessionData): Promise<void>;
-    private shouldRunMaintenance;
-    private runMaintenance;
+    /**
+     * Append an explicit new tail without accepting any historical prefix.
+     * A fulfilled non-null value means the append committed and its successor
+     * boundary is reusable. A fulfilled `null` also means the append committed,
+     * but the successor could not be witnessed: reload and do not retry the same
+     * tail. Pre-commit validation conflicts reject with `data_changed`.
+     */
+    appendPreparedSessionTail(id: string, delta: PreparedSessionTailDelta): Promise<PreparedSessionAppendBaseline | null>;
     save(id: string, data: SessionData): Promise<void>;
+    /**
+     * Fast creation path for IDs produced by KodaX's timestamp + random-bit
+     * generator. The per-ID cross-process lock and exact target check preserve
+     * atomic creation without an all-project negative lookup. Caller-supplied
+     * IDs must continue through the ordinary global conflict check.
+    */
+    createGenerated(id: string, data: SessionData): Promise<void>;
     mutateLineage(id: string, mutation: (lineage: KodaXSessionLineage) => KodaXSessionLineage): Promise<boolean>;
     /** F270/F269 owner mutation: CAS-update only the Actor section of a session snapshot. */
     saveActorSnapshot(id: string, snapshot: AgentActorSnapshot, expectedRevision: number): Promise<void>;
     /** Read Session data without recovery writes or append-watermark mutation. */
     peek(id: string): Promise<SessionData | null>;
+    /** Strict read-only Session load. It never migrates or repairs persisted data. */
+    read(id: string, options?: SessionReadOptions): Promise<SessionData | null>;
+    readConversationPageCache(id: string, input: ConversationPageCacheInput, options?: SessionReadOptions): Promise<ConversationPageCachePage | null>;
+    readConversationPageBoundary(id: string, options?: SessionReadOptions): Promise<{
+        readonly boundaryRevision: string;
+        readonly admission: ConversationPageCacheAdmission;
+    } | null>;
+    prepareConversationPageCache(id: string, history: SessionConversationHistoryData, lineage: KodaXSessionLineage, runtimeInfo: KodaXSessionRuntimeInfo | undefined, boundaryRevision: string, sourceRevisionState: SessionSourceRevisionState, options?: SessionReadOptions): Promise<void>;
+    readConversationPageCacheChunk(id: string, input: ConversationPageCacheChunkInput, options?: SessionReadOptions): Promise<ConversationPageCacheChunk | null>;
+    /** Stable read-only main + sidecar snapshot with no lock or migration writes. */
+    readFullSnapshot(id: string, options?: SessionReadOptions): Promise<SessionReadSnapshot | null>;
+    private readFullSnapshotAtPath;
     load(id: string): Promise<SessionData | null>;
     isArchived(id: string): Promise<boolean>;
     getLineage(id: string): Promise<KodaXSessionLineage | null>;
@@ -983,11 +1198,14 @@ declare class FileSessionStorage implements KodaXSessionStorage {
     setActiveEntry(id: string, selector: string, options?: {
         summarizeCurrentBranch?: boolean;
     }): Promise<SessionData | null>;
-    rewind(id: string, selector?: string): Promise<SessionData | null>;
+    rewind(id: string, selector?: string, options?: {
+        historyBoundary?: SessionHistoryBoundary;
+    }): Promise<SessionData | null>;
     setLabel(id: string, selector: string, label?: string): Promise<SessionData | null>;
     fork(id: string, selector?: string, options?: {
         sessionId?: string;
         title?: string;
+        historyBoundary?: SessionHistoryBoundary;
     }): Promise<{
         sessionId: string;
         data: SessionData;
@@ -1023,13 +1241,15 @@ declare class FileSessionStorage implements KodaXSessionStorage {
      */
     archive(id: string): Promise<boolean>;
     archiveOwned(id: string, ownerId: string): Promise<boolean>;
+    private sessionConversationCacheMainPaths;
+    private removeSessionConversationCaches;
     private archiveWithActorOwner;
     /** Restore an archived session back into its project directory. */
     unarchive(id: string): Promise<boolean>;
     unarchiveOwned(id: string, ownerId: string): Promise<boolean>;
     private unarchiveWithActorOwner;
     /**
-     * Move a session + its island sidecar between two directories. Propagates a
+     * Move a session + modern and legacy island sidecars between two directories. Propagates a
      * non-ENOENT rename error (e.g. Windows file-in-use) so a partial move is
      * surfaced as a failure instead of silently splitting main + sidecar.
      */
@@ -1055,9 +1275,10 @@ declare class FileSessionStorage implements KodaXSessionStorage {
      * `cleanup.ts` (`unlinkIfOld`). Bounds the sessions directory so it never
      * accumulates unboundedly — which is what keeps `list()`'s head-read pass
      * fast (its cost scales with file COUNT, not size). A non-positive /
-     * non-finite `retentionDays` disables cleanup (no-op). Best-effort: per-file
-     * errors are isolated so a single locked/racing file never aborts the
-     * sweep. Durable Actor owners and non-terminal turns are never eligible.
+     * non-finite `retentionDays` disables cleanup (no-op). The sweep continues
+     * after individual failures, then reports them together so cleanup is
+     * observable and retryable. Durable Actor owners and non-terminal turns are
+     * never eligible.
      * Returns the number of files removed.
      */
     cleanupOldSessions(retentionDays: number): Promise<number>;
@@ -1177,10 +1398,54 @@ interface SessionTranscriptEntry {
     readonly taskResults?: readonly KodaXTaskResultMetadata[];
 }
 interface FullTranscriptSessionData extends Omit<SessionData, 'messages'> {
+    /** Legacy flattened projection. Rewind markers are excluded. */
     readonly messages: KodaXMessage[];
+    /** Messages on the active branch that are eligible for model context. */
     readonly activeMessages: KodaXMessage[];
+    /**
+     * Authoritative raw append-order audit entries, including archived islands
+     * and inactive branches. The host owns visibility, folding, and presentation.
+     */
     readonly transcriptEntries: SessionTranscriptEntry[];
 }
+/** One immutable storage boundary shared by Runtime admission and history. */
+interface SessionReadCapture {
+    readonly data: SessionData;
+    readonly transcript: FullTranscriptSessionData;
+    readonly sourceRevision: string;
+    /** Internal exact-revision witness used to extend prepared page caches. */
+    readonly sourceRevisionState: SessionSourceRevisionState;
+    /** Bounded persisted-file witness corresponding to sourceRevision. */
+    readonly boundaryRevision: string;
+}
+type SessionBundleExportStatus = 'ok' | 'partial' | 'unsupported' | 'corrupt' | 'ambiguous' | 'missing';
+interface SessionBundleExportFile {
+    readonly kind: 'main' | 'islands' | 'legacy_archive';
+    readonly path: string;
+    readonly byteLength: number;
+    readonly sha256: string;
+    readonly modifiedAt: string;
+    /** Best-effort UTF-8 projection for inspection and JSONL diagnostics. */
+    readonly content: string;
+    /** Canonical byte-preserving representation. */
+    readonly contentBase64: string;
+}
+interface SessionBundleExportDiagnostic {
+    readonly code: 'partial_tail' | 'malformed_record' | 'unsupported_record' | 'unsupported_version';
+    readonly file: string;
+    readonly line?: number;
+    readonly message: string;
+}
+interface SessionBundleExportResult {
+    readonly sessionId: string;
+    readonly status: SessionBundleExportStatus;
+    readonly files: readonly SessionBundleExportFile[];
+    readonly candidates?: readonly string[];
+    readonly diagnostics: readonly SessionBundleExportDiagnostic[];
+}
+interface SessionBundleExportOptions extends SessionReadOptions {
+    readonly sessionsDir?: string;
+}
 interface AppendClientNoticeOptions {
     readonly source?: string;
     readonly content: string;
@@ -1229,6 +1494,9 @@ interface SessionManager {
     listSessions: typeof listSessions;
     loadSession: typeof loadSession;
     loadFullTranscript: typeof loadFullTranscript;
+    readFullTranscript: typeof readFullTranscript;
+    readConversationHistory: typeof readConversationHistory;
+    readSessionCapture(id: string, options?: SessionReadOptions): Promise<SessionReadCapture | null>;
     appendClientNotice: typeof appendClientNotice;
     forkSession: typeof forkSession;
     rewindSession: typeof rewindSession;
@@ -1265,11 +1533,32 @@ declare function loadSession(id: string): Promise<SessionData | null>;
 /**
  * Load append-order transcript data by ID.
  *
- * `loadSession` remains the active model-context API. This helper is for UI
- * scrollback: it returns every persisted transcript-bearing lineage entry in
- * append order and keeps the active branch in `activeMessages`.
+ * `loadSession` remains the active model-context API. This helper returns raw
+ * host-facing scrollback/audit data, including archived islands and inactive
+ * branches, in append order. Hosts decide what to show or fold.
  */
 declare function loadFullTranscript(id: string): Promise<FullTranscriptSessionData | null>;
+/**
+ * Strict, boundary-consistent history read.
+ *
+ * Unlike the legacy null-on-error helper, this never migrates or repairs the
+ * Session and preserves structured read errors for the host.
+ */
+declare function readFullTranscript(id: string, options?: SessionReadOptions): Promise<FullTranscriptSessionData | null>;
+/**
+ * Read the SDK-resolved ordinary conversation view at one immutable boundary.
+ * Raw append-order audit data remains available through `readFullTranscript`.
+ */
+declare function readConversationHistory(id: string, options?: SessionReadOptions): Promise<SessionConversationHistoryData | null>;
+/** Build the conversation projection from an already captured read boundary. */
+declare function conversationHistoryFromCapture(capture: SessionReadCapture, checkpoint?: () => void): SessionConversationHistoryData;
+declare function readSessionCapture(id: string, options?: SessionReadOptions): Promise<SessionReadCapture | null>;
+/**
+ * Export the exact persisted Session bundle without migration, recovery, or
+ * schema rewriting. Unknown and malformed records remain byte-for-byte intact
+ * and are described by diagnostics instead of being discarded.
+ */
+declare function exportSessionBundle(id: string, options?: SessionBundleExportOptions): Promise<SessionBundleExportResult>;
 /**
  * Append a host-owned transcript notice that never enters model context.
  *
@@ -1278,15 +1567,25 @@ declare function loadFullTranscript(id: string): Promise<FullTranscriptSessionDa
  * `loadSession()` keeps returning only the active model messages.
  */
 declare function appendClientNotice(id: string, options: AppendClientNoticeOptions): Promise<SessionTranscriptEntry | null>;
+interface SessionConversationMutationBoundary {
+    readonly boundaryId: string;
+    readonly sourceRevision: string;
+}
+interface ForkSessionOptions {
+    readonly selector?: string;
+    readonly sessionId?: string;
+    readonly title?: string;
+    readonly historyBoundary?: SessionConversationMutationBoundary;
+}
+interface RewindSessionOptions {
+    readonly selector?: string;
+    readonly historyBoundary?: SessionConversationMutationBoundary;
+}
 /**
  * Fork a session at an optional selector.
  * Returns null for a missing session. NEVER throws.
  */
-declare function forkSession(id: string, opts?: {
-    selector?: string;
-    sessionId?: string;
-    title?: string;
-}): Promise<{
+declare function forkSession(id: string, opts?: ForkSessionOptions): Promise<{
     sessionId: string;
     data: SessionData;
 } | null>;
@@ -1294,9 +1593,7 @@ declare function forkSession(id: string, opts?: {
  * Rewind a session to a previous user entry.
  * Returns null for a missing session. NEVER throws.
  */
-declare function rewindSession(id: string, opts?: {
-    selector?: string;
-}): Promise<SessionData | null>;
+declare function rewindSession(id: string, opts?: RewindSessionOptions): Promise<SessionData | null>;
 /**
  * Set the active lineage entry by selector.
  * Returns null for a missing session. NEVER throws.
@@ -1381,5 +1678,5 @@ declare function createSessionManager(opts?: {
     configHome?: string;
 }): SessionManager;
 
-export { KeypressHandlerPriority as B, DEFAULT_UI_STATE as D, FILE_MODIFICATION_TOOLS as F, MemorySessionStorage as M, PERMISSION_MODES as P, StreamingState as a0, TOOL_STATUS_ICONS as a2, TextBuffer as a3, ToolCallStatus as a9, appendClientNotice as ag, archiveSession as ah, compactSession as ai, computeConfirmTools as aj, createMemorySessionStorage as ak, createSessionManager as al, deleteSession as am, forkSession as an, isPermissionMode as ao, listRunningSessions as ap, listSessions as aq, loadFullTranscript as ar, loadSession as as, normalizePermissionMode as at, permissionModeDisplayName as au, rewindSession as av, setActiveEntry as aw, unarchiveSession as ax, watchSessions as ay, FileSessionStorage as j };
-export type { StatusBarProps as $, AppProps as A, CompactSessionOptions as C, LearningSurfaceSnapshot as E, LegacyMessageListProps as G, HistoryEntry as H, InputPromptProps as I, ListSessionsOptions as J, KeyInfo as K, LearningBinding as L, Message as N, PastedContent as O, PermissionContext as Q, PermissionMode as R, PromptEditingMode as S, PromptSubmitPayload as T, RunningSessionInfo as U, SessionData as V, SessionManager as W, SessionStorage as X, SessionSummary as Y, SessionTranscriptEntry as Z, SessionTranscriptEntryType as _, AppState as a, Suggestion as a1, TextBufferOptions as a4, Theme as a5, ThemeColors as a6, ThemeSymbols as a7, ToolCall as a8, UIActions as aa, UIState as ab, UseTextBufferReturn as ac, VisualCursor as ad, VisualLayout as ae, WatchSessionsCallback as af, AppendClientNoticeOptions as b, CompactSessionResult as c, Completer as d, Completion as e, ConfirmResult as f, CreatableHistoryItem as g, CursorPosition as h, DeleteSessionResult as i, FullTranscriptSessionData as k, HistoryItem as l, HistoryItemAssistant as m, HistoryItemBase as n, HistoryItemError as o, HistoryItemEvent as p, HistoryItemHint as q, HistoryItemInfo as r, HistoryItemSidecar as s, HistoryItemSystem as t, HistoryItemThinking as u, HistoryItemToolGroup as v, HistoryItemType as w, HistoryItemUser as x, KeypressEvent as y, KeypressHandler as z };
+export { DEFAULT_UI_STATE as D, KeypressHandlerPriority as E, FileSessionStorage as F, MemorySessionStorage as N, PERMISSION_MODES as P, archiveSession as aA, compactSession as aB, computeConfirmTools as aC, conversationHistoryFromCapture as aD, createConversationEntryChain as aE, createMemorySessionStorage as aF, createSessionConversationHistoryRevision as aG, createSessionManager as aH, deleteSession as aI, emptyConversationEntryChain as aJ, exportSessionBundle as aK, extendConversationEntryChain as aL, forkSession as aM, isPermissionMode as aN, listRunningSessions as aO, listSessions as aP, loadFullTranscript as aQ, loadSession as aR, normalizePermissionMode as aS, permissionModeDisplayName as aT, readConversationHistory as aU, readFullTranscript as aV, readSessionCapture as aW, rewindSession as aX, setActiveEntry as aY, unarchiveSession as aZ, watchSessions as a_, SessionReadError as ab, StreamingState as aj, TOOL_STATUS_ICONS as al, TextBuffer as am, ToolCallStatus as as, appendClientNotice as az, ConversationPageCacheCapacityError as g };
+export type { SessionBundleExportOptions as $, AppProps as A, KeypressHandler as B, CompactSessionOptions as C, LearningSurfaceSnapshot as G, HistoryEntry as H, InputPromptProps as I, LegacyMessageListProps as J, KeyInfo as K, LearningBinding as L, ListSessionsOptions as M, Message as O, PastedContent as Q, PermissionContext as R, PermissionMode as S, PreparedSessionAppendBaseline as T, PreparedSessionTailDelta as U, PromptEditingMode as V, PromptSubmitPayload as W, RewindSessionOptions as X, RunningSessionInfo as Y, SessionBundleExportDiagnostic as Z, SessionBundleExportFile as _, AppState as a, SessionBundleExportResult as a0, SessionBundleExportStatus as a1, SessionConversationHistoryData as a2, SessionConversationHistoryEntry as a3, SessionConversationHistoryIssue as a4, SessionConversationHistoryIssueCode as a5, SessionConversationHistoryStatus as a6, SessionConversationMutationBoundary as a7, SessionData as a8, SessionManager as a9, SessionReadCapture as aa, SessionReadErrorCode as ac, SessionReadOptions as ad, SessionStorage as ae, SessionSummary as af, SessionTranscriptEntry as ag, SessionTranscriptEntryType as ah, StatusBarProps as ai, Suggestion as ak, TextBufferOptions as an, Theme as ao, ThemeColors as ap, ThemeSymbols as aq, ToolCall as ar, UIActions as at, UIState as au, UseTextBufferReturn as av, VisualCursor as aw, VisualLayout as ax, WatchSessionsCallback as ay, AppendClientNoticeOptions as b, CompactSessionResult as c, Completer as d, Completion as e, ConfirmResult as f, CreatableHistoryItem as h, CursorPosition as i, DeleteSessionResult as j, ForkSessionOptions as k, FullTranscriptSessionData as l, HistoryItem as m, HistoryItemAssistant as n, HistoryItemBase as o, HistoryItemError as p, HistoryItemEvent as q, HistoryItemHint as r, HistoryItemInfo as s, HistoryItemSidecar as t, HistoryItemSystem as u, HistoryItemThinking as v, HistoryItemToolGroup as w, HistoryItemType as x, HistoryItemUser as y, KeypressEvent as z };

package/dist/types-chunks/{repl.d-Ie_ZXb_U.d.ts → repl.d-DvXQtgr7.d.ts}

@@ -1,8 +1,8 @@
-import { n as ResolvedAutoModeSettings, b as CommandDefinition, e as CommandSource, c as CommandInfo, C as Command$1, I as InteractiveContext, a as CommandCallbacks, g as CurrentConfig, d as CommandInvocationRequest, f as CommandWorkflowInvocationRequest, p as RuntimeSurfaceStatus } from './utils.d-CVp6bFl9.js';
-import { X as SessionStorage$1, R as PermissionMode, L as LearningBinding } from './public-api.d-B3AohsxN.js';
-import { a1 as KodaXOptions, ad as KodaXResult } from './bash-prefix-extractor.d-uAe2Oqda.js';
-import { c1 as KodaXSessionStorage, bP as KodaXSessionData } from './types.d-BA-Jwpfs.js';
-import { s as AutoModeStats } from './guardrail.d-CXDYRgZ3.js';
+import { n as ResolvedAutoModeSettings, b as CommandDefinition, e as CommandSource, c as CommandInfo, C as Command$1, I as InteractiveContext, a as CommandCallbacks, g as CurrentConfig, d as CommandInvocationRequest, f as CommandWorkflowInvocationRequest, p as RuntimeSurfaceStatus } from './utils.d-BpACJmzt.js';
+import { ae as SessionStorage$1, S as PermissionMode, L as LearningBinding } from './public-api.d-CewTvUKV.js';
+import { a1 as KodaXOptions, ad as KodaXResult } from './bash-prefix-extractor.d-DStqKIlu.js';
+import { ca as KodaXSessionStorage, bY as KodaXSessionData } from './controller.d-C2aHqzHj.js';
+import { s as AutoModeStats } from './guardrail.d-DM-OK0m3.js';
 
 interface ReplRuntimePermissionGrantSuggestion {
     readonly id: string;

package/dist/types-chunks/{resolver.d-iAQ9ocLB.d.ts → resolver.d-C9IW4fmU.d.ts}

@@ -1,6 +1,6 @@
-import { F as KodaXReasoningMode, M as KodaXStableEffortIntent, a9 as KodaXWireReasoningEffort, G as KodaXReasoningProfile, Z as KodaXThinkingBudgetMap, _ as KodaXThinkingDepth, q as KodaXProviderConfig, B as KodaXReasoningCapability, H as KodaXReasoningRequest, n as KodaXNormalizedReasoningRequest, V as KodaXTaskType, a7 as KodaXVerifyCredentialResult, a1 as KodaXToolDefinition, k as KodaXMessage, y as KodaXProviderStreamOptions, N as KodaXStreamResult, l as KodaXModelDescriptor, p as KodaXProviderCapabilityProfile, a8 as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, j as KodaXListModelsResult } from './types.d-DIpZJKUl.js';
+import { G as KodaXReasoningMode, N as KodaXStableEffortIntent, aa as KodaXWireReasoningEffort, H as KodaXReasoningProfile, _ as KodaXThinkingBudgetMap, $ as KodaXThinkingDepth, r as KodaXProviderConfig, C as KodaXReasoningCapability, I as KodaXReasoningRequest, n as KodaXNormalizedReasoningRequest, W as KodaXTaskType, a8 as KodaXVerifyCredentialResult, a2 as KodaXToolDefinition, k as KodaXMessage, z as KodaXProviderStreamOptions, O as KodaXStreamResult, l as KodaXModelDescriptor, q as KodaXProviderCapabilityProfile, o as KodaXOpenAICompatMaxOutputTokensField, a9 as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, j as KodaXListModelsResult } from './types.d-CgrXrFrq.js';
 import Anthropic from '@anthropic-ai/sdk';
-import { K as KodaXBaseProvider } from './base.d-4e74xDdy.js';
+import { K as KodaXBaseProvider } from './base.d-DxG0m09Z.js';
 import OpenAI from 'openai';
 
 /**
@@ -282,6 +282,7 @@ declare abstract class KodaXOpenAICompatProvider extends KodaXBaseProvider {
     protected get client(): OpenAI;
     protected set client(client: OpenAI);
     protected buildClient(): OpenAI;
+    private getEffectiveMaxOutputTokensField;
     protected onStaleConnection(): void;
     /**
      * FEATURE_216 v0.7.45 — Lightweight credential verification.
@@ -389,6 +390,8 @@ type ProviderSnapshot = {
     readonly contextWindow?: number;
     /** Per-turn output token cap KodaX requests. Provider-level default. */
     readonly maxOutputTokens?: number;
+    /** OpenAI Chat Completions field used for the output-token cap. */
+    readonly maxOutputTokensField?: KodaXOpenAICompatMaxOutputTokensField;
     /** Upper bound on `thinking_budget` for native-budget reasoning providers. */
     readonly thinkingBudgetCap?: number;
     /** Whether the provider supports `thinking_budget` / native reasoning. */

package/dist/types-chunks/{run-manager.d-D1twIhF9.d.ts → run-manager.d-C6ahvZqK.d.ts}

@@ -1,4 +1,4 @@
-import { f4 as WorkflowProcessTrackerOptions, eC as WorkflowEvent, e_ as WorkflowProcessSnapshot, eU as WorkflowProcessEvent } from './types.d-BA-Jwpfs.js';
+import { fh as WorkflowProcessTrackerOptions, eP as WorkflowEvent, fb as WorkflowProcessSnapshot, f5 as WorkflowProcessEvent } from './controller.d-C2aHqzHj.js';
 
 /**
  * FEATURE_246 Part A0 (ADR-046) — neutral workflow run lifecycle manager.

package/dist/types-chunks/{sdk-session-DB9KksIx.d.ts → sdk-session-C59RUrri.d.ts}

@@ -1,6 +1,6 @@
-import { g as CreatableHistoryItem, a8 as ToolCall } from './public-api.d-B3AohsxN.js';
-import { k as KodaXMessage, c as KodaXContentBlock } from './types.d-DIpZJKUl.js';
-import { c3 as KodaXSessionUiHistoryItem, c7 as KodaXSessionUiToolCall } from './types.d-BA-Jwpfs.js';
+import { h as CreatableHistoryItem, ar as ToolCall } from './public-api.d-CewTvUKV.js';
+import { k as KodaXMessage, c as KodaXContentBlock } from './types.d-CgrXrFrq.js';
+import { cc as KodaXSessionUiHistoryItem, cg as KodaXSessionUiToolCall } from './controller.d-C2aHqzHj.js';
 
 interface RestoreHistoryItemsFromSessionInput {
     messages: readonly KodaXMessage[];