@kodax-ai/kodax 0.7.68 → 0.7.69

package/dist/sdk-runtime.d.ts

@@ -1,33 +1,144 @@
-import { F as KodaXReasoningMode, d as KodaXCustomProviderConfig } from './types-chunks/types.d-CO_ZkmOd.js';
-export { k as KodaXMessage } from './types-chunks/types.d-CO_ZkmOd.js';
-import { X as KodaXOptions, L as KodaXEvents, a5 as KodaXResult, b0 as RuntimeContextBudgetSnapshot, b7 as RuntimeToolExposurePlan } from './types-chunks/bash-prefix-extractor.d-Dm-T865v.js';
-import { x as AgentExecutorFactory, p as AgentDispatchPolicy, n as AgentCredentialBroker, g as AgentArtifactPolicy, o as AgentDispatchContext, aP as KodaXImageInputArtifact, aS as KodaXInputArtifactSource, bo as KodaXVideoInputArtifact, dq as WorkflowProcessSnapshot, dj as WorkflowProcessEvent, N as AgentRegistrationService, am as DispatchableAgentQuery, ak as DispatchableAgentListing, K as AgentPreflightInput, L as AgentPreflightResult, V as AgentTaskService } from './types-chunks/types.d-D2frCRaY.js';
+import { F as KodaXReasoningMode, d as KodaXCustomProviderConfig } from './types-chunks/types.d-TTvpAGWf.js';
+export { k as KodaXMessage } from './types-chunks/types.d-TTvpAGWf.js';
+import { Y as KodaXOptions, R as KodaXManagedTaskStatusEvent, L as KodaXEvents, a6 as KodaXResult, b5 as RuntimeContextBudgetSnapshot, bc as RuntimeToolExposurePlan, H as KodaXContextOptions, K as KodaXActivityEventMeta, aA as KodaXToolEventMeta, aH as KodaXTurnStartedEvent, aE as KodaXTurnCompletedEvent, aG as KodaXTurnFailedEvent } from './types-chunks/bash-prefix-extractor.d-BkIA8Wto.js';
+import { o as AgentDispatchContext, x as AgentExecutorFactory, p as AgentDispatchPolicy, n as AgentCredentialBroker, g as AgentArtifactPolicy, aP as KodaXImageInputArtifact, aS as KodaXInputArtifactSource, bo as KodaXVideoInputArtifact, dt as WorkflowProcessSnapshot, dm as WorkflowProcessEvent, N as AgentRegistrationService, am as DispatchableAgentQuery, ak as DispatchableAgentListing, K as AgentPreflightInput, L as AgentPreflightResult, V as AgentTaskService } from './types-chunks/types.d-BtC4yLYO.js';
 import { i as SkillMetadata } from './types-chunks/types.d-vJExiRje.js';
 import { a as McpServerConfig } from './types-chunks/config.d-CJy1WENT.js';
-import { s as McpServerStatus, t as McpServerToolList } from './types-chunks/manager.d-Zum9cGHU.js';
-import { c as ManagedWorkflowSnapshot } from './types-chunks/run-manager.d-CSj7_kWk.js';
-import { L as LoadedExtensionDiagnostic, u as ExtensionRuntimeDiagnostics } from './types-chunks/types.d-CzscbsG0.js';
-import { D as saveConfig, c as CommandInfo } from './types-chunks/utils.d-DOXxnOnI.js';
-import { d as FullTranscriptSessionData, j as SessionTranscriptEntry, a as CompactSessionResult } from './types-chunks/public-api.d-BcKbBy1E.js';
+import { s as McpServerStatus, t as McpServerToolList } from './types-chunks/manager.d-CoEuPRAo.js';
+import { c as ManagedWorkflowSnapshot } from './types-chunks/run-manager.d-BaXtkryp.js';
+import { L as LoadedExtensionDiagnostic, u as ExtensionRuntimeDiagnostics } from './types-chunks/types.d-C9YHEAmA.js';
+import { F as saveConfig, c as CommandInfo } from './types-chunks/utils.d-BbB5jzi1.js';
+import { d as FullTranscriptSessionData, j as SessionTranscriptEntry, a as CompactSessionResult } from './types-chunks/public-api.d-7G4--RZE.js';
 import 'vscode-languageserver-protocol';
-import './types-chunks/cost-tracker.d-CBLk1fiD.js';
+import './types-chunks/cost-tracker.d-BeaenODW.js';
 import './types-chunks/capability.d-3C62G8Eq.js';
-import './types-chunks/base.d-C8mXDhLL.js';
-import './types-chunks/guardrail.d-CPDfZyJp.js';
-import './types-chunks/guardrail.d-D7r6zVSR.js';
+import './types-chunks/base.d-CYjtB68X.js';
+import './types-chunks/guardrail.d-R7AiGfrI.js';
+import './types-chunks/guardrail.d-6ZDbNbHO.js';
 import 'readline';
 import 'child_process';
 
+interface RuntimeUserMarkdownAgentRef {
+    readonly source: 'markdown:user';
+    readonly name: string;
+}
+interface RuntimeEffectiveSkillRef {
+    readonly name: string;
+    readonly source: 'workspace' | 'user' | 'plugin' | 'builtin';
+    readonly revision: string;
+}
+type RuntimeWorkspaceBinding = {
+    readonly mode: 'managed';
+} | {
+    readonly mode: 'fixed';
+    readonly root: string;
+};
+interface RuntimeExecutionToolPolicy {
+    readonly workspace: 'none' | 'read' | 'write';
+    readonly process: 'deny' | 'isolated';
+    readonly network: {
+        readonly mode: 'deny';
+    } | {
+        readonly mode: 'allowlist';
+        readonly origins: readonly string[];
+    };
+    readonly tools: readonly string[];
+    readonly mcp: Readonly<Record<string, readonly string[]>>;
+    readonly skillScripts: Readonly<Record<string, readonly string[]>>;
+    readonly subagents: 'deny' | 'inherit';
+}
+interface RuntimeResolvedLocalAgent {
+    readonly ref: RuntimeUserMarkdownAgentRef;
+    readonly agentId: string;
+    readonly displayName: string;
+    readonly description: string;
+    readonly configurationRevision: string;
+    readonly effectiveSkills: readonly RuntimeEffectiveSkillRef[];
+    readonly skillSetRevision: string;
+}
+interface RuntimeAgentOwnerSession {
+    readonly ownerSessionId: string;
+}
+interface RuntimeBoundDefaultAgent {
+    readonly ownerSessionId: string;
+    readonly bindingId: string;
+    readonly executionPolicyRevision: string;
+    readonly toolPolicyRevision: string;
+    readonly workspaceBindingRevision: string;
+    readonly skillSetRevision: string;
+    readonly effectiveSkills: readonly RuntimeEffectiveSkillRef[];
+    readonly effectiveTools: readonly string[];
+}
+interface RuntimeBoundLocalAgent extends RuntimeResolvedLocalAgent {
+    readonly ownerSessionId: string;
+    readonly bindingId: string;
+    readonly executionPolicyRevision: string;
+    readonly toolPolicyRevision: string;
+    readonly workspaceBindingRevision: string;
+    readonly effectiveTools: readonly string[];
+}
+interface RuntimeAgentStartBase {
+    readonly ownerSessionId: string;
+    readonly bindingId: string;
+    readonly expectedExecutionPolicyRevision: string;
+    readonly sessionId: string;
+    readonly input: RuntimeInput | readonly RuntimeInput[];
+    readonly permissionBroker?: RuntimePermissionBroker;
+    readonly agentContext?: AgentDispatchContext;
+}
+interface RuntimeDefaultAgentStartInput extends RuntimeAgentStartBase {
+}
+interface RuntimeLocalAgentStartInput extends RuntimeAgentStartBase {
+    readonly expectedConfigurationRevision: string;
+}
+interface RuntimeAgentBindingService {
+    resolveLocal(input: {
+        readonly ref: RuntimeUserMarkdownAgentRef;
+        readonly workspace: RuntimeWorkspaceBinding;
+    }): Promise<RuntimeResolvedLocalAgent>;
+    openOwnerSession(): Promise<RuntimeAgentOwnerSession>;
+    bindDefault(input: {
+        readonly ownerSessionId: string;
+        readonly profileId?: string;
+        readonly workspace: RuntimeWorkspaceBinding;
+        readonly toolPolicy: RuntimeExecutionToolPolicy;
+        readonly expectedExecutionPolicyRevision?: string;
+        readonly workspaceByteLimit?: number;
+    }): Promise<RuntimeBoundDefaultAgent>;
+    startDefault(input: RuntimeDefaultAgentStartInput): Promise<RuntimeRunHandle>;
+    bindLocal(input: {
+        readonly ownerSessionId: string;
+        readonly ref: RuntimeUserMarkdownAgentRef;
+        readonly profileId?: string;
+        readonly workspace: RuntimeWorkspaceBinding;
+        readonly toolPolicy: RuntimeExecutionToolPolicy;
+        readonly expectedConfigurationRevision?: string;
+        readonly expectedExecutionPolicyRevision?: string;
+        readonly workspaceByteLimit?: number;
+    }): Promise<RuntimeBoundLocalAgent>;
+    startLocal(input: RuntimeLocalAgentStartInput): Promise<RuntimeRunHandle>;
+    prepareWorkspace(input: {
+        readonly ownerSessionId: string;
+        readonly bindingId: string;
+        readonly contextKey: string;
+    }): Promise<string>;
+    releaseBinding(input: {
+        readonly ownerSessionId: string;
+        readonly bindingId: string;
+    }): Promise<void>;
+    closeOwnerSession(ownerSessionId: string): Promise<void>;
+}
+
 declare const KODAX_DAEMON_PROTOCOL = "kodax-runtime-daemon";
 declare const KODAX_DAEMON_PROTOCOL_VERSION = 1;
