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

package/dist/types-chunks/{sdk-session-B6XjHNU1.d.ts → sdk-session-BDFjCpDn.d.ts}

@@ -1,12 +1,16 @@
-import { j as CreatableHistoryItem, av as ToolCall } from './public-api.d-amBop8Nk.js';
-import { k as KodaXMessage, c as KodaXContentBlock } from './types.d-BrQMB-hy.js';
-import { ar as KodaXSessionUiHistoryItem, av as KodaXSessionUiToolCall } from './types.d-CSv0_cZC.js';
+import { aI as KodaXSessionUiHistoryItem, aM as KodaXSessionUiToolCall } from './review-inbox.d-BeaLRNHx.js';
+import { k as KodaXMessage, c as KodaXContentBlock } from './types.d-BjOq57-z.js';
+import { j as CreatableHistoryItem, av as ToolCall } from './public-api.d-Cq8ILMte.js';
 
 interface RestoreHistoryItemsFromSessionInput {
     messages: readonly KodaXMessage[];
     uiHistory?: readonly KodaXSessionUiHistoryItem[];
+    /** Canonical history pages must retain all blocks; live restoration stays bounded. */
+    historyScope?: 'window' | 'all';
 }
-declare function trimPersistedUiHistorySnapshot(items: readonly KodaXSessionUiHistoryItem[]): KodaXSessionUiHistoryItem[];
+declare function trimPersistedUiHistorySnapshot<T extends {
+    readonly type: string;
+}>(items: readonly T[]): T[];
 declare function restoreHistoryItemsFromSession(input: RestoreHistoryItemsFromSessionInput): CreatableHistoryItem[];
 
 /**
@@ -16,6 +20,7 @@ declare function restoreHistoryItemsFromSession(input: RestoreHistoryItemsFromSe
 type RestoredHistorySeed = ({
     type: "user";
     text: string;
+    inputId?: string;
 } | {
     type: "assistant";
     text: string;
@@ -40,6 +45,7 @@ type RestoredHistorySeed = ({
     tools: KodaXSessionUiToolCall[];
 }) & {
     timestamp?: number;
+    outputId?: string;
 };
 /** Convert a RestoredHistorySeed to a CreatableHistoryItem. tool_summary / task_completed → event with icon. */
 declare function seedToHistoryItem(seed: RestoredHistorySeed): CreatableHistoryItem;
