@wrenai/genbi 0.0.4 → 0.0.5

package/dist-server/server/codex-runtime-composition.js

@@ -0,0 +1,250 @@
+import { lstatSync, realpathSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, realpath, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { codexModelsForRuntime } from "./runtime-binding.js";
+import { compileProfile } from "../harness/compile/index.js";
+import { resolveContextLoaderBinary } from "../harness/compile/context-loader.js";
+import { attestNativeExecutable, assertNativeExecutableIdentity, buildNativeRuntimeSpec } from "./native-runtime-spec.js";
+import { createEmptyCodexWrenHome } from "./native-wren-home.js";
+import { prepareCapturedCodexDirectTools } from "./native-component-context.js";
+import { CodexAppServerBackend, CodexBackendError } from "./runtime-host/codex-app-server.js";
+import { buildCodexSessionPolicy } from "./runtime-host/codex-policy.js";
+import { isCodexExecutionCertified, isCodexTerminalCertified } from "./runtime-host/codex-compatibility.js";
+import { runtimeNotReady } from "./runtime-host/policy.js";
+/** Read once at composition. No browser values, PATH discovery or credential copying. */
+export function readCodexBootConfiguration(env) {
+    const selected = env.GENBI_CODEX_RUNTIME ?? "local";
+    const local = env.GENBI_ALLOW_LOCAL_RUNTIME ?? "1";
+    if (!["local", "app-server"].includes(selected) || !["0", "1"].includes(local))
+        throw new Error("Invalid server runtime selection.");
+    return Object.freeze({ selected: selected === "app-server" ? "codex-app-server" : "local", allowLocal: local === "1",
+        ...(env.GENBI_CODEX_EXECUTABLE ? { executable: env.GENBI_CODEX_EXECUTABLE } : {}),
+        ...(env.GENBI_CODEX_SOURCE ? { source: env.GENBI_CODEX_SOURCE } : {}),
+        ...(env.WREN_HARNESS_CODEX_HOME ? { loginHome: env.WREN_HARNESS_CODEX_HOME } : {}),
+        ...(env.GENBI_CODEX_ACCOUNT_EMAIL ? { accountEmail: env.GENBI_CODEX_ACCOUNT_EMAIL } : {}) });
+}
+const unavailable = () => new CodexBackendError("runtime_policy_unavailable");
+/** Real composition for both entry surfaces; certification is enforced by the packaged backend. */
+export function createCodexRuntimeComposition(options) {
+    const config = Object.freeze({ ...options.configuration });
+    const backend = new CodexAppServerBackend({ executable: config.executable ?? "", source: config.source ?? "", packageRoot: options.packageRoot });
+    const checkConfiguration = () => {
+        if (!config.executable || !path.isAbsolute(config.executable) || !config.source?.startsWith("https://")
+            || !config.loginHome || !path.isAbsolute(config.loginHome) || !config.accountEmail?.trim())
+            throw unavailable();
+        const login = realpathSync(config.loginHome);
+        const directory = lstatSync(config.loginHome);
+        const auth = lstatSync(path.join(login, "auth.json"));
+        if (directory.isSymbolicLink() || !directory.isDirectory() || (directory.mode & 0o777) !== 0o700
+            || login === path.join(os.homedir(), ".codex") || !auth.isFile() || auth.isSymbolicLink() || (auth.mode & 0o077) !== 0)
+            throw unavailable();
+        return login;
+    };
+    const checkExecutionScope = (entry) => {
+        const models = codexModelsForRuntime(options.store.getRuntimeSettings());
+        const vendor = attestNativeExecutable("vendor", config.executable);
+        if (!isCodexExecutionCertified(config.source, vendor.digest.slice(7), Object.values(models), entry))
+            throw unavailable();
+    };
+    const probe = async () => {
+        const result = await backend.probe();
+        if (result.readiness.state !== "ready")
+            return result;
+        try {
+            checkConfiguration();
+            checkExecutionScope("answer_query");
+            attestNativeExecutable("producer", options.producerBinary);
+            resolveContextLoaderBinary();
+            return result;
+        }
+        catch {
+            return { readiness: runtimeNotReady("codex-app-server", "unprovisioned", "runtime_policy_unavailable"), diagnostic: { phase: "policy" } };
+        }
+    };
+    async function prepare(input) {
+        input.permit.assertActive();
+        input.assertActive();
+        input.signal.throwIfAborted();
+        if (!["answer_query", "generate_dashboard"].includes(input.entry))
+            throw unavailable();
+        const loginHome = checkConfiguration();
+        checkExecutionScope(input.entry);
+        const binding = structuredClone(input.binding);
+        const settings = structuredClone(options.store.getRuntimeSettings());
+        const generation = options.store.getNativeRuntimeBinding().generation;
+        if (settings.authMode !== "subscription" || settings.subscriptionProvider !== "codex")
+            throw unavailable();
+        const models = codexModelsForRuntime(settings);
+        if (!models.orchestrator.trim())
+            throw unavailable();
+        const sourceHome = options.sourceWrenHome();
+        const runtime = input.permit.runtime;
+        const vendor = attestNativeExecutable("vendor", config.executable);
+        const producer = attestNativeExecutable("producer", options.producerBinary);
+        const loader = attestNativeExecutable("producer", resolveContextLoaderBinary());
+        const node = attestNativeExecutable("node", process.execPath);
+        const wren = attestNativeExecutable("wren", runtime.launcher);
+        const python = attestNativeExecutable("python", runtime.venv_python);
+        const identity = { session_id: input.id, vendor: "codex", auth_identity: config.accountEmail, runtime_generation: String(generation),
+            binding: { project_identity: binding.identity, generation: String(binding.generation), revision: binding.revision } };
+        let retired = false;
+        const checkLive = () => {
+            input.signal.throwIfAborted();
+            input.assertActive();
+            if (retired || !isDeepStrictEqual(options.getBinding(), binding) || !isDeepStrictEqual(options.store.getRuntimeSettings(), settings)
+                || options.store.getNativeRuntimeBinding().generation !== generation || sourceHome !== options.sourceWrenHome() || checkConfiguration() !== loginHome)
+                throw unavailable();
+        };
+        const check = () => {
+            checkLive();
+            for (const executable of [vendor, producer, loader, node, wren, python])
+                assertNativeExecutableIdentity(executable);
+        };
+        check();
+        input.permit.assertActive();
+        const root = await realpath(await mkdtemp(path.join(os.tmpdir(), "genbi-codex-session-")));
+        let tools;
+        const steps = new Set();
+        let cleanupFailed = false;
+        let cleaned = false;
+        const dispose = async () => {
+            if (cleaned)
+                return;
+            if (cleanupFailed || steps.size)
+                throw new CodexBackendError("codex_app_server_cleanup_failed");
+            retired = true;
+            await rm(root, { recursive: true, force: true });
+            cleaned = true;
+        };
+        try {
+            check();
+            input.permit.assertActive();
+            const workspace = path.join(root, "workspace"), home = path.join(root, "home");
+            await mkdir(workspace, { mode: 0o700 });
+            await mkdir(home, { mode: 0o700 });
+            const wrenHome = createEmptyCodexWrenHome(workspace);
+            const spec = buildNativeRuntimeSpec({ backend: "codex-app-server", vendor: "codex", executables: [vendor, producer, node, wren, python],
+                toolDirectories: await Promise.all([path.dirname(node.executable), "/usr/bin", "/bin", path.dirname(runtime.launcher)].map((directory) => realpath(directory))), workspace, home,
+                binding, sessionWrenHome: wrenHome.home, codexHome: loginHome });
+            buildCodexSessionPolicy(spec, runtime, wrenHome, true, models.orchestrator);
+            const compiled = await compileProfile({ profileSource: options.profileSource, userProject: binding.path, mode: "native", warbleBin: producer.executable });
+            check();
+            input.permit.assertActive();
+            const irDocument = await readFile(compiled.irPath, "utf8");
+            tools = await prepareCapturedCodexDirectTools(irDocument, { binding: identity.binding, entry: { kind: "agent", verb: input.entry, prompt: "Use the selected analysis tool." } }, {
+                identity, currentIdentity: () => { checkLive(); return identity; }, assertCurrent: check, assertLive: checkLive,
+                verifierBinary: producer.executable, producerBinary: producer.executable, contextLoaderBinary: loader.executable,
+                wrenBinary: wren.executable, project: binding.path, signal: input.signal, expiresAt: Date.now() + 60 * 60_000,
+                wrenEnvironment: { PATH: [path.dirname(runtime.launcher), path.dirname(runtime.venv_python), "/usr/bin", "/bin"].join(path.delimiter), HOME: home,
+                    WREN_HOME: sourceHome, WREN_PROJECT_HOME: binding.path, PYTHONNOUSERSITE: "1", PYTHONUTF8: "1", PYTHONDONTWRITEBYTECODE: "1" },
+                ...(input.persistRoot ? { persistRoot: input.persistRoot } : {}),
+                vendor: { vendor: "codex", authIdentity: config.accountEmail, accountEmail: config.accountEmail, generation: String(generation),
+                    models: { cheap: models.cheap, strong: models.strong }, assertCurrent: check, assertLive: checkLive,
+                    async open(model, signal) {
+                        check();
+                        signal.throwIfAborted();
+                        const permit = backend.prepareLaunch();
+                        try {
+                            if (!isDeepStrictEqual(permit.runtime, runtime))
+                                throw unavailable();
+                            const resource = backend.openStep(permit, { spec, wrenHome, model, accountEmail: config.accountEmail, signal, assertScopeActive: checkLive });
+                            const raw = resource.transport;
+                            let closing;
+                            const transport = { listen: raw.listen.bind(raw), write: raw.write.bind(raw), close: () => closing ??= (async () => {
+                                    try {
+                                        await raw.close();
+                                        steps.delete(transport);
+                                    }
+                                    catch (error) {
+                                        cleanupFailed = true;
+                                        throw error;
+                                    }
+                                })() };
+                            steps.add(transport);
+                            return { ...resource, transport };
+                        }
+                        finally {
+                            permit.release();
+                        }
+                    } },
+            });
+            check();
+            input.permit.assertActive();
+            const preparedTools = tools;
+            const scopedTools = { ...tools, async close() {
+                    const results = await Promise.allSettled([preparedTools.close(), ...[...steps].map((step) => step.close())]);
+                    if (cleanupFailed || results.some((item) => item.status === "rejected")) {
+                        cleanupFailed = true;
+                        throw new CodexBackendError("codex_app_server_cleanup_failed");
+                    }
+                } };
+            return { input: { spec, wrenHome, model: models.orchestrator, tools: scopedTools, assertScopeActive: checkLive }, dispose };
+        }
+        catch (error) {
+            try {
+                await tools?.close();
+                await dispose();
+            }
+            catch {
+                throw new CodexBackendError("codex_app_server_cleanup_failed");
+            }
+            throw error;
+        }
+    }
+    const terminalCertified = (entry) => {
+        try {
+            const vendor = attestNativeExecutable("vendor", config.executable);
+            return isCodexTerminalCertified(config.source, vendor.digest.slice(7), Object.values(codexModelsForRuntime(options.store.getRuntimeSettings())), entry);
+        }
+        catch {
+            return false;
+        }
+    };
+    const native = { backend, terminal: true, terminalCertified, async prepare(input) {
+            input.permit.assertActive();
+            input.assertActive();
+            input.signal.throwIfAborted();
+            checkConfiguration();
+            checkExecutionScope(input.session.entryVerb ?? "answer_query");
+            if (!terminalCertified(input.session.entryVerb ?? "answer_query"))
+                throw unavailable();
+            const credential = options.artifacts.issue(input.session, input.binding).credential;
+            try {
+                const prepared = await prepare({ id: input.session.id, binding: input.binding, entry: input.session.entryVerb ?? "answer_query",
+                    permit: input.permit, signal: input.signal, assertActive: input.assertActive,
+                    async persistRoot(result, _binding, signal) {
+                        signal.throwIfAborted();
+                        input.assertActive();
+                        if (result.provenance?.verified !== true)
+                            return;
+                        if (result.output.kind === "render") {
+                            options.artifacts.saveGrounded(credential, { version: "1", idempotency_key: randomUUID(), name: "Generated dashboard",
+                                envelope: { blocks: result.output.blocks, ...(result.output.summary ? { summary: result.output.summary } : {}), verified: true } });
+                        }
+                        else {
+                            const table = z.object({ columns: z.array(z.string()), rows: z.array(z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())])) }).parse(result.output.value);
+                            const blocks = [{ type: "table", columns: table.columns, rows: table.rows }];
+                            if (result.provenance.definition)
+                                blocks.push({ type: "definition", ...z.record(z.string(), z.unknown()).parse(result.provenance.definition) });
+                            options.artifacts.persistGroundedAnswer(credential, { version: "1", idempotency_key: randomUUID(), envelope: { blocks, verified: true } });
+                        }
+                    } });
+                return { ...prepared, async dispose() { options.artifacts.revoke(credential); await prepared.dispose(); } };
+            }
+            catch (error) {
+                options.artifacts.revoke(credential);
+                throw error;
+            }
+        } };
+    const structured = { backend: { probe, prepareLaunch: backend.prepareLaunch.bind(backend), open: backend.open.bind(backend) }, async prepare({ options: request, scope, permit }) {
+            const binding = options.getBinding();
+            if (!binding || request.userProject !== binding.path || !scope.signal)
+                throw unavailable();
+            return prepare({ id: `${scope.sessionId}:${scope.turnId}`, binding, entry: request.agentId ?? "answer_query", permit, signal: scope.signal, assertActive: scope.assertCurrent });
+        } };
+    return { probe, native, structured, shutdown: () => backend.shutdown() };
+}

