@gaia-ai/core 0.7.0 → 0.8.0

package/dist/src/cli/gaia-dir.d.ts

@@ -1,3 +1,16 @@
+/**
+ * The conductor stem a config file name denotes, or `undefined` when the file
+ * is not a conductor config at all.
+ *
+ * The inverse of {@link fileForStem}, exported because the naming rule has to
+ * stay in one place: a conductor reporting which config it was started from
+ * would otherwise slice the filename itself and quietly disagree with the
+ * loader about the near-miss cases this rule exists to exclude
+ * (`myconductor.config.js`, `vite.config.js`, `gaia.config.js`).
+ *
+ * Takes a bare file name, not a path — callers pass `basename(config_path)`.
+ */
+export declare function stemForConfigFile(fileName: string): string | undefined;
 /**
  * The user-global `~/.gaia` dir. Core owns where the split-config files live,
  * so a consumer that must recognise the home dir (e.g. to exclude it from a

package/dist/src/cli/gaia-dir.js

@@ -39,14 +39,31 @@ const GAIA_CONFIG = 'gaia.config.js';
  */
 function configStems(gaiaDir) {
     return readdirSync(gaiaDir)
-        .map((f) => f === DEFAULT_CONFIG
-        ? 'conductor'
-        : f.endsWith(VARIANT_SUFFIX)
-            ? f.slice(0, -VARIANT_SUFFIX.length)
-            : undefined)
+        .map(stemForConfigFile)
         .filter((s) => s !== undefined)
         .sort();
 }
+/**
+ * The conductor stem a config file name denotes, or `undefined` when the file
+ * is not a conductor config at all.
+ *
+ * The inverse of {@link fileForStem}, exported because the naming rule has to
+ * stay in one place: a conductor reporting which config it was started from
+ * would otherwise slice the filename itself and quietly disagree with the
+ * loader about the near-miss cases this rule exists to exclude
+ * (`myconductor.config.js`, `vite.config.js`, `gaia.config.js`).
+ *
+ * Takes a bare file name, not a path — callers pass `basename(config_path)`.
+ */
+export function stemForConfigFile(fileName) {
+    if (fileName === DEFAULT_CONFIG)
+        return 'conductor';
+    if (fileName.endsWith(VARIANT_SUFFIX)) {
+        const stem = fileName.slice(0, -VARIANT_SUFFIX.length);
+        return stem === '' ? undefined : stem;
+    }
+    return undefined;
+}
 /** Map a conductor stem back to its file name. */
 function fileForStem(stem) {
     return stem === 'conductor' ? DEFAULT_CONFIG : `${stem}${VARIANT_SUFFIX}`;

package/dist/src/cli/version-check.d.ts

@@ -0,0 +1,17 @@
+export declare const GAIA_PACKAGE = "@gaia-ai/gaia";
+export declare const REGISTRY_LATEST_URL = "https://registry.npmjs.org/@gaia-ai/gaia/latest";
+export declare const UNKNOWN_VERSION = "0.0.0";
+export declare const UPDATE_CHECK_TTL_MS: number;
+export declare const DEFAULT_UPDATE_CACHE_PATH: string;
+export declare function resolveCliVersion(): string;
+export declare function fetchLatestVersion(fetchImpl?: typeof fetch, timeoutMs?: number): Promise<string | null>;
+export declare function updateNotice(current: string, latest: string): string | null;
+export interface UpdateCheckOptions {
+    cachePath?: string;
+    now?: () => Date;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+    ttlMs?: number;
+}
+export declare function fetchUpdateNotice(current: string, options?: UpdateCheckOptions): Promise<string | null>;
+export declare function printVersionLine(out?: (line: string) => void): string;

package/dist/src/cli/version-check.js

@@ -0,0 +1,100 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import semver from 'semver';
+export const GAIA_PACKAGE = '@gaia-ai/gaia';
+export const REGISTRY_LATEST_URL = 'https://registry.npmjs.org/@gaia-ai/gaia/latest';
+export const UNKNOWN_VERSION = '0.0.0';
+export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_UPDATE_CACHE_PATH = join(homedir(), '.gaia', 'update-check.json');
+let cachedCliVersion;
+export function resolveCliVersion() {
+    if (cachedCliVersion)
+        return cachedCliVersion;
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 7; i++) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+            if (pkg.name === '@gaia-ai/core') {
+                cachedCliVersion = pkg.version ?? UNKNOWN_VERSION;
+                return cachedCliVersion;
+            }
+        }
+        catch { }
+        dir = dirname(dir);
+    }
+    cachedCliVersion = UNKNOWN_VERSION;
+    return cachedCliVersion;
+}
+export async function fetchLatestVersion(fetchImpl = globalThis.fetch, timeoutMs = 1500) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const result = await fetchImpl(REGISTRY_LATEST_URL, {
+            signal: controller.signal,
+            headers: { accept: 'application/json' },
+        });
+        if (!result.ok)
+            return null;
+        const body = (await result.json());
+        return typeof body.version === 'string' && semver.valid(body.version)
+            ? body.version
+            : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function updateNotice(current, latest) {
+    if (current === UNKNOWN_VERSION ||
+        !semver.valid(current) ||
+        !semver.valid(latest) ||
+        !semver.gt(latest, current))
+        return null;
+    return `A new gaia version is available: ${current} → ${latest}\nRun \`gaia update\` to install it, then \`gaia upgrade\` to migrate your config.`;
+}
+function validRecord(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const record = value;
+    if (typeof record.checkedAt !== 'string' ||
+        (record.latestVersion !== null && typeof record.latestVersion !== 'string'))
+        return null;
+    const time = Date.parse(record.checkedAt);
+    return Number.isFinite(time) ? record : null;
+}
+export async function fetchUpdateNotice(current, options = {}) {
+    const cachePath = options.cachePath ?? DEFAULT_UPDATE_CACHE_PATH;
+    const now = options.now?.() ?? new Date();
+    const ttl = options.ttlMs ?? UPDATE_CHECK_TTL_MS;
+    try {
+        const record = validRecord(JSON.parse(await readFile(cachePath, 'utf8')));
+        if (record) {
+            const age = now.getTime() - Date.parse(record.checkedAt);
+            if (age >= 0 && age < ttl)
+                return record.latestVersion
+                    ? updateNotice(current, record.latestVersion)
+                    : null;
+        }
+    }
+    catch { }
+    const latestVersion = await fetchLatestVersion(options.fetchImpl, options.timeoutMs);
+    try {
+        await mkdir(dirname(cachePath), { recursive: true });
+        const temporary = `${cachePath}.${process.pid}.tmp`;
+        await writeFile(temporary, JSON.stringify({ checkedAt: now.toISOString(), latestVersion }), 'utf8');
+        await rename(temporary, cachePath);
+    }
+    catch { }
+    return latestVersion ? updateNotice(current, latestVersion) : null;
+}
+export function printVersionLine(out = console.log) {
+    const version = resolveCliVersion();
+    out(`gaia v${version}`);
+    return version;
+}

