@kodax-ai/kodax 0.7.56 → 0.7.58

package/dist/types-chunks/{resolver.d-Djq8KlCE.d.ts → resolver.d-DDOfVYDr.d.ts}

@@ -1,6 +1,6 @@
-import { E as KodaXReasoningMode, V as KodaXThinkingBudgetMap, W as KodaXThinkingDepth, s as KodaXProviderConfig, D as KodaXReasoningCapability, G as KodaXReasoningRequest, R as KodaXTaskType, F as KodaXReasoningOverride, a2 as KodaXVerifyCredentialResult, Y as KodaXToolDefinition, n as KodaXMessage, A as KodaXProviderStreamOptions, L as KodaXStreamResult, o as KodaXModelDescriptor, r as KodaXProviderCapabilityProfile, a3 as KodaXVerifyStrategy, h as KodaXCustomProviderConfig, m as KodaXListModelsResult } from './types.d-BJmoMf5H.js';
+import { E as KodaXReasoningMode, L as KodaXStableEffortIntent, a6 as KodaXWireReasoningEffort, F as KodaXReasoningProfile, W as KodaXThinkingBudgetMap, X as KodaXThinkingDepth, p as KodaXProviderConfig, A as KodaXReasoningCapability, G as KodaXReasoningRequest, m as KodaXNormalizedReasoningRequest, S as KodaXTaskType, a4 as KodaXVerifyCredentialResult, _ as KodaXToolDefinition, j as KodaXMessage, x as KodaXProviderStreamOptions, M as KodaXStreamResult, k as KodaXModelDescriptor, o as KodaXProviderCapabilityProfile, a5 as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, i as KodaXListModelsResult } from './types.d-Ci5YPFEh.js';
 import Anthropic from '@anthropic-ai/sdk';
-import { K as KodaXBaseProvider } from './base.d-CwPfI8WQ.js';
+import { K as KodaXBaseProvider } from './base.d-BA9Doaj_.js';
 import OpenAI from 'openai';
 
 /**
@@ -34,23 +34,58 @@ declare class KodaXToolCallIdError extends KodaXError {
 }
 
 declare const KODAX_REASONING_MODE_SEQUENCE: KodaXReasoningMode[];
+declare const KODAX_STABLE_EFFORT_INTENTS: KodaXStableEffortIntent[];
 declare const KODAX_DEFAULT_THINKING_BUDGETS: KodaXThinkingBudgetMap;
 declare const KODAX_REASONING_SAFETY_RESERVE = 4096;
 declare function getReasoningCapability(config: KodaXProviderConfig): KodaXReasoningCapability;
 declare function isReasoningEnabled(reasoning?: boolean | KodaXReasoningRequest): boolean;
-declare function normalizeReasoningRequest(reasoning?: boolean | KodaXReasoningRequest): Required<KodaXReasoningRequest>;
+declare function normalizeReasoningRequest(reasoning?: boolean | KodaXReasoningRequest): KodaXNormalizedReasoningRequest;
+type KodaXReasoningEffortEnvOverride = {
+    kind: 'unset';
+} | {
+    kind: 'clear';
+} | {
+    kind: 'value';
+    value: KodaXWireReasoningEffort;
+};
+type KodaXReasoningEffortSource = 'env' | 'explicit' | 'session' | 'legacy' | 'model-default' | 'provider-default' | 'fallback';
+interface KodaXResolvedReasoningEffort {
+    readonly configuredEffort: KodaXWireReasoningEffort;
+    readonly effectiveEffort?: KodaXWireReasoningEffort;
+    readonly source: KodaXReasoningEffortSource;
+    readonly isExplicit: boolean;
+    readonly diagnostics: readonly string[];
+}
+interface KodaXResolveReasoningEffortInput {
+    readonly capability?: KodaXReasoningProfile;
+    readonly envEffort?: string;
+    readonly explicitEffort?: string;
+    readonly sessionEffort?: string;
+    readonly legacyReasoningMode?: KodaXReasoningMode;
+    readonly thinking?: boolean;
+    readonly modelDefaultEffort?: string;
+    readonly providerDefaultEffort?: string;
+    readonly fallbackEffort?: string;
+}
+interface KodaXModelSwitchEffortResolution {
+    readonly effectiveEffort?: KodaXWireReasoningEffort;
+    readonly preserved: boolean;
+    readonly diagnostic?: string;
+}
+declare function normalizeReasoningEffortValue(value: string): KodaXWireReasoningEffort;
+declare function mapLegacyReasoningModeToEffortIntent(mode: KodaXReasoningMode): KodaXStableEffortIntent;
+declare function effortToLegacyReasoningMode(effort: string | undefined): KodaXReasoningMode | undefined;
+declare function parseReasoningEffortEnv(raw: string | undefined): KodaXReasoningEffortEnvOverride;
+declare function resolveReasoningEffort(input: KodaXResolveReasoningEffortInput): KodaXResolvedReasoningEffort;
+declare function resolveReasoningEffortForModelSwitch(input: {
+    readonly currentEffort: string | undefined;
+    readonly capability?: KodaXReasoningProfile;
+}): KodaXModelSwitchEffortResolution;
 declare function getDefaultThinkingDepthForMode(mode: KodaXReasoningMode): KodaXThinkingDepth;
 declare function resolveThinkingBudget(config: KodaXProviderConfig, depth: KodaXThinkingDepth, taskType?: KodaXTaskType): number;
 declare function clampThinkingBudget(requestedBudget: number, maxOutputTokens: number, safetyReserve?: number): number;
 declare function mapDepthToOpenAIReasoningEffort(depth: KodaXThinkingDepth): 'low' | 'medium' | 'high' | undefined;
 
-declare function reasoningCapabilityToOverride(capability: KodaXReasoningCapability): KodaXReasoningOverride | undefined;
-declare function reasoningOverrideToCapability(override: KodaXReasoningOverride): KodaXReasoningCapability;
-declare function buildReasoningOverrideKey(providerName: string, config: Pick<KodaXProviderConfig, 'baseUrl' | 'model'>, modelOverride?: string): string;
-declare function loadReasoningOverride(providerName: string, config: Pick<KodaXProviderConfig, 'baseUrl' | 'model'>, modelOverride?: string): KodaXReasoningOverride | undefined;
-declare function saveReasoningOverride(providerName: string, config: Pick<KodaXProviderConfig, 'baseUrl' | 'model'>, override: KodaXReasoningOverride, modelOverride?: string): void;
-declare function clearReasoningOverride(providerName: string, config: Pick<KodaXProviderConfig, 'baseUrl' | 'model'>, modelOverride?: string): void;
-
 /**
  * KodaX Anthropic Compatible Provider
  *
@@ -73,6 +108,9 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
     protected set client(client: Anthropic);
     protected buildClient(): Anthropic;
     protected onStaleConnection(): void;
+    private buildMessageCreateOptions;
+    private applyReasoningProfile;
+    private resolveReasoningProfileBudget;
     /**
      * FEATURE_216 v0.7.45 — Lightweight credential verification.
      * Dispatches by `this.config.verifyStrategy`:
@@ -103,6 +141,14 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
      * original string unchanged so prompt caching can be disabled at
      * runtime without redeploying.
      */
