@hasna-internal/kai-cordis-client-runner 0.1.1-rc.2

package/lib/index.js

@@ -0,0 +1,11 @@
+//#region lib/types/index.js
+/**
+* Dynamic-package runner plugin, node half. Pure browser-side capability: the
+* empty apply exists so the row appears in the host cordis.yml / Loader, while
+* the browser half ships through exports["./client"], discovered from the
+* package.json dshClient declaration.
+*/
+/** Host plugin body — this package contributes nothing host-side. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/invariant.js

@@ -0,0 +1,26 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@hasna-internal/kai-cordis-client-runner`.
+* @module @hasna-internal/kai-cordis-client-runner/invariant
+*/
+const PACKAGE_NAME = "@hasna-internal/kai-cordis-client-runner";
+/** Cordis companion plugin name. */
+const name = "cordis-client-runner-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the owned relation (a live
+* Plugin's loader entry exists exactly while one Plugin Run ID is live) is
+* browser-only state reachable through the client half's service, which the
+* node-plane companion cannot observe. The relation is asserted by the
+* package's own load/teardown coverage instead.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/client/api-catalog.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Generated by scripts/gen-cordis-api.ts — do not edit by hand; run
+ * `pnpm run gen-cordis-api` to regenerate (freshness-gated by
+ * `pnpm run verify-cordis-api` in doc-sync).
+ *
+ * The machine-readable cordis API catalog `cordis_inspect` serves to the
+ * model: harness services (summary + structured public method contracts),
+ * harness events (mode + structured listener contracts), and the inherited `ctx` API. Produced by
+ * the same AST walk as docs/cordis-catalog, so this data and the rendered
+ * docs cannot diverge.
+ *
+ * @module @hasna-internal/kai-cordis-client-runner/client/api-catalog
+ */
+/** One named parameter in a Service method or Event listener. */
+export interface ApiParameter {
+    /** Parameter name from the exact signature. */
+    name: string;
+    /** Source-owned parameter contract. */
+    description: string;
+}
+/** One public service member and its source-owned contract. */
+export interface ServiceApiMethod {
+    /** Public method signature with its body stripped. */
+    signature: string;
+    /** Method purpose and behavior. */
+    description: string;
+    /** Named parameters in signature order. */
+    parameters: readonly ApiParameter[];
+    /** Non-void result contract when documented. */
+    returns?: string;
+    /** Documented failure conditions. */
+    throws?: readonly string[];
+}
+/** One harness `ctx.<key>` service and its public methods. */
+export interface ServiceApiEntry {
+    /** The `ctx.<key>` name, e.g. `tools`. */
+    key: string;
+    /** First sentence of the service class JSDoc. */
+    summary: string;
+    /** Complete service description. */
+    description: string;
+    /** Public methods, bodies stripped, in source order. */
+    methods: readonly ServiceApiMethod[];
+}
+/** One harness event: its dispatch mode, exact signature, and listener contract. */
+export interface EventApiEntry {
+    /** The scoped event name, e.g. `agent/status`. */
+    name: string;
+    /** The dispatch mode from the declaration's `@mode` tag. */
+    mode: string;
+    /** The exact listener signature, whitespace-normalized. */
+    signature: string;
+    /** First sentence of the event JSDoc. */
+    summary: string;
+    /** Complete event description. */
+    description: string;
+    /** Named listener parameters in signature order. */
+    parameters: readonly ApiParameter[];
+}
+/** One inherited (cordis core + loader/hmr/timer) `ctx` member group with its summary. */
+export interface InheritedApiEntry {
+    /** The `ctx` member name(s), e.g. `ctx.on / ctx.once`. */
+    name: string;
+    /** One-line summary of what the member does. */
+    summary: string;
+}
+/** One named type declaration referenced by a Service or Event signature. */
+export interface TypeApiEntry {
+    /** The exported type/interface name, e.g. `ShellRunResult`. */
+    name: string;
+    /** The full declaration text, comments stripped. */
+    declaration: string;
+}
+/** Every harness `ctx.<key>` service, sorted by key. */
+export declare const SERVICE_API: readonly ServiceApiEntry[];
+/** Every harness event, sorted by name. */
+export declare const EVENT_API: readonly EventApiEntry[];
+/** Shapes of every exported type the Service and Event signatures reference (transitively), sorted by name. */
+export declare const TYPE_API: readonly TypeApiEntry[];
+/** The inherited `ctx` API (cordis core + loader/hmr/timer), in curated order. */
+export declare const INHERITED_CTX_API: readonly InheritedApiEntry[];
+/**
+ * Project the Service Catalog as a compact directory or one exact coding contract.
+ * @param key - exact Service key; omit it to list all Services and method signatures.
+ * @param services - platform-specific visible Service entries.
+ * @returns compact navigation data or one detailed Service with its referenced type closure.
+ */
+export declare function queryServiceApi(key?: string, services?: readonly ServiceApiEntry[]): object;
+/**
+ * Project the Event Catalog as a compact directory or one exact listener contract.
+ * @param name - exact Event name; omit it to list all Events and listener signatures.
+ * @param events - platform-specific visible Event entries.
+ * @returns compact navigation data or one detailed Event with its referenced type closure.
+ */
+export declare function queryEventApi(name?: string, events?: readonly EventApiEntry[]): object;
+//# sourceMappingURL=api-catalog.d.ts.map