package/dist/src/core/liveness.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The derived liveness of a conductor.
+ *
+ * These three words are the server's, and they are deliberately the only ones:
+ * the dashboard, the ticket board, the CLI listing and the cockpit all describe
+ * the same conductor the same way. A `registry-only` fourth state existed while
+ * a local registry could name a conductor the control plane had never heard of;
+ * with the control plane as the sole list there is nothing left for it to
+ * denote.
+ */
+export type ConductorLiveness = 'running' | 'stale' | 'offline';
+/** The raw liveness inputs of a `gaia_conductor` record. */
+export interface ConductorLivenessInput {
+    status?: string | null;
+    /** Unix seconds of the last heartbeat. */
+    lastSeen?: number | null;
+    /** Unix seconds the lease runs out. */
+    leaseExpiresAt?: number | null;
+}
+/**
+ * Derives whether a conductor is alive from its own record.
+ *
+ * `offline` is only ever self-declared: a conductor writes it as it exits, and
+ * a heartbeat sets `online` unconditionally, so the flag means "it shut down
+ * cleanly" rather than "it is not answering". Everything that is neither
+ * clearly shut down nor clearly fresh is `stale` — including a crash, which
+ * keeps `online` on the record until the lease lapses. Calling that state
+ * `running` would block a restart until the reaper caught up; calling it
+ * `offline` would claim a clean shutdown that did not happen.
+ */
+export declare function deriveConductorLiveness(input: ConductorLivenessInput, nowSeconds: number): ConductorLiveness;
+/**
+ * A control-plane timestamp as unix seconds, or `null` when it says nothing.
+ *
+ * Drupal's JSON:API serialises a `timestamp` field as **ISO-8601**
+ * (`'2026-08-04T05:27:20+00:00'`), not as the unix integer the name suggests.
+ * Both readers of these fields got that wrong, in mirror-image ways: the
+ * cockpit's `typeof === 'number'` guard rejected the string and fell back to 0,
+ * showing a conductor that was demonstrably ticking as `stale` with an unknown
+ * age; the CLI declared the value `number` for the compiler alone, so every
+ * arithmetic comparison was NaN — and since NaN comparisons are false, `stale`
+ * was quietly unreachable there.
+ *
+ * `0` is treated as unknown rather than as 1970: no conductor heartbeat has
+ * ever legitimately been at the epoch, and reading it as a real timestamp would
+ * report a fresh conductor as decades stale.
+ */
+export declare function toUnixSeconds(value: unknown): number | null;

