@gaia-ai/ui 0.7.0 → 0.9.0

package/dist/src/bun-runtime.d.ts

@@ -0,0 +1,84 @@
+/**
+ * GAIA-326 — `@opentui/core` reaches its Zig core through FFI, which Node does
+ * not expose before 26.1 (and then only behind `--experimental-ffi`). So the
+ * cockpit runs under the `bun` that `@gaia-ai/addon-gaia-ui` installs.
+ *
+ * `process.versions.bun` is the loop guard: it is defined under Bun and nowhere
+ * else, so a re-exec can never recurse and no sentinel variable is introduced.
+ * `--print-config` deliberately stays on Node — it is what a human runs when the
+ * cockpit will not start, and a diagnostic that needs the thing it diagnoses is
+ * worth nothing.
+ *
+ * `injectedRenderer` is the same argument one step further: the runtime is
+ * needed by the DYNAMICALLY-resolved `@gaia-ai/addon-gaia-ui`, so a caller that
+ * supplies its own `runUi` never reaches OpenTUI and must not be re-execed.
+ */
+export declare function shouldReExecUnderBun(input: {
+    bunVersion?: string | undefined;
+    noBun?: string | undefined;
+    printConfig: boolean;
+    injectedRenderer?: boolean | undefined;
+}): boolean;
+/**
+ * Resolve the `bun` executable from the renderer addon's own base — the same
+ * dynamic seam `loadGaiaUiModule` resolves the renderer through, so the one
+ * dynamic edge in this package stays one edge.
+ *
+ * The manifest is read with a plain `readFileSync` rather than through the
+ * resolver: `createRequire(...).resolve()` gives an absolute path, and reading a
+ * known path needs no module system. `bun`'s manifest is resolved by name
+ * (`bun/package.json`) because the launcher's location is the thing we are
+ * looking up; its `bin` entry is a relative path from the manifest's directory.
+ */
+export declare function resolveBunBinary(bases: string[]): string | undefined;
+export type LibcFamily = 'glibc' | 'musl' | 'unknown';
+/**
+ * GAIA-326 (A1) — which C library is this host running?
+ *
+ * Two evidence sources, cheapest first, both injected so the answer never
+ * depends on the machine the test runs on:
+ *
+ *  - `/proc/self/maps` (~0.1 ms) names the interpreter the kernel ACTUALLY
+ *    mapped into this process. That is the strongest signal available: a glibc
+ *    box with a musl-compat package installed has `/lib/ld-musl-x86_64.so.1` on
+ *    disk but never maps it, so the `existsSync` shortcut would misread it.
+ *  - the node report's `header.glibcVersionRuntime` (~4.6 ms) — present on
+ *    glibc, absent on musl. It needs no filesystem, which is why it is the
+ *    fallback for a container that hides `/proc`. Verified on all four
+ *    combinations: node+glibc `"2.43"`, bun+glibc `"2.43"`, node+musl absent,
+ *    bun+musl absent (node:22-alpine).
+ *
+ * Non-Linux returns `unknown` and NOT `musl`: the report header omits
+ * `glibcVersionRuntime` on macOS and Windows too, so reading its absence as
+ * musl would mislabel every mac. musl is a Linux question.
+ *
+ * Inconclusive is `unknown`, and `unknown` changes nothing — glibc is upstream's
+ * default and the overwhelmingly common case, so a failed probe must degrade to
+ * today's behaviour rather than to a guess.
+ */
+export declare function detectLibcFamily(probe: {
+    platform: string;
+    readProcSelfMaps: () => string | undefined;
+    readReportLibc: () => LibcFamily;
+}): LibcFamily;
+/** The real probe. Every leg is wrapped: an inconclusive read must not throw. */
+export declare function nodeLibcFamily(): LibcFamily;
+/**
+ * GAIA-326 (A1) — make the cockpit start on musl with no manual step.
+ *
+ * `@opentui/core@0.5.1` selects its native platform package from
+ * `process.env.OPENTUI_LIBC` and DEFAULTS TO GLIBC — it runs no probe of its
+ * own. Both prebuilts are always on disk (npm and pnpm filter optional deps by
+ * `os`/`cpu`, never by libc), so on Alpine the wrong one loads and the first
+ * frame dies with `Error loading shared library ld-linux-x86-64.so.2 (needed by
+ * libopentui.so)`. Requiring the user to export the variable IS a manual step,
+ * so A1 is only met once we set it.
+ *
+ * An explicit value always wins: an operator who exports `OPENTUI_LIBC=glibc`
+ * on a musl box is doing something deliberate, and a probe must not overrule
+ * them. Because a set value short-circuits BEFORE `detect` is called, the Bun
+ * child — which inherits this env — never pays for the probe a second time.
+ */
+export declare function applyOpentuiLibc(env: NodeJS.ProcessEnv, detect?: () => LibcFamily): void;
+/** Replace this process with the same command under Bun. Never returns. */
+export declare function reExecUnderBun(bin: string, argv: string[]): never;