package/lib/types/client/evaluator.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Browser-half closure evaluation: the package source runs as the body of an
+ * async function whose parameters ARE the symbol surface. Shadowing parameters
+ * (setTimeout/fetch/require/…) turn the ambient browser globals into teaching
+ * redirects without touching the page. The host syntax-prechecked the source at
+ * define time; SyntaxError handling here is the engine-divergence fallback and
+ * reaches the model through the load report.
+ */
+import type { CordisDynamicPluginId } from '@hasna-internal/kai-api-remotes/client';
+/** A mountable plugin as the closure must return it (FUNCTION or OBJECT form). */
+export interface DynamicCordisEvaluatedPlugin {
+    /** Optional plugin name; the runner overwrites it with the module id. */
+    name?: string;
+    /** Services the browser half declares; the runner overwrites it from the dispatched row. */
+    inject?: string[];
+    /** Plugin body receiving the guard facade. */
+    apply: (ctx: unknown, config?: unknown) => unknown;
+}
+/** What the evaluator needs from the runner to build one package's closure. */
+export interface DynamicCordisClosureEnv {
+    /** Route `host.call` to this package's host half over the wire. */
+    invoke(method: string, args: unknown): Promise<unknown>;
+    /** Mirror one runtime error text into the load report (console.error copies). */
+    noteError(message: string): void;
+}
+/**
+ * Where each withheld browser global sends the author instead. One home for two
+ * consumers: the closure traps below throw these, and a render crash whose
+ * message names one of them gets the same redirect appended — a package that
+ * reached the global some other way (`window.setInterval`) crashes with the
+ * engine's own bare text, and the author needs the redirect either way.
+ */
+export declare const DYNAMIC_CLIENT_REDIRECTS: Readonly<Record<string, string>>;
+/** Per-package style-tag bookkeeping behind the `styles.insert` symbol. */
+export declare class DynamicCordisStyles {
+    private readonly pluginId;
+    private readonly tags;
+    /** @param pluginId - owning Plugin ID, stamped as `data-dyn` on every tag. */
+    constructor(pluginId: CordisDynamicPluginId);
+    /**
+     * Inject one stylesheet, removed automatically on package unload.
+     * @param css - raw CSS text.
+     * @returns disposer removing this one tag early.
+     */
+    insert(css: string): () => void;
+    /** Live tag count (load-report contribution summary). */
+    get count(): number;
+    /** Remove every tag this package still owns (unload path). */
+    dispose(): void;
+}
+/**
+ * Narrow a closure return value to a mountable plugin (host guard mirror).
+ * @param value - whatever the closure returned.
+ * @returns whether the value is mountable.
+ */
+export declare function isDynamicCordisPlugin(value: unknown): value is DynamicCordisEvaluatedPlugin | ((ctx: unknown) => unknown);
+/**
+ * Evaluate one package's browser half and return the (un-guarded) plugin.
+ * @param pluginId - stable Plugin ID (console tag and style ownership).
+ * @param clientCode - the browser half's source: an async function body returning a plugin.
+ * @param env - runner wiring for `host.call` and error mirroring.
+ * @param styles - the package's style bookkeeping (owned by the caller so unload can dispose it).
+ * @returns the plugin the closure returned.
+ * @throws teaching errors for syntax failures and non-plugin returns.
+ */
+export declare function evaluateClientHalf(pluginId: CordisDynamicPluginId, clientCode: string, env: DynamicCordisClosureEnv, styles: DynamicCordisStyles): Promise<DynamicCordisEvaluatedPlugin | ((ctx: unknown) => unknown)>;
+//# sourceMappingURL=evaluator.d.ts.map