package/dist/src/core/liveness.js

@@ -0,0 +1,56 @@
+/**
+ * How long a conductor may go without a heartbeat before it is stale.
+ *
+ * Mirrors the server-side ConductorDeriver
+ * (web/modules/custom/gaia_core/modules/gaia_dashboard/src/Dashboard/ConductorDeriver.php).
+ */
+const STALE_WINDOW_SECONDS = 600;
+/**
+ * Derives whether a conductor is alive from its own record.
+ *
+ * `offline` is only ever self-declared: a conductor writes it as it exits, and
+ * a heartbeat sets `online` unconditionally, so the flag means "it shut down
+ * cleanly" rather than "it is not answering". Everything that is neither
+ * clearly shut down nor clearly fresh is `stale` — including a crash, which
+ * keeps `online` on the record until the lease lapses. Calling that state
+ * `running` would block a restart until the reaper caught up; calling it
+ * `offline` would claim a clean shutdown that did not happen.
+ */
+export function deriveConductorLiveness(input, nowSeconds) {
+    if (input.status === 'offline')
+        return 'offline';
+    if (input.lastSeen == null || input.lastSeen <= 0)
+        return 'stale';
+    if (nowSeconds - input.lastSeen > STALE_WINDOW_SECONDS)
+        return 'stale';
+    if (input.leaseExpiresAt != null && input.leaseExpiresAt < nowSeconds) {
+        return 'stale';
+    }
+    return 'running';
+}
+/**
+ * A control-plane timestamp as unix seconds, or `null` when it says nothing.
+ *
+ * Drupal's JSON:API serialises a `timestamp` field as **ISO-8601**
+ * (`'2026-08-04T05:27:20+00:00'`), not as the unix integer the name suggests.
+ * Both readers of these fields got that wrong, in mirror-image ways: the
+ * cockpit's `typeof === 'number'` guard rejected the string and fell back to 0,
+ * showing a conductor that was demonstrably ticking as `stale` with an unknown
+ * age; the CLI declared the value `number` for the compiler alone, so every
+ * arithmetic comparison was NaN — and since NaN comparisons are false, `stale`
+ * was quietly unreachable there.
+ *
+ * `0` is treated as unknown rather than as 1970: no conductor heartbeat has
+ * ever legitimately been at the epoch, and reading it as a real timestamp would
+ * report a fresh conductor as decades stale.
+ */
+export function toUnixSeconds(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) && value > 0 ? value : null;
+    }
+    if (typeof value === 'string' && value !== '') {
+        const parsed = Date.parse(value);
+        return Number.isNaN(parsed) ? null : Math.floor(parsed / 1000);
+    }
+    return null;
+}

package/dist/src/core/logger.d.ts

@@ -45,4 +45,6 @@ export declare function createLogger(opts: {
     level?: string;
     /** CLI override for the sink — beats env + default. */
     sink?: string;
+    /** Pretty-output destination; test seam, defaults to stdout. */
+    prettyDestination?: NodeJS.WritableStream;
 }): ConductorLogger;

package/dist/src/core/logger.js

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import pino from 'pino';
 import pretty from 'pino-pretty';