@@ -48,6 +54,8 @@ declare function toolCallSeedToHistoryToolCall(tool: KodaXSessionUiToolCall): To
  * Minimal message shape required to restore UI history items.
  */
 interface HistorySeedSourceMessage {
+    outputId?: string;
+    inputId?: string;
     role: KodaXMessage["role"];
     content: string | KodaXContentBlock[];
     timestamp?: string;

package/dist/types-chunks/{side-query.d-DHWG1JZg.d.ts → side-query.d-DTrhVd_r.d.ts}

@@ -1,6 +1,7 @@
-import { k as KodaXMessage, I as KodaXReasoningRequest, a2 as KodaXTokenUsage, H as KodaXReasoningProfile } from './types.d-BrQMB-hy.js';
-import { K as KodaXBaseProvider } from './base.d-Bt9lhwSV.js';
-import { f as ProviderCredentialPurpose, a as CostTracker } from './cost-tracker.d-BWI4lFWn.js';
+import { k as KodaXMessage, I as KodaXReasoningRequest, a2 as KodaXTokenUsage, H as KodaXReasoningProfile } from './types.d-BjOq57-z.js';
+import { K as KodaXBaseProvider } from './base.d-ZBOdjDUT.js';
+import { a as CostTracker } from './cost-tracker.d-BeaenODW.js';
+import { c as ProviderCredentialPurpose } from './provider-credential-context.d-BH2OaB1b.js';
 
 /**
  * sideQuery — independent one-shot LLM invocation.

package/dist/types-chunks/trusted-repl-entry-vbUM8R6P.d.ts

@@ -0,0 +1,445 @@
+import { r as ResolvedAutoModeSettings, b as CommandDefinition, g as CommandSource, d as CommandInfo, C as Command$1, I as InteractiveContext, a as CommandCallbacks, j as CurrentConfig, e as CommandInvocationRequest, h as CommandWorkflowInvocationRequest, t as RuntimeSurfaceStatus, S as SessionCommandBinding } from './utils.d-CWiMhFfu.js';
+import { c as CanonicalPermissionMode, h as ConfirmResult, o as HistoryItem, ai as SessionStorage$1, L as LearningBinding } from './public-api.d-Cq8ILMte.js';
+import { at as KodaXResult, aa as KodaXOptions } from './bash-prefix-extractor.d-DvswAXKS.js';
+import { W as ExecPolicyRuleInput, r as AutoModeStats } from './run-manager.d-C7Q71rin.js';
+import { ar as ClientToolInvocationInput, ac as ClientSessionCancelInput, ad as ClientSessionCancelReceipt, aj as ClientSessionSettingsPatch, a8 as ClientRunStopReceipt, am as ClientSessionView, Y as ClientObserveOptions, E as ClientItemReadOptions, D as ClientItemContent, v as ClientHistoryReadOptions, u as ClientHistoryPage, A as ClientInteractionResponse, a0 as ClientPermissionInteractionOptions, z as ClientInteraction, at as ClientViewItem } from './client-contract-A1jdk6xz.js';
+import { am as KodaXInputArtifact, _ as AskUserQuestionOptions, W as AskUserAnswer, Y as AskUserMultiOptions } from './types.d-o7t9dds4.js';
+import { aG as KodaXSessionStorage, as as KodaXSessionData } from './review-inbox.d-BeaLRNHx.js';
+
+/** Host-owned user Stop; acceptance is distinct from execution settlement. */
+interface RuntimeStopControl {
+    request(): Promise<{
+        readonly state: 'unknown' | 'confirmed';
+    }>;
+}
+interface RuntimeStopCallbacks {
+    readonly onStopControl?: (control: RuntimeStopControl | undefined) => void;
+    readonly onStopState?: (state: 'requesting' | 'accepted' | 'confirmed' | 'rejected', detail?: string) => void;
+}
+
+interface StandaloneExecPolicyOptions {
+    readonly adminRules?: readonly ExecPolicyRuleInput[];
+    readonly trustedProjectRoots?: readonly string[];
+}
+
+interface ReplRuntimePermissionGrantSuggestion {
+    readonly id: string;
+    readonly kind: 'session' | 'persistent';
+    readonly label: string;
+}
+interface ReplRuntimePermissionRequest {
+    readonly id: string;
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    readonly input: Readonly<Record<string, unknown>>;
+    readonly reason?: string;
+    readonly risk?: 'low' | 'medium' | 'high';
+    readonly executionCwd?: string;
+    readonly grantSuggestions?: readonly ReplRuntimePermissionGrantSuggestion[];
+    readonly createdAt?: string;
+    readonly expiresAt?: string;
+}
+interface ReplRuntimePermissionPromptContext {
+    readonly signal: AbortSignal;
+}
+type ReplRuntimePermissionDecision = {
+    readonly type: 'allow_once';
+} | {
+    readonly type: 'allow_session';
+    readonly suggestionId: string;
+} | {
+    readonly type: 'allow_always';
+    readonly suggestionId: string;
+} | {
+    readonly type: 'reject';
+    readonly reason?: string;
+};
+type ReplRuntimePermissionPrompt = (request: ReplRuntimePermissionRequest, context: ReplRuntimePermissionPromptContext) => Promise<ReplRuntimePermissionDecision>;
+declare const RUNTIME_PERMISSION_PENDING_NOTICE = "Runtime state: run active until this approval is resolved.";
+interface ReplRuntimeAutoModeControl {
+    getStats(sessionId: string): Promise<AutoModeStats | undefined>;
+    syncSettings?(sessionId: string, permissionMode: CanonicalPermissionMode, settings: ReplRuntimeAutoModeSettings): Promise<AutoModeStats | undefined>;
+    subscribe?(sessionId: string, listener: (stats: AutoModeStats | undefined) => void): {
+        close(): void;
+    };
+}
+interface ReplRuntimeAutoModeSettings {
+    readonly classifierModel?: string;
+    readonly reviewPolicy?: string;
+}
+declare function toReplRuntimeAutoModeSettings(settings: ResolvedAutoModeSettings): ReplRuntimeAutoModeSettings;
+
+/**
+ * Command Registry - Dynamic command registration system
+ * 命令注册表 - 动态命令注册系统
+ *
+ * Provides centralized command management with source tracking,
+ * supporting dynamic registration, lookup, and listing of commands.
+ */
+
+/**
+ * CommandRegistry - Centralized command management
+ * 命令注册表 - 集中式命令管理
+ *
+ * @example
+ * ```typescript
+ * const registry = new CommandRegistry();
+ *
+ * // Register a command
+ * registry.register({
+ *   name: 'copy',
+ *   description: 'Copy last message to clipboard',
+ *   source: 'builtin',
+ *   handler: async (args, context, callbacks, config) => {
+ *     // Implementation
+ *   }
+ * });
+ *
+ * // Get a command
+ * const cmd = registry.get('copy');
+ *
+ * // List all commands
+ * const allCommands = registry.getAll();
+ *
+ * // List builtin commands only
+ * const builtinCommands = registry.getBySource('builtin');
+ * ```
+ */
+declare class CommandRegistry {
+    /**
+     * Internal command storage
+     * 内部命令存储
+     */
+    private commands;
+    /**
+     * Alias to command name mapping
+     * 别名到命令名称的映射
+     */
+    private aliases;
+    /**
+     * Register a command
+     * 注册命令
+     *
+     * @param def - Command definition
+     * @throws Error if command with same name already exists
+     */
+    register(def: CommandDefinition): void;
+    /**
+     * Unregister a command
+     * 注销命令
+     *
+     * @param name - Command name or alias
+     * @returns true if command was unregistered, false if not found
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a command by name or alias
+     * 通过名称或别名获取命令
+     *
+     * @param name - Command name or alias
+     * @returns Command definition or undefined if not found
+     */
+    get(name: string): CommandDefinition | undefined;
+    /**
+     * Check if a command exists
+     * 检查命令是否存在
+     *
+     * @param name - Command name or alias
+     * @returns true if command exists, false otherwise
+     */
+    has(name: string): boolean;
+    /**
+     * Get all commands with optional source filter
+     * 获取所有命令，可选按来源过滤
+     *
+     * @param source - Optional source filter
+     * @returns Array of command information
+     */
+    getAll(source?: CommandSource): CommandInfo[];
+    /**
+     * Get commands by source
+     * 按来源获取命令
+     *
+     * @param source - Command source
+     * @returns Array of command information
+     */
+    getBySource(source: CommandSource): CommandInfo[];
+    /**
+     * Get all command names
+     * 获取所有命令名称
+     *
+     * @returns Array of command names
+     */
+    getNames(): string[];
+    /**
+     * Clear all commands
+     * 清空所有命令
+     */
+    clear(): void;
+    /**
+     * Get command count
+     * 获取命令数量
+     *
+     * @returns Number of registered commands
+     */
+    get size(): number;
+    /**
+     * Get alias count
+     * 获取别名数量
+     *
+     * @returns Number of registered aliases
+     */
+    get aliasCount(): number;
+}
+
+/**
+ * KodaX Interactive Command System
+ */
+
+type Command = Command$1;
+declare const BUILTIN_COMMANDS: Command[];
+declare function getCommandRegistry(projectRoot?: string): CommandRegistry;
+declare function parseCommand(input: string): {
+    command: string;
+    args: string[];
+    skillInvocation?: {
+        name: string;
+    };
+} | null;
+type CommandResult = boolean | {
+    success?: boolean;
+    message?: string;
+    startedRunId?: string;
+    skillContent?: string;
+    invocation?: CommandInvocationRequest;
+    workflow?: CommandWorkflowInvocationRequest;
+};
+declare function executeCommand(parsed: {
+    command: string;
+    args: string[];
+    skillInvocation?: {
+        name: string;
+    };
+}, context: InteractiveContext, callbacks: CommandCallbacks, currentConfig: CurrentConfig, rawInput?: string): Promise<CommandResult>;
+
+/** Terminal projection of one client round; `result` is the legacy shape Ink's loop expects. */
+interface ClientRoundOutcome {
+    readonly phase: string;
+    readonly result?: KodaXResult;
+    readonly error?: string;
+}
+interface InkClientPlane {
+    executeTool(input: ClientToolInvocationInput): Promise<{
+        readonly runId: string;
+        readonly sessionId: string;
+    }>;
+    cancelSession(input: ClientSessionCancelInput): Promise<ClientSessionCancelReceipt>;
+    /** Configure the Host-owned Session before starting or changing a round. */
+    updateSettings?(sessionId: string, patch: ClientSessionSettingsPatch): Promise<void>;
+    /** Persist client-only command feedback without submitting model input. */
+    appendNotice?(sessionId: string, input: {
+        content: string;
+        source?: string;
+    }): Promise<void>;
+    /**
+     * Submit user text. 'immediate' starts the run, 'after_turn' queues
+     * Host-side, 'redirect' queues and cancels the target run (FEATURE_149
+     * fast-redirect parity; requires targetRunId).
+     */
+    submit(input: {
+        readonly sessionId: string;
+        readonly text: string;
+        readonly inputId: string;
+        readonly delivery?: 'immediate' | 'after_turn' | 'steer' | 'redirect';
+        readonly targetRunId?: string;
+        readonly inputArtifacts?: readonly KodaXInputArtifact[];
+    }): Promise<{
+        readonly runId?: string;
+        readonly state?: 'submitted' | 'queued' | 'withdrawn' | 'dropped';
+    }>;
+    /** Withdraw a queued input, retaining attachments; standalone bindings may return plain text. */
+    withdraw(sessionId: string, inputId: string): Promise<string | {
+        readonly text: string;
+        readonly inputArtifacts?: readonly KodaXInputArtifact[];
+    } | undefined>;
+    /** Resolve uncertain acceptance without starting new work. */
+    readInput?(sessionId: string, inputId: string): Promise<{
+        readonly state: 'submitted' | 'queued' | 'withdrawn' | 'dropped';
+    } | null>;
+    /** Resolve when the run reaches a terminal phase. */
+    awaitRun(sessionId: string, runId: string): Promise<ClientRoundOutcome>;
+    /** Request a stop for one run (Esc); the receipt never implies terminal state. */
+    stop(runId: string): Promise<ClientRunStopReceipt | undefined>;
+    /** Newest run in a live phase for the session, or undefined when idle. */
+    activeRun(sessionId: string): Promise<string | undefined>;
+    /** Live current-state replacement; resolves with the closer. */
+    observe(sessionId: string, onView: (view: ClientSessionView) => void, options?: ClientObserveOptions): Promise<() => void>;
+    /** Page the complete content of a bounded view item by stable id. */
+    readItem(sessionId: string, itemId: string, options?: ClientItemReadOptions | number): Promise<ClientItemContent | null>;
+    readHistory?(sessionId: string, options?: ClientHistoryReadOptions): Promise<ClientHistoryPage>;
+    readHistoryEntry?(sessionId: string, itemId: string, options?: ClientItemReadOptions): Promise<ClientItemContent | null>;
+    /** Answer a pending Host question/permission; first valid answer wins. */
+    respondInteraction(requestId: string, response: ClientInteractionResponse): Promise<boolean>;
+}
+/** Client-minted input identity; withdraw targets it while the input is queued. */
+declare function mintInkInputId(): string;
+/** Submit one input, following its Run and the Host's queued continuations. */
+declare function runClientPlaneRound(input: {
+    readonly plane: InkClientPlane;
+    readonly submit?: InkClientPlane['submit'];
+    readonly sessionId: string;
+    readonly prompt: string;
+    readonly abortSignal?: AbortSignal;
+    /** Read the Run already displayed to the user synchronously at interruption. */
+    readonly getDisplayedRunId?: () => string | undefined;
+    readonly inputArtifacts?: readonly KodaXInputArtifact[];
+} & RuntimeStopCallbacks): Promise<KodaXResult>;
+/** First run in a live phase; run lists are ordered oldest-first. */
+declare function firstActiveRunId(runs: readonly {
+    readonly runId: string;
+    readonly phase: string;
+}[]): string | undefined;
+/** Active run id from the view's run list, or undefined when idle. */
+declare function viewRunsActive(view: Pick<ClientSessionView, 'runs'>): string | undefined;
+/** Adapter-side memo entry: reuse the mapped item while the fingerprint holds. */
+interface ClientViewItemMemo {
+    readonly entries: Map<string, {
+        fingerprint: string;
+        item: HistoryItem;
+    }>;
+}
+/**
+ * Map the Host's display items onto the Ink render model (types align by
+ * design). Streaming marks only the TRAILING assistant item — the item the
+ * active run is appending to. Pass a `memo` (kept across calls by the
+ * observer) so unchanged items keep their HistoryItem identity and the
+ * memoized renderers skip re-rendering the whole transcript per delta.
+ */
+declare function clientViewToHistoryItems(items: readonly ClientViewItem[], options?: {
+    readonly activeRunId?: string;
+    readonly memo?: ClientViewItemMemo;
+}): HistoryItem[];
+/**
+ * FEATURE_298 T17 — the dialog surface the plane drives. Ink binds these to
+ * its existing askUser/permission dialog implementations; tests inject fakes.
+ */
+interface ClientPlaneDialogSurface {
+    readonly question: (options: AskUserQuestionOptions, signal?: AbortSignal) => Promise<AskUserAnswer>;
+    readonly questionMulti: (options: AskUserMultiOptions, signal?: AbortSignal) => Promise<Record<string, AskUserAnswer> | undefined>;
+    readonly questionInput: (options: {
+        readonly question: string;
+        readonly default?: string;
+    }, signal?: AbortSignal) => Promise<string | undefined>;
+    readonly permission: (options: ClientPermissionInteractionOptions, signal?: AbortSignal) => Promise<ConfirmResult>;
+}
+/**
+ * Answer one pending Host interaction through the dialog surface and forward
+ * the typed response; first valid answer wins Host-side, so a late dialog
+ * result simply resolves as `false`.
+ */
+declare function answerClientPlaneInteraction(plane: Pick<InkClientPlane, 'respondInteraction'>, interaction: ClientInteraction, surface: ClientPlaneDialogSurface, signal?: AbortSignal): Promise<boolean>;
+
+type InkRuntimeStatusProvider = () => Promise<RuntimeSurfaceStatus | undefined>;
+interface InkTransientNotice {
+    readonly text: string;
+    readonly tone: "success" | "warning";
+}
+interface InkREPLOptions extends KodaXOptions {
+    initialClientSettings?: ClientSessionSettingsPatch;
+    storage?: SessionStorage$1;
+    execPolicy?: StandaloneExecPolicyOptions;
+    hardExitOnClose?: boolean;
+    runtimeAutoModeControl?: ReplRuntimeAutoModeControl;
+    getRuntimeStatus?: InkRuntimeStatusProvider;
+    validateSetupA2AConfig?: (value: unknown) => unknown;
+    prepareSetupSandbox?: CommandCallbacks['prepareSetupSandbox'];
+    inspectSandbox?: CommandCallbacks['inspectSandbox'];
+    learning?: LearningBinding;
+    /** FEATURE_298 T22 — Host workflow plane; required for start/control. */
+    workflows?: CommandCallbacks['workflows'];
+    commandClient?: CommandCallbacks['commandClient'];
+    listHostCommands?: CommandCallbacks['listHostCommands'];
+    inspectExtensions?: CommandCallbacks['inspectExtensions'];
+    mcp?: CommandCallbacks['mcp'];
+    config?: CommandCallbacks['config'];
+    catalog?: CommandCallbacks['catalog'];
+    providerCapabilities?: CommandCallbacks['providerCapabilities'];
+    startReview?: CommandCallbacks['startReview'];
+    reviewAgentsLean?: CommandCallbacks['reviewAgentsLean'];
+    goal?: CommandCallbacks['goal'];
+    sessionCommands?: SessionCommandBinding;
+    compactSession?: CommandCallbacks['compactSession'];
+    memory?: CommandCallbacks['memory'];
+    /** FEATURE_298 T17 — when bound, execution/observation travel the Client plane. */
+    clientPlane?: InkClientPlane;
+    subscribeTransientNotices?: (listener: (notice: InkTransientNotice) => void) => () => void;
+}
+
+/** Manual shell syntax is a host tool invocation under the current Session owner. */
+interface ShellExecutorConfig {
+    maxBuffer?: number;
+    timeout?: number;
+    maxOutputLength?: number;
+    maxErrorLength?: number;
+    cwd?: string;
+    execute?: (command: string) => Promise<{
+        success: boolean;
+        lastText: string;
+        interrupted?: boolean;
+    }>;
+    onOutput?: (text: string) => void;
+}
+declare function executeShellCommand(command: string, config?: ShellExecutorConfig): Promise<string>;
+declare function isShellCommand(input: string): boolean;
+declare function isShellCommandSuccess(result: string): boolean;
+
+interface SessionStorage extends KodaXSessionStorage {
+    list(gitRoot?: string, options?: {
+        limit?: number;
+        includeArchived?: boolean;
+    }): Promise<Array<{
+        id: string;
+        title: string;
+        msgCount: number;
+        tag?: string;
+        runtimeInfo?: KodaXSessionData['runtimeInfo'];
+    }>>;
+}
+type ReplRuntimeStatusProvider = () => Promise<RuntimeSurfaceStatus | undefined>;
+interface RepLOptions extends KodaXOptions {
+    initialClientSettings?: ClientSessionSettingsPatch;
+    storage?: SessionStorage;
+    execPolicy?: StandaloneExecPolicyOptions;
+    /** FEATURE_298 T18 — bound rounds travel the Host input/run faces. */
+    clientPlane?: InkClientPlane;
+    runtimeAutoModeControl?: ReplRuntimeAutoModeControl;
+    getRuntimeStatus?: ReplRuntimeStatusProvider;
+    validateSetupA2AConfig?: (value: unknown) => unknown;
+    prepareSetupSandbox?: CommandCallbacks['prepareSetupSandbox'];
+    inspectSandbox?: CommandCallbacks['inspectSandbox'];
+    learning?: LearningBinding;
+    /** FEATURE_298 T22 — Host workflow plane; required for start/control. */
+    workflows?: CommandCallbacks['workflows'];
+    commandClient?: CommandCallbacks['commandClient'];
+    listHostCommands?: CommandCallbacks['listHostCommands'];
+    inspectExtensions?: CommandCallbacks['inspectExtensions'];
+    mcp?: CommandCallbacks['mcp'];
+    config?: CommandCallbacks['config'];
+    catalog?: CommandCallbacks['catalog'];
+    providerCapabilities?: CommandCallbacks['providerCapabilities'];
+    startReview?: CommandCallbacks['startReview'];
+    reviewAgentsLean?: CommandCallbacks['reviewAgentsLean'];
+    goal?: CommandCallbacks['goal'];
+    sessionCommands?: SessionCommandBinding;
+    compactSession?: CommandCallbacks['compactSession'];
+    memory?: CommandCallbacks['memory'];
+}
+declare function processSpecialSyntax(input: string, executionCwd?: string, execute?: ShellExecutorConfig['execute']): Promise<string>;
+
+/** KodaX-owned classic REPL entry with the native trusted-text authority bound. */
+declare function runInteractiveMode(options: RepLOptions): Promise<void>;
+/** KodaX-owned Ink REPL entry with the native trusted-text authority bound. */
+declare function runInkInteractiveMode(options: InkREPLOptions): Promise<void>;
+
+export { parseCommand as A, BUILTIN_COMMANDS as B, processSpecialSyntax as D, runClientPlaneRound as E, runInkInteractiveMode as F, runInteractiveMode as G, toReplRuntimeAutoModeSettings as H, viewRunsActive as J, RUNTIME_PERMISSION_PENDING_NOTICE as R, answerClientPlaneInteraction as r, clientViewToHistoryItems as s, executeCommand as t, executeShellCommand as u, firstActiveRunId as v, getCommandRegistry as w, isShellCommand as x, isShellCommandSuccess as y, mintInkInputId as z };
+export type { ClientPlaneDialogSurface as C, InkClientPlane as I, ShellExecutorConfig as S, ClientRoundOutcome as a, ClientViewItemMemo as b, Command as c, InkREPLOptions as d, InkRuntimeStatusProvider as e, InkTransientNotice as f, RepLOptions as g, ReplRuntimeAutoModeControl as h, ReplRuntimeAutoModeSettings as i, ReplRuntimePermissionDecision as j, ReplRuntimePermissionGrantSuggestion as k, ReplRuntimePermissionPrompt as l, ReplRuntimePermissionRequest as m, ReplRuntimeStatusProvider as n, RuntimeStopCallbacks as o, RuntimeStopControl as p, StandaloneExecPolicyOptions as q };

package/dist/types-chunks/{types.d-CtO8mR1s.d.ts → types.d-BJTN-RZr.d.ts}

@@ -1,8 +1,8 @@
-import { ab as KodaXWireReasoningEffort, a3 as KodaXToolDefinition, a5 as KodaXToolResultContentItem, k as KodaXMessage } from './types.d-BrQMB-hy.js';
-import { K as KodaXBaseProvider } from './base.d-Bt9lhwSV.js';
-import { C as CapabilityKind, a as CapabilityProvider, b as CapabilityResult } from './capability.d-Ch5Vos33.js';
-import { a1 as KodaXJsonValue, V as KodaXExtensionSessionRecord, X as KodaXExtensionStore } from './types.d-CSv0_cZC.js';
-import { b8 as KodaXToolExecutionContext, b$ as ToolSideEffect, E as ExtensionExecutionScope } from './bash-prefix-extractor.d-DWFIMg0v.js';
+import { ab as KodaXWireReasoningEffort, a3 as KodaXToolDefinition, a5 as KodaXToolResultContentItem, k as KodaXMessage } from './types.d-BjOq57-z.js';
+import { K as KodaXBaseProvider } from './base.d-ZBOdjDUT.js';
+import { C as CapabilityKind, a as CapabilityProvider, b as CapabilityResult } from './capability.d-DOF3r0fJ.js';
+import { ai as KodaXJsonValue, aa as KodaXExtensionSessionRecord, ac as KodaXExtensionStore } from './review-inbox.d-BeaLRNHx.js';
+import { b9 as KodaXToolExecutionContext, c0 as ToolSideEffect, E as ExtensionExecutionScope } from './bash-prefix-extractor.d-DvswAXKS.js';
 
 /**
  * KodaX Constructed-World types (FEATURE_087, v0.7.28).

package/dist/types-chunks/{types.d-BrQMB-hy.d.ts → types.d-BjOq57-z.d.ts}

@@ -163,6 +163,12 @@ interface KodaXMessage {
      * sessions and provider-internal synthetic messages.
      */
     turnId?: string;
+    /** Stable identity of one generated assistant message, shared by its live projection. */
+    outputId?: string;
+    /** Accepted user input identity; absent on older and system-generated messages. */
+    inputId?: string;
+    /** User inputs merged into this canonical message by the Host queue. */
+    inputIds?: readonly string[];
     /**
      * ISO-8601 timestamp of when this message was finalized (assistant: when the
      * LLM stream completed; user: when submitted/injected). Optional and