@wrenai/genbi 0.0.4 → 0.0.5

package/dist-server/server/native-sessions.d.ts

@@ -1,3 +1,6 @@
+import type { DirectCodexProvisioner } from "./codex-native-session.js";
+import { type CodexConversationAttachment, type ConversationFrame, type ConversationReplay } from "./runtime-host/codex-conversation.js";
+import { type NativeComponentPreparation, type NativeComponentReceipt } from "./native-components.js";
 import type { EnrichmentBinding } from "./enrichment.js";
 import { InteractiveTerminalManager } from "./interactive-terminal.js";
 import type { InteractiveLaunchSpec, InteractiveTarget, InteractiveTerminalSession } from "./interactive-terminal.js";
@@ -7,6 +10,10 @@ import { NATIVE_PURPOSES } from "./native-dispatch-registry.js";
 import type { NativePurpose, NativeRuntimeBinding, NativeVendor } from "./native-dispatch-registry.js";
 import type { NativeSessionStateBase } from "./native-session-workspace.js";
 import type { NativeWrenRuntime } from "./native-wren-runtime.js";
+import type { NativeChildEnvironment, NativeExecutableIdentity } from "./native-runtime-spec.js";
+import type { CodexWrenHome } from "./native-wren-home.js";
+import { RuntimeHost } from "./runtime-host/local.js";
+import type { RuntimeReadiness } from "./runtime-host/types.js";
 export declare const NATIVE_VENDORS: readonly ["claude", "codex"];
 export { NATIVE_PURPOSES };
 export type { NativePurpose, NativeVendor };
@@ -31,10 +38,6 @@ export declare const NATIVE_SESSION_POST_CLAIM_DETACH_GRACE_MS: number;
  * profile so WREN_PROJECT_HOME can resolve through the exact server-owned binding.
  */
 export declare function grantCodexBoundProjectRead(cwd: string, projectPath: string, dataRoots?: readonly string[]): void;