package/lib/types/client/guard.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The browser twin of the tool-cordis context facade: a whitelist of
+ * lifecycle-safe verbs plus optional `ctx.get()` lookup and declared-service
+ * property access, with
+ * framework internals withheld and Context-valued returns denied. Two seats
+ * carry extra machinery: `slots`, where the register proxy assigns the
+ * shadowing priority and ledgers the registration — invoking the service with
+ * the traced receiver so the effect lands on the CALLING plugin's fiber
+ * (SlotRegistry.register must stay a prototype method for exactly that
+ * reason) — and `theme`, whose override source is pinned to the package id.
+ *
+ * This is API discipline, not a security boundary: a dynamic package's code is
+ * as trusted as the host process that accepted its definition.
+ */
+import { Context } from '@deepseek-ai/cordis';
+import type { DynamicCordisPackage } from '@hasna-internal/kai-api-remotes/client';
+/** One package's slot-registration ledger row (contribution projection source). */
+export interface DynamicCordisSlotLedgerRow {
+    /** Target slot name. */
+    slot: string;
+    /** The assigned shadowing priority (globally unique — how winners are matched back to packages). */
+    priority: number | undefined;
+}
+/** What the facade needs beyond the real ctx to govern one package. */
+export interface DynamicCordisGuardEnv {
+    /** The dispatched Package row. */
+    pkg: DynamicCordisPackage;
+    /** Ledger sink: every slot registration this package makes. */
+    ledger: DynamicCordisSlotLedgerRow[];
+    /**
+     * Ownership index sink: the component object seated in a slot, so a later
+     * render crash reported against the stored entry can be attributed back to
+     * this package. Identity is the key — the registry stores the component
+     * verbatim — which is why nothing else has to be remembered about the entry.
+     * @param component - whatever the package passed as its component.
+     */
+    claim(component: unknown): void;
+    /** Allocate one page-local shadowing rank; later registrations sort first. */
+    allocatePriority(): number;
+    /** Report one post-activation guard rejection to the owning Agent. */
+    reportFailure(error: Error): void;
+}
+/**
+ * Build the facade one dynamic plugin's `apply` receives (host sandboxContext
+ * twin, browser seats). `ctx.get(name)` performs optional lookup; direct
+ * `ctx.serviceName` access is gated by the fiber's `inject` declaration.
+ * @param ctx - the plugin's real fiber ctx (loader-created).
+ * @param env - package row + ledger sink.
+ * @returns the whitelisting proxy standing in for ctx.
+ */
+export declare function dynamicCordisContext(ctx: Context, env: DynamicCordisGuardEnv): Context;
+//# sourceMappingURL=guard.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Dynamic-package runner, browser half: the load engine that turns one browser
+ * half's source into a live cordis plugin (closure → guard → module table →
+ * loader entry, ./runtime.ts), plus the retract announcement that unloads it.
+ *
+ * Nothing loads on activation: this page holds no dynamic package until a
+ * dispatch arrives, and a dispatch only follows a model `cordis_run` or a user
+ * pressing a card's start control. A refresh therefore starts clean by design —
+ * host process memory still holds the definition, the page simply does not run
+ * it until asked again.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ApprovalRequestId, CordisDynamicPluginId, DynamicCordisInventoryRow } from '@hasna-internal/kai-api-remotes/client';
+import type { DynamicCordisLivePackage } from './runtime.ts';
+import type { CordisRunActivity, CordisRunFailure, CordisUserRunRequest } from './orchestrator.ts';
+import type { CordisObservable, DynamicCordisRenderFailure } from './runtime.ts';
+export { CordisRunOrchestrator } from './orchestrator.ts';
+export { ClientCordisInspectRegistry } from './inspect-registry.ts';
+export type { ClientCordisInspectHost, ClientCordisInspectProviderRegistration, ClientCordisInspectQueryContext, } from './inspect-registry.ts';
+export type { CordisRunActivity, CordisRunFailure, CordisRunHostSeam, CordisRunOrchestratorEnv, CordisRunRequest, CordisUserRunRequest, } from './orchestrator.ts';
+export { DynamicCordisPackageRunner } from './runtime.ts';
+export type { CordisObservable, DynamicCordisClientHalf, DynamicCordisLivePackage, DynamicCordisLoadErrorCause, DynamicCordisLoadResult, DynamicCordisRenderFailure, DynamicCordisRunnerEnv, } from './runtime.ts';
+export { DynamicCordisStyles, evaluateClientHalf, isDynamicCordisPlugin } from './evaluator.ts';
+export type { DynamicCordisClosureEnv, DynamicCordisEvaluatedPlugin } from './evaluator.ts';
+export { dynamicCordisContext } from './guard.ts';
+export type { DynamicCordisGuardEnv, DynamicCordisSlotLedgerRow } from './guard.ts';
+export { ClientTimerService } from './timer.ts';
+export type { ApprovalRequestId, CordisDynamicPackageId, CordisDynamicPluginId, CordisDynamicPluginRunId, DynamicCordisPackage, } from '@hasna-internal/kai-api-remotes/client';
+/**
+ * What a run surface reads and calls. The activity map is the single home of
+ * "a run is in flight", so an affordance never keeps its own copy — that is what
+ * makes it survive a remount.
+ */
+export interface CordisRunnerFace {
+    /** Each definition's in-flight run activity. */
+    readonly activeRuns: CordisObservable<ReadonlyMap<CordisDynamicPluginId, CordisRunActivity>>;
+    /** The last failure of this page's own run attempt, per definition. */
+    readonly lastRunError: CordisObservable<ReadonlyMap<CordisDynamicPluginId, CordisRunFailure>>;
+    /**
+     * This page's last render crash per definition: a browser half that loaded
+     * cleanly and then broke while React rendered it. Page-local and current by
+     * construction — cleared when the package stops, is retracted, or loads again —
+     * which is what makes it safe for a row to render directly. The host keeps its
+     * own last-across-pages copy for the model; the two have different owners and
+     * lifetimes and neither is derived from the other.
+     */
+    readonly renderFailures: CordisObservable<ReadonlyMap<CordisDynamicPluginId, DynamicCordisRenderFailure>>;
+    /**
+     * Restore pending approvals after a page reconnect or missed event.
+     * @param rows - current dynamic Plugin inventory.
+     */
+    reconcileApprovals(rows: readonly DynamicCordisInventoryRow[]): void;
+    /**
+     * Answer one run request with "run it" and drive both halves.
+     * @param requestId - the request being answered; unknown or settled ids are a no-op.
+     * @param approveFutureVersions - whether this decision covers later Packages of the same Plugin.
+     * @returns after the orchestration settled.
+     */
+    approve(requestId: ApprovalRequestId, approveFutureVersions: boolean): Promise<void>;
+    /**
+     * Answer one run request with "do not run it".
+     * @param requestId - the request being answered; unknown or settled ids are a no-op.
+     * @returns after the refusal reached the host.
+     */
+    decline(requestId: ApprovalRequestId): Promise<void>;
+    /**
+     * Run a definition here at the user's own request (the gesture authorizes it).
+     * A definition with a browser half also loads onto this page; a host-only one
+     * only comes up in the host process.
+     * @param request - the definition to run, its session, and whether it has a browser half.
+     * @returns after the orchestration settled.
+     */
+    startUserRun(request: CordisUserRunRequest): Promise<void>;
+    /**
+     * Observe what this page has loaded.
+     * @param fn - notified after every converged load or unload.
+     * @returns unsubscribe.
+     */
+    subscribe(fn: () => void): () => void;
+    /**
+     * Read what this page currently has loaded.
+     * @returns immutable rows for live Client halves.
+     */
+    getSnapshot(): readonly DynamicCordisLivePackage[];
+    /**
+     * Whether this page loaded a definition's browser half — page-local truth,
+     * never the host's "it is running".
+     * @param pluginId - stable Plugin identity.
+     * @returns true while a load is live here.
+     */
+    isLoaded(pluginId: CordisDynamicPluginId): boolean;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Run orchestration and page-local load state: what run surfaces read and call. */
+        dynamicCordisRunner: CordisRunnerFace;
+    }
+}
+/** Stable Cordis plugin name. */
+export declare const name = "cordis-client-runner";
+/**
+ * Required services: the loader/module chain for entries, the slot registry for
+ * contributions, and the `dynamicCordisRunner` Remote namespace. Declaring the
+ * namespace parks this plugin until the host side exists, so a page never loads
+ * a browser half whose host half it could not reach.
+ */
+export declare const inject: string[];
+/**
+ * Client plugin body: build the runner and subscribe the dispatch family.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/inspect-registry.d.ts

@@ -0,0 +1,67 @@
+/** Browser registry for read-only Cordis capability providers. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { CordisInspectProviderManifest, CordisInspectQueryRequest, CordisInspectQueryResolution, CordisInspectRequestId, JsonValue } from '@hasna-internal/kai-api-remotes/client';
+import type { SessionId } from '@hasna-internal/kai-client-connection/client';
+/** Context supplied to a Client inspect provider query. */
+export interface ClientCordisInspectQueryContext {
+    /** Cancellation broadcast by the Host. */
+    signal: AbortSignal;
+    /** Session whose model requested the query. */
+    sessionId: SessionId;
+}
+/** Client provider registration retained beside its serializable manifest. */
+export interface ClientCordisInspectProviderRegistration {
+    /** Provider and explicit query directory. */
+    manifest: CordisInspectProviderManifest;
+    /** Execute one declared read-only method. */
+    query(method: string, input: JsonValue | undefined, context: ClientCordisInspectQueryContext): Promise<JsonValue>;
+}
+/** Remote operations needed by the Client registry. */
+export interface ClientCordisInspectHost {
+    /** Replace the Host's mirrored Client manifest. */
+    sync(providers: readonly CordisInspectProviderManifest[]): Promise<void>;
+    /** Submit one query result; the first accepted page wins. */
+    resolve(sessionId: SessionId, requestId: CordisInspectRequestId, resolution: CordisInspectQueryResolution): Promise<void>;
+}
+/** Client provider registry, manifest publisher, and live query dispatcher. */
+export declare class ClientCordisInspectRegistry {
+    private readonly host;
+    private readonly providers;
+    private readonly active;
+    private publishQueued;
+    private syncChain;
+    /** @param host - folded manifest and query result transport. */
+    constructor(host: ClientCordisInspectHost);
+    /**
+     * Register one Client provider and publish a new complete manifest.
+     * @param registration - provider manifest and local handler.
+     * @returns idempotent disposer.
+     */
+    register(registration: ClientCordisInspectProviderRegistration): () => void;
+    /** Publish the current complete manifest, including after reconnect. */
+    publish(): void;
+    /**
+     * Execute and answer one Host-broadcast query.
+     * @param request - exact provider query and Session correlation received from Host.
+     * @returns after the first local result has been sent back to Host.
+     */
+    query(request: CordisInspectQueryRequest): Promise<void>;
+    /**
+     * Cancel local work after another page answered or the Tool call ended.
+     * @param requestId - query correlation that is no longer answerable.
+     */
+    close(requestId: CordisInspectRequestId): void;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Browser registry for pre-definition Cordis capability discovery. */
+        cordisInspect: ClientCordisInspectRegistry;
+    }
+}
+/**
+ * Provide the registry as a normal Client service.
+ * @param ctx - Client Cordis context receiving the service.
+ * @param registry - page-local inspect registry to publish.
+ */
+export declare function provideClientCordisInspect(ctx: Context, registry: ClientCordisInspectRegistry): void;
+//# sourceMappingURL=inspect-registry.d.ts.map

