@wrenai/genbi 0.0.2 → 0.0.4

package/README.md

@@ -25,7 +25,7 @@ the rest:
 
 ## Developer preview
 
-`@wrenai/genbi` is published at `0.0.2`. Nothing here is under a compatibility
+`@wrenai/genbi` is published at `0.0.4`. Nothing here is under a compatibility
 commitment yet — commands, environment variables and interfaces move without
 notice. The Codex runtime is supported in code but has not been exercised end
 to end; Claude is the one that is. See

package/dist-server/harness/compile/resolve-binary.js

@@ -31,6 +31,16 @@ import { isWarbleSiblingCheckoutDevModeEnabled, resolveInstalledPackageBin } fro
  */
 export async function resolveWarbleBinary(explicit) {
     if (explicit !== undefined) {
+        // A value with no path separator is a command name, not a file path, and is
+        // resolved on PATH — the same reading the native-session preflight gives it.
+        // Requiring it to exist relative to the working directory made `"warble"` an
+        // explicit value that could never resolve, while the preflight found it and
+        // reported the producer healthy: one string, two answers.
+        if (!explicit.includes(path.sep) && !path.isAbsolute(explicit)) {
+            if (await isExecutableOnPath(explicit))
+                return explicit;
+            throw new WarbleBinaryNotFoundError([`explicit warbleBin "${explicit}" is not on PATH`]);
+        }
         if (!existsSync(explicit)) {
             throw new WarbleBinaryNotFoundError([`explicit warbleBin "${explicit}" does not exist`]);
         }

package/dist-server/server/bin.js

@@ -105,6 +105,7 @@ import { createApp } from "./app.js";
 import { recoverBootstrapProjectBinding } from "./bootstrap-project-binding.js";
 import { createHarnessProfileSources } from "./harness-profile-sources.js";
 import { compileProfile, compileRawProfile } from "../harness/compile/index.js";
+import { resolveWarbleBinary } from "../harness/compile/resolve-binary.js";
 import { toAuthChoiceFromRuntimeSettings } from "./auth-choice.js";
 import { Store } from "./db.js";
 import { resolveEnrichmentBinding, resolveProjectIdentity } from "./enrichment.js";
@@ -170,6 +171,22 @@ async function main() {
     // (server/turn.ts) and `server/spa.ts`.
     const candidateStaticDir = path.join(packageRoot, "dist");
     const staticDir = existsSync(path.join(candidateStaticDir, "index.html")) ? candidateStaticDir : undefined;
+    // Resolve the Warble binary once, here, and hand the resolved path to every
+    // consumer. Passing the bare name `"warble"` looked like a harmless default and
+    // was not: `resolveWarbleBinary` treats any value it is given as an explicit
+    // path and only searches when given nothing, so that default disabled the one
+    // lookup that finds the `@warble/cli` an install actually ships. It also made
+    // two resolvers disagree about the same string — the native preflight resolves
+    // a bare name through PATH and reported the producer healthy, while every
+    // compile failed.
+    const resolvedWarbleBin = await resolveWarbleBinary(flags.warbleBin).catch((error) => {
+        // Not fatal: the app still starts, and readiness reports the reason per
+        // vendor rather than the process dying at boot over a feature the user may
+        // not reach.
+        process.stderr.write(`warning: ${error instanceof Error ? error.message : String(error)}\n`);
+        return undefined;
+    });
+    const warbleBinOption = resolvedWarbleBin !== undefined ? { warbleBin: resolvedWarbleBin } : {};
     const profileSource = flags.profile ?? resolveDefaultProfileSource();
     // Frozen at boot: GET /api/harness accepts only a purpose and must never
     // inherit a caller-supplied RouteOptions.profileSource.
@@ -459,7 +476,7 @@ async function main() {
             binding,
             artifactRoot,
             materializationState: nativeMaterializationState,
-            materialize: () => dispatchInteractiveArtifacts({ warbleBin: flags.warbleBin ?? "warble", irPath: enrichIrPath, target, cwd: artifactRoot, boundProject: binding.path, materializationState: nativeMaterializationState }),
+            materialize: () => dispatchInteractiveArtifacts({ warbleBin: resolvedWarbleBin ?? "warble", irPath: enrichIrPath, target, cwd: artifactRoot, boundProject: binding.path, materializationState: nativeMaterializationState }),
         }, { getCurrentBinding: currentInteractiveBinding });
     }
     const nativeMcpUrl = `http://127.0.0.1:${port}/api/native-sessions/mcp`;
@@ -489,11 +506,13 @@ async function main() {
         resolveDispatchIr: async (purpose, binding) => {
             const profileSource = harnessProfileSources[purpose];
             const compiled = purpose === "setup" || binding === undefined
-                ? await compileRawProfile({ profileSource, mode: "native", warbleBin: flags.warbleBin ?? "warble" })
-                : await compileProfile({ profileSource, userProject: binding.path, mode: "native", warbleBin: flags.warbleBin ?? "warble" });
+                ? await compileRawProfile({ profileSource, mode: "native", ...warbleBinOption })
+                : await compileProfile({ profileSource, userProject: binding.path, mode: "native", ...warbleBinOption });
             return compiled.irPath;
         },
-        warbleBin: flags.warbleBin ?? "warble",
+        // The service's option is a required string; when resolution failed the bare
+        // name is what the preflight will report as unresolvable, with its reason.
+        warbleBin: resolvedWarbleBin ?? "warble",
         ...(process.env["WREN_HARNESS_WREN_SHIM"] !== undefined ? { wrenShim: process.env["WREN_HARNESS_WREN_SHIM"] } : {}),
         terminalHostAvailable: async () => {
             try {

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

@@ -95,6 +95,17 @@ export interface NativeVendorReadiness {
 export interface NativeProducerReadiness {
     readonly available: boolean;
     readonly category?: "native_session_producer_incompatible";
+    /**
+     * Why the preflight rejected the producer. Safe to send: every field is a
+     * fixed string plus a content digest of the resolved binary — the phase name,
+     * a `result=` token, and (for a Wren runtime rejection) one of that resolver's
+     * fixed sentences. None of them interpolate a path or process output.
+     *
+     * It is here because the category alone named a state without a cause, so an
+     * operator reading the Sessions view could not tell a missing binary from an
+     * incompatible one, and neither could a bug report.
+     */
+    readonly diagnostic?: string;
 }
 export interface NativePurposeReadiness {
     readonly scopeKind: "bootstrap" | "bound_project";
@@ -196,13 +207,30 @@ export interface NativeProducerIdentity {
     readonly executable: string;
     readonly identity: string;
 }
+/** One vendor's own preflight outcome. A vendor nobody selected must not speak for one that was. */
+export interface NativeProducerVendorProbe {
+    readonly available: boolean;
+    /** Browser-safe: a fixed sentence, never a path or process output. */
+    readonly reason?: string;
+    /** Fixed fields plus a content digest; never a command path or process output. */
+    readonly diagnostic: string;
+}
 export interface NativeProducerPreflightResult {
+    /** True when at least one vendor is usable — never a verdict on the vendor in use. */
     readonly available: boolean;
     readonly category?: typeof NATIVE_PRODUCER_CATEGORY;
     /** Server-only resolved executable and content identity for the eventual launch. */
     readonly producer?: NativeProducerIdentity;
     /** Server-only: fixed fields plus a content digest; never a command path or process output. */
     readonly diagnostic: string;
+    /**
+     * Per-vendor outcomes. The preflight probes every vendor so that readiness can
+     * answer for the one actually configured: the Codex leg requires a native Wren
+     * runtime the resolver can trace to the server's own repository, which an
+     * installed package can never satisfy, and a single boolean over both vendors
+     * let that failure take Claude down with it.
+     */
+    readonly vendors: Readonly<Record<NativeVendor, NativeProducerVendorProbe>>;
 }
 /**
  * Exercises the exact, file-only native dispatch boundary against the

package/dist-server/server/native-sessions.js

@@ -7,6 +7,7 @@ import { execFileSync, spawn } from "node:child_process";
 import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { WarbleBinaryNotFoundError } from "../harness/compile/errors.js";
 import { InteractiveLaunchError, NO_INTERACTIVE_TERMINAL_LEASES, interactiveExecutableAvailable } from "./interactive-terminal.js";
 import { newId } from "./db.js";
 import { NATIVE_MCP_CREDENTIAL_ENV_VAR } from "./native-artifacts.js";
@@ -39,11 +40,13 @@ const CODEX_NATIVE_PERMISSION_HEADER = "[permissions.warble_native_wren.filesyst
 const PROVIDER_SESSION_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const CODEX_RESUME_HANDLE_FILE = path.join(".warble", "codex-thread-id");
 function logNativeLaunchFailure(purpose, vendor, phase, error) {
-    const category = error instanceof InteractiveLaunchError ? "rejected" : "unexpected";
-    // Keep the precise boundary server-side without logging exception text,
-    // paths, credentials, argv, or other launch material. Browser/API callers
-    // continue through nativeSessionLaunchFailure's closed public projection.
-    console.error(`[native-sessions] launch failed purpose=${purpose} vendor=${vendor} phase=${phase} category=${category}`);
+    const rejected = error instanceof InteractiveLaunchError;
+    // Exception text, paths, credentials and argv stay out of the log for an
+    // unexpected error, which may carry any of them. A rejection carries a
+    // sentence authored here, and suppressing that turned every diagnosis into a
+    // guess: an operator saw a phase and a category and no cause.
+    const detail = rejected ? ` reason=${error.message}` : "";
+    console.error(`[native-sessions] launch failed purpose=${purpose} vendor=${vendor} phase=${phase} category=${rejected ? "rejected" : "unexpected"}${detail}`);
 }
 /**
  * The producer deliberately sees only a sealed binding identity, never a caller-supplied path.
@@ -310,6 +313,24 @@ function configuredIrPath(irPath) {
         return false;
     }
 }
+/**
+ * Why a vendor's preflight rejected the producer. Each is a fixed sentence
+ * chosen here — none is built from a path, a command, or process output — so
+ * `nativeSessionLaunchFailure` may pass them through unchanged.
+ */
+const NATIVE_PRODUCER_REASONS = new Set([
+    "the Warble binary could not be resolved",
+    "the Warble binary could not be identified",
+    "the Warble binary could not be started",
+    "the Warble binary did not respond",
+    "the Warble binary rejected the dispatch probe",
+    "the Warble binary does not support the native session flags this build requires",
+    "the Warble binary could not be started for this vendor",
+    "the Warble binary did not respond for this vendor",
+    "Warble could not dispatch this profile for this vendor",
+    "Warble emitted a launch spec this build cannot run",
+    "the preflight could not create its temporary workspace",
+]);
 /** A deliberately small public classification; never expose process or filesystem detail. */
 export function nativeSessionLaunchFailure(error) {
     const message = error instanceof Error ? error.message : "";
@@ -319,14 +340,31 @@ export function nativeSessionLaunchFailure(error) {
         return message;
     if (message === "native session materialization prerequisites are unavailable")
         return message;
-    if (message === "native Wren runtime is unavailable")
-        return "native session materialization prerequisites are unavailable";
+    // Every NativeWrenRuntimeError message is `native Wren runtime is unavailable: `
+    // followed by one of that resolver's fixed literals; not one of them
+    // interpolates a path or process output, so the whole family may pass through.
+    // Matching the bare sentence, as this did, stopped matching anything once the
+    // resolver started naming which link in the chain broke.
+    if (message.startsWith("native Wren runtime is unavailable"))
+        return message;
+    if (NATIVE_PRODUCER_REASONS.has(message))
+        return message;
     if (message === "native session producer is incompatible")
         return message;
     if (message === "native session launch artifacts are unavailable" || message === "native session launch specification is invalid" || message === "native session launch specification is incompatible")
         return "native session launch artifacts are unavailable";
     if (message === "native session launch paths are unavailable" || message === "native session launch paths are outside its server-owned scope")
         return "native session launch artifacts are unavailable";
+    // Every InteractiveLaunchError message is authored in this file: a fixed
+    // sentence, a fixed profile name, or a reason readiness already publishes.
+    // None is built from a path, argv, or process output. Falling through to the
+    // generic string threw away the cause of eighteen distinct failures, which is
+    // what left "native session launch failed" as the only thing a user could see.
+    if (error instanceof InteractiveLaunchError)
+        return message;
+    // This one is NOT safe to forward: its text embeds the configured binary path.
+    if (error instanceof WarbleBinaryNotFoundError)
+        return "the Warble binary could not be resolved";
     return "native session launch failed";
 }
 const NATIVE_PRODUCER_CATEGORY = "native_session_producer_incompatible";
@@ -348,12 +386,25 @@ const NATIVE_HELP_MARKERS = [
     "--native-mcp",
     "--out",
 ];
-function nativeProducerResult(available, identity, phase, detail, producer) {
+function producerDiagnostic(identity, phase, detail) {
+    return `identity=${identity ?? "unavailable"} phase=${phase} ${detail}`;
+}
+/** A failure before any vendor-specific work rules out every vendor, for the same reason. */
+function everyVendorUnavailable(probe) {
+    const vendors = {};
+    for (const vendor of NATIVE_PROBE_TARGETS)
+        vendors[vendor] = probe;
+    return vendors;
+}
+/** A shared-phase outcome: it decided nothing vendor-specific, so it speaks for all of them. */
+function nativeProducerResult(available, identity, phase, detail, reason, producer) {
+    const diagnostic = producerDiagnostic(identity, phase, detail);
     return {
         available,
         ...(available ? {} : { category: NATIVE_PRODUCER_CATEGORY }),
-        ...(available && producer ? { producer } : {}),
-        diagnostic: `identity=${identity ?? "unavailable"} phase=${phase} ${detail}`,
+        ...(producer ? { producer } : {}),
+        diagnostic,
+        vendors: everyVendorUnavailable(available ? { available: true, diagnostic } : { available: false, reason, diagnostic }),
     };
 }
 function executableIdentity(executable) {
@@ -439,26 +490,34 @@ function runNativeProbe(command, args) {
 export async function probeNativeSessionProducer(input) {
     const executable = localExecutablePath(input.warbleBin);
     if (!executable)
-        return nativeProducerResult(false, undefined, "resolve", "result=binary_not_found");
+        return nativeProducerResult(false, undefined, "resolve", "result=binary_not_found", "the Warble binary could not be resolved");
     const identity = executableIdentity(executable);
     if (!identity)
-        return nativeProducerResult(false, undefined, "identity", "result=identity_unavailable");
+        return nativeProducerResult(false, undefined, "identity", "result=identity_unavailable", "the Warble binary could not be identified");
     const producer = { executable, identity };
     const help = await runNativeProbe(executable, ["dispatch", "--help"]);
     if (help.spawnFailed)
-        return nativeProducerResult(false, identity, "dispatch_help", "result=spawn_failed");
+        return nativeProducerResult(false, identity, "dispatch_help", "result=spawn_failed", "the Warble binary could not be started");
     if (help.timedOut)
-        return nativeProducerResult(false, identity, "dispatch_help", "result=timed_out");
+        return nativeProducerResult(false, identity, "dispatch_help", "result=timed_out", "the Warble binary did not respond");
     if (help.exitCode !== 0)
-        return nativeProducerResult(false, identity, "dispatch_help", `result=exit_code_${help.exitCode ?? "signal"}`);
+        return nativeProducerResult(false, identity, "dispatch_help", `result=exit_code_${help.exitCode ?? "signal"}`, "the Warble binary rejected the dispatch probe");
     const missingMarkers = NATIVE_HELP_MARKERS.filter((marker) => !help.output.includes(marker));
     if (missingMarkers.length > 0)
-        return nativeProducerResult(false, identity, "dispatch_help", `result=missing_markers_${missingMarkers.join(",")}`);
-    for (const purpose of NATIVE_PURPOSES) {
-        const irPath = input.irPaths[purpose];
-        if (!irPath || !configuredIrPath(irPath))
-            continue;
-        for (const vendor of NATIVE_PROBE_TARGETS) {
+        return nativeProducerResult(false, identity, "dispatch_help", `result=missing_markers_${missingMarkers.join(",")}`, "the Warble binary does not support the native session flags this build requires");
+    // Vendor is the outer loop on purpose. It used to be the inner one, and the
+    // first failing pair returned for the whole preflight — so a Codex rejection
+    // reported the producer incompatible even for a Claude-only install, which is
+    // exactly what an installed package produces.
+    const vendors = {};
+    for (const vendor of NATIVE_PROBE_TARGETS) {
+        let outcome = { available: true, diagnostic: producerDiagnostic(identity, `complete_${vendor}`, "result=compatible") };
+        for (const purpose of NATIVE_PURPOSES) {
+            const irPath = input.irPaths[purpose];
+            if (!irPath || !configuredIrPath(irPath))
+                continue;
+            const phase = `dispatch_${purpose}_${vendor}`;
+            const fail = (detail, reason) => ({ available: false, reason, diagnostic: producerDiagnostic(identity, phase, detail) });
             let root;
             try {
                 root = mkdtempSync(path.join(os.tmpdir(), "genbi-native-preflight-"));
@@ -478,32 +537,54 @@ export async function probeNativeSessionProducer(input) {
                 writeFileSync(scopePath, JSON.stringify({ version: "3", kind: NATIVE_DISPATCH_REGISTRY[purpose].scopeKind, scope_id: scopeId, cwd: outputRoot, entry: nativeEntryFor(purpose, vendor), ...(purpose === "setup" ? { bootstrap_root: bootstrapRoot } : {}), ...(wrenRuntime ? { wren_runtime: wrenRuntime } : {}), ...(binding ? { binding } : {}) }), { encoding: "utf8", mode: 0o600, flag: "wx" });
                 writeFileSync(mcpPath, JSON.stringify({ version: "1", url: "http://127.0.0.1:0/api/native-sessions/mcp", credential: "native-preflight-nonsecret" }), { encoding: "utf8", mode: 0o600, flag: "wx" });
                 const dispatched = await runNativeProbe(executable, ["dispatch", irPath, "--target", targetForProvider(vendor), "--purpose", purpose, "--native-scope", scopePath, "--native-mcp", mcpPath, "--out", outputRoot]);
-                const phase = `dispatch_${purpose}_${vendor}`;
-                if (dispatched.spawnFailed)
-                    return nativeProducerResult(false, identity, phase, "result=spawn_failed");
-                if (dispatched.timedOut)
-                    return nativeProducerResult(false, identity, phase, "result=timed_out");
-                if (dispatched.exitCode !== 0)
-                    return nativeProducerResult(false, identity, phase, `result=exit_code_${dispatched.exitCode ?? "signal"}`);
+                if (dispatched.spawnFailed) {
+                    outcome = fail("result=spawn_failed", "the Warble binary could not be started for this vendor");
+                    break;
+                }
+                if (dispatched.timedOut) {
+                    outcome = fail("result=timed_out", "the Warble binary did not respond for this vendor");
+                    break;
+                }
+                if (dispatched.exitCode !== 0) {
+                    outcome = fail(`result=exit_code_${dispatched.exitCode ?? "signal"}`, "Warble could not dispatch this profile for this vendor");
+                    break;
+                }
                 try {
                     readNativeLaunchSpec(outputRoot, purpose, vendor, scopeId, undefined, { version: "1", url: "http://127.0.0.1:0/api/native-sessions/mcp", credential: "native-preflight-nonsecret" });
                 }
                 catch {
-                    return nativeProducerResult(false, identity, phase, "result=launch_spec_incompatible");
+                    outcome = fail("result=launch_spec_incompatible", "Warble emitted a launch spec this build cannot run");
+                    break;
                 }
             }
             catch (error) {
-                if (error instanceof NativeWrenRuntimeError)
-                    return nativeProducerResult(false, identity, `dispatch_${purpose}_${vendor}`, `result=wren_runtime_unavailable (${error.message})`);
-                return nativeProducerResult(false, identity, `dispatch_${purpose}_${vendor}`, "result=preflight_workspace_unavailable");
+                outcome = error instanceof NativeWrenRuntimeError
+                    ? fail(`result=wren_runtime_unavailable (${error.message})`, error.message)
+                    : fail("result=preflight_workspace_unavailable", "the preflight could not create its temporary workspace");
+                break;
             }
             finally {
                 if (root)
                     rmSync(root, { recursive: true, force: true });
             }
         }
-    }
-    return nativeProducerResult(true, identity, "complete", "result=compatible", producer);
+        vendors[vendor] = outcome;
+    }
+    const usable = NATIVE_PROBE_TARGETS.filter((vendor) => vendors[vendor].available);
+    const available = usable.length > 0;
+    // When nothing is usable the summary must still carry each vendor's own cause;
+    // collapsing them to "no_compatible_vendor" would lose the only line that says
+    // what actually broke.
+    const vendorResults = NATIVE_PROBE_TARGETS
+        .map((vendor) => `${vendor}=${vendors[vendor].diagnostic.split(" result=")[1] ?? "unknown"}`)
+        .join(" ");
+    return {
+        available,
+        ...(available ? {} : { category: NATIVE_PRODUCER_CATEGORY }),
+        producer,
+        diagnostic: producerDiagnostic(identity, "complete", available ? `result=compatible_${usable.join("+")}` : `result=no_compatible_vendor ${vendorResults}`),
+        vendors,
+    };
 }
 function parseNativeSetupRecoveryReport(value) {
     const report = record(value);
@@ -1139,6 +1220,10 @@ export class NativeSessionService {
                 ? nativeSessionStateBaseAvailableForProject(this.materializationState(), configuredRoot)
                 : purpose === "setup" && projectAvailable && nativeSessionStateBaseAvailable(this.materializationState());
             const workspaceUnavailable = !projectAvailable || !stateAvailable;
+            // Only the configured vendor's own probe may block this purpose. Probing
+            // both and collapsing them into one boolean let an unselected vendor veto
+            // the selected one.
+            const selectedProducer = producer && dispatch ? producer.vendors[dispatch.provider] : undefined;
             const reason = runtimeCorrection
                 ?? (!dispatch && !legacyFixture
                     ? "native sessions require a saved Runtime & authentication binding"
@@ -1146,8 +1231,8 @@ export class NativeSessionService {
                         ? purpose === "setup" ? "native setup sessions require a workspace root" : "native sessions require a current bound project"
                         : workspaceUnavailable
                             ? "native session workspace is unavailable"
-                            : producer && !producer.available
-                                ? "native session producer is incompatible"
+                            : selectedProducer && !selectedProducer.available
+                                ? selectedProducer.reason ?? "native session producer is incompatible"
                                 : !irPath || !(this.options.dispatch !== undefined || configuredIrPath(irPath)) || !legacyProducerAvailable()
                                     ? "native session materialization prerequisites are unavailable"
                                     : mcpReadiness && !mcpReadiness.available
@@ -1160,6 +1245,17 @@ export class NativeSessionService {
                     ? `the ${executable} interactive CLI is not available on this machine`
                     : undefined);
             const vendorReadiness = {};
+            // Production readiness now reports every vendor, so the UI can say which
+            // one is unusable and why instead of only that "the producer" is.
+            if (!legacyFixture && producer)
+                for (const vendor of NATIVE_VENDORS) {
+                    const probe = producer.vendors[vendor];
+                    vendorReadiness[vendor] = probe?.available === false
+                        ? { available: false, reason: probe.reason ?? "native session producer is incompatible" }
+                        : !executableAvailable(vendor)
+                            ? { available: false, reason: `the ${vendor === "claude" ? "claude" : "codex"} interactive CLI is not available on this machine` }
+                            : { available: true };
+                }
             if (legacyFixture)
                 for (const vendor of NATIVE_VENDORS) {
                     const legacyExecutable = vendor === "claude" ? "claude" : "codex";
@@ -1174,7 +1270,16 @@ export class NativeSessionService {
                 scopeKind,
                 profile: definition.profile,
                 ...(dispatch ? { target: dispatch.target, targetLabel: dispatch.targetLabel } : {}),
-                ...(producer ? { producer: producer.available ? { available: true } : { available: false, category: NATIVE_PRODUCER_CATEGORY } } : {}),
+                // With a vendor selected this answers for that vendor; with none selected
+                // it falls back to "is any vendor usable", rather than claiming health
+                // no vendor could back.
+                ...(producer
+                    ? {
+                        producer: (selectedProducer ? selectedProducer.available : producer.available)
+                            ? { available: true, diagnostic: (selectedProducer ?? producer).diagnostic }
+                            : { available: false, category: NATIVE_PRODUCER_CATEGORY, diagnostic: (selectedProducer ?? producer).diagnostic },
+                    }
+                    : {}),
                 available: legacyAvailable,
                 ...(unavailable ? { reason: unavailable } : {}),
                 vendors: vendorReadiness,
@@ -1218,12 +1323,25 @@ export class NativeSessionService {
         // Compile for this binding rather than dispatching the profile's golden.
         // Falls back to the configured path only where no resolver is wired (the
         // fixture-mode tests), never silently in production — see `bin.ts`.
-        const irPath = this.options.resolveDispatchIr === undefined
-            ? configuredIr
-            : await this.options.resolveDispatchIr(purpose, binding);
+        // Compiling for this binding runs before the launch try/catch below, so a
+        // failure here reached the HTTP route unlogged and unclassified — the case
+        // where the server printed nothing at all and the browser said only "native
+        // session launch failed".
+        let irPath;
+        try {
+            irPath = this.options.resolveDispatchIr === undefined
+                ? configuredIr
+                : await this.options.resolveDispatchIr(purpose, binding);
+        }
+        catch (error) {
+            logNativeLaunchFailure(purpose, dispatchDefinition.provider, "dispatch_ir", error);
+            throw error;
+        }
         const producer = this.legacyFixtureMode() ? undefined : await this.productionProducerPreflight();
-        if (producer && (!producer.available || !producer.producer))
-            throw new InteractiveLaunchError("native session producer is incompatible");
+        const launchProducer = producer ? producer.vendors[dispatchDefinition.provider] : undefined;
+        if (producer && (!launchProducer?.available || !producer.producer)) {
+            throw new InteractiveLaunchError(launchProducer?.reason ?? "native session producer is incompatible");
+        }
         if (producer?.producer)
             assertNativeProducerIdentity(producer.producer);
         const scopeId = resumed?.row.scopeId ?? newId("native-scope");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrenai/genbi",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Wren GenBI — the web UI for WrenAI: ask questions of your data and get dashboards back",
   "license": "Apache-2.0",
   "keywords": [