-interface CodexWrenHome {
-    readonly home: string;
-    readonly dataRoots: readonly string[];
-}
 export interface NativeSetupRecoveryReport {
     readonly version: "1";
     readonly sequence: number;
@@ -120,11 +123,65 @@ export interface NativePurposeReadiness {
 }
 export type NativeSessionReadiness = {
     readonly runtime: NativeRuntimeBinding;
+    /** Read-only RuntimeHost projection. Diagnostics remain in the host process. */
+    readonly runtimeHost?: RuntimeReadiness;
     readonly purposes: Record<NativePurpose, NativePurposeReadiness>;
+    /** Per conversation profile, when a registry is wired: analysis readiness narrowed by the profile's own verdict. */
+    readonly profiles?: Readonly<Record<string, NativeProfileReadiness>>;
     /** Health of the host-owned GenBI MCP endpoint; never includes a credential. */
     readonly mcp: NativeMcpHealth;
 } & Record<NativePurpose, NativePurposeReadiness>;
+/** User-selected analysis entry is a single pin; it never widens Claude scope. */
+export declare function selectedNativeEntry(purpose: NativePurpose, vendor: NativeVendor, entryVerb?: string | null): string | undefined;
+/**
+ * The conversation profile an analysis session starts inside.
+ *
+ * The default is the registry's fixed analysis profile and keeps every existing entry rule
+ * (`claudeScopeEntry`, `agentFor`, the Codex entry verbs). Any other id is a profile the
+ * server-held registry (`profile-registry.ts`) has admitted; its entry form was decided at
+ * admission and is carried here, never inferred at launch. A browser only ever names the id.
+ */
+export interface NativeProfileSelection {
+    readonly id: string;
+    /** Directory the session's IR is compiled from; absent means the boot-time analysis source. */
+    readonly sourceDir?: string;
+    readonly entry: {
+        readonly kind: "scope";
+    } | {
+        readonly kind: "agent";
+        readonly verb: string;
+    };
+}
+/** One conversation profile as readiness reports it; `selectable` is the registry's verdict. */
+export interface NativeConversationProfileSummary {
+    readonly id: string;
+    readonly selectable: boolean;
+    readonly reason?: string;
+    readonly entryKind?: "scope" | "agent";
+    readonly entryVerb?: string;
+}
+export interface NativeProfileReadiness {
+    readonly id: string;
+    readonly scopeKind: "bound_project";
+    readonly profile: string;
+    readonly target?: InteractiveTarget;
+    readonly targetLabel?: string;
+    readonly available: boolean;
+    readonly reason?: string;
+    readonly entryKind?: "scope" | "agent";
+    readonly entryVerb?: string;
+}
+export declare const DEFAULT_CONVERSATION_PROFILE: string;
+/** The one shape every launch entry point accepts; `profile` is only meaningful for analysis. */
+export interface NativeLaunchInput {
+    readonly purpose: NativePurpose;
+    readonly vendor?: NativeVendor;
+    readonly entryVerb?: string | undefined;
+    readonly profile?: string | undefined;
+}
 export interface NativeSessionServiceOptions {
+    /** Certified server composition only; absence keeps direct execution closed. */
+    readonly directCodex?: DirectCodexProvisioner;
     readonly store: Store;
     readonly terminalManager: () => Promise<InteractiveTerminalManager>;
     readonly getBinding: () => EnrichmentBinding | undefined;
@@ -146,12 +203,42 @@ export interface NativeSessionServiceOptions {
      * this Warble can dispatch these profile shapes at all and has no user
      * project in view. They are wrong the moment a session has a binding.
      */
-    readonly resolveDispatchIr?: (purpose: NativePurpose, binding: EnrichmentBinding | undefined) => Promise<string>;
+    readonly resolveDispatchIr?: (purpose: NativePurpose, binding: EnrichmentBinding | undefined, profileSource?: string) => Promise<string>;
+    /**
+     * Resolves a non-default conversation profile id to the directory and entry form the registry
+     * admitted it with. Rejects (with the stored reason) for an unknown, system or unavailable id.
+     * Absent means only the default profile can be selected.
+     */
+    readonly resolveConversationProfile?: (id: string) => Promise<NativeProfileSelection>;
+    /** Every conversation profile the registry lists, for per-profile readiness. */
+    readonly listConversationProfiles?: () => Promise<readonly NativeConversationProfileSummary[]>;
     readonly warbleBin: string;
     /** Absolute server-configured Wren shim for native Codex sessions; never a request input. */
     readonly wrenShim?: string;
+    /**
+     * Server-only managed-runtime record resolver. Phase 2A intentionally has
+     * no production implementation: absence is the fail-closed launch fence.
+     * A later provisioner must revalidate its immutable record in this callback;
+     * the editable `wrenShim` resolver is never a launch fallback.
+     */
+    readonly resolveManagedCodexWrenRuntime?: () => NativeWrenRuntime;
+    /** Fixed native child HOME captured by BFF composition, never request input. */
+    readonly nativeHome?: string;
+    /** Decision-17 profile source selected by server setup mode. */
+    readonly sourceWrenHome?: () => string;
+    /** Optional dedicated authenticated Codex home captured at BFF boot. */
+    readonly codexHome?: string;
+    /** Canonical vendor identities captured once by server composition. */
+    readonly vendorExecutables?: Readonly<Partial<Record<NativeVendor, NativeExecutableIdentity>>>;
+    /** Canonical Node identity used by env-shebang tools and the PTY probe. */
+    readonly nodeExecutable?: NativeExecutableIdentity;
+    readonly childToolDirectories?: readonly string[];
+    /** Fixed discovery PATH captured at BFF boot; never consulted after construction. */
+    readonly pathValue?: string;
     /** Read-only probe used by readiness; creation remains the final authority. */
     readonly terminalHostAvailable?: () => Promise<boolean>;
+    /** Phase-1 readiness boundary; no runtime host can be selected by browser input. */
+    readonly runtimeHost?: RuntimeHost;
     /** Test seam for the local executable probe. */
     readonly executableAvailable?: (vendor: NativeVendor) => boolean;
     /** Test seam for the configured local Warble producer probe. */
@@ -161,6 +248,9 @@ export interface NativeSessionServiceOptions {
         readonly runtime: NativeWrenRuntime;
         readonly projectPath: string;
         readonly cwd: string;
+        readonly sourceWrenHome: string;
+        readonly home: string;
+        readonly toolDirectories: readonly string[];
     }) => CodexWrenHome;
     /** When configured, bound native sessions use the accepted v4 MCP+welcome descriptor; v2 remains compatible for callers without it. */
     readonly artifactService?: NativeArtifactService;
@@ -174,11 +264,26 @@ export interface NativeSessionServiceOptions {
     readonly startSeparateReplayLimit?: number;
     /** Test seam for the fixed, server-owned Warble dispatch only. */
     readonly dispatch?: (input: NativeDispatchInput) => Promise<void>;
+    /** File-only producer probe. Supplied together with a certified component provisioner. */
+    readonly prepareComponentProbe?: NativeComponentProbe;
+    /** No production default: a separately certified same-account step runtime is required. */
+    readonly prepareComponents?: (input: {
+        readonly session: NativeSessionRow;
+        readonly binding: EnrichmentBinding;
+        readonly irDocument: string;
+        readonly scope: Readonly<Record<string, unknown>>;
+    }) => Promise<NativeComponentPreparation | undefined>;
 }
+export type NativeComponentProbe = (input: {
+    readonly vendor: NativeVendor;
+    readonly purpose: NativePurpose;
+    readonly irDocument: string;
+    readonly scope: Readonly<Record<string, unknown>>;
+}) => NativeComponentPreparation | undefined;
 export interface NativeDispatchInput {
     readonly warbleBin: string;
     /** Server-owned resolved producer identity captured by the compatibility preflight. */
-    readonly producer?: NativeProducerIdentity;
+    readonly producer: NativeProducerIdentity;
     readonly irPath: string;
     readonly target: InteractiveTarget;
     readonly cwd: string;
@@ -187,6 +292,9 @@ export interface NativeDispatchInput {
     readonly scope: Record<string, unknown>;
     /** Exact v4 MCP descriptor, transported separately through --native-mcp. */
     readonly mcp?: NativeMcpDescriptor;
+    readonly env: NativeChildEnvironment;
+    readonly componentHost?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
 }
 type NativeProviderLaunch = {
     readonly kind: "initial";
@@ -231,6 +339,8 @@ export interface NativeProducerPreflightResult {
      * let that failure take Claude down with it.
      */
     readonly vendors: Readonly<Record<NativeVendor, NativeProducerVendorProbe>>;
+    /** Purpose-specific results; a composed analysis failure cannot veto setup or enrichment. */
+    readonly purposes?: Readonly<Record<NativePurpose, Readonly<Record<NativeVendor, NativeProducerVendorProbe>>>>;
 }
 /**
  * Exercises the exact, file-only native dispatch boundary against the
@@ -239,16 +349,23 @@ export interface NativeProducerPreflightResult {
  * validator used just before a PTY starts.
  */
 export declare function probeNativeSessionProducer(input: {
+    readonly prepareComponents?: NativeComponentProbe;
     readonly warbleBin: string;
     readonly irPaths: Readonly<Record<NativePurpose, string | undefined>>;
     readonly wrenShim?: string;
+    /** Production Codex probes receive the same immutable-record resolver used at launch. */
+    readonly resolveManagedCodexWrenRuntime?: () => NativeWrenRuntime;
+    readonly nativeHome?: string;
+    readonly nodeExecutable?: NativeExecutableIdentity;
+    readonly childToolDirectories?: readonly string[];
+    readonly pathValue?: string;
 }): Promise<NativeProducerPreflightResult>;
 /**
  * Strict parser for the public v2/v4 producer contracts. V4 deliberately
  * omits the host-issued scope; Setup exposes only its separately authorized
  * bootstrap root, which is revalidated against the durable host configuration.
  */
-export declare function readNativeLaunchSpec(cwd: string, purpose: NativePurpose, vendor: NativeVendor, scopeId: string, binding?: EnrichmentBinding, mcp?: NativeMcpDescriptor, materializationState?: NativeSessionStateBase, authorizedWorkspace?: string, providerLaunch?: NativeProviderLaunch): InteractiveLaunchSpec;
+export declare function readNativeLaunchSpec(cwd: string, purpose: NativePurpose, vendor: NativeVendor, scopeId: string, binding?: EnrichmentBinding, mcp?: NativeMcpDescriptor, materializationState?: NativeSessionStateBase, authorizedWorkspace?: string, providerLaunch?: NativeProviderLaunch, componentReceipt?: NativeComponentReceipt, selection?: NativeProfileSelection): InteractiveLaunchSpec;
 /**
  * Materializes only host-owned, short-lived producer inputs. The scope and
  * MCP descriptor deliberately stay in separate exclusive files because the
@@ -258,7 +375,28 @@ export declare function readNativeLaunchSpec(cwd: string, purpose: NativePurpose
 export declare function dispatchNativeArtifacts(input: NativeDispatchInput): Promise<void>;
 export declare class NativeSessionService {
     private readonly options;
+    private readonly runtimeHost;
+    private readonly nativeHome;
+    private readonly wrenShim;
+    private readonly sourceWrenHome;
+    private readonly nodeExecutable;
+    private readonly producerExecutable;
+    private readonly vendorExecutables;
+    private readonly childToolDirectories;
+    private readonly conversations;
     private readonly sessions;
+    private readonly componentAdmissions;
+    private readonly componentCleanups;
+    private componentCleanupFailed;
+    private runtimeCleanupFailed;
+    private readonly pendingTerminalCleanup;
+    private readonly pendingHomeCleanup;
+    private shuttingDown;
+    private readonly shutdownController;
+    private shutdownPromise?;
+    private readonly pendingCreates;
+    private readonly runtimeSpecs;
+    private readonly codexWrenHomes;
     private readonly leaseTimers;
     /** Open/reconnect coalescing only lasts while a matching launch is in flight. */
     private readonly launches;
@@ -288,6 +426,7 @@ export declare class NativeSessionService {
      * content-addressed diagnostic; the browser never receives it.
      */
     private productionProducerPreflight;
+    private assertSelectedRuntimeReady;
     /**
      * SQLite is the durable source of truth, but a native PTY and its attach
      * capability are deliberately process-local.  A BFF restart (or a lease
@@ -308,10 +447,7 @@ export declare class NativeSessionService {
      * particular, a setup session never inherits the active project binding,
      * while a bound-purpose session cannot cross a generation or revision.
      */
-    openOrCreate(input: {
-        purpose: NativePurpose;
-        vendor?: NativeVendor;
-    }): Promise<NativeSessionLaunch>;
+    openOrCreate(input: NativeLaunchInput): Promise<NativeSessionLaunch>;
     /** Opens the exact row selected by the browser after revalidating its scope. */
     openExisting(input: {
         purpose: NativePurpose;
@@ -324,10 +460,8 @@ export declare class NativeSessionService {
      * click coalesce, while a later intentional launch receives new durable and
      * browser-scoped authority.
      */
-    startSeparate(input: {
-        purpose: NativePurpose;
-        idempotencyKey: string;
-        vendor?: NativeVendor;
+    startSeparate(input: NativeLaunchInput & {
+        readonly idempotencyKey: string;
     }): Promise<NativeSessionLaunch>;
     /**
      * Continues only a sealed Claude conversation. This creates a new durable
@@ -364,14 +498,24 @@ export declare class NativeSessionService {
     private trimStartSeparateReplays;
     private clearStartSeparateReplaysForSession;
     private singleFlight;
+    /**
+     * Resolves the profile a launch runs inside. The default needs no registry; any other id is
+     * Claude-only (the Codex entry is a purpose skill with no scope form), accepts no entry verb
+     * (its entry form was decided at admission), and must still be admitted right now.
+     */
+    private selectProfile;
+    /** Analysis readiness, narrowed per conversation profile by the registry's verdict and the vendor. */
+    private conversationProfileReadiness;
     readiness(): Promise<NativeSessionReadiness>;
-    create(input: {
-        purpose: NativePurpose;
-        vendor?: NativeVendor;
-    }, binding?: EnrichmentBinding | undefined, capturedRuntime?: NativeRuntimeBinding, resumed?: {
+    create(input: NativeLaunchInput, binding?: EnrichmentBinding | undefined, capturedRuntime?: NativeRuntimeBinding, resumed?: {
         readonly row: NativeSessionRow;
         readonly handle: string;
     }): Promise<NativeSessionLaunch>;
+    private createCaptured;
+    private liveCapability;
+    private createDirectCodex;
+    attachConversation(id: string, capability: string, listener: (frame: ConversationFrame | ConversationReplay) => void, afterSequence?: number): CodexConversationAttachment | undefined;
+    stopAndWait(id: string, capability: string): Promise<boolean>;
     attach(id: string, capability: string): InteractiveTerminalSession | undefined;
     detach(id: string): void;
     stop(id: string, capability: string): boolean;
@@ -380,6 +524,15 @@ export declare class NativeSessionService {
     revokeRuntimeCapabilities(ids: readonly string[]): void;
     /** Called after the store advances the bound-project generation. */
     revokeBindingCapabilities(ids: readonly string[]): void;
+    componentTools(id: string): readonly {
+        name: string;
+        description: string;
+        inputSchema: typeof import("./native-components.js").NATIVE_COMPONENT_REQUEST_SCHEMA;
+    }[];
+    callComponent(id: string, tool: string, input: unknown, requestId: string | number, signal: AbortSignal): Promise<import("@warble/claude-agent-sdk").ComponentInvocationResult>;
+    drainComponentCleanup(): Promise<void>;
+    shutdown(): Promise<void>;
+    private cleanupRuntime;
     /**
      * Records only the producer's closed redacted report. Completion remains a
      * host decision supplied by the canonical-artifact validator at the route.