package/dist-server/server/codex-structured-ask.d.ts

@@ -0,0 +1,23 @@
+import { type RouteOptions } from "../harness/index.js";
+import { type CodexAppServerBackend, type CodexLaunchPermit } from "./runtime-host/codex-app-server.js";
+import type { CodexSessionTools } from "./runtime-host/codex-direct-tools.js";
+import { type StructuredAdapter, type StructuredScope } from "./structured-runtime.js";
+type OpenInput = Omit<Parameters<CodexAppServerBackend["open"]>[1], "onEvent" | "tools"> & {
+    readonly tools: CodexSessionTools;
+};
+export interface CodexStructuredProvisioner {
+    readonly backend: Pick<CodexAppServerBackend, "prepareLaunch" | "open" | "probe">;
+    /** Own partial allocations on failure; use only captured scope and server-resolved credentials. */
+    prepare(input: {
+        readonly options: RouteOptions;
+        readonly scope: StructuredScope;
+        readonly permit: CodexLaunchPermit;
+    }): Promise<{
+        readonly input: OpenInput;
+        /** Delete materialization only after process and scoped tools have confirmed close. */
+        dispose(): Promise<void>;
+    }>;
+}
+/** Supported direct composition is analysis only; no Setup producer contract is implied. */
+export declare function createCodexStructuredAdapter(provisioner: CodexStructuredProvisioner): StructuredAdapter;
+export {};