+import { resolveCliVersion } from '../cli/version-check.js';
 /**
  * Pick the log sink. Precedence: explicit CLI override (`sink`) > the
  * GAIA_CONDUCTOR_LOG env var > default (`both` on a TTY, `file` otherwise).
@@ -37,8 +38,15 @@ export function createLogger(opts) {
     const isTTY = opts.isTTY ?? Boolean(process.stdout.isTTY);
     const level = resolveLevel(env, opts.level);
     const sink = resolveSink(env, isTTY, opts.checkoutRoot, opts.sink);
+    const loggerOptions = {
+        level,
+        base: { gaia_version: resolveCliVersion() },
+    };
+    const prettyOptions = opts.prettyDestination
+        ? { colorize: true, sync: true, destination: opts.prettyDestination }
+        : { colorize: true, sync: true };
     if (sink.kind === 'stdout') {
-        return pino({ level }, pretty({ colorize: true, sync: true }));
+        return pino(loggerOptions, pretty(prettyOptions));
     }
     const file = () => pino.destination({
         dest: sink.path,
@@ -47,7 +55,7 @@ export function createLogger(opts) {
         sync: true,
     });
     if (sink.kind === 'file') {
-        return pino({ level }, file());
+        return pino(loggerOptions, file());
     }
     // 'both' — tee via multistream so the pane stays readable AND the record is
     // durable (GAIA-237). `level` is enforced by the logger, so each stream takes
@@ -56,8 +64,8 @@ export function createLogger(opts) {
     // would silently drop `--log-level debug` from BOTH streams — so each entry
     // carries the resolved level and the logger stays the single gate.
     const at = level;
-    return pino({ level }, pino.multistream([
-        { level: at, stream: pretty({ colorize: true, sync: true }) },
+    return pino(loggerOptions, pino.multistream([
+        { level: at, stream: pretty(prettyOptions) },
         { level: at, stream: file() },
     ]));
 }

package/dist/src/core/proc.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The platform-facing half of pid verification, injected so tests never touch a
+ * real process.
+ */
+export interface ProcProbe {
+    /** Whether this platform can report a running process's cwd at all. */
+    readonly supported: boolean;
+    /** The cwd of a running process, or `undefined` when it cannot be read. */
+    cwdOf(pid: number): string | undefined;
+    /** Deliver a signal. Throws what the platform throws. */
+    send(pid: number, signal: NodeJS.Signals): void;
+}
+export type SignalFailureReason = 
+/** Nothing on record to signal — the conductor never reported a pid. */
+'no-pid'
+/** The pid is gone, or belongs to something that is not this conductor. */
+ | 'stale-pid'
+/** This platform cannot prove what a pid is, so we refuse to guess. */
+ | 'unverifiable-platform'
+/** Verified, but the OS refused the signal (permissions, race). */
+ | 'signal-failed';
+export type SignalOutcome = {
+    ok: true;
+    pid: number;
+    signal: NodeJS.Signals;
+} | {
+    ok: false;
+    reason: SignalFailureReason;
+    message: string;
+};
+export interface SignalVerifiedInput {
+    /** The last pid the conductor reported, if any. */
+    pid: number | undefined;
+    /** The directory that pid must be running in to count as this conductor. */
+    workspaceRoot: string;
+    signal: NodeJS.Signals;
+    probe?: ProcProbe;
+}
+/**
+ * Signals a process only after proving it is the conductor of `workspaceRoot`.
+ *
+ * The proof is the process's working directory. A conductor is started with its
+ * `.gaia` dir as cwd (herdr passes `--cwd <checkoutRoot>`, and that is what
+ * `workspace_root` stores), so a process running there is that conductor.
+ *
+ * The alternative — trusting `last_pid` — is unsafe in a way that only shows up
+ * rarely and badly: pids are recycled, so a stale one eventually names an
+ * unrelated program, and the "stop" would kill it. Refusing to signal an
+ * unverified pid costs a stopped conductor nothing (the operator sees why and
+ * the lease reaper marks it offline anyway) and costs a mis-signalled process
+ * everything.
+ *
+ * Deliberately never throws: a cockpit calls this from a keypress handler and
+ * must render the reason on the row rather than unwind.
+ */
+export declare function signalVerifiedProcess(input: SignalVerifiedInput): SignalOutcome;
+/**
+ * The real probe: `/proc/<pid>/cwd` on Linux.
+ *
+ * Only Linux is claimed as supported. macOS could shell out to `lsof`, but a
+ * wrong answer here signals the wrong process, so an unimplemented platform
+ * reports `supported: false` and stop degrades with a message rather than
+ * guessing. Start is unaffected everywhere.
+ */
+export declare function defaultProcProbe(): ProcProbe;

package/dist/src/core/proc.js