package/dist/src/bun-runtime.js

@@ -0,0 +1,149 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+/**
+ * GAIA-326 — `@opentui/core` reaches its Zig core through FFI, which Node does
+ * not expose before 26.1 (and then only behind `--experimental-ffi`). So the
+ * cockpit runs under the `bun` that `@gaia-ai/addon-gaia-ui` installs.
+ *
+ * `process.versions.bun` is the loop guard: it is defined under Bun and nowhere
+ * else, so a re-exec can never recurse and no sentinel variable is introduced.
+ * `--print-config` deliberately stays on Node — it is what a human runs when the
+ * cockpit will not start, and a diagnostic that needs the thing it diagnoses is
+ * worth nothing.
+ *
+ * `injectedRenderer` is the same argument one step further: the runtime is
+ * needed by the DYNAMICALLY-resolved `@gaia-ai/addon-gaia-ui`, so a caller that
+ * supplies its own `runUi` never reaches OpenTUI and must not be re-execed.
+ */
+export function shouldReExecUnderBun(input) {
+    if (input.printConfig)
+        return false;
+    if (input.injectedRenderer)
+        return false;
+    if (input.bunVersion !== undefined)
+        return false;
+    if (input.noBun !== undefined && input.noBun !== '')
+        return false;
+    return true;
+}
+/**
+ * Resolve the `bun` executable from the renderer addon's own base — the same
+ * dynamic seam `loadGaiaUiModule` resolves the renderer through, so the one
+ * dynamic edge in this package stays one edge.
+ *
+ * The manifest is read with a plain `readFileSync` rather than through the
+ * resolver: `createRequire(...).resolve()` gives an absolute path, and reading a
+ * known path needs no module system. `bun`'s manifest is resolved by name
+ * (`bun/package.json`) because the launcher's location is the thing we are
+ * looking up; its `bin` entry is a relative path from the manifest's directory.
+ */
+export function resolveBunBinary(bases) {
+    for (const base of bases) {
+        try {
+            const addon = createRequire(base).resolve('@gaia-ai/addon-gaia-ui');
+            const manifest = createRequire(addon).resolve('bun/package.json');
+            const { bin } = JSON.parse(readFileSync(manifest, 'utf8'));
+            const relative = typeof bin === 'string' ? bin : bin?.bun;
+            if (relative)
+                return join(dirname(manifest), relative);
+        }
+        catch {
+            // try the next base
+        }
+    }
+    return undefined;
+}
+/**
+ * The dynamic linker musl installs. Matched as a path segment ending in `.so`
+ * rather than a bare `includes('ld-musl')`, so an unrelated mapped file whose
+ * NAME happens to carry the string cannot be mistaken for the interpreter.
+ */
+const MUSL_INTERPRETER = /\/ld-musl-[^/\s]*\.so/;
+/**
+ * GAIA-326 (A1) — which C library is this host running?
+ *
+ * Two evidence sources, cheapest first, both injected so the answer never
+ * depends on the machine the test runs on:
+ *
+ *  - `/proc/self/maps` (~0.1 ms) names the interpreter the kernel ACTUALLY
+ *    mapped into this process. That is the strongest signal available: a glibc
+ *    box with a musl-compat package installed has `/lib/ld-musl-x86_64.so.1` on
+ *    disk but never maps it, so the `existsSync` shortcut would misread it.
+ *  - the node report's `header.glibcVersionRuntime` (~4.6 ms) — present on
+ *    glibc, absent on musl. It needs no filesystem, which is why it is the
+ *    fallback for a container that hides `/proc`. Verified on all four
+ *    combinations: node+glibc `"2.43"`, bun+glibc `"2.43"`, node+musl absent,
+ *    bun+musl absent (node:22-alpine).
+ *
+ * Non-Linux returns `unknown` and NOT `musl`: the report header omits
+ * `glibcVersionRuntime` on macOS and Windows too, so reading its absence as
+ * musl would mislabel every mac. musl is a Linux question.
+ *
+ * Inconclusive is `unknown`, and `unknown` changes nothing — glibc is upstream's
+ * default and the overwhelmingly common case, so a failed probe must degrade to
+ * today's behaviour rather than to a guess.
+ */
+export function detectLibcFamily(probe) {
+    if (probe.platform !== 'linux')
+        return 'unknown';
+    const maps = probe.readProcSelfMaps();
+    if (maps !== undefined)
+        return MUSL_INTERPRETER.test(maps) ? 'musl' : 'glibc';
+    return probe.readReportLibc();
+}
+/** The real probe. Every leg is wrapped: an inconclusive read must not throw. */
+export function nodeLibcFamily() {
+    return detectLibcFamily({
+        platform: process.platform,
+        readProcSelfMaps: () => {
+            try {
+                return readFileSync('/proc/self/maps', 'utf8');
+            }
+            catch {
+                return undefined;
+            }
+        },
+        readReportLibc: () => {
+            try {
+                const report = process.report.getReport();
+                return report.header?.glibcVersionRuntime ? 'glibc' : 'musl';
+            }
+            catch {
+                return 'unknown';
+            }
+        },
+    });
+}
+/**
+ * GAIA-326 (A1) — make the cockpit start on musl with no manual step.
+ *
+ * `@opentui/core@0.5.1` selects its native platform package from
+ * `process.env.OPENTUI_LIBC` and DEFAULTS TO GLIBC — it runs no probe of its
+ * own. Both prebuilts are always on disk (npm and pnpm filter optional deps by
+ * `os`/`cpu`, never by libc), so on Alpine the wrong one loads and the first
+ * frame dies with `Error loading shared library ld-linux-x86-64.so.2 (needed by
+ * libopentui.so)`. Requiring the user to export the variable IS a manual step,
+ * so A1 is only met once we set it.
+ *
+ * An explicit value always wins: an operator who exports `OPENTUI_LIBC=glibc`
+ * on a musl box is doing something deliberate, and a probe must not overrule
+ * them. Because a set value short-circuits BEFORE `detect` is called, the Bun
+ * child — which inherits this env — never pays for the probe a second time.
+ */
+export function applyOpentuiLibc(env, detect = nodeLibcFamily) {
+    const current = env.OPENTUI_LIBC;
+    if (current !== undefined && current !== '')
+        return;
+    if (detect() === 'musl')
+        env.OPENTUI_LIBC = 'musl';
+}
+/** Replace this process with the same command under Bun. Never returns. */
+export function reExecUnderBun(bin, argv) {
+    const result = spawnSync(bin, argv.slice(1), {
+        stdio: 'inherit',
+        env: process.env,
+    });
+    process.exit(result.status ?? 1);
+}