-type RuntimeDaemonMethod = 'initialize' | 'runtime.initialize' | 'ping' | 'runtime.identity' | 'runtime.status' | 'runtime.shutdown' | 'runtime.capabilities' | 'daemon.status' | 'daemon.stop' | 'daemon.logs' | 'session.create' | 'session.load' | 'session.list' | 'session.transcript' | 'session.fork' | 'session.notice.append' | 'session.rewind' | 'session.active_entry.set' | 'session.activeEntry.set' | 'session.compact' | 'session.archive' | 'session.unarchive' | 'session.delete' | 'session.settings.get' | 'session.settings.update' | 'run.start' | 'run.get' | 'run.list' | 'run.await' | 'run.abort' | 'run.model.set' | 'run.provider.set' | 'run.reasoning.set' | 'run.setModel' | 'run.setProvider' | 'run.setReasoning' | 'event.subscribe' | 'event.unsubscribe' | 'event.replay' | 'permission.list' | 'permission.listPending' | 'permission.request' | 'permission.respond' | 'workflow.list' | 'workflow.get' | 'workflow.subscribe' | 'workflow.unsubscribe' | 'workflow.pause' | 'workflow.resume' | 'workflow.stop' | 'config.read' | 'config.patch' | 'config.reload' | 'model.list' | 'provider.list' | 'provider.custom.list' | 'provider.custom.upsert' | 'provider.custom.remove' | 'mcp.server.list' | 'mcp.server.get' | 'mcp.server.validate' | 'mcp.server.upsert' | 'mcp.server.delete' | 'mcp.server.remove' | 'mcp.server.reload' | 'mcp.tool.list' | 'extension.list' | 'extension.reload' | 'command.list' | 'command.resolve' | 'skill.list' | 'skill.describe' | 'skill.read' | 'artifact.create' | 'artifact.get' | 'artifact.delete' | 'agentRegistrations.list' | 'agentRegistrations.upsert' | 'agentRegistrations.remove' | 'agents.listDispatchable' | 'agents.describe' | 'agents.preflight' | 'agentTasks.list' | 'agentTasks.start' | 'agentTasks.get' | 'agentTasks.events' | 'agentTasks.wait' | 'agentTasks.sendInput' | 'agentTasks.cancel' | 'agentTasks.reconcile' | 'context.budget.get' | 'tool.exposure.preview';
-type RuntimeDaemonNotificationMethod = 'event' | 'runtime.warning';
+type RuntimeDaemonMethod = 'initialize' | 'runtime.initialize' | 'ping' | 'runtime.identity' | 'runtime.status' | 'runtime.shutdown' | 'runtime.capabilities' | 'daemon.status' | 'daemon.stop' | 'daemon.logs' | 'daemon.preflight' | 'operation.get' | 'session.create' | 'session.load' | 'session.list' | 'session.transcript' | 'session.observe' | 'session.fork' | 'session.notice.append' | 'session.rewind' | 'session.active_entry.set' | 'session.activeEntry.set' | 'session.compact' | 'session.archive' | 'session.unarchive' | 'session.delete' | 'session.settings.get' | 'session.settings.getVersioned' | 'session.settings.update' | 'session.settings.updateVersioned' | 'run.start' | 'run.input.submit' | 'run.get' | 'run.list' | 'run.await' | 'run.abort' | 'run.model.set' | 'run.provider.set' | 'run.reasoning.set' | 'run.setModel' | 'run.setProvider' | 'run.setReasoning' | 'event.subscribe' | 'event.unsubscribe' | 'event.replay' | 'permission.list' | 'permission.listPending' | 'permission.request' | 'permission.respond' | 'permission.grants.list' | 'permission.grants.revoke' | 'user_input.listPending' | 'user_input.respond' | 'user_input.dismiss' | 'credential.register' | 'credential.get' | 'credential.revoke' | 'credential.supply' | 'host_tool.register' | 'host_tool.get' | 'host_tool.invocation.get' | 'host_tool.revoke' | 'host_tool.complete' | 'workflow.list' | 'workflow.get' | 'workflow.subscribe' | 'workflow.unsubscribe' | 'workflow.pause' | 'workflow.resume' | 'workflow.stop' | 'config.read' | 'config.patch' | 'config.reload' | 'model.list' | 'provider.list' | 'provider.custom.list' | 'provider.custom.upsert' | 'provider.custom.remove' | 'mcp.server.list' | 'mcp.server.get' | 'mcp.server.validate' | 'mcp.server.upsert' | 'mcp.server.delete' | 'mcp.server.remove' | 'mcp.server.reload' | 'mcp.tool.list' | 'extension.list' | 'extension.reload' | 'command.list' | 'command.resolve' | 'skill.list' | 'skill.describe' | 'skill.read' | 'artifact.create' | 'artifact.get' | 'artifact.delete' | 'agentRegistrations.list' | 'agentRegistrations.upsert' | 'agentRegistrations.remove' | 'agents.listDispatchable' | 'agents.describe' | 'agents.preflight' | 'agentTasks.list' | 'agentTasks.start' | 'agentTasks.get' | 'agentTasks.events' | 'agentTasks.wait' | 'agentTasks.sendInput' | 'agentTasks.cancel' | 'agentTasks.reconcile' | 'context.budget.get' | 'tool.exposure.preview';
+type RuntimeDaemonNotificationMethod = 'event' | 'credential.request' | 'host_tool.invoke' | 'runtime.warning';
 interface RuntimeDaemonError {
     readonly code: RuntimeDaemonErrorCode;
     readonly message: string;
     readonly data?: unknown;
 }
