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

package/dist/types-chunks/{utils.d-DcznBeQ3.d.ts → utils.d-CWiMhFfu.d.ts}

@@ -1,10 +1,11 @@
-import { k as KodaXMessage, G as KodaXReasoningMode, d as KodaXCustomProviderConfig, q as KodaXProviderCapabilityProfile } from './types.d-BrQMB-hy.js';
-import { ar as KodaXSessionUiHistoryItem, ag as KodaXSessionLineage, a7 as KodaXSessionArtifactLedgerEntry, W as KodaXExtensionSessionState, V as KodaXExtensionSessionRecord, an as KodaXSessionRuntimeInfo } from './types.d-CSv0_cZC.js';
-import { dl as WorkflowProcessSource } from './controller.d-J2t1q8Ly.js';
-import { S as KodaXContextTokenSnapshot, aN as KodaXSkillDynamicContextPolicy, v as KodaXAgentMode, an as KodaXRepoIntelligenceMode, a9 as KodaXOptions, as as KodaXResult, aO as KodaXSkillInvocationContext } from './bash-prefix-extractor.d-DWFIMg0v.js';
-import { d as AgentsFile, r as AutoModeStats, Z as KodaXMcpServersConfig } from './exec-policy.d-BPESl90L.js';
+import { aI as KodaXSessionUiHistoryItem, ax as KodaXSessionLineage, ao as KodaXSessionArtifactLedgerEntry, ab as KodaXExtensionSessionState, aa as KodaXExtensionSessionRecord, aE as KodaXSessionRuntimeInfo, af as KodaXGoalState, b9 as MemoryManagementController, by as PendingEpisodeReviewSummary } from './review-inbox.d-BeaLRNHx.js';
+import { k as KodaXMessage, G as KodaXReasoningMode, d as KodaXCustomProviderConfig, q as KodaXProviderCapabilityProfile } from './types.d-BjOq57-z.js';
+import { bu as WorkflowProcessSource, bt as WorkflowProcessSnapshot, bm as WorkflowProcessEvent } from './types.d-o7t9dds4.js';
+import { T as KodaXContextTokenSnapshot, aO as KodaXSkillDynamicContextPolicy, aP as KodaXSkillInvocationContext, w as KodaXAgentMode, ao as KodaXRepoIntelligenceMode, aa as KodaXOptions, at as KodaXResult } from './bash-prefix-extractor.d-DvswAXKS.js';
+import { d as AgentsFile, al as WorkflowRunProcessMetadata, a4 as ManagedWorkflowSnapshot, r as AutoModeStats, _ as KodaXMcpServersConfig } from './run-manager.d-C7Q71rin.js';
+import { aB as KodaXProductClient, ai as ClientSessionSettings } from './client-contract-A1jdk6xz.js';
 import * as readline from 'readline';