package/dist/src/index.d.ts

@@ -1,3 +1,3 @@
 export { type HereContext, isTicketIdentifier, isUuid, normalizeRepoUrl, type ParsedTarget, parseTarget, parseTicketIdentifierFromBranch, resolveHere, type TargetInputs, UI_VIEW_MODES, type UiInitialRoute, type UiViewMode, } from './route.js';
 export { cmdUi, default, type RunGaiaUiOptions, type UiDeps } from './ui.js';
-export { type HomeConnection, type ProjectRooting, resolveAgentCommand, resolveDefaultProject, resolveProjectRooting, } from './ui-home.js';
+export { type HomeConnection, type ProjectRooting, resolveAgentCommand, resolveProjectRooting, } from './ui-home.js';

package/dist/src/index.js

@@ -7,4 +7,4 @@
 // GAIA-223: the deep-link grammar (the pure CLI seam).
 export { isTicketIdentifier, isUuid, normalizeRepoUrl, parseTarget, parseTicketIdentifierFromBranch, resolveHere, UI_VIEW_MODES, } from './route.js';
 export { cmdUi, default } from './ui.js';
-export { resolveAgentCommand, resolveDefaultProject, resolveProjectRooting, } from './ui-home.js';
+export { resolveAgentCommand, resolveProjectRooting, } from './ui-home.js';