package/dist-server/server/codex-structured-ask.js

@@ -0,0 +1,102 @@
+import { createAgentEventEmitter, enforceCompliance } from "../harness/index.js";
+import { CodexBackendError } from "./runtime-host/codex-app-server.js";
+import { CodexRpcError } from "./runtime-host/codex-rpc.js";
+import { structuredQueryEnvelope, analyticalAskPrompt } from "./structured-query-evidence.js";
+import { StructuredRuntimeError } from "./structured-runtime.js";
+/** Supported direct composition is analysis only; no Setup producer contract is implied. */
+export function createCodexStructuredAdapter(provisioner) {
+    return {
+        vendor: "codex", backend: "codex-app-server",
+        async probe() { return (await provisioner.backend.probe()).readiness; },
+        async ask(options, scope) {
+            if (options.authChoice.mode !== "subscription" || options.authChoice.provider !== "codex"
+                || !["answer_query", "generate_dashboard"].includes(options.agentId ?? "answer_query")
+                || options.modelsConfig !== undefined || options.tierBinding !== undefined || options.disclosurePolicy !== undefined || options.zoneRoles !== undefined)
+                throw new StructuredRuntimeError("unsupported");
+            scope.assertCurrent();
+            const { warnings } = enforceCompliance(options.authChoice, { deployment: options.deployment ?? "personal" });
+            const permit = provisioner.backend.prepareLaunch();
+            let prepared;
+            let driver;
+            const emitter = createAgentEventEmitter(options.onEvent);
+            let closing;
+            let unconfirmedOpenCleanup = false;
+            const close = () => closing ??= (async () => {
+                const results = await Promise.allSettled([driver?.close(), prepared?.input.tools.close()]);
+                if (unconfirmedOpenCleanup || results.some((result) => result.status === "rejected"))
+                    throw new StructuredRuntimeError("cleanup");
+                await prepared?.dispose();
+            })();
+            const abort = () => { void close().catch(() => { }); };
+            try {
+                permit.assertActive();
+                scope.assertCurrent();
+                prepared = await provisioner.prepare({ options, scope, permit });
+                scope.assertCurrent();
+                permit.assertActive();
+                prepared.input.tools.assertCurrent();
+                const hostGuard = prepared.input.assertScopeActive;
+                const hostTools = prepared.input.tools;
+                const rootResults = [];
+                let toolFailed = false;
+                const tools = { ...hostTools, async call(...args) {
+                        try {
+                            const value = await hostTools.call(...args);
+                            scope.assertCurrent();
+                            hostTools.assertCurrent();
+                            rootResults.push(structuredClone(value));
+                            return value;
+                        }
+                        catch (error) {
+                            toolFailed = true;
+                            throw error;
+                        }
+                    } };
+                driver = await provisioner.backend.open(permit, { ...prepared.input, tools, assertScopeActive: () => { scope.assertCurrent(); hostGuard(); }, onEvent(event) {
+                        scope.assertCurrent();
+                        if ((event.method === "item/started" || event.method === "item/completed") && event.params.item.type === "dynamicToolCall") {
+                            const item = event.params.item;
+                            if (event.method === "item/started")
+                                emitter.emit({ kind: "tool.call", stepId: "analysis", callId: item.id, tool: "component", depth: 0, status: "running" });
+                            else
+                                emitter.emit({ kind: "tool.result", stepId: "analysis", callId: item.id, tool: "component", status: item.success === false || item.status === "failed" ? "error" : "success" });
+                        }
+                    } });
+                scope.signal?.addEventListener("abort", abort, { once: true });
+                scope.assertCurrent();
+                emitter.emit({ kind: "run.start", mode: "B", agentId: options.agentId ?? "answer_query" });
+                await driver.startThread();
+                scope.assertCurrent();
+                const result = await driver.runTurn(analyticalAskPrompt(options.question, new Date()), { ...(scope.signal ? { signal: scope.signal } : {}), timeoutMs: options.chatTimeoutMs ?? 300_000 });
+                scope.assertCurrent();
+                prepared.input.tools.assertCurrent();
+                if (result.status !== "completed")
+                    throw new StructuredRuntimeError("failed");
+                const finalText = result.items.filter((item) => item.type === "agentMessage").map((item) => item.text).join("\n");
+                if (!finalText.trim() || Buffer.byteLength(finalText) > 1_048_576)
+                    throw new StructuredRuntimeError("failed");
+                const envelope = toolFailed ? undefined : structuredQueryEnvelope(rootResults, finalText);
+                await close();
+                scope.assertCurrent();
+                emitter.emit({ kind: "run.finish", status: "answer" });
+                return { backend: "codex-app-server", warnings, finalText, ...(envelope ? { envelope } : {}), dataAttempted: toolFailed || rootResults.length > 0 };
+            }
+            catch (error) {
+                if (error instanceof CodexBackendError && error.code === "codex_app_server_cleanup_failed")
+                    unconfirmedOpenCleanup = true;
+                try {
+                    await close();
+                }
+                catch {
+                    throw new StructuredRuntimeError("cleanup");
+                }
+                throw error instanceof StructuredRuntimeError ? error : new StructuredRuntimeError(scope.signal?.aborted ? "cancelled"
+                    : error instanceof CodexRpcError && error.reason === "timeout" ? "timeout" : "failed");
+            }
+            finally {
+                scope.signal?.removeEventListener("abort", abort);
+                permit.release();
+            }
+        },
+    };
+}

