@kodax-ai/kodax 0.7.76 → 0.7.78

package/dist/types-chunks/{base.d-ChvpaKjZ.d.ts → base.d-4e74xDdy.d.ts}

@@ -1,4 +1,4 @@
-import { q as KodaXProviderConfig, k as KodaXMessage, a1 as KodaXToolDefinition, H as KodaXReasoningRequest, y as KodaXProviderStreamOptions, N as KodaXStreamResult, a7 as KodaXVerifyCredentialResult, l as KodaXModelDescriptor, p as KodaXProviderCapabilityProfile, B as KodaXReasoningCapability, G as KodaXReasoningProfile, n as KodaXNormalizedReasoningRequest, a9 as KodaXWireReasoningEffort } from './types.d-CSmF0t0n.js';
+import { q as KodaXProviderConfig, k as KodaXMessage, a1 as KodaXToolDefinition, H as KodaXReasoningRequest, y as KodaXProviderStreamOptions, N as KodaXStreamResult, a7 as KodaXVerifyCredentialResult, l as KodaXModelDescriptor, p as KodaXProviderCapabilityProfile, B as KodaXReasoningCapability, G as KodaXReasoningProfile, n as KodaXNormalizedReasoningRequest, a9 as KodaXWireReasoningEffort } from './types.d-DIpZJKUl.js';
 
 /**
  * Retry-After header parsing — FEATURE_130 (v0.7.36).
@@ -194,8 +194,18 @@ declare abstract class KodaXBaseProvider {
      * layer sets it — matches third-party Anthropic-compat behavior.
      */
     getEffectiveStrictThinkingSignature(model?: string): boolean;