package/dist/src/ui-home.d.ts

@@ -1,4 +1,4 @@
-import { type ConductorRegistryEntry, type MachineContext } from '@gaia-ai/core';
+import { type MachineContext } from '@gaia-ai/core';
 /**
  * The resolved control-plane connection passed to the renderer launcher.
  * A structural mirror of `@gaia-ai/addon-gaia-ui`'s `HomeConnection` — kept
@@ -20,12 +20,6 @@ export interface HomeConnection {
      */
     writeProfile?: string | undefined;
 }
-/**
- * Resolve the default project (opaque group) from the conductor registry: the
- * `preferred` project when it is registered, else the first entry's project.
- * `undefined` when the registry is empty — a valid empty cockpit.
- */
-export declare function resolveDefaultProject(entries: ConductorRegistryEntry[], preferred?: string): string | undefined;
 /**
  * Resolve the agent-launch command builder from the home config. Turns a TUI
  * prompt into the shell command herdr runs. Defaults to `claude` (an empty
@@ -38,11 +32,18 @@ export declare function resolveAgentCommand(machine: Partial<MachineContext> & {
 /** Where `gaia ui` roots the agents it launches, and which project they belong to. */
 export interface ProjectRooting {
     cwd: string;
-    project?: string | undefined;
-    ownConductorMachineId?: string | undefined;
+    /**
+     * The `.gaia` dir of the project we are standing in, when there is one.
+     *
+     * The ui hands this over rather than a resolved project name: matching it
+     * against a conductor's `workspace_root` needs the control plane, and the
+     * client that reaches it first exists in the renderer (GAIA-232). Undefined
+     * outside any project.
+     */
+    gaiaDir?: string | undefined;
 }
 /**
- * Decide the agents' working directory + project (GAIA-219 AC-9).
+ * Decide the agents' working directory (GAIA-219 AC-9).
  *
  * The trigger is the **cwd**, deliberately not the winning connection config:
  * "which connection did we resolve" and "which project am I standing in" are
@@ -50,17 +51,22 @@ export interface ProjectRooting {
  * silently relocate the agents' working directory.
  *
  * Standing **in** a project (core's walk-up finds a `.gaia/` project dir that
- * is not the user's own `~/.gaia`), the cwd is that repo's **root** and the
- * matching registry entry supplies the project + machine id; a project with no
- * registry entry still roots at its repo root. Otherwise the registry default
- * applies verbatim, exactly as before this ticket.
+ * is not the user's own `~/.gaia`), the cwd is that repo's **root**. Otherwise
+ * the agents root at the home dir and the cockpit opens with no default group —
+ * an honest empty cockpit rather than a guess.
+ *
+ * The project name and this machine's conductor id used to come from a local
+ * registry file, which GAIA-232 deleted. Both now resolve in the renderer's
+ * `run()` — `Entity/conductor/Data/own-conductor.ts`, reached through the
+ * launcher's `gaiaDir` — from the conductor record whose `workspace_root`
+ * equals this dir: the same data, from the store that also knows whether the
+ * conductor is alive, and matched by the same exact normalised path comparison
+ * the registry lookup used.
  *
  * The marker is core's `findProjectGaiaDir` — "is there a `.gaia/` here" —
  * NOT the connection walk-up `findGaiaConfig`. Since GAIA-230 the latter skips
  * an engine-only `conductor.config.js`, which GAIA-218 makes the canonical repo
- * shape, so keying on it would leave the most common project rooted in the
- * registry default. Which connection won and which project we stand in stay two
- * separate questions, as this function's whole point requires.
+ * shape, so keying on it would leave the most common project rooted at home.
  *
  * `~/.gaia` is excluded for the same reason core labels it `home`: the walk-up
  * reaches it from every directory under `$HOME`, so counting it would make
@@ -69,4 +75,4 @@ export interface ProjectRooting {
  * Pure with respect to precedence — the walk-up is core's; this helper owns no
  * filesystem probe of its own.
  */
-export declare function resolveProjectRooting(cwd: string, entries: ConductorRegistryEntry[], homeDir: string): ProjectRooting;
+export declare function resolveProjectRooting(cwd: string, homeDir: string): ProjectRooting;

package/dist/src/ui-home.js

