@kodax-ai/kodax 0.7.84 → 0.7.86

package/dist/types-chunks/types.d-DlLBRqZ9.d.ts

@@ -0,0 +1,1057 @@
+import { k as KodaXMessage } from './types.d-CgrXrFrq.js';
+
+type AgentActorState = 'running' | 'idle' | 'closed';
+type AgentTurnState = 'accepted' | 'running' | 'completed' | 'failed' | 'interrupted';
+type AgentExecutionKind = 'native' | 'constructed' | 'workflow' | 'external';
+type AgentForkTurns = 'all' | 'none' | number;
+type AgentDataClassification = 'public' | 'internal' | 'sensitive';
+type AgentProgressKind = 'status' | 'tool' | 'assistant';
+type AgentInterruptScope = 'turn' | 'subtree';
+type AgentMetadataValue = string | number | boolean | null | readonly AgentMetadataValue[] | {
+    readonly [key: string]: AgentMetadataValue;
+};
+interface AgentCapabilities {
+    readonly tools: readonly string[];
+    readonly filesystem: 'none' | 'read' | 'write';
+    readonly network: boolean;
+    readonly providers: readonly string[];
+    readonly canAskUser: boolean;
+    /** Backend operation support. Omitted means the complete native contract. */
+    readonly control?: {
+        readonly followup: boolean;
+        readonly interrupt: boolean;
+        readonly streaming: boolean;
+        readonly artifacts: boolean;
+    };
+}
+interface AgentActor {
+    readonly path: string;
+    readonly taskName: string;
+    readonly parentPath?: string;
+    readonly kind: AgentExecutionKind;
+    readonly state: AgentActorState;
+    readonly capabilities: AgentCapabilities;
+    readonly turnIds: readonly string[];
+    readonly currentTurnId?: string;
+    readonly mailboxCursor: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly revision: number;
+}
+/** Executor-neutral artifact metadata retained beside the legacy string reference. */
+interface AgentArtifactDescriptor {
+    readonly name: string;
+    readonly uri?: string;
+    readonly mimeType?: string;
+    readonly size?: number;
+    readonly hash?: string;
+    readonly provenance?: string;
+    readonly producingAgentId?: string;
+    readonly remoteTaskId?: string;
+}
+interface AgentTurn {
+    readonly turnId: string;
+    readonly actorPath: string;
+    readonly sequence: number;
+    readonly state: AgentTurnState;
+    readonly objective: string;
+    readonly forkTurns: AgentForkTurns;
+    readonly metadata?: Readonly<Record<string, AgentMetadataValue>>;
+    readonly createdAt: string;
+    readonly startedAt?: string;
+    readonly completedAt?: string;
+    readonly output?: string;
+    readonly artifacts?: readonly string[];
+    readonly artifactDetails?: readonly AgentArtifactDescriptor[];
+    readonly structured?: AgentMetadataValue;
+    readonly error?: string;
+    /** Bounded Runtime-owned activity projection; full transcripts remain executor-owned. */
+    readonly progress?: readonly AgentProgressItem[];
+    readonly revision: number;
+}
+interface AgentProgressUpdate {
+    readonly kind: AgentProgressKind;
+    readonly summary: string;
+}
+interface AgentProgressItem extends AgentProgressUpdate {
+    readonly sequence: number;
+    readonly createdAt: string;
+}
+interface AgentMailboxMessage {
+    readonly messageId: string;
+    readonly sequence: number;
+    readonly senderPath: string;
+    readonly recipientPath: string;
+    readonly turnId?: string;
+    readonly kind: 'message' | 'followup' | 'completion';
+    readonly classification: AgentDataClassification;
+    /** Canonical actors that handled this chain; absent only on pre-hardening schema-v1 snapshots. */
+    readonly lineage?: readonly string[];
+    readonly forwardedMessageId?: string;
+    readonly content: string;
+    readonly createdAt: string;
+}
+type AgentEventKind = 'actor_spawned' | 'turn_started' | 'message_delivered' | 'turn_progress' | 'turn_completed' | 'turn_failed' | 'turn_interrupted' | 'actor_closed';
+interface AgentEvent {
+    readonly sequence: number;
+    readonly kind: AgentEventKind;
+    readonly actorPath: string;
+    readonly turnId?: string;
+    readonly parentPath?: string;
+    readonly progress?: AgentProgressItem;
+    readonly createdAt: string;
+}
+interface AgentSpawnInput {
+    readonly taskName: string;
+    readonly objective: string;
+    readonly kind?: AgentExecutionKind;
+    readonly forkTurns?: AgentForkTurns;
+    readonly capabilities?: Partial<AgentCapabilities>;
+    readonly metadata?: Readonly<Record<string, AgentMetadataValue>>;
+}
+interface AgentTurnRef {
+    readonly actorPath: string;
+    readonly turnId: string;
+    readonly state: 'accepted' | 'running';
+}
+interface AgentFollowupResult {
+    readonly delivery: 'started_turn' | 'current_turn';
+    readonly turn: AgentTurnRef;
+}
+interface AgentTreeSnapshot {
+    readonly rootPath: '/root';
+    readonly actors: readonly AgentListEntry[];
+    readonly activeNonRootTurns: number;
+    readonly maxConcurrentThreads: number;
+    readonly revision: number;
+    /** Turn-admission state revision; absent only on older/custom clients. */
+    readonly admissionRevision?: number;
+}
+interface AgentTurnSummary {
+    readonly turnId: string;
+    readonly state: AgentTurnState;
+    readonly summary: string;
+    readonly summaryTruncated: boolean;
+    readonly recentActivity: readonly AgentProgressItem[];
+}
+interface AgentListEntry extends AgentActor {
+    readonly latestTurn?: AgentTurnSummary;
+}
+interface AgentDetail {
+    readonly actor: AgentActor;
+    readonly turns: readonly AgentTurn[];
+    readonly mailbox: readonly AgentMailboxMessage[];
+}
+interface AgentOutput {
+    readonly actorPath: string;
+    readonly turnId: string;
+    readonly state: AgentTurnState;
+    readonly output?: string;
+    readonly outputTruncated?: boolean;
+    readonly artifacts: readonly string[];
+    readonly artifactDetails?: readonly AgentArtifactDescriptor[];
+    readonly progress: readonly AgentProgressItem[];
+    readonly structured?: AgentMetadataValue;
+    readonly error?: string;
+}
+interface AgentLimitReached {
+    readonly code: 'agent_limit_reached';
+    readonly maxConcurrentThreads: number;
+    readonly activeNonRootTurns: number;
+    readonly availableNonRootSlots: 0;
+    readonly retryable: true;
+}
+interface AgentBudgetExhausted {
+    readonly code: 'agent_budget_exhausted';
+    readonly retryable: false;
+    readonly reason: string;
+}
+interface AgentBudgetAdmissionInput {
+    readonly actorPath: string;
+    readonly parentPath: string;
+    readonly turnId: string;
+    readonly kind: AgentExecutionKind;
+    readonly units: 1;
+}
+type AgentBudgetAdmission = {
+    readonly admitted: true;
+} | {
+    readonly admitted: false;
+    readonly fact: AgentBudgetExhausted;
+};
+interface AgentBudgetPort {
+    admit(input: AgentBudgetAdmissionInput): Promise<AgentBudgetAdmission>;
+    refund?(turnId: string): Promise<void>;
+    snapshot?(): unknown;
+}
+interface AgentExecutionInput {
+    readonly actor: AgentActor;
+    readonly turn: AgentTurn;
+    readonly priorTurns: readonly AgentTurn[];
+    readonly signal: AbortSignal;
+    drainMailbox(): Promise<readonly AgentMailboxMessage[]>;
+    reportProgress(update: AgentProgressUpdate): Promise<void>;
+}
+interface AgentExecutionResult {
+    readonly output: string;
+    readonly artifacts?: readonly string[];
+    readonly artifactDetails?: readonly AgentArtifactDescriptor[];
+    readonly structured?: AgentMetadataValue;
+    /** Runtime-observed completion facts merged into the durable Turn metadata. */
+    readonly turnMetadata?: Readonly<Record<string, AgentMetadataValue>>;
+}
+interface AgentMutationOptions {
+    /** Optimistic Actor revision checked inside the serialized durable mutation. */
+    readonly expectedRevision?: number;
+    /** Optimistic tree revision checked inside the serialized durable mutation. */
+    readonly expectedTreeRevision?: number;
+    /** Optimistic turn-admission revision, excluding progress and mailbox writes. */
+    readonly expectedAdmissionRevision?: number;
+}
+interface AgentTurnExecutor {
+    execute(input: AgentExecutionInput): Promise<AgentExecutionResult>;
+}
+interface AgentActorSnapshotContents {
+    readonly revision: number;
+    /** Added after schema v2; legacy snapshots derive it from revision on load. */
+    readonly admissionRevision?: number;
+    readonly maxConcurrentThreads: number;
+    readonly actors: readonly AgentActor[];
+    readonly turns: readonly AgentTurn[];
+    readonly mailboxes: Readonly<Record<string, readonly AgentMailboxMessage[]>>;
+    /** Terminal child turns explicitly observed by their direct parent. */
+    readonly acknowledgedCompletionTurnIds?: readonly string[];
+    /** Root completion notifications that must survive process-local queue loss. */
+    readonly pendingRootCompletionTurnIds?: readonly string[];
+    readonly events: readonly AgentEvent[];
+}
+/** Runtime process/controller identity that exclusively owns one durable Actor tree. */
+interface AgentActorOwner {
+    readonly ownerId: string;
+    readonly runtimeId: string;
+    readonly pid: number;
+    readonly startedAt: string;
+    /** Opaque host identity for proving that this exact Runtime, not only its PID, remains alive. */
+    readonly livenessId?: string;
+    /** Loopback challenge endpoint paired with livenessId. */
+    readonly livenessPort?: number;
+}
+interface AgentActorSnapshotV1 extends AgentActorSnapshotContents {
+    readonly schemaVersion: 1;
+}
+interface AgentActorSnapshotV2 extends AgentActorSnapshotContents {
+    readonly schemaVersion: 2;
+    readonly owner?: AgentActorOwner;
+}
+type AgentActorSnapshot = AgentActorSnapshotV1 | AgentActorSnapshotV2;
+interface AgentActorStore {
+    load(): Promise<AgentActorSnapshot | undefined>;
+    /** CAS save. Implementations must throw actor_snapshot_conflict on a revision mismatch. */
+    save(snapshot: AgentActorSnapshot, expectedRevision: number): Promise<void>;
+}
+/** Runtime-bound actor control surface. The caller path is minted by Runtime. */
+interface AgentActorClient {
+    readonly callerPath: string;
+    /** Stable in-process identity shared by clients bound to the same Actor tree. */
+    readonly admissionScope?: object;
+    spawn(input: AgentSpawnInput, options?: AgentMutationOptions): Promise<AgentTurnRef>;
+    send(targetPath: string, content: string, classification?: AgentDataClassification, forwardedMessageId?: string): Promise<AgentMailboxMessage>;
+    followup(targetPath: string, objective: string, metadata?: Readonly<Record<string, AgentMetadataValue>>, options?: AgentMutationOptions): Promise<AgentFollowupResult>;
+    interrupt(targetPath: string, reason?: string, scope?: AgentInterruptScope): Promise<void>;
+    acknowledgeCompletions(turnIds: readonly string[]): Promise<number>;
+    list(): AgentTreeSnapshot;
+    get(targetPath: string): AgentDetail;
+    output(targetPath: string, turnId?: string): AgentOutput;
+    eventSnapshot(afterSequence?: number): readonly AgentEvent[];
+    wait(afterSequence?: number, timeoutMs?: number, signal?: AbortSignal): Promise<AgentEvent | undefined>;
+}
+
+/**
+ * @kodax-ai/agent Types
+ *
+ * 通用 Agent 类型定义
+ */
+
+type KodaXJsonPrimitive = string | number | boolean | null;
+type KodaXJsonValue = KodaXJsonPrimitive | KodaXJsonValue[] | {
+    [key: string]: KodaXJsonValue;
+};
+/**
+ * Session error metadata - 会话错误元数据
+ * Used for error recovery and session cleanup - 用于错误恢复和会话清理
+ */
+interface SessionErrorMetadata {
+    /** Last error message - 最后的错误消息 */
+    lastError?: string;
+    /** Last error timestamp - 最后错误时间戳 */
+    lastErrorTime?: number;
+    /** Consecutive error count - 连续错误计数 */
+    consecutiveErrors: number;
+}
+interface KodaXExtensionSessionRecord {
+    id: string;
+    extensionId: string;
+    type: string;
+    ts: number;
+    data?: KodaXJsonValue;
+    dedupeKey?: string;
+}
+type KodaXExtensionSessionState = Record<string, Record<string, KodaXJsonValue>>;
+interface KodaXSessionEntryBase {
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+    /**
+     * Stable logical identity for this transcript item. Cloned/forked entries get
+     * a fresh physical `id` but keep their source entry's `logicalId`, allowing
+     * SDK hosts to group or fold cloned history without comparing content.
+     */
+    logicalId?: string;
+    /** Root physical entry id this item was cloned from, when it is a clone. */
+    sourceEntryId?: string;
+}
+interface KodaXSessionMessageEntry extends KodaXSessionEntryBase {
+    type: 'message';
+    message: KodaXMessage;
+}
+interface KodaXSessionCompactionEntry extends KodaXSessionEntryBase {
+    type: 'compaction';
+    summary: string;
+    firstKeptEntryId?: string;
+    tokensBefore?: number;
+    tokensAfter?: number;
+    artifactLedgerId?: string;
+    reason?: string;
+    details?: KodaXJsonValue;
+    memorySeed?: KodaXCompactMemorySeed;
+    /**
+     * FEATURE_072: post-compact ledger summary + file-content messages that
+     * are inlined after the compaction summary at slicer time
+     * (`getSessionMessagesFromLineage`). Stored here so they leave the active
+     * path automatically when a new compaction entry is appended.
+     *
+     * NOTE: attachments are emitted by the slicer, NOT by `getContextMessagesForEntry`
+     * — preserving the latter's 1-to-1 contract that `entryMatchesContextMessage`
+     * and FEATURE_073's future slicing both depend on.
+     */
+    postCompactAttachments?: readonly KodaXMessage[];
+}
+interface KodaXSessionBranchSummaryEntry extends KodaXSessionEntryBase {
+    type: 'branch_summary';
+    summary: string;
+    fromId?: string;
+    details?: KodaXJsonValue;
+}
+interface KodaXSessionLabelEntry extends KodaXSessionEntryBase {
+    type: 'label';
+    targetId: string;
+    label?: string;
+}
+interface KodaXSessionArchiveMarkerEntry extends KodaXSessionEntryBase {
+    type: 'archive_marker';
+    /** Links to the corresponding batch in the .archive.jsonl sidecar file */
+    archiveBatchId: string;
+    /** Number of entries that were archived in this batch */
+    archivedEntryCount: number;
+    /** Brief summary of the archived content */
+    summary: string;
+}
+interface KodaXSessionRewindMarkerEntry extends KodaXSessionEntryBase {
+    type: 'rewind_marker';
+    targetId: string;
+    fromId?: string;
+    truncatedCount: number;
+    summary: string;
+}
+interface KodaXSessionClientNoticeEntry extends KodaXSessionEntryBase {
+    type: 'client_notice';
+    source: string;
+    content: string;
+    turnId?: string;
+    payload?: KodaXJsonValue;
+}
+interface KodaXMemoryOutcomeDigest {
+    readonly id: string;
+    readonly reviewKey: string;
+    /** Stable root-episode identity; absent on pre-F263 digests. */
+    readonly episodeId?: string;
+    readonly sessionId: string;
+    readonly branchId: string;
+    readonly sequence: number;
+    readonly objective: string;
+    readonly actionSignature?: string;
+    readonly approach: string;
+    /**
+     * `cancelled` is reserved for a host-bound explicit Memory intent. Ordinary
+     * cancelled episodes do not produce an outcome digest.
+     */
+    readonly outcome: 'succeeded' | 'failed' | 'cancelled';
+    readonly summary: string;
+    readonly preconditions?: string;
+    readonly lesson?: string;
+    readonly evidenceRefs: readonly string[];
+    readonly evidence?: readonly KodaXMemoryOutcomeEvidence[];
+    /**
+     * Explicit durable intent captured from the Action LLM and bound by the
+     * host to an exact quote in the current user turn. It is evidence for the
+     * governed reviewer, never proof that Memory was queued or applied.
+     */
+    readonly memoryIntent?: KodaXMemoryIntent;
+    /** Explicit Memory operations already completed during this episode. */
+    readonly handledMemoryOperations?: readonly KodaXHandledMemoryOperation[];
+    readonly memoryInfluence?: readonly KodaXMemoryInfluenceRef[];
+    readonly visibility: 'prompt_safe' | 'private' | 'sensitive';
+    readonly createdAt: string;
+}
+interface KodaXHandledMemoryOperation {
+    readonly operation: 'remember' | 'correct' | 'forget';
+    readonly disposition?: 'applied' | 'decision' | 'blocked';
+    readonly statement?: string;
+    readonly claimKey?: string;
+    readonly targetRefIds: readonly string[];
+}
+interface KodaXMemoryIntent {
+    readonly operation: 'remember' | 'correct';
+    readonly evidenceRef: string;
+    /** Sanitized model-derived claim proposed for governed review. */
+    readonly candidateStatement: string;
+    /** Sanitized representation of the exact current-user quote verified by the host. */
+    readonly userQuote: string;
+}
+interface KodaXMemoryOutcomeEvidence {
+    readonly ref: string;
+    readonly grade: 'authoritative' | 'verified' | 'corroborated' | 'observed' | 'inferred';
+    readonly source: 'user' | 'host' | 'tool' | 'environment' | 'agent';
+    readonly verdict?: 'passed' | 'failed' | 'inconclusive';
+    readonly observedAt: string;
+}
+interface KodaXMemoryInfluenceRef {
+    readonly decisionReceiptRef: string;
+    readonly grade: 'direct' | 'supporting' | 'exposed' | 'unknown';
+}
+interface KodaXSessionMemoryOutcomeDigestEntry extends KodaXSessionEntryBase {
+    readonly type: 'memory_outcome_digest';
+    readonly digest: KodaXMemoryOutcomeDigest;
+    /** Durable F263 review job identity. Absent on pre-F263 lineage records. */
+    readonly jobId?: string;
+}
+interface KodaXSessionMemoryReviewReceiptEntry extends KodaXSessionEntryBase {
+    readonly type: 'memory_review_receipt';
+    /** Distinguishes repeated review keys across branch epochs. */
+    readonly jobId?: string;
+    readonly reviewKey: string;
+    readonly proposalIds: readonly string[];
+    readonly status: 'completed' | 'no_action';
+    readonly completedAt: string;
+}
+type KodaXGoalStatus = 'active' | 'paused' | 'budget_limited' | 'blocked' | 'complete';
+/**
+ * Persistent user-set goal state. v0.7.44 FEATURE_192 — backs the
+ * `/goal` slash command and the get_goal / create_goal / update_goal
+ * tools.
+ *
+ * Persistence model: each lifecycle event (create / update / pause /
+ * resume / clear / budget_limited / blocked / complete) appends a
+ * `KodaXSessionGoalEntry` carrying a frozen `KodaXGoalState` snapshot
+ * to the session lineage. `readLatestGoalFromBranch` walks the active
+ * branch's message-entry IDs and returns the latest goal entry whose
+ * parentId belongs to that branch — so forks and rewinds naturally
+ * drop goals attached to abandoned message paths.
+ */
+interface KodaXGoalState {
+    readonly version: 1;
+    /** `${createdAt}-${rand}` — stable across updates of the same goal. */
+    readonly id: string;
+    readonly objective: string;
+    readonly status: KodaXGoalStatus;
+    /** Optional explicit token budget; null when the user did not set one. */
+    readonly tokenBudget: number | null;
+    readonly tokensUsed: number;
+    readonly timeUsedSeconds: number;
+    /** Consecutive turns the model has reported the same blocker. */
+    readonly blockerTurnCount: number;
+    /** The blocker_kind string the model last reported, or null. */
+    readonly lastBlockerKind: string | null;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+type KodaXGoalEventType = 'created' | 'updated' | 'paused' | 'resumed' | 'cleared' | 'budget_limited' | 'blocked' | 'complete';
+interface KodaXSessionGoalEntry extends KodaXSessionEntryBase {
+    type: 'goal';
+    /** Snapshot at time of event; `null` only when `event === 'cleared'`. */
+    goal: KodaXGoalState | null;
+    event: KodaXGoalEventType;
+}
+type KodaXSessionEntry = KodaXSessionMessageEntry | KodaXSessionCompactionEntry | KodaXSessionBranchSummaryEntry | KodaXSessionLabelEntry | KodaXSessionArchiveMarkerEntry | KodaXSessionRewindMarkerEntry | KodaXSessionClientNoticeEntry | KodaXSessionMemoryOutcomeDigestEntry | KodaXSessionMemoryReviewReceiptEntry | KodaXSessionGoalEntry;
+interface KodaXSessionArtifactLedgerEntry {
+    id: string;
+    kind: 'file_read' | 'file_modified' | 'file_created' | 'file_deleted' | 'path_scope' | 'search_scope' | 'command_scope' | 'check_result' | 'decision' | 'image_input' | 'tombstone';
+    sourceTool?: string;
+    action?: string;
+    target: string;
+    displayTarget?: string;
+    summary?: string;
+    sessionEntryId?: string;
+    timestamp: string;
+    metadata?: Record<string, KodaXJsonValue>;
+}
+interface KodaXCompactMemoryProgress {
+    completed: string[];
+    inProgress: string[];
+    blockers: string[];
+}
+interface KodaXCompactMemorySeed {
+    objective?: string;
+    constraints: string[];
+    progress: KodaXCompactMemoryProgress;
+    keyDecisions: string[];
+    nextSteps: string[];
+    keyContext: string[];
+    importantTargets: string[];
+    tombstones: string[];
+}
+interface KodaXSessionLineage {
+    version: 2;
+    activeEntryId: string | null;
+    entries: KodaXSessionEntry[];
+}
+interface KodaXSessionNavigationOptions {
+    summarizeCurrentBranch?: boolean;
+}
+interface KodaXSessionTreeNode {
+    entry: Exclude<KodaXSessionEntry, KodaXSessionLabelEntry | KodaXSessionGoalEntry | KodaXSessionClientNoticeEntry | KodaXSessionRewindMarkerEntry | KodaXSessionMemoryOutcomeDigestEntry | KodaXSessionMemoryReviewReceiptEntry>;
+    children: KodaXSessionTreeNode[];
+    label?: string;
+    active: boolean;
+}
+type KodaXSessionScope = 'user' | 'managed-task-worker';
+type KodaXSessionUiTextHistoryItemType = 'user' | 'assistant' | 'system' | 'thinking' | 'error' | 'event' | 'info' | 'hint' | 'sidecar';
+type KodaXSessionUiHistoryItemType = KodaXSessionUiTextHistoryItemType | 'tool_group';
+interface KodaXSessionUiTextHistoryItem {
+    type: KodaXSessionUiTextHistoryItemType;
+    text: string;
+    /** Original UI event time in epoch milliseconds. Absent on older sessions. */
+    timestamp?: number;
+    icon?: string;
+    compactText?: string;
+}
+type KodaXSessionUiToolCallStatus = 'success' | 'error' | 'cancelled' | 'awaiting_approval';
+interface KodaXSessionUiToolCall {
+    id: string;
+    name: string;
+    status: KodaXSessionUiToolCallStatus;
+    input?: {
+        [key: string]: KodaXJsonValue;
+    };
+    preview?: string;
+    output?: string;
+    error?: string;
+    startTime?: number;
+    endTime?: number;
+}
+interface KodaXSessionUiToolGroupHistoryItem {
+    type: 'tool_group';
+    /** Original UI event time in epoch milliseconds. Absent on older sessions. */
+    timestamp?: number;
+    tools: KodaXSessionUiToolCall[];
+}
+type KodaXSessionUiHistoryItem = KodaXSessionUiTextHistoryItem | KodaXSessionUiToolGroupHistoryItem;
+type KodaXSessionWorkspaceKind = 'detected' | 'managed';
+interface KodaXSessionRuntimeInfo {
+    canonicalRepoRoot?: string;
+    workspaceRoot?: string;
+    executionCwd?: string;
+    branch?: string;
+    workspaceKind?: KodaXSessionWorkspaceKind;
+    /** SDK consumer surface/profile label, e.g. `'code'` | `'partner'`. */
+    surface?: string;
+    /** SDK consumer profile id (stable name or UUID). */
+    profileId?: string;
+    /** SDK consumer profile version. */
+    profileVersion?: string;
+    /** LLM provider alias active at session start, e.g. `'anthropic'`. */
+    provider?: string;
+    /** Model identifier active at session start. */
+    model?: string;
+    /** Reasoning mode active at session start. */
+    reasoningMode?: string;
+    /** Permission mode active at session start, e.g. `'auto'` | `'plan'`. */
+    permissionMode?: string;
+    /** Agent mode active at session start, e.g. `'sa'` | `'ama'`. */
+    agentMode?: string;
+}
+interface KodaXSessionData {
+    messages: KodaXMessage[];
+    title: string;
+    gitRoot: string;
+    /** Consumer-owned private string persisted with the session. */
+    tag?: string;
+    runtimeInfo?: KodaXSessionRuntimeInfo;
+    scope?: KodaXSessionScope;
+    uiHistory?: KodaXSessionUiHistoryItem[];
+    errorMetadata?: SessionErrorMetadata;
+    extensionState?: KodaXExtensionSessionState;
+    extensionRecords?: KodaXExtensionSessionRecord[];
+    lineage?: KodaXSessionLineage;
+    artifactLedger?: KodaXSessionArtifactLedgerEntry[];
+    /** Runtime-owned F270 Actor tree snapshot; persisted with the session owner. */
+    actorSnapshot?: AgentActorSnapshot;
+}
+interface KodaXSessionMeta {
+    _type: 'meta';
+    title: string;
+    id: string;
+    gitRoot: string;
+    /** Consumer-owned private string persisted with the session. */
+    tag?: string;
+    runtimeInfo?: KodaXSessionRuntimeInfo;
+    createdAt: string;
+    scope?: KodaXSessionScope;
+    uiHistory?: KodaXSessionUiHistoryItem[];
+    extensionState?: KodaXExtensionSessionState;
+    extensionRecordCount?: number;
+    artifactLedgerCount?: number;
+    /** Runtime-owned F270 Actor tree snapshot; absent on pre-v0.7.72 sessions. */
+    actorSnapshot?: AgentActorSnapshot;
+    lineageVersion?: 2;
+    activeEntryId?: string | null;
+    lineageEntryCount?: number;
+    activeMessageCount?: number;
+    /** Error metadata for recovery - 错误元数据用于恢复 */
+    errorMetadata?: SessionErrorMetadata;
+}
+/**
+ * Extension-scoped persistence entry.
+ *
+ * Each entry belongs to a namespace (extensionId) and carries
+ * a string key, a JSON-safe value, and an opaque version tag
+ * used for optimistic concurrency control.
+ */
+interface KodaXExtensionStoreEntry {
+    key: string;
+    value: KodaXJsonValue;
+    version: string;
+    updatedAt: number;
+}
+/**
+ * Extension persistence store interface (FEATURE_034 manual persistence).
+ *
+ * Implementations provide a durable key-value store scoped to a single
+ * extension identity.  The store is independent of session lifecycle —
+ * data survives across sessions and restarts.
+ */
+interface KodaXExtensionStore {
+    /**
+     * Read a single key.
+     * Returns `undefined` when the key does not exist.
+     */
+    get(key: string): Promise<KodaXExtensionStoreEntry | undefined>;
+    /**
+     * Write a key-value pair.
+     *
+     * When `expectedVersion` is provided the write only succeeds when the
+     * stored entry's version still matches (optimistic concurrency).
+     * Returns the new entry on success, or `false` on version mismatch.
+     */
+    put(key: string, value: KodaXJsonValue, options?: {
+        expectedVersion?: string;
+    }): Promise<KodaXExtensionStoreEntry | false>;
+    /**
+     * Remove a key.
+     * Returns `true` when the key existed and was removed.
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * List all keys (optionally filtered by prefix).
+     */
+    list(options?: {
+        prefix?: string;
+    }): Promise<string[]>;
+    /**
+     * Clear all keys (optionally filtered by prefix).
+     * Returns the number of entries removed.
+     */
+    clear(options?: {
+        prefix?: string;
+    }): Promise<number>;
+}
+interface KodaXSessionStorage {
+    save(id: string, data: KodaXSessionData): Promise<void>;
+    load(id: string): Promise<KodaXSessionData | null>;
+    /**
+     * Atomically mutates context-silent lineage state against the latest
+     * persisted session. Hosts that own session persistence may expose this
+     * without allowing the runner to write a stale full snapshot. Returns
+     * true when the session existed and the callback was evaluated, including
+     * an idempotent no-op; false only when the session was not found.
+     */
+    mutateLineage?(id: string, mutation: (lineage: KodaXSessionLineage) => KodaXSessionLineage): Promise<boolean>;
+    getLineage?(id: string): Promise<KodaXSessionLineage | null>;
+    /** Exact lineage merged from the active session file and island sidecars. */
+    loadFullLineage?(id: string): Promise<KodaXSessionLineage | null>;
+    setActiveEntry?(id: string, selector: string, options?: KodaXSessionNavigationOptions): Promise<KodaXSessionData | null>;
+    setLabel?(id: string, selector: string, label?: string): Promise<KodaXSessionData | null>;
+    rewind?(id: string, selector?: string): Promise<KodaXSessionData | null>;
+    fork?(id: string, selector?: string, options?: {
+        sessionId?: string;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+        data: KodaXSessionData;
+    } | null>;
+    list?(gitRoot?: string, options?: {
+        limit?: number;
+        includeArchived?: boolean;
+    }): Promise<Array<{
+        id: string;
+        title: string;
+        msgCount: number;
+        tag?: string;
+        runtimeInfo?: KodaXSessionRuntimeInfo;
+    }>>;
+    delete?(id: string): Promise<void>;
+    deleteAll?(gitRoot?: string): Promise<void>;
+}
+
+interface MemoryContextIdentity {
+    /** Explicit owner home for durable runtime state; never persisted in review envelopes. */
+    readonly configHome?: string;
+    readonly tenantId: string;
+    readonly workspaceId?: string;
+    readonly userId?: string;
+    readonly agentId: string;
+    readonly projectId?: string;
+    readonly sessionId: string;
+}
+interface MemoryApplicability {
+    readonly tenantId: string;
+    readonly workspaceId?: string;
+    readonly userId?: string;
+    readonly agentId?: string;
+    readonly projectId?: string;
+    readonly sessionId?: string;
+}
+declare function matchesMemoryApplicability(identity: MemoryContextIdentity, applicability: MemoryApplicability): boolean;
+declare function hashMemoryIdentityComponent(kind: string, canonicalId: string): string;
+declare function memoryApplicabilityFingerprint(applicability: MemoryApplicability): string;
+
+type MemoryRefKind = 'working_context' | 'session_trace' | 'artifact_ledger' | 'learning_proposal' | 'memdir' | 'skill' | 'workflow_run' | 'reasoning_report' | 'self_manual' | 'project_doc';
+
+type MemoryScope = 'turn' | 'session' | 'project' | 'workspace' | 'agent' | 'user' | 'builtin';
+type MemoryClaimKind = 'fact' | 'policy' | 'preference' | 'procedure' | 'episode';
+type MemoryLifecycle = 'pending' | 'active' | 'provisional' | 'trusted' | 'stale' | 'quarantined' | 'archived' | 'readonly';
+type MemoryAuthority = 'read_only' | 'proposal_only' | 'approved_write';
+type MemoryVisibility = 'prompt_safe' | 'private' | 'sensitive';
+interface MemoryItemRef {
+    readonly kind: MemoryRefKind;
+    readonly id: string;
+    readonly scope: MemoryScope;
+    readonly scopeId?: string;
+    readonly applicability?: MemoryApplicability;
+    readonly claimKind?: MemoryClaimKind;
+    readonly claimKey?: string;
+    readonly actionSignature?: string;
+    readonly title?: string;
+    readonly owner: 'user' | 'project' | 'kodax' | 'external';
+    readonly lifecycle: MemoryLifecycle;
+    readonly authority: MemoryAuthority;
+    readonly visibility: MemoryVisibility;
+    readonly sourceRefs: readonly string[];
+    readonly relatedRefs: readonly string[];
+    readonly version?: string;
+    readonly bodyFingerprint?: string;
+    readonly storageUri?: string;
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+    readonly lastUsedAt?: string;
+    readonly pinned?: boolean;
+    readonly applyReceiptRef?: string;
+    readonly expectedFingerprint?: string;
+    readonly resultingFingerprint?: string;
+}
+interface MemoryRefFilter {
+    readonly kinds?: readonly MemoryRefKind[];
+    readonly scopes?: readonly MemoryScope[];
+    readonly lifecycles?: readonly MemoryLifecycle[];
+    readonly includePrivate?: boolean;
+    readonly includeSensitive?: boolean;
+    readonly query?: string;
+}
+interface MemoryBodySnapshot {
+    readonly ref: MemoryItemRef;
+    readonly body: string;
+    readonly bodyFingerprint: string;
+    readonly frontmatter?: Readonly<Record<string, string>>;
+    readonly readAt: string;
+    readonly warnings: readonly string[];
+}
+type MemoryProposalAction = 'no_op' | 'link_refs' | 'write_memdir' | 'patch_memdir' | 'handoff_to_skill_loop' | 'quarantine' | 'archive' | 'conflict_report';
+interface MemoryApplyPreview {
+    readonly summary: string;
+    readonly changedRefs: readonly MemoryItemRef[];
+    readonly changedPaths: readonly string[];
+    readonly beforeFingerprints: Readonly<Record<string, string>>;
+    readonly afterFingerprints?: Readonly<Record<string, string>>;
+    readonly diff?: string;
+    readonly warnings: readonly string[];
+}
+interface MemoryActionProposal {
+    readonly id: string;
+    readonly action: MemoryProposalAction;
+    readonly targetRefs: readonly MemoryItemRef[];
+    readonly sourceRefs: readonly MemoryItemRef[];
+    readonly expectedFingerprints: Readonly<Record<string, string>>;
+    readonly rationale: string;
+    readonly risk: 'low' | 'medium' | 'high';
+    readonly preview: MemoryApplyPreview;
+    readonly requiresApproval: true;
+    readonly createdAt: string;
+}
+interface MemoryApproval {
+    readonly proposalId: string;
+    readonly approvedBy: 'user' | 'host';
+    readonly approvedAt: string;
+    readonly expectedFingerprints: Readonly<Record<string, string>>;
+    readonly policyId?: string;
+    readonly policyReason?: string;
+    readonly revalidateAuthority?: () => Promise<void>;
+}
+interface MemoryApplyResult {
+    readonly proposalId: string;
+    readonly applied: boolean;
+    readonly changedRefs: readonly MemoryItemRef[];
+    readonly changedPaths: readonly string[];
+    readonly skippedReason?: string;
+    readonly warnings: readonly string[];
+}
+interface MemoryRejectResult {
+    readonly proposalId: string;
+    readonly rejected: boolean;
+    readonly skippedReason?: string;
+    readonly review?: MemoryReviewPlan;
+    readonly warnings: readonly string[];
+}
+interface MemoryLifecycleOperationResult {
+    readonly refId: string;
+    readonly operation: 'archive' | 'forget' | 'purge';
+    readonly acknowledged: boolean;
+    readonly residualSourceRefs: readonly string[];
+    readonly warnings: readonly string[];
+}
+interface MemoryRememberInput {
+    /** `correct` requires an exact managed Memory ref so the host never guesses a destructive target. */
+    readonly operation?: 'remember' | 'correct';
+    readonly statement: string;
+    readonly targetRefId?: string;
+    readonly claimKind?: MemoryClaimKind;
+    readonly claimKey?: string;
+    /** Stable evidence identity supplied by the user-facing host. */
+    readonly evidenceRef?: string;
+    /** Optional version guard for a target selected from a previously shown view. */
+    readonly expectedTargetFingerprint?: string;
+}
+interface MemoryRememberResult {
+    readonly status: 'remembered' | 'updated' | 'already_known' | 'needs_clarification' | 'needs_review' | 'rejected';
+    readonly changedRefIds: readonly string[];
+    readonly proposalIds: readonly string[];
+    readonly reason?: string;
+    readonly warnings: readonly string[];
+}
+interface MemorySourceAdapter {
+    readonly kind: MemoryRefKind;
+    listRefs(filter?: MemoryRefFilter): Promise<readonly MemoryItemRef[]>;
+    readRef(ref: MemoryItemRef): Promise<MemoryBodySnapshot>;
+    previewProposal(proposal: MemoryActionProposal): Promise<MemoryApplyPreview>;
+    applyProposal(proposal: MemoryActionProposal, approval: MemoryApproval): Promise<MemoryApplyResult>;
+}
+interface MemoryCuratorInput {
+    readonly includePrivate?: boolean;
+    readonly includeSensitive?: boolean;
+}
+interface MemoryAutoCuratorInput extends MemoryCuratorInput {
+    readonly enabled?: boolean;
+    readonly intervalMs?: number;
+    readonly minRefs?: number;
+}
+type MemoryAutoCuratorSkipReason = 'disabled' | 'not_due' | 'insufficient_refs';
+interface MemoryAutoCuratorResult {
+    readonly ran: boolean;
+    readonly skippedReason?: MemoryAutoCuratorSkipReason;
+    readonly report?: MemoryGovernanceReport;
+    readonly reportPath?: string;
+    readonly nextEligibleAt?: string;
+}
+type MemoryGovernanceFindingKind = 'duplicate' | 'conflict' | 'stale' | 'quarantined' | 'orphaned' | 'no_op';
+interface MemoryGovernanceFinding {
+    readonly kind: MemoryGovernanceFindingKind;
+    readonly severity: 'info' | 'warning' | 'error';
+    readonly refIds: readonly string[];
+    readonly summary: string;
+    readonly suggestedAction: MemoryProposalAction;
+}
+interface MemoryGovernanceReport {
+    readonly reportId: string;
+    readonly generatedAt: string;
+    readonly findings: readonly MemoryGovernanceFinding[];
+    readonly warnings: readonly string[];
+}
+interface MemoryPackInput {
+    readonly task: string;
+    readonly identity?: MemoryContextIdentity;
+    readonly decisionIntent?: string;
+    readonly actionSignature?: string;
+    readonly maxCandidates?: number;
+    readonly maxHints?: number;
+    readonly includePrivate?: boolean;
+    readonly includeSensitive?: boolean;
+    readonly includeSnippets?: boolean;
+    readonly ignoreMemory?: boolean;
+    readonly purpose?: 'automatic' | 'deliberate_query' | 'intervention';
+}
+interface MemoryPackHint {
+    readonly ref: MemoryItemRef;
+    readonly hook: string;
+    readonly reason: string;
+    readonly bodySnippet?: string;
+    readonly bodyFingerprint?: string;
+}
+interface MemoryPack {
+    readonly generatedAt: string;
+    readonly taskFingerprint: string;
+    readonly memoryRevision: string;
+    readonly candidates: readonly MemoryPackHint[];
+    readonly promptHints: readonly MemoryPackHint[];
+    /** @deprecated Use promptHints. Retained for F228 source compatibility. */
+    readonly hints: readonly MemoryPackHint[];
+    readonly omitted: readonly string[];
+    readonly traceMetadata: MemoryPackTraceMetadata;
+}
+interface MemoryPackTraceMetadata {
+    readonly selectedRefIds: readonly string[];
+    readonly omittedRefIds: readonly string[];
+    readonly taskFingerprint: string;
+    readonly suppressed: boolean;
+}
+type MemoryReviewTrigger = 'user_correction' | 'explicit_remember' | 'explicit_forget' | 'proposal_rejected' | 'conflict_detected' | 'episode_completed';
+interface MemoryReviewCandidateRef {
+    readonly ref: MemoryItemRef;
+    readonly bodySnippet?: string;
+    readonly bodyFingerprint?: string;
+    readonly warnings: readonly string[];
+}
+interface MemoryReviewInput {
+    readonly trigger: MemoryReviewTrigger;
+    readonly userFeedback?: string;
+    readonly episodeDigest?: KodaXMemoryOutcomeDigest;
+    readonly task?: string;
+    readonly sourceRefs?: readonly string[];
+    readonly candidateRefIds?: readonly string[];
+    readonly includePrivate?: boolean;
+    readonly includeSensitive?: boolean;
+    readonly maxRefs?: number;
+}
+interface MemoryReviewModelInput {
+    readonly trigger: MemoryReviewTrigger;
+    readonly userFeedback: string;
+    readonly task?: string;
+    readonly sourceRefs: readonly string[];
+    readonly candidateRefs: readonly MemoryReviewCandidateRef[];
+    readonly warnings: readonly string[];
+}
+interface MemoryReviewDraftAction {
+    readonly action: MemoryProposalAction;
+    readonly targetRefIds: readonly string[];
+    readonly summary: string;
+    readonly rationale: string;
+    readonly confidence: 'low' | 'medium' | 'high';
+    readonly risk: 'low' | 'medium' | 'high';
+    readonly requiresApproval: true;
+    readonly proposedBody?: string;
+    readonly claimKind?: MemoryClaimKind;
+    readonly claimKey?: string;
+    readonly actionSignature?: string;
+    readonly preconditions?: string;
+    /** Host-bound version for an explicitly presented correction target. */
+    readonly authorizationTargetFingerprint?: string;
+    readonly counterexamples?: readonly string[];
+    readonly relationship?: 'same_claim' | 'condition_refinement' | 'conflict';
+}
+interface MemoryReviewPlan {
+    readonly trigger: MemoryReviewTrigger;
+    readonly createdAt: string;
+    readonly sourceRefs: readonly string[];
+    readonly candidateRefs: readonly MemoryReviewCandidateRef[];
+    readonly actions: readonly MemoryReviewDraftAction[];
+    readonly warnings: readonly string[];
+    readonly episodeDigest?: KodaXMemoryOutcomeDigest;
+}
+interface MemoryEpisodeReviewResult {
+    readonly plan: MemoryReviewPlan;
+    readonly proposalIds: readonly string[];
+    readonly appliedProposalIds: readonly string[];
+    readonly decisions: readonly MemoryReviewPersistenceDecision[];
+    readonly warnings: readonly string[];
+}
+type MemoryReviewPersistenceKind = 'create' | 'evidence_update' | 'condition_refinement' | 'conflict' | 'no_action' | 'reject' | 'quarantine';
+interface MemoryReviewPersistenceDecision {
+    readonly actionIndex: number;
+    readonly kind: MemoryReviewPersistenceKind;
+    readonly reason: string;
+    readonly existingRefId?: string;
+    readonly proposalId?: string;
+}
+type MemoryReviewRunner = (input: MemoryReviewModelInput) => Promise<MemoryReviewPlan>;
+interface MemoryController {
+    listInbox(): Promise<readonly MemoryActionProposal[]>;
+    showProposal(id: string): Promise<MemoryActionProposal | undefined>;
+    approveProposal(id: string, expectedFingerprints: Readonly<Record<string, string>>, expectedRevision?: string): Promise<MemoryApplyResult>;
+    rejectProposal(id: string, reason?: string, expectedRevision?: string): Promise<MemoryRejectResult>;
+    listRefs(filter?: MemoryRefFilter): Promise<readonly MemoryItemRef[]>;
+    readRef(ref: MemoryItemRef): Promise<MemoryBodySnapshot>;
+    runCurator(input?: MemoryCuratorInput): Promise<MemoryGovernanceReport>;
+    maybeRunAutoCurator(input?: MemoryAutoCuratorInput): Promise<MemoryAutoCuratorResult>;
+    buildMemoryPack(input: MemoryPackInput): Promise<MemoryPack>;
+    reviewMemoryFeedback(input: MemoryReviewInput): Promise<MemoryReviewPlan>;
+    prepareEpisodeReview?(digest: KodaXMemoryOutcomeDigest): Promise<MemoryReviewModelInput>;
+    applyReviewedEpisode?(plan: MemoryReviewPlan, digest: KodaXMemoryOutcomeDigest, signal?: AbortSignal, revalidateAuthority?: () => Promise<void>): Promise<MemoryEpisodeReviewResult>;
+    persistReviewPlan(plan: MemoryReviewPlan): Promise<readonly string[]>;
+    /**
+     * Resolves which episode-review proposals were actually auto-applied by the
+     * governed host policy. Used to keep durable receipts complete while user
+     * notices remain truthful.
+     */
+    listHostAppliedEpisodeProposalIds?(proposalIds: readonly string[]): Promise<readonly string[]>;
+    reviewEpisode(digest: KodaXMemoryOutcomeDigest, signal?: AbortSignal): Promise<MemoryEpisodeReviewResult>;
+    archiveRef(id: string): Promise<MemoryLifecycleOperationResult>;
+    forgetRef(id: string, expectedBodyFingerprint?: string): Promise<MemoryLifecycleOperationResult>;
+    purgeRef(id: string): Promise<MemoryLifecycleOperationResult>;
+}
+/** Additive management capability implemented by KodaX's default control plane. */
+interface MemoryManagementController extends MemoryController {
+    /** Applies an explicit, prompt-safe user/host instruction without a second approval ceremony. */
+    remember(input: MemoryRememberInput): Promise<MemoryRememberResult>;
+}
+declare function isMemoryManagementController(controller: MemoryController): controller is MemoryManagementController;
+type MemoryEvent = {
+    readonly type: 'proposal.created';
+    readonly proposalId: string;
+} | {
+    readonly type: 'proposal.approved';
+    readonly proposalId: string;
+} | {
+    readonly type: 'proposal.rejected';
+    readonly proposalId: string;
+} | {
+    readonly type: 'curator.completed';
+    readonly reportId: string;
+} | {
+    readonly type: 'pack.selected';
+    readonly refIds: readonly string[];
+} | {
+    readonly type: 'review.completed';
+    readonly trigger: MemoryReviewTrigger;
+    readonly actionCount: number;
+};
+
+export { hashMemoryIdentityComponent as bb, isMemoryManagementController as bc, matchesMemoryApplicability as bd, memoryApplicabilityFingerprint as be };
+export type { KodaXMemoryOutcomeDigest as $, AgentActor as A, AgentMetadataValue as B, AgentMutationOptions as C, AgentOutput as D, AgentProgressItem as E, AgentProgressKind as F, AgentProgressUpdate as G, AgentSpawnInput as H, AgentTreeSnapshot as I, AgentTurn as J, AgentTurnExecutor as K, AgentTurnRef as L, AgentTurnState as M, AgentTurnSummary as N, KodaXCompactMemoryProgress as O, KodaXCompactMemorySeed as P, KodaXExtensionSessionRecord as Q, KodaXExtensionSessionState as R, KodaXExtensionStore as S, KodaXExtensionStoreEntry as T, KodaXGoalEventType as U, KodaXGoalState as V, KodaXGoalStatus as W, KodaXHandledMemoryOperation as X, KodaXJsonValue as Y, KodaXMemoryInfluenceRef as Z, KodaXMemoryIntent as _, AgentActorClient as a, MemoryReviewDraftAction as a$, KodaXMemoryOutcomeEvidence as a0, KodaXSessionArchiveMarkerEntry as a1, KodaXSessionArtifactLedgerEntry as a2, KodaXSessionBranchSummaryEntry as a3, KodaXSessionClientNoticeEntry as a4, KodaXSessionCompactionEntry as a5, KodaXSessionData as a6, KodaXSessionEntry as a7, KodaXSessionEntryBase as a8, KodaXSessionGoalEntry as a9, MemoryAutoCuratorInput as aA, MemoryAutoCuratorResult as aB, MemoryBodySnapshot as aC, MemoryClaimKind as aD, MemoryContextIdentity as aE, MemoryController as aF, MemoryCuratorInput as aG, MemoryEpisodeReviewResult as aH, MemoryEvent as aI, MemoryGovernanceFinding as aJ, MemoryGovernanceFindingKind as aK, MemoryGovernanceReport as aL, MemoryItemRef as aM, MemoryLifecycle as aN, MemoryLifecycleOperationResult as aO, MemoryManagementController as aP, MemoryPack as aQ, MemoryPackHint as aR, MemoryPackInput as aS, MemoryPackTraceMetadata as aT, MemoryProposalAction as aU, MemoryRefFilter as aV, MemoryRefKind as aW, MemoryRejectResult as aX, MemoryRememberInput as aY, MemoryRememberResult as aZ, MemoryReviewCandidateRef as a_, KodaXSessionLabelEntry as aa, KodaXSessionLineage as ab, KodaXSessionMemoryOutcomeDigestEntry as ac, KodaXSessionMemoryReviewReceiptEntry as ad, KodaXSessionMessageEntry as ae, KodaXSessionMeta as af, KodaXSessionNavigationOptions as ag, KodaXSessionRewindMarkerEntry as ah, KodaXSessionRuntimeInfo as ai, KodaXSessionScope as aj, KodaXSessionStorage as ak, KodaXSessionTreeNode as al, KodaXSessionUiHistoryItem as am, KodaXSessionUiHistoryItemType as an, KodaXSessionUiTextHistoryItem as ao, KodaXSessionUiTextHistoryItemType as ap, KodaXSessionUiToolCall as aq, KodaXSessionUiToolCallStatus as ar, KodaXSessionUiToolGroupHistoryItem as as, KodaXSessionWorkspaceKind as at, MemoryActionProposal as au, MemoryApplicability as av, MemoryApplyPreview as aw, MemoryApplyResult as ax, MemoryApproval as ay, MemoryAuthority as az, AgentActorOwner as b, MemoryReviewInput as b0, MemoryReviewModelInput as b1, MemoryReviewPersistenceDecision as b2, MemoryReviewPersistenceKind as b3, MemoryReviewPlan as b4, MemoryReviewRunner as b5, MemoryReviewTrigger as b6, MemoryScope as b7, MemorySourceAdapter as b8, MemoryVisibility as b9, SessionErrorMetadata as ba, AgentActorSnapshot as c, AgentActorSnapshotV1 as d, AgentActorSnapshotV2 as e, AgentActorState as f, AgentActorStore as g, AgentArtifactDescriptor as h, AgentBudgetAdmission as i, AgentBudgetAdmissionInput as j, AgentBudgetExhausted as k, AgentBudgetPort as l, AgentCapabilities as m, AgentDataClassification as n, AgentDetail as o, AgentEvent as p, AgentEventKind as q, AgentExecutionInput as r, AgentExecutionKind as s, AgentExecutionResult as t, AgentFollowupResult as u, AgentForkTurns as v, AgentInterruptScope as w, AgentLimitReached as x, AgentListEntry as y, AgentMailboxMessage as z };