@@ -0,0 +1,92 @@
+import { readlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+/**
+ * Signals a process only after proving it is the conductor of `workspaceRoot`.
+ *
+ * The proof is the process's working directory. A conductor is started with its
+ * `.gaia` dir as cwd (herdr passes `--cwd <checkoutRoot>`, and that is what
+ * `workspace_root` stores), so a process running there is that conductor.
+ *
+ * The alternative — trusting `last_pid` — is unsafe in a way that only shows up
+ * rarely and badly: pids are recycled, so a stale one eventually names an
+ * unrelated program, and the "stop" would kill it. Refusing to signal an
+ * unverified pid costs a stopped conductor nothing (the operator sees why and
+ * the lease reaper marks it offline anyway) and costs a mis-signalled process
+ * everything.
+ *
+ * Deliberately never throws: a cockpit calls this from a keypress handler and
+ * must render the reason on the row rather than unwind.
+ */
+export function signalVerifiedProcess(input) {
+    const { pid, workspaceRoot, signal } = input;
+    const probe = input.probe ?? defaultProcProbe();
+    if (pid === undefined || !Number.isInteger(pid) || pid <= 0) {
+        return {
+            ok: false,
+            reason: 'no-pid',
+            message: 'no pid on record for this conductor — it has not reported one since it last started',
+        };
+    }
+    if (!probe.supported) {
+        return {
+            ok: false,
+            reason: 'unverifiable-platform',
+            message: `cannot verify on this platform that pid ${pid} is the conductor of ${workspaceRoot}; refusing to signal an unverified pid`,
+        };
+    }
+    const actual = probe.cwdOf(pid);
+    if (actual === undefined) {
+        return {
+            ok: false,
+            reason: 'stale-pid',
+            message: `pid ${pid} is not running; it is the last known pid, not a live one (expected it in ${workspaceRoot})`,
+        };
+    }
+    if (resolve(actual) !== resolve(workspaceRoot)) {
+        return {
+            ok: false,
+            reason: 'stale-pid',
+            message: `pid ${pid} runs in ${actual}, not in ${workspaceRoot} — the pid was recycled by another process; not signalling it`,
+        };
+    }
+    try {
+        probe.send(pid, signal);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: 'signal-failed',
+            message: `verified pid ${pid} but could not deliver ${signal}: ${String(err)}`,
+        };
+    }
+    return { ok: true, pid, signal };
+}
+/**
+ * The real probe: `/proc/<pid>/cwd` on Linux.
+ *
+ * Only Linux is claimed as supported. macOS could shell out to `lsof`, but a
+ * wrong answer here signals the wrong process, so an unimplemented platform
+ * reports `supported: false` and stop degrades with a message rather than
+ * guessing. Start is unaffected everywhere.
+ */
+export function defaultProcProbe() {
+    const supported = process.platform === 'linux';
+    return {
+        supported,
+        cwdOf(pid) {
+            if (!supported)
+                return undefined;
+            try {
+                return readlinkSync(`/proc/${pid}/cwd`);
+            }
+            catch {
+                // ESRCH (gone) and EACCES (another user's process) are both "cannot
+                // prove it is ours", which is the same answer for our purposes.
+                return undefined;
+            }
+        },
+        send(pid, signal) {
+            process.kill(pid, signal);
+        },
+    };
+}

package/dist/src/index.d.ts

@@ -1,15 +1,17 @@
 export type { GaiaCommandHost, GaiaCommandPlugin } from './cli/commands.js';
 export { declaresTopLevelKey, findDefaultExportObject, matchDelimiter, type PropEntry, readKey, scanTopLevelProperties, scanToTopLevelComma, skipBlockComment, skipLineComment, skipString, skipTrivia, } from './cli/config-source.js';
 export type { GaiaConfigResolution, GaiaConfigSource, } from './cli/gaia-dir.js';
-export { findGaiaConfig, findGaiaDir, findProjectGaiaDir, homeGaiaDir, resolveConfigPath, resolveGaiaConfigPath, } from './cli/gaia-dir.js';
+export { findGaiaConfig, findGaiaDir, findProjectGaiaDir, homeGaiaDir, resolveConfigPath, resolveGaiaConfigPath, stemForConfigFile, } from './cli/gaia-dir.js';
 export { type GaiaConnectionConfig, loadGaiaConfig, } from './cli/load-gaia-config.js';
 export { legacyMachineContextPath, type MachineContext, machineContextPath, readMachineContext, resolveMachineContextPath, } from './cli/machine-context.js';
 export { corePackageRoot, homeFallbackGaiaConfigPath, } from './cli/paths.js';
 export { resolveModuleEslintStyle } from './cli/resolve-module.js';
