@kodax-ai/kodax 0.7.93 → 0.7.95

package/dist/types-chunks/{run-manager.d-BeSEc2OL.d.ts → run-manager.d-BVJSntpS.d.ts}

@@ -1,4 +1,4 @@
-import { W as WorkflowProcessTrackerOptions, a as WorkflowEvent, b as WorkflowProcessSnapshot, c as WorkflowProcessEvent } from './controller.d-Bm1i9RVj.js';
+import { dk as WorkflowProcessTrackerOptions, cS as WorkflowEvent, de as WorkflowProcessSnapshot, d8 as WorkflowProcessEvent } from './controller.d-C5noq5-w.js';
 
 /**
  * FEATURE_246 Part A0 (ADR-046) — neutral workflow run lifecycle manager.
@@ -88,4 +88,4 @@ declare function createWorkflowRunManager(deps?: {
 declare function getDefaultWorkflowRunManager(): WorkflowRunManager;
 
 export { createWorkflowRunManager as f, getDefaultWorkflowRunManager as g };
-export type { ManagedWorkflowStatus as M, StartManagedRunInput as S, WorkflowProcessMetadata as W, ManagedWorkflowSnapshot as a, ManagedRunClassification as b, ManagedRunHooks as c, ManagedWorkflowRun as d, WorkflowRunManager as e };
+export type { ManagedRunClassification as M, StartManagedRunInput as S, WorkflowProcessMetadata as W, ManagedRunHooks as a, ManagedWorkflowRun as b, ManagedWorkflowSnapshot as c, ManagedWorkflowStatus as d, WorkflowRunManager as e };

package/dist/types-chunks/{sdk-session-BTzblJTQ.d.ts → sdk-session-CqEG84oP.d.ts}

@@ -1,6 +1,6 @@
-import { j as CreatableHistoryItem, T as ToolCall } from './public-api.d-BsZWOq3P.js';
-import { b as KodaXMessage, q as KodaXContentBlock } from './types.d-Cv09EdJR.js';
-import { S as KodaXSessionUiHistoryItem, W as KodaXSessionUiToolCall } from './types.d-EjZTEEVu.js';
+import { h as CreatableHistoryItem, ar as ToolCall } from './public-api.d-D7fXaWW8.js';
+import { k as KodaXMessage, c as KodaXContentBlock } from './types.d-CK9A9rpP.js';
+import { aq as KodaXSessionUiHistoryItem, au as KodaXSessionUiToolCall } from './types.d-rUOjXych.js';
 
 interface RestoreHistoryItemsFromSessionInput {
     messages: readonly KodaXMessage[];

package/dist/types-chunks/sdk-skills-DokfOoJF.d.ts

@@ -0,0 +1,335 @@
+import { R as ResolvedSkillSource, S as Skill, e as SkillFile, i as SkillMetadata, f as SkillFrontmatter, j as SkillPathsConfig, a as IVariableResolver, c as SkillContext, I as ISkillRegistry, k as SkillResult } from './types.d-Cb8RdrjU.js';
+
+declare function registerPluginSkillPath(skillPath: string): () => void;
+declare function unregisterPluginSkillPath(skillPath: string): boolean;
+declare function listPluginSkillPaths(): string[];
+declare function clearPluginSkillPaths(): void;
+
+/**
+ * Skill Loader - YAML Frontmatter Parsing and Skill Loading
+ *
+ * Parses SKILL.md files with YAML frontmatter and loads skill content.
+ * Implements fallback sanitization for non-standard YAML formats.
+ */
+
+/**
+ * Parse SKILL.md file with YAML frontmatter
+ */
+declare function parseSkillMarkdown(content: string): {
+    frontmatter: SkillFrontmatter;
+    body: string;
+};
+/**
+ * Load skill metadata from SKILL.md file
+ */
+declare function loadSkillMetadata(skillDir: string, source: ResolvedSkillSource): Promise<SkillMetadata | null>;
+/**
+ * Load full skill content
+ */
+declare function loadFullSkill(skillDir: string, source: ResolvedSkillSource): Promise<Skill | null>;
+/**
+ * Load a specific support file's content
+ */
+declare function loadSkillFileContent(file: SkillFile): Promise<string>;
+
+/**
+ * Skill Discovery - Multi-path skill scanning
+ *
+ * Discovers skills from multiple paths with priority handling.
+ * Supports nested directory discovery for monorepos.
+ */
+
+/**
+ * Result of skill discovery
+ */
+interface DiscoveryResult {
+    skills: Map<string, SkillMetadata>;
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+/**
+ * Discover all skills from configured paths
+ */
+declare function discoverSkills(projectRoot?: string, customPaths?: Partial<SkillPathsConfig>): Promise<DiscoveryResult>;
+/**
+ * Get nested skill paths for monorepo support
+ * When in a subdirectory, also check parent directories for skills
+ */
+declare function getNestedSkillPaths(currentDir: string, projectRoot: string): string[];
+/**
+ * Discover skills with monorepo support
+ */
+declare function discoverSkillsWithMonorepo(currentDir: string, projectRoot: string): Promise<DiscoveryResult>;
+
+/**
+ * Skill Resolver - Variable Replacement System
+ *
+ * Handles variable replacement in skill content:
+ * - $ARGUMENTS - All arguments
+ * - $0, $1, $2... - Positional arguments
+ * - ${VAR_NAME} - Environment variables
+ * - !`command` - Dynamic context injection
+ */
+
+/**
+ * Split arguments string into positional arguments
+ * Handles quoted strings correctly
+ */
+declare function parseArguments(args: string): string[];
+/**
+ * Variable resolver implementation
+ */
+declare class VariableResolver implements IVariableResolver {
+    private context;
+    constructor(context: SkillContext);
+    /**
+     * Resolve all variables in content
+     */
+    resolve(content: string, args: string): Promise<string>;
+    /**
+     * Replace $0, $1, $2... with positional arguments
+     */
+    private resolvePositionalArgs;
+    /**
+     * Replace $ARGUMENTS with all arguments
+     */
+    private resolveArguments;
+    /**
+     * Replace ${VAR_NAME} with environment variables
+     */
+    private resolveEnvVars;
+    /**
+     * Replace !`command` with command output (dynamic context).
+     *
+     * Three-tier dispatch (v0.7.42):
+     *   1. `context.disableDynamicContext === true` → throw immediately,
+     *      surfaced to the LLM as `[Error: …]`. Host-level kill switch.
+     *   2. `context.executeDynamicContext` provided → route there. Embedder
+     *      mediates shell execution (broker, audit, deny).
+     *   3. else → legacy built-in path (`isSafeDynamicContextCommand`
+     *      whitelist + `execSync` with 5s timeout).
+     *
+     * The resolver inlines an `[Error: …]` placeholder for any thrown
+     * exception so a single bad token doesn't poison the whole skill load.
+     */
+    private resolveDynamicContext;
+    /**
+     * Execute a dynamic context command via the appropriate dispatch tier.
+     * See `resolveDynamicContext` JSDoc for the 3-tier ordering rationale.
+     */
+    private executeDynamicCommand;
+}
+/**
+ * Create a variable resolver for a given context
+ */
+declare function createResolver(context: SkillContext): IVariableResolver;
+/**
+ * Resolve skill content with arguments and context
+ */
+declare function resolveSkillContent(content: string, args: string, context: SkillContext): Promise<string>;
+
+/**
+ * Skill Registry - Progressive Disclosure and Skill Management
+ *
+ * Manages skill discovery, loading, and invocation with progressive disclosure:
+ * - Level 1: Metadata preloaded at startup (name, description)
+ * - Level 2: Full content loaded on invoke
+ * - Level 3: Support files loaded on demand
+ */
+
+/** Format the model-visible Skill catalog from an arbitrary trusted registry. */
+declare function formatSkillsSystemPrompt(skills: readonly SkillMetadata[]): string;
+/**
+ * Skill Registry implementation
+ */
+declare class SkillRegistry implements ISkillRegistry {
+    private readonly skillsByName;
+    private readonly fullSkillsByName;
+    private readonly projectRoot?;
+    private readonly customPaths?;
+    constructor(projectRoot?: string, customPaths?: Partial<SkillPathsConfig>);
+    /**
+     * Discover skills from all configured paths
+     */
+    discover(): Promise<void>;
+    /**
+     * Get skill metadata by name
+     */
+    get skills(): ReadonlyMap<string, SkillMetadata>;
+    /**
+     * Get skill metadata by name
+     */
+    get(name: string): SkillMetadata | undefined;
+    /**
+     * Load full skill content
+     */
+    loadFull(name: string): Promise<Skill>;
+    /**
+     * Explicitly invoke a skill with arguments. Model tool admission is enforced
+     * by the coding-layer `skill` tool before it reaches this SDK primitive.
+     */
+    invoke(name: string, args: string, context: SkillContext): Promise<SkillResult>;
+    /**
+     * Reload skills from disk
+     */
+    reload(): Promise<void>;
+    /**
+     * List all available skills
+     */
+    list(): SkillMetadata[];
+    /**
+     * List user-invocable skills (for / menu)
+     */
+    listUserInvocable(): SkillMetadata[];
+    /**
+     * Get skills formatted for system prompt injection.
+     *
+     * FEATURE_143 (v0.7.36): manifest wording hardened toward Claude
+     * Code-style strong constraints. The previous wording ("when a user
+     * request matches a skill description, use read to load the skill")
+     * was too soft — the LLM treated skill invocation as one option among
+     * many and frequently authored its own answer instead of loading the
+     * SKILL.md instructions. Aligns with the
+     * `c:/Works/claudecode/src/tools/SkillTool/prompt.ts` ruleset:
+     * BLOCKING REQUIREMENT to load the relevant skill BEFORE generating
+     * any other response when a skill matches.
+     *
+     * Filters out skills with disableModelInvocation=true (Issue 056).
+     */
+    getSystemPromptSnippet(): string;
+    /**
+     * Check if a name is a valid skill
+     */
+    has(name: string): boolean;
+    /**
+     * Get the count of discovered skills
+     */
+    get size(): number;
+}
+/**
+ * Get the global skill registry instance
+ *
+ * IMPORTANT: If projectRoot is undefined, returns existing instance without reset.
+ * This prevents accidental singleton reset when called without arguments.
+ */
+declare function getSkillRegistry(projectRoot?: string, customPaths?: Partial<SkillPathsConfig>): SkillRegistry;
+/**
+ * Initialize the skill registry and discover skills
+ */
+declare function initializeSkillRegistry(projectRoot?: string, customPaths?: Partial<SkillPathsConfig>): Promise<SkillRegistry>;
+/**
+ * Reset the global registry (for testing or hot reload)
+ */
+declare function resetSkillRegistry(): void;
+
+/**
+ * Skill Executor - Execution Engine
+ *
+ * Handles skill execution with support for:
+ * - Inline execution (default)
+ * - Fork execution (sub-agent)
+ * - Tool restrictions
+ */
+
+/**
+ * Execution mode
+ */
+type ExecutionMode = 'inline' | 'fork';
+/**
+ * Execution options
+ */
+interface ExecutionOptions {
+    /** Force a specific execution mode */
+    mode?: ExecutionMode;
+    /** Override model */
+    model?: string;
+    /** Override agent type (for fork mode) */
+    agent?: string;
+    /** Override allowed tools */
+    allowedTools?: string[];
+    /** Callback for inline execution */
+    onExecute?: (content: string, skill: Skill) => Promise<string>;
+}
+/**
+ * Skill executor class
+ */
+declare class SkillExecutor {
+    private context;
+    constructor(context: SkillContext);
+    /**
+     * Execute a skill
+     */
+    execute(skillName: string, args: string, options?: ExecutionOptions): Promise<SkillResult>;
+    /**
+     * Execute skill inline (in current context)
+     */
+    private executeInline;
+    /**
+     * Execute skill in fork mode (sub-agent)
+     */
+    private executeFork;
+    /**
+     * Build the execution prompt
+     */
+    private buildPrompt;
+    /**
+     * Parse allowed tools string into array
+     */
+    private parseAllowedTools;
+}
+/**
+ * Create a skill executor
+ */
+declare function createExecutor(context: SkillContext): SkillExecutor;
+/**
+ * Execute a skill with default context
+ */
+declare function executeSkill(skillName: string, args: string, context: SkillContext, options?: ExecutionOptions): Promise<SkillResult>;
+
+/**
+ * Skill Expander - Expand skill commands for LLM context injection
+ *
+ * Takes a skill invocation and produces content that can be injected
+ * into the user message for LLM execution.
+ *
+ * Design based on pi-mono's _expandSkillCommand:
+ * - Wraps content in XML blocks for clear context
+ * - Includes skill metadata (name, location)
+ * - Resolves all variables ($ARGUMENTS, $0, etc.)
+ * - Handles dynamic context (!`command`)
+ */
+
+/**
+ * Result of skill expansion
+ */
+interface SkillExpansionResult {
+    /** The expanded skill content ready for LLM injection */
+    content: string;
+    /** Whether the skill has model invocation disabled */
+    disableModelInvocation: boolean;
+    /** Original skill metadata */
+    skill: Skill;
+}
+/**
+ * Expand a skill into LLM-ready content
+ *
+ * This function:
+ * 1. Resolves all variables in the skill content ($ARGUMENTS, $0, $1, etc.)
+ * 2. Executes dynamic context commands (!`command`)
+ * 3. Wraps the content in an XML block for clear context boundaries
+ *
+ * @param skill - The full skill object with content
+ * @param args - Raw arguments string from user input
+ * @param context - Execution context (working directory, session ID, etc.)
+ * @returns Expansion result with content ready for LLM injection
+ */
+declare function expandSkillForLLM(skill: Skill, args: string, context: SkillContext): Promise<SkillExpansionResult>;
+/**
+ * Format skill activation message for user display
+ */
+declare function formatSkillActivationMessage(skillName: string, args: string): string;
+
+export { SkillExecutor as S, VariableResolver as V, SkillRegistry as c, clearPluginSkillPaths as d, createExecutor as e, createResolver as f, discoverSkills as g, discoverSkillsWithMonorepo as h, executeSkill as i, expandSkillForLLM as j, formatSkillActivationMessage as k, formatSkillsSystemPrompt as l, getNestedSkillPaths as m, getSkillRegistry as n, initializeSkillRegistry as o, listPluginSkillPaths as p, loadFullSkill as q, loadSkillFileContent as r, loadSkillMetadata as s, parseArguments as t, parseSkillMarkdown as u, registerPluginSkillPath as v, resetSkillRegistry as w, resolveSkillContent as x, unregisterPluginSkillPath as y };
+export type { DiscoveryResult as D, ExecutionMode as E, ExecutionOptions as a, SkillExpansionResult as b };

package/dist/types-chunks/{shell-command-sets.d-C2cc9Hwi.d.ts → shell-command-sets.d-DqaaBwhU.d.ts}

@@ -1,4 +1,4 @@
-import { R as RunScopedToolDefinition, B as BashPrefixExtractor } from './bash-prefix-extractor.d-BMi_TJIY.js';
+import { bx as RunScopedToolDefinition, a as BashPrefixExtractor } from './bash-prefix-extractor.d-B2rxNI4L.js';
 
 /**
  * Permission Utilities

package/dist/types-chunks/{side-query.d-DNes6rHA.d.ts → side-query.d-iH0P9ASy.d.ts}

@@ -1,6 +1,6 @@
-import { b as KodaXMessage, c as KodaXReasoningRequest, d as KodaXTokenUsage } from './types.d-Cv09EdJR.js';
-import { K as KodaXBaseProvider } from './base.d-JjF6aKsh.js';
-import { C as CostTracker } from './cost-tracker.d-MTAt6N7b.js';
+import { k as KodaXMessage, I as KodaXReasoningRequest, a1 as KodaXTokenUsage } from './types.d-CK9A9rpP.js';
+import { K as KodaXBaseProvider } from './base.d-vopO1rml.js';
+import { a as CostTracker } from './cost-tracker.d-BeaenODW.js';
 
 /**
  * sideQuery — independent one-shot LLM invocation.

package/dist/types-chunks/{types-D8OiIEwA.d.ts → types-PHjfwebT.d.ts}

@@ -531,4 +531,4 @@ interface CreateMemoryManagementAgentOptions extends Omit<CreateMemoryAgentOptio
     readonly controlPlane: MemoryManagementController;
 }
 
-export type { AcceptedMemoryView as A, CreateMemoryManagementAgentOptions as C, KodaXHandledMemoryOperation as K, MemoryManagementAgent as M, PersistedOutcomeDigest as P, CreateMemoryAgentOptions as a, MemoryAgent as b, MemoryAgentTraceEvent as c, MemoryDecisionReceipt as d, MemoryEpisodeOutcome as e, MemoryEvidenceGrade as f, MemoryEvidenceRef as g, MemoryInterventionInput as h, MemoryInterventionTrigger as i, MemoryListFilter as j, MemoryObservation as k, MemoryObservationKind as l, MemoryQueryInput as m, MemoryRecallCandidate as n, MemoryRecallInput as o, MemoryRecallRunner as p, MemoryRecallRunnerInput as q, MemoryReminder as r, MemorySelectionMode as s, MemorySession as t, MemorySessionInput as u, MemorySourcePolicy as v };
+export type { AcceptedMemoryView as A, CreateMemoryAgentOptions as C, KodaXHandledMemoryOperation as K, MemoryAgent as M, PersistedOutcomeDigest as P, CreateMemoryManagementAgentOptions as a, MemoryAgentTraceEvent as b, MemoryDecisionReceipt as c, MemoryEpisodeOutcome as d, MemoryEvidenceGrade as e, MemoryEvidenceRef as f, MemoryInterventionInput as g, MemoryInterventionTrigger as h, MemoryListFilter as i, MemoryManagementAgent as j, MemoryObservation as k, MemoryObservationKind as l, MemoryQueryInput as m, MemoryRecallCandidate as n, MemoryRecallInput as o, MemoryRecallRunner as p, MemoryRecallRunnerInput as q, MemoryReminder as r, MemorySelectionMode as s, MemorySession as t, MemorySessionInput as u, MemorySourcePolicy as v };

package/dist/types-chunks/{types.d-DrtP1ceI.d.ts → types.d-C5xQEFcj.d.ts}

@@ -1,8 +1,8 @@
-import { n as KodaXWireReasoningEffort, f as KodaXToolDefinition, R as KodaXToolResultContentItem, b as KodaXMessage } from './types.d-Cv09EdJR.js';
-import { K as KodaXBaseProvider } from './base.d-JjF6aKsh.js';
+import { aa as KodaXWireReasoningEffort, a2 as KodaXToolDefinition, a4 as KodaXToolResultContentItem, k as KodaXMessage } from './types.d-CK9A9rpP.js';
+import { K as KodaXBaseProvider } from './base.d-vopO1rml.js';
 import { C as CapabilityKind, a as CapabilityProvider } from './capability.d-K664nHOS.js';
-import { C as KodaXJsonValue, A as KodaXExtensionSessionRecord, a1 as KodaXExtensionStore } from './types.d-EjZTEEVu.js';
-import { aY as KodaXToolExecutionContext, bH as ToolSideEffect } from './bash-prefix-extractor.d-BMi_TJIY.js';
+import { a0 as KodaXJsonValue, U as KodaXExtensionSessionRecord, W as KodaXExtensionStore } from './types.d-rUOjXych.js';
+import { b1 as KodaXToolExecutionContext, bO as ToolSideEffect } from './bash-prefix-extractor.d-B2rxNI4L.js';
 
 /**
  * KodaX Constructed-World types (FEATURE_087, v0.7.28).
@@ -1008,5 +1008,5 @@ interface KodaXExtensionModule {
     activate?: (api: KodaXExtensionAPI) => KodaXExtensionActivationResult;
 }
 
-export { DEFAULT_HANDLER_TIMEOUT_MS as D, defaultPolicy as a3, exec as a4, webhook as a5, CapabilityDeniedError as b, ConstructionManifestError as d };
-export type { ToolRegistrationOptions as $, AgentArtifact as A, KodaXRetrievalResult as B, Capabilities as C, ExecOptions as E, KodaXRetrievalScope as F, KodaXRetrievalToolName as G, KodaXRetrievalTrust as H, LocalToolDefinition as I, RegisteredCommandDiagnostic as J, KodaXExtensionAPI as K, LoadedExtensionDiagnostic as L, ModelProviderRegistration as M, RegisteredHookDiagnostic as N, RegisteredToolDefinition as O, RegisteredToolDiagnostic as P, RuntimeRemoteToolContext as Q, RegisteredCapabilityProviderDiagnostic as R, RuntimeRemoteToolContract as S, RuntimeRemoteToolDecision as T, RuntimeRemoteWorkspaceBroker as U, ScriptSource as V, StagedHandle as W, TestResult as X, ToolContent as Y, ToolDefinitionSource as Z, ToolHandler as _, ArtifactStatus as a, ToolRegistry as a0, WebhookOptions as a1, WebhookResult as a2, AgentContent as a6, ToolHandlerSync as a7, ConstructionArtifact as c, ConstructionPolicy as e, ConstructionPolicyVerdict as f, ExecResult as g, ExtensionCommandContext as h, ExtensionCommandDefinition as i, ExtensionCommandInvocation as j, ExtensionCommandResult as k, ExtensionContributionSource as l, ExtensionEventMap as m, ExtensionFailureDiagnostic as n, ExtensionFailureStage as o, ExtensionHookMap as p, ExtensionLoadSource as q, ExtensionLogger as r, ExtensionRuntimeController as s, ExtensionRuntimeDiagnostics as t, ExtensionToolBeforeHookContext as u, KodaXExtensionActivationResult as v, KodaXExtensionModule as w, KodaXRetrievalArtifact as x, KodaXRetrievalFreshness as y, KodaXRetrievalItem as z };
+export { DEFAULT_HANDLER_TIMEOUT_MS as D, defaultPolicy as a5, exec as a6, webhook as a7, CapabilityDeniedError as c, ConstructionManifestError as e };
+export type { ToolHandler as $, AgentArtifact as A, KodaXRetrievalItem as B, Capabilities as C, ExecOptions as E, KodaXRetrievalResult as F, KodaXRetrievalScope as G, KodaXRetrievalToolName as H, KodaXRetrievalTrust as I, LocalToolDefinition as J, KodaXExtensionAPI as K, LoadedExtensionDiagnostic as L, ModelProviderRegistration as M, RegisteredCommandDiagnostic as N, RegisteredHookDiagnostic as O, RegisteredToolDefinition as P, RegisteredToolDiagnostic as Q, RegisteredCapabilityProviderDiagnostic as R, RuntimeRemoteToolContext as S, RuntimeRemoteToolContract as T, RuntimeRemoteToolDecision as U, RuntimeRemoteWorkspaceBroker as V, ScriptSource as W, StagedHandle as X, TestResult as Y, ToolContent as Z, ToolDefinitionSource as _, AgentContent as a, ToolHandlerSync as a0, ToolRegistrationOptions as a1, ToolRegistry as a2, WebhookOptions as a3, WebhookResult as a4, ArtifactStatus as b, ConstructionArtifact as d, ConstructionPolicy as f, ConstructionPolicyVerdict as g, ExecResult as h, ExtensionCommandContext as i, ExtensionCommandDefinition as j, ExtensionCommandInvocation as k, ExtensionCommandResult as l, ExtensionContributionSource as m, ExtensionEventMap as n, ExtensionFailureDiagnostic as o, ExtensionFailureStage as p, ExtensionHookMap as q, ExtensionLoadSource as r, ExtensionLogger as s, ExtensionRuntimeController as t, ExtensionRuntimeDiagnostics as u, ExtensionToolBeforeHookContext as v, KodaXExtensionActivationResult as w, KodaXExtensionModule as x, KodaXRetrievalArtifact as y, KodaXRetrievalFreshness as z };

package/dist/types-chunks/{types.d-Cv09EdJR.d.ts → types.d-CK9A9rpP.d.ts}

@@ -671,4 +671,4 @@ interface KodaXProviderStreamOptions {
     signal?: AbortSignal;
 }
 
-export type { KodaXProviderContextFidelity as $, KodaXReasoningEffortWireStrategy as A, KodaXRedactedThinkingBlock as B, KodaXReviewScale as C, KodaXRiskLevel as D, KodaXStableEffortIntent as E, KodaXTaskBudgetOverrides as F, KodaXTaskResultSource as G, KodaXTaskRoutingDecision as H, KodaXTaskType as I, KodaXTextBlock as J, KodaXReasoningProfile as K, KodaXThinkingBlock as L, KodaXThinkingBudgetMap as M, KodaXThinkingDepth as N, KodaXThinkingWireStrategy as O, KodaXToolResultBlock as P, KodaXToolUseBlock as Q, KodaXToolResultContentItem as R, KodaXOpenAICompatMaxOutputTokensField as S, KodaXVerifyStrategy as T, KodaXListModelsResult as U, KodaXCacheBoundary as V, KodaXAssuranceIntent as W, KodaXEphemeralSuffix as X, KodaXExecutionPattern as Y, KodaXHarnessProfile as Z, KodaXMutationSurface as _, KodaXTaskResultMetadata as a, KodaXProviderEvidenceSupport as a0, KodaXProviderLongRunningSupport as a1, KodaXProviderMultimodalSupport as a2, KodaXProviderSessionSupport as a3, KodaXProviderToolCallingFidelity as a4, KodaXTaskActionability as a5, KodaXTaskComplexity as a6, KodaXTaskFamily as a7, KodaXTaskWorkIntent as a8, KodaXToolResultImageItem as a9, KodaXToolResultTextItem as aa, KodaXMessage as b, KodaXReasoningRequest as c, KodaXTokenUsage as d, KodaXProviderConfig as e, KodaXToolDefinition as f, KodaXProviderStreamOptions as g, KodaXStreamResult as h, KodaXVerifyCredentialResult as i, KodaXModelDescriptor as j, KodaXProviderCapabilityProfile as k, KodaXReasoningCapability as l, KodaXNormalizedReasoningRequest as m, KodaXWireReasoningEffort as n, KodaXReasoningMode as o, KodaXChildFanoutClass as p, KodaXContentBlock as q, KodaXCustomProviderConfig as r, KodaXExecutionMode as s, KodaXImageBlock as t, KodaXProtocolFamily as u, KodaXProviderConversationSemantics as v, KodaXProviderMcpSupport as w, KodaXProviderTransport as x, KodaXReasoningEffortPreset as y, KodaXReasoningEffortRequest as z };
+export type { KodaXThinkingDepth as $, KodaXProviderToolCallingFidelity as A, KodaXProviderTransport as B, KodaXReasoningCapability as C, KodaXReasoningEffortPreset as D, KodaXReasoningEffortRequest as E, KodaXReasoningEffortWireStrategy as F, KodaXReasoningMode as G, KodaXReasoningProfile as H, KodaXReasoningRequest as I, KodaXRedactedThinkingBlock as J, KodaXAssuranceIntent as K, KodaXReviewScale as L, KodaXRiskLevel as M, KodaXStableEffortIntent as N, KodaXStreamResult as O, KodaXTaskActionability as P, KodaXTaskBudgetOverrides as Q, KodaXTaskComplexity as R, KodaXTaskFamily as S, KodaXTaskResultMetadata as T, KodaXTaskResultSource as U, KodaXTaskRoutingDecision as V, KodaXTaskType as W, KodaXTaskWorkIntent as X, KodaXTextBlock as Y, KodaXThinkingBlock as Z, KodaXThinkingBudgetMap as _, KodaXCacheBoundary as a, KodaXThinkingWireStrategy as a0, KodaXTokenUsage as a1, KodaXToolDefinition as a2, KodaXToolResultBlock as a3, KodaXToolResultContentItem as a4, KodaXToolResultImageItem as a5, KodaXToolResultTextItem as a6, KodaXToolUseBlock as a7, KodaXVerifyCredentialResult as a8, KodaXVerifyStrategy as a9, KodaXWireReasoningEffort as aa, KodaXChildFanoutClass as b, KodaXContentBlock as c, KodaXCustomProviderConfig as d, KodaXEphemeralSuffix as e, KodaXExecutionMode as f, KodaXExecutionPattern as g, KodaXHarnessProfile as h, KodaXImageBlock as i, KodaXListModelsResult as j, KodaXMessage as k, KodaXModelDescriptor as l, KodaXMutationSurface as m, KodaXNormalizedReasoningRequest as n, KodaXOpenAICompatMaxOutputTokensField as o, KodaXProtocolFamily as p, KodaXProviderCapabilityProfile as q, KodaXProviderConfig as r, KodaXProviderContextFidelity as s, KodaXProviderConversationSemantics as t, KodaXProviderEvidenceSupport as u, KodaXProviderLongRunningSupport as v, KodaXProviderMcpSupport as w, KodaXProviderMultimodalSupport as x, KodaXProviderSessionSupport as y, KodaXProviderStreamOptions as z };

package/dist/types-chunks/{types.d-Dc3kwcjC.d.ts → types.d-CaTXAW_Q.d.ts}

@@ -1,5 +1,5 @@
-import { K as KodaXInputArtifact } from './controller.d-Bm1i9RVj.js';
-import { a as KodaXTaskResultMetadata } from './types.d-Cv09EdJR.js';
+import { a$ as KodaXInputArtifact } from './controller.d-C5noq5-w.js';
+import { T as KodaXTaskResultMetadata } from './types.d-CK9A9rpP.js';
 
 /**
  * @kodax-ai/agent/messaging — Message queue types
@@ -17,6 +17,13 @@ import { a as KodaXTaskResultMetadata } from './types.d-Cv09EdJR.js';
  */
 
 type MessagePriority = 'user' | 'background';
+/**
+ * Delivery owner for user prompts. Ordinary messages are runtime-deliverable.
+ * `host` is reserved for prompts that must re-enter a trusted host command
+ * pipeline (for example an explicit user Skill invocation) before any model
+ * can observe them.
+ */
+type MessageDelivery = 'runtime' | 'host';
 /**
  * Delivery semantics, independent of priority:
  * - `prompt`: user-authored input; delivered as a real user turn.
@@ -40,6 +47,8 @@ interface QueuedMessage {
      */
     readonly agentId?: string;
     readonly mode: MessageMode;
+    /** Omitted means `runtime`; `host` messages must not be spliced into a model turn. */
+    readonly delivery?: MessageDelivery;
     readonly content: string;
     readonly inputArtifacts?: readonly QueuedInputArtifact[];
     readonly taskResult?: KodaXTaskResultMetadata;
@@ -126,10 +135,12 @@ type QueueEventListener = (event: QueueEvent) => void;
 interface EnqueueInput {
     readonly priority: MessagePriority;
     readonly mode: MessageMode;
+    /** Omitted means `runtime`; use `host` for command-pipeline-owned prompts. */
+    readonly delivery?: MessageDelivery;
     readonly content: string;
     readonly agentId?: string;
     readonly inputArtifacts?: readonly QueuedInputArtifact[];
     readonly taskResult?: KodaXTaskResultMetadata;
 }
 
-export type { DequeueFilter as D, EnqueueInput as E, MessagePriority as M, QueuedMessage as Q, QueueEventListener as a, QueuedInputArtifact as b, MessageMode as c };
+export type { DequeueFilter as D, EnqueueInput as E, MessageDelivery as M, QueueEventListener as Q, MessageMode as a, MessagePriority as b, QueuedInputArtifact as c, QueuedMessage as d };

package/dist/types-chunks/{types.d-BEMcUOng.d.ts → types.d-Cb8RdrjU.d.ts}

@@ -14,7 +14,7 @@ interface SkillFrontmatter {
     description: string;
     /** Whether to disable automatic model invocation (default: false) */
     disableModelInvocation?: boolean;
-    /** Whether skill appears in / menu (default: true) */
+    /** @deprecated Enabled skills are always explicitly user-invocable. */
     userInvocable?: boolean;
     /** Tool restrictions, e.g., "Read, Grep, Bash(python:*)" */
     allowedTools?: string;
@@ -52,6 +52,7 @@ interface SkillHooks {
 interface SkillMetadata {
     name: string;
     description: string;
+    /** @deprecated Enabled skills always report true and support explicit invocation. */
     userInvocable: boolean;
     argumentHint?: string;
     path: string;
@@ -110,13 +111,13 @@ interface ISkillRegistry {
     get(name: string): SkillMetadata | undefined;
     /** Load full skill content */
     loadFull(name: string): Promise<Skill>;
-    /** Invoke a skill with arguments */
+    /** Explicitly invoke a skill with arguments; model admission is a caller concern. */
     invoke(name: string, args: string, context: SkillContext): Promise<SkillResult>;
     /** Reload skills from disk */
     reload(): Promise<void>;
     /** List all discovered skills */
     list(): ReadonlyArray<SkillMetadata>;
-    /** List skills that can be invoked directly by users */
+    /** List enabled skills available for explicit user invocation. */
     listUserInvocable(): ReadonlyArray<SkillMetadata>;
     /** Check whether a skill exists */
     has(name: string): boolean;
@@ -275,4 +276,4 @@ declare function getSkillPathsFlat(config: SkillPathsConfig): Array<{
 }>;
 
 export { getDefaultSkillPaths as m, getSkillPathsFlat as n };
-export type { ISkillRegistry as I, LearnedSkillDiscoveryConfig as L, ResolvedSkillSource as R, SkillMetadata as S, SkillDynamicContextExecutor as a, IVariableResolver as b, Skill as c, SkillArtifact as d, SkillContext as e, SkillFile as f, SkillFrontmatter as g, SkillHook as h, SkillHooks as i, SkillPathsConfig as j, SkillResult as k, SkillSource as l };
+export type { ISkillRegistry as I, LearnedSkillDiscoveryConfig as L, ResolvedSkillSource as R, Skill as S, IVariableResolver as a, SkillArtifact as b, SkillContext as c, SkillDynamicContextExecutor as d, SkillFile as e, SkillFrontmatter as f, SkillHook as g, SkillHooks as h, SkillMetadata as i, SkillPathsConfig as j, SkillResult as k, SkillSource as l };

package/dist/types-chunks/{types.d-EjZTEEVu.d.ts → types.d-rUOjXych.d.ts}

@@ -1,4 +1,4 @@
-import { b as KodaXMessage } from './types.d-Cv09EdJR.js';
+import { k as KodaXMessage } from './types.d-CK9A9rpP.js';
 
 type AgentActorState = 'running' | 'idle' | 'closed';
 type AgentTurnState = 'accepted' | 'running' | 'completed' | 'failed' | 'interrupted';
@@ -611,6 +611,8 @@ interface KodaXSessionRuntimeInfo {
     permissionMode?: string;
     /** Agent mode active at session start, e.g. `'sa'` | `'ama'`. */
     agentMode?: string;
+    /** Runtime-owned exact linked-worktree roots admitted for this Session. */
+    sandboxWorktreeRoots?: string[];
 }
 interface KodaXSessionData {
     messages: KodaXMessage[];
@@ -710,6 +712,8 @@ interface KodaXExtensionStore {
 interface KodaXSessionStorage {
     save(id: string, data: KodaXSessionData): Promise<void>;
     load(id: string): Promise<KodaXSessionData | null>;
+    /** Atomically updates Runtime-owned Session metadata without replacing transcript state. */
+    mutateRuntimeInfo?(id: string, mutation: (runtimeInfo: KodaXSessionRuntimeInfo | undefined) => KodaXSessionRuntimeInfo | undefined): Promise<boolean>;
     /**
      * Atomically mutates context-silent lineage state against the latest
      * persisted session. Hosts that own session persistence may expose this
@@ -1086,4 +1090,4 @@ type MemoryEvent = {
 };
 
 export { hashMemoryIdentityComponent as bf, isMemoryManagementController as bg, matchesMemoryApplicability as bh, memoryApplicabilityFingerprint as bi };
-export type { MemoryApplicability as $, KodaXExtensionSessionRecord as A, KodaXExtensionSessionState as B, KodaXJsonValue as C, KodaXSessionBranchSummaryEntry as D, KodaXSessionCompactionEntry as E, KodaXSessionData as F, KodaXSessionEntry as G, KodaXSessionEntryBase as H, KodaXSessionLabelEntry as I, KodaXSessionMessageEntry as J, KodaXSessionLineage as K, KodaXSessionMeta as L, MemoryContextIdentity as M, KodaXSessionNavigationOptions as N, KodaXSessionRuntimeInfo as O, KodaXSessionScope as P, KodaXSessionStorage as Q, KodaXSessionTreeNode as R, KodaXSessionUiHistoryItem as S, KodaXSessionUiHistoryItemType as T, KodaXSessionUiTextHistoryItem as U, KodaXSessionUiTextHistoryItemType as V, KodaXSessionUiToolCall as W, KodaXSessionUiToolCallStatus as X, KodaXSessionUiToolGroupHistoryItem as Y, KodaXSessionWorkspaceKind as Z, SessionErrorMetadata as _, MemoryItemRef as a, MemoryClaimKind as a$, MemoryController as a0, KodaXExtensionStore as a1, AgentActorSnapshot as a2, AgentActorSaveAttempt as a3, AgentExecutionKind as a4, AgentTreeSnapshot as a5, AgentDetail as a6, AgentSpawnInput as a7, AgentTurnRef as a8, AgentDataClassification as a9, AgentActorSavePhase as aA, AgentActorSaveTiming as aB, AgentActorSnapshotV1 as aC, AgentActorSnapshotV2 as aD, AgentActorState as aE, AgentArtifactDescriptor as aF, AgentBudgetAdmission as aG, AgentBudgetAdmissionInput as aH, AgentEventKind as aI, AgentExecutionInput as aJ, AgentForkTurns as aK, AgentListEntry as aL, AgentProgressItem as aM, AgentProgressKind as aN, AgentProgressUpdate as aO, AgentTurn as aP, AgentTurnState as aQ, AgentTurnSummary as aR, KodaXGoalStatus as aS, KodaXHandledMemoryOperation as aT, KodaXMemoryInfluenceRef as aU, KodaXMemoryIntent as aV, KodaXMemoryOutcomeEvidence as aW, KodaXSessionArchiveMarkerEntry as aX, MemoryApplyPreview as aY, MemoryApproval as aZ, MemoryAuthority as a_, AgentFollowupResult as aa, AgentOutput as ab, AgentEvent as ac, KodaXSessionGoalEntry as ad, KodaXSessionClientNoticeEntry as ae, KodaXSessionRewindMarkerEntry as af, KodaXSessionMemoryOutcomeDigestEntry as ag, KodaXSessionMemoryReviewReceiptEntry as ah, KodaXGoalState as ai, AgentActorStore as aj, AgentTurnExecutor as ak, AgentBudgetPort as al, AgentActorOwner as am, AgentActorClient as an, AgentExecutionResult as ao, AgentCapabilities as ap, AgentMailboxMessage as aq, AgentMutationOptions as ar, AgentMetadataValue as as, AgentInterruptScope as at, KodaXGoalEventType as au, KodaXExtensionStoreEntry as av, AgentBudgetExhausted as aw, AgentLimitReached as ax, AgentActor as ay, AgentActorSaveDiagnostics as az, KodaXSessionArtifactLedgerEntry as b, MemoryGovernanceFinding as b0, MemoryGovernanceFindingKind as b1, MemoryLifecycle as b2, MemoryPackHint as b3, MemoryPackTraceMetadata as b4, MemoryProposalAction as b5, MemoryRefKind as b6, MemoryReviewCandidateRef as b7, MemoryReviewDraftAction as b8, MemoryReviewPersistenceDecision as b9, MemoryReviewPersistenceKind as ba, MemoryReviewTrigger as bb, MemoryScope as bc, MemorySourceAdapter as bd, MemoryVisibility as be, MemoryEvent as c, MemoryReviewRunner as d, MemoryManagementController as e, MemoryActionProposal as f, MemoryApplyResult as g, MemoryRejectResult as h, MemoryRefFilter as i, MemoryBodySnapshot as j, MemoryRememberInput as k, MemoryRememberResult as l, MemoryLifecycleOperationResult as m, MemoryCuratorInput as n, MemoryGovernanceReport as o, MemoryAutoCuratorInput as p, MemoryAutoCuratorResult as q, MemoryPackInput as r, MemoryPack as s, MemoryReviewInput as t, MemoryReviewPlan as u, KodaXMemoryOutcomeDigest as v, MemoryReviewModelInput as w, MemoryEpisodeReviewResult as x, KodaXCompactMemoryProgress as y, KodaXCompactMemorySeed as z };
+export type { KodaXHandledMemoryOperation as $, AgentActor as A, AgentInterruptScope as B, AgentLimitReached as C, AgentListEntry as D, AgentMailboxMessage as E, AgentMetadataValue as F, AgentMutationOptions as G, AgentOutput as H, AgentProgressItem as I, AgentProgressKind as J, AgentProgressUpdate as K, AgentSpawnInput as L, AgentTreeSnapshot as M, AgentTurn as N, AgentTurnExecutor as O, AgentTurnRef as P, AgentTurnState as Q, AgentTurnSummary as R, KodaXCompactMemoryProgress as S, KodaXCompactMemorySeed as T, KodaXExtensionSessionRecord as U, KodaXExtensionSessionState as V, KodaXExtensionStore as W, KodaXExtensionStoreEntry as X, KodaXGoalEventType as Y, KodaXGoalState as Z, KodaXGoalStatus as _, AgentActorClient as a, MemoryRejectResult as a$, KodaXJsonValue as a0, KodaXMemoryInfluenceRef as a1, KodaXMemoryIntent as a2, KodaXMemoryOutcomeDigest as a3, KodaXMemoryOutcomeEvidence as a4, KodaXSessionArchiveMarkerEntry as a5, KodaXSessionArtifactLedgerEntry as a6, KodaXSessionBranchSummaryEntry as a7, KodaXSessionClientNoticeEntry as a8, KodaXSessionCompactionEntry as a9, MemoryApplyPreview as aA, MemoryApplyResult as aB, MemoryApproval as aC, MemoryAuthority as aD, MemoryAutoCuratorInput as aE, MemoryAutoCuratorResult as aF, MemoryBodySnapshot as aG, MemoryClaimKind as aH, MemoryContextIdentity as aI, MemoryController as aJ, MemoryCuratorInput as aK, MemoryEpisodeReviewResult as aL, MemoryEvent as aM, MemoryGovernanceFinding as aN, MemoryGovernanceFindingKind as aO, MemoryGovernanceReport as aP, MemoryItemRef as aQ, MemoryLifecycle as aR, MemoryLifecycleOperationResult as aS, MemoryManagementController as aT, MemoryPack as aU, MemoryPackHint as aV, MemoryPackInput as aW, MemoryPackTraceMetadata as aX, MemoryProposalAction as aY, MemoryRefFilter as aZ, MemoryRefKind as a_, KodaXSessionData as aa, KodaXSessionEntry as ab, KodaXSessionEntryBase as ac, KodaXSessionGoalEntry as ad, KodaXSessionLabelEntry as ae, KodaXSessionLineage as af, KodaXSessionMemoryOutcomeDigestEntry as ag, KodaXSessionMemoryReviewReceiptEntry as ah, KodaXSessionMessageEntry as ai, KodaXSessionMeta as aj, KodaXSessionNavigationOptions as ak, KodaXSessionRewindMarkerEntry as al, KodaXSessionRuntimeInfo as am, KodaXSessionScope as an, KodaXSessionStorage as ao, KodaXSessionTreeNode as ap, KodaXSessionUiHistoryItem as aq, KodaXSessionUiHistoryItemType as ar, KodaXSessionUiTextHistoryItem as as, KodaXSessionUiTextHistoryItemType as at, KodaXSessionUiToolCall as au, KodaXSessionUiToolCallStatus as av, KodaXSessionUiToolGroupHistoryItem as aw, KodaXSessionWorkspaceKind as ax, MemoryActionProposal as ay, MemoryApplicability as az, AgentActorOwner as b, MemoryRememberInput as b0, MemoryRememberResult as b1, MemoryReviewCandidateRef as b2, MemoryReviewDraftAction as b3, MemoryReviewInput as b4, MemoryReviewModelInput as b5, MemoryReviewPersistenceDecision as b6, MemoryReviewPersistenceKind as b7, MemoryReviewPlan as b8, MemoryReviewRunner as b9, MemoryReviewTrigger as ba, MemoryScope as bb, MemorySourceAdapter as bc, MemoryVisibility as bd, SessionErrorMetadata as be, AgentActorSaveAttempt as c, AgentActorSaveDiagnostics as d, AgentActorSavePhase as e, AgentActorSaveTiming as f, AgentActorSnapshot as g, AgentActorSnapshotV1 as h, AgentActorSnapshotV2 as i, AgentActorState as j, AgentActorStore as k, AgentArtifactDescriptor as l, AgentBudgetAdmission as m, AgentBudgetAdmissionInput as n, AgentBudgetExhausted as o, AgentBudgetPort as p, AgentCapabilities as q, AgentDataClassification as r, AgentDetail as s, AgentEvent as t, AgentEventKind as u, AgentExecutionInput as v, AgentExecutionKind as w, AgentExecutionResult as x, AgentFollowupResult as y, AgentForkTurns as z };

package/dist/types-chunks/{utils.d-50Q24Few.d.ts → utils.d-CWUyLiXo.d.ts}

@@ -1,10 +1,10 @@
-import { b as KodaXMessage, o as KodaXReasoningMode, r as KodaXCustomProviderConfig, k as KodaXProviderCapabilityProfile } from './types.d-Cv09EdJR.js';
-import { N as WorkflowProcessSource } from './controller.d-Bm1i9RVj.js';
-import { O as KodaXContextTokenSnapshot, aB as KodaXSkillDynamicContextPolicy, s as KodaXAgentMode, ag as KodaXRepoIntelligenceMode, a2 as KodaXOptions, aC as KodaXSkillInvocationContext } from './bash-prefix-extractor.d-BMi_TJIY.js';
-import { f as AgentsFile, u as AutoModeStats, S as KodaXMcpServersConfig } from './guardrail.d-CKkoea7y.js';
+import { k as KodaXMessage, G as KodaXReasoningMode, d as KodaXCustomProviderConfig, q as KodaXProviderCapabilityProfile } from './types.d-CK9A9rpP.js';
+import { df as WorkflowProcessSource } from './controller.d-C5noq5-w.js';
+import { Q as KodaXContextTokenSnapshot, aD as KodaXSkillDynamicContextPolicy, t as KodaXAgentMode, ai as KodaXRepoIntelligenceMode, a4 as KodaXOptions, aE as KodaXSkillInvocationContext } from './bash-prefix-extractor.d-B2rxNI4L.js';
+import { e as AgentsFile, t as AutoModeStats, T as KodaXMcpServersConfig } from './guardrail.d-DqHD-61O.js';
 import * as readline from 'readline';
-import { S as KodaXSessionUiHistoryItem, K as KodaXSessionLineage, b as KodaXSessionArtifactLedgerEntry, B as KodaXExtensionSessionState, A as KodaXExtensionSessionRecord, O as KodaXSessionRuntimeInfo } from './types.d-EjZTEEVu.js';
-import { b as PermissionMode, L as LearningBinding, c as LearningSurfaceSnapshot } from './public-api.d-BsZWOq3P.js';
+import { aq as KodaXSessionUiHistoryItem, af as KodaXSessionLineage, a6 as KodaXSessionArtifactLedgerEntry, V as KodaXExtensionSessionState, U as KodaXExtensionSessionRecord, am as KodaXSessionRuntimeInfo } from './types.d-rUOjXych.js';
+import { S as PermissionMode, L as LearningBinding, G as LearningSurfaceSnapshot } from './public-api.d-D7fXaWW8.js';
 import { SpawnSyncReturns } from 'child_process';
 
 /**
@@ -720,5 +720,5 @@ declare function resolveRuntimeEffortSelection(input: {
 declare function getGitRoot(cwd?: string): Promise<string | null>;
 declare function rateLimitedCall<T>(fn: () => Promise<T>): Promise<T>;
 
-export { KODAX_EXAMPLE_CONFIG_FILE as E, KODAX_INTEGRATION_EXAMPLE_FILES as F, ensureExampleConfigFile as H, ensureExampleConfigFiles as J, KODAX_CONFIG_FILE as K, resolveRuntimeEffortSelection as L, resolveRuntimeModelSelection as M, resolveRuntimeProviderSelection as N, PREVIEW_MAX_LENGTH as P, KODAX_DIR as b, KODAX_SESSIONS_DIR as c, KODAX_VERSION as d, createInteractiveContext as f, getGitRoot as g, getProviderList as h, getProviderModel as i, getVersion as j, hydrateProcessEnvFromShell as k, isProviderConfigured as l, loadAutoModeSettings as m, loadConfig as n, registerConfiguredCustomProviders as o, prepareRuntimeConfig as p, resolveAutoModeSettings as q, rateLimitedCall as r, saveConfig as s, touchContext as t };
-export type { AutoModeSettings as A, RuntimeSurfaceStatus as B, CommandCallbacks as C, InteractiveMode as D, RuntimeSurfaceMode as G, InteractiveContext as I, ResolveAutoModeSettingsInput as R, CurrentConfig as a, ResolvedAutoModeSettings as e, CommandDefinition as u, CommandSource as v, CommandInfo as w, Command as x, CommandInvocationRequest as y, CommandWorkflowInvocationRequest as z };
+export { loadConfig as B, prepareRuntimeConfig as D, rateLimitedCall as E, registerConfiguredCustomProviders as F, resolveAutoModeSettings as G, resolveRuntimeEffortSelection as H, resolveRuntimeModelSelection as J, KODAX_CONFIG_FILE as K, resolveRuntimeProviderSelection as L, saveConfig as M, touchContext as N, PREVIEW_MAX_LENGTH as P, KODAX_DIR as i, KODAX_EXAMPLE_CONFIG_FILE as j, KODAX_INTEGRATION_EXAMPLE_FILES as k, KODAX_SESSIONS_DIR as l, KODAX_VERSION as m, createInteractiveContext as q, ensureExampleConfigFile as r, ensureExampleConfigFiles as s, getGitRoot as t, getProviderList as u, getProviderModel as v, getVersion as w, hydrateProcessEnvFromShell as x, isProviderConfigured as y, loadAutoModeSettings as z };
+export type { AutoModeSettings as A, Command as C, InteractiveContext as I, ResolveAutoModeSettingsInput as R, CommandCallbacks as a, CommandDefinition as b, CommandInfo as c, CommandInvocationRequest as d, CommandSource as e, CommandWorkflowInvocationRequest as f, CurrentConfig as g, InteractiveMode as h, ResolvedAutoModeSettings as n, RuntimeSurfaceMode as o, RuntimeSurfaceStatus as p };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodax-ai/kodax",
-  "version": "0.7.93",
+  "version": "0.7.95",
   "description": "KodaX lightweight coding agent - TypeScript implementation with 16 built-in LLM provider aliases, published as a Node-free single-file CLI and SDK",
   "type": "module",
   "private": false,
@@ -13,7 +13,7 @@
     "daemonShutdownVerification": 1,
     "integrationConfigResilience": 1,
     "managedRunDurability": 1,
-    "runtimeExitSettlement": 1,
+    "runtimeExitSettlement": 2,
     "sessionEventJournal": 1,
     "liveOutputSegments": 1
   },

package/dist/chunks/agent-R7HVNARP.js

@@ -1,2 +0,0 @@
-// @kodax-ai/kodax — bundled distribution. See docs/ADR.md ADR-022 + ADR-024.
-import{Ka as g,Ma as h,Za as i,_a as j,a as c,sa as d,ta as e,ua as f,yc as k}from"./chunk-JJ2YDBSN.js";import"./chunk-7QBWHCIZ.js";import"./chunk-JTZKC4TV.js";import"./chunk-GH3KBC2H.js";import"./chunk-YVG6OKN7.js";import"./chunk-BHE66SP3.js";import{Jb as a,Kb as b}from"./chunk-7XSZVOG7.js";import"./chunk-QFV6YCIH.js";import"./chunk-ONUPGMER.js";export{e as bucketProviderPayloadSize,g as buildAutoRepoIntelligenceContext,f as checkPromiseSignal,b as cleanupIncompleteToolCalls,h as describeTransientProviderRetry,c as emitResilienceDebug,d as estimateProviderPayloadBytes,k as runKodaX,j as saveRequiredSessionSnapshot,i as saveSessionSnapshot,a as validateAndFixToolHistory};

package/dist/chunks/argument-completer-JHXUJWHC.js

@@ -1,2 +0,0 @@
-// @kodax-ai/kodax — bundled distribution. See docs/ADR.md ADR-022 + ADR-024.
-import{Ha as a,Ia as b}from"./chunk-3YOZIFSJ.js";import"./chunk-HLZWPB32.js";import"./chunk-GRWUC6H7.js";import"./chunk-4BY53JTF.js";import"./chunk-XTWIGVUL.js";import"./chunk-JJ2YDBSN.js";import"./chunk-7QBWHCIZ.js";import"./chunk-PRASABCC.js";import"./chunk-JTZKC4TV.js";import"./chunk-GH3KBC2H.js";import"./chunk-YVG6OKN7.js";import"./chunk-BHE66SP3.js";import"./chunk-7XSZVOG7.js";import"./chunk-QFV6YCIH.js";import"./chunk-ONUPGMER.js";export{a as ArgumentCompleter,b as createArgumentCompleter};