@gaia-ai/conductor 0.5.4 → 0.6.0

package/dist/src/config.js

@@ -1,17 +1,20 @@
-import { existsSync, readdirSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { dirname, join, resolve } from 'node:path';
+import { readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { discoverAddons, emptyContributions, resolveConductorSlots, resolveModuleEslintStyle, } from '@gaia-ai/core';
+// GAIA-201: the `.gaia/` walk-up + connection resolution moved to `@gaia-ai/core`
+// (`resolveConfigPath` / `resolveGaiaConfigPath` / `findGaiaDir`). Re-export the
+// engine resolver here so existing conductor callers/tests keep importing it
+// from `../config.js`.
+export { findGaiaDir, resolveConfigPath, } from '@gaia-ai/core';
 /**
- * Default agent prompt - the GAIA run contract. One run works EXACTLY one state;
+ * Default agent prompt - the project instruction contract. One run works EXACTLY one state;
  * the agent must stop instead of running the whole flow in one session. The run
  * is closed automatically when the ticket state changes on the next claim - the
  * agent does not release it. Run mechanics live here (not in the repo's
- * WORKFLOW.md). The prompt routes through the gaia skill (`ticket:run`) rather
- * than pointing at WORKFLOW.md directly (GAIA-125): the intake line + state
- * engine are a skill mechanic, so a bare "follow WORKFLOW.md" pointer left the
- * intake line unprinted unless an external skill-forcing hook happened to fire. A
- * conductor config may override via the `prompt` field.
+ * WORKFLOW.md). The prompt points directly at the matching project-owned state
+ * section and does not prescribe an agent skill. A conductor config may override
+ * it via the `prompt` field.
  *
  * The ticket + its comments are NOT embedded (GAIA-112): embedding unbounded
  * ticket content into a single typed pane line overran the PTY canonical line
@@ -34,15 +37,12 @@ import { pathToFileURL } from 'node:url';
  * wrapper, GAIA-118, was the thing that re-inflated the line past the cap and
  * truncated it mid-quote).
  * Placeholders: `{identifier}`, `{state}`, `{runUuid}` ({state} falls back to
- * `triage` for unclassified tickets).
+ * `qualification` for unclassified tickets).
  */
-export const DEFAULT_AGENT_PROMPT = `You are a GAIA agent working ticket {identifier}, current state: {state}. ` +
-    `Invoke the gaia skill and run \`ticket:run {identifier} {state}\` — it first ` +
-    `reads the ticket + all comments ` +
+export const DEFAULT_AGENT_PROMPT = `You are working ticket {identifier}, current state: {state}. Read the ticket and all comments ` +
     `(gaia dropsh read gaia_ticket/gaia_ticket/$GAIA_ID --include comments), ` +
-    `prints an intake line, runs the {state} engine, and applies ` +
-    `WORKFLOW.md's {state} policy. Do ONLY the {state} work — never start or ` +
-    `prepare a later state.`;
+    `then read ./WORKFLOW.md and execute only its ordered "State: {state}" section. ` +
+    `Do not start or prepare a later state.`;
 function requirePlugin(value, kind) {
     if (!isRecord(value) || value.kind !== kind) {
         throw new Error(`conductor config requires a ${kind} plugin in the "${kind}" slot`);
@@ -73,16 +73,7 @@ async function loadNamedPlugin(entry, configPath) {
         pathToFileURL(`${process.cwd()}/`).href,
         import.meta.url,
     ];
-    let resolved;
-    for (const base of bases) {
-        try {
-            resolved = createRequire(base).resolve(entry.plugin);
-            break;
-        }
-        catch {
-            // try the next base
-        }
-    }
+    const resolved = resolveModuleEslintStyle(entry.plugin, bases);
     if (resolved === undefined) {
         throw new Error(`conductor config cannot resolve plugin '${entry.plugin}'`);
     }
@@ -144,23 +135,6 @@ export async function resolveAgents(raw, configPath) {
         ? Promise.all(raw.map(resolveOne))
         : resolveOne(raw);
 }
-/**
- * Resolve the `plugins[]` array: descriptor entries are constructed, already-
- * constructed entries pass through. No kind-guard (plugins are not slotted).
- *
- * A factory may return one plugin OR an array of plugins — an aggregator built
- * with dropsh's `composePlugins(a(), b())` returns the flat child list. dropsh's
- * own `loadConfig` flattens such a nested entry one level; we mirror that here so
- * `buildProgram({ plugins })` — which reads each entry's hooks/renderers per
- * top-level element and does NOT recurse — sees every child.
- */
-async function resolvePlugins(raw, configPath) {
-    if (!Array.isArray(raw)) {
-        return [];
-    }
-    const resolved = await Promise.all(raw.map((entry) => isPluginDescriptor(entry) ? loadNamedPlugin(entry, configPath) : entry));
-    return resolved.flat();
-}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -179,98 +153,15 @@ function optionalPositiveInteger(value, fallback, key) {
     }
     return value;
 }
-/** A repo's config files live in this dir, one conductor config per conductor. */
-const GAIA_DIR = '.gaia';
-/** The default conductor's file name; its stem is `conductor`. */
-const DEFAULT_CONFIG = 'conductor.config.js';
-/** Variant files are `<stem>.conductor.config.js`. */
-const VARIANT_SUFFIX = '.conductor.config.js';
 /**
- * List the conductor-config stems in a `.gaia/` dir. A file is a conductor
- * config iff it is exactly `conductor.config.js` (stem `conductor`, the
- * default) or ends with `.conductor.config.js` (stem = the leading part).
- * Every other file (`vite.config.js`, the near-miss `myconductor.config.js`)
- * is ignored.
+ * Load the ENGINE half of a conductor config (GAIA-201 split model). Reads
+ * remote/executor/agent/workspace + project/states/machine_id/label/prompt/
+ * scheduler/hooks — and deliberately NOT `site` or the auth `plugins`, which now
+ * live in a `gaia.config.js` connection config. The conductor command composes
+ * the two via `composeConductorConfig`. A legacy `conductor.config.js` still
+ * carrying `site`/`plugins` loads fine — those two keys are simply ignored here
+ * (the connection loader reads them, back-compat).
  */
-function configStems(gaiaDir) {
-    return readdirSync(gaiaDir)
-        .map((f) => f === DEFAULT_CONFIG
-        ? 'conductor'
-        : f.endsWith(VARIANT_SUFFIX)
-            ? f.slice(0, -VARIANT_SUFFIX.length)
-            : undefined)
-        .filter((s) => s !== undefined)
-        .sort();
-}
-/** Map a conductor stem back to its file name. */
-function fileForStem(stem) {
-    return stem === 'conductor' ? DEFAULT_CONFIG : `${stem}${VARIANT_SUFFIX}`;
-}
-/**
- * Walk from `cwd` root-ward (git/eslint style) to the nearest ancestor whose
- * `.gaia/` dir holds at least one conductor config; return that `.gaia/` dir, or
- * `undefined` if none is found up to the filesystem root.
- */
-function findGaiaDir(cwd) {
-    let dir = resolve(cwd);
-    for (;;) {
-        const gaiaDir = join(dir, GAIA_DIR);
-        if (existsSync(gaiaDir) && configStems(gaiaDir).length > 0) {
-            return gaiaDir;
-        }
-        const parent = dirname(dir);
-        if (parent === dir) {
-            return undefined;
-        }
-        dir = parent;
-    }
-}
-/**
- * Resolve the conductor config path from `cwd`.
- *
- * 1. An explicit `--config` / `$GAIA_CONDUCTOR_CONFIG` wins verbatim (no walk).
- * 2. Otherwise walk root-ward to the nearest `.gaia/` dir holding a conductor config
- *    — so any subdirectory of a project/worktree resolves the same dir.
- *    - A `--conductor <name>` / `$GAIA_CONDUCTOR` selector resolves the stem's
- *      file (`conductor` → `conductor.config.js`, else
- *      `<name>.conductor.config.js`; error listing the stems if absent).
- *    - No selector: `conductor.config.js` present → it is the default; else
- *      exactly one config → use it (back-compat); else → error naming the
- *      stems + the selector.
- * 3. No `.gaia/` config anywhere up the tree → an actionable `gaia init` error
- *    (never leak a raw "Cannot find module" from a later import()).
- */
-export function resolveConfigPath(override, cwd = process.cwd(), conductorName) {
-    const explicit = override ?? process.env.GAIA_CONDUCTOR_CONFIG;
-    if (explicit) {
-        return explicit;
-    }
-    const gaiaDir = findGaiaDir(cwd);
-    if (gaiaDir === undefined) {
-        throw new Error(`no .gaia/conductor.config.js found from ${cwd} upward; run \`gaia init\``);
-    }
-    const stems = configStems(gaiaDir);
-    const name = conductorName ?? process.env.GAIA_CONDUCTOR;
-    if (name !== undefined && name !== '') {
-        const candidate = join(gaiaDir, fileForStem(name));
-        if (!existsSync(candidate)) {
-            throw new Error(`no conductor '${name}' in ${gaiaDir}; available: ${stems.join(', ')}`);
-        }
-        return candidate;
-    }
-    // No selector: the file named conductor.config.js is the default (AC-1, AC-2).
-    // Two conductor.config.js files cannot coexist in one dir, so ">1 default"
-    // (AC-5) is structurally impossible — no ambiguity branch is needed.
-    if (stems.includes('conductor')) {
-        return join(gaiaDir, DEFAULT_CONFIG);
-    }
-    // Back-compat: a lone config resolves even without the default name.
-    if (stems.length === 1) {
-        return join(gaiaDir, fileForStem(stems[0]));
-    }
-    throw new Error(`${stems.length} conductors in ${gaiaDir} (${stems.join(', ')}); ` +
-        'select one with --conductor <name> or $GAIA_CONDUCTOR');
-}
 export async function loadConductorConfig(configFile) {
     const configPath = resolve(configFile);
     const module = (await import(pathToFileURL(configPath).href));
@@ -279,13 +170,13 @@ export async function loadConductorConfig(configFile) {
         throw new Error('conductor config default export must be an object');
     }
     const config = raw;
-    const site = isRecord(config.site) ? config.site : {};
-    const baseUrl = requireNonEmptyString(site.base_url, 'site.base_url');
     const project = requireNonEmptyString(config.project, 'project');
-    if (!Array.isArray(config.states) || config.states.length === 0) {
-        throw new Error('conductor config requires non-empty states');
-    }
-    const states = config.states.map((state) => requireNonEmptyString(state, 'states'));
+    // `states` is optional. An empty (or absent) list means the conductor serves
+    // every claimable state in its project; a non-empty list narrows it to those
+    // states (GAIA-207). When present it must be an array of non-empty strings.
+    const states = Array.isArray(config.states)
+        ? config.states.map((state) => requireNonEmptyString(state, 'states'))
+        : [];
     // machine_id is required — the config MUST set it; there is no derived
     // fallback. The id is defined in a single place (config.machine_id), which
     // the CLI lifecycle commands and registration all read, never re-derive. The
@@ -298,21 +189,46 @@ export async function loadConductorConfig(configFile) {
     const label = typeof config.label === 'string' && config.label.trim() !== ''
         ? config.label
         : machineId;
+    // GAIA-215: discover the conductor `addons: []` surface (last-wins singletons,
+    // agent candidate list). A pre-existing per-slot descriptor still loads and
+    // WINS over a discovered contributor of the same kind (back-compat additive).
+    const discovered = Array.isArray(config.addons)
+        ? await discoverAddons(config.addons, 'conductor', [
+            pathToFileURL(configPath).href,
+            pathToFileURL(`${process.cwd()}/`).href,
+            import.meta.url,
+        ])
+        : emptyContributions();
+    const wired = resolveConductorSlots(discovered);
+    const remote = config.remote !== undefined
+        ? await resolveSlot(config.remote, 'remote', configPath)
+        : wired.remote;
+    if (!remote) {
+        throw new Error('conductor config resolves no remote — name a remote addon in addons[] or set the remote slot');
+    }
+    const executor = config.executor !== undefined
+        ? await resolveSlot(config.executor, 'executor', configPath)
+        : wired.executor;
+    if (!executor) {
+        throw new Error('conductor config resolves no executor — name an executor addon in addons[] or set the executor slot');
+    }
+    const workspace = config.workspace !== undefined
+        ? await resolveSlot(config.workspace, 'workspace', configPath)
+        : wired.workspace;
+    if (!workspace) {
+        throw new Error('conductor config resolves no workspace — name a workspace addon in addons[] or set the workspace slot');
+    }
+    const agent = config.agent !== undefined
+        ? await resolveAgents(config.agent, configPath)
+        : wired.agents;
+    if (Array.isArray(agent) && agent.length === 0) {
+        throw new Error('conductor config resolves no agent — name an agent addon in addons[] or set the agent slot');
+    }
     return {
-        site: {
-            base_url: baseUrl,
-            jsonapi_prefix: typeof site.jsonapi_prefix === 'string' &&
-                site.jsonapi_prefix.trim() !== ''
-                ? site.jsonapi_prefix
-                : '/jsonapi',
-        },
-        ...(Array.isArray(config.plugins)
-            ? { plugins: await resolvePlugins(config.plugins, configPath) }
-            : {}),
-        remote: await resolveSlot(config.remote, 'remote', configPath),
-        executor: await resolveSlot(config.executor, 'executor', configPath),
-        agent: await resolveAgents(config.agent, configPath),
-        workspace: await resolveSlot(config.workspace, 'workspace', configPath),
+        remote,
+        executor,
+        agent,
+        workspace,
         label,
         machine_id: machineId,
         project,
@@ -327,3 +243,61 @@ export async function loadConductorConfig(configFile) {
         config_path: configPath,
     };
 }
+/**
+ * Compose the full `ConductorFileConfig` the engine consumes from the engine
+ * half (`loadConductorConfig`) and the connection half (`loadGaiaConfig`). The
+ * connection supplies `site` + the auth `plugins`; `ensureAuthenticated` /
+ * `selectRemote` read them exactly as before — the fields just arrive from
+ * `gaia.config.js` now.
+ */
+export function composeConductorConfig(engine, connection) {
+    return {
+        ...engine,
+        site: connection.site,
+        ...(connection.plugins.length > 0 ? { plugins: connection.plugins } : {}),
+    };
+}
+const DEFAULT_CONFIG = 'conductor.config.js';
+const VARIANT_SUFFIX = '.conductor.config.js';
+/**
+ * The conductor **stems** in a `.gaia/` dir — the file naming predicate of
+ * GAIA-137: exactly `conductor.config.js` (stem `conductor`) or
+ * `<variant>.conductor.config.js` (stem `<variant>`). The resolution itself
+ * lives in `@gaia-ai/core` (re-exported above); this is the enumeration.
+ */
+export function configStems(gaiaDir) {
+    return readdirSync(gaiaDir)
+        .map((f) => f === DEFAULT_CONFIG
+        ? 'conductor'
+        : f.endsWith(VARIANT_SUFFIX)
+            ? f.slice(0, -VARIANT_SUFFIX.length)
+            : undefined)
+        .filter((s) => s !== undefined)
+        .sort();
+}
+/** Map a conductor stem back to its file name. */
+export function fileForStem(stem) {
+    return stem === 'conductor' ? DEFAULT_CONFIG : `${stem}${VARIANT_SUFFIX}`;
+}
+/**
+ * List the conductor-config **file names** in a `.gaia/` dir, using the same
+ * naming predicate the loader uses (`configStems`). This is the only supported
+ * enumeration for the `@gaia/upgrade-project` states-strip: it visits the
+ * default `conductor.config.js` + every `<variant>.conductor.config.js`, and
+ * never an unrelated JS config (`vite.config.js`, the near-miss
+ * `myconductor.config.js`).
+ */
+export function listConductorConfigFiles(gaiaDir) {
+    return configStems(gaiaDir).map(fileForStem);
+}
+/**
+ * Remove the obsolete `states:` array property from a conductor-config JS
+ * source (GAIA-207 made `states` optional — empty ⇒ serve all claimable
+ * states — so `@gaia/upgrade-project` drops the now-dead key). Pure string
+ * transform: it strips the `states: [ ... ]` property (line form or inline in
+ * an object literal) with its trailing comma, and rewrites nothing else. A
+ * `substates:`/other key containing "states" is not matched.
+ */
+export function stripStatesFromConfigSource(source) {
+    return source.replace(/\n?[ \t]*(?<![A-Za-z0-9_$])states[ \t]*:[ \t]*\[[^\]]*\][ \t]*,?/g, '');
+}

package/dist/src/core/conductor.js

@@ -236,7 +236,9 @@ export class Conductor {
                     const branch = await this.remote.getRunTicketBranchName(r.runUuid);
                     if (branch) {
                         try {
-                            await this.executor.cleanupRun(branch);
+                            // Run-scoped (GAIA-183): close only this done run's own tab
+                            // (label `#<runId>`), never a sibling/concurrent run's tab.
+                            await this.executor.cleanupRun(branch, r.runId);
                         }
                         catch (err) {
                             this.logger.warn({ run: r.runUuid, err: String(err) }, 'run tab cleanup failed');
@@ -368,14 +370,11 @@ export class Conductor {
         };
         const env = resolveRunEnv(t.effectiveEnvVars, core, this.logger);
         const ws = await this.workspace.ensure(t.identifier, t.branchName, baseRef);
-        // A claimable state has no deterministic policy without a WORKFLOW.md
-        // (SKILL.md dispatch reads its `## State: <state>` sections). The human
-        // steered this to WARN-and-proceed (not a hard fail): the agent runs on
-        // engine defaults, and the gap is observable in the conductor log rather
-        // than wedging the run. `ws.instructions` IS the loaded WORKFLOW.md (null
-        // when absent), so no extra stat.
+        // A claimable state has no project policy without a WORKFLOW.md. Warn and
+        // proceed so the missing project instructions are observable without
+        // wedging the run. `ws.instructions` is the loaded file (null when absent).
         if (!ws.instructions) {
-            this.logger.warn({ ticket: t.identifier, workspace: ws.path }, 'WORKFLOW.md missing — dispatching on engine defaults');
+            this.logger.warn({ ticket: t.identifier, workspace: ws.path }, 'WORKFLOW.md missing — no project instructions dispatched');
         }
         // Lifecycle hooks are executor-owned + best-effort (GAIA-84): runHook never
         // throws, so neither call can abort dispatch or wedge a run in `claimed`.
@@ -386,12 +385,16 @@ export class Conductor {
             await this.executor.runHook('after_create', ws.path, { ticket: t.identifier }, env);
         }
         await this.executor.runHook('before_run', ws.path, { ticket: t.identifier }, env);
-        // Clear any leftover tabs of a reused workspace before starting the run.
-        await this.executor.cleanupRun(t.branchName);
+        // Clear a leftover tab for THIS run id in a reused workspace before
+        // starting it (GAIA-183): run-scoped so a still-open sibling run's tab is
+        // never killed. A fresh dispatch has no matching tab yet → a quiet no-op;
+        // a re-dispatch of the same run drops its stale duplicate before startRun
+        // re-creates it. Sibling prior-state run tabs are left to the worktree reap.
+        await this.executor.cleanupRun(t.branchName, run.runId);
         const prompt = ws.instructions
             ? renderPrompt(this.config.prompt, {
                 identifier: t.identifier,
-                state: t.state || 'triage',
+                state: t.state || 'qualification',
                 runUuid: run.runUuid,
             })
             : '';

package/dist/src/index.d.ts

@@ -1,8 +1,9 @@
 export type * from '@gaia-ai/core';
 export { conductorId } from '@gaia-ai/core';
 export { DrupalGaiaRemote, drupalRemote, FakeGaiaRemote, FakeWorkspace, fakeRemote, fakeWorkspace, GitWorkspace, gitWorkspace, selectExecutor, selectRemote, selectWorkspace, } from '@gaia-ai/core/plugins';
-export type { GaiaCliDeps } from './cli/gaia.js';
-export { main, runGaiaCli } from './cli/gaia.js';
-export type { ConductorRegistryEntry } from './cli/local-registry.js';
-export { DEFAULT_AGENT_PROMPT, loadConductorConfig } from './config.js';
+export type { ConductorRegistryEntry } from './cli/conductor-registry.js';
+export { renderGaiaConfig } from './cli/init.js';
+export { runConnectionUpgrade, runUpgrade, type UpgradeReport, } from './cli/upgrade.js';
+export { default as conductorCommandPlugin, type GaiaCliDeps, runConductorCli, } from './commands/conductor.js';
+export { composeConductorConfig, DEFAULT_AGENT_PROMPT, loadConductorConfig, } from './config.js';
 export { Conductor } from './core/conductor.js';

package/dist/src/index.js

@@ -1,5 +1,14 @@
 export { conductorId } from '@gaia-ai/core';
 export { DrupalGaiaRemote, drupalRemote, FakeGaiaRemote, FakeWorkspace, fakeRemote, fakeWorkspace, GitWorkspace, gitWorkspace, selectExecutor, selectRemote, selectWorkspace, } from '@gaia-ai/core/plugins';
-export { main, runGaiaCli } from './cli/gaia.js';
-export { DEFAULT_AGENT_PROMPT, loadConductorConfig } from './config.js';
+// GAIA-201: the connection-config template, reused by `gaia upgrade` to seed a
+// `gaia.config.js`.
+export { renderGaiaConfig } from './cli/init.js';
+// GAIA-216: the seed/migration routine, hoisted from the host so `conductor init`
+// (intra-package) and `gaia upgrade` (host→engine) share one implementation.
+export { runConnectionUpgrade, runUpgrade, } from './cli/upgrade.js';
+// GAIA-201: the conductor is now a COMMAND PLUGIN mounted by the `@gaia-ai/gaia`
+// host, not the CLI entrypoint. `main`/`runGaiaCli` are gone; the default export
+// is the `GaiaCommandPlugin`, exposed here as `./commands/conductor` too.
+export { default as conductorCommandPlugin, runConductorCli, } from './commands/conductor.js';
+export { composeConductorConfig, DEFAULT_AGENT_PROMPT, loadConductorConfig, } from './config.js';
 export { Conductor } from './core/conductor.js';

package/dist/src/preset.d.ts

@@ -0,0 +1,2 @@
+import type { GaiaPreset } from '@gaia-ai/core';
+export declare const commands: GaiaPreset['commands'];

package/dist/src/preset.js

@@ -0,0 +1,8 @@
+export const commands = (acc) => [
+    ...acc,
+    {
+        name: 'conductor',
+        plugin: '@gaia-ai/conductor/commands/conductor',
+        describe: 'node-agent lifecycle + local registry',
+    },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/conductor",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "GAIA conductor engine + CLI: registers, claims tickets via JSON:API, dispatches agents.",
   "type": "module",
   "license": "MIT",
@@ -9,6 +9,8 @@
   },
   "exports": {
     ".": "./dist/src/index.js",
+    "./preset": "./dist/src/preset.js",
+    "./commands/conductor": "./dist/src/commands/conductor.js",
     "./package.json": "./package.json"
   },
   "files": [
@@ -22,14 +24,14 @@
   "repository": {
     "type": "git",
     "url": "git+https://git.key-tec.de/keytec/gaia.git",
-    "directory": "conductor/packages/conductor"
+    "directory": "conductor/engine"
   },
   "dependencies": {
-    "@gaia-ai/core": "^0.5.4",
+    "@gaia-ai/core": "^0.6.0",
     "@dropsh/plugin-oauth2": "^0.5.7",
-    "@dropsh/plugin-jsonapi-schema": "^0.5.7",
+    "@dropsh/plugin-jsonapi-schema": "^0.5.8",
     "commander": "^12.1.0",
-    "dropsh": "^0.5.7",
+    "dropsh": "^0.5.8",
     "semver": "^7.6.0"
   }
 }

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

@@ -1,23 +0,0 @@
-import { type ConductorFileConfig, type ConductorLogger, type GaiaExecutor, type GaiaRemote, type GaiaWorkspace, type ResolvedAgent } from '@gaia-ai/core';
-import { Command } from 'commander';
-/** Test seam: inject any subset of dependencies. */
-export interface GaiaCliDeps {
-    remote?: GaiaRemote;
-    executor?: GaiaExecutor;
-    workspace?: GaiaWorkspace;
-    agents?: ResolvedAgent[];
-    config?: ConductorFileConfig;
-    /** Injectable registry fetch for the start-time version check (tests). */
-    fetch?: typeof fetch;
-}
-export declare function parseHerdrJson(output: string, command: string): unknown;
-/**
- * Start-time auth gate. Returns true if authenticated (session or session-less
- * provider); otherwise logs a single clear line and returns false. Must run
- * before remote resolution (resolveRemote), which calls resolveAuth and throws
- * when unauthenticated.
- */
-export declare function ensureAuthenticated(config: ConductorFileConfig, logger: ConductorLogger): Promise<boolean>;
-export declare function buildProgram(deps: GaiaCliDeps): Command;
-export declare function runGaiaCli(argv: string[], deps?: GaiaCliDeps): Promise<void>;
-export declare function main(argv: string[]): Promise<void>;

package/dist/src/cli/local-registry.d.ts

@@ -1,14 +0,0 @@
-export interface ConductorRegistryEntry {
-    id: string;
-    path: string;
-    project: string;
-    label: string;
-    host: 'herdr' | 'process' | 'systemd';
-    handle: string;
-}
-/** `${GAIA_HOME ?? ~}/.gaia/conductors.json`. */
-export declare function registryPath(): string;
-export declare function register(entry: ConductorRegistryEntry): Promise<void>;
-export declare function remove(id: string): Promise<void>;
-export declare function list(): Promise<ConductorRegistryEntry[]>;
-export declare function get(id: string): Promise<ConductorRegistryEntry | null>;

package/dist/src/cli/local-registry.js

@@ -1,56 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-/** `${GAIA_HOME ?? ~}/.gaia/conductors.json`. */
-export function registryPath() {
-    const home = process.env.GAIA_HOME ?? homedir();
-    return join(home, '.gaia', 'conductors.json');
-}
-async function read() {
-    let raw;
-    try {
-        raw = await readFile(registryPath(), 'utf8');
-    }
-    catch {
-        return {};
-    }
-    if (raw.trim() === '') {
-        return {};
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed === 'object' &&
-            parsed !== null &&
-            !Array.isArray(parsed)) {
-            return parsed;
-        }
-        return {};
-    }
-    catch {
-        return {};
-    }
-}
-async function write(data) {
-    const path = registryPath();
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
-}
-export async function register(entry) {
-    const data = await read();
-    data[entry.id] = entry;
-    await write(data);
-}
-export async function remove(id) {
-    const data = await read();
-    if (data[id]) {
-        delete data[id];
-        await write(data);
-    }
-}
-export async function list() {
-    return Object.values(await read());
-}
-export async function get(id) {
-    const data = await read();
-    return data[id] ?? null;
-}