package/lib/types/client/orchestrator.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Page-side run orchestration for model approvals and direct panel gestures.
+ * Host activation always precedes Client loading. The same Plugin-keyed state
+ * drives every surface, so remounting a panel never loses an open approval or
+ * an in-flight transition.
+ */
+import type { ApprovalRequestId, CordisDynamicPackageId, CordisDynamicPluginId, CordisDynamicPluginRunId, CordisDynamicRunMode, DynamicCordisClientSource, DynamicCordisHostHalfResult, DynamicCordisInventoryRow, DynamicCordisResolveAck, DynamicCordisRunResolution, DynamicCordisRunResponse } from '@hasna-internal/kai-api-remotes/client';
+import type { SessionId } from '@hasna-internal/kai-client-connection/client';
+import type { CordisObservable, DynamicCordisPackageRunner } from './runtime.ts';
+/** One Plugin's in-flight approval or activation. */
+export type CordisRunActivity = {
+    phase: 'awaiting-approval';
+    requestId: ApprovalRequestId;
+    agentId: SessionId;
+    packageId: CordisDynamicPackageId;
+    mode: CordisDynamicRunMode;
+    name: string;
+    purpose: string;
+} | {
+    phase: 'orchestrating';
+    agentId: SessionId;
+    packageId: CordisDynamicPackageId;
+    mode: CordisDynamicRunMode;
+};
+/** Why this page's latest activation attempt failed. */
+export interface CordisRunFailure {
+    /** Package the attempt targeted. */
+    packageId: CordisDynamicPackageId;
+    /** Which half or settlement stage failed. */
+    reason: 'host-half-failed' | 'client-half-failed';
+    /** Actionable failure text. */
+    message: string;
+    /** Original failure stack when available. */
+    stack?: string;
+}
+/** Host operations consumed by the orchestrator after transport folding. */
+export interface CordisRunHostSeam {
+    /** Start a new Host activation or attach this page to an existing one. */
+    runHostHalf(agentId: SessionId, pluginId: CordisDynamicPluginId, packageId: CordisDynamicPackageId, mode: CordisDynamicRunMode, requestId: ApprovalRequestId | null, approveFutureVersions: boolean): Promise<DynamicCordisHostHalfResult>;
+    /** Fetch Client source for one exact active run. */
+    getClientCode(agentId: SessionId, pluginId: CordisDynamicPluginId, pluginRunId: CordisDynamicPluginRunId): Promise<DynamicCordisClientSource>;
+    /** Settle a model-driven approval. */
+    resolveRequestRun(requestId: ApprovalRequestId, resolution: DynamicCordisRunResolution): Promise<DynamicCordisResolveAck>;
+    /** Settle a direct panel activation after this page handles its Client half. */
+    settleUserRun(agentId: SessionId, pluginId: CordisDynamicPluginId, resolution: DynamicCordisRunResolution): Promise<DynamicCordisRunResponse>;
+}
+/** Dependencies of one page's orchestrator. */
+export interface CordisRunOrchestratorEnv {
+    /** Page-local Client loader. */
+    runner: DynamicCordisPackageRunner;
+    /** Folded Host RPC operations. */
+    host: CordisRunHostSeam;
+}
+/** Forwarded approval request fields used by this page. */
+export interface CordisRunRequest {
+    requestId: ApprovalRequestId;
+    agentId: SessionId;
+    pluginId: CordisDynamicPluginId;
+    packageId: CordisDynamicPackageId;
+    mode: CordisDynamicRunMode;
+    name: string;
+    purpose: string;
+    requiresApproval: boolean;
+}
+/** Direct panel activation request. */
+export interface CordisUserRunRequest {
+    agentId: SessionId;
+    pluginId: CordisDynamicPluginId;
+    packageId: CordisDynamicPackageId;
+    mode: CordisDynamicRunMode;
+    /** Host-only Packages finish without a Client load or settlement call. */
+    hasClientHalf: boolean;
+}
+/** Drives Host → Client activation and publishes Plugin-keyed activity. */
+export declare class CordisRunOrchestrator {
+    private readonly env;
+    private readonly requests;
+    private readonly activity;
+    private readonly failures;
+    private readonly inFlight;
+    private readonly listeners;
+    private activityCache;
+    private failureCache;
+    /** @param env - Client loader and folded Host operations. */
+    constructor(env: CordisRunOrchestratorEnv);
+    /** Open approvals and current activation attempts, keyed by stable Plugin ID. */
+    readonly activeRuns: CordisObservable<ReadonlyMap<CordisDynamicPluginId, CordisRunActivity>>;
+    /** Latest page-side activation failure for each Plugin. */
+    readonly lastRunError: CordisObservable<ReadonlyMap<CordisDynamicPluginId, CordisRunFailure>>;
+    /**
+     * Register a Client activation request, starting it immediately when the Plugin is already authorized.
+     * @param request - forwarded approval and activation metadata.
+     */
+    open(request: CordisRunRequest): void;
+    /**
+     * Rebuild pending approvals and automatic Client activations from an authoritative Host inventory read.
+     * @param rows - complete process-wide Plugin inventory.
+     */
+    reconcileApprovals(rows: readonly DynamicCordisInventoryRow[]): void;
+    /**
+     * Close an approval settled by another page or by cancellation.
+     * @param requestId - approval request that can no longer be answered here.
+     */
+    close(requestId: ApprovalRequestId): void;
+    /**
+     * Approve and execute one still-open model request.
+     * @param requestId - approval request to execute.
+     * @param approveFutureVersions - whether this approval covers later Packages for the same Plugin.
+     */
+    approve(requestId: ApprovalRequestId, approveFutureVersions: boolean): Promise<void>;
+    /**
+     * Reject one still-open model request without executing either half.
+     * @param requestId - approval request to reject.
+     */
+    decline(requestId: ApprovalRequestId): Promise<void>;
+    /**
+     * Execute a direct panel run; the user gesture itself authorizes it.
+     * @param request - exact Package activation selected by the user.
+     */
+    startUserRun(request: CordisUserRunRequest): Promise<void>;
+    private observe;
+    private commit;
+    private orchestrate;
+    private drive;
+    private startHost;
+    private finishClientFailure;
+    private settleDirect;
+    private answer;
+    private fail;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/lib/types/client/providers.d.ts

@@ -0,0 +1,13 @@
+/** Built-in Client inspect providers over live Client-owned services. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { JsonValue } from '@hasna-internal/kai-api-remotes/client';
+import type { ClientCordisInspectProviderRegistration } from './inspect-registry.ts';
+/** Exact Client closure symbols exposed by the evaluator and guard. */
+export declare const CLIENT_BUILTIN_INSPECTION: readonly JsonValue[];
+/**
+ * Construct the first-party Client provider registrations.
+ * @param ctx - Client context used for live Service-backed queries.
+ * @returns registrations for static catalogs and live Client capabilities.
+ */
+export declare function clientInspectProviders(ctx: Context): ClientCordisInspectProviderRegistration[];
+//# sourceMappingURL=providers.d.ts.map