-import { U as PermissionMode, L as LearningBinding, M as LearningSurfaceSnapshot } from './public-api.d-amBop8Nk.js';
+import { U as PermissionMode, L as LearningBinding, M as LearningSurfaceSnapshot } from './public-api.d-Cq8ILMte.js';
 import { SpawnSyncReturns } from 'child_process';
 
 /**
@@ -34,17 +35,11 @@ interface AutoReviewSettings {
  * `permissionMode`'s scope) plus the classifier-model environment override.
  */
 interface AutoModeSettings {
-    /** @deprecated Legacy input accepted and ignored at the read boundary. */
-    engine?: 'llm' | 'rules';
     /**
      * Classifier model spec — `"provider:model"` or `"model"` (provider then
      * inherits from the main session). Feeds layer 4 of `resolveClassifierModel`.
      */
     classifierModel?: string;
-    /** @deprecated Accepted as inert migration input. Reviewer deadlines are fixed. */
-    timeoutMs?: number;
-    /** @deprecated Accepted as inert migration input. Sandbox-first routing has no speculative window. */
-    speculativeWindowMs?: number;
 }
 interface ResolvedAutoModeSettings {
     readonly classifierModel?: string;
@@ -64,7 +59,6 @@ interface ResolveAutoModeSettingsInput {
  * Env priority (highest first):
  *   - KODAX_AUTO_MODE_CLASSIFIER_MODEL: model spec — surfaced as `classifierModelEnv`
  *     so it reaches `AutoModeGuardrailConfig.envVar` (the resolver's layer 2)
- * Legacy timeout/window inputs and environment variables are ignored.
  */
 declare function loadAutoModeSettings(env?: NodeJS.ProcessEnv): ResolvedAutoModeSettings;
 /**
@@ -188,6 +182,8 @@ interface CommandExecutionMetadata {
     frontmatter?: Record<string, unknown>;
 }
 interface CurrentConfig {
+    /** Present on Host-bound displays; omitted values remain unknown rather than local defaults. */
+    hostSettings?: ClientSessionSettings;
     provider: string;
     model?: string;
     effort?: string;
@@ -222,26 +218,129 @@ type SessionBranchSwitchStatus = 'switched' | 'missing' | 'blocked';
 type SessionForkStatus = 'forked' | 'failed' | 'blocked';
 type SessionRewindStatus = 'rewound' | 'failed' | 'blocked';
 type SessionRecoverStatus = 'recovered' | 'empty' | 'failed' | 'blocked';
+/**
+ * FEATURE_298 T34 — goal persistence is Host-owned: the command plane
+ * sends the session id and objective; lineage mutation and journal
+ * writes happen inside the Host. Unbound REPLs keep the local
+ * appendGoalEntry + saveSession path (standalone capability).
+ */
+interface SessionGoalBinding {
+    read(sessionId: string): Promise<KodaXGoalState | null>;
+    create(input: {
+        readonly sessionId: string;
+        readonly objective: string;
+        readonly tokenBudget?: number;
+    }): Promise<KodaXGoalState>;
+    pause(sessionId: string): Promise<KodaXGoalState>;
+    resume(sessionId: string): Promise<KodaXGoalState>;
+    clear(sessionId: string): Promise<void>;
+}
+/**
+ * FEATURE_298 T34 — session-command mutations are Host-owned: the surface
+ * sends ids/selectors only and reads the resulting Host projections;
+ * unbound REPLs keep the direct SessionStorage paths (standalone).
+ */
+interface SessionCommandBinding {
+    list?: KodaXProductClient['sessions']['list'];
+    read?: KodaXProductClient['sessions']['read'];
+    getSettings?: KodaXProductClient['sessions']['getSettings'];
+    readLineage?: KodaXProductClient['sessions']['readLineage'];
+    delete(sessionId: string): Promise<void>;
+    deleteAll(input: {
+        readonly gitRoot?: string;
+    }): Promise<void>;
+    /** Returns false when no lineage entry matches the selector. */
+    setActiveEntry(input: {
+        readonly sessionId: string;
+        readonly selector: string;
+        readonly summarizeCurrentBranch?: boolean;
+    }): Promise<boolean>;
+    /** Returns false when no lineage entry matches the selector. */
+    setLabel(input: {
+        readonly sessionId: string;
+        readonly selector: string;
+        readonly label?: string;
+    }): Promise<boolean>;
+    /** Returns the new session id, or undefined when the fork failed. */
+    fork(input: {
+        readonly sessionId: string;
+        readonly selector?: string;
+    }): Promise<string | undefined>;
+    /** Returns false when the rewind failed. */
+    rewind(input: {
+        readonly sessionId: string;
+        readonly selector?: string;
+        readonly expectedHead?: string | null;
+    }): Promise<boolean>;
+    /** Recovers into a fresh Host-derived seed session; returns its id. */
+    recover(input: {
+        readonly sessionId: string;
+        readonly reason?: string;
+    }): Promise<string | undefined>;
+    create(input: {
+        readonly sessionId: string;
+        readonly title: string;
+        readonly gitRoot?: string;
+        readonly projectPath?: string;
+        readonly surface: string;
+    }): Promise<void>;
+}
+/**
+ * FEATURE_298 T34 — manual compaction is a Host session command: the Host
+ * replays its journal through the compaction domain and persists the
+ * result; the REPL only refreshes its display context.
+ */
+interface SessionCompactBinding {
+    compact(input: {
+        readonly sessionId: string;
+        readonly customInstructions?: string;
+    }): Promise<{
+        readonly compacted: boolean;
+        readonly tokensBefore: number;
+        readonly tokensAfter: number;
+        readonly messages: readonly KodaXMessage[];
+        readonly reason?: string;
+    }>;
+}
 interface CommandCallbacks {
+    config?: KodaXProductClient['config'];
+    catalog?: Pick<KodaXProductClient['catalog'], 'providers' | 'models' | 'reasoningEfforts'>;
+    commandClient?: KodaXProductClient['commands'];
+    listHostCommands?: KodaXProductClient['catalog']['commands'];
+    inspectExtensions?: KodaXProductClient['catalog']['extensions'];
+    mcp?: Pick<KodaXProductClient['mcp'], 'status' | 'listTools'>;
+    /** Host-owned reasoning-effort probing; unbound keeps the local provider path. */
+    providerCapabilities?: Pick<KodaXProductClient['catalog'], 'reasoningEfforts' | 'probeReasoningEfforts' | 'forgetCapabilities'>;
+    startReview?: KodaXProductClient['review']['start'];
+    reviewAgentsLean?: KodaXProductClient['agents']['reviewLean'];
     exit: () => void | Promise<void>;
     /** Compaction supplies authoritative lineage; ordinary saves may omit it. */
     saveSession: (compactionLineage?: KodaXSessionLineage) => Promise<void>;
-    startNewSession?: () => void;
+    /** FEATURE_298 T34 — Host-owned goal plane; unbound keeps the local lineage path. */
+    readonly goal?: SessionGoalBinding;
+    /**
+     * FEATURE_298 T34 — after a bound session mutation, re-read the lineage
+     * the Host just wrote so local display and the embedded goal runtime
+     * stay coherent without a second writer.
+     */
+    readonly refreshSessionLineage?: () => Promise<KodaXSessionLineage | undefined>;
+    /** FEATURE_298 T34 — Host-owned manual compaction; unbound compacts locally. */
+    readonly compactSession?: SessionCompactBinding;
+    startNewSession?: () => void | Promise<void>;
     loadSession: (id: string) => Promise<SessionLoadStatus>;
-    listSessions: () => Promise<void>;
+    listSessions: () => Promise<void | CommandResultData>;
     /** Clear presentation only. Commands own changes to messages/token state. */
     clearHistory: () => void;
-    printHistory: () => void;
-    switchProvider?: (provider: string, model?: string) => void;
-    setEffort?: (effort?: string) => void;
-    setThinking?: (enabled: boolean) => void;
-    setReasoningMode?: (mode: KodaXReasoningMode) => void;
-    setAgentMode?: (mode: KodaXAgentMode) => void;
+    printHistory: () => void | CommandResultData | Promise<void | CommandResultData>;
+    switchProvider?: (provider: string, model?: string) => void | Promise<void>;
+    setEffort?: (effort?: string) => void | Promise<void>;
+    setReasoningMode?: (mode: KodaXReasoningMode) => void | Promise<void>;
+    setAgentMode?: (mode: KodaXAgentMode) => void | Promise<void>;
     setPermissionMode?: (mode: PermissionMode) => void | Promise<void>;
     setRepoIntelligenceRuntime?: (update: {
         mode?: KodaXRepoIntelligenceMode;
         trace?: boolean;
-    }) => void;
+    }) => void | Promise<void>;
     deleteSession?: (id: string) => Promise<void>;
     deleteAllSessions?: () => Promise<void>;
     createKodaXOptions?: () => KodaXOptions;
@@ -305,6 +404,10 @@ interface CommandCallbacks {
     rewindSession?: (selector?: string) => Promise<SessionRewindStatus>;
     getCostReport?: () => string | null;
     getRuntimeStatus?: () => Promise<RuntimeSurfaceStatus | undefined>;
+    getSessionStatus?: () => Promise<{
+        messageCount?: number;
+        tokens?: number;
+    }>;
     /** Canonical host parser used by `/setup` for the root-owned A2A schema. */
     validateSetupA2AConfig?: (value: unknown) => unknown;
     /** Root-owned sandbox activation because ASRT is distributed by the host package. */
@@ -322,6 +425,18 @@ interface CommandCallbacks {
         readonly guidance: readonly string[];
     }>;
     learning?: LearningBinding;
+    /**
+     * FEATURE_298 T36 — Host-owned Memory management plane for a project
+     * root. Absent means Memory controls report unavailable; the UI never
+     * builds its own identity/controller.
+     */
+    memory?: (projectRoot: string) => MemoryCommandPlane | Promise<MemoryCommandPlane>;
+    /**
+     * FEATURE_298 T22 — Host-owned workflow control plane. When present,
+     * run/control operations (list/get/pause/resume/stop/start) route to the
+     * Host manager so every client of the same Host sees the same work.
+     */
+    workflows?: WorkflowHostControl;
     getLearningSummary?: () => Promise<LearningSurfaceSnapshot>;
     openLearningCenter?: (nameOrSlug?: string) => Promise<void>;
     /**
@@ -335,6 +450,7 @@ interface CommandCallbacks {
     ui: UIContext;
 }
 interface CommandResultData {
+    startedRunId?: string;
     success?: boolean;
     message?: string;
     data?: unknown;
@@ -425,6 +541,65 @@ interface Command {
     hooks?: CommandHooks;
     frontmatter?: Record<string, unknown>;
 }
+interface MemoryRebuildResult {
+    readonly status: 'missing-dir' | 'no-topics' | 'rebuilt';
+    readonly memoryRoot: string;
+    readonly entrypointPath: string;
+    readonly entryCount: number;
+    readonly malformedFiles: readonly string[];
+    readonly warnings: readonly string[];
+}
+interface MemoryCommandPlane {
+    readonly controller: Pick<MemoryManagementController, 'listInbox' | 'showProposal' | 'approveProposal' | 'rejectProposal' | 'listRefs' | 'readRef' | 'remember' | 'forgetRef'>;
+    readonly memoryRoot: string;
+    readonly entrypointPath: string;
+    listReviews(): Promise<readonly PendingEpisodeReviewSummary[]>;
+    reviewerProviderConfigured(): boolean;
+    rebuild(): Promise<MemoryRebuildResult>;
+    ensureOpenTarget(targetPath: string): Promise<string>;
+}
+interface WorkflowHostControl {
+    start(input: {
+        readonly sessionId?: string;
+        readonly projectRoot: string;
+        readonly source: {
+            readonly kind: 'inline';
+            readonly manifest: unknown;
+            readonly source: string;
+        } | {
+            readonly kind: 'request';
+            readonly request: string;
+        } | {
+            readonly kind: 'name';
+            readonly name: string;
+        };
+        readonly args?: unknown;
+        readonly provider?: string;
+        readonly model?: string;
+        /** FEATURE_298 T22 — serializable run lineage the Host attaches verbatim. */
+        readonly metadata?: WorkflowRunProcessMetadata;
+    }): Promise<{
+        readonly kind: 'declined';
+        readonly reason: string;
+    } | {
+        readonly kind: 'started';
+        readonly runId: string;
+    }>;
+    list(): Promise<readonly ManagedWorkflowSnapshot[]>;
+    get(runId: string): Promise<WorkflowProcessSnapshot | undefined>;
+    /** FEATURE_298 T22 — live process events for a Host-minted run. */
+    subscribe(filter: {
+        readonly runId?: string;
+    }, listener: (event: WorkflowProcessEvent) => void, onError?: (error: unknown) => void): {
+        readonly ready?: Promise<void>;
+        close(): void;
+    };
+    pause(runId: string): Promise<boolean>;
+    resume(runId: string): Promise<boolean>;
+    stop(runId: string, options?: {
+        readonly sessionId: string;
+    }): Promise<boolean>;
+}
 
 /**
  * KodaX CLI Utilities
@@ -487,6 +662,7 @@ declare function registerConfiguredCustomProviders(config: {
 declare function getVersion(): string;
 declare const KODAX_VERSION: string;
 declare function getProviderModel(name: string): string | null;
+declare function getProviderReasoningEffortOptions(provider: string, model?: string, configHome?: string): string[];
 declare function getProviderList(providerModelsConfig?: Record<string, string[]>): Array<{
     name: string;
     model: string;
@@ -500,7 +676,6 @@ declare function isProviderConfigured(name: string): boolean;
 declare function loadConfig(): {
     provider?: string;
     model?: string;
-    runtimeMode?: 'embedded' | 'daemon';
     effort?: string;
     planModeEffort?: string;
     thinking?: boolean;
@@ -582,16 +757,6 @@ declare function loadConfig(): {
     workflow?: {
         maxConcurrency?: number;
     };
-    /**
-     * Worker-hosted embedded Runtime options. `configuredA2A` lets a
-     * Worker-hosted embedded Runtime load and reconcile
-     * `<homeDir>/.kodax/integrations/a2a.json` inside the Worker owner,
-     * installing the full list/describe/preflight and external Actor dispatch
-     * surface so configured A2A Agents appear as `external:<name>`.
-     */
-    worker?: {
-        configuredA2A?: boolean;
-    };
 };
 /**
  * F1 — first-launch onboarding. config.json must be STRICT JSON (no comments), so we
@@ -623,11 +788,12 @@ declare const KODAX_CONFIG_ENV_BINDINGS: ReadonlyArray<{
     readonly configPath: string;
     readonly env: string;
 }>;
+/** Only these existing commands promise immediate control of later execution. */
+declare function applyExecutionConfigEnvironment(config: ReturnType<typeof loadConfig>, explicit?: boolean): void;
 declare function prepareRuntimeConfig(): ReturnType<typeof loadConfig>;
 declare function saveConfig(config: {
     provider?: string;
     model?: string;
-    runtimeMode?: 'embedded' | 'daemon';
     effort?: string;
     planModeEffort?: string;
     thinking?: boolean;
@@ -704,5 +870,5 @@ declare function resolveRuntimeEffortSelection(input: {
 declare function getGitRoot(cwd?: string): Promise<string | null>;
 declare function rateLimitedCall<T>(fn: () => Promise<T>): Promise<T>;
 
-export { inspectConfigEnvironmentSource as B, isProviderConfigured as D, loadAutoModeSettings as E, loadConfig as F, prepareRuntimeConfig as G, rateLimitedCall as H, registerConfiguredCustomProviders as J, KODAX_CONFIG_ENV_BINDINGS as K, resolveAutoModeSettings as L, resolveRuntimeEffortSelection as M, resolveRuntimeModelSelection as N, resolveRuntimeProviderSelection as O, PREVIEW_MAX_LENGTH as P, saveConfig as Q, touchContext as S, KODAX_CONFIG_FILE as j, KODAX_DIR as k, KODAX_EXAMPLE_CONFIG_FILE as l, KODAX_INTEGRATION_EXAMPLE_FILES as m, KODAX_SESSIONS_DIR as n, KODAX_VERSION as o, createInteractiveContext as s, ensureExampleConfigFile as t, ensureExampleConfigFiles as u, getGitRoot as v, getProviderList as w, getProviderModel as x, getVersion as y, hydrateProcessEnvFromShell 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, ConfigEnvironmentSource as g, CurrentConfig as h, InteractiveMode as i, ResolvedAutoModeSettings as p, RuntimeSurfaceMode as q, RuntimeSurfaceStatus as r };
+export { getGitRoot as B, getProviderList as D, getProviderModel as E, getProviderReasoningEffortOptions as F, getVersion as G, hydrateProcessEnvFromShell as H, inspectConfigEnvironmentSource as J, KODAX_CONFIG_ENV_BINDINGS as K, isProviderConfigured as L, loadAutoModeSettings as M, loadConfig as N, prepareRuntimeConfig as O, PREVIEW_MAX_LENGTH as P, rateLimitedCall as Q, registerConfiguredCustomProviders as T, resolveAutoModeSettings as U, resolveRuntimeEffortSelection as V, resolveRuntimeModelSelection as W, resolveRuntimeProviderSelection as X, saveConfig as Y, touchContext as Z, KODAX_CONFIG_FILE as l, KODAX_DIR as m, KODAX_EXAMPLE_CONFIG_FILE as n, KODAX_INTEGRATION_EXAMPLE_FILES as o, KODAX_SESSIONS_DIR as p, KODAX_VERSION as q, applyExecutionConfigEnvironment as w, createInteractiveContext as x, ensureExampleConfigFile as y, ensureExampleConfigFiles as z };
+export type { AutoModeSettings as A, Command as C, InteractiveContext as I, ResolveAutoModeSettingsInput as R, SessionCommandBinding as S, CommandCallbacks as a, CommandDefinition as b, CommandExecutionMetadata as c, CommandInfo as d, CommandInvocationRequest as e, CommandPriority as f, CommandSource as g, CommandWorkflowInvocationRequest as h, ConfigEnvironmentSource as i, CurrentConfig as j, InteractiveMode as k, ResolvedAutoModeSettings as r, RuntimeSurfaceMode as s, RuntimeSurfaceStatus as t, SessionCompactBinding as u, SessionGoalBinding as v };