@kodax-ai/kodax 0.7.96 → 0.7.97-alpha.2

package/dist/types-chunks/{cost-tracker.d-BWI4lFWn.d.ts → cost-tracker.d-BeaenODW.d.ts}

@@ -1,48 +1,3 @@
-type ProviderCredentialPurpose = 'primary' | 'fallback' | 'classifier' | 'sidecar' | 'compaction' | 'workflow' | 'utility';
-interface ProviderCredentialLeaseAccess {
-    readonly allowedProviders: readonly string[];
-    readonly signal?: AbortSignal;
-    readonly isActive?: () => boolean;
-    acquire(provider: string, purpose: ProviderCredentialPurpose, signal: AbortSignal, attribution?: ProviderCredentialAttribution): Promise<string>;
-}
-type ProviderCredentialAttribution = {
-    readonly kind: 'actor_turn';
-    readonly actorPath: string;
-    readonly turnId: string;
-} | {
-    readonly kind: 'workflow';
-    readonly workflowRunId: string;
-};
-interface ProviderCredentialLeaseScope {
-    readonly allowedProviders: readonly string[];
-    close(reason?: string): void;
-}
-/** Run a provider operation with an in-memory, run-scoped credential override. */
-declare function runWithProviderCredential<T>(provider: string, credential: string, operation: () => T): T;
-/** Create an operation-owned resolver scope. No credential material is retained here. */
-declare function createProviderCredentialLeaseScope(access: ProviderCredentialLeaseAccess): ProviderCredentialLeaseScope;
-/** Run an operation in a previously created lease scope. */
-declare function runWithProviderCredentialLeaseScope<T>(scope: ProviderCredentialLeaseScope, operation: () => T): T;
-/** Run outside any Runtime Provider credential authority (for external executors). */
-declare function runWithoutProviderCredentialScope<T>(operation: () => T): T;
-/** Derive a short-lived child from the active lazy lease without exposing its resolver. */
-declare function deriveCurrentProviderCredentialLeaseScope(allowedProviders: readonly string[], attribution?: ProviderCredentialAttribution): ProviderCredentialLeaseScope | undefined;
-/** Concrete Provider authority carried by the active lazy lease, never a wildcard. */
-declare function currentProviderCredentialLeaseProviders(): readonly string[] | undefined;
-/**
- * Resolve one Provider immediately before its wire call. The secret exists only
- * in the nested exact scope and is discarded when the call settles.
- */
-declare function withProviderRequestCredential<T>(provider: string, purpose: ProviderCredentialPurpose, signal: AbortSignal | undefined, operation: (signal: AbortSignal | undefined) => Promise<T> | T): Promise<T>;
-/** Internal provider lookup. The credential is never copied to config or diagnostics. */
-declare function getScopedProviderCredential(provider: string): string | undefined;
-/** Whether an active scope authorizes a Provider without triggering broker I/O. */
-declare function hasScopedProviderCredentialAuthority(provider: string): boolean | undefined;
-/** True while either an exact or lazy credential authority is present. */
-declare function hasProviderCredentialContext(): boolean;
-/** Remove the active exact credential from DTOs before diagnostics or persistence. */
-declare function redactScopedProviderCredential<T>(value: T): T;
-
 interface KodaXLlmTimeoutConfig {
     /** Main provider request hard timeout, in seconds. Default 600s. */
     readonly requestTimeoutSec?: number;
@@ -176,5 +131,5 @@ declare function getSummary(tracker: CostTracker): SessionCostSummary;
 declare function formatCost(usd: number): string;
 declare function formatCostReport(summary: SessionCostSummary): string;
 
-export { timeoutSecToMs as A, withProviderRequestCredential as B, DEFAULT_COST_RATES as D, calculateCost as g, createCostTracker as h, createProviderCredentialLeaseScope as i, currentProviderCredentialLeaseProviders as j, deriveCurrentProviderCredentialLeaseScope as k, formatCost as l, formatCostReport as m, getCostRate as n, getScopedProviderCredential as o, getSummary as p, hasProviderCredentialContext as q, hasScopedProviderCredentialAuthority as r, parseTimeoutSecEnvMs as s, recordRetry as t, recordUsage as u, redactScopedProviderCredential as v, resolveLlmTimeoutConfig as w, runWithProviderCredential as x, runWithProviderCredentialLeaseScope as y, runWithoutProviderCredentialScope as z };
-export type { CostRate as C, KodaXLlmTimeoutConfig as K, ProviderCostSummary as P, RetryRecord as R, SessionCostSummary as S, TokenUsageRecord as T, CostTracker as a, KodaXResolvedLlmTimeoutConfig as b, ProviderCredentialAttribution as c, ProviderCredentialLeaseAccess as d, ProviderCredentialLeaseScope as e, ProviderCredentialPurpose as f };
+export { DEFAULT_COST_RATES as D, calculateCost as c, createCostTracker as d, formatCostReport as e, formatCost as f, getCostRate as g, getSummary as h, recordUsage as i, resolveLlmTimeoutConfig as j, parseTimeoutSecEnvMs as p, recordRetry as r, timeoutSecToMs as t };
+export type { CostRate as C, KodaXLlmTimeoutConfig as K, ProviderCostSummary as P, RetryRecord as R, SessionCostSummary as S, TokenUsageRecord as T, CostTracker as a, KodaXResolvedLlmTimeoutConfig as b };

package/dist/types-chunks/{history-retrieval.d-CPN5PMBV.d.ts → history-retrieval.d-JdFfkeF3.d.ts}

@@ -1,5 +1,5 @@
-import { k as KodaXMessage } from './types.d-BrQMB-hy.js';
-import { ag as KodaXSessionLineage } from './types.d-CSv0_cZC.js';
+import { k as KodaXMessage } from './types.d-BjOq57-z.js';
+import { ax as KodaXSessionLineage } from './review-inbox.d-BeaLRNHx.js';
 
 type KodaXSessionHistoryScope = 'compacted' | 'all';
 type KodaXSessionHistorySource = 'user' | 'assistant' | 'system' | 'tool' | 'child_task';

package/dist/types-chunks/{manager.d-rtmywU9M.d.ts → manager.d-C_20XqCV.d.ts}

@@ -1,4 +1,4 @@
-import { b as CapabilityResult, a as CapabilityProvider, C as CapabilityKind, f as CapabilitySearchSnapshot } from './capability.d-Ch5Vos33.js';
+import { b as CapabilityResult, a as CapabilityProvider, C as CapabilityKind, f as CapabilitySearchSnapshot } from './capability.d-DOF3r0fJ.js';
 import { a as McpServerConfig, b as McpServersConfig, M as McpConnectMode } from './config.d-CJy1WENT.js';
 
 type McpCapabilityKind = 'tool' | 'resource' | 'prompt';
@@ -271,6 +271,13 @@ declare class McpServerRuntime {
     private sendResponse;
     /** Best-effort JSON-RPC error send. */
     private sendError;
+    /**
+     * The shared host call context of the currently in-flight client requests.
+     * Zero, one, or many pending requests may share one context; a mix of
+     * different contexts cannot be attributed and resolves to undefined
+     * (fail-closed: the host handler declines rather than mis-attributes).
+     */
+    private pendingCallContext;
     /**
      * FEATURE_222 — handle a server→client request for an advertised reverse
      * capability. Each slice adds a case to {@link dispatchServerRequest};

package/dist/types-chunks/manifest.d-Bw2i-zQi.d.ts

@@ -0,0 +1,18 @@
+import { bb as WorkflowMeta } from './types.d-o7t9dds4.js';
+
+declare const WORKFLOW_PATTERN_IDS: readonly ["classify-and-act", "fan-out-and-synthesize", "adversarial-verification", "generate-and-filter", "tournament", "loop-until-done"];
+type WorkflowPatternId = (typeof WORKFLOW_PATTERN_IDS)[number];
+interface WorkflowScriptManifest extends WorkflowMeta {
+    readonly phases: readonly string[];
+    readonly readOnly: boolean;
+    readonly plannedAgents?: number;
+    readonly maxAgents: number;
+    readonly maxConcurrency: number;
+    readonly tokenBudget?: number;
+    readonly mayUseWorktree?: boolean;
+    readonly patterns: readonly WorkflowPatternId[];
+}
+declare function validateWorkflowScriptManifest(value: unknown): WorkflowScriptManifest;
+
+export { WORKFLOW_PATTERN_IDS as W, validateWorkflowScriptManifest as v };
+export type { WorkflowPatternId as a, WorkflowScriptManifest as b };

package/dist/types-chunks/provider-credential-context.d-BH2OaB1b.d.ts

@@ -0,0 +1,47 @@
+type ProviderCredentialPurpose = 'primary' | 'fallback' | 'classifier' | 'sidecar' | 'compaction' | 'workflow' | 'utility';
+interface ProviderCredentialLeaseAccess {
+    readonly allowedProviders: readonly string[];
+    readonly signal?: AbortSignal;
+    readonly isActive?: () => boolean;
+    acquire(provider: string, purpose: ProviderCredentialPurpose, signal: AbortSignal, attribution?: ProviderCredentialAttribution): Promise<string>;
+}
+type ProviderCredentialAttribution = {
+    readonly kind: 'actor_turn';
+    readonly actorPath: string;
+    readonly turnId: string;
+} | {
+    readonly kind: 'workflow';
+    readonly workflowRunId: string;
+};
+interface ProviderCredentialLeaseScope {
+    readonly allowedProviders: readonly string[];
+    close(reason?: string): void;
+}
+/** Run a provider operation with an in-memory, run-scoped credential override. */
+declare function runWithProviderCredential<T>(provider: string, credential: string, operation: () => T): T;
+/** Create an operation-owned resolver scope. No credential material is retained here. */
+declare function createProviderCredentialLeaseScope(access: ProviderCredentialLeaseAccess): ProviderCredentialLeaseScope;
+/** Run an operation in a previously created lease scope. */
+declare function runWithProviderCredentialLeaseScope<T>(scope: ProviderCredentialLeaseScope, operation: () => T): T;
+/** Run outside any Runtime Provider credential authority (for external executors). */
+declare function runWithoutProviderCredentialScope<T>(operation: () => T): T;
+/** Derive a short-lived child from the active lazy lease without exposing its resolver. */
+declare function deriveCurrentProviderCredentialLeaseScope(allowedProviders: readonly string[], attribution?: ProviderCredentialAttribution): ProviderCredentialLeaseScope | undefined;
+/** Concrete Provider authority carried by the active lazy lease, never a wildcard. */
+declare function currentProviderCredentialLeaseProviders(): readonly string[] | undefined;
+/**
+ * Resolve one Provider immediately before its wire call. The secret exists only
+ * in the nested exact scope and is discarded when the call settles.
+ */
+declare function withProviderRequestCredential<T>(provider: string, purpose: ProviderCredentialPurpose, signal: AbortSignal | undefined, operation: (signal: AbortSignal | undefined) => Promise<T> | T, logicalRequestId?: string): Promise<T>;
+/** Internal provider lookup. The credential is never copied to config or diagnostics. */
+declare function getScopedProviderCredential(provider: string): string | undefined;
+/** Whether an active scope authorizes a Provider without triggering broker I/O. */
+declare function hasScopedProviderCredentialAuthority(provider: string): boolean | undefined;
+/** True while either an exact or lazy credential authority is present. */
+declare function hasProviderCredentialContext(): boolean;
+/** Remove the active exact credential from DTOs before diagnostics or persistence. */
+declare function redactScopedProviderCredential<T>(value: T): T;
+
+export { createProviderCredentialLeaseScope as d, currentProviderCredentialLeaseProviders as e, deriveCurrentProviderCredentialLeaseScope as f, getScopedProviderCredential as g, hasProviderCredentialContext as h, hasScopedProviderCredentialAuthority as i, runWithProviderCredential as j, runWithProviderCredentialLeaseScope as k, runWithoutProviderCredentialScope as l, redactScopedProviderCredential as r, withProviderRequestCredential as w };
+export type { ProviderCredentialAttribution as P, ProviderCredentialLeaseAccess as a, ProviderCredentialLeaseScope as b, ProviderCredentialPurpose as c };

package/dist/types-chunks/provider-request-observation.d-jL8T6wVO.d.ts

@@ -0,0 +1,34 @@
+import { a2 as KodaXTokenUsage } from './types.d-BjOq57-z.js';
+import { c as ProviderCredentialPurpose, P as ProviderCredentialAttribution } from './provider-credential-context.d-BH2OaB1b.js';
+
+interface ProviderRequestObservation {
+    /** pending is a native fetch adapter's provisional boundary; unavailable is operation-only. */
+    readonly wireObservation?: 'pending' | 'observed' | 'unavailable';
+    readonly route?: {
+        readonly chainId: string;
+        readonly attempt: number;
+        readonly fromProvider?: string;
+    };
+    readonly requestId: string;
+    readonly logicalRequestId: string;
+    readonly provider: string;
+    readonly model?: string;
+    readonly purpose: ProviderCredentialPurpose;
+    readonly attribution?: ProviderCredentialAttribution;
+    readonly attempt: number;
+    readonly boundary: 'physical_attempt' | 'provider_operation';
+    readonly dispatch: 'dispatched' | 'unknown';
+    readonly state: 'started' | 'succeeded' | 'failed' | 'cancelled';
+    readonly startedAt: string;
+    readonly endedAt?: string;
+    readonly usage?: KodaXTokenUsage;
+}
+type Observer = (fact: ProviderRequestObservation) => void;
+/** Execution identity is observational and exists independently of credential authority. */
+declare function runWithProviderRequestAttribution<T>(attribution: ProviderCredentialAttribution, operation: () => T): T;
+declare function runWithProviderRequestRoute<T>(route: NonNullable<ProviderRequestObservation['route']>, operation: () => T): T;
+declare function runWithProviderRequestAbortSignal<T>(signal: AbortSignal, operation: () => T): T;
+declare function runWithProviderRequestObserver<T>(observer: Observer, operation: () => T): T;
+
+export { runWithProviderRequestAttribution as a, runWithProviderRequestObserver as b, runWithProviderRequestRoute as c, runWithProviderRequestAbortSignal as r };
+export type { ProviderRequestObservation as P };

package/dist/types-chunks/{public-api.d-amBop8Nk.d.ts → public-api.d-Cq8ILMte.d.ts}

@@ -1,7 +1,8 @@
-import { a as BashPrefixExtractor, v as KodaXAgentMode } from './bash-prefix-extractor.d-DWFIMg0v.js';
-import { G as KodaXReasoningMode, k as KodaXMessage, U as KodaXTaskResultMetadata } from './types.d-BrQMB-hy.js';
-import { bG as LearningSurfaceSnapshot$1, bB as LearningQuery, bA as LearningPage, bd as LearnedCapabilityRecord, bw as LearningEvent, bF as LearningSubscribeOptions, aj as CompactionReport, ah as CompactionConfig } from './controller.d-J2t1q8Ly.js';
-import { ab as KodaXSessionData, ag as KodaXSessionLineage, al as KodaXSessionNavigationOptions, an as KodaXSessionRuntimeInfo, ap as KodaXSessionStorage, V as KodaXExtensionSessionRecord, ac as KodaXSessionEntry, a7 as KodaXSessionArtifactLedgerEntry, ar as KodaXSessionUiHistoryItem, ao as KodaXSessionScope, g as AgentActorSnapshot, c as AgentActorSaveAttempt, a1 as KodaXJsonValue } from './types.d-CSv0_cZC.js';
+import { ai as ClientSessionSettings } from './client-contract-A1jdk6xz.js';
+import { a as BashPrefixExtractor, w as KodaXAgentMode } from './bash-prefix-extractor.d-DvswAXKS.js';
+import { G as KodaXReasoningMode, k as KodaXMessage, U as KodaXTaskResultMetadata } from './types.d-BjOq57-z.js';
+import { aP as LearningSurfaceSnapshot$1, aN as LearningQuery, aM as LearningPage, ax as LearnedCapabilityRecord, aI as LearningEvent, aO as LearningSubscribeOptions, a4 as CompactionReport, a2 as CompactionConfig } from './types.d-o7t9dds4.js';
+import { as as KodaXSessionData, ax as KodaXSessionLineage, aC as KodaXSessionNavigationOptions, aE as KodaXSessionRuntimeInfo, aG as KodaXSessionStorage, aa as KodaXExtensionSessionRecord, at as KodaXSessionEntry, ao as KodaXSessionArtifactLedgerEntry, aI as KodaXSessionUiHistoryItem, aF as KodaXSessionScope, g as AgentActorSnapshot, c as AgentActorSaveAttempt, ai as KodaXJsonValue } from './review-inbox.d-BeaLRNHx.js';
 
 /**
  * TextBuffer - Text buffer management class - 文本缓冲区管理类
@@ -485,14 +486,15 @@ interface InputPromptProps {
      * `undefined` to leave history-recall behavior intact when the queue is
      * empty.
      */
-    onPopPendingInputs?: () => string | undefined;
+    onPopPendingInputs?: () => string | undefined | Promise<string | undefined>;
 }
 type LearningSurfaceSnapshot = LearningSurfaceSnapshot$1;
 interface LearningBinding {
     getSnapshot(): Promise<LearningSurfaceSnapshot>;
     list(query?: LearningQuery): Promise<LearningPage>;
     get(nameOrSlug: string): Promise<LearnedCapabilityRecord>;
-    subscribe(listener: (event: LearningEvent) => void, options?: LearningSubscribeOptions): {
+    subscribe(listener: (event: LearningEvent) => void, options?: LearningSubscribeOptions, onError?: (error: unknown) => void): {
+        readonly ready?: Promise<void>;
         close(): void;
     };
     acknowledge(nameOrSlug: string): Promise<void>;
@@ -505,6 +507,7 @@ interface LearningBinding {
     trust(nameOrSlug: string): Promise<void>;
 }
 interface StatusBarProps {
+    hostSettings?: ClientSessionSettings;
     sessionId: string;
     permissionMode: PermissionMode;
     agentMode: KodaXAgentMode;
@@ -538,6 +541,11 @@ interface StatusBarProps {
     maxIter?: number;
     /** Context usage info - Issue 070: 显示上下文使用情况 */
     contextUsage?: {
+        /** Host configuration cannot supply a physical trigger before execution resolves its envelope. */
+        hostBudget?: boolean;
+        effectiveTriggerTokens?: number;
+        /** Live execution scope the tokens belong to; workers run their own window. */
+        scope?: 'parent' | 'worker';
         /** Current token count in context */
         currentTokens: number;
         /** Context window size (effective contextWindow) */
@@ -549,6 +557,11 @@ interface StatusBarProps {
         /** Provider output capacity reserved from the physical context window. */
         reservedResponseTokens?: number;
     };
+    /** Scope-specific quantity when no matching budget is known. */
+    contextTokens?: {
+        currentTokens: number;
+        scope: 'parent' | 'worker';
+    };
     /** Client-specific Learning Center projection. Inventory alone stays hidden. */
     learning?: LearningSurfaceSnapshot;
     /** Whether current busy/thinking status should be visible in the bar */
@@ -630,9 +643,12 @@ declare const TOOL_STATUS_ICONS: Record<ToolCallStatus, string>;
  */
 interface ToolCall {
     id: string;
+    assistantOutputId?: string;
     name: string;
     status: ToolCallStatus;
     input?: Record<string, unknown>;
+    /** Serialized Host arguments; may be a bounded preview until explicitly read. */
+    inputText?: string;
     preview?: string;
     output?: unknown;
     error?: string;
@@ -651,9 +667,21 @@ type HistoryItemType = "user" | "assistant" | "system" | "tool_group" | "thinkin
  * History item base class - 历史项基类
  */
 interface HistoryItemBase {
+    outputId?: string;
+    outputState?: 'draft' | 'committed';
+    textRevision?: number;
+    /** Source input boundary for retained Host output. */
+    afterInputId?: string;
     id: string;
+    /** Accepted input identity used to join saved history to a frozen browse snapshot. */
+    inputId?: string;
     type: HistoryItemType;
     timestamp: number;
+    textOffset?: number;
+    totalTextLength?: number;
+    totalInputLength?: number;
+    /** Stable canonical reader identity when this display item came from history paging. */
+    historyItemId?: string;
     /** Ephemeral marker used so restored display-only entries cannot evict canonical transcript history. */
     isSessionUiOnly?: boolean;
 }
@@ -737,15 +765,15 @@ interface HistoryItemHint extends HistoryItemBase {
  * Displayed as an independent "role" with its own header so the user can
  * clearly see that the Sidecar Verifier is actively reviewing the output.
  * verdict: 'revise' | 'blocked' | undefined; delivery 'budget-exhausted' means
- * the verifier ran out of budget before returning a verdict.
+ * the verifier exhausted its delivery budget instead of injecting the advice.
  */
 interface HistoryItemSidecar extends HistoryItemBase {
     type: "sidecar";
     text: string;
-    /** 'revise' or 'blocked'; absent when delivery === 'budget-exhausted' */
+    /** Absent on legacy snapshots that retained only a delivery marker. */
     verdict?: "revise" | "blocked";
-    /** Set when the verifier exhausted its token budget before reaching a verdict */
-    delivery?: "budget-exhausted";
+    /** How the verifier result was delivered; absent on older snapshots. */
+    delivery?: "synthetic-user-message" | "budget-exhausted" | "terminal-block";
 }
 /**
  * Union type of all history items - 所有历史项的联合类型
@@ -788,6 +816,8 @@ interface UIActions {
     clearResponse: () => void;
     addHistoryItem: (item: CreatableHistoryItem) => void;
     addHistoryItems: (items: CreatableHistoryItem[]) => void;
+    /** FEATURE_298 T17 — wholesale replacement from the Host session view. */
+    replaceHistoryItems: (items: HistoryItem[]) => void;
     updateHistoryItem: (id: string, updates: Partial<HistoryItem>) => void;
     clearHistory: () => void;
     addToolCall: (tool: Omit<ToolCall, "id" | "startTime">) => string;
@@ -934,8 +964,8 @@ interface SessionIdentityRepairInput {
         readonly runId: string;
         readonly inputId: string;
         readonly eventId: string;
-        readonly seq: number;
-        readonly eventDigest: string;
+        /** sha256 over the persisted Run-status delivery receipt the Host verified. */
+        readonly receiptDigest: string;
     };
 }
 interface SessionConfirmedIdentityRepairData extends SessionIdentityRepairInput {
@@ -971,6 +1001,8 @@ interface ConversationPageCacheInput {
     readonly maxPageBytes: number;
     readonly maxInlineEntryBytes: number;
     readonly reservedBytes: number;
+    /** Internal source lookup: returns matching entry locators without reading bodies. */
+    readonly sourceKeys?: readonly string[];
     readonly authorize?: (admission: ConversationPageCacheAdmission) => void | Promise<void>;
     readonly signal?: AbortSignal;
 }
@@ -1140,6 +1172,7 @@ declare class FileSessionStorage implements KodaXSessionStorage {
     completeSessionLocationTraversal(boundary: SessionLocationTraversalBoundary, filePaths: readonly string[], traversalComplete: boolean): void;
     private writeQueues;
     private serializedWrite;
+    private awaitOwnWrites;
     private refreshSelfVerifiedLocationTopology;
     private sessionWriteLockPath;
     private persistSessionLocationHint;
@@ -1207,6 +1240,8 @@ declare class FileSessionStorage implements KodaXSessionStorage {
      * IDs must continue through the ordinary global conflict check.
     */
     createGenerated(id: string, data: SessionData): Promise<void>;
+    /** Update display metadata under the same writer lock as canonical Session saves. */
+    mutateUiHistory(id: string, mutation: (history: readonly KodaXSessionUiHistoryItem[], session: Readonly<SessionData>) => KodaXSessionUiHistoryItem[]): Promise<boolean>;
     mutateLineage(id: string, mutation: (lineage: KodaXSessionLineage) => KodaXSessionLineage): Promise<boolean>;
     mutateRuntimeInfo(id: string, mutation: (runtimeInfo: KodaXSessionRuntimeInfo | undefined) => KodaXSessionRuntimeInfo | undefined): Promise<boolean>;
     /** Phase-aware Actor CAS save; canonical success is observable before cache maintenance. */
@@ -1240,6 +1275,7 @@ declare class FileSessionStorage implements KodaXSessionStorage {
     }): Promise<SessionData | null>;
     setLabel(id: string, selector: string, label?: string): Promise<SessionData | null>;
     fork(id: string, selector?: string, options?: {
+        before?: boolean;
         sessionId?: string;
         title?: string;
         historyBoundary?: SessionHistoryBoundary;
@@ -1337,6 +1373,7 @@ declare class FileSessionStorage implements KodaXSessionStorage {
  */
 
 interface CompactSessionOptions {
+    readonly abortSignal?: AbortSignal;
     /** Summary policy, normally supplied by the Runtime Session settings. */
     readonly reasoning?: CompactionConfig['reasoning'];
     /** Provider alias for the summarizer. Defaults to the session's persisted provider, then 'anthropic'. */
@@ -1642,7 +1679,9 @@ declare function rewindSession(id: string, opts?: RewindSessionOptions): Promise
  * Set the active lineage entry by selector.
  * Returns null for a missing session. NEVER throws.
  */
-declare function setActiveEntry(id: string, selector: string): Promise<SessionData | null>;
+declare function setActiveEntry(id: string, selector: string, options?: {
+    summarizeCurrentBranch?: boolean;
+}): Promise<SessionData | null>;
 interface RunningSessionInfo {
     readonly pid: number;
     readonly startedAt: number;

package/dist/types-chunks/{resolver.d-BrwLoWNr.d.ts → resolver.d-DLY01RHx.d.ts}

@@ -1,6 +1,6 @@
-import { G as KodaXReasoningMode, O as KodaXStableEffortIntent, ab as KodaXWireReasoningEffort, H as KodaXReasoningProfile, $ as KodaXThinkingBudgetMap, a0 as KodaXThinkingDepth, r as KodaXProviderConfig, C as KodaXReasoningCapability, I as KodaXReasoningRequest, n as KodaXNormalizedReasoningRequest, X as KodaXTaskType, a9 as KodaXVerifyCredentialResult, a3 as KodaXToolDefinition, k as KodaXMessage, z as KodaXProviderStreamOptions, P as KodaXStreamResult, l as KodaXModelDescriptor, q as KodaXProviderCapabilityProfile, o as KodaXOpenAICompatMaxOutputTokensField, aa as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, j as KodaXListModelsResult } from './types.d-BrQMB-hy.js';
+import { G as KodaXReasoningMode, O as KodaXStableEffortIntent, ab as KodaXWireReasoningEffort, H as KodaXReasoningProfile, $ as KodaXThinkingBudgetMap, a0 as KodaXThinkingDepth, r as KodaXProviderConfig, C as KodaXReasoningCapability, I as KodaXReasoningRequest, n as KodaXNormalizedReasoningRequest, X as KodaXTaskType, a9 as KodaXVerifyCredentialResult, a3 as KodaXToolDefinition, k as KodaXMessage, z as KodaXProviderStreamOptions, P as KodaXStreamResult, l as KodaXModelDescriptor, q as KodaXProviderCapabilityProfile, o as KodaXOpenAICompatMaxOutputTokensField, aa as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, j as KodaXListModelsResult } from './types.d-BjOq57-z.js';
 import Anthropic from '@anthropic-ai/sdk';
-import { K as KodaXBaseProvider } from './base.d-Bt9lhwSV.js';
+import { K as KodaXBaseProvider } from './base.d-ZBOdjDUT.js';
 import OpenAI from 'openai';
 
 declare const KODAX_REASONING_MODE_SEQUENCE: KodaXReasoningMode[];
@@ -117,6 +117,7 @@ declare function resolveWireEffort(input: ResolveWireEffortInput): ResolvedWireE
  */
 
 declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
+    protected readonly requestObservationBoundary: "physical_attempt";
     abstract readonly name: string;
     readonly supportsThinking = true;
     protected abstract readonly config: KodaXProviderConfig;
@@ -242,6 +243,7 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
  */
 
 declare abstract class KodaXOpenAICompatProvider extends KodaXBaseProvider {
+    protected readonly requestObservationBoundary: "physical_attempt";
     private reasoningRejections;
     protected normalizeReasoning(reasoning?: boolean | KodaXReasoningRequest): KodaXNormalizedReasoningRequest;
     private reasoningAttempts;