@kodax-ai/kodax 0.7.83 → 0.7.85

package/dist/types-chunks/{bash-prefix-extractor.d-CJM7OY-L.d.ts → bash-prefix-extractor.d-BnZQDirs.d.ts}

@@ -1,9 +1,10 @@
-import { bI as KodaXGoalState, ae as AgentMessage, er as StopHookFn, c1 as KodaXSessionLineage, o as AgentActorStore, aI as AgentTurnExecutor, x as AgentBudgetPort, j as AgentActorOwner, D as AgentControllerHealth, h as AgentActorClient, T as AgentExecutionResult, $ as AgentExecutorPlaneBinding, bO as KodaXJsonValue, bC as KodaXExtensionSessionRecord, f as Agent, eT as WorkflowIsolation, bD as KodaXExtensionSessionState, bU as KodaXSessionArtifactLedgerEntry, eb as SessionErrorMetadata, c9 as KodaXSessionScope, ca as KodaXSessionStorage, bp as GuardrailPermissionIntent, db as MemoryContextIdentity, dn as MemoryPack, aQ as AskUserQuestionOptions, aM as AskUserAnswer, aO as AskUserMultiOptions, eQ as WorkflowEventCorrelation, a_ as CompactionUpdate, f5 as WorkflowProcessEvent, eP as WorkflowEvent, dC as MemoryReviewPlan, bR as KodaXMemoryOutcomeDigest, bl as Guardrail, b5 as DiscoveredInstance, bM as KodaXInputArtifact, dD as MemoryReviewRunner, eH as UnifiedLearningReviewRunner } from './controller.d-CYNuR2n9.js';
+import { V as KodaXGoalState, ab as KodaXSessionLineage, g as AgentActorStore, K as AgentTurnExecutor, l as AgentBudgetPort, b as AgentActorOwner, a as AgentActorClient, t as AgentExecutionResult, Y as KodaXJsonValue, Q as KodaXExtensionSessionRecord, R as KodaXExtensionSessionState, a2 as KodaXSessionArtifactLedgerEntry, ba as SessionErrorMetadata, aj as KodaXSessionScope, ak as KodaXSessionStorage, aE as MemoryContextIdentity, aQ as MemoryPack, b4 as MemoryReviewPlan, $ as KodaXMemoryOutcomeDigest, b5 as MemoryReviewRunner } from './types.d-DlLBRqZ9.js';
 import { Diagnostic, Position, Location, Hover, DocumentSymbol, SymbolInformation, WorkspaceSymbol, CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from 'vscode-languageserver-protocol';
 import { a1 as KodaXTokenUsage, k as KodaXMessage, a2 as KodaXToolDefinition, aa as KodaXWireReasoningEffort, V as KodaXTaskRoutingDecision, W as KodaXTaskType, X as KodaXTaskWorkIntent, R as KodaXTaskComplexity, M as KodaXRiskLevel, h as KodaXHarnessProfile, f as KodaXExecutionMode, b as KodaXChildFanoutClass, G as KodaXReasoningMode, L as KodaXReviewScale } from './types.d-CgrXrFrq.js';
-import { d as SkillDynamicContextExecutor, I as ISkillRegistry } from './types.d-BbtGlKZu.js';
+import { P as AgentMessage, ct as StopHookFn, o as AgentControllerHealth, G as AgentExecutorPlaneBinding, f as Agent, cV as WorkflowIsolation, aN as GuardrailPermissionIntent, ac as AskUserQuestionOptions, a8 as AskUserAnswer, aa as AskUserMultiOptions, cS as WorkflowEventCorrelation, am as CompactionUpdate, d7 as WorkflowProcessEvent, cR as WorkflowEvent, aJ as Guardrail, at as DiscoveredInstance, a$ as KodaXInputArtifact, cJ as UnifiedLearningReviewRunner } from './controller.d-Dzxz22X-.js';
+import { d as SkillDynamicContextExecutor, I as ISkillRegistry } from './types.d-BSPlmJqf.js';
 import { K as KodaXLlmTimeoutConfig, a as CostTracker } from './cost-tracker.d-BeaenODW.js';
-import { t as MemoryRecallRunner } from './types-Bf3Y3mW-.js';
+import { p as MemoryRecallRunner } from './types-PHjfwebT.js';
 import { C as CapabilityKind, f as CapabilitySearchSnapshot, b as CapabilityResult } from './capability.d-K664nHOS.js';
 import { K as KodaXBaseProvider } from './base.d-DxG0m09Z.js';
 
@@ -1243,7 +1244,7 @@ interface CompactionSavingsDecision {
     readonly lowSavings: boolean;
     readonly enteredCooldown: boolean;
 }
-type CompactionSkipReason = 'low_savings_cooldown' | 'covered_context_unchanged';
+type CompactionSkipReason = 'low_savings_cooldown' | 'covered_context_unchanged' | 'compactable_below_threshold' | 'no_compactable_prefix' | 'circuit_breaker_cooldown';
 interface RuntimeCompactionSkippedEvent {
     readonly contextId?: string;
     readonly contextKind?: 'root' | 'child';
@@ -1255,6 +1256,13 @@ interface RuntimeCompactionSkippedEvent {
     readonly triggerPercent: number;
     readonly cooldownTurnsRemaining: number;
     readonly lowSavingsStreak: number;
+    /** Full request minus replaceable managed-run-context messages. */
+    readonly compactableTokens?: number;
+    readonly effectiveTriggerTokens?: number;
+    readonly consecutiveFailures?: number;
+    readonly circuitBreakerLimit?: number;
+    readonly circuitBreakerState?: 'closed' | 'open' | 'half_open';
+    readonly rearmAtTokens?: number;
 }
 declare function createCompactionAntiThrashState(): CompactionAntiThrashState;
 declare function shouldSkipLlmCompaction(state: CompactionAntiThrashState | undefined, currentTokens?: number): boolean;
@@ -1732,6 +1740,41 @@ interface KodaXContextCompactionFinishedEvent extends Partial<KodaXLiveEventMeta
     readonly summaryTokens?: number;
     readonly queryLedgerTokens?: number;
 }
+type KodaXCompactionFailureReason = 'summary_generation_failed' | 'persistence_failed' | 'context_capacity_exceeded' | 'post_processing_failed';
+interface KodaXCompactionEndState {
+    readonly currentTokens: number;
+    readonly compactableTokens: number;
+    readonly consecutiveFailures: number;
+    readonly circuitBreakerLimit: number;
+    readonly circuitBreakerState: 'closed' | 'open' | 'half_open';
+    readonly cooldownTurnsRemaining: number;
+}
+/** Structured outcome attached to the existing compaction-ended lifecycle event. */
+type KodaXCompactionEndResult = KodaXCompactionEndState & ({
+    readonly outcome: 'compacted';
+    readonly reason?: never;
+    readonly failurePhase?: never;
+} | {
+    readonly outcome: 'skipped';
+    readonly reason: CompactionSkipReason;
+    readonly failurePhase?: never;
+} | {
+    readonly outcome: 'failed';
+    readonly reason: 'summary_generation_failed';
+    readonly failurePhase: 'summary_generation';
+} | {
+    readonly outcome: 'failed';
+    readonly reason: 'persistence_failed';
+    readonly failurePhase: 'persistence';
+} | {
+    readonly outcome: 'failed';
+    readonly reason: 'post_processing_failed';
+    readonly failurePhase: 'post_processing';
+} | {
+    readonly outcome: 'failed';
+    readonly reason: 'context_capacity_exceeded';
+    readonly failurePhase?: never;
+});
 interface KodaXSidecarMessageEvent {
     readonly source: 'sidecar-verifier';
     readonly verdict: 'revise' | 'blocked';
@@ -1831,6 +1874,16 @@ interface KodaXEvents {
         name: string;
         content: string;
     }, meta?: KodaXToolEventMeta) => void;
+    /** Internal execution lease boundary; fires immediately around tool.execute. */
+    onToolExecutionStart?: (tool: {
+        id: string;
+        name: string;
+    }, meta?: KodaXToolEventMeta) => void;
+    /** Pairs with onToolExecutionStart in a finally block. */
+    onToolExecutionEnd?: (tool: {
+        id: string;
+        name: string;
+    }, meta?: KodaXToolEventMeta) => void;
     /** FEATURE_067 v2: Real-time tool execution progress update. Updates the tool's display in the REPL transcript. */
     onToolProgress?: (update: {
         id: string;
@@ -1886,8 +1939,8 @@ interface KodaXEvents {
     onCompactedMessages?: (messages: KodaXMessage[], update?: CompactionUpdate, meta?: KodaXActivityEventMeta) => void | Promise<void>;
     /** Canonical, post-commit compaction fact. Legacy callbacks are projections. */
     onContextCompactionFinished?: (event: KodaXContextCompactionFinishedEvent) => void;
-    /** Emitted to silently dismiss the compaction UI if compaction aborted or completed without changes */
-    onCompactEnd?: (meta?: KodaXActivityEventMeta) => void;
+    /** Ends a started compaction attempt; the optional result preserves legacy one-argument handlers. */
+    onCompactEnd?: (meta?: KodaXActivityEventMeta, result?: KodaXCompactionEndResult) => void;
     /** Whether the caller has queued follow-up input waiting for the next round */
     hasPendingInputs?: () => boolean;
     /**
@@ -1960,7 +2013,7 @@ interface KodaXEvents {
     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. */
+    /** Bounded operational reason whenever a compaction gate skips work. */
     onContextCompactionSkipped?: (event: RuntimeCompactionSkippedEvent & Partial<KodaXLiveEventMeta>) => void;
     /**
      * Fired when the Sidecar Verifier produces an actionable message.
@@ -2789,15 +2842,30 @@ interface KodaXShellSandboxPrepareInput {
     readonly deadlineAt?: number;
     readonly reportObservation?: (observation: KodaXShellSandboxObservation) => void;
 }
+/** Exclusive host filesystem fence acquired before a sandbox grants temporary ACLs. */
+interface KodaXFileSystemEffectLease {
+    bindEffectProcess(pid: number, windowsJobContained: boolean): Promise<void>;
+    finishEffectProcess(): Promise<void>;
+    release(): Promise<void>;
+}
 interface KodaXPreparedShellSandboxInvocation {
     readonly executable: string;
     readonly args: readonly string[];
     readonly env: NodeJS.ProcessEnv;
     readonly windowsVerbatimArguments?: boolean;
+    readonly fileSystemEffectLease?: KodaXFileSystemEffectLease;
     cleanup(): Promise<KodaXShellSandboxObservation | undefined>;
 }
 /** Runtime-owned OS sandbox broker for selected concrete shell calls. */
 interface KodaXShellSandbox {
+    /** Selected calls must not fall back to ordinary host execution. */
+    readonly failClosed?: boolean;
+    /**
+     * Host-trusted proof that the prepared root cannot settle while one of its
+     * descendants remains alive. Omitted adapters remain source-compatible but
+     * cannot authorize opaque process-launching shell calls.
+     */
+    readonly processTreeContainment?: 'root-exit-drains';
     prepare(input: KodaXShellSandboxPrepareInput): Promise<KodaXPreparedShellSandboxInvocation | undefined>;
 }
 interface KodaXContextOptions {
@@ -3503,10 +3571,9 @@ interface KodaXToolExecutionContext {
         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.
+     * @deprecated Legacy end-of-episode explicit Memory-intent capture callback.
+     * Hosts may keep providing this callback; the conversation-first management
+     * tool never sends its broader operation protocol through this seam.
      */
     memoryIntent?: (input: {
         readonly operation: 'remember' | 'correct';
@@ -3520,6 +3587,56 @@ interface KodaXToolExecutionContext {
         readonly status: 'rejected';
         readonly reason: string;
     }>;
+    /** Root-session-only conversation-first Memory management channel. */
+    memoryManagementIntent?: (input: {
+        readonly operation: 'list' | 'remember' | 'correct' | 'forget' | 'decisions' | 'show' | 'approve' | 'reject';
+        readonly statement?: string;
+        readonly targetRefId?: string;
+        readonly claimKind?: 'fact' | 'policy' | 'preference' | 'procedure';
+        readonly claimKey?: string;
+        readonly userQuote?: string;
+        readonly reason?: string;
+    }) => Promise<{
+        readonly status: 'listed';
+        readonly operation: 'list';
+        readonly total: number;
+        readonly memories: readonly {
+            readonly refId: string;
+            readonly title: string;
+            readonly body: string;
+            readonly bodyFingerprint: string;
+        }[];
+    } | {
+        readonly status: 'decisions';
+        readonly operation: 'decisions';
+        readonly total: number;
+        readonly decisions: readonly {
+            readonly refId: string;
+            readonly summary: string;
+            readonly rationale: string;
+            readonly risk: 'low' | 'medium' | 'high';
+            readonly proposedBody?: string;
+        }[];
+    } | {
+        readonly status: 'shown';
+        readonly operation: 'show';
+        readonly decision: {
+            readonly refId: string;
+            readonly summary: string;
+            readonly rationale: string;
+            readonly risk: 'low' | 'medium' | 'high';
+            readonly proposedBody?: string;
+        };
+    } | {
+        readonly status: 'remembered' | 'updated' | 'already_known' | 'forgotten' | 'approved' | 'decision_rejected';
+        readonly operation: 'remember' | 'correct' | 'forget' | 'approve' | 'reject';
+        readonly changedRefIds: readonly string[];
+    } | {
+        readonly status: 'needs_clarification' | 'needs_review' | 'rejected';
+        readonly operation: 'remember' | 'correct' | 'forget' | 'show' | 'approve' | 'reject';
+        readonly reason: string;
+        readonly decisionRefIds?: readonly string[];
+    }>;
     /** Exact persisted history loader for the current root or isolated worker Session. */
     loadSessionHistory?: () => Promise<KodaXSessionLineage | null>;
     /** Git root directory - Git 鏍圭洰褰?*/
@@ -4024,5 +4141,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-export { ALWAYS_RESIDENT_TOOL_NAMES as A, BASH_POLICY_SPEC as B, recordCompactionSavings as b$, LSP_SERVERS as b1, LspService as b3, buildGoalRuntimeBinding as bJ, consumeCompactionCooldown as bK, createBashPrefixExtractor as bL, createCompactionAntiThrashState as bM, createExternalActorTurnExecutor as bN, createLocalCodingActorControl as bO, createRuntimeContextBudgetSnapshot as bP, decideWorkflowInvocation as bQ, drainPendingSwaps as bR, estimateToolSchemaTokens as bS, extractCommandPrefix as bT, getDefaultLspService as bU, hasExplicitNaturalLanguageWorkflowIntent as bV, hasPendingSwap as bW, makeDisabledGoalToolsContext as bX, normalizeKodaXAgentMode as bY, planToolExposure as bZ, providerResilienceConfigFromTimeouts as b_, resolveConstructedAgent as c0, shouldSkipLlmCompaction as c1, shutdownDefaultLspService as c2, withGoalBeforeNextTurn as c3, withGoalStopHook as c4, workflowStartOutcomeConsumesTurn as c5, 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, KodaXWorkflowEventMeta 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, KodaXSkillScriptRunner as aA, KodaXTaskCapabilityHint as aB, KodaXTaskContract as aC, KodaXTaskEvidenceArtifact as aD, KodaXTaskEvidenceBundle as aE, KodaXTaskEvidenceEntry as aF, KodaXTaskRole as aG, KodaXTaskRoleAssignment as aH, KodaXTaskStatus as aI, KodaXTaskSurface as aJ, KodaXTaskToolPolicy as aK, KodaXTaskVerificationContract as aL, KodaXTaskVerificationCriterion as aM, KodaXTaskWorkItem as aN, KodaXTimeoutConfig as aO, KodaXToolEventMeta as aP, KodaXToolExecutionContext as aQ, KodaXToolSandboxObservationUpdate as aR, KodaXToolVisibilityMeta as aS, KodaXToolVisibilityPolicy as aT, KodaXTurnCompletedEvent as aU, KodaXTurnDeliveryKind as aV, KodaXTurnFailedEvent as aW, KodaXTurnStartedEvent as aX, KodaXVerificationScorecard as aY, KodaXVerificationScorecardCriterion as aZ, KodaXWorkflowAgentDigestEvent as a_, KodaXRepoIntelligenceTrace as aa, KodaXRepoIntelligenceTraceEvent as ab, KodaXRepoRoutingSignals as ac, KodaXResult as ad, KodaXRoleRoundSummary as ae, KodaXRuntimeVerificationContract as af, KodaXSandboxOptions as ag, KodaXSelfManualConfig as ah, KodaXSessionControl as ai, KodaXSessionMutators as aj, KodaXSessionOptions as ak, KodaXShellExecutionContract as al, KodaXShellKind as am, KodaXShellProfileMode as an, KodaXShellSandbox as ao, KodaXShellSandboxBackend as ap, KodaXShellSandboxObservation as aq, KodaXShellSandboxPrepareInput as ar, KodaXSidecarMessageEvent as as, KodaXSkillDynamicContextPolicy as at, KodaXSkillInvocationContext as au, KodaXSkillMap as av, KodaXSkillProjectionConfidence as aw, KodaXSkillScriptInputFile as ax, KodaXSkillScriptOutputFile as ay, KodaXSkillScriptRunInput as az, BashPrefixResult as b, KodaXWorkflowTimeoutConfig as b0, LspServerInfo as b2, LspServiceConfig as b4, ProviderExecutionState as b5, ProviderRecoveryEvent as b6, ProviderResilienceConfig as b7, ProviderResiliencePolicy as b8, RecoveryAction as b9, WorkflowInvocationAction as bA, WorkflowInvocationPolicyDecision as bB, WorkflowInvocationPolicyInput as bC, WorkflowInvocationSource as bD, WorkflowStartOutcome as bE, WorkflowToolHost as bF, WorkflowToolHostInlineInput as bG, WorkflowToolHostResult as bH, WorkflowToolHostStartResult as bI, RecoveryDecision as ba, RecoveryLadderStep as bb, RecoveryResult as bc, ResilienceClassification as bd, ResilienceErrorClass as be, ResolveKodaXManualInput as bf, ResolveKodaXManualOptions as bg, ResolveKodaXManualResult as bh, RuntimeCompactionSkippedEvent as bi, RuntimeContextBudgetBreakdown as bj, RuntimeContextBudgetRecommendation as bk, RuntimeContextBudgetSnapshot as bl, RuntimeContextBudgetSnapshotInput as bm, RuntimeContextOptimizationProfile as bn, RuntimeContextPressure as bo, RuntimeDefaultsSnapshot as bp, RuntimeToolExposureDecision as bq, RuntimeToolExposureMode as br, RuntimeToolExposurePlan as bs, RuntimeToolExposurePlanInput as bt, RuntimeToolExposureReason as bu, TodoItem as bv, TodoList as bw, TodoStatus as bx, ToolSideEffect as by, WorkflowHostPolicy 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 };
+export { ALWAYS_RESIDENT_TOOL_NAMES as A, BASH_POLICY_SPEC as B, normalizeKodaXAgentMode as b$, LSP_SERVERS as b4, LspService as b6, buildGoalRuntimeBinding as bM, consumeCompactionCooldown as bN, createBashPrefixExtractor as bO, createCompactionAntiThrashState as bP, createExternalActorTurnExecutor as bQ, createLocalCodingActorControl as bR, createRuntimeContextBudgetSnapshot as bS, decideWorkflowInvocation as bT, drainPendingSwaps as bU, estimateToolSchemaTokens as bV, extractCommandPrefix as bW, getDefaultLspService as bX, hasExplicitNaturalLanguageWorkflowIntent as bY, hasPendingSwap as bZ, makeDisabledGoalToolsContext as b_, planToolExposure as c0, providerResilienceConfigFromTimeouts as c1, recordCompactionSavings as c2, resolveConstructedAgent as c3, shouldSkipLlmCompaction as c4, shutdownDefaultLspService as c5, withGoalBeforeNextTurn as c6, withGoalStopHook as c7, workflowStartOutcomeConsumesTurn as c8, CodingActorSession as d };
+export type { KodaXManualSource as $, CapabilityRuntimeContract as C, DiagnosticsRequest as D, ExtensionRuntimeContract as E, FailureStage as F, GoalBlockedResult as G, KodaXChildContextBundle as H, KodaXChildExecutionResult as I, KodaXCompactionEndResult as J, KodaXActivityEventMeta as K, KodaXCompactionFailureReason as L, KodaXCompactionOverride as M, KodaXContextCompactionFinishedEvent as N, KodaXContextIdentity as O, KodaXContextOptions as P, KodaXContextTokenSnapshot as Q, KodaXEffectiveTaskConfig as R, KodaXEvents as S, KodaXFileSystemEffectLease as T, KodaXLiveEventMeta as U, KodaXManagedBudgetSnapshot as V, KodaXManagedProtocolPayload as W, KodaXManagedTask as X, KodaXManagedTaskRuntimeState as Y, KodaXManagedTaskStatusEvent as Z, KodaXManualIndexTopic as _, BashPrefixExtractor as a, KodaXVerificationScorecard as a$, KodaXManualTopic as a0, KodaXManualTopicId as a1, KodaXManualTopicInput as a2, KodaXMemoryStrategy as a3, KodaXOptions as a4, KodaXOrchestrationVerdict as a5, KodaXParentReductionContract as a6, KodaXPreparedShellSandboxInvocation as a7, KodaXPromptCacheDiagnosticEvent as a8, KodaXProviderPolicyHints as a9, KodaXSkillScriptInputFile as aA, KodaXSkillScriptOutputFile as aB, KodaXSkillScriptRunInput as aC, KodaXSkillScriptRunner as aD, KodaXTaskCapabilityHint as aE, KodaXTaskContract as aF, KodaXTaskEvidenceArtifact as aG, KodaXTaskEvidenceBundle as aH, KodaXTaskEvidenceEntry as aI, KodaXTaskRole as aJ, KodaXTaskRoleAssignment as aK, KodaXTaskStatus as aL, KodaXTaskSurface as aM, KodaXTaskToolPolicy as aN, KodaXTaskVerificationContract as aO, KodaXTaskVerificationCriterion as aP, KodaXTaskWorkItem as aQ, KodaXTimeoutConfig as aR, KodaXToolEventMeta as aS, KodaXToolExecutionContext as aT, KodaXToolSandboxObservationUpdate as aU, KodaXToolVisibilityMeta as aV, KodaXToolVisibilityPolicy as aW, KodaXTurnCompletedEvent as aX, KodaXTurnDeliveryKind as aY, KodaXTurnFailedEvent as aZ, KodaXTurnStartedEvent as a_, KodaXRepoIntelligenceCapability as aa, KodaXRepoIntelligenceMode as ab, KodaXRepoIntelligenceResolvedMode as ac, KodaXRepoIntelligenceTrace as ad, KodaXRepoIntelligenceTraceEvent as ae, KodaXRepoRoutingSignals as af, KodaXResult as ag, KodaXRoleRoundSummary as ah, KodaXRuntimeVerificationContract as ai, KodaXSandboxOptions as aj, KodaXSelfManualConfig as ak, KodaXSessionControl as al, KodaXSessionMutators as am, KodaXSessionOptions as an, KodaXShellExecutionContract as ao, KodaXShellKind as ap, KodaXShellProfileMode as aq, KodaXShellSandbox as ar, KodaXShellSandboxBackend as as, KodaXShellSandboxObservation as at, KodaXShellSandboxPrepareInput as au, KodaXSidecarMessageEvent as av, KodaXSkillDynamicContextPolicy as aw, KodaXSkillInvocationContext as ax, KodaXSkillMap as ay, KodaXSkillProjectionConfidence as az, BashPrefixResult as b, KodaXVerificationScorecardCriterion as b0, KodaXWorkflowAgentDigestEvent as b1, KodaXWorkflowEventMeta as b2, KodaXWorkflowTimeoutConfig as b3, LspServerInfo as b5, LspServiceConfig as b7, ProviderExecutionState as b8, ProviderRecoveryEvent as b9, TodoStatus as bA, ToolSideEffect as bB, WorkflowHostPolicy as bC, WorkflowInvocationAction as bD, WorkflowInvocationPolicyDecision as bE, WorkflowInvocationPolicyInput as bF, WorkflowInvocationSource as bG, WorkflowStartOutcome as bH, WorkflowToolHost as bI, WorkflowToolHostInlineInput as bJ, WorkflowToolHostResult as bK, WorkflowToolHostStartResult as bL, ProviderResilienceConfig as ba, ProviderResiliencePolicy as bb, RecoveryAction as bc, RecoveryDecision as bd, RecoveryLadderStep as be, RecoveryResult as bf, ResilienceClassification as bg, ResilienceErrorClass as bh, ResolveKodaXManualInput as bi, ResolveKodaXManualOptions as bj, ResolveKodaXManualResult as bk, RuntimeCompactionSkippedEvent as bl, RuntimeContextBudgetBreakdown as bm, RuntimeContextBudgetRecommendation as bn, RuntimeContextBudgetSnapshot as bo, RuntimeContextBudgetSnapshotInput as bp, RuntimeContextOptimizationProfile as bq, RuntimeContextPressure as br, RuntimeDefaultsSnapshot as bs, RuntimeToolExposureDecision as bt, RuntimeToolExposureMode as bu, RuntimeToolExposurePlan as bv, RuntimeToolExposurePlanInput as bw, RuntimeToolExposureReason as bx, TodoItem as by, TodoList 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/{capsule.d-B7yoH4dM.d.ts → capsule.d-CN_iMqAS.d.ts}

@@ -1,5 +1,6 @@
 import { k as KodaXMessage } from './types.d-CgrXrFrq.js';
-import { ae as AgentMessage, ea as SessionEntry, e8 as Session, ec as SessionExtension, c1 as KodaXSessionLineage, bO as KodaXJsonValue, aW as CompactionDetails, bB as KodaXCompactMemorySeed, bZ as KodaXSessionEntry, cb as KodaXSessionTreeNode, c0 as KodaXSessionLabelEntry, b$ as KodaXSessionGoalEntry, bW as KodaXSessionClientNoticeEntry, c7 as KodaXSessionRewindMarkerEntry, c2 as KodaXSessionMemoryOutcomeDigestEntry, c3 as KodaXSessionMemoryReviewReceiptEntry, c6 as KodaXSessionNavigationOptions, bU as KodaXSessionArtifactLedgerEntry, bj as FileOperations, eW as WorkflowMeta, eX as WorkflowModelHint, eY as WorkflowModule } from './controller.d-CYNuR2n9.js';
+import { P as AgentMessage, cd as SessionEntry, cb as Session, ce as SessionExtension, ai as CompactionDetails, aH as FileOperations, cY as WorkflowMeta, cZ as WorkflowModelHint, c_ as WorkflowModule } from './controller.d-Dzxz22X-.js';
+import { ab as KodaXSessionLineage, Y as KodaXJsonValue, P as KodaXCompactMemorySeed, a7 as KodaXSessionEntry, al as KodaXSessionTreeNode, aa as KodaXSessionLabelEntry, a9 as KodaXSessionGoalEntry, a4 as KodaXSessionClientNoticeEntry, ah as KodaXSessionRewindMarkerEntry, ac as KodaXSessionMemoryOutcomeDigestEntry, ad as KodaXSessionMemoryReviewReceiptEntry, ag as KodaXSessionNavigationOptions, a2 as KodaXSessionArtifactLedgerEntry } from './types.d-DlLBRqZ9.js';
 
 /**
  * @kodax-ai/agent Constants

package/dist/types-chunks/controller.d-A73Kf6tH.d.ts

@@ -0,0 +1,105 @@
+import { aE as MemoryContextIdentity, aM as MemoryItemRef, ab as KodaXSessionLineage, a2 as KodaXSessionArtifactLedgerEntry, aI as MemoryEvent, b5 as MemoryReviewRunner, aP as MemoryManagementController, au as MemoryActionProposal, ax as MemoryApplyResult, aX as MemoryRejectResult, aV as MemoryRefFilter, aC as MemoryBodySnapshot, aY as MemoryRememberInput, aZ as MemoryRememberResult, aO as MemoryLifecycleOperationResult, aG as MemoryCuratorInput, aL as MemoryGovernanceReport, aA as MemoryAutoCuratorInput, aB as MemoryAutoCuratorResult, aS as MemoryPackInput, aQ as MemoryPack, b0 as MemoryReviewInput, b4 as MemoryReviewPlan, $ as KodaXMemoryOutcomeDigest, b1 as MemoryReviewModelInput, aH as MemoryEpisodeReviewResult } from './types.d-DlLBRqZ9.js';
+
+interface CreateMemoryControlPlaneOptions {
+    readonly cwd: string;
+    readonly identity?: MemoryContextIdentity;
+    readonly learningStorePath?: string;
+    readonly memoryRoot?: string;
+    readonly projectDocs?: readonly string[];
+    readonly extraRefs?: readonly MemoryItemRef[];
+    readonly sessionId?: string;
+    readonly sessionLineage?: KodaXSessionLineage;
+    readonly artifactLedger?: readonly KodaXSessionArtifactLedgerEntry[];
+    readonly now?: () => string;
+    readonly onEvent?: (event: MemoryEvent) => void;
+    readonly discoverSkills?: boolean;
+    readonly memoryReviewer?: MemoryReviewRunner;
+}
+declare function createMemoryControlPlane(options: CreateMemoryControlPlaneOptions): MemoryManagementController;
+declare class MemoryControlPlane implements MemoryManagementController {
+    private readonly cwd;
+    private readonly learningStorePath;
+    private readonly memoryRoot;
+    private readonly now;
+    private readonly onEvent?;
+    private readonly projectDocs;
+    private readonly extraRefs;
+    private readonly sessionId;
+    private readonly sessionLineage?;
+    private readonly artifactLedger;
+    private readonly discoverSkills;
+    private readonly memoryReviewer?;
+    private readonly identity?;
+    private readonly applicability?;
+    private readonly scopedRoots;
+    constructor(options: CreateMemoryControlPlaneOptions);
+    listInbox(): Promise<readonly MemoryActionProposal[]>;
+    showProposal(id: string): Promise<MemoryActionProposal | undefined>;
+    listHostAppliedEpisodeProposalIds(proposalIds: readonly string[]): Promise<readonly string[]>;
+    approveProposal(id: string, expectedFingerprints: Readonly<Record<string, string>>, expectedRevision?: string): Promise<MemoryApplyResult>;
+    private approveProposalWithLock;
+    rejectProposal(id: string, reason?: string, expectedRevision?: string): Promise<MemoryRejectResult>;
+    private rejectProposalWithLocks;
+    private reviewRejectedProposal;
+    private proposalDecisionLockPath;
+    listRefs(filter?: MemoryRefFilter): Promise<readonly MemoryItemRef[]>;
+    readRef(ref: MemoryItemRef): Promise<MemoryBodySnapshot>;
+    remember(input: MemoryRememberInput): Promise<MemoryRememberResult>;
+    private explicitMemoryLockPath;
+    private rememberWithLock;
+    private inspectMemoryRemember;
+    private resolveRememberDuplicate;
+    private findRememberDuplicate;
+    private applyExplicitMemoryRemember;
+    private mapExplicitMemoryResult;
+    private findRememberedRefIds;
+    archiveRef(id: string): Promise<MemoryLifecycleOperationResult>;
+    private archiveRefWithLock;
+    forgetRef(id: string, expectedBodyFingerprint?: string): Promise<MemoryLifecycleOperationResult>;
+    purgeRef(id: string): Promise<MemoryLifecycleOperationResult>;
+    private removeManagedRef;
+    runCurator(input?: MemoryCuratorInput): Promise<MemoryGovernanceReport>;
+    maybeRunAutoCurator(input?: MemoryAutoCuratorInput): Promise<MemoryAutoCuratorResult>;
+    buildMemoryPack(input: MemoryPackInput): Promise<MemoryPack>;
+    reviewMemoryFeedback(input: MemoryReviewInput): Promise<MemoryReviewPlan>;
+    prepareEpisodeReview(digest: KodaXMemoryOutcomeDigest): Promise<MemoryReviewModelInput>;
+    private prepareReviewInput;
+    persistReviewPlan(plan: MemoryReviewPlan): Promise<readonly string[]>;
+    private persistReviewPlanWithDecisions;
+    private resolveReviewMemoryPlacement;
+    private customRootPlacement;
+    private existingRefPlacement;
+    private newClaimPlacement;
+    private procedurePromotionStorePath;
+    private projectPlacement;
+    reviewEpisode(digest: KodaXMemoryOutcomeDigest, signal?: AbortSignal): Promise<MemoryEpisodeReviewResult>;
+    applyReviewedEpisode(reviewedPlan: MemoryReviewPlan, digest: KodaXMemoryOutcomeDigest, signal?: AbortSignal, revalidateAuthority?: () => Promise<void>): Promise<MemoryEpisodeReviewResult>;
+    private applyReviewedEpisodeWithLock;
+    private consultReviewAction;
+    private applyHostEligibleProposal;
+    private staleProposalClaimReason;
+    private projectLearningProposal;
+    private projectMemdirHandoff;
+    private projectReasoningHandoff;
+    private listLearningRefs;
+    private readLearningRef;
+    private listProjectDocRefs;
+    private listSessionTraceRefs;
+    private listArtifactLedgerRefs;
+    private readSessionTraceRef;
+    private readArtifactLedgerRef;
+    private listSkillRefs;
+    private buildPackHints;
+    private selectReviewCandidateRefs;
+    private readReviewCandidateRef;
+    private adapterForProposal;
+    private memdirAdapter;
+    private memdirAdapters;
+    private memoryRootForHandoff;
+    private memoryRootForRef;
+    private emit;
+    private buildGovernanceReport;
+}
+
+export { MemoryControlPlane as M, createMemoryControlPlane as c };
+export type { CreateMemoryControlPlaneOptions as C };