package/dist-server/server/conn-config.js

@@ -35,7 +35,7 @@
  * so a small line-based parser is enough here; pulling in a full YAML
  * library for one flat file would be overkill. `wren_project.yml` only ever
  * needs two scalar fields read out of it, so it gets the same small-parser
- * treatment (mirrors `server/adopt.ts`'s own `readYamlScalarField`).
+ * treatment (shares `readYamlScalarField` with `server/adopt.ts`, from `harness/setup/yaml-scalar.ts`).
  *
  * SECURITY: `describeConnection` only ever reads from a fixed ALLOWLIST of
  * non-secret field names (host/port/database/project id/…) when building the
@@ -48,6 +48,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { loadProfileStore } from "./wren-profiles.js";
+import { readYamlScalarField } from "../harness/setup/yaml-scalar.js";
 function stripQuotes(value) {
     if (value.length >= 2) {
         const first = value[0];
@@ -156,19 +157,6 @@ export function loadConnConfig(projectDir) {
     }
     return raw.datasource !== undefined ? { datasource: raw.datasource, fields } : { fields };
 }
-/**
- * Matches a `wren_project.yml` top-level `field: value` scalar line — a
- * second small instance of `server/adopt.ts`'s own `readYamlScalarField`
- * rather than an import from it: this module only ever needs the same two
- * fields (`data_source`, `profile`), and adopt.ts's function isn't exported
- * for reuse, so a four-line regex duplicated here is cheaper than adding a
- * cross-module export just for it.
- */
-function readManifestScalar(content, field) {
-    const re = new RegExp(`^${field}:\\s*(.+?)\\s*$`, "m");
-    const match = re.exec(content);
-    return match ? stripQuotes(match[1].trim()) : undefined;
-}
 /** Reads `<projectDir>/wren_project.yml`'s persistent `data_source:`/`profile:` scalars. Unlike `conn.yml`, this file always exists on a bound wren project. Returns `undefined` only when the manifest itself is missing/unreadable — never throws. */
 export function loadProjectManifest(projectDir) {
     const manifestPath = path.join(projectDir, "wren_project.yml");
@@ -176,8 +164,8 @@ export function loadProjectManifest(projectDir) {
         return undefined;
     try {
         const content = readFileSync(manifestPath, "utf-8");
-        const dataSource = readManifestScalar(content, "data_source");
-        const profile = readManifestScalar(content, "profile");
+        const dataSource = readYamlScalarField(content, "data_source") || undefined;
+        const profile = readYamlScalarField(content, "profile") || undefined;
         return { ...(dataSource !== undefined ? { dataSource } : {}), ...(profile !== undefined ? { profile } : {}) };
     }
     catch {

package/dist-server/server/conversation-socket.d.ts

@@ -0,0 +1,16 @@
+import type { NativeSessionService } from "./native-sessions.js";
+interface Socket {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    raw?: unknown;
+}
+/** A socket owns exactly one attachment; a rejected socket cannot detach another. */
+export declare function conversationSocket(service: NativeSessionService | undefined, id: string, capability: string, cursor: string): {
+    onOpen(_event: unknown, ws: Socket): void;
+    onMessage(event: {
+        data: unknown;
+    }, ws: Socket): void;
+    onClose(): void;
+    onError(): void;
+};
+export {};

package/dist-server/server/conversation-socket.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { CodexConversationError } from "./runtime-host/codex-conversation.js";
+const command = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("prompt"), text: z.string().trim().min(1) }).strict(),
+    z.object({ type: z.literal("interrupt") }).strict(),
+]);
+/** A socket owns exactly one attachment; a rejected socket cannot detach another. */
+export function conversationSocket(service, id, capability, cursor) {
+    let attachment;
+    let disposed = false;
+    const detach = () => { disposed = true; attachment?.detach(); attachment = undefined; };
+    const send = (ws, value) => {
+        if (disposed)
+            return;
+        const raw = ws.raw;
+        const json = JSON.stringify(value);
+        if ((raw?.bufferedAmount ?? 0) + Buffer.byteLength(json) > 2_097_152)
+            throw new Error("conversation backpressure");
+        ws.send(json);
+    };
+    const reject = (ws) => { detach(); ws.close(1008, "Conversation unavailable"); };
+    return {
+        onOpen(_event, ws) {
+            if (disposed)
+                return reject(ws);
+            if (!/^(0|[1-9][0-9]{0,15})$/.test(cursor))
+                return reject(ws);
+            attachment = service?.attachConversation(id, capability, (frame) => send(ws, frame), Number(cursor));
+            if (!attachment)
+                reject(ws);
+        },
+        onMessage(event, ws) {
+            if (!attachment || disposed)
+                return reject(ws);
+            try {
+                if (typeof event.data !== "string" || Buffer.byteLength(event.data) > 270_000)
+                    return reject(ws);
+                const value = command.parse(JSON.parse(event.data));
+                const pending = value.type === "prompt" ? attachment.submit(value.text) : attachment.interrupt();
+                void pending.catch((error) => {
+                    try {
+                        send(ws, { type: "error", code: error instanceof CodexConversationError && error.code === "busy" ? "busy" : "unavailable" });
+                    }
+                    catch {
+                        reject(ws);
+                    }
+                });
+            }
+            catch (error) {
+                if (error instanceof CodexConversationError && error.code === "busy") {
+                    try {
+                        send(ws, { type: "error", code: "busy" });
+                    }
+                    catch {
+                        reject(ws);
+                    }
+                }
+                else
+                    reject(ws);
+            }
+        },
+        onClose() { detach(); },
+        onError() { detach(); },
+    };
+}

package/dist-server/server/db.d.ts

@@ -25,10 +25,12 @@ export type NativeSetupRecoveryPhase = "connect" | "context";
 export type NativeSetupRecoveryState = "working" | "needs_input" | "needs_decision" | "retryable_failure" | "reported_complete";
 export type NativeSetupRecoveryCode = "in_progress" | "user_action_required" | "continue_or_stop" | "retryable" | "completion_reported";
 export interface NativeSessionRow {
+    readonly transport?: "conversation";
     readonly id: string;
     readonly purpose: NativeSessionPurpose;
     readonly vendor: NativeSessionVendor;
     readonly agent: string;
+    readonly entryVerb?: string | null;
     readonly scopeKind: NativeSessionScopeKind;
     readonly scopeId: string;
     readonly projectIdentity: string | null;
@@ -62,6 +64,33 @@ export interface NativeSessionResumeAction {
     readonly scopeFingerprint: string;
     readonly resumedSessionId: string;
 }
+export type WarbleProfileKind = "builtin" | "user";
+export type WarbleProfileRole = "conversation" | "system";
+export type WarbleProfileAdmissionStatus = "admitted" | "unavailable";
+export type WarbleProfileEntryKind = "scope" | "agent";
+/**
+ * One registered Warble profile (see server/profile-registry.ts). `componentsJson` is the
+ * admission-time component summary, kept so the UI can explain a verdict without recompiling.
+ */
+export interface WarbleProfileRow {
+    readonly id: string;
+    readonly kind: WarbleProfileKind;
+    readonly role: WarbleProfileRole;
+    readonly sourceDir: string;
+    readonly profileHash: string;
+    readonly warbleIdentity: string;
+    readonly admissionStatus: WarbleProfileAdmissionStatus;
+    readonly admissionReason: string | null;
+    readonly entryKind: WarbleProfileEntryKind | null;
+    readonly entryVerb: string | null;
+    readonly irVersion: string | null;
+    readonly componentsJson: string;
+    /** The admission rule set the verdict was computed under; a newer set re-runs admission. */
+    readonly rulesVersion: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly admittedAt: string | null;
+}
 /**
  * Session-scoped, typed answer material retained for native follow-up tools.
  * `envelopeJson` is limited by the native-artifact contract to table and
@@ -76,6 +105,8 @@ export interface NativeStructuredAnswerRow {
     readonly envelopeJson: string;
     readonly digest: string;
     readonly createdAt: string;
+    /** True only when the host persisted a grounded component root; a model-typed answer is never grounded. */
+    readonly grounded: boolean;
 }
 /** Retained answers are intentionally bounded without a global cleanup job. */
 export declare const MAX_NATIVE_STRUCTURED_ANSWERS_PER_SESSION = 32;
@@ -382,6 +413,7 @@ export interface ContextSetupSuccessPersistence {
 }
 export declare class Store {
     private readonly db;
+    private closed;
     private readonly onContextSuccessWrite;
     private readonly onEnrichmentTransitionWrite;
     private readonly onEnrichmentCreationWrite;
@@ -416,12 +448,16 @@ export declare class Store {
     private migrateSchema;
     private addColumnIfMissing;
     close(): void;
+    /** Lets delayed process-local cleanup avoid touching SQLite after shutdown. */
+    isClosed(): boolean;
     createSession(title: string): SessionRow;
     createNativeSession(params: {
+        transport?: "conversation";
         id: string;
         purpose: NativeSessionPurpose;
         vendor: NativeSessionVendor;
         agent: string;
+        entryVerb?: string | undefined;
         scopeKind: NativeSessionScopeKind;
         scopeId: string;
         projectIdentity?: string;
@@ -452,6 +488,7 @@ export declare class Store {
             readonly purpose: NativeSessionPurpose;
             readonly vendor: NativeSessionVendor;
             readonly agent: string;
+            readonly entryVerb?: string | undefined;
             readonly scopeKind: NativeSessionScopeKind;
             readonly scopeId: string;
             readonly projectIdentity?: string;
@@ -473,6 +510,7 @@ export declare class Store {
         readonly idempotencyKey: string;
         readonly envelopeJson: string;
         readonly digest: string;
+        readonly grounded: boolean;
     }): {
         readonly row: NativeStructuredAnswerRow;
         readonly created: boolean;
@@ -480,6 +518,13 @@ export declare class Store {
     getNativeStructuredAnswer(id: string): NativeStructuredAnswerRow | undefined;
     getNativeStructuredAnswerByIdempotency(nativeSessionId: string, idempotencyKey: string): NativeStructuredAnswerRow | undefined;
     getLatestNativeStructuredAnswer(nativeSessionId: string): NativeStructuredAnswerRow | undefined;
+    upsertWarbleProfile(row: WarbleProfileRow): WarbleProfileRow;
+    getWarbleProfile(id: string): WarbleProfileRow | undefined;
+    /** Built-ins first (in registration order), then user profiles by id. */
+    listWarbleProfiles(): WarbleProfileRow[];
+    deleteWarbleProfile(id: string): boolean;
+    /** How many native sessions ever ran inside this profile; the registry refuses to remove a referenced one. */
+    countNativeSessionsByDispatchProfile(profileId: string): number;
     listNativeSessions(): NativeSessionRow[];
     transitionNativeSession(id: string, status: NativeSessionStatus, patch?: {
         exitCode?: number | null;
@@ -631,6 +676,7 @@ export declare class Store {
         agent: string;
         digest: string;
         idempotencyKey: string;
+        verified: boolean;
         sourceAnswerId?: string;
     }): {
         readonly row: ArtifactRow;