+    /** Provider-level switch used by serializers for compatibility placeholders. */
+    getProviderSupportsThinking(): boolean;
     protected getEffectiveThinkingBudgetCap(model?: string): number | undefined;
     abstract stream(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
+    /**
+     * Whether this Provider lowers `streamOptions.ephemeralSuffix` onto the wire.
+     * Runtime-registered Providers default to false so callers can fall back to a
+     * request-only message copy instead of silently dropping managed context.
+     */
+    supportsEphemeralSuffix(): boolean;
+    /** Whether this configured transport lowers `promptCacheKey` onto its wire. */
+    usesPromptCacheAffinity(): boolean;
     supportsNonStreamingFallback(): boolean;
     complete(_messages: KodaXMessage[], _tools: KodaXToolDefinition[], _system: string, _reasoning?: boolean | KodaXReasoningRequest, _streamOptions?: KodaXProviderStreamOptions, _signal?: AbortSignal): Promise<KodaXStreamResult>;
     isConfigured(): boolean;
@@ -220,6 +230,8 @@ declare abstract class KodaXBaseProvider {
     getAvailableModels(): string[];
     getModelDescriptor(modelId?: string): KodaXModelDescriptor | undefined;
     protected getWireModelId(modelId?: string): string;
+    /** Exact model identifier serialized into native provider requests. */
+    getWireModel(modelId?: string): string;
     getBaseUrl(): string | undefined;
     getApiKeyEnv(): string;
     getCapabilityProfile(): KodaXProviderCapabilityProfile;

package/dist/types-chunks/{bash-prefix-extractor.d-r1beOESM.d.ts → bash-prefix-extractor.d-uAe2Oqda.d.ts}

@@ -1,10 +1,11 @@
-import { bs as KodaXGoalState, a8 as AgentMessage, dv as StopHookFn, bM as KodaXSessionLineage, k as AgentActorStore, aC as AgentTurnExecutor, t as AgentBudgetPort, h as AgentActorClient, N as AgentExecutionResult, V as AgentExecutorPlaneBinding, by as KodaXJsonValue, bm as KodaXExtensionSessionRecord, f as Agent, dS as WorkflowIsolation, bn as KodaXExtensionSessionState, bD as KodaXSessionArtifactLedgerEntry, df as SessionErrorMetadata, bU as KodaXSessionScope, bV as KodaXSessionStorage, cj as MemoryContextIdentity, cv as MemoryPack, aK as AskUserQuestionOptions, aG as AskUserAnswer, aI as AskUserMultiOptions, dP as WorkflowEventCorrelation, aT as CompactionUpdate, e4 as WorkflowProcessEvent, dO as WorkflowEvent, cJ as MemoryReviewPlan, bA as KodaXMemoryOutcomeDigest, bb as Guardrail, aY as DiscoveredInstance, bw as KodaXInputArtifact, cK as MemoryReviewRunner } from './types.d-sRLugmjy.js';
-import { a0 as KodaXTokenUsage, k as KodaXMessage, a1 as KodaXToolDefinition, a9 as KodaXWireReasoningEffort, U as KodaXTaskRoutingDecision, V as KodaXTaskType, W as KodaXTaskWorkIntent, Q as KodaXTaskComplexity, L as KodaXRiskLevel, h as KodaXHarnessProfile, f as KodaXExecutionMode, b as KodaXChildFanoutClass, F as KodaXReasoningMode, J as KodaXReviewScale } from './types.d-CSmF0t0n.js';
-import { d as SkillDynamicContextExecutor, I as ISkillRegistry } from './types.d-DCQVBqVn.js';
+import { bz as KodaXGoalState, ab as AgentMessage, eg as StopHookFn, bU as KodaXSessionLineage, n as AgentActorStore, aF as AgentTurnExecutor, w as AgentBudgetPort, i as AgentActorOwner, h as AgentActorClient, Q as AgentExecutionResult, Y as AgentExecutorPlaneBinding, bF as KodaXJsonValue, bt as KodaXExtensionSessionRecord, f as Agent, eG as WorkflowIsolation, bu as KodaXExtensionSessionState, bL as KodaXSessionArtifactLedgerEntry, e0 as SessionErrorMetadata, c0 as KodaXSessionScope, c1 as KodaXSessionStorage, d2 as MemoryContextIdentity, de as MemoryPack, aN as AskUserQuestionOptions, aJ as AskUserAnswer, aL as AskUserMultiOptions, eD as WorkflowEventCorrelation, aX as CompactionUpdate, eU as WorkflowProcessEvent, eC as WorkflowEvent, dt as MemoryReviewPlan, bI as KodaXMemoryOutcomeDigest, bi as Guardrail, b2 as DiscoveredInstance, bD as KodaXInputArtifact, du as MemoryReviewRunner, eu as UnifiedLearningReviewRunner } from './types.d-BA-Jwpfs.js';
+import { a0 as KodaXTokenUsage, k as KodaXMessage, a1 as KodaXToolDefinition, a9 as KodaXWireReasoningEffort, U as KodaXTaskRoutingDecision, V as KodaXTaskType, W as KodaXTaskWorkIntent, Q as KodaXTaskComplexity, L as KodaXRiskLevel, h as KodaXHarnessProfile, f as KodaXExecutionMode, b as KodaXChildFanoutClass, F as KodaXReasoningMode, J as KodaXReviewScale } from './types.d-DIpZJKUl.js';
+import { d as SkillDynamicContextExecutor, I as ISkillRegistry } from './types.d-BbtGlKZu.js';
 import { Diagnostic, Position, Location, Hover, DocumentSymbol, SymbolInformation, WorkspaceSymbol, CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from 'vscode-languageserver-protocol';
 import { K as KodaXLlmTimeoutConfig, a as CostTracker } from './cost-tracker.d-BeaenODW.js';
+import { t as MemoryRecallRunner } from './types-D3g6XUQr.js';
 import { C as CapabilityKind, f as CapabilitySearchSnapshot, b as CapabilityResult } from './capability.d-K664nHOS.js';
-import { K as KodaXBaseProvider } from './base.d-ChvpaKjZ.js';
+import { K as KodaXBaseProvider } from './base.d-4e74xDdy.js';
 
 /**
  * FEATURE_192 v0.7.44 Phase C — Goal-tools execution context.
@@ -836,6 +837,8 @@ interface CodingActorSessionOptions {
     readonly store?: AgentActorStore;
     readonly executor?: AgentTurnExecutor;
     readonly budget?: AgentBudgetPort;
+    readonly owner?: AgentActorOwner;
+    readonly isOwnerAlive?: (owner: AgentActorOwner) => boolean | Promise<boolean>;
 }
 /** One Runtime-owned Actor tree for one KodaX session. */
 declare class CodingActorSession {
@@ -848,6 +851,8 @@ declare class CodingActorSession {
     initialize(): Promise<void>;
     attach(parentCtx: KodaXToolExecutionContext, options: KodaXOptions, callerPath?: string): AgentActorClient;
     rootControl(): AgentActorClient;
+    ownerId(): string | undefined;
+    ownsDurableFence(): boolean;
     createWorkflowOwner(parentPath: string, runId: string): Promise<AgentActorClient>;
     workflowOwnerSignal(ownerPath: string): AbortSignal;
     settleWorkflowOwner(ownerPath: string, state: 'completed' | 'failed' | 'interrupted', result: AgentExecutionResult & {
@@ -858,6 +863,8 @@ declare class CodingActorSession {
     registerTurnExecutor(key: string, executor: AgentTurnExecutor): () => void;
     waitForAgentCapacity(signal?: AbortSignal): Promise<boolean>;
     close(reason?: string): Promise<void>;
+    quiesce(reason?: string): Promise<void>;
+    disposeAfterStoreRemoval(reason?: string): void;
 }
 declare function createLocalCodingActorControl(parentCtx: KodaXToolExecutionContext, options: KodaXOptions): AgentActorClient;
 /** Runtime adapter for detached external Actor turns. The executor plane stays internal. */
@@ -870,7 +877,7 @@ declare function createExternalActorTurnExecutor(binding: AgentExecutorPlaneBind
  * configure / install / troubleshoot KodaX?" questions. Pure data + a
  * deterministic resolver — no RAG, no vector store, no network fetch.
  */
-type KodaXManualTopicId = 'overview' | 'license' | 'install' | 'quickstart' | 'providers' | 'custom-providers' | 'config' | 'permissions' | 'commands' | 'tools' | 'agents' | 'skills' | 'extensions' | 'mcp' | 'a2a' | 'repo-intelligence' | 'sessions' | 'compaction' | 'memory' | 'doctor' | 'sdk' | 'troubleshooting';
+type KodaXManualTopicId = 'overview' | 'license' | 'install' | 'quickstart' | 'providers' | 'custom-providers' | 'config' | 'permissions' | 'sandbox' | 'commands' | 'tools' | 'agents' | 'skills' | 'extensions' | 'mcp' | 'a2a' | 'repo-intelligence' | 'sessions' | 'compaction' | 'memory' | 'doctor' | 'sdk' | 'troubleshooting';
 /** A pointer to the code/doc the topic is derived from (for traceability). */
 interface KodaXManualSource {
     readonly label: string;
@@ -1113,6 +1120,10 @@ interface RuntimeContextBudgetSnapshot {
     readonly sessionId?: string;
     readonly runId?: string;
     readonly turnId?: string;
+    readonly contextId?: string;
+    readonly contextKind?: 'root' | 'child';
+    readonly parentContextId?: string;
+    readonly agentId?: string;
     readonly provider?: string;
     readonly model?: string;
     readonly profile: RuntimeContextOptimizationProfile;
@@ -1133,6 +1144,10 @@ interface RuntimeContextBudgetSnapshotInput {
     readonly sessionId?: string;
     readonly runId?: string;
     readonly turnId?: string;
+    readonly contextId?: string;
+    readonly contextKind?: 'root' | 'child';
+    readonly parentContextId?: string;
+    readonly agentId?: string;
     readonly provider?: string;
     readonly model?: string;
     readonly profile?: RuntimeContextOptimizationProfile;
@@ -1142,11 +1157,19 @@ interface RuntimeContextBudgetSnapshotInput {
     readonly skillCatalogText?: string;
     readonly mcpCatalogText?: string;
     readonly messages?: readonly KodaXMessage[];
+    readonly messageTokenBreakdown?: RuntimeContextBudgetMessageBreakdown;
     readonly pendingInput?: string;
     readonly recentToolResults?: readonly string[];
     readonly reservedResponseTokens?: number;
     readonly now?: () => Date;
 }
+interface RuntimeContextBudgetMessageBreakdown {
+    readonly transcript: number;
+    readonly pendingInput: number;
+    readonly recentToolResults: number;
+    readonly skillCatalog: number;
+    readonly mcpCatalog: number;
+}
 declare function estimateToolSchemaTokens(definition: KodaXToolDefinition, descriptionOverride?: string): number;
 declare function createRuntimeContextBudgetSnapshot(input: RuntimeContextBudgetSnapshotInput): RuntimeContextBudgetSnapshot;
 
@@ -1163,6 +1186,10 @@ interface RuntimeToolExposureDecision {
     readonly modelVisible: boolean;
 }
 interface RuntimeToolExposurePlan {
+    readonly contextId?: string;
+    readonly contextKind?: 'root' | 'child';
+    readonly parentContextId?: string;
+    readonly agentId?: string;
     readonly profile: RuntimeContextOptimizationProfile;
     readonly reportOnly: boolean;
     readonly pressure: RuntimeContextPressure;
@@ -1215,6 +1242,10 @@ interface CompactionSavingsDecision {
 }
 type CompactionSkipReason = 'low_savings_cooldown' | 'covered_context_unchanged';
 interface RuntimeCompactionSkippedEvent {
+    readonly contextId?: string;
+    readonly contextKind?: 'root' | 'child';
+    readonly parentContextId?: string;
+    readonly agentId?: string;
     readonly reason: CompactionSkipReason;
     readonly currentTokens: number;
     readonly contextWindow: number;
@@ -1662,6 +1693,25 @@ interface KodaXWorkflowAgentDigestEvent {
 interface KodaXToolEventMeta extends KodaXActivityEventMeta {
     readonly toolId?: string;
 }
+type KodaXShellSandboxBackend = 'windows-restricted-user' | 'macos-seatbelt' | 'linux-bubblewrap' | 'unsupported';
+type KodaXShellSandboxObservation = {
+    readonly version: 1;
+    readonly state: 'applied';
+    readonly backend: KodaXShellSandboxBackend;
+    readonly policyId: 'kodax-workspace-shell-v1';
+} | {
+    readonly version: 1;
+    readonly state: 'fallback';
+    readonly reason: 'not_ready' | 'prepare_failed' | 'backend_failed';
+    readonly execution: 'normal_permission_policy';
+} | {
+    readonly version: 1;
+    readonly state: 'not_selected';
+};
+interface KodaXToolSandboxObservationUpdate {
+    readonly id: string;
+    readonly observation: KodaXShellSandboxObservation;
+}
 interface KodaXContextCompactionFinishedEvent extends Partial<KodaXLiveEventMeta> {
     readonly source: 'manual' | 'automatic_threshold' | 'physical_capacity';
     readonly tokensBefore: number;
@@ -1685,6 +1735,9 @@ interface KodaXSidecarMessageEvent {
     /** Exact actionable text from the sidecar. `budget-exhausted` means it was not injected. */
     readonly content: string;
     readonly suggestedFix?: string;
+    readonly strategyReasonCode?: 'missing_requirement' | 'contradicted_evidence' | 'unsupported_claim' | 'unresolved_high_risk' | 'verification_degraded';
+    readonly recommendedPattern?: 'classify-and-act' | 'fan-out-and-synthesize' | 'adversarial-verification' | 'generate-and-filter' | 'tournament' | 'loop-until-done';
+    readonly targetEvidenceRefs?: readonly string[];
     readonly trace?: string;
     /**
      * FEATURE_247 (R3/R8) — session id the verdict belongs to, so a host running
@@ -1708,6 +1761,55 @@ interface KodaXTodoDriftWarningEvent {
     readonly firstPendingTodoId?: string;
     readonly firstPendingTodoSubject?: string;
 }
+interface KodaXPromptCacheDiagnosticEvent {
+    readonly phase: 'request' | 'response';
+    /** Provider API path used for this physical request. */
+    readonly transport?: 'stream' | 'complete';
+    readonly requestId: string;
+    readonly requestedAt: string;
+    readonly completedAt?: string;
+    readonly provider: string;
+    /** Stable logical Runtime context. Prompt/message text is never included. */
+    readonly contextId?: string;
+    readonly contextKind?: 'root' | 'child';
+    readonly parentContextId?: string;
+    readonly agentId?: string;
+    /** Caller-facing model id selected for this request. */
+    readonly model: string;
+    /** Exact provider wire model after alias resolution. */
+    readonly wireModel?: string;
+    /** Hash of the caller-level reasoning controls; never contains prompt text. */
+    readonly reasoningHash?: string;
+    /** Effective output reservation sent for this adapter request. */
+    readonly maxOutputTokens?: number;
+    /** Whether KodaX explicit prompt-cache controls are enabled. */
+    readonly kodaxPromptCacheEnabled?: boolean;
+    /** Credential-free provider origin. */
+    readonly endpoint?: string;
+    /** Hash of the endpoint path, which may itself contain tenant credentials. */
+    readonly endpointPathHash?: string;
+    readonly attempt: number;
+    readonly systemPromptHash: string;
+    readonly toolSchemaHash: string;
+    /** Hash of provider-visible messages before the current turn starts. */
+    readonly messagePrefixHash: string;
+    readonly messagePrefixCount: number;
+    /** Hash of persistent provider-visible messages, excluding any ephemeral suffix. */
+    readonly requestMessagesHash: string;
+    /** Composite hash of system, tools, persistent messages, and ephemeral suffix. */
+    readonly requestEnvelopeHash: string;
+    /** Hash of provider-visible ephemeral request suffixes, when present. */
+    readonly ephemeralSuffixHash?: string;
+    /** Hash of the opaque affinity key when this Provider applies it on wire. */
+    readonly promptCacheAffinityHash?: string;
+    readonly messageCount: number;
+    readonly toolCount: number;
+    /** Provider-reported usage only. Missing fields remain undefined. */
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly cachedReadTokens?: number;
+    readonly cachedWriteTokens?: number;
+}
 interface KodaXEvents {
     /** FEATURE_229: correlates child-agent SDK callbacks back to a workflow run/item. */
     workflowCorrelation?: WorkflowEventCorrelation;
@@ -1729,6 +1831,11 @@ interface KodaXEvents {
         id: string;
         message: string;
     }, meta?: KodaXToolEventMeta) => void;
+    /**
+     * Execution metadata for professional hosts. REPL history intentionally does
+     * not render this internal containment state.
+     */
+    onToolSandboxObservation?: (update: KodaXToolSandboxObservationUpdate, meta?: KodaXToolEventMeta) => void;
     onToolInputDelta?: (toolName: string, partialJson: string, meta?: KodaXToolEventMeta) => void;
     onStreamEnd?: (meta?: KodaXActivityEventMeta) => void;
     /** Fired once when a child-agent run fully leaves the child executor. */
@@ -1839,6 +1946,11 @@ interface KodaXEvents {
     onRepoIntelligenceTrace?: (event: KodaXRepoIntelligenceTraceEvent & Partial<KodaXLiveEventMeta>) => void;
     /** Optional bounded context diagnostics. Emitted only when context.contextDiagnostics is true. */
     onContextBudgetSnapshot?: (event: RuntimeContextBudgetSnapshot & Partial<KodaXLiveEventMeta>) => void;
+    /**
+     * Hash-only prompt-cache diagnostics; never contains prompt or message text.
+     * Emitted only when context.contextDiagnostics is true.
+     */
+    onPromptCacheDiagnostics?: (event: KodaXPromptCacheDiagnosticEvent & Partial<KodaXLiveEventMeta>) => void;
     /** Optional bounded tool-exposure diagnostics. Emitted only when context.contextDiagnostics is true. */
     onToolExposurePlanned?: (event: RuntimeToolExposurePlan & Partial<KodaXLiveEventMeta>) => void;
     /** Optional bounded compaction-pressure diagnostics. Emitted only when context.contextDiagnostics is true. */
@@ -1953,12 +2065,17 @@ interface KodaXEvents {
     /** Semantic memory review plan produced from explicit user feedback. */
     onMemoryReview?: (plan: MemoryReviewPlan) => void;
     onMemoryNotice?: (notice: {
+        readonly sessionId?: string;
         readonly episodeId: string;
         readonly summaries: readonly string[];
         readonly proposalIds: readonly string[];
     }) => void;
-    onMemoryOutcomeDigest?: (digest: KodaXMemoryOutcomeDigest) => void;
+    onMemoryOutcomeDigest?: (digest: KodaXMemoryOutcomeDigest, metadata?: {
+        readonly jobId?: string;
+    }) => void;
     onMemoryReviewReceipt?: (receipt: {
+        readonly sessionId?: string;
+        readonly jobId?: string;
         readonly reviewKey: string;
         readonly proposalIds: readonly string[];
         readonly completedAt: string;
@@ -2011,7 +2128,10 @@ interface KodaXSessionOptions {
      * NOT also snapshot the session: `saveSessionSnapshot` early-returns so
      * the runner's flat full-rewrite `storage.save` can never race / clobber
      * the host's richer incremental writes (which regressed `activeEntryId`
-     * to the first round on resume).
+     * to the first round on resume). Context-silent protocol facts may use the
+     * host's optional atomic `storage.mutateLineage`; this never writes a stale
+     * full session snapshot. A host using F263 durable Memory review facts must
+     * provide that capability; those writes fail closed when it is absent.
      *
      * `storage` is still consulted for LOAD (resume / `resolveInitialMessages`
      * tier 2). When absent (print CLI, ACP, SDK headless), the runner remains
@@ -2222,6 +2342,11 @@ interface KodaXChildContextBundle {
      * one bounded repair turn) and surfaces it on `KodaXChildAgentResult.structured`.
      */
     outputSchema?: unknown;
+    /**
+     * Runtime-only fixed AMA result contract. Unlike Workflow outputSchema,
+     * invalid output is parse-only and never starts a repair model turn.
+     */
+    structuredOutputContract?: 'pattern-disposition-parse-only';
     /** Trusted host provenance plus the generated script's terse-result declaration. */
     workflowOutputContract?: {
         readonly kodaxAuthored: boolean;
@@ -2599,7 +2724,78 @@ interface KodaXManagedWorkBudget {
     upgradeCeiling?: KodaXHarnessProfile;
     lastApprovalBudgetTotal?: number;
 }
+type KodaXShellKind = 'pwsh' | 'powershell' | 'cmd' | 'bash' | 'zsh';
+type KodaXShellProfileMode = 'default' | 'none' | 'login' | 'interactive' | 'login-interactive';
+/**
+ * Host-owned, JSON-serializable shell execution policy.
+ *
+ * The contract is opt-in. When absent, command execution keeps the legacy
+ * platform-shell/process.env behavior. When present, KodaX resolves a
+ * credential-filtered environment through this shell in the effective cwd,
+ * then executes the command with the same explicit interpreter.
+ */
+interface KodaXShellExecutionContract {
+    readonly version: 1;
+    readonly shell: {
+        readonly kind: KodaXShellKind;
+        /** Absolute path is recommended; a bare name is resolved from sanitized PATH. */
+        readonly executable?: string;
+        /** Trusted fixed arguments inserted before KodaX's generated command flag. */
+        readonly args?: readonly string[];
+        readonly profile?: KodaXShellProfileMode;
+    };
+    readonly environment?: {
+        /** `filtered` keeps non-sensitive daemon variables; `none` keeps only OS bootstrap variables. */
+        readonly inherit?: 'filtered' | 'none';
+        /** Trusted, non-secret variables added before profile resolution. */
+        readonly set?: Readonly<Record<string, string>>;
+        /** Additional glob-style variable-name denies. Built-in credential denies are immutable. */
+        readonly denyPatterns?: readonly string[];
+        /**
+         * Trusted shell code run after profile loading and before environment
+         * capture. Directory-aware version-manager activation belongs here.
+         */
+        readonly setup?: string;
+        /** Windows-only PATH source. `registry` re-reads current Machine/User PATH. */
+        readonly windowsPath?: 'process' | 'registry';
+    };
+    readonly cache?: {
+        /** Strict environment-cache lifetime. Zero disables caching. */
+        readonly ttlMs?: number;
+        /** Changing this JSON scalar explicitly invalidates an existing cache entry. */
+        readonly refreshToken?: string | number;
+    };
+    readonly probeTimeoutMs?: number;
+}
+interface KodaXShellSandboxPrepareInput {
+    readonly toolCallId?: string;
+    readonly toolInput: Readonly<Record<string, unknown>>;
+    readonly command: string;
+    readonly executable?: string;
+    readonly args?: readonly string[];
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly windowsVerbatimArguments?: boolean;
+    /** Caller cancellation while waiting for sandbox admission/preparation. */
+    readonly signal?: AbortSignal;
+    /** Absolute wall-clock deadline shared with the command timeout. */
+    readonly deadlineAt?: number;
+    readonly reportObservation?: (observation: KodaXShellSandboxObservation) => void;
+}
+interface KodaXPreparedShellSandboxInvocation {
+    readonly executable: string;
+    readonly args: readonly string[];
+    readonly env: NodeJS.ProcessEnv;
+    readonly windowsVerbatimArguments?: boolean;
+    cleanup(): Promise<KodaXShellSandboxObservation | undefined>;
+}
+/** Runtime-owned OS sandbox broker for selected concrete shell calls. */
+interface KodaXShellSandbox {
+    prepare(input: KodaXShellSandboxPrepareInput): Promise<KodaXPreparedShellSandboxInvocation | undefined>;
+}
 interface KodaXContextOptions {
+    /** Runtime-owner config home used by Memory, review inbox, and Learned Area routing. */
+    configHome?: string;
     /** Runtime-internal shared work ledger inherited by every descendant Agent run. */
     managedWorkBudget?: KodaXManagedWorkBudget;
     /** FEATURE_260 runtime-owned identity used for scoped memory reads. */
@@ -2608,10 +2804,44 @@ interface KodaXContextOptions {
     memoryPack?: MemoryPack;
     /** Runtime-minted collaboration principal for this actor execution. */
     actorControl?: AgentActorClient;
+    /**
+     * Exact MessageQueue route for the Actor execution. Actor children keep
+     * independent transcript session ids, so their collaboration mailbox cannot
+     * be derived from the child run's session id.
+     *
+     * @internal
+     */
+    actorQueueAgentId?: string;
+    /**
+     * Stable logical Session namespace used only for context identity. Child
+     * transcripts remain isolated under their physical worker Session ids.
+     *
+     * @internal
+     */
+    contextIdentitySessionId?: string;
+    /**
+     * Whether compaction in this physical run owns the canonical context
+     * revision. Synthetic digest/repair requests share attribution but not
+     * canonical history ownership.
+     *
+     * @internal
+     */
+    ownsContextRevision?: boolean;
     /** Trusted host operations that are intentionally absent from model-facing clients. */
     actorHost?: KodaXActorHost;
     /** Runtime-owned session Actor tree; attached when a root run builds its tool context. */
     actorSession?: CodingActorSession;
+    /**
+     * Runtime-owned admission window for interrupt input targeted at the active
+     * run. Its presence opts the managed Runner into consuming already-accepted
+     * input before a terminal candidate is allowed to complete.
+     *
+     * @internal
+     */
+    interruptInput?: {
+        closeInputWindow(): void;
+        reopenInputWindow(): void;
+    };
     /** Host attribution for an explicit Workflow command, SDK request, or natural-language product word. */
     workflowIntent?: 'explicit';
     /** Project root used for project-scoped prompts, permissions, and path policy. */
@@ -2621,6 +2851,10 @@ interface KodaXContextOptions {
      * and shell execution. Defaults to `gitRoot`, then `process.cwd()`.
      */
     executionCwd?: string;
+    /** Optional host-owned shell/environment resolution policy for command tools. */
+    shellExecution?: KodaXShellExecutionContract;
+    /** Runtime-owned OS sandbox broker; never accepted from serialized model input. */
+    shellSandbox?: KodaXShellSandbox;
     /** Fail-closed host policy applied to every concrete file a read tool opens. */
     assertReadablePath?: (candidate: string) => void;
     /**
@@ -2661,6 +2895,30 @@ interface KodaXContextOptions {
     skillsPrompt?: string;
     /** Optional run-scoped registry used to pin and restrict Skill invocation. */
     skillRegistry?: ISkillRegistry;
+    /** Runtime-owned complete formal-name inventory used to prevent learned Skill shadowing. */
+    protectedFormalSkillNames?: readonly string[];
+    /**
+     * Opaque root-run binding used to correlate learned Skill usage with the
+     * exact Memory episode produced by that run.
+     *
+     * @internal
+     */
+    learnedSkillBindingId?: string;
+    /** Runtime-owner admission for exact learned Skill revisions. */
+    admitLearnedSkillInvocation?: (input: {
+        readonly sessionId: string;
+        readonly capabilityId: string;
+        readonly revision: number;
+        readonly fingerprint: string;
+    }) => Promise<{
+        readonly invocationId: string;
+    }>;
+    /** Runtime-owner outcome correlation for learned Skill canaries. */
+    completeLearnedSkillOutcomes?: (input: {
+        readonly sessionId: string;
+        readonly outcome: 'verified_success' | 'credible_negative' | 'inconclusive';
+        readonly evidenceRefs: readonly string[];
+    }) => Promise<void>;
     /** Remote-runtime broker for explicitly admitted, OS-sandboxed Skill scripts. */
     skillScriptRunner?: KodaXSkillScriptRunner;
     rawUserInput?: string;
@@ -2854,6 +3112,10 @@ interface KodaXOptions {
     context?: KodaXContextOptions;
     events?: KodaXEvents;
     memoryReviewer?: MemoryReviewRunner;
+    /** One-call F263 reviewer. When present it replaces the memory-only reviewer for episode jobs. */
+    learningReviewer?: UnifiedLearningReviewRunner;
+    /** Optional host-owned semantic selector for sparse governed memory interventions. */
+    memoryRecallRunner?: MemoryRecallRunner;
     extensionRuntime?: ExtensionRuntimeContract;
     /** FEATURE_229: host-owned policy for workflow auto-start and ceilings. */
     workflowHostPolicy?: WorkflowHostPolicy;
@@ -3118,6 +3380,9 @@ interface KodaXManagedVerdictPayload {
     nextHarness?: KodaXTaskRoutingDecision['harnessProfile'];
     protocolParseFailed?: boolean;
     verificationDegraded?: boolean;
+    strategyReasonCode?: 'missing_requirement' | 'contradicted_evidence' | 'unsupported_claim' | 'unresolved_high_risk' | 'verification_degraded';
+    recommendedPattern?: 'classify-and-act' | 'fan-out-and-synthesize' | 'adversarial-verification' | 'generate-and-filter' | 'tournament' | 'loop-until-done';
+    targetEvidenceRefs?: string[];
     preferredFallbackWorkerId?: string;
     /**
      * v0.7.26 Risk-3 fix — Evaluator explicit budget-extension request.
@@ -3198,6 +3463,15 @@ interface KodaXToolExecutionContext {
     backups: Map<string, string>;
     /** Runtime-minted collaboration principal; model inputs cannot replace its caller path. */
     actorControl?: AgentActorClient;
+    /** Runtime-minted MessageQueue route for this Actor's collaboration mailbox. */
+    actorQueueAgentId?: string;
+    /** Stable logical Session namespace used for child context identity. */
+    contextIdentitySessionId?: string;
+    /** Runtime-minted exact Actor/Turn owner for collaboration metadata. */
+    actorTurnRef?: {
+        readonly actorPath: string;
+        readonly turnId: string;
+    };
     /** Shared root-run work ledger; descendant runtimes retain this exact object. */
     managedWorkBudget?: KodaXManagedWorkBudget;
     /** Trusted host operations that are intentionally absent from model-facing clients. */
@@ -3207,6 +3481,24 @@ interface KodaXToolExecutionContext {
         readonly content: string;
         readonly evidenceRefs: readonly string[];
     } | undefined>;
+    /**
+     * Root-session-only submission channel for explicit user Memory intent.
+     * The host validates an exact current-user quote and captures one intent for
+     * end-of-episode governed submission; this callback never creates a durable
+     * review job or writes Memory directly.
+     */
+    memoryIntent?: (input: {
+        readonly operation: 'remember' | 'correct';
+        readonly statement: string;
+        readonly userQuote: string;
+    }) => Promise<{
+        readonly status: 'captured';
+        readonly operation: 'remember' | 'correct';
+        readonly evidenceRef: string;
+    } | {
+        readonly status: 'rejected';
+        readonly reason: string;
+    }>;
     /** Exact persisted history loader for the current root or isolated worker Session. */
     loadSessionHistory?: () => Promise<KodaXSessionLineage | null>;
     /** Git root directory - Git 鏍圭洰褰?*/
@@ -3247,10 +3539,25 @@ interface KodaXToolExecutionContext {
     skillDynamicContext?: KodaXSkillDynamicContextPolicy;
     /** Runtime-bound Skill registry; avoids process-global cross-session drift. */
     skillRegistry?: ISkillRegistry;
+    /** Runtime-owner admission for exact learned Skill revisions. */
+    admitLearnedSkillInvocation?: KodaXContextOptions['admitLearnedSkillInvocation'];
     /** Present only when the host admitted exact Skill scripts for this run. */
     skillScriptRunner?: KodaXSkillScriptRunner;
     /** Working directory used to resolve relative paths and execute shell commands. */
     executionCwd?: string;
+    /** Validated shell execution policy inherited by native child runtimes. */
+    shellExecution?: KodaXShellExecutionContract;
+    /** Runtime-owned OS sandbox broker for selected concrete shell calls. */
+    shellSandbox?: KodaXShellSandbox;
+    /** Structured containment metadata; never model-visible or persisted as conversation text. */
+    reportToolSandboxObservation?: (observation: KodaXShellSandboxObservation) => void;
+    /**
+     * Exact credential variable names owned by registered Providers.
+     * Used only to remove non-standard `apiKeyEnv` names from child processes.
+     *
+     * @internal
+     */
+    providerCredentialEnvironmentNames?: readonly string[];
     /** Fail-closed host policy applied to every concrete file a read tool opens. */
     assertReadablePath?: (candidate: string) => void;
     /** Host tool visibility ceiling inherited by child agents. */
@@ -3330,6 +3637,9 @@ interface KodaXToolExecutionContext {
         readonly repoIntelligenceMode?: KodaXRepoIntelligenceMode;
         readonly repoIntelligenceTrace?: boolean;
         readonly compaction?: Readonly<KodaXCompactionOverride>;
+        readonly contextDiagnostics?: boolean;
+        readonly disablePromptCache?: boolean;
+        readonly shellExecution?: KodaXShellExecutionContract;
     };
     /** Parent SDK/REPL callback surface used to preserve nested Agent telemetry. */
     parentEvents?: KodaXEvents;
@@ -3689,5 +3999,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-export { ALWAYS_RESIDENT_TOOL_NAMES as A, BASH_POLICY_SPEC as B, LSP_SERVERS as aS, LspService as aU, createBashPrefixExtractor as bA, createCompactionAntiThrashState as bB, createExternalActorTurnExecutor as bC, createLocalCodingActorControl as bD, createRuntimeContextBudgetSnapshot as bE, decideWorkflowInvocation as bF, drainPendingSwaps as bG, estimateToolSchemaTokens as bH, extractCommandPrefix as bI, getDefaultLspService as bJ, hasExplicitNaturalLanguageWorkflowIntent as bK, hasPendingSwap as bL, makeDisabledGoalToolsContext as bM, normalizeKodaXAgentMode as bN, planToolExposure as bO, providerResilienceConfigFromTimeouts as bP, recordCompactionSavings as bQ, resolveConstructedAgent as bR, shouldSkipLlmCompaction as bS, shutdownDefaultLspService as bT, withGoalBeforeNextTurn as bU, withGoalStopHook as bV, workflowStartOutcomeConsumesTurn as bW, buildGoalRuntimeBinding as by, consumeCompactionCooldown as bz, CodingActorSession as d };
-export type { KodaXManualTopicInput as $, CapabilityRuntimeContract as C, DiagnosticsRequest as D, ExtensionRuntimeContract as E, FailureStage as F, GoalBlockedResult as G, KodaXChildContextBundle as H, KodaXChildExecutionResult as I, KodaXCompactionOverride as J, KodaXActivityEventMeta as K, KodaXContextCompactionFinishedEvent as L, KodaXContextIdentity as M, KodaXContextOptions as N, KodaXContextTokenSnapshot as O, KodaXEffectiveTaskConfig as P, KodaXEvents as Q, KodaXLiveEventMeta as R, KodaXManagedBudgetSnapshot as S, KodaXManagedProtocolPayload as T, KodaXManagedTask as U, KodaXManagedTaskRuntimeState as V, KodaXManagedTaskStatusEvent as W, KodaXManualIndexTopic as X, KodaXManualSource as Y, KodaXManualTopic as Z, KodaXManualTopicId as _, BashPrefixExtractor as a, RecoveryDecision as a$, KodaXMemoryStrategy as a0, KodaXOptions as a1, KodaXOrchestrationVerdict as a2, KodaXParentReductionContract as a3, KodaXProviderPolicyHints as a4, KodaXRepoIntelligenceCapability as a5, KodaXRepoIntelligenceMode as a6, KodaXRepoIntelligenceResolvedMode as a7, KodaXRepoIntelligenceTrace as a8, KodaXRepoIntelligenceTraceEvent as a9, KodaXTaskToolPolicy as aA, KodaXTaskVerificationContract as aB, KodaXTaskVerificationCriterion as aC, KodaXTaskWorkItem as aD, KodaXTimeoutConfig as aE, KodaXToolEventMeta as aF, KodaXToolExecutionContext as aG, KodaXToolVisibilityMeta as aH, KodaXToolVisibilityPolicy as aI, KodaXTurnCompletedEvent as aJ, KodaXTurnDeliveryKind as aK, KodaXTurnFailedEvent as aL, KodaXTurnStartedEvent as aM, KodaXVerificationScorecard as aN, KodaXVerificationScorecardCriterion as aO, KodaXWorkflowAgentDigestEvent as aP, KodaXWorkflowEventMeta as aQ, KodaXWorkflowTimeoutConfig as aR, LspServerInfo as aT, LspServiceConfig as aV, ProviderExecutionState as aW, ProviderRecoveryEvent as aX, ProviderResilienceConfig as aY, ProviderResiliencePolicy as aZ, RecoveryAction as a_, KodaXRepoRoutingSignals as aa, KodaXResult as ab, KodaXRoleRoundSummary as ac, KodaXRuntimeVerificationContract as ad, KodaXSelfManualConfig as ae, KodaXSessionControl as af, KodaXSessionMutators as ag, KodaXSessionOptions as ah, KodaXSidecarMessageEvent as ai, KodaXSkillDynamicContextPolicy as aj, KodaXSkillInvocationContext as ak, KodaXSkillMap as al, KodaXSkillProjectionConfidence as am, KodaXSkillScriptInputFile as an, KodaXSkillScriptOutputFile as ao, KodaXSkillScriptRunInput as ap, KodaXSkillScriptRunner as aq, KodaXTaskCapabilityHint as ar, KodaXTaskContract as as, KodaXTaskEvidenceArtifact as at, KodaXTaskEvidenceBundle as au, KodaXTaskEvidenceEntry as av, KodaXTaskRole as aw, KodaXTaskRoleAssignment as ax, KodaXTaskStatus as ay, KodaXTaskSurface as az, BashPrefixResult as b, RecoveryLadderStep as b0, RecoveryResult as b1, ResilienceClassification as b2, ResilienceErrorClass as b3, ResolveKodaXManualInput as b4, ResolveKodaXManualOptions as b5, ResolveKodaXManualResult as b6, RuntimeCompactionSkippedEvent as b7, RuntimeContextBudgetBreakdown as b8, RuntimeContextBudgetRecommendation as b9, RuntimeContextBudgetSnapshot as ba, RuntimeContextBudgetSnapshotInput as bb, RuntimeContextOptimizationProfile as bc, RuntimeContextPressure as bd, RuntimeDefaultsSnapshot as be, RuntimeToolExposureDecision as bf, RuntimeToolExposureMode as bg, RuntimeToolExposurePlan as bh, RuntimeToolExposurePlanInput as bi, RuntimeToolExposureReason as bj, TodoItem as bk, TodoList as bl, TodoStatus as bm, ToolSideEffect as bn, WorkflowHostPolicy as bo, WorkflowInvocationAction as bp, WorkflowInvocationPolicyDecision as bq, WorkflowInvocationPolicyInput as br, WorkflowInvocationSource as bs, WorkflowStartOutcome as bt, WorkflowToolHost as bu, WorkflowToolHostInlineInput as bv, WorkflowToolHostResult as bw, WorkflowToolHostStartResult as bx, BoundExtensionRuntimeController as c, CodingActorSessionOptions as e, CompactionAntiThrashConfig as f, CompactionAntiThrashState as g, CompactionSavingsDecision as h, CompactionSavingsSample as i, CompactionSkipReason as j, CreateBashPrefixExtractorOptions as k, ExtractCommandPrefixOptions as l, GoalCompleteResult as m, GoalCreateInput as n, GoalLifecycleContext as o, GoalRuntimeBinding as p, GoalRuntimeBindingDeps as q, GoalToolsContext as r, KodaXActorHost as s, KodaXAgentMode as t, KodaXAgentProfile as u, KodaXAgentScope as v, KodaXBudgetDisclosureZone as w, KodaXBudgetExtensionRequest as x, KodaXCanonicalAgentMode as y, KodaXChildAgentResult as z };
+export { ALWAYS_RESIDENT_TOOL_NAMES as A, BASH_POLICY_SPEC as B, resolveConstructedAgent as b$, LSP_SERVERS as b0, LspService as b2, buildGoalRuntimeBinding as bI, consumeCompactionCooldown as bJ, createBashPrefixExtractor as bK, createCompactionAntiThrashState as bL, createExternalActorTurnExecutor as bM, createLocalCodingActorControl as bN, createRuntimeContextBudgetSnapshot as bO, decideWorkflowInvocation as bP, drainPendingSwaps as bQ, estimateToolSchemaTokens as bR, extractCommandPrefix as bS, getDefaultLspService as bT, hasExplicitNaturalLanguageWorkflowIntent as bU, hasPendingSwap as bV, makeDisabledGoalToolsContext as bW, normalizeKodaXAgentMode as bX, planToolExposure as bY, providerResilienceConfigFromTimeouts as bZ, recordCompactionSavings as b_, shouldSkipLlmCompaction as c0, shutdownDefaultLspService as c1, withGoalBeforeNextTurn as c2, withGoalStopHook as c3, workflowStartOutcomeConsumesTurn as c4, CodingActorSession as d };
+export type { KodaXManualTopicInput as $, CapabilityRuntimeContract as C, DiagnosticsRequest as D, ExtensionRuntimeContract as E, FailureStage as F, GoalBlockedResult as G, KodaXChildContextBundle as H, KodaXChildExecutionResult as I, KodaXCompactionOverride as J, KodaXActivityEventMeta as K, KodaXContextCompactionFinishedEvent as L, KodaXContextIdentity as M, KodaXContextOptions as N, KodaXContextTokenSnapshot as O, KodaXEffectiveTaskConfig as P, KodaXEvents as Q, KodaXLiveEventMeta as R, KodaXManagedBudgetSnapshot as S, KodaXManagedProtocolPayload as T, KodaXManagedTask as U, KodaXManagedTaskRuntimeState as V, KodaXManagedTaskStatusEvent as W, KodaXManualIndexTopic as X, KodaXManualSource as Y, KodaXManualTopic as Z, KodaXManualTopicId as _, BashPrefixExtractor as a, KodaXWorkflowTimeoutConfig as a$, KodaXMemoryStrategy as a0, KodaXOptions as a1, KodaXOrchestrationVerdict as a2, KodaXParentReductionContract as a3, KodaXPreparedShellSandboxInvocation as a4, KodaXPromptCacheDiagnosticEvent as a5, KodaXProviderPolicyHints as a6, KodaXRepoIntelligenceCapability as a7, KodaXRepoIntelligenceMode as a8, KodaXRepoIntelligenceResolvedMode as a9, KodaXTaskCapabilityHint as aA, KodaXTaskContract as aB, KodaXTaskEvidenceArtifact as aC, KodaXTaskEvidenceBundle as aD, KodaXTaskEvidenceEntry as aE, KodaXTaskRole as aF, KodaXTaskRoleAssignment as aG, KodaXTaskStatus as aH, KodaXTaskSurface as aI, KodaXTaskToolPolicy as aJ, KodaXTaskVerificationContract as aK, KodaXTaskVerificationCriterion as aL, KodaXTaskWorkItem as aM, KodaXTimeoutConfig as aN, KodaXToolEventMeta as aO, KodaXToolExecutionContext as aP, KodaXToolSandboxObservationUpdate as aQ, KodaXToolVisibilityMeta as aR, KodaXToolVisibilityPolicy as aS, KodaXTurnCompletedEvent as aT, KodaXTurnDeliveryKind as aU, KodaXTurnFailedEvent as aV, KodaXTurnStartedEvent as aW, KodaXVerificationScorecard as aX, KodaXVerificationScorecardCriterion as aY, KodaXWorkflowAgentDigestEvent as aZ, KodaXWorkflowEventMeta as a_, KodaXRepoIntelligenceTrace as aa, KodaXRepoIntelligenceTraceEvent as ab, KodaXRepoRoutingSignals as ac, KodaXResult as ad, KodaXRoleRoundSummary as ae, KodaXRuntimeVerificationContract as af, KodaXSelfManualConfig as ag, KodaXSessionControl as ah, KodaXSessionMutators as ai, KodaXSessionOptions as aj, KodaXShellExecutionContract as ak, KodaXShellKind as al, KodaXShellProfileMode as am, KodaXShellSandbox as an, KodaXShellSandboxBackend as ao, KodaXShellSandboxObservation as ap, KodaXShellSandboxPrepareInput as aq, KodaXSidecarMessageEvent as ar, KodaXSkillDynamicContextPolicy as as, KodaXSkillInvocationContext as at, KodaXSkillMap as au, KodaXSkillProjectionConfidence as av, KodaXSkillScriptInputFile as aw, KodaXSkillScriptOutputFile as ax, KodaXSkillScriptRunInput as ay, KodaXSkillScriptRunner as az, BashPrefixResult as b, LspServerInfo as b1, LspServiceConfig as b3, ProviderExecutionState as b4, ProviderRecoveryEvent as b5, ProviderResilienceConfig as b6, ProviderResiliencePolicy as b7, RecoveryAction as b8, RecoveryDecision as b9, WorkflowInvocationPolicyDecision as bA, WorkflowInvocationPolicyInput as bB, WorkflowInvocationSource as bC, WorkflowStartOutcome as bD, WorkflowToolHost as bE, WorkflowToolHostInlineInput as bF, WorkflowToolHostResult as bG, WorkflowToolHostStartResult as bH, RecoveryLadderStep as ba, RecoveryResult as bb, ResilienceClassification as bc, ResilienceErrorClass as bd, ResolveKodaXManualInput as be, ResolveKodaXManualOptions as bf, ResolveKodaXManualResult as bg, RuntimeCompactionSkippedEvent as bh, RuntimeContextBudgetBreakdown as bi, RuntimeContextBudgetRecommendation as bj, RuntimeContextBudgetSnapshot as bk, RuntimeContextBudgetSnapshotInput as bl, RuntimeContextOptimizationProfile as bm, RuntimeContextPressure as bn, RuntimeDefaultsSnapshot as bo, RuntimeToolExposureDecision as bp, RuntimeToolExposureMode as bq, RuntimeToolExposurePlan as br, RuntimeToolExposurePlanInput as bs, RuntimeToolExposureReason as bt, TodoItem as bu, TodoList as bv, TodoStatus as bw, ToolSideEffect as bx, WorkflowHostPolicy as by, WorkflowInvocationAction as bz, BoundExtensionRuntimeController as c, CodingActorSessionOptions as e, CompactionAntiThrashConfig as f, CompactionAntiThrashState as g, CompactionSavingsDecision as h, CompactionSavingsSample as i, CompactionSkipReason as j, CreateBashPrefixExtractorOptions as k, ExtractCommandPrefixOptions as l, GoalCompleteResult as m, GoalCreateInput as n, GoalLifecycleContext as o, GoalRuntimeBinding as p, GoalRuntimeBindingDeps as q, GoalToolsContext as r, KodaXActorHost as s, KodaXAgentMode as t, KodaXAgentProfile as u, KodaXAgentScope as v, KodaXBudgetDisclosureZone as w, KodaXBudgetExtensionRequest as x, KodaXCanonicalAgentMode as y, KodaXChildAgentResult as z };

package/dist/types-chunks/{capability-learning.d-DPrYxRjF.d.ts → capability-learning.d-CVsdHw4j.d.ts}

@@ -1,4 +1,4 @@
-import { G as KodaXReasoningProfile } from './types.d-CSmF0t0n.js';
+import { G as KodaXReasoningProfile } from './types.d-DIpZJKUl.js';
 
 type CapabilityCacheSource = 'observed' | 'probed';
 interface CapabilityCacheEntry {

package/dist/types-chunks/{capsule.d-zeqV4IQX.d.ts → capsule.d-BlSv9l3V.d.ts}

@@ -1,5 +1,5 @@
-import { k as KodaXMessage } from './types.d-CSmF0t0n.js';
-import { a8 as AgentMessage, de as SessionEntry, dc as Session, dg as SessionExtension, bM as KodaXSessionLineage, by as KodaXJsonValue, aP as CompactionDetails, bl as KodaXCompactMemorySeed, bI as KodaXSessionEntry, bW as KodaXSessionTreeNode, bL as KodaXSessionLabelEntry, bK as KodaXSessionGoalEntry, bF as KodaXSessionClientNoticeEntry, bS as KodaXSessionRewindMarkerEntry, bN as KodaXSessionMemoryOutcomeDigestEntry, bO as KodaXSessionMemoryReviewReceiptEntry, bR as KodaXSessionNavigationOptions, bD as KodaXSessionArtifactLedgerEntry, b9 as FileOperations, dV as WorkflowMeta, dW as WorkflowModelHint, dX as WorkflowModule } from './types.d-sRLugmjy.js';
+import { k as KodaXMessage } from './types.d-DIpZJKUl.js';
+import { ab as AgentMessage, d$ as SessionEntry, dZ as Session, e1 as SessionExtension, bU as KodaXSessionLineage, bF as KodaXJsonValue, aT as CompactionDetails, bs as KodaXCompactMemorySeed, bQ as KodaXSessionEntry, c2 as KodaXSessionTreeNode, bT as KodaXSessionLabelEntry, bS as KodaXSessionGoalEntry, bN as KodaXSessionClientNoticeEntry, b_ as KodaXSessionRewindMarkerEntry, bV as KodaXSessionMemoryOutcomeDigestEntry, bW as KodaXSessionMemoryReviewReceiptEntry, bZ as KodaXSessionNavigationOptions, bL as KodaXSessionArtifactLedgerEntry, bg as FileOperations, eJ as WorkflowMeta, eK as WorkflowModelHint, eL as WorkflowModule } from './types.d-BA-Jwpfs.js';
 
 /**
  * @kodax-ai/agent Constants

package/dist/types-chunks/{guardrail.d-CWYD1bdL.d.ts → guardrail.d-BRE_ErEj.d.ts}

@@ -1,4 +1,4 @@
-import { bb as Guardrail, d6 as RunnerToolCall, f as Agent, a8 as AgentMessage, d9 as RunnerToolResult, dk as Span } from './types.d-sRLugmjy.js';
+import { bi as Guardrail, dT as RunnerToolCall, f as Agent, ab as AgentMessage, dW as RunnerToolResult, e5 as Span } from './types.d-BA-Jwpfs.js';
 
 /**
  * Guardrail Runtime — FEATURE_085 (v0.7.26).