@kodax-ai/kodax 0.7.57 → 0.7.59

package/dist/types-chunks/{capsule.d-DwJp5r63.d.ts → run-manager.d-CsJC9zYf.d.ts}

@@ -1,6 +1,6 @@
-import { j as KodaXMessage } from './types.d-6VOXvF88.js';
-import { Q as QueueEventListener, c as QueuedMessage, E as EnqueueInput, D as DequeueFilter } from './types.d-D8WcfrOD.js';
-import { f as AgentMessage, aM as SessionEntry, aK as Session, aO as SessionExtension, a4 as KodaXSessionLineage, W as KodaXJsonValue, p as CompactionDetails, O as KodaXCompactMemorySeed, a0 as KodaXSessionEntry, ab as KodaXSessionTreeNode, a3 as KodaXSessionLabelEntry, a2 as KodaXSessionGoalEntry, a7 as KodaXSessionNavigationOptions, Y as KodaXSessionArtifactLedgerEntry, x as FileOperations, br as WorkflowMeta, bs as WorkflowModelHint, bt as WorkflowModule } from './process.d-BZncyzEj.js';
+import { j as KodaXMessage } from './types.d-Ci5YPFEh.js';
+import { Q as QueueEventListener, f as QueuedMessage, E as EnqueueInput, D as DequeueFilter } from './types.d-CE_Ter29.js';
+import { g as AgentMessage, aU as SessionEntry, aS as Session, aW as SessionExtension, aa as KodaXSessionLineage, a0 as KodaXJsonValue, q as CompactionDetails, P as KodaXCompactMemorySeed, a6 as KodaXSessionEntry, ah as KodaXSessionTreeNode, a9 as KodaXSessionLabelEntry, a8 as KodaXSessionGoalEntry, ad as KodaXSessionNavigationOptions, a2 as KodaXSessionArtifactLedgerEntry, y as FileOperations, bz as WorkflowMeta, bA as WorkflowModelHint, bB as WorkflowModule, bR as WorkflowProcessTrackerOptions, bs as WorkflowEvent, bL as WorkflowProcessSnapshot, bF as WorkflowProcessEvent } from './process.d-BOrAxjvM.js';
 
 /**
  * @kodax-ai/agent Constants
@@ -758,6 +758,13 @@ declare const WORKFLOW_CAPSULE_API_VERSION: 1;
 type WorkflowCapsuleEnvironmentRequirement = 'git-repo' | 'worktree-capable';
 interface WorkflowCapsuleIntent {
     readonly taskClass: string;
+    /**
+     * The full set of workflow patterns the script declares (manifest.patterns).
+     * `taskClass` keeps only the primary pattern; this records the whole
+     * combination so a declared ['fan-out-and-synthesize', 'adversarial-verification']
+     * is preserved rather than collapsed to its first id.
+     */
+    readonly patterns?: readonly string[];
     readonly originalRequest?: string;
     readonly reusableFor?: readonly string[];
     readonly notFor?: readonly string[];