@@ -5,17 +5,6 @@
 // holds no connection-precedence rule of its own (AC-6).
 import { dirname, resolve } from 'node:path';
 import { findProjectGaiaDir, homeGaiaDir, shellQuote, } from '@gaia-ai/core';
-/**
- * Resolve the default project (opaque group) from the conductor registry: the
- * `preferred` project when it is registered, else the first entry's project.
- * `undefined` when the registry is empty — a valid empty cockpit.
- */
-export function resolveDefaultProject(entries, preferred) {
-    if (preferred && entries.some((e) => e.project === preferred)) {
-        return preferred;
-    }
-    return entries[0]?.project;
-}
 /**
  * Resolve the agent-launch command builder from the home config. Turns a TUI
  * prompt into the shell command herdr runs. Defaults to `claude` (an empty
@@ -27,7 +16,7 @@ export function resolveAgentCommand(machine) {
     return (prompt) => prompt.trim() === '' ? bin : `${bin} ${shellQuote(prompt)}`;
 }
 /**
- * Decide the agents' working directory + project (GAIA-219 AC-9).
+ * Decide the agents' working directory (GAIA-219 AC-9).
  *
  * The trigger is the **cwd**, deliberately not the winning connection config:
  * "which connection did we resolve" and "which project am I standing in" are
@@ -35,17 +24,22 @@ export function resolveAgentCommand(machine) {
  * silently relocate the agents' working directory.
  *
  * Standing **in** a project (core's walk-up finds a `.gaia/` project dir that
- * is not the user's own `~/.gaia`), the cwd is that repo's **root** and the
- * matching registry entry supplies the project + machine id; a project with no
- * registry entry still roots at its repo root. Otherwise the registry default
- * applies verbatim, exactly as before this ticket.
+ * is not the user's own `~/.gaia`), the cwd is that repo's **root**. Otherwise
+ * the agents root at the home dir and the cockpit opens with no default group —
+ * an honest empty cockpit rather than a guess.
+ *
+ * The project name and this machine's conductor id used to come from a local
+ * registry file, which GAIA-232 deleted. Both now resolve in the renderer's
+ * `run()` — `Entity/conductor/Data/own-conductor.ts`, reached through the
+ * launcher's `gaiaDir` — from the conductor record whose `workspace_root`
+ * equals this dir: the same data, from the store that also knows whether the
+ * conductor is alive, and matched by the same exact normalised path comparison
+ * the registry lookup used.
  *
  * The marker is core's `findProjectGaiaDir` — "is there a `.gaia/` here" —
  * NOT the connection walk-up `findGaiaConfig`. Since GAIA-230 the latter skips
  * an engine-only `conductor.config.js`, which GAIA-218 makes the canonical repo
- * shape, so keying on it would leave the most common project rooted in the
- * registry default. Which connection won and which project we stand in stay two
- * separate questions, as this function's whole point requires.
+ * shape, so keying on it would leave the most common project rooted at home.
  *
  * `~/.gaia` is excluded for the same reason core labels it `home`: the walk-up
  * reaches it from every directory under `$HOME`, so counting it would make
@@ -54,25 +48,12 @@ export function resolveAgentCommand(machine) {
  * Pure with respect to precedence — the walk-up is core's; this helper owns no
  * filesystem probe of its own.
  */