-export { type ConductorRegistryEntry, conductorRegistryPath, getRegisteredConductor, listRegisteredConductors, registerConductor, removeConductor, } from './conductor-registry/index.js';
+export { DEFAULT_UPDATE_CACHE_PATH, fetchLatestVersion, fetchUpdateNotice, GAIA_PACKAGE, printVersionLine, REGISTRY_LATEST_URL, resolveCliVersion, UNKNOWN_VERSION, UPDATE_CHECK_TTL_MS, type UpdateCheckOptions, updateNotice, } from './cli/version-check.js';
 export { conductorId } from './core/conductor-id.js';
 export { CommandRunner, ExecError, exec, setDefaultCommandRunner, } from './core/exec.js';
+export { type ConductorLiveness, type ConductorLivenessInput, deriveConductorLiveness, toUnixSeconds, } from './core/liveness.js';
 export { type ConductorLogger, createLogger } from './core/logger.js';
+export { defaultProcProbe, type ProcProbe, type SignalFailureReason, type SignalOutcome, signalVerifiedProcess, } from './core/proc.js';
 export { shellQuote } from './core/shell.js';
 export { DEFAULT_SLUG_MAX_LENGTH, slugify } from './core/slug.js';
 export { discoverAddons, type ResolvedConductorSlots, resolveConductorSlots, } from './plugins/discover-addons.js';

package/dist/src/index.js

@@ -3,15 +3,17 @@
 // GAIA-218 strip pass share one answer to "which top-level properties does this
 // config source declare?" — core is layer 0 and cannot import the conductor's copy.
 export { declaresTopLevelKey, findDefaultExportObject, matchDelimiter, readKey, scanTopLevelProperties, scanToTopLevelComma, skipBlockComment, skipLineComment, skipString, skipTrivia, } from './cli/config-source.js';
-export { findGaiaConfig, findGaiaDir, findProjectGaiaDir, homeGaiaDir, resolveConfigPath, resolveGaiaConfigPath, } from './cli/gaia-dir.js';
+export { findGaiaConfig, findGaiaDir, findProjectGaiaDir, homeGaiaDir, resolveConfigPath, resolveGaiaConfigPath, stemForConfigFile, } from './cli/gaia-dir.js';
 export { loadGaiaConfig, } from './cli/load-gaia-config.js';
 export { legacyMachineContextPath, machineContextPath, readMachineContext, resolveMachineContextPath, } from './cli/machine-context.js';
 export { corePackageRoot, homeFallbackGaiaConfigPath, } from './cli/paths.js';
 export { resolveModuleEslintStyle } from './cli/resolve-module.js';
-export { conductorRegistryPath, getRegisteredConductor, listRegisteredConductors, registerConductor, removeConductor, } from './conductor-registry/index.js';
+export { DEFAULT_UPDATE_CACHE_PATH, fetchLatestVersion, fetchUpdateNotice, GAIA_PACKAGE, printVersionLine, REGISTRY_LATEST_URL, resolveCliVersion, UNKNOWN_VERSION, UPDATE_CHECK_TTL_MS, updateNotice, } from './cli/version-check.js';
 export { conductorId } from './core/conductor-id.js';
 export { CommandRunner, ExecError, exec, setDefaultCommandRunner, } from './core/exec.js';
+export { deriveConductorLiveness, toUnixSeconds, } from './core/liveness.js';
 export { createLogger } from './core/logger.js';
+export { defaultProcProbe, signalVerifiedProcess, } from './core/proc.js';
 export { shellQuote } from './core/shell.js';
 export { DEFAULT_SLUG_MAX_LENGTH, slugify } from './core/slug.js';
 // GAIA-215: the Storybook-style preset contract + the shared addon discovery.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "GAIA surface-agnostic kernel: host contract, split-config helpers, addon preset/discovery machinery, shared primitives.",
   "type": "module",
   "license": "MIT",
@@ -33,6 +33,7 @@
     "dropsh": "^0.5.8",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
+    "semver": "^7.6.0",
     "yaml": "^2.7.0"
   }
 }