@@ -806,6 +813,107 @@ interface CreateWorkflowCapsuleInput {
 declare function validateWorkflowCapsule(value: unknown): WorkflowCapsule;
 declare function createWorkflowCapsule(input: CreateWorkflowCapsuleInput): WorkflowCapsule;
 declare function createWorkflowModuleFromCapsule(capsule: WorkflowCapsule): WorkflowModule;
+/**
+ * Single source of truth for deriving a capsule intent from a workflow manifest.
+ * `taskClass` keeps the primary pattern; the full declared set is recorded on
+ * `patterns` so a combination like ['fan-out-and-synthesize',
+ * 'adversarial-verification'] is preserved rather than collapsed to its first id
+ * (M15). Used by every capsule-save path so the propagation logic is tested once.
+ */
+declare function buildWorkflowCapsuleIntent(manifest: {
+    readonly patterns: readonly string[];
+    readonly name: string;
+    readonly description: string;
+}, opts?: {
+    readonly originalRequest?: string;
+}): WorkflowCapsuleIntent;
+
+/**
+ * FEATURE_246 Part A0 (ADR-046) — neutral workflow run lifecycle manager.
+ *
+ * Domain-neutral run registry + lifecycle (pause / resume / stop), process-event
+ * tracking, and terminal settle — lifted out of `@kodax-ai/coding` so any agent
+ * (including non-coding SDK hosts) can host and manage workflow runs.
+ *
+ * It never knows HOW a run executes: the caller injects a `runFn` thunk that
+ * receives lifecycle hooks (`onEvent` / `signal` / `beforeSpawn`) and returns a
+ * caller-shaped outcome, plus a `classify` mapping that outcome to a neutral
+ * terminal status and an `onError` that synthesizes a failure outcome. The
+ * coding layer wires `runFn` to its `runWorkflowModule` / `runWorkflowFromOptions`
+ * (backend + run-graph + worktrees); SDK hosts wire their own. Dependency arrows
+ * therefore point only coding → agent — no cycle.
+ */
+
+type ManagedWorkflowStatus = 'running' | 'paused' | 'completed' | 'failed' | 'denied' | 'stopped';
+/** Provenance/display metadata for a run's process tracker. */
+type WorkflowProcessMetadata = Pick<WorkflowProcessTrackerOptions, 'displayName' | 'goal' | 'source' | 'savedWorkflowName' | 'sourceRunId' | 'sourceWorkflowName' | 'revisionOf' | 'resumedFromRunId' | 'hostMetadata'>;
+interface ManagedWorkflowSnapshot {
+    readonly runId: string;
+    readonly workflow: string;
+    readonly status: ManagedWorkflowStatus;
+    readonly totalSpawned: number;
+    readonly eventCount: number;
+    readonly startedAt: number;
+    readonly endedAt?: number;
+    readonly error?: string;
+    readonly resultText?: string;
+}
+interface ManagedWorkflowRun<TOutcome = unknown> {
+    readonly runId: string;
+    readonly done: Promise<TOutcome>;
+    getSnapshot(): ManagedWorkflowSnapshot | undefined;
+    getProcessSnapshot(): WorkflowProcessSnapshot | undefined;
+}
+/** Lifecycle hooks the manager injects into the caller's `runFn`. */
+interface ManagedRunHooks {
+    /** Forward every workflow event so the manager can track spawn/progress. */
+    readonly onEvent: (event: WorkflowEvent) => void;
+    /** Abort signal owned by the manager (fires on stop()). */
+    readonly signal: AbortSignal;
+    /** Await before launching each agent so pause() can gate new spawns. */
+    readonly beforeSpawn: () => Promise<void>;
+}
+/** Neutral terminal classification of a caller-shaped outcome. */
+interface ManagedRunClassification {
+    readonly status: 'completed' | 'failed' | 'denied';
+    readonly error?: Error;
+    readonly resultText?: string;
+}
+interface StartManagedRunInput<TOutcome> {
+    readonly runId: string;
+    /** Display name (usually the workflow's `meta.name`). */
+    readonly workflow: string;
+    readonly phases?: readonly string[];
+    readonly maxAgents?: number;
+    readonly plannedAgents?: number;
+    readonly tokenBudget?: number;
+    readonly processMetadata?: WorkflowProcessMetadata;
+    readonly signal?: AbortSignal;
+    /** Executes the run with the manager's lifecycle hooks injected. */
+    readonly runFn: (hooks: ManagedRunHooks) => Promise<TOutcome>;
+    /** Map the caller's terminal outcome to a neutral status for the snapshot. */
+    readonly classify: (outcome: TOutcome) => ManagedRunClassification;
+    /** Synthesize a caller-shaped outcome when `runFn` throws. */
+    readonly onError: (error: unknown) => TOutcome;
+}
+interface WorkflowRunManager {
+    start<TOutcome>(input: StartManagedRunInput<TOutcome>): ManagedWorkflowRun<TOutcome>;
+    list(): readonly ManagedWorkflowSnapshot[];
+    get(runId: string): ManagedWorkflowSnapshot | undefined;
+    subscribeWorkflowProcess(listener: (event: WorkflowProcessEvent) => void): () => void;
+    getWorkflowProcessSnapshot(runId: string): WorkflowProcessSnapshot | undefined;
+    listWorkflowProcessSnapshots(options?: {
+        readonly activeOnly?: boolean;
+        readonly limit?: number;
+    }): readonly WorkflowProcessSnapshot[];
+    pause(runId: string): boolean;
+    resume(runId: string): boolean;
+    stop(runId: string, reason?: string): boolean;
+}
+declare function createWorkflowRunManager(deps?: {
+    readonly now?: () => number;
+}): WorkflowRunManager;
+declare function getDefaultWorkflowRunManager(): WorkflowRunManager;
 
-export { extractFileOps as $, DefaultSummaryCompaction as D, appendSessionLineageLabel as I, applyLineageTruncation as J, KODAX_API_MIN_INTERVAL as K, LINEAGE_ENTRY_TYPES as L, MessageQueue as M, applySessionCompaction as N, archiveOldIslands as O, PROMISE_PATTERN as P, buildSessionTree as Q, cleanupIncompleteToolCalls as R, countActiveLineageMessages as S, countTokens as T, createSessionLineage as U, createWorkflowCapsule as V, WORKFLOW_CAPSULE_API_VERSION as W, createWorkflowModuleFromCapsule as X, estimateTokens as Y, extractArtifactLedger as Z, _resetMessageQueueForTests as _, extractTitleFromMessages as a0, findPreviousUserEntryId as a1, forkSessionLineage as a2, generateSessionId as a3, getAgentConfigHome as a4, getAgentConfigPath as a5, getAppDataDir as a6, getMessageQueue as a7, getSessionLineagePath as a8, getSessionMessagesFromLineage as a9, mergeArtifactLedger as aa, mergeFileOps as ab, resolveSessionLineageTarget as ac, rewindSessionLineage as ad, setAgentConfigHome as ae, setSessionLineageActiveEntry as af, validateAndFixToolHistory as ag, validateWorkflowCapsule as ah, validateWorkflowScriptManifest as ai, KODAX_DEFAULT_TIMEOUT as f, KODAX_HARD_TIMEOUT as g, KODAX_MAX_INCOMPLETE_RETRIES as h, KODAX_MAX_MAXTOKENS_RETRIES as i, KODAX_MAX_RETRIES as j, KODAX_MAX_TOKENS as k, KODAX_RETRY_BASE_DELAY as l, KODAX_STAGGER_DELAY as m, LineageCompaction as o, LineageExtension as r, WORKFLOW_CAPSULE_FORMAT as v, WORKFLOW_CAPSULE_VERSION as w, WORKFLOW_PATTERN_IDS as x };
-export type { WorkflowCapsuleInputs as A, WorkflowCapsuleIntent as B, CompactionContext as C, WorkflowCapsuleProvenance as E, WorkflowCapsuleRequirements as F, WorkflowPatternId as G, WorkflowScriptManifest as H, CompactionEntry as a, CompactionEntryPayload as b, CompactionPolicy as c, CreateWorkflowCapsuleInput as d, DefaultSummaryCompactionOptions as e, LineageArtifactLedgerPayload as n, LineageCompactionDelegates as p, LineageEntryType as q, LineageLabelPayload as s, LineageTreeNode as t, PolicyCompactionResult as u, WorkflowCapsule as y, WorkflowCapsuleEnvironmentRequirement as z };
+export { buildWorkflowCapsuleIntent as $, WORKFLOW_CAPSULE_FORMAT as A, WORKFLOW_CAPSULE_VERSION as B, DefaultSummaryCompaction as D, WORKFLOW_PATTERN_IDS as E, KODAX_API_MIN_INTERVAL as K, LINEAGE_ENTRY_TYPES as L, PROMISE_PATTERN as P, appendSessionLineageLabel as U, applyLineageTruncation as V, WORKFLOW_CAPSULE_API_VERSION as W, applySessionCompaction as X, archiveOldIslands as Y, buildSessionTree as Z, _resetMessageQueueForTests as _, cleanupIncompleteToolCalls as a0, countActiveLineageMessages as a1, countTokens as a2, createSessionLineage as a3, createWorkflowCapsule as a4, createWorkflowModuleFromCapsule as a5, createWorkflowRunManager as a6, estimateTokens as a7, extractArtifactLedger as a8, extractFileOps as a9, extractTitleFromMessages as aa, findPreviousUserEntryId as ab, forkSessionLineage as ac, generateSessionId as ad, getAgentConfigHome as ae, getAgentConfigPath as af, getAppDataDir as ag, getDefaultWorkflowRunManager as ah, getMessageQueue as ai, getSessionLineagePath as aj, getSessionMessagesFromLineage as ak, mergeArtifactLedger as al, mergeFileOps as am, resolveSessionLineageTarget as an, rewindSessionLineage as ao, setAgentConfigHome as ap, setSessionLineageActiveEntry as aq, validateAndFixToolHistory as ar, validateWorkflowCapsule as as, validateWorkflowScriptManifest as at, KODAX_DEFAULT_TIMEOUT as f, KODAX_HARD_TIMEOUT as g, KODAX_MAX_INCOMPLETE_RETRIES as h, KODAX_MAX_MAXTOKENS_RETRIES as i, KODAX_MAX_RETRIES as j, KODAX_MAX_TOKENS as k, KODAX_RETRY_BASE_DELAY as l, KODAX_STAGGER_DELAY as m, LineageCompaction as o, LineageExtension as r, MessageQueue as y };
+export type { CompactionContext as C, WorkflowCapsule as F, WorkflowCapsuleEnvironmentRequirement as G, WorkflowCapsuleInputs as H, WorkflowCapsuleIntent as I, WorkflowCapsuleProvenance as J, ManagedRunClassification as M, WorkflowCapsuleRequirements as N, WorkflowPatternId as O, WorkflowProcessMetadata as Q, WorkflowRunManager as R, StartManagedRunInput as S, WorkflowScriptManifest as T, CompactionEntry as a, CompactionEntryPayload as b, CompactionPolicy as c, CreateWorkflowCapsuleInput as d, DefaultSummaryCompactionOptions as e, LineageArtifactLedgerPayload as n, LineageCompactionDelegates as p, LineageEntryType as q, LineageLabelPayload as s, LineageTreeNode as t, ManagedRunHooks as u, ManagedWorkflowRun as v, ManagedWorkflowSnapshot as w, ManagedWorkflowStatus as x, PolicyCompactionResult as z };

package/dist/types-chunks/{sdk-session-DAScB0rW.d.ts → sdk-session-ByZlwgdM.d.ts}

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

package/dist/types-chunks/{storage.d-CPvn9qI0.d.ts → storage.d-DHL3XpAL.d.ts}

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

package/dist/types-chunks/{guardrail.d-BP3yyr6u.d.ts → types.d-CE_Ter29.d.ts}

@@ -1,4 +1,4 @@
-import { y as Guardrail, aG as RunnerToolCall, d as Agent, f as AgentMessage, aJ as RunnerToolResult, aS as Span } from './process.d-BZncyzEj.js';
+import { z as Guardrail, aO as RunnerToolCall, e as Agent, g as AgentMessage, aR as RunnerToolResult, a_ as Span, _ as KodaXInputArtifact } from './process.d-BOrAxjvM.js';
 
 /**
  * Guardrail Runtime — FEATURE_085 (v0.7.26).
@@ -151,5 +151,127 @@ declare function runToolBeforeGuardrails(call: RunnerToolCall, guardrails: reado
  */
 declare function runToolAfterGuardrails(call: RunnerToolCall, result: RunnerToolResult, guardrails: readonly ToolGuardrail[], ctx: GuardrailContext, agentSpan: Span | null): Promise<RunnerToolResult>;
 
-export { GuardrailBlockedError as G, GuardrailEscalateError as b, collectGuardrails as e, runOutputGuardrails as f, runToolAfterGuardrails as g, runToolBeforeGuardrails as h, runInputGuardrails as r };
-export type { InputGuardrail as I, OutputGuardrail as O, ToolBeforeOutcome as T, GuardrailContext as a, GuardrailVerdict as c, ToolGuardrail as d };
+/**
+ * @kodax-ai/agent/messaging — Message queue types
+ *
+ * FEATURE_115 (v0.7.36): agentId-scoped 2-tier priority queue infrastructure.
+ *
+ * Per ADR-021: messaging is a generic agent-platform primitive (not coding-
+ * specific). Downstream consumers:
+ *   - @kodax-ai/coding runner-driven mid-turn drain
+ *   - @kodax-ai/repl InkREPL ESC soft-pause + text injection (FEATURE_111 absorbed)
+ *   - subagent task-notification routing (FEATURE_155 idle-yield wakeup)
+ *
+ * Phase 0.6 study (`c:/tmp/claude-code-actual-usage.md`): Claude Code's
+ * `'now'` priority has zero production usage; KodaX simplifies to 2 tiers.
+ */
+
+type MessagePriority = 'user' | 'background';
+type MessageMode = 'prompt' | 'task-notification' | 'system-reminder';
+type QueuedInputArtifact = KodaXInputArtifact;
+interface QueuedMessage {
+    /** Stable id for tracing / dedup. Format: `msg-<sequence>`. */
+    readonly id: string;
+    readonly priority: MessagePriority;
+    /**
+     * Routing key:
+     *   undefined = main thread / coordinator agent
+     *   'agent-id-XYZ' = subagent / specific consumer
+     *
+     * Drain consumers MUST filter by agentId match — undefined matches only
+     * undefined-agentId messages, not "any agent".
+     */
+    readonly agentId?: string;
+    readonly mode: MessageMode;
+    readonly content: string;
+    readonly inputArtifacts?: readonly QueuedInputArtifact[];
+    /** Wall-clock timestamp (`Date.now()`) for tracing only — not used for ordering. */
+    readonly enqueuedAt: number;
+}
+interface DequeueFilter {
+    /**
+     * Only return messages with this agentId.
+     * undefined matches messages with no agentId (main-thread messages only).
+     */
+    readonly agentId?: string;
+    /**
+     * Highest priority level included in the drain.
+     *   'user'       → only user priority drained, background stays queued
+     *   'background' → both user + background drained (Sleep-gated case)
+     */
+    readonly maxPriority: MessagePriority;
+    /**
+     * Optional cap on number of messages drained in this call.
+     * Defaults to unlimited (drains all matching).
+     */
+    readonly limit?: number;
+    /**
+     * FEATURE_159 (v0.7.40) — optional mode filter. Lets REPL split the
+     * single queue into mode-typed views (e.g. `mode:'prompt'` for user
+     * input vs `mode:'task-notification'` for child completion banners)
+     * without separate queues. When omitted, all modes match.
+     */
+    readonly mode?: MessageMode;
+    /**
+     * FEATURE_159 (v0.7.40) — optional precise-id filter. Single-message
+     * targeted removal — drives Esc-pop-this-uuid in REPL. When set, all
+     * other filters still apply (agentId / priority / mode mismatches still
+     * skip the message), so callers can't accidentally remove a message
+     * outside their scope.
+     */
+    readonly id?: string;
+    /**
+     * FEATURE_159 (v0.7.40) — optional escape-hatch predicate, AND-ed with
+     * the structured filters. Lets SDK consumers express conditions the
+     * typed fields don't cover (e.g. timestamp ranges, content-match) without
+     * forcing every new use case to extend `DequeueFilter`. KodaX-internal
+     * code should prefer the typed fields for readability; this is the
+     * "data-driven main path + predicate escape" pattern.
+     *
+     * Evaluated AFTER the typed filters succeed — so a `predicate` that
+     * inspects `message.content` never runs on messages outside the
+     * caller's `agentId` / `mode` / `id` scope.
+     */
+    readonly predicate?: (message: QueuedMessage) => boolean;
+}
+/**
+ * FEATURE_159 (v0.7.40) — structured queue event emitted to subscribers.
+ *
+ * Replaces the prior `() => void` bare-notify signal. Carries the kind +
+ * affected messages so SDK observability consumers (logging, tracing,
+ * metrics) can react per-event without re-diffing snapshots.
+ *
+ * Event granularity rules:
+ *   - `enqueued` fires ONCE per `enqueue()` call (always 1 message).
+ *   - `dequeued` fires ONCE per `dequeue()` call that removed ≥1 message,
+ *     carrying ALL drained messages in priority+FIFO order. No-op drains
+ *     (filter matched nothing) fire no event — quiet by design so the
+ *     `waitForWakeEvent` 100ms poll doesn't spam idle subscribers.
+ *   - `cleared` fires ONCE per `clear()` call that removed ≥1 message,
+ *     carrying the pre-clear messages. Empty-queue clear fires nothing.
+ *
+ * The `useSyncExternalStore` React hook ignores the event payload (it
+ * only needs the change signal); SDK / tracer consumers read the event.
+ */
+type QueueEvent = {
+    readonly kind: 'enqueued';
+    readonly message: QueuedMessage;
+} | {
+    readonly kind: 'dequeued';
+    readonly messages: readonly QueuedMessage[];
+} | {
+    readonly kind: 'cleared';
+    readonly messages: readonly QueuedMessage[];
+};
+/** FEATURE_159 — `MessageQueue.subscribe` listener signature. */
+type QueueEventListener = (event: QueueEvent) => void;
+interface EnqueueInput {
+    readonly priority: MessagePriority;
+    readonly mode: MessageMode;
+    readonly content: string;
+    readonly agentId?: string;
+    readonly inputArtifacts?: readonly QueuedInputArtifact[];
+}
+
+export { GuardrailBlockedError as G, GuardrailEscalateError as b, collectGuardrails as h, runOutputGuardrails as i, runToolAfterGuardrails as j, runToolBeforeGuardrails as k, runInputGuardrails as r };
+export type { DequeueFilter as D, EnqueueInput as E, InputGuardrail as I, MessageMode as M, OutputGuardrail as O, QueueEventListener as Q, ToolBeforeOutcome as T, GuardrailContext as a, GuardrailVerdict as c, MessagePriority as d, QueuedInputArtifact as e, QueuedMessage as f, ToolGuardrail as g };

package/dist/types-chunks/{types.d-6VOXvF88.d.ts → types.d-Ci5YPFEh.d.ts}

@@ -12,6 +12,31 @@ interface KodaXToolUseBlock {
     id: string;
     name: string;
     input: Record<string, unknown>;
+    /**
+     * Set true when `input` was salvaged from malformed JSON (strict `JSON.parse`
+     * threw). RAW signal — set regardless of stop reason. On its own it means the
+     * payload is syntactically suspect: even a "complete" turn can carry malformed
+     * JSON (e.g. unescaped quotes) that the partial-json salvage silently truncates
+     * mid-value. `checkIncompleteToolCalls` therefore treats a salvaged input on a
+     * MUTATING tool (write/edit/bash — `isToolMutation`) as incomplete even on a
+     * clean stop, because executing a silently-cut payload corrupts files; a
+     * salvaged input on a read-only tool is allowed through on a clean stop.
+     */
+    _salvaged?: boolean;
+    /**
+     * Set true when `input` was salvaged AND the stream did NOT end on a
+     * recognized clean stop (`max_tokens`/`length`, or an ambiguous/`unknown`
+     * stop). A truncating stop means the payload may be cut mid-value, so this is
+     * unsafe to execute for ANY tool (not just mutating ones) — the agent loop
+     * routes it into the incomplete-tool retry (CAP-072). Subset of `_salvaged`.
+     *
+     * Both markers are internal: provider serializers never write them to the wire
+     * (they read only type/id/name/input). They may transiently remain on an
+     * assistant tool_use block in session history on the retry-cap path; harmless
+     * and never reaches the model. Mirrors the `KodaXMessage._synthetic`
+     * convention.
+     */
+    _truncated?: boolean;
 }
 /**
  * Tool-result content blocks — a structural subset of the full
@@ -93,6 +118,14 @@ interface KodaXMessage {
     content: string | KodaXContentBlock[];
     /** Marks messages injected by the system (auto-continue, retry prompts). Hidden in REPL display. */
     _synthetic?: boolean;
+    /**
+     * Identifies which subsystem injected a synthetic message so consumers can
+     * render/attribute it distinctly instead of treating it like a user query.
+     * Absent on genuine user/assistant/system messages. Known values include
+     * `'sidecar-verifier'` (Sidecar Verifier revise feedback). Exposed verbatim
+     * through `KodaXResult.messages` and session-load APIs for SDK consumers.
+     */
+    _source?: string;
 }
 interface KodaXTokenUsage {
     inputTokens: number;
@@ -133,7 +166,7 @@ interface KodaXReasoningEffortPreset {
     readonly isDefault?: boolean;
     readonly isUserVisible?: boolean;
 }
-type KodaXReasoningEffortWireStrategy = 'openai-responses-effort' | 'openai-chat-effort' | 'codex-cli-config' | 'anthropic-output-effort' | 'provider-budget' | 'provider-toggle' | 'prompt-only' | 'none';
+type KodaXReasoningEffortWireStrategy = 'openai-responses-effort' | 'openai-chat-effort' | 'codex-cli-config' | 'anthropic-output-effort' | 'anthropic-reasoning-effort' | 'provider-budget' | 'provider-toggle' | 'prompt-only' | 'none';
 type KodaXThinkingWireStrategy = 'anthropic-adaptive' | 'anthropic-budget' | 'provider-budget' | 'provider-toggle' | 'none';
 interface KodaXReasoningProfile {
     readonly reasoningPreset?: KodaXReasoningPresetName;
@@ -540,10 +573,11 @@ interface KodaXProviderStreamOptions {
     }) => void;
     /** 会话标识，用于多轮对话上下文恢复 */
     /**
-     * Passive capability learning — fired when a provider HARD-rejects a
-     * reasoning-effort value (400/422 naming the param). The REPL records it in
-     * `capability-cache.json` so the rung is removed from the ladder and never
-     * offered or sent again (see `classifyReasoningEffortRejection`).
+     * Passive capability learning: fired when a provider HARD-rejects a
+     * reasoning-effort value (400/422 naming the param). Hosts can record it via
+     * the agent-layer capability cache so the rung is removed from the effective
+     * ladder and never offered or sent again (see
+     * `classifyReasoningEffortRejection`).
      */
     onReasoningEffortRejected?: (event: {
         provider: string;