-type RuntimeDaemonErrorCode = 'invalid_frame' | 'invalid_request' | 'invalid_params' | 'not_initialized' | 'method_not_found' | 'unauthorized' | 'permission_denied' | 'conflict' | 'not_found' | 'cancelled' | 'overloaded' | 'internal_error';
+type RuntimeDaemonErrorCode = 'invalid_frame' | 'invalid_request' | 'invalid_params' | 'not_initialized' | 'method_not_found' | 'unauthorized' | 'permission_denied' | 'conflict' | 'not_found' | 'session_not_admitted' | 'cancelled' | 'overloaded' | 'client_upgrade_required' | 'operation_required' | 'operation_epoch_mismatch' | 'operation_id_reuse' | 'operation_interrupted' | 'operation_unknown' | 'control_history_untrusted' | 'credential_unavailable' | 'host_tool_unavailable' | 'host_tool_unknown' | 'internal_error';
 interface RuntimeDaemonFrameBase {
     readonly protocol: typeof KODAX_DAEMON_PROTOCOL;
     readonly version: typeof KODAX_DAEMON_PROTOCOL_VERSION;
@@ -37,6 +148,11 @@ interface RuntimeDaemonRequest extends RuntimeDaemonFrameBase {
     readonly id: string;
     readonly method: RuntimeDaemonMethod;
     readonly params?: unknown;
+    readonly operation?: RuntimeDaemonOperationEnvelope;
+}
+interface RuntimeDaemonOperationEnvelope {
+    readonly operationId: string;
+    readonly journalEpoch: string;
 }
 interface RuntimeDaemonSuccessResponse extends RuntimeDaemonFrameBase {
     readonly kind: 'response';
@@ -57,10 +173,22 @@ type RuntimeDaemonFrame = RuntimeDaemonRequest | RuntimeDaemonSuccessResponse |
 declare const RUNTIME_DAEMON_METHODS: readonly RuntimeDaemonMethod[];
 
 interface RuntimeDaemonClientTransport {
-    request(method: RuntimeDaemonMethod, params?: unknown): Promise<unknown>;
+    request(method: RuntimeDaemonMethod, params?: unknown, operation?: RuntimeDaemonOperationEnvelope): Promise<unknown>;
     subscribe(listener: (notification: RuntimeDaemonNotification) => void): RuntimeSubscription;
+    subscribeLifecycle?(listener: (state: RuntimeDaemonTransportLifecycleState) => void): RuntimeSubscription;
     close?(): Promise<void> | void;
 }
+interface RuntimeDaemonTransportLifecycleState {
+    readonly state: 'connected' | 'disconnected';
+    readonly connectionId: string;
+    readonly reason?: string;
+    readonly reconnectable: boolean;
+}
+declare class RuntimeTransportBoundaryError extends Error {
+    readonly path: string;
+    readonly code: "invalid_transport_value";
+    constructor(path: string, message: string);
+}
 
 interface RuntimeWorkerResourceLimits {
     readonly maxOldGenerationSizeMb?: number;
@@ -77,6 +205,8 @@ interface RuntimeDaemonEndpoint {
     readonly path: string;
 }
 
+declare function parseRuntimeEvent(value: unknown): RuntimeEventParseResult;
+
 type RuntimeDaemonJsonSchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
 interface RuntimeDaemonJsonSchema {
     readonly type?: RuntimeDaemonJsonSchemaType | readonly RuntimeDaemonJsonSchemaType[];
@@ -139,6 +269,14 @@ declare const RUNTIME_DAEMON_METHOD_SCHEMAS: {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
     };
+    'daemon.preflight': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'operation.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
     'session.create': {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
@@ -155,6 +293,10 @@ declare const RUNTIME_DAEMON_METHOD_SCHEMAS: {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
     };
+    'session.observe': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
     'session.fork': {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
@@ -195,14 +337,26 @@ declare const RUNTIME_DAEMON_METHOD_SCHEMAS: {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
     };
+    'session.settings.getVersioned': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
     'session.settings.update': {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
     };
+    'session.settings.updateVersioned': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
     'run.start': {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
     };
+    'run.input.submit': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
     'run.get': {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
@@ -271,6 +425,68 @@ declare const RUNTIME_DAEMON_METHOD_SCHEMAS: {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
     };
+    'permission.grants.list': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'permission.grants.revoke': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'user_input.listPending': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'user_input.respond': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'user_input.dismiss': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'credential.register': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'credential.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+    'credential.revoke': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'credential.supply': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'host_tool.register': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'host_tool.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+    'host_tool.invocation.get': {
+        params: RuntimeDaemonJsonSchema;
+        result: {
+            oneOf: RuntimeDaemonJsonSchema[];
+        };
+    };
+    'host_tool.revoke': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
+    'host_tool.complete': {
+        params: RuntimeDaemonJsonSchema;
+        result: RuntimeDaemonJsonSchema;
+    };
     'workflow.list': {
         params: RuntimeDaemonJsonSchema;
         result: RuntimeDaemonJsonSchema;
@@ -482,6 +698,8 @@ declare const RUNTIME_DAEMON_METHOD_SCHEMAS: {
 };
 declare const RUNTIME_DAEMON_NOTIFICATION_SCHEMAS: {
     event: RuntimeDaemonJsonSchema;
+    'credential.request': RuntimeDaemonJsonSchema;
+    'host_tool.invoke': RuntimeDaemonJsonSchema;
     'runtime.warning': RuntimeDaemonJsonSchema;
 };
 declare const RUNTIME_DAEMON_PROTOCOL_SCHEMA: RuntimeDaemonProtocolSchema;
@@ -499,6 +717,30 @@ declare function listRuntimeDaemonSchemaMethods(): readonly RuntimeDaemonMethod[
 type KodaXRuntimeMode = 'embedded' | 'daemon';
 type KodaXRuntimeIsolation = 'inline' | 'worker' | 'process';
 
+interface RuntimeInlineOwnerHandle {
+    readonly profile: string;
+    readonly ownerId: string;
+    close(): void;
+}
+/**
+ * Reserve the Coder profile for inline rollback. Partner runtimes must not use
+ * this fence; they remain in their independent embedded namespace.
+ */
+declare function acquireKodaXInlineOwner(input?: {
+    readonly homeDir?: string;
+    readonly profile?: string;
+    readonly enableRollback?: boolean;
+}): RuntimeInlineOwnerHandle;
+declare function setKodaXRuntimeOwnerMode(input: {
+    readonly mode: 'daemon' | 'inline';
+    readonly expectedRevision: number;
+    readonly homeDir?: string;
+    readonly profile?: string;
+}): {
+    readonly mode: 'daemon' | 'inline';
+    readonly revision: number;
+    readonly updatedAt: string;
+};
 type ReplRuntimeConfigPatch = Parameters<typeof saveConfig>[0];
 declare const RUNTIME_CONFIG_PATCH_KEYS: readonly ["provider", "model", "effort", "planModeEffort", "thinking", "reasoningMode", "agentMode", "permissionMode", "locale", "providerModels", "extensions", "repoIntelligenceMode", "repoIntelligenceTrace", "verifierLog", "stallLog", "fallbackProviders", "fastProvider", "fastModel", "deepProvider", "deepModel", "maxOutputTokens", "disablePromptCache", "lsp", "lspAutoDownload", "acpLogLevel", "sessionRetentionDays", "repoIntelligence", "workflow"];
 type RuntimeConfigPatchKey = typeof RUNTIME_CONFIG_PATCH_KEYS[number];
@@ -513,6 +755,10 @@ interface RuntimeIdentity {
 }
 interface RuntimeClientInfo {
     readonly name: string;
+    /** Stable host-generated identity used only after daemon authentication. */
+    readonly instanceId?: string;
+    /** Stable host-generated secret; persist in OS keychain to resume client-owned leases. */
+    readonly instanceSecret?: string;
     readonly title?: string;
     readonly version?: string;
 }
@@ -524,7 +770,9 @@ interface RuntimeClientCapabilities {
     readonly skillCatalog?: boolean;
     readonly artifactUpload?: boolean;
     readonly contextDiagnostics?: boolean;
+    readonly operationDeduplication?: boolean;
 }
+type RuntimeGrantedScope = 'session:observe' | 'session:write' | 'run:control' | 'interaction:respond' | 'permission:respond' | 'permission:grant-admin' | 'integration:admin' | 'workflow:control' | 'artifact:write' | 'agent:control' | 'credential:register' | 'host-tool:register' | 'owner:admin' | 'daemon:admin';
 interface RuntimeExternalAgentsOptions {
     readonly factories: readonly AgentExecutorFactory[];
     readonly policy: AgentDispatchPolicy;
@@ -547,6 +795,10 @@ interface CreateKodaXRuntimeOptions {
     readonly defaultProvider?: string;
     readonly defaultModel?: string;
     readonly permissionTimeoutMs?: number;
+    /** Internal daemon-host switch; keeps ordinary embedded runs non-interactive by default. */
+    readonly sharedDaemonHost?: boolean;
+    /** @internal Owner-fence identity assigned before a shared daemon Runtime is constructed. */
+    readonly daemonHostRuntimeId?: string;
     readonly daemonStartupTimeoutMs?: number;
     readonly daemonConnectTimeoutMs?: number;
     readonly daemonTransport?: RuntimeDaemonClientTransport;
@@ -583,6 +835,47 @@ interface RuntimeCapabilityRequirements {
     readonly hardDispose?: boolean;
     /** Reject hosts that do not advertise an installed external Agent executor plane. */
     readonly externalAgents?: boolean;
+    readonly operationDeduplication?: 1;
+    readonly sessionObservation?: 1;
+    readonly afterTurnInput?: 1;
+    readonly interruptInput?: 1;
+    readonly askUserTransport?: 1;
+    readonly permissionCas?: 1;
+    readonly providerCredentialBroker?: 1;
+    readonly runBoundHostTools?: 1;
+    readonly coderOwnerFencing?: 1;
+    readonly crashOutcomeModel?: 1;
+    readonly coderFeatureMatrix?: 1;
+    readonly sessionAdmission?: 1;
+    readonly completeObservationSnapshot?: 1;
+    readonly connectionLifecycle?: 1;
+    readonly typedRuntimeEvents?: 1;
+    readonly daemonSafeRunInput?: 1;
+    readonly sharedSessionSettings?: 1;
+    readonly durableRecoveryQueries?: 1;
+}
+type RuntimeOperationState = 'accepted' | 'dispatched' | 'applied' | 'rejected' | 'interrupted' | 'unknown';
+interface RuntimeOperationReceipt {
+    readonly operationId: string;
+    readonly journalEpoch: string;
+    readonly principalId: string;
+    readonly method: string;
+    readonly resourceId?: string;
+    readonly requestDigest: string;
+    readonly state: RuntimeOperationState;
+    /** Serialized mutation result when state is applied; exact retries return the same value. */
+    readonly result?: unknown;
+    readonly updatedAt: string;
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    };
+}
+interface RuntimeOperationService {
+    get(input: {
+        readonly operationId: string;
+        readonly journalEpoch: string;
+    }): Promise<RuntimeOperationReceipt>;
 }
 interface RuntimeDiagnosticFilter {
     readonly sessionId?: string;
@@ -592,12 +885,31 @@ interface RuntimeDiagnosticsService {
     latestContextBudget(filter?: RuntimeDiagnosticFilter): Promise<RuntimeContextBudgetSnapshot | null>;
     latestToolExposure(filter?: RuntimeDiagnosticFilter): Promise<RuntimeToolExposurePlan | null>;
 }
+interface RuntimeConnectionState {
+    readonly state: 'connected' | 'disconnected';
+    readonly connectionId: string;
+    readonly runtimeEpoch: string;
+    readonly journalEpoch?: string;
+    readonly reason?: string;
+    readonly reconnectable: boolean;
+}
+interface RuntimeConnectionService {
+    current(): RuntimeConnectionState;
+    subscribe(listener: (state: RuntimeConnectionState) => void): RuntimeSubscription;
+}
 interface KodaXRuntime {
     readonly identity: RuntimeIdentity;
+    /** Server-advertised facts. Authorization remains defined by grantedScopes. */
+    readonly capabilities?: Readonly<Record<string, unknown>>;
+    readonly grantedScopes?: readonly RuntimeGrantedScope[];
     readonly sessions: RuntimeSessionService;
     readonly runs: RuntimeRunService;
     readonly events: RuntimeEventService;
     readonly permissions: RuntimePermissionService;
+    readonly userInputs: RuntimeUserInputService;
+    readonly credentials: RuntimeCredentialService;
+    readonly hostTools: RuntimeHostToolService;
+    readonly operations: RuntimeOperationService;
     readonly workflows: RuntimeWorkflowService;
     readonly config: RuntimeConfigService;
     readonly catalog: RuntimeCatalogService;
@@ -605,6 +917,8 @@ interface KodaXRuntime {
     readonly artifacts: RuntimeArtifactService;
     readonly status: RuntimeStatusService;
     readonly diagnostics: RuntimeDiagnosticsService;
+    /** Present on daemon facades; emits disconnects without waiting for polling. */
+    readonly connection?: RuntimeConnectionService;
     readonly admin: RuntimeAdminService;
     readonly agents: RuntimeAgentService;
     readonly agentTasks: RuntimeAgentTaskService;
@@ -619,6 +933,8 @@ interface RuntimeAdminService {
 }
 interface RuntimeAgentService {
     readonly enabled: boolean;
+    /** Present when this facade owns an embedded execution substrate. */
+    readonly execution?: RuntimeAgentBindingService;
     listDispatchable(query: DispatchableAgentQuery): Promise<readonly DispatchableAgentListing[]>;
     describe(agentId: string, query: DispatchableAgentQuery): Promise<DispatchableAgentListing | undefined>;
     preflight(input: AgentPreflightInput): Promise<AgentPreflightResult>;
@@ -770,6 +1086,7 @@ interface RuntimeCreateSessionInput {
     readonly surface?: string;
     readonly profileId?: string;
     readonly tag?: string;
+    readonly operation?: RuntimeOperationOptions;
 }
 interface RuntimeSession {
     readonly id: string;
@@ -780,6 +1097,15 @@ interface RuntimeSession {
     readonly profileId?: string;
     readonly createdAt?: string;
 }
+/** Payload emitted when an executing run binds its provider session. */
+interface RuntimeRunSessionLoadedEventPayload {
+    readonly provider: string;
+    readonly sessionId: string;
+    readonly turnId?: string;
+    readonly iteration?: number;
+}
+/** `session.loaded` is emitted both for an explicit SDK load and a run provider session bind. */
+type RuntimeSessionLoadedEventPayload = RuntimeSession | RuntimeRunSessionLoadedEventPayload;
 interface RuntimeSessionSummary extends RuntimeSession {
     /** Opaque continuation token accepted by RuntimeSessionFilter.cursor. */
     readonly cursor?: string;
@@ -813,6 +1139,8 @@ interface RuntimeSessionSettings {
     readonly reasoningMode?: KodaXReasoningMode;
     readonly permissionMode?: string;
     readonly executionCwd?: string;
+    readonly agentMode?: KodaXOptions['agentMode'];
+    readonly autoModeEngine?: 'llm' | 'rules';
 }
 interface RuntimeSessionSettingsPatch {
     readonly provider?: string | null;
@@ -822,6 +1150,8 @@ interface RuntimeSessionSettingsPatch {
     readonly reasoningMode?: KodaXReasoningMode | null;
     readonly permissionMode?: string | null;
     readonly executionCwd?: string | null;
+    readonly agentMode?: KodaXOptions['agentMode'] | null;
+    readonly autoModeEngine?: 'llm' | 'rules' | null;
 }
 interface RuntimeAppendNoticeInput {
     readonly sessionId: string;
@@ -846,14 +1176,65 @@ interface RuntimeCompactSessionInput {
 interface RuntimeCompactSessionResult extends CompactSessionResult {
     readonly session?: RuntimeSession;
 }
+interface RuntimeVersionedValue<T> {
+    readonly revision: number;
+    readonly value: T;
+}
+interface RuntimeVersionedUpdateOptions extends RuntimeOperationOptions {
+    readonly expectedRevision: number;
+}
+interface RuntimeActiveToolProjection {
+    readonly key: string;
+    readonly runId: string;
+    readonly turnId?: string;
+    readonly started: unknown;
+    readonly progress?: unknown;
+}
+interface RuntimePendingUserInputProjection {
+    readonly requestId: string;
+    readonly runId: string;
+    readonly turnId?: string;
+    readonly detail: unknown;
+}
+interface RuntimeManagedTaskProjection {
+    readonly runId: string;
+    readonly turnId?: string;
+    readonly status: KodaXManagedTaskStatusEvent;
+}
+interface RuntimeSessionLiveProjection {
+    readonly assistantTextByRun: Readonly<Record<string, string>>;
+    readonly thinkingTextByRun: Readonly<Record<string, string>>;
+    readonly activeTools: readonly RuntimeActiveToolProjection[];
+    readonly todo?: unknown;
+    readonly pendingUserInputs: readonly RuntimePendingUserInputProjection[];
+    readonly managedTasks: readonly RuntimeManagedTaskProjection[];
+}
+interface RuntimeSessionObservationSnapshot {
+    readonly runtimeId: string;
+    readonly cursor: number;
+    /** Content-derived token for the transcript captured at this observation boundary. */
+    readonly transcriptRevision: string;
+    readonly session: RuntimeSession;
+    readonly transcript: RuntimeTranscript | null;
+    readonly settings: RuntimeVersionedValue<RuntimeSessionSettings>;
+    readonly runs: readonly RuntimeRunStatus[];
+    readonly pendingPermissions: readonly RuntimePermissionRequest[];
+    readonly live: RuntimeSessionLiveProjection;
+}
+interface RuntimeSessionObservation extends RuntimeSubscription {
+    readonly snapshot: RuntimeSessionObservationSnapshot;
+}
 interface RuntimeSessionService {
     create(input?: RuntimeCreateSessionInput): Promise<RuntimeSession>;
     load(sessionId: string): Promise<RuntimeSession>;
     list(filter?: RuntimeSessionFilter): Promise<readonly RuntimeSessionSummary[]>;
     transcript(sessionId: string): Promise<RuntimeTranscript | null>;
+    observe(sessionId: string, listener: RuntimeEventListener): Promise<RuntimeSessionObservation>;
     fork(input: RuntimeForkSessionInput): Promise<RuntimeSession | null>;
     getSettings(sessionId: string): Promise<RuntimeSessionSettings>;
+    getSettingsVersioned(sessionId: string): Promise<RuntimeVersionedValue<RuntimeSessionSettings>>;
     updateSettings(sessionId: string, patch: RuntimeSessionSettingsPatch): Promise<RuntimeSessionSettings>;
+    updateSettingsVersioned(sessionId: string, patch: RuntimeSessionSettingsPatch, options: RuntimeVersionedUpdateOptions): Promise<RuntimeVersionedValue<RuntimeSessionSettings>>;
     appendNotice(input: RuntimeAppendNoticeInput): Promise<SessionTranscriptEntry | null>;
     rewind(input: RuntimeRewindSessionInput): Promise<RuntimeSession | null>;
     setActiveEntry(input: RuntimeSetActiveEntryInput): Promise<RuntimeSession | null>;
@@ -908,23 +1289,122 @@ interface RuntimeStartRunInput {
     readonly options?: RuntimeKodaXOptions;
     /** Host-derived dispatch identity; never accepted from an LLM tool payload. */
     readonly agentContext?: AgentDispatchContext;
+    /** Daemon-issued lease binding; contains no credential material. */
+    readonly credential?: {
+        readonly leaseId: string;
+        readonly provider: string;
+    };
+    /** Daemon-issued host capability binding. Unbound runs never inherit it. */
+    readonly hostTools?: {
+        readonly leaseId: string;
+    };
+    readonly operation?: RuntimeOperationOptions;
+}
+interface RuntimeSubmitInput {
+    readonly sessionId: string;
+    readonly afterRunId: string;
+    readonly delivery: 'after_turn' | 'interrupt';
+    readonly input: RuntimeInput | readonly RuntimeInput[];
+    /** Continuations receive only bindings explicitly supplied for this input. */
+    readonly credential?: {
+        readonly leaseId: string;
+        readonly provider: string;
+    };
+    readonly hostTools?: {
+        readonly leaseId: string;
+    };
+    readonly operation?: RuntimeOperationOptions;
+}
+type RuntimeSubmitInputResult = {
+    readonly accepted: true;
+    readonly delivery: 'after_turn';
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly afterRunId: string;
+    readonly sessionOrder: number;
+} | {
+    readonly accepted: false;
+    readonly delivery: 'after_turn' | 'interrupt';
+    readonly sessionId: string;
+    readonly afterRunId: string;
+    readonly reason: 'stale_run' | 'unsupported_capability';
+};
+interface RuntimeOperationOptions {
+    readonly operationId?: string;
+    readonly journalEpoch?: string;
+    readonly expectedRevision?: number;
 }
 type RuntimeKodaXOptions = Omit<KodaXOptions, 'provider' | 'session' | 'events'> & {
     readonly provider?: string;
     readonly session?: KodaXOptions['session'];
     readonly events?: KodaXEvents;
 };
+type RuntimeDaemonContextOptions = Pick<KodaXContextOptions, 'memoryIdentity' | 'gitRoot' | 'executionCwd' | 'contextTokenSnapshot' | 'projectSnapshot' | 'longRunning' | 'providerPolicyHints' | 'repoRoutingSignals' | 'repoIntelligenceMode' | 'repoIntelligenceTrace' | 'contextDiagnostics' | 'disableAutoTaskReroute' | 'toolConstructionMode' | 'skillsPrompt' | 'rawUserInput' | 'skillInvocation' | 'repoIntelligenceContext' | 'inputArtifacts' | 'promptOverlay' | 'taskSurface' | 'liveTurn' | 'managedTaskWorkspaceDir' | 'managedProtocolEmission' | 'excludeTools' | 'systemPromptOverride' | 'taskMetadata' | 'taskVerification' | 'agentProfile' | 'currentAgentId' | 'parentAgentId'>;
+type RuntimeDaemonKodaXOptions = Pick<RuntimeKodaXOptions, 'provider' | 'model' | 'modelOverride' | 'effort' | 'thinking' | 'reasoningMode' | 'agentMode' | 'maxIter' | 'workflowRunsBaseDir' | 'modelTiers' | 'maxOutputTokens' | 'disablePromptCache' | 'lsp' | 'workflow' | 'selfManual' | 'compaction' | 'timeouts'> & {
+    readonly context?: RuntimeDaemonContextOptions;
+};
+type RuntimeDaemonStartRunInput = Omit<RuntimeStartRunInput, 'options' | 'agentContext' | 'permissionBroker'> & {
+    readonly options?: RuntimeDaemonKodaXOptions;
+};
+interface RuntimeDaemonRunService extends Omit<RuntimeRunService, 'start'> {
+    start(input: RuntimeDaemonStartRunInput): Promise<RuntimeRunHandle>;
+}
+type KodaXDaemonRuntime = Omit<KodaXRuntime, 'runs'> & {
+    readonly runs: RuntimeDaemonRunService;
+};
 interface RuntimeRunStatus {
     readonly runId: string;
     readonly sessionId: string;
     readonly turnId?: string;
     readonly phase: RuntimeRunPhase;
     readonly startedAt: string;
+    /** Durable acceptance timestamp; equals startedAt for protocol v1. */
+    readonly acceptedAt?: string;
+    readonly sessionOrder?: number;
+    readonly queuedAt?: string;
+    readonly runningAt?: string;
+    readonly executionStartedAt?: string;
     readonly endedAt?: string;
     readonly provider: string;
+    readonly mode?: RuntimeRunMode;
+    readonly origin?: {
+        readonly principalId: string;
+        readonly clientName?: string;
+        readonly clientVersion?: string;
+        readonly operationId?: string;
+    };
     readonly model?: string;
     readonly reasoning?: KodaXReasoningMode;
     readonly error?: string;
+    readonly terminal?: RuntimeTerminalFact;
+    readonly continuation?: RuntimeContinuationStatus;
+    readonly requirements?: RuntimeRunRequirements;
+}
+interface RuntimeRunRequirements {
+    readonly credential?: {
+        readonly leaseId: string;
+        readonly provider: string;
+        readonly state: 'ready' | 'expired' | 'terminal';
+    };
+    readonly hostTools?: {
+        readonly leaseId: string;
+        readonly state: 'ready' | 'waiting_host' | 'expired' | 'terminal';
+    };
+}
+interface RuntimeContinuationStatus {
+    readonly inputId: string;
+    readonly afterRunId: string;
+    readonly delivery: 'after_turn';
+    readonly state: 'queued' | 'delivered' | 'terminal';
+    readonly contentPreview: string;
+}
+type RuntimeTerminalCode = 'completed' | 'run_failed' | 'cancelled' | 'interrupted' | 'runtime_restarted' | 'daemon_crashed' | 'credential_unavailable' | 'host_not_dispatched' | 'host_outcome_unknown' | 'control_history_untrusted';
+interface RuntimeTerminalFact {
+    readonly revision: number;
+    readonly kind: 'completed' | 'failed' | 'cancelled' | 'interrupted';
+    readonly code: RuntimeTerminalCode;
+    readonly effectOutcome: 'none' | 'known' | 'unknown';
+    readonly message?: string;
 }
 interface RuntimeRunResult {
     readonly runId: string;
@@ -945,6 +1425,7 @@ interface RuntimeRunFilter {
 }
 interface RuntimeRunService {
     start(input: RuntimeStartRunInput): Promise<RuntimeRunHandle>;
+    submitInput(input: RuntimeSubmitInput): Promise<RuntimeSubmitInputResult>;
     await(runId: string): Promise<RuntimeRunResult>;
     get(runId: string): Promise<RuntimeRunStatus>;
     list(filter?: RuntimeRunFilter): Promise<readonly RuntimeRunStatus[]>;
@@ -953,7 +1434,124 @@ interface RuntimeRunService {
     setProvider(runId: string, provider: string): Promise<void>;
     setReasoning(runId: string, reasoning: KodaXReasoningMode | undefined): Promise<void>;
 }
-type RuntimeEventType = 'session.created' | 'session.loaded' | 'session.settings.updated' | 'session.notice.appended' | 'session.rewound' | 'session.active_entry.updated' | 'session.compacted' | 'run.queued' | 'run.started' | 'run.progress' | 'turn.started' | 'turn.completed' | 'turn.failed' | 'assistant.delta' | 'thinking.delta' | 'thinking.finished' | 'tool.started' | 'tool.progress' | 'tool.finished' | 'user_input.requested' | 'user_input.resolved' | 'permission.requested' | 'permission.resolved' | 'workflow.started' | 'workflow.updated' | 'workflow.finished' | 'context.compaction.started' | 'context.compaction.stats' | 'context.compaction.finished' | 'context.compaction.messages' | 'context.compaction.ended' | 'context.compaction.skipped' | 'context.budget.snapshot' | 'tool.exposure.planned' | 'child_activity.finished' | 'provider.retry' | 'provider.recovery' | 'repo_intelligence.trace' | 'todo.updated' | 'todo.warning' | 'sidecar.message' | 'run.completed' | 'run.failed' | 'run.cancelled' | 'run.interrupted' | 'artifact.created' | 'config.effective' | 'runtime.warning';
+type RuntimeEventType = 'session.created' | 'session.loaded' | 'session.settings.updated' | 'session.notice.appended' | 'session.rewound' | 'session.active_entry.updated' | 'session.compacted' | 'run.queued' | 'run.started' | 'run.updated' | 'run.progress' | 'turn.started' | 'turn.completed' | 'turn.failed' | 'assistant.delta' | 'thinking.delta' | 'thinking.finished' | 'tool.started' | 'tool.progress' | 'tool.finished' | 'user_input.requested' | 'user_input.resolved' | 'permission.requested' | 'permission.resolved' | 'workflow.started' | 'workflow.updated' | 'workflow.finished' | 'context.compaction.started' | 'context.compaction.stats' | 'context.compaction.finished' | 'context.compaction.messages' | 'context.compaction.ended' | 'context.compaction.skipped' | 'context.budget.snapshot' | 'tool.exposure.planned' | 'child_activity.finished' | 'provider.retry' | 'provider.recovery' | 'repo_intelligence.trace' | 'todo.updated' | 'todo.warning' | 'sidecar.message' | 'run.completed' | 'run.failed' | 'run.cancelled' | 'run.interrupted' | 'artifact.created' | 'config.effective' | 'runtime.warning';
+interface RuntimeTextDeltaEventPayload {
+    readonly text: string;
+    readonly meta?: KodaXActivityEventMeta;
+}
+interface RuntimeThinkingFinishedEventPayload {
+    readonly thinking: string;
+    readonly meta?: KodaXActivityEventMeta;
+}
+interface RuntimeToolStartedEventPayload {
+    readonly tool: {
+        readonly name: string;
+        readonly id: string;
+        readonly input?: Readonly<Record<string, unknown>>;
+    };
+    readonly meta?: KodaXToolEventMeta;
+}
+type RuntimeToolProgressEventPayload = {
+    readonly update: {
+        readonly id: string;
+        readonly message: string;
+    };
+    readonly meta?: KodaXToolEventMeta;
+} | {
+    readonly toolName: string;
+    readonly partialJson: string;
+    readonly meta?: KodaXToolEventMeta;
+};
+interface RuntimeToolFinishedEventPayload {
+    readonly result: {
+        readonly id: string;
+        readonly name: string;
+        readonly content: string;
+    };
+    readonly meta?: KodaXToolEventMeta;
+}
+type RuntimeRunProgressEventPayload = {
+    readonly kind: 'managed_task_status';
+    readonly status: KodaXManagedTaskStatusEvent;
+} | {
+    readonly kind: 'stream_end' | 'complete';
+    readonly meta?: KodaXActivityEventMeta;
+} | {
+    readonly kind: 'iteration_start';
+    readonly iter: number;
+    readonly maxIter: number;
+    readonly meta?: KodaXActivityEventMeta;
+} | {
+    readonly kind: 'iteration_end';
+    readonly info: Readonly<Record<string, unknown>>;
+} | {
+    readonly kind: 'mid_turn_user_messages';
+    readonly contents: readonly string[];
+    readonly meta?: KodaXActivityEventMeta;
+};
+interface RuntimeTodoUpdatedEventPayload {
+    readonly items: readonly unknown[];
+    readonly meta?: KodaXActivityEventMeta;
+}
+interface RuntimeInteractionResolvedEventPayload {
+    readonly requestId: string;
+    readonly status?: string;
+    readonly decision?: RuntimePermissionDecision;
+    readonly kind?: RuntimeUserInputKind;
+}
+interface RuntimeWarningEventPayload {
+    readonly message: string;
+    readonly source?: string;
+    readonly severity?: string;
+    readonly sourceEventId?: string;
+}
+interface RuntimeSessionSettingsUpdatedEventPayload {
+    readonly sessionId: string;
+    readonly revision: number;
+    readonly settings: RuntimeSessionSettings;
+    readonly patch: RuntimeSessionSettingsPatch;
+}
+type RuntimeUserInputRequestedEventPayload = RuntimeUserInputRequest | {
+    readonly requestId: string;
+    readonly kind: RuntimeUserInputKind;
+    readonly options: unknown;
+};
+type RuntimeEventPayloadDefaults = {
+    readonly [K in RuntimeEventType]: unknown;
+};
+type RuntimeEventPayloadMap = Omit<RuntimeEventPayloadDefaults, 'session.created' | 'session.loaded' | 'run.queued' | 'run.started' | 'run.updated' | 'run.completed' | 'run.failed' | 'run.cancelled' | 'run.interrupted' | 'assistant.delta' | 'thinking.delta' | 'thinking.finished' | 'tool.started' | 'tool.progress' | 'tool.finished' | 'run.progress' | 'todo.updated' | 'user_input.requested' | 'user_input.resolved' | 'permission.requested' | 'permission.resolved' | 'session.settings.updated' | 'turn.started' | 'turn.completed' | 'turn.failed' | 'workflow.started' | 'workflow.updated' | 'workflow.finished' | 'context.budget.snapshot' | 'tool.exposure.planned' | 'runtime.warning'> & {
+    readonly 'session.created': RuntimeSession;
+    readonly 'session.loaded': RuntimeSessionLoadedEventPayload;
+    readonly 'run.queued': RuntimeRunStatus;
+    readonly 'run.started': RuntimeRunStatus;
+    readonly 'run.updated': RuntimeRunStatus;
+    readonly 'run.completed': RuntimeRunStatus;
+    readonly 'run.failed': RuntimeRunStatus;
+    readonly 'run.cancelled': RuntimeRunStatus;
+    readonly 'run.interrupted': RuntimeRunStatus;
+    readonly 'assistant.delta': RuntimeTextDeltaEventPayload;
+    readonly 'thinking.delta': RuntimeTextDeltaEventPayload;
+    readonly 'thinking.finished': RuntimeThinkingFinishedEventPayload;
+    readonly 'tool.started': RuntimeToolStartedEventPayload;
+    readonly 'tool.progress': RuntimeToolProgressEventPayload;
+    readonly 'tool.finished': RuntimeToolFinishedEventPayload;
+    readonly 'run.progress': RuntimeRunProgressEventPayload;
+    readonly 'todo.updated': RuntimeTodoUpdatedEventPayload;
+    readonly 'user_input.requested': RuntimeUserInputRequestedEventPayload;
+    readonly 'user_input.resolved': RuntimeInteractionResolvedEventPayload;
+    readonly 'permission.requested': RuntimePermissionRequest;
+    readonly 'permission.resolved': RuntimeInteractionResolvedEventPayload;
+    readonly 'session.settings.updated': RuntimeSessionSettingsUpdatedEventPayload;
+    readonly 'turn.started': KodaXTurnStartedEvent;
+    readonly 'turn.completed': KodaXTurnCompletedEvent;
+    readonly 'turn.failed': KodaXTurnFailedEvent;
+    readonly 'workflow.started': WorkflowProcessEvent;
+    readonly 'workflow.updated': WorkflowProcessEvent;
+    readonly 'workflow.finished': WorkflowProcessEvent;
+    readonly 'context.budget.snapshot': RuntimeContextBudgetSnapshot;
+    readonly 'tool.exposure.planned': RuntimeToolExposurePlan;
+    readonly 'runtime.warning': RuntimeWarningEventPayload;
+};
 interface RuntimeEventEnvelope<TPayload = unknown> {
     readonly id: string;
     readonly seq: number;
@@ -964,7 +1562,20 @@ interface RuntimeEventEnvelope<TPayload = unknown> {
     readonly type: RuntimeEventType;
     readonly payload: TPayload;
 }
+type RuntimeTypedEvent<TType extends RuntimeEventType = RuntimeEventType> = {
+    readonly [K in TType]: RuntimeEventEnvelope<RuntimeEventPayloadMap[K]> & {
+        readonly type: K;
+    };
+}[TType];
+/** Backward-compatible raw envelope; use parseRuntimeEvent for payload narrowing. */
 type RuntimeEvent = RuntimeEventEnvelope;
+type RuntimeEventParseResult = {
+    readonly ok: true;
+    readonly event: RuntimeTypedEvent;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
 interface RuntimeEventFilter {
     readonly sessionId?: string;
     readonly runId?: string;
@@ -975,6 +1586,7 @@ interface RuntimeEventReplayFilter extends RuntimeEventFilter {
     readonly limit?: number;
 }
 type RuntimeEventListener = (event: RuntimeEvent) => void;
+type RuntimeTypedEventListener = (event: RuntimeTypedEvent) => void;
 interface RuntimeSubscription {
     close(): void;
 }
@@ -1029,10 +1641,107 @@ interface RuntimePermissionFilter {
 interface RuntimePermissionRespondOptions {
     readonly runId?: string;
 }
+interface RuntimePermissionGrant {
+    readonly id: string;
+    readonly scope: RuntimePermissionScope;
+    readonly createdAt: string;
+}
 interface RuntimePermissionService {
     request(input: RuntimePermissionRequestInput): Promise<RuntimePermissionDecision>;
     listPending(filter?: RuntimePermissionFilter): Promise<readonly RuntimePermissionRequest[]>;
     respond(requestId: string, decision: RuntimePermissionDecision, options?: RuntimePermissionRespondOptions): Promise<boolean>;
+    listGrants(): Promise<RuntimeVersionedValue<readonly RuntimePermissionGrant[]>>;
+    revokeGrant(grantId: string, expectedRevision: number): Promise<boolean>;
+}
+type RuntimeUserInputKind = 'askUser' | 'askUserMulti' | 'askUserInput';
+interface RuntimeUserInputRequest {
+    readonly id: string;
+    readonly revision: number;
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turnId?: string;
+    readonly kind: RuntimeUserInputKind;
+    readonly options: unknown;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+}
+interface RuntimeUserInputFilter {
+    readonly sessionId?: string;
+    readonly runId?: string;
+}
+interface RuntimeUserInputResolution {
+    readonly requestId: string;
+    readonly accepted: boolean;
+    readonly status: 'answered' | 'dismissed' | 'already_resolved';
+}
+interface RuntimeUserInputService {
+    listPending(filter?: RuntimeUserInputFilter): Promise<readonly RuntimeUserInputRequest[]>;
+    respond(requestId: string, answer: unknown, options?: {
+        readonly expectedRevision?: number;
+        readonly runId?: string;
+    }): Promise<RuntimeUserInputResolution>;
+    dismiss(requestId: string, options?: {
+        readonly expectedRevision?: number;
+        readonly runId?: string;
+    }): Promise<RuntimeUserInputResolution>;
+}
+interface RuntimeCredentialRequest {
+    readonly leaseId: string;
+    readonly provider: string;
+    readonly sessionId: string;
+    readonly runId: string;
+}
+type RuntimeCredentialBroker = (request: RuntimeCredentialRequest) => Promise<string | undefined>;
+interface RuntimeCredentialLease {
+    readonly id: string;
+    readonly providers: readonly string[];
+    readonly expiresAt?: string;
+}
+interface RuntimeCredentialService {
+    register(input: {
+        readonly providers: readonly string[];
+        readonly expiresAt?: string;
+    }, broker: RuntimeCredentialBroker): Promise<RuntimeCredentialLease>;
+    resume(leaseId: string, broker: RuntimeCredentialBroker): Promise<RuntimeCredentialLease>;
+    revoke(leaseId: string): Promise<boolean>;
+}
+interface RuntimeHostToolDescriptor {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+    readonly sideEffect: 'none' | 'idempotent' | 'non_idempotent';
+}
+interface RuntimeHostToolInvocation {
+    readonly invocationId: string;
+    readonly leaseId: string;
+    readonly toolName: string;
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly input: Readonly<Record<string, unknown>>;
+}
+interface RuntimeHostToolResult {
+    readonly content: string;
+    readonly structuredContent?: unknown;
+}
+type RuntimeHostToolHandler = (invocation: RuntimeHostToolInvocation) => Promise<RuntimeHostToolResult>;
+interface RuntimeHostToolLease {
+    readonly id: string;
+    readonly tools: readonly RuntimeHostToolDescriptor[];
+}
+interface RuntimeHostToolInvocationStatus {
+    readonly invocationId: string;
+    readonly leaseId: string;
+    readonly toolName: string;
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly state: 'prepared' | 'dispatched' | 'completed' | 'unknown' | 'not_dispatched';
+    readonly updatedAt: string;
+}
+interface RuntimeHostToolService {
+    register(tools: readonly RuntimeHostToolDescriptor[], handlers: Readonly<Record<string, RuntimeHostToolHandler>>): Promise<RuntimeHostToolLease>;
+    resume(leaseId: string, handlers: Readonly<Record<string, RuntimeHostToolHandler>>): Promise<RuntimeHostToolLease>;
+    getInvocation(invocationId: string): Promise<RuntimeHostToolInvocationStatus | undefined>;
+    revoke(leaseId: string): Promise<boolean>;
 }
 interface RuntimeWorkflowFilter {
     readonly runId?: string;
@@ -1060,11 +1769,25 @@ interface RuntimeStatusSnapshot {
     readonly pendingPermissions: readonly RuntimePermissionRequest[];
     readonly workflows: readonly RuntimeWorkflowSummary[];
 }
+interface RuntimeDaemonPreflight {
+    readonly runtimeId: string;
+    readonly clientCount: number;
+    readonly activeRuns: readonly RuntimeRunStatus[];
+    readonly queuedRuns: readonly RuntimeRunStatus[];
+    readonly pendingPermissions: readonly RuntimePermissionRequest[];
+    readonly pendingUserInputs: readonly RuntimeUserInputRequest[];
+    readonly blockers: readonly ('connected_clients' | 'active_runs' | 'queued_runs' | 'pending_interactions')[];
+    readonly canStop: boolean;
+}
 interface RuntimeStatusService {
     snapshot(): Promise<RuntimeStatusSnapshot>;
+    preflight(): Promise<RuntimeDaemonPreflight>;
 }
+declare function createKodaXRuntime(options: CreateKodaXRuntimeOptions & {
+    readonly mode: 'daemon';
+}): Promise<KodaXDaemonRuntime>;
 declare function createKodaXRuntime(options?: CreateKodaXRuntimeOptions): Promise<KodaXRuntime>;
-declare function connectKodaXRuntime(options?: ConnectKodaXRuntimeOptions): Promise<KodaXRuntime>;
+declare function connectKodaXRuntime(options?: ConnectKodaXRuntimeOptions): Promise<KodaXDaemonRuntime>;
 
-export { KODAX_DAEMON_PROTOCOL, KODAX_DAEMON_PROTOCOL_VERSION, KodaXEvents, KodaXResult, RUNTIME_DAEMON_METHODS, RUNTIME_DAEMON_METHOD_SCHEMAS, RUNTIME_DAEMON_NOTIFICATION_SCHEMAS, RUNTIME_DAEMON_PROTOCOL_SCHEMA, RUNTIME_DAEMON_PROTOCOL_SCHEMA_JSON, RuntimeContextBudgetSnapshot, RuntimeToolExposurePlan, SessionTranscriptEntry, connectKodaXRuntime, createKodaXRuntime, listRuntimeDaemonSchemaMethods };
-export type { ConnectKodaXRuntimeOptions, CreateKodaXRuntimeOptions, KodaXRuntime, KodaXRuntimeIsolation, KodaXRuntimeMode, RuntimeAdminService, RuntimeAgentService, RuntimeAgentTaskService, RuntimeAppendNoticeInput, RuntimeArtifact, RuntimeArtifactKind, RuntimeArtifactRefInput, RuntimeArtifactService, RuntimeCapabilityRequirements, RuntimeCatalogService, RuntimeClientCapabilities, RuntimeClientInfo, RuntimeCommandInfo, RuntimeCommandResolveInput, RuntimeCompactSessionInput, RuntimeCompactSessionResult, RuntimeConfigPatch, RuntimeConfigReloadResult, RuntimeConfigService, RuntimeCreateArtifactInput, RuntimeCreateSessionInput, RuntimeDaemonClientTransport, RuntimeDaemonEndpoint, RuntimeDaemonError, RuntimeDaemonErrorCode, RuntimeDaemonFrame, RuntimeDaemonJsonSchema, RuntimeDaemonMethod, RuntimeDaemonMethodSchema, RuntimeDaemonNotification, RuntimeDaemonNotificationMethod, RuntimeDaemonProtocolSchema, RuntimeDaemonRequest, RuntimeDiagnosticFilter, RuntimeDiagnosticsService, RuntimeEvent, RuntimeEventEnvelope, RuntimeEventFilter, RuntimeEventListener, RuntimeEventReplayFilter, RuntimeEventService, RuntimeEventType, RuntimeExtensionListResult, RuntimeExtensionReloadResult, RuntimeExternalAgentsOptions, RuntimeFileInput, RuntimeForkSessionInput, RuntimeIdentity, RuntimeImageInput, RuntimeInput, RuntimeKodaXOptions, RuntimeMcpReloadResult, RuntimeMcpService, RuntimeMcpToolListFilter, RuntimeMcpValidateResult, RuntimeModelListFilter, RuntimePermissionBroker, RuntimePermissionDecision, RuntimePermissionFilter, RuntimePermissionRequest, RuntimePermissionRequestInput, RuntimePermissionRespondOptions, RuntimePermissionRisk, RuntimePermissionScope, RuntimePermissionService, RuntimeRewindSessionInput, RuntimeRunFilter, RuntimeRunHandle, RuntimeRunMode, RuntimeRunPhase, RuntimeRunResult, RuntimeRunService, RuntimeRunStatus, RuntimeSession, RuntimeSessionFilter, RuntimeSessionService, RuntimeSessionSettings, RuntimeSessionSettingsPatch, RuntimeSessionSummary, RuntimeSetActiveEntryInput, RuntimeSkillDescribeInput, RuntimeSkillDescription, RuntimeSkillFileSummary, RuntimeSkillListFilter, RuntimeSkillSummary, RuntimeStartRunInput, RuntimeStatusService, RuntimeStatusSnapshot, RuntimeSubscription, RuntimeTextInput, RuntimeTranscript, RuntimeVideoInput, RuntimeWorkerOptions, RuntimeWorkerResourceLimits, RuntimeWorkflowFilter, RuntimeWorkflowListener, RuntimeWorkflowService, RuntimeWorkflowSnapshot, RuntimeWorkflowSummary };
+export { KODAX_DAEMON_PROTOCOL, KODAX_DAEMON_PROTOCOL_VERSION, KodaXEvents, KodaXResult, RUNTIME_DAEMON_METHODS, RUNTIME_DAEMON_METHOD_SCHEMAS, RUNTIME_DAEMON_NOTIFICATION_SCHEMAS, RUNTIME_DAEMON_PROTOCOL_SCHEMA, RUNTIME_DAEMON_PROTOCOL_SCHEMA_JSON, RuntimeContextBudgetSnapshot, RuntimeToolExposurePlan, RuntimeTransportBoundaryError, SessionTranscriptEntry, acquireKodaXInlineOwner, connectKodaXRuntime, createKodaXRuntime, listRuntimeDaemonSchemaMethods, parseRuntimeEvent, setKodaXRuntimeOwnerMode };
+export type { ConnectKodaXRuntimeOptions, CreateKodaXRuntimeOptions, KodaXDaemonRuntime, KodaXRuntime, KodaXRuntimeIsolation, KodaXRuntimeMode, RuntimeActiveToolProjection, RuntimeAdminService, RuntimeAgentBindingService, RuntimeAgentOwnerSession, RuntimeAgentService, RuntimeAgentTaskService, RuntimeAppendNoticeInput, RuntimeArtifact, RuntimeArtifactKind, RuntimeArtifactRefInput, RuntimeArtifactService, RuntimeBoundDefaultAgent, RuntimeBoundLocalAgent, RuntimeCapabilityRequirements, RuntimeCatalogService, RuntimeClientCapabilities, RuntimeClientInfo, RuntimeCommandInfo, RuntimeCommandResolveInput, RuntimeCompactSessionInput, RuntimeCompactSessionResult, RuntimeConfigPatch, RuntimeConfigReloadResult, RuntimeConfigService, RuntimeConnectionService, RuntimeConnectionState, RuntimeContinuationStatus, RuntimeCreateArtifactInput, RuntimeCreateSessionInput, RuntimeCredentialBroker, RuntimeCredentialLease, RuntimeCredentialRequest, RuntimeCredentialService, RuntimeDaemonClientTransport, RuntimeDaemonContextOptions, RuntimeDaemonEndpoint, RuntimeDaemonError, RuntimeDaemonErrorCode, RuntimeDaemonFrame, RuntimeDaemonJsonSchema, RuntimeDaemonKodaXOptions, RuntimeDaemonMethod, RuntimeDaemonMethodSchema, RuntimeDaemonNotification, RuntimeDaemonNotificationMethod, RuntimeDaemonPreflight, RuntimeDaemonProtocolSchema, RuntimeDaemonRequest, RuntimeDaemonRunService, RuntimeDaemonStartRunInput, RuntimeDaemonTransportLifecycleState, RuntimeDefaultAgentStartInput, RuntimeDiagnosticFilter, RuntimeDiagnosticsService, RuntimeEffectiveSkillRef, RuntimeEvent, RuntimeEventEnvelope, RuntimeEventFilter, RuntimeEventListener, RuntimeEventParseResult, RuntimeEventPayloadMap, RuntimeEventReplayFilter, RuntimeEventService, RuntimeEventType, RuntimeExecutionToolPolicy, RuntimeExtensionListResult, RuntimeExtensionReloadResult, RuntimeExternalAgentsOptions, RuntimeFileInput, RuntimeForkSessionInput, RuntimeGrantedScope, RuntimeHostToolDescriptor, RuntimeHostToolHandler, RuntimeHostToolInvocation, RuntimeHostToolInvocationStatus, RuntimeHostToolLease, RuntimeHostToolResult, RuntimeHostToolService, RuntimeIdentity, RuntimeImageInput, RuntimeInlineOwnerHandle, RuntimeInput, RuntimeInteractionResolvedEventPayload, RuntimeKodaXOptions, RuntimeLocalAgentStartInput, RuntimeManagedTaskProjection, RuntimeMcpReloadResult, RuntimeMcpService, RuntimeMcpToolListFilter, RuntimeMcpValidateResult, RuntimeModelListFilter, RuntimeOperationOptions, RuntimeOperationReceipt, RuntimeOperationService, RuntimeOperationState, RuntimePendingUserInputProjection, RuntimePermissionBroker, RuntimePermissionDecision, RuntimePermissionFilter, RuntimePermissionGrant, RuntimePermissionRequest, RuntimePermissionRequestInput, RuntimePermissionRespondOptions, RuntimePermissionRisk, RuntimePermissionScope, RuntimePermissionService, RuntimeResolvedLocalAgent, RuntimeRewindSessionInput, RuntimeRunFilter, RuntimeRunHandle, RuntimeRunMode, RuntimeRunPhase, RuntimeRunProgressEventPayload, RuntimeRunRequirements, RuntimeRunResult, RuntimeRunService, RuntimeRunSessionLoadedEventPayload, RuntimeRunStatus, RuntimeSession, RuntimeSessionFilter, RuntimeSessionLiveProjection, RuntimeSessionLoadedEventPayload, RuntimeSessionObservation, RuntimeSessionObservationSnapshot, RuntimeSessionService, RuntimeSessionSettings, RuntimeSessionSettingsPatch, RuntimeSessionSettingsUpdatedEventPayload, RuntimeSessionSummary, RuntimeSetActiveEntryInput, RuntimeSkillDescribeInput, RuntimeSkillDescription, RuntimeSkillFileSummary, RuntimeSkillListFilter, RuntimeSkillSummary, RuntimeStartRunInput, RuntimeStatusService, RuntimeStatusSnapshot, RuntimeSubmitInput, RuntimeSubmitInputResult, RuntimeSubscription, RuntimeTerminalCode, RuntimeTerminalFact, RuntimeTextDeltaEventPayload, RuntimeTextInput, RuntimeThinkingFinishedEventPayload, RuntimeTodoUpdatedEventPayload, RuntimeToolFinishedEventPayload, RuntimeToolProgressEventPayload, RuntimeToolStartedEventPayload, RuntimeTranscript, RuntimeTypedEvent, RuntimeTypedEventListener, RuntimeUserInputFilter, RuntimeUserInputKind, RuntimeUserInputRequest, RuntimeUserInputRequestedEventPayload, RuntimeUserInputResolution, RuntimeUserInputService, RuntimeUserMarkdownAgentRef, RuntimeVersionedUpdateOptions, RuntimeVersionedValue, RuntimeVideoInput, RuntimeWarningEventPayload, RuntimeWorkerOptions, RuntimeWorkerResourceLimits, RuntimeWorkflowFilter, RuntimeWorkflowListener, RuntimeWorkflowService, RuntimeWorkflowSnapshot, RuntimeWorkflowSummary, RuntimeWorkspaceBinding };