+    /**
+     * Run-scoped (concurrency-safe) config wins over the global env, in BOTH
+     * directions: an SDK caller that explicitly sets `disablePromptCache: false`
+     * re-enables caching even when `KODAX_DISABLE_PROMPT_CACHE=1` is set at
+     * startup (e.g. bridged from `config.json`). A plain `||` would let the env
+     * win in that re-enable case, breaking the documented SDK > env precedence.
+     */
+    private isPromptCacheDisabled;
     protected applyCacheControlToSystem(systemText: string): string | Anthropic.Messages.TextBlockParam[];
     /**
      * FEATURE_116 (v0.7.37) — Mark the last tool definition as the cache
@@ -113,12 +159,51 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
      * Returns a new array; never mutates input.
      */
     protected applyCacheControlToTools(tools: KodaXToolDefinition[]): Anthropic.Messages.Tool[];
+    /**
+     * FEATURE_116 follow-up — Place an incremental cache breakpoint on the
+     * conversation history (Anthropic breakpoint 3). The system prompt and
+     * tools already carry breakpoints 1 & 2 (applyCacheControlToSystem /
+     * applyCacheControlToTools); without a message-level breakpoint the whole
+     * growing transcript is re-billed as uncached input every turn.
+     *
+     * Strategy: mark the LAST content block of the second-to-last `user` turn.
+     * The most recent user turn is skipped — it is the current, still-changing
+     * input. The prior user turn's content is settled, so its prefix is a stable
+     * cache write-point that later turns read back incrementally (Anthropic caches
+     * the whole prefix up to and including the marked block: tools + system + all
+     * earlier messages). Total breakpoints stay at 3 (≤ Anthropic's limit of 4).
+     *
+     * Only anthropic-compat providers reach this path; OpenAI/ACP strip cache
+     * markers and rely on upstream automatic prefix caching. Escape hatch:
+     * `KODAX_DISABLE_PROMPT_CACHE=1` returns the array untouched.
+     *
+     * Returns a new array; never mutates input.
+     */
+    protected applyCacheControlToMessages(messages: Anthropic.Messages.MessageParam[]): Anthropic.Messages.MessageParam[];
     stream(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
     supportsNonStreamingFallback(): boolean;
     complete(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
     private serializeSystemMessageContent;
     private buildSystemPrompt;
     private convertMessages;
+    /**
+     * Wire-only defense-in-depth: drop orphan `tool_use` / `tool_result` blocks
+     * so the Anthropic API never 400s on "tool_use ids ... were not found in
+     * tool_result blocks" or "unexpected tool_result". The upstream
+     * `validateAndFixToolHistory` (run every turn before serialization) is the
+     * primary guard; this mirrors the OpenAI-side `repairToolCallHistory` so
+     * both provider families have the same last-mile net for any path that
+     * bypasses validate (custom callers, side queries). Never mutates input.
+     *
+     * Pairing is computed against adjacent messages (same rule as validate): a
+     * `tool_use` is orphan when the immediately-following user message has no
+     * matching `tool_result`; a `tool_result` is orphan when the
+     * immediately-preceding assistant message has no matching `tool_use`. A
+     * message emptied by repair is replaced with a minimal wire-only `'...'`
+     * text block to keep user/assistant alternation and satisfy gateways that
+     * reject empty content.
+     */
+    private repairToolCallHistory;
 }
 
 /**
@@ -193,6 +278,8 @@ declare abstract class KodaXOpenAICompatProvider extends KodaXBaseProvider {
     private appendExtraBody;
     private resetReasoningCapabilityParams;
     private applyReasoningCapability;
+    private applyReasoningProfile;
+    private resolveReasoningProfileBudget;
     private getFallbackTerms;
     stream(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
     supportsNonStreamingFallback(): boolean;
@@ -208,10 +295,10 @@ declare abstract class KodaXOpenAICompatProvider extends KodaXBaseProvider {
 /**
  * KodaX Provider Registry
  *
- * Provider 注册表 - 统一管理所有 Provider
+  * Provider 注册表 - 统一管理所有 Provider
  */
 
-type ProviderName = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'kimi-code' | 'qwen' | 'zhipu' | 'zhipu-coding' | 'minimax-coding' | 'mimo-coding' | 'mimo' | 'ark-coding' | 'gemini-cli' | 'codex-cli';
+type ProviderName = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'kimi-code' | 'qwen' | 'zhipu' | 'zhipu-coding' | 'zai-coding' | 'minimax-coding' | 'mimo-coding' | 'mimo' | 'ark-coding' | 'gemini-cli' | 'codex-cli';
 /**
  * Per-provider static metadata. v0.7.43 promoted this from a partial
  * descriptor (`models: string[]`) to the full capability surface so
@@ -240,6 +327,7 @@ type ProviderSnapshot = {
     readonly models?: readonly KodaXModelDescriptor[];
     readonly apiKeyEnv: string;
     readonly reasoningCapability: KodaXReasoningCapability;
+    readonly reasoningProfile?: KodaXReasoningProfile;
     readonly modelReasoningCapabilities?: Readonly<Record<string, KodaXReasoningCapability>>;
     readonly capabilityProfile: KodaXProviderCapabilityProfile;
     /** Maximum input context window (tokens). Provider-level default. */
@@ -271,6 +359,7 @@ declare function getProviderList(): Array<{
     models: string[];
     configured: boolean;
     reasoningCapability: KodaXReasoningCapability;
+    reasoningProfile?: KodaXReasoningProfile;
     capabilityProfile: KodaXProviderCapabilityProfile;
 }>;
 declare function getProviderModels(name: string): string[];
@@ -305,6 +394,8 @@ interface KodaXModelCapabilities {
     supportsThinking: boolean;
     /** Effective reasoning capability for THIS model (per-model override aware). */
     reasoningCapability: KodaXReasoningCapability;
+    /** Effort-first reasoning capability metadata for THIS model, when known. */
+    reasoningProfile?: KodaXReasoningProfile;
     /** Maximum input context window (tokens). `undefined` for CLI-bridge providers. */
     contextWindow?: number;
     /**
@@ -331,10 +422,12 @@ interface KodaXModelCapabilities {
  */
 declare function getProviderModelDescriptors(name: string): KodaXModelDescriptor[];
 /**
- * Effective per-model capability surface for a built-in provider. Returns
- * `undefined` for unknown provider name or unknown model under a known
- * provider — caller should fall back to `DEFAULT_CONTEXT_WINDOW` from
- * `@kodax-ai/kodax/agent` when nothing is advertised.
+ * Effective per-model capability surface for a built-in provider.
+ *
+ * Returns `undefined` only for an unknown PROVIDER name. An unknown MODEL under
+ * a known provider inherits the provider-level capability (optimistic-wide
+ * default — see the inline note below), so callers always get a usable surface
+ * for any model id routed to a known provider.
  *
  * No API key required.
  */
@@ -501,5 +594,5 @@ declare function listProviderModels(name: string, _opts?: {
     signal?: AbortSignal;
 }): Promise<KodaXListModelsResult>;
 
-export { reasoningOverrideToCapability as $, getModelCapabilities as A, getProvider as B, getProviderConfiguredCapabilityProfile as C, getProviderConfiguredReasoningCapability as D, getProviderList as E, getProviderModel as F, getProviderModelDescriptors as G, getProviderModels as H, getReasoningCapability as I, getRuntimeModelProvider as J, KODAX_DEFAULT_PROVIDER as K, getRuntimeModelProviderNames as L, isCustomProviderName as M, isKnownProvider as N, isProviderConfigured as O, isProviderName as Q, isReasoningEnabled as R, isRuntimeModelProviderName as S, listAllModelCapabilities as T, listBuiltinModelCapabilities as U, listCustomProviderModelCapabilities as V, listProviderModels as W, loadReasoningOverride as X, mapDepthToOpenAIReasoningEffort as Y, normalizeReasoningRequest as Z, reasoningCapabilityToOverride as _, KODAX_DEFAULT_THINKING_BUDGETS as a, registerCustomProviders as a0, registerModelProvider as a1, resolveModelCapabilities as a2, resolveProvider as a3, resolveProviderModelDescriptors as a4, resolveThinkingBudget as a5, saveReasoningOverride as a6, validateCustomProviderConfig as a7, verifyProviderCredential as a8, KODAX_PROVIDERS as b, KODAX_PROVIDER_SNAPSHOTS as c, KODAX_REASONING_MODE_SEQUENCE as d, KODAX_REASONING_SAFETY_RESERVE as e, KodaXAnthropicCompatProvider as f, KodaXError as g, KodaXNetworkError as i, KodaXOpenAICompatProvider as j, KodaXProviderError as k, KodaXRateLimitError as l, KodaXToolCallIdError as m, buildReasoningOverrideKey as n, clampThinkingBudget as o, clearReasoningOverride as p, clearRuntimeModelProviders as q, createCustomProvider as r, getAvailableProviderNames as s, getCustomModelCapabilities as t, getCustomProvider as u, getCustomProviderList as v, getCustomProviderModelDescriptors as w, getCustomProviderModels as x, getCustomProviderNames as y, getDefaultThinkingDepthForMode as z };
-export type { ProviderName as P, KodaXModelCapabilities as h };
+export { parseReasoningEffortEnv as $, getModelCapabilities as A, getProvider as B, getProviderConfiguredCapabilityProfile as C, getProviderConfiguredReasoningCapability as D, getProviderList as E, getProviderModel as F, getProviderModelDescriptors as G, getProviderModels as H, getReasoningCapability as I, getRuntimeModelProvider as J, KODAX_DEFAULT_PROVIDER as K, getRuntimeModelProviderNames as L, isCustomProviderName as M, isKnownProvider as N, isProviderConfigured as O, isProviderName as Q, isReasoningEnabled as R, isRuntimeModelProviderName as S, listAllModelCapabilities as T, listBuiltinModelCapabilities as U, listCustomProviderModelCapabilities as V, listProviderModels as W, mapDepthToOpenAIReasoningEffort as X, mapLegacyReasoningModeToEffortIntent as Y, normalizeReasoningEffortValue as Z, normalizeReasoningRequest as _, KODAX_DEFAULT_THINKING_BUDGETS as a, registerCustomProviders as a0, registerModelProvider as a1, resolveModelCapabilities as a2, resolveProvider as a3, resolveProviderModelDescriptors as a4, resolveReasoningEffort as a5, resolveReasoningEffortForModelSwitch as a6, resolveThinkingBudget as a7, validateCustomProviderConfig as a8, verifyProviderCredential as a9, KODAX_PROVIDERS as b, KODAX_PROVIDER_SNAPSHOTS as c, KODAX_REASONING_MODE_SEQUENCE as d, KODAX_REASONING_SAFETY_RESERVE as e, KODAX_STABLE_EFFORT_INTENTS as f, KodaXAnthropicCompatProvider as g, KodaXError as h, KodaXNetworkError as j, KodaXOpenAICompatProvider as k, KodaXProviderError as l, KodaXRateLimitError as m, KodaXToolCallIdError as n, clampThinkingBudget as o, clearRuntimeModelProviders as p, createCustomProvider as q, effortToLegacyReasoningMode as r, getAvailableProviderNames as s, getCustomModelCapabilities as t, getCustomProvider as u, getCustomProviderList as v, getCustomProviderModelDescriptors as w, getCustomProviderModels as x, getCustomProviderNames as y, getDefaultThinkingDepthForMode as z };
+export type { ProviderName as P, KodaXModelCapabilities as i };

package/dist/types-chunks/{capsule.d-D0kjnqYy.d.ts → run-manager.d-ByDcJc5g.d.ts}

@@ -1,6 +1,6 @@
-import { n as KodaXMessage } from './types.d-BJmoMf5H.js';
-import { Q as QueueEventListener, e as QueuedMessage, E as EnqueueInput, D as DequeueFilter } from './types.d-BKuHSiR0.js';
-import { f as AgentMessage, aM as SessionEntry, aK as Session, aO as SessionExtension, a4 as KodaXSessionLineage, W as KodaXJsonValue, p as CompactionDetails, O as KodaXCompactMemorySeed, a0 as KodaXSessionEntry, ab as KodaXSessionTreeNode, a3 as KodaXSessionLabelEntry, a2 as KodaXSessionGoalEntry, a7 as KodaXSessionNavigationOptions, Y as KodaXSessionArtifactLedgerEntry, x as FileOperations, br as WorkflowMeta, bs as WorkflowModelHint, bt as WorkflowModule } from './process.d-BdiIUr8T.js';
+import { j as KodaXMessage } from './types.d-Ci5YPFEh.js';
+import { Q as QueueEventListener, f as QueuedMessage, E as EnqueueInput, D as DequeueFilter } from './types.d-D4ZA8LJV.js';
+import { g as AgentMessage, aU as SessionEntry, aS as Session, aW as SessionExtension, aa as KodaXSessionLineage, a0 as KodaXJsonValue, q as CompactionDetails, P as KodaXCompactMemorySeed, a6 as KodaXSessionEntry, ah as KodaXSessionTreeNode, a9 as KodaXSessionLabelEntry, a8 as KodaXSessionGoalEntry, ad as KodaXSessionNavigationOptions, a2 as KodaXSessionArtifactLedgerEntry, y as FileOperations, bz as WorkflowMeta, bA as WorkflowModelHint, bB as WorkflowModule, bQ as WorkflowProcessTrackerOptions, bs as WorkflowEvent, bK as WorkflowProcessSnapshot, bF as WorkflowProcessEvent } from './process.d-DHow2y2G.js';
 
 /**
  * @kodax-ai/agent Constants
@@ -188,8 +188,8 @@ declare class DefaultSummaryCompaction implements CompactionPolicy {
  *      before any subsystem reads the path.
  *   2. **`KODAX_HOME` env var** — middle priority. Used by shell / CI /
  *      test isolation / multi-tenant shared machines. (Already honored
- *      historically by `@kodax-ai/llm/src/reasoning-overrides.ts`; this
- *      helper makes it the canonical path for all packages.)
+ *      historically by the llm-layer config helpers; this helper makes it
+ *      the canonical path for all packages.)
  *   3. **`~/.kodax/`** — lowest priority. Default for the standalone
  *      kodax CLI. With DI not set + env not set, the resolver returns
  *      the same byte sequence as the prior hardcoded
@@ -209,9 +209,9 @@ declare class DefaultSummaryCompaction implements CompactionPolicy {
  * `~/.opsagent/` simultaneously).
  *
  * NOT migrated:
- *   - `@kodax-ai/llm/src/reasoning-overrides.ts:49` keeps its inline
+ *   - llm-layer config helpers keep their inline
  *     `process.env.KODAX_HOME ?? path.join(os.homedir(), '.kodax')`
- *     fallback because moving it to this helper would create an
+ *     fallback because moving them to this helper would create an
  *     `@kodax-ai/llm → @kodax-ai/agent` dependency cycle (agent already
  *     imports ai). The two implementations have identical observable
  *     behavior at the env / default tiers; the programmatic override
@@ -382,8 +382,10 @@ declare function _resetMessageQueueForTests(): void;
  *     history and fixes mis-pairings on both sides — orphan `tool_use` in
  *     assistant messages, orphan `tool_result` in user messages, and ensures
  *     no message becomes empty after stripping (Kimi specifically rejects
- *     empty assistant messages with 400, so we inject a `'...'` placeholder
- *     when stripping would empty an assistant message).
+ *     empty assistant messages with 400, so we inject an EMPTY text-block
+ *     marker when stripping would empty an assistant message — the visible
+ *     `'...'` is synthesized wire-only by the provider serializer, never
+ *     persisted into history).
  *
  * Migration history: extracted from `agent.ts` (originally lines 517–758)
  * during FEATURE_100 P2. Both `agent.ts` and `task-engine/runner-driven.ts`
@@ -407,8 +409,9 @@ declare function _resetMessageQueueForTests(): void;
  *     message → removed
  *   - user `tool_result` with empty / missing tool_use_id → removed
  *   - assistant message that becomes content-empty after stripping → inject
- *     a `'...'` placeholder text block (preserves message-alternation invariant
- *     downstream providers like Kimi require)
+ *     an EMPTY text-block marker (preserves message-alternation invariant
+ *     downstream providers like Kimi require; the visible '...' is added
+ *     wire-only by the serializer, never persisted)
  */
 declare function validateAndFixToolHistory(messages: KodaXMessage[]): KodaXMessage[];
 /**
@@ -755,6 +758,13 @@ declare const WORKFLOW_CAPSULE_API_VERSION: 1;
 type WorkflowCapsuleEnvironmentRequirement = 'git-repo' | 'worktree-capable';
 interface WorkflowCapsuleIntent {
     readonly taskClass: string;
+    /**
+     * The full set of workflow patterns the script declares (manifest.patterns).
+     * `taskClass` keeps only the primary pattern; this records the whole
+     * combination so a declared ['fan-out-and-synthesize', 'adversarial-verification']
+     * is preserved rather than collapsed to its first id.
+     */
+    readonly patterns?: readonly string[];
     readonly originalRequest?: string;
     readonly reusableFor?: readonly string[];
     readonly notFor?: readonly string[];
@@ -803,6 +813,107 @@ interface CreateWorkflowCapsuleInput {
 declare function validateWorkflowCapsule(value: unknown): WorkflowCapsule;
 declare function createWorkflowCapsule(input: CreateWorkflowCapsuleInput): WorkflowCapsule;
 declare function createWorkflowModuleFromCapsule(capsule: WorkflowCapsule): WorkflowModule;
+/**
+ * Single source of truth for deriving a capsule intent from a workflow manifest.
+ * `taskClass` keeps the primary pattern; the full declared set is recorded on
+ * `patterns` so a combination like ['fan-out-and-synthesize',
+ * 'adversarial-verification'] is preserved rather than collapsed to its first id
+ * (M15). Used by every capsule-save path so the propagation logic is tested once.
+ */
+declare function buildWorkflowCapsuleIntent(manifest: {
+    readonly patterns: readonly string[];
+    readonly name: string;
+    readonly description: string;
+}, opts?: {
+    readonly originalRequest?: string;
+}): WorkflowCapsuleIntent;
+
+/**
+ * FEATURE_246 Part A0 (ADR-046) — neutral workflow run lifecycle manager.
+ *
+ * Domain-neutral run registry + lifecycle (pause / resume / stop), process-event
+ * tracking, and terminal settle — lifted out of `@kodax-ai/coding` so any agent
+ * (including non-coding SDK hosts) can host and manage workflow runs.
+ *
+ * It never knows HOW a run executes: the caller injects a `runFn` thunk that
+ * receives lifecycle hooks (`onEvent` / `signal` / `beforeSpawn`) and returns a
+ * caller-shaped outcome, plus a `classify` mapping that outcome to a neutral
+ * terminal status and an `onError` that synthesizes a failure outcome. The
+ * coding layer wires `runFn` to its `runWorkflowModule` / `runWorkflowFromOptions`
+ * (backend + run-graph + worktrees); SDK hosts wire their own. Dependency arrows
+ * therefore point only coding → agent — no cycle.
+ */
+
+type ManagedWorkflowStatus = 'running' | 'paused' | 'completed' | 'failed' | 'denied' | 'stopped';
+/** Provenance/display metadata for a run's process tracker. */
+type WorkflowProcessMetadata = Pick<WorkflowProcessTrackerOptions, 'displayName' | 'goal' | 'source' | 'savedWorkflowName' | 'sourceRunId' | 'sourceWorkflowName' | 'revisionOf' | 'hostMetadata'>;
+interface ManagedWorkflowSnapshot {
+    readonly runId: string;
+    readonly workflow: string;
+    readonly status: ManagedWorkflowStatus;
+    readonly totalSpawned: number;
+    readonly eventCount: number;
+    readonly startedAt: number;
+    readonly endedAt?: number;
+    readonly error?: string;
+    readonly resultText?: string;
+}
+interface ManagedWorkflowRun<TOutcome = unknown> {
+    readonly runId: string;
+    readonly done: Promise<TOutcome>;
+    getSnapshot(): ManagedWorkflowSnapshot | undefined;
+    getProcessSnapshot(): WorkflowProcessSnapshot | undefined;
+}
+/** Lifecycle hooks the manager injects into the caller's `runFn`. */
+interface ManagedRunHooks {
+    /** Forward every workflow event so the manager can track spawn/progress. */
+    readonly onEvent: (event: WorkflowEvent) => void;
+    /** Abort signal owned by the manager (fires on stop()). */
+    readonly signal: AbortSignal;
+    /** Await before launching each agent so pause() can gate new spawns. */
+    readonly beforeSpawn: () => Promise<void>;
+}
+/** Neutral terminal classification of a caller-shaped outcome. */
+interface ManagedRunClassification {
+    readonly status: 'completed' | 'failed' | 'denied';
+    readonly error?: Error;
+    readonly resultText?: string;
+}
+interface StartManagedRunInput<TOutcome> {
+    readonly runId: string;
+    /** Display name (usually the workflow's `meta.name`). */
+    readonly workflow: string;
+    readonly phases?: readonly string[];
+    readonly maxAgents?: number;
+    readonly plannedAgents?: number;
+    readonly tokenBudget?: number;
+    readonly processMetadata?: WorkflowProcessMetadata;
+    readonly signal?: AbortSignal;
+    /** Executes the run with the manager's lifecycle hooks injected. */
+    readonly runFn: (hooks: ManagedRunHooks) => Promise<TOutcome>;
+    /** Map the caller's terminal outcome to a neutral status for the snapshot. */
+    readonly classify: (outcome: TOutcome) => ManagedRunClassification;
+    /** Synthesize a caller-shaped outcome when `runFn` throws. */
+    readonly onError: (error: unknown) => TOutcome;
+}
+interface WorkflowRunManager {
+    start<TOutcome>(input: StartManagedRunInput<TOutcome>): ManagedWorkflowRun<TOutcome>;
+    list(): readonly ManagedWorkflowSnapshot[];
+    get(runId: string): ManagedWorkflowSnapshot | undefined;
+    subscribeWorkflowProcess(listener: (event: WorkflowProcessEvent) => void): () => void;
+    getWorkflowProcessSnapshot(runId: string): WorkflowProcessSnapshot | undefined;
+    listWorkflowProcessSnapshots(options?: {
+        readonly activeOnly?: boolean;
+        readonly limit?: number;
+    }): readonly WorkflowProcessSnapshot[];
+    pause(runId: string): boolean;
+    resume(runId: string): boolean;
+    stop(runId: string, reason?: string): boolean;
+}
+declare function createWorkflowRunManager(deps?: {
+    readonly now?: () => number;
+}): WorkflowRunManager;
+declare function getDefaultWorkflowRunManager(): WorkflowRunManager;
 
-export { extractFileOps as $, DefaultSummaryCompaction as D, appendSessionLineageLabel as I, applyLineageTruncation as J, KODAX_API_MIN_INTERVAL as K, LINEAGE_ENTRY_TYPES as L, MessageQueue as M, applySessionCompaction as N, archiveOldIslands as O, PROMISE_PATTERN as P, buildSessionTree as Q, cleanupIncompleteToolCalls as R, countActiveLineageMessages as S, countTokens as T, createSessionLineage as U, createWorkflowCapsule as V, WORKFLOW_CAPSULE_API_VERSION as W, createWorkflowModuleFromCapsule as X, estimateTokens as Y, extractArtifactLedger as Z, _resetMessageQueueForTests as _, extractTitleFromMessages as a0, findPreviousUserEntryId as a1, forkSessionLineage as a2, generateSessionId as a3, getAgentConfigHome as a4, getAgentConfigPath as a5, getAppDataDir as a6, getMessageQueue as a7, getSessionLineagePath as a8, getSessionMessagesFromLineage as a9, mergeArtifactLedger as aa, mergeFileOps as ab, resolveSessionLineageTarget as ac, rewindSessionLineage as ad, setAgentConfigHome as ae, setSessionLineageActiveEntry as af, validateAndFixToolHistory as ag, validateWorkflowCapsule as ah, validateWorkflowScriptManifest as ai, KODAX_DEFAULT_TIMEOUT as f, KODAX_HARD_TIMEOUT as g, KODAX_MAX_INCOMPLETE_RETRIES as h, KODAX_MAX_MAXTOKENS_RETRIES as i, KODAX_MAX_RETRIES as j, KODAX_MAX_TOKENS as k, KODAX_RETRY_BASE_DELAY as l, KODAX_STAGGER_DELAY as m, LineageCompaction as o, LineageExtension as r, WORKFLOW_CAPSULE_FORMAT as v, WORKFLOW_CAPSULE_VERSION as w, WORKFLOW_PATTERN_IDS as x };
-export type { WorkflowCapsuleInputs as A, WorkflowCapsuleIntent as B, CompactionContext as C, WorkflowCapsuleProvenance as E, WorkflowCapsuleRequirements as F, WorkflowPatternId as G, WorkflowScriptManifest as H, CompactionEntry as a, CompactionEntryPayload as b, CompactionPolicy as c, CreateWorkflowCapsuleInput as d, DefaultSummaryCompactionOptions as e, LineageArtifactLedgerPayload as n, LineageCompactionDelegates as p, LineageEntryType as q, LineageLabelPayload as s, LineageTreeNode as t, PolicyCompactionResult as u, WorkflowCapsule as y, WorkflowCapsuleEnvironmentRequirement as z };
+export { buildWorkflowCapsuleIntent as $, WORKFLOW_CAPSULE_FORMAT as A, WORKFLOW_CAPSULE_VERSION as B, DefaultSummaryCompaction as D, WORKFLOW_PATTERN_IDS as E, KODAX_API_MIN_INTERVAL as K, LINEAGE_ENTRY_TYPES as L, PROMISE_PATTERN as P, appendSessionLineageLabel as U, applyLineageTruncation as V, WORKFLOW_CAPSULE_API_VERSION as W, applySessionCompaction as X, archiveOldIslands as Y, buildSessionTree as Z, _resetMessageQueueForTests as _, cleanupIncompleteToolCalls as a0, countActiveLineageMessages as a1, countTokens as a2, createSessionLineage as a3, createWorkflowCapsule as a4, createWorkflowModuleFromCapsule as a5, createWorkflowRunManager as a6, estimateTokens as a7, extractArtifactLedger as a8, extractFileOps as a9, extractTitleFromMessages as aa, findPreviousUserEntryId as ab, forkSessionLineage as ac, generateSessionId as ad, getAgentConfigHome as ae, getAgentConfigPath as af, getAppDataDir as ag, getDefaultWorkflowRunManager as ah, getMessageQueue as ai, getSessionLineagePath as aj, getSessionMessagesFromLineage as ak, mergeArtifactLedger as al, mergeFileOps as am, resolveSessionLineageTarget as an, rewindSessionLineage as ao, setAgentConfigHome as ap, setSessionLineageActiveEntry as aq, validateAndFixToolHistory as ar, validateWorkflowCapsule as as, validateWorkflowScriptManifest as at, KODAX_DEFAULT_TIMEOUT as f, KODAX_HARD_TIMEOUT as g, KODAX_MAX_INCOMPLETE_RETRIES as h, KODAX_MAX_MAXTOKENS_RETRIES as i, KODAX_MAX_RETRIES as j, KODAX_MAX_TOKENS as k, KODAX_RETRY_BASE_DELAY as l, KODAX_STAGGER_DELAY as m, LineageCompaction as o, LineageExtension as r, MessageQueue as y };
+export type { CompactionContext as C, WorkflowCapsule as F, WorkflowCapsuleEnvironmentRequirement as G, WorkflowCapsuleInputs as H, WorkflowCapsuleIntent as I, WorkflowCapsuleProvenance as J, ManagedRunClassification as M, WorkflowCapsuleRequirements as N, WorkflowPatternId as O, WorkflowProcessMetadata as Q, WorkflowRunManager as R, StartManagedRunInput as S, WorkflowScriptManifest as T, CompactionEntry as a, CompactionEntryPayload as b, CompactionPolicy as c, CreateWorkflowCapsuleInput as d, DefaultSummaryCompactionOptions as e, LineageArtifactLedgerPayload as n, LineageCompactionDelegates as p, LineageEntryType as q, LineageLabelPayload as s, LineageTreeNode as t, ManagedRunHooks as u, ManagedWorkflowRun as v, ManagedWorkflowSnapshot as w, ManagedWorkflowStatus as x, PolicyCompactionResult as z };

package/dist/types-chunks/{sdk-session-BP6ZNpOp.d.ts → sdk-session-21Tt3N_x.d.ts}

@@ -1,7 +1,7 @@
-import { b as PermissionMode, S as SessionData, F as FileSessionStorage } from './storage.d-CkydxFsV.js';
-import { E as KodaXReasoningMode, n as KodaXMessage, g as KodaXContentBlock } from './types.d-BJmoMf5H.js';
-import { m as KodaXAgentMode } from './bash-prefix-extractor.d-DZF1gDDz.js';
-import { ac as KodaXSessionUiHistoryItem, ag as KodaXSessionUiToolCall } from './process.d-BdiIUr8T.js';
+import { b as PermissionMode, F as FileSessionStorage, S as SessionData } from './storage.d-BsZrBPYu.js';
+import { E as KodaXReasoningMode, j as KodaXMessage, c as KodaXContentBlock } from './types.d-Ci5YPFEh.js';
+import { m as KodaXAgentMode } from './bash-prefix-extractor.d-D3cddmyV.js';
+import { ai as KodaXSessionUiHistoryItem, am as KodaXSessionUiToolCall } from './process.d-DHow2y2G.js';
 
 /**
  * TextBuffer - Text buffer management class - 文本缓冲区管理类
@@ -412,6 +412,8 @@ interface StatusBarProps {
     activeToolCount?: number;
     thinking?: boolean;
     reasoningMode?: KodaXReasoningMode;
+    effort?: string;
+    reasoningEffortLabel?: string;
     reasoningCapability?: string;
     /** Is context currently compacting - 是否正在压缩上下文 */
     isCompacting?: boolean;
@@ -538,7 +540,7 @@ interface ToolCall {
  * History item type - 历史项类型
  * Reference: Gemini CLI HistoryItem - 参考: Gemini CLI HistoryItem
  */
-type HistoryItemType = "user" | "assistant" | "system" | "tool_group" | "thinking" | "error" | "event" | "info" | "hint";
+type HistoryItemType = "user" | "assistant" | "system" | "tool_group" | "thinking" | "error" | "event" | "info" | "hint" | "sidecar";
 /**
  * History item base class - 历史项基类
  */
@@ -622,15 +624,30 @@ interface HistoryItemHint extends HistoryItemBase {
     type: "hint";
     text: string;
 }
+/**
+ * Sidecar Verifier message - Sidecar 验证器消息
+ * 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.
+ */
+interface HistoryItemSidecar extends HistoryItemBase {
+    type: "sidecar";
+    text: string;
+    /** 'revise' or 'blocked'; absent when delivery === 'budget-exhausted' */
+    verdict?: "revise" | "blocked";
+    /** Set when the verifier exhausted its token budget before reaching a verdict */
+    delivery?: "budget-exhausted";
+}
 /**
  * Union type of all history items - 所有历史项的联合类型
  */
-type HistoryItem = HistoryItemUser | HistoryItemAssistant | HistoryItemSystem | HistoryItemToolGroup | HistoryItemThinking | HistoryItemError | HistoryItemEvent | HistoryItemInfo | HistoryItemHint;
+type HistoryItem = HistoryItemUser | HistoryItemAssistant | HistoryItemSystem | HistoryItemToolGroup | HistoryItemThinking | HistoryItemError | HistoryItemEvent | HistoryItemInfo | HistoryItemHint | HistoryItemSidecar;
 /**
  * Creatable history item types (with text property) - 可创建的历史项类型（带 text 属性）
  * Used for addHistoryItem function parameter type - 用于 addHistoryItem 等函数的参数类型
  */
-type CreatableHistoryItem = Omit<HistoryItemUser, "id" | "timestamp"> | Omit<HistoryItemAssistant, "id" | "timestamp"> | Omit<HistoryItemSystem, "id" | "timestamp"> | Omit<HistoryItemThinking, "id" | "timestamp"> | Omit<HistoryItemError, "id" | "timestamp"> | Omit<HistoryItemEvent, "id" | "timestamp"> | Omit<HistoryItemInfo, "id" | "timestamp"> | Omit<HistoryItemHint, "id" | "timestamp"> | Omit<HistoryItemToolGroup, "id" | "timestamp">;
+type CreatableHistoryItem = Omit<HistoryItemUser, "id" | "timestamp"> | Omit<HistoryItemAssistant, "id" | "timestamp"> | Omit<HistoryItemSystem, "id" | "timestamp"> | Omit<HistoryItemThinking, "id" | "timestamp"> | Omit<HistoryItemError, "id" | "timestamp"> | Omit<HistoryItemEvent, "id" | "timestamp"> | Omit<HistoryItemInfo, "id" | "timestamp"> | Omit<HistoryItemHint, "id" | "timestamp"> | Omit<HistoryItemSidecar, "id" | "timestamp"> | Omit<HistoryItemToolGroup, "id" | "timestamp">;
 /**
  * UI global state interface - UI 全局状态接口
  * Reference: Gemini CLI UIStateContext - 参考: Gemini CLI UIStateContext
@@ -755,6 +772,50 @@ declare function extractTitle(messages: KodaXMessage[]): string;
  */
 declare function formatMessagePreview(content: string, maxLength?: number): string;
 
+/**
+ * FEATURE_247 (R6) — imperative session compaction.
+ *
+ * Lets an SDK embedder (KodaX-Space) compact a session by id immediately —
+ * e.g. when the user clicks a "/compact" button — instead of forging a token
+ * snapshot or appending an empty message to trip auto-compaction. Loads the
+ * session, runs the same `compact()` pass the REPL `/compact` command uses,
+ * applies the result to the session lineage (so `loadFullTranscript` / resume
+ * see the compaction entry), and writes it back.
+ *
+ * Applies uniformly to Partner and Coder sessions. Never throws — failures
+ * return `{ compacted: false, reason }`.
+ */
+
+interface CompactSessionOptions {
+    /** Provider alias for the summarizer. Defaults to the session's persisted provider, then 'anthropic'. */
+    readonly provider?: string;
+    /** Model override forwarded to the summarizer. */
+    readonly model?: string;
+    /** Custom summarizer instructions (same as `/compact <text>`). */
+    readonly customInstructions?: string;
+    /** Provider context-window override (tokens). Otherwise resolved from the provider/model. */
+    readonly contextWindow?: number;
+    /** Sessions directory (mirrors createSessionManager's override). */
+    readonly sessionsDir?: string;
+    /** Injected storage instance (takes precedence over sessionsDir). */
+    readonly storage?: FileSessionStorage;
+}
+interface CompactSessionResult {
+    /** True when the session was actually rewritten. */
+    readonly compacted: boolean;
+    readonly tokensBefore: number;
+    readonly tokensAfter: number;
+    /** The rewritten (or unchanged) message list. */
+    readonly messages: KodaXMessage[];
+    /** Populated when `compacted` is false to explain why (not-found / no-op / error). */
+    readonly reason?: string;
+}
+/**
+ * Compact a session by id, writing the result (lineage + messages) back to
+ * storage. Never throws.
+ */
+declare function compactSession(sessionId: string, options?: CompactSessionOptions): Promise<CompactSessionResult>;
+
 /**
  * FEATURE_173 Part B (v0.7.42) — Session Management Public SDK.
  *
@@ -775,6 +836,8 @@ interface SessionSummary {
     readonly runtimeInfo?: {
         workspaceRoot?: string;
         gitRoot?: string;
+        surface?: string;
+        profileId?: string;
     };
     /**
      * FEATURE_219 (v0.7.46) — the per-project directory key this session lives
@@ -846,6 +909,8 @@ interface SessionManager {
     unarchiveSession: typeof unarchiveSession;
     listRunningSessions: typeof listRunningSessions;
     watchSessions: typeof watchSessions;
+    /** FEATURE_247 (R6) — imperatively compact a session by id (writes lineage + emits nothing; returns stats). */
+    compactSession: typeof compactSession;
     /**
      * v0.7.43 — the raw write-side storage instance. SDK embedders pass
      * this into `runKodaX({ session: { id, scope, storage } })` so the
@@ -973,5 +1038,5 @@ declare function createSessionManager(opts?: {
     sessionsDir?: string;
 }): SessionManager;
 
-export { DEFAULT_UI_STATE as D, StreamingState as N, TextBuffer as Q, TOOL_STATUS_ICONS as T, ToolCallStatus as Z, archiveSession as a4, createSessionManager as a5, deleteSession as a6, extractHistorySeedsFromMessage as a7, extractHistorySeedsFromMessages as a8, extractTextContent as a9, extractTitle as aa, forkSession as ab, formatMessagePreview as ac, listRunningSessions as ad, listSessions as ae, loadFullTranscript as af, loadSession as ag, restoreHistoryItemsFromSession as ah, rewindSession as ai, seedToHistoryItem as aj, setActiveEntry as ak, toolCallSeedToHistoryToolCall as al, trimPersistedUiHistorySnapshot as am, unarchiveSession as an, watchSessions as ao, KeypressHandlerPriority as u };
-export type { UIState as $, AppProps as A, SessionSummary as B, Completer as C, SessionTranscriptEntry as E, FullTranscriptSessionData as F, SessionTranscriptEntryType as G, HistoryEntry as H, InputPromptProps as I, StatusBarProps as J, KeyInfo as K, LegacyMessageListProps as L, Message as M, Suggestion as O, PastedContent as P, RestoreHistoryItemsFromSessionInput as R, SessionManager as S, TextBufferOptions as U, Theme as V, ThemeColors as W, ThemeSymbols as X, ToolCall as Y, UIActions as _, AppState as a, UseTextBufferReturn as a0, VisualCursor as a1, VisualLayout as a2, WatchSessionsCallback as a3, Completion as b, CreatableHistoryItem as c, CursorPosition as d, DeleteSessionResult as e, HistoryItem as f, HistoryItemAssistant as g, HistoryItemBase as h, HistoryItemError as i, HistoryItemEvent as j, HistoryItemHint as k, HistoryItemInfo as l, HistoryItemSystem as m, HistoryItemThinking as n, HistoryItemToolGroup as o, HistoryItemType as p, HistoryItemUser as q, HistorySeedSourceMessage as r, KeypressEvent as s, KeypressHandler as t, ListSessionsOptions as v, PromptEditingMode as w, PromptSubmitPayload as x, RestoredHistorySeed as y, RunningSessionInfo as z };
+export { DEFAULT_UI_STATE as D, StreamingState as O, TOOL_STATUS_ICONS as T, TextBuffer as U, ToolCallStatus as _, archiveSession as a5, createSessionManager as a6, deleteSession as a7, extractHistorySeedsFromMessage as a8, extractHistorySeedsFromMessages as a9, extractTextContent as aa, extractTitle as ab, forkSession as ac, formatMessagePreview as ad, listRunningSessions as ae, listSessions as af, loadFullTranscript as ag, loadSession as ah, restoreHistoryItemsFromSession as ai, rewindSession as aj, seedToHistoryItem as ak, setActiveEntry as al, toolCallSeedToHistoryToolCall as am, trimPersistedUiHistorySnapshot as an, unarchiveSession as ao, watchSessions as ap, KeypressHandlerPriority as v };
+export type { UIActions as $, AppProps as A, RunningSessionInfo as B, Completer as C, SessionSummary as E, FullTranscriptSessionData as F, SessionTranscriptEntry as G, HistoryEntry as H, InputPromptProps as I, SessionTranscriptEntryType as J, KeyInfo as K, LegacyMessageListProps as L, Message as M, StatusBarProps as N, PastedContent as P, Suggestion as Q, RestoreHistoryItemsFromSessionInput as R, SessionManager as S, TextBufferOptions as V, Theme as W, ThemeColors as X, ThemeSymbols as Y, ToolCall as Z, AppState as a, UIState as a0, UseTextBufferReturn as a1, VisualCursor as a2, VisualLayout as a3, WatchSessionsCallback as a4, Completion as b, CreatableHistoryItem as c, CursorPosition as d, DeleteSessionResult as e, HistoryItem as f, HistoryItemAssistant as g, HistoryItemBase as h, HistoryItemError as i, HistoryItemEvent as j, HistoryItemHint as k, HistoryItemInfo as l, HistoryItemSidecar as m, HistoryItemSystem as n, HistoryItemThinking as o, HistoryItemToolGroup as p, HistoryItemType as q, HistoryItemUser as r, HistorySeedSourceMessage as s, KeypressEvent as t, KeypressHandler as u, ListSessionsOptions as w, PromptEditingMode as x, PromptSubmitPayload as y, RestoredHistorySeed as z };

package/dist/types-chunks/{storage.d-CkydxFsV.d.ts → storage.d-BsZrBPYu.d.ts}

@@ -1,5 +1,5 @@
-import { a as BashPrefixExtractor } from './bash-prefix-extractor.d-DZF1gDDz.js';
-import { $ as KodaXSessionData, a4 as KodaXSessionLineage, a7 as KodaXSessionNavigationOptions, a8 as KodaXSessionRuntimeInfo, aa as KodaXSessionStorage } from './process.d-BdiIUr8T.js';
+import { a as BashPrefixExtractor } from './bash-prefix-extractor.d-D3cddmyV.js';
+import { a5 as KodaXSessionData, aa as KodaXSessionLineage, ad as KodaXSessionNavigationOptions, ae as KodaXSessionRuntimeInfo, ag as KodaXSessionStorage } from './process.d-DHow2y2G.js';
 
 /**
  * Permission Types