-export function resolveProjectRooting(cwd, entries, homeDir) {
+export function resolveProjectRooting(cwd, homeDir) {
     const gaiaDir = findProjectGaiaDir(cwd);
     // Core owns where `.gaia` lives; the ui never spells the path itself.
     const homeDotGaia = resolve(homeGaiaDir(homeDir));
     if (gaiaDir !== undefined && resolve(gaiaDir) !== homeDotGaia) {
-        // Registry entries store the `.gaia` dir (the conductor's checkoutRoot),
-        // so that — not the repo root — is what an entry is matched on.
-        const entry = entries.find((e) => resolve(e.path) === resolve(gaiaDir));
-        return {
-            cwd: dirname(gaiaDir),
-            project: entry?.project,
-            ownConductorMachineId: entry?.id,
-        };
+        return { cwd: dirname(gaiaDir), gaiaDir };
     }
-    const project = resolveDefaultProject(entries);
-    const projectEntry = entries.find((e) => e.project === project);
-    return {
-        cwd: projectEntry?.path ?? homeDir,
-        project,
-        ownConductorMachineId: projectEntry?.id,
-    };
+    return { cwd: homeDir };
 }

package/dist/src/ui.d.ts

@@ -1,5 +1,5 @@
 import { type AgentLaunchHost } from '@gaia-ai/addon-herdr';
-import { type ConductorRegistryEntry, type GaiaCommandHost, type GaiaCommandPlugin, type GaiaConnectionConfig, type MachineContext } from '@gaia-ai/core';
+import { type GaiaCommandHost, type GaiaCommandPlugin, type GaiaConnectionConfig, type MachineContext } from '@gaia-ai/core';
 import { type UiInitialRoute } from './route.js';
 import { type HomeConnection } from './ui-home.js';
 /** Prompt-level agent service the renderer consumes (mirror of gaia-ui's `TuiAgentService`). */
@@ -38,7 +38,15 @@ export interface RunGaiaUiOptions {
     project?: string | undefined;
     agents?: TuiAgentService | undefined;
     currentUser?: string | undefined;
-    ownConductorMachineId?: string | undefined;
+    /**
+     * The `.gaia` dir of the project the ui was started in, when there is one.
+     *
+     * Replaces the `ownConductorMachineId` the local registry used to supply
+     * (GAIA-232): the renderer matches this against each conductor's
+     * `workspace_root` to find which record is this machine's own — it holds the
+     * JSON:API client, and this entry does not.
+     */
+    gaiaDir?: string | undefined;
     createPrompt?: string | undefined;
     buildProgram: (opts: {
         plugins: unknown[];
@@ -62,8 +70,6 @@ export interface BuildWriteClientOptions {
 export interface UiDeps {
     /** Machine context (identity + connection); default: read from disk. */
     machine?: Partial<MachineContext>;
-    /** Conductor registry entries; default: `listRegisteredConductors()`. */
-    registryEntries?: ConductorRegistryEntry[];
     /** herdr-backed agent host; default: `herdrAgentHost(exec herdr)`. */
     agentHost?: AgentLaunchHost;
     /** The renderer launcher; default: the dynamically-resolved `runGaiaUi`. */
@@ -83,6 +89,8 @@ export interface UiDeps {
     printConfig?: boolean;
     /** Sink for `--print-config`; default: `process.stdout.write`. */
     stdout?: (s: string) => void;
+    /** Daily update lookup; injectable for startup ordering tests. */
+    updateCheck?: () => Promise<string | null>;
     /** Positional `[target]` (`GAIA-221`, `ticket:…`, `project:…`, `run:…`). */
     target?: string | undefined;
     /** `--ticket <id>`. */

package/dist/src/ui.js

@@ -2,9 +2,10 @@ import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { herdrAgentHost } from '@gaia-ai/addon-herdr';
-import { CommandRunner, createLogger, exec, listRegisteredConductors, loadGaiaConfig, machineContextPath, readMachineContext, setDefaultCommandRunner, } from '@gaia-ai/core';
+import { CommandRunner, createLogger, exec, fetchUpdateNotice, loadGaiaConfig, machineContextPath, readMachineContext, resolveCliVersion, setDefaultCommandRunner, } from '@gaia-ai/core';
 import { buildProgram as buildDropshProgram, resolveAuth } from 'dropsh';
 import { createHttpClient, createJsonApiClient } from 'dropsh/plugin';
+import { applyOpentuiLibc, reExecUnderBun, resolveBunBinary, shouldReExecUnderBun, } from './bun-runtime.js';
 import { parseTarget, resolveHere, UI_VIEW_MODES, } from './route.js';
 import { resolveAgentCommand, resolveProjectRooting, } from './ui-home.js';
 /** The auth profile `gaia ui` writes as. Reads stay on `session`. */
@@ -57,11 +58,13 @@ async function readCurrentBranch(cwd) {
  * with no `origin`, it yields '' and the ladder produces its named error.
  *
  * Revision 4 replaced the previous rung (an `import()` of the repo's engine
- * `conductor.config.js` plus a conductor-registry longest-prefix fallback) with
- * this one read: the registry cannot answer inside a worktree (its paths point
- * at `.gaia` DIRS, and a worktree has its own unregistered one), the config read
- * needed a dynamic import of a possibly secret-bearing module, and the remote
- * works in a fresh clone that has no `.gaia/` at all.
+ * `conductor.config.js` plus a longest-prefix fallback over the then-still-alive
+ * local conductor registry) with this one read: neither could answer inside a
+ * worktree (both keyed on `.gaia` DIRS, and a worktree has its own), the config
+ * read needed a dynamic import of a possibly secret-bearing module, and the
+ * remote works in a fresh clone that has no `.gaia/` at all. Revision 5 then
+ * deleted that registry outright, which only removes an alternative this rung
+ * had already rejected.
  */
 async function readOriginRemoteUrl(cwd) {
     try {
@@ -90,8 +93,19 @@ function resolveExplicitConfig(flag) {
     }
     return undefined;
 }
-/** The `--print-config` block (AC-7): which file won, and what it points at. */
-function formatConnectionReport(connection, rooting) {
+/**
+ * The `--print-config` block (AC-7): which file won, and what it points at.
+ *
+ * `project` reports the `--project` flag, and `gaia_dir` the project dir the
+ * rooting resolved. GAIA-232 split the two on purpose: the DEFAULT project is no
+ * longer knowable here. It used to be read out of `~/.gaia/conductors.json`,
+ * which this ticket deleted, and its replacement is the conductor record whose
+ * `workspace_root` equals `gaia_dir` — a control-plane read, and this command
+ * holds no JSON:API client (GAIA-223 spec Finding 1). Printing `gaia_dir` is
+ * therefore the honest form: it names the exact input the renderer resolves the
+ * project from, instead of a `project:` line that could only ever say `(none)`.
+ */
+function formatConnectionReport(connection, rooting, project) {
     const yesNo = (b) => (b ? 'yes' : 'no');
     const lines = [
         ['connection', connection.config_path],
@@ -100,7 +114,11 @@ function formatConnectionReport(connection, rooting) {
         ['legacy', yesNo(connection.legacy)],
         ['base_url', connection.site.base_url],
         ['cwd', rooting.cwd],
-        ['project', rooting.project ?? '(none)'],
+        ['gaia_dir', rooting.gaiaDir ?? '(none)'],
+        [
+            'project',
+            project ?? (rooting.gaiaDir ? '(resolved from gaia_dir)' : '(none)'),
+        ],
     ];
     return `${lines.map(([k, v]) => `${`${k}:`.padEnd(12)}${v}`).join('\n')}\n`;
 }
@@ -156,6 +174,38 @@ export async function cmdUi(deps = {}) {
         (deps.stderr ?? ((line) => process.stderr.write(line)))(`${message}\n`);
         process.exitCode = 1;
     };
+    // GAIA-326 (A1) — teach OpenTUI which libc this host runs BEFORE anything
+    // else. It is set on THIS process rather than only on the re-exec's `env`
+    // argument, and that placement is the whole point: `reExecUnderBun` passes
+    // `env: process.env`, so the Bun child inherits it for free, while the three
+    // paths that never re-exec (already under Bun, `$GAIA_UI_NO_BUN` on Node 26 +
+    // --experimental-ffi, an injected `runUi`) load `@opentui/core` in THIS
+    // process and would otherwise get the glibc default on Alpine. `@opentui/core`
+    // reads the variable when it resolves its native asset — strictly later than
+    // here, since the renderer is a dynamic import — so one assignment covers
+    // every path. On glibc it is a no-op.
+    applyOpentuiLibc(process.env);
+    // GAIA-326 — the renderer needs Bun's FFI. Re-exec here rather than in a bin
+    // shim: there are three shims, the host already owns the value-aware argv
+    // pre-scan that says `ui` was invoked, and `--print-config` must keep working
+    // without Bun. This sits after `fail` is declared (the only ordering the
+    // named-error path allows) and still before every config load and the whole
+    // deep-link ladder, so nothing is resolved twice across the two processes.
+    if (shouldReExecUnderBun({
+        bunVersion: process.versions.bun,
+        noBun: process.env.GAIA_UI_NO_BUN,
+        printConfig: Boolean(deps.printConfig),
+        injectedRenderer: deps.runUi !== undefined,
+    })) {
+        const bin = resolveBunBinary(host.resolveBases);
+        if (bin === undefined) {
+            fail('gaia ui: could not resolve the bun runtime. `@gaia-ai/addon-gaia-ui` ' +
+                'depends on it; reinstall, or set $GAIA_UI_NO_BUN=1 to run on Node ' +
+                '26+ with --experimental-ffi.');
+            return;
+        }
+        reExecUnderBun(bin, process.argv);
+    }
     // GAIA-223: build the deep-link route FIRST — argv parsing, the conflict rule
     // and the whole `--here` ladder are offline, so every one of their failures
     // costs no config load and no network round-trip, and never reaches the
@@ -186,9 +236,6 @@ export async function cmdUi(deps = {}) {
         fail(err instanceof Error ? err.message : String(err));
         return;
     }
-    // Read only AFTER the route: the whole grammar + ladder is offline, so a
-    // parse/conflict/no-remote failure must not even touch the registry file.
-    const entries = deps.registryEntries ?? (await listRegisteredConductors());
     const mcPath = machineContextPath();
     // The machine context still supplies identity (`user_id`) + the agent binary;
     // it is NOT the connection any more — core resolves that.
@@ -209,6 +256,14 @@ export async function cmdUi(deps = {}) {
         process.exitCode = 1;
         return;
     }
+    const notice = deps.updateCheck
+        ? await deps.updateCheck()
+        : deps.runUi
+            ? null
+            : await fetchUpdateNotice(resolveCliVersion());
+    if (notice !== null) {
+        (deps.stdout ?? ((line) => process.stdout.write(line)))(`${notice}\n`);
+    }
     const connection = {
         baseUrl: resolved.site.base_url,
         jsonapiPrefix: resolved.site.jsonapi_prefix,
@@ -242,9 +297,8 @@ export async function cmdUi(deps = {}) {
             `(${err instanceof Error ? err.message : String(err)}); ` +
             `edits will be attempted as '${connection.authProfile}'.`);
     }
-    const rooting = resolveProjectRooting(cwd, entries, homedir());
-    const ownConductorMachineId = rooting.ownConductorMachineId;
-    const project = rooting.project;
+    const rooting = resolveProjectRooting(cwd, homedir());
+    const project = deps.project;
     // AC-7, always on: the resolution lands in the log even when the TUI takes
     // over the screen a moment later.
     logger.info({
@@ -254,13 +308,17 @@ export async function cmdUi(deps = {}) {
         legacy: resolved.legacy,
         base_url: resolved.site.base_url,
         cwd: rooting.cwd,
+        // The `.gaia` dir, not a project name: since GAIA-232 the default project
+        // is resolved in the renderer from the conductor record whose
+        // `workspace_root` is this dir. `project` here is the flag alone.
+        gaia_dir: rooting.gaiaDir,
         project,
     }, 'gaia ui: resolved connection');
     // AC-7, the human surface: print and exit 0 WITHOUT booting the TUI, so a
     // wrong-control-plane situation is diagnosable at a prompt.
     if (deps.printConfig) {
         const write = deps.stdout ?? ((s) => process.stdout.write(s));
-        write(formatConnectionReport(resolved, rooting));
+        write(formatConnectionReport(resolved, rooting, project));
         return;
     }
     const agentCommand = resolveAgentCommand(machine);
@@ -315,7 +373,7 @@ export async function cmdUi(deps = {}) {
             ...(project !== undefined ? { project } : {}),
             agents,
             ...(machine.user_id ? { currentUser: machine.user_id } : {}),
-            ...(ownConductorMachineId ? { ownConductorMachineId } : {}),
+            ...(rooting.gaiaDir ? { gaiaDir: rooting.gaiaDir } : {}),
             // The plugins are real constructed `DropSHPlugin[]` now (core built them),
             // matching dropsh's declared contract — F3's substance, a descriptor handed
             // to an API expecting instances, is gone. The two casts that remain are

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/ui",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "GAIA project-first cockpit: the `gaia ui` command plugin (renderer resolved dynamically).",
   "type": "module",
   "license": "MIT",
@@ -26,8 +26,8 @@
     "directory": "gaia-cli/ui"
   },
   "dependencies": {
-    "@gaia-ai/core": "^0.7.0",
-    "@gaia-ai/addon-herdr": "^0.7.0",
+    "@gaia-ai/core": "^0.9.0",
+    "@gaia-ai/addon-herdr": "^0.9.0",
     "commander": "^12.1.0",
     "dropsh": "^0.5.8"
   }