@gaia-ai/conductor 0.6.0 → 0.6.1

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

@@ -5,6 +5,13 @@ export interface UpgradeReport {
     /** true when nothing needed doing. */
     alreadyCurrent: boolean;
 }
+/**
+ * GAIA-218: what `gaia upgrade` does to the PROJECT connection override. The
+ * pure routine defaults to `'skip'` (non-interactive / `conductor init`): never
+ * create, never migrate, never delete. The host CLI resolves `'create'` /
+ * `'remove'` from an opt-in TTY prompt.
+ */
+export type ProjectConnectionChoice = 'skip' | 'create' | 'remove';
 /** The outcome of routing a single connection-config file. */
 interface ConnectionUpgradeResult {
     action: string;
@@ -29,10 +36,18 @@ export declare function runConnectionUpgrade(path: string, opts?: {
     current?: number;
     chain?: ConnectionConfigMigration[];
 }): ConnectionUpgradeResult;
+/**
+ * The absolute path of the PROJECT connection override (`./.gaia/gaia.config.js`)
+ * when one exists for `cwd`, else `undefined`. Used by the host CLI to decide
+ * whether to ask "remove this override?" vs "create an override?" (GAIA-218).
+ */
+export declare function hasProjectConnection(cwd: string): string | undefined;
 /** Run the migration. Pure w.r.t. injected `cwd`/`home`; `dryRun` suppresses writes. */
 export declare function runUpgrade(opts?: {
     cwd?: string;
     home?: string;
     dryRun?: boolean;
+    /** GAIA-218: what to do with the PROJECT connection override (default skip). */
+    projectConnection?: ProjectConnectionChoice;
 }): UpgradeReport;
 export {};

package/dist/src/cli/upgrade.js

@@ -1,9 +1,11 @@
-import { chmodSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { listConductorConfigFiles, stripLegacyConnectionFromConfigSource, } from '../config.js';
 import { applyMigrations, CONNECTION_MIGRATIONS, GAIA_CONFIG_SCHEMA_VERSION, readConfigSchemaVersion, stampVersion, stripVersionHeader, } from './config-schema.js';
 import { renderGaiaConfig } from './init.js';
+import { runAddonRenameMigration } from './migrate-addon-names.js';
 const GAIA_DIR = '.gaia';
 const DEFAULT_ENGINE = 'conductor.config.js';
 const VARIANT_SUFFIX = '.conductor.config.js';
@@ -98,22 +100,86 @@ export function runConnectionUpgrade(path, opts = {}) {
         changed: true,
     };
 }
+/**
+ * The absolute path of the PROJECT connection override (`./.gaia/gaia.config.js`)
+ * when one exists for `cwd`, else `undefined`. Used by the host CLI to decide
+ * whether to ask "remove this override?" vs "create an override?" (GAIA-218).
+ */
+export function hasProjectConnection(cwd) {
+    const gaiaDir = findGaiaDir(cwd);
+    if (gaiaDir === undefined)
+        return undefined;
+    const p = join(gaiaDir, CONNECTION);
+    return existsSync(p) ? p : undefined;
+}
 /** Run the migration. Pure w.r.t. injected `cwd`/`home`; `dryRun` suppresses writes. */
 export function runUpgrade(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const home = opts.home ?? homedir();
     const dry = opts.dryRun ?? false;
+    const choice = opts.projectConnection ?? 'skip';
     const actions = [];
     let changed = false;
-    // 1. Project connection config (schema-versioned seed/migrate).
     const gaiaDir = findGaiaDir(cwd);
+    // 0. GAIA-218 (AC-7): strip legacy connection/auth (`site`/`plugins` + the
+    //    orphaned connection preamble) from EVERY engine config in the `.gaia/`
+    //    dir — the supported enumeration only, never an unrelated `*.config.js`.
+    if (gaiaDir !== undefined) {
+        for (const file of listConductorConfigFiles(gaiaDir)) {
+            const path = join(gaiaDir, file);
+            if (!existsSync(path))
+                continue;
+            const original = readFileSync(path, 'utf8');
+            const { text, removed } = stripLegacyConnectionFromConfigSource(original);
+            if (removed.length === 0)
+                continue;
+            if (dry) {
+                actions.push(`would strip ${removed.join('/')} from ${path}`);
+            }
+            else {
+                writeFileSync(`${path}.legacy.bak`, original, 'utf8');
+                writeFileSync(path, text, 'utf8');
+                actions.push(`stripped ${removed.join('/')} from ${path} (backup ${path}.legacy.bak)`);
+            }
+            changed = true;
+        }
+    }
+    // 1. Project connection config — decision-driven (GAIA-218, default skip).
     if (gaiaDir !== undefined && hasEngineConfig(gaiaDir)) {
-        const res = runConnectionUpgrade(join(gaiaDir, CONNECTION), {
-            dryRun: dry,
-            label: 'project connection config',
-        });
-        actions.push(res.action);
-        changed = changed || res.changed;
+        const projectConn = join(gaiaDir, CONNECTION);
+        if (choice === 'create') {
+            if (existsSync(projectConn)) {
+                actions.push(`project connection: unchanged (${projectConn} exists — kept, not migrated)`);
+            }
+            else {
+                const res = runConnectionUpgrade(projectConn, {
+                    dryRun: dry,
+                    label: 'project connection config',
+                });
+                actions.push(res.action);
+                changed = changed || res.changed;
+            }
+        }
+        else if (choice === 'remove') {
+            if (existsSync(projectConn)) {
+                const bak = `${projectConn}.removed.bak`;
+                if (dry) {
+                    actions.push(`would remove ${projectConn} (project connection override)`);
+                }
+                else {
+                    copyFileSync(projectConn, bak);
+                    rmSync(projectConn);
+                    actions.push(`removed ${projectConn} (project connection override; backup ${bak})`);
+                }
+                changed = true;
+            }
+            else {
+                actions.push('project connection: unchanged (no project override to remove)');
+            }
+        }
+        else {
+            actions.push('project connection: unchanged');
+        }
     }
     // 2. Machine context move (secret-bearing — never schema-migrated).
     const legacy = legacyMachinePath(home);
@@ -139,5 +205,18 @@ export function runUpgrade(opts = {}) {
     });
     actions.push(homeRes.action);
     changed = changed || homeRes.changed;
+    // 4. GAIA-224 addon rename pass over the project + home `.gaia/` configs
+    //    (connection `gaia.config.js` + every recognised engine config). Runs LAST
+    //    so a config seeded/migrated above — already on the current names — is a
+    //    zero-match no-op. Reports only the files it actually rewrites.
+    const rename = runAddonRenameMigration({
+        gaiaDirs: [
+            ...(gaiaDir === undefined ? [] : [gaiaDir]),
+            join(home, GAIA_DIR),
+        ],
+        dryRun: dry,
+    });
+    actions.push(...rename.actions);
+    changed = changed || rename.changed;
     return { actions, alreadyCurrent: !changed };
 }

package/dist/src/commands/conductor.d.ts

@@ -1,5 +1,10 @@
-import { type ConductorFileConfig, type ConductorLogger, type GaiaCommandHost, type GaiaCommandPlugin, type GaiaExecutor, type GaiaRemote, type GaiaWorkspace, type ResolvedAgent } from '@gaia-ai/core';
+import { type ConductorLogger, type GaiaCommandHost, type GaiaCommandPlugin } from '@gaia-ai/core';
 import { Command } from 'commander';
+import type { GaiaExecutor } from '../plugins/executor.js';
+import { type ResolvedAgent } from '../plugins/plugins.js';
+import type { GaiaRemote } from '../plugins/remote.js';
+import type { GaiaWorkspace } from '../plugins/workspace.js';
+import type { ConductorFileConfig } from '../types.js';
 /** Test seam: inject any subset of dependencies. */
 export interface GaiaCliDeps {
     remote?: GaiaRemote;
@@ -11,8 +16,26 @@ export interface GaiaCliDeps {
     fetch?: typeof fetch;
     /** Host contract (resolveBases); default: this install + cwd. */
     host?: GaiaCommandHost;
+    /**
+     * GAIA-222: the herdr process host behind `start` / `stop`. Defaults to the
+     * real shell-out (`realHerdrHost`) — a test MUST inject a fake, or the suite
+     * creates real workspaces + real conductor processes on the developer's
+     * machine.
+     */
+    herdr?: HerdrHost;
+}
+/**
+ * The multiplexer seam of the conductor lifecycle: start a detached foreground
+ * loop, and kill it again by its handle. One interface so both directions are
+ * injectable — `killViaHerdr` is reached by BOTH `stop` and `stop --now`.
+ */
+export interface HerdrHost {
+    spawn(label: string, cwd: string, cmd: string): Promise<void>;
+    kill(label: string): Promise<void>;
 }
 export declare function parseHerdrJson(output: string, command: string): unknown;
+/** The production host: the real `herdr` binary. */
+export declare const realHerdrHost: HerdrHost;
 /**
  * Start-time auth gate. Returns true if authenticated (session or session-less
  * provider); otherwise logs a single clear line and returns false.
@@ -20,8 +43,9 @@ export declare function parseHerdrJson(output: string, command: string): unknown
 export declare function ensureAuthenticated(config: ConductorFileConfig, logger: ConductorLogger): Promise<boolean>;
 /** Build the `conductor` subcommand tree (lifecycle + registry + init). */
 export declare function createConductorCommand(deps: GaiaCliDeps): Command;
-/** The `conductor` command plugin the host mounts (GAIA-201). It also registers
- *  the `gaia deployment` batch helper (conductor-scoped: needs remote + project). */
+/** The `conductor` command plugin the host mounts (GAIA-201). GAIA-224
+ *  (Finding 7): the `gaia deployment` batch helper is no longer registered here —
+ *  it is its own command addon, `@gaia-ai/addon-deployment`. */
 declare const conductorCommandPlugin: GaiaCommandPlugin;
 export default conductorCommandPlugin;
 /**

package/dist/src/commands/conductor.js

@@ -1,17 +1,15 @@
 import { existsSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { createInterface } from 'node:readline';
-import { CommandRunner, createLogger, exec, loadGaiaConfig, machineContextPath, readMachineContext, resolveConfigPath, setDefaultCommandRunner, } from '@gaia-ai/core';
-import { selectAgents, selectExecutor, selectRemote, selectWorkspace, } from '@gaia-ai/core/plugins';
+import { CommandRunner, createLogger, exec, getRegisteredConductor, listRegisteredConductors, loadGaiaConfig, machineContextPath, readMachineContext, registerConductor, removeConductor, resolveConfigPath, setDefaultCommandRunner, } from '@gaia-ai/core';
 import { Command } from 'commander';
 import { authStatus } from 'dropsh';
-import * as conductorRegistry from '../cli/conductor-registry.js';
-import { registerDeployment } from '../cli/deployment.js';
-import { scaffold, scaffoldGaiaConfig } from '../cli/init.js';
+import { scaffold } from '../cli/init.js';
 import { runUpgrade } from '../cli/upgrade.js';
 import { fetchUpdateNotice, printVersionLine } from '../cli/version-check.js';
 import { composeConductorConfig, loadConductorConfig } from '../config.js';
 import { Conductor } from '../core/conductor.js';
+import { selectAgents, selectExecutor, selectRemote, selectWorkspace, } from '../plugins/plugins.js';
 /** Default host bases for connection/plugin resolution when none is injected. */
 function defaultHost() {
     return { resolveBases: [import.meta.url, `${process.cwd()}/`] };
@@ -64,7 +62,7 @@ function loggerFor(checkoutRoot, log = {}) {
     setDefaultCommandRunner(new CommandRunner(logger));
     return logger;
 }
-// --- herdr host (untested: shells out to herdr) ---------------------------
+// --- herdr host (shells out to herdr; injectable via deps.herdr) -----------
 export function parseHerdrJson(output, command) {
     try {
         return JSON.parse(output);
@@ -100,6 +98,14 @@ async function killViaHerdr(label) {
         await exec('herdr', ['workspace', 'close', ws.workspace_id]);
     }
 }
+/** The production host: the real `herdr` binary. */
+export const realHerdrHost = {
+    spawn: spawnViaHerdr,
+    kill: killViaHerdr,
+};
+function herdrHostOf(deps) {
+    return deps.herdr ?? realHerdrHost;
+}
 // --- ls/status freshness ----------------------------------------------------
 const DEFAULT_FRESH_S = 120;
 function freshnessThresholdS(config) {
@@ -119,7 +125,7 @@ function classify(hub, freshS) {
     return fresh ? 'running' : 'wedged';
 }
 async function buildLsRows(remote, config, onlyId) {
-    const entries = await conductorRegistry.list();
+    const entries = await listRegisteredConductors();
     let hub = [];
     try {
         hub = await remote.listConductors('me');
@@ -249,7 +255,7 @@ async function cmdStartBody(deps, log) {
         return;
     const remote = await resolveRemote(deps, config);
     const id = conductorIdOf(config);
-    const existing = await conductorRegistry.get(id);
+    const existing = await getRegisteredConductor(id);
     if (existing) {
         const hubStatus = await remote.getConductorStatus(id);
         if (hubStatus !== null && hubStatus !== 'offline') {
@@ -258,7 +264,7 @@ async function cmdStartBody(deps, log) {
         }
     }
     const handle = `gaia-conductor:${id}`;
-    await conductorRegistry.register({
+    await registerConductor({
         id,
         path: checkoutRoot,
         project: config.project,
@@ -274,7 +280,7 @@ async function cmdStartBody(deps, log) {
         .join(' ');
     const fgCmd = `GAIA_CONDUCTOR_LOG=file gaia conductor ${fgFlags} start --foreground`.replace(/\s+/g, ' ');
     try {
-        await spawnViaHerdr(handle, checkoutRoot, fgCmd);
+        await herdrHostOf(deps).spawn(handle, checkoutRoot, fgCmd);
         logger.info({ id, handle }, 'started conductor via herdr');
     }
     catch (err) {
@@ -287,9 +293,9 @@ async function cmdStop(deps, now) {
     const remote = await resolveRemote(deps, config);
     const id = conductorIdOf(config);
     if (now) {
-        const entry = await conductorRegistry.get(id);
+        const entry = await getRegisteredConductor(id);
         if (entry && entry.host === 'herdr') {
-            await killViaHerdr(entry.handle);
+            await herdrHostOf(deps).kill(entry.handle);
             console.log(`hard-stopped conductor ${id} (${entry.handle})`);
         }
         else {
@@ -297,9 +303,9 @@ async function cmdStop(deps, now) {
         }
         return;
     }
-    const entry = await conductorRegistry.get(id);
+    const entry = await getRegisteredConductor(id);
     if (entry && entry.host === 'herdr') {
-        await killViaHerdr(entry.handle);
+        await herdrHostOf(deps).kill(entry.handle);
     }
     await remote.setConductorStatus(id, 'offline');
     console.log(`stopped conductor ${id} (offline)`);
@@ -320,7 +326,7 @@ async function cmdStatus(deps) {
 async function cmdRm(deps) {
     const config = await resolveConfig(deps);
     const id = conductorIdOf(config);
-    await conductorRegistry.remove(id);
+    await removeConductor(id);
     console.log(`removed conductor ${id} from registry`);
 }
 /** ls may run without a config file; best-effort load. */
@@ -516,15 +522,11 @@ function registerInit(conductor) {
             skipMachine: !onboarding,
             skipCommitted: !hasProject,
         });
-        // Scaffold the sibling connection config (project-local gaia.config.js)
-        // next to the engine config when setting up a repo.
-        let wroteConnection = false;
-        let connectionPath = '';
-        if (hasProject) {
-            const conn = scaffoldGaiaConfig(opts.config, opts.force);
-            wroteConnection = conn.wrote;
-            connectionPath = conn.path;
-        }
+        // GAIA-218: `conductor init` writes the ENGINE config only. It no longer
+        // scaffolds a project-local `gaia.config.js` — the global
+        // `~/.gaia/gaia.config.js` (seeded by the reachability step below) is the
+        // default connection every repo inherits; a project override is opt-in
+        // via `gaia upgrade`.
         if (!onboarding) {
             console.log(`machine context found (${machinePath}) → setting up project only`);
             if (typeof existing.base_url !== 'string' ||
@@ -545,20 +547,19 @@ function registerInit(conductor) {
             console.log(res.wroteCommitted
                 ? `wrote ${res.committedPath} (engine)`
                 : `kept ${res.committedPath} (exists — pass --force to replace)`);
-            console.log(wroteConnection
-                ? `wrote ${connectionPath} (connection)`
-                : `kept ${connectionPath} (exists — pass --force to replace)`);
-            // GAIA-216: make the split-config seed reachable from `init` itself —
-            // migrate a legacy machine context and seed the home connection config
+            // GAIA-216/218: make the split-config seed reachable from `init` itself
+            // — migrate a legacy machine context and seed the HOME connection config
             // so an install can never be left with an engine config and no
-            // connection config. Idempotent: a fresh init reports these as kept.
-            // `home` is derived from the machine-context path (canonical
-            // `<home>/.gaia/machine.config.js`) so the home-side steps target the
-            // same home the context lives in — real home in production, isolated
-            // when `--machine-path` overrides it.
+            // connection config. `projectConnection: 'skip'` keeps `init` from
+            // writing a project override (the global connection is the default;
+            // overrides are opt-in via `gaia upgrade`). Idempotent: a fresh init
+            // reports these as kept. `home` is derived from the machine-context path
+            // (canonical `<home>/.gaia/machine.config.js`) so the home-side steps
+            // target the same home the context lives in.
             const reach = runUpgrade({
                 cwd: dirname(dirname(opts.config)),
                 home: dirname(dirname(machinePath)),
+                projectConnection: 'skip',
             });
             for (const line of reach.actions)
                 console.log(line);
@@ -577,22 +578,15 @@ function registerInit(conductor) {
             '  gaia dropsh auth status   # both profiles present');
     });
 }
-/** The `conductor` command plugin the host mounts (GAIA-201). It also registers
- *  the `gaia deployment` batch helper (conductor-scoped: needs remote + project). */
+/** The `conductor` command plugin the host mounts (GAIA-201). GAIA-224
+ *  (Finding 7): the `gaia deployment` batch helper is no longer registered here —
+ *  it is its own command addon, `@gaia-ai/addon-deployment`. */
 const conductorCommandPlugin = {
     kind: 'command',
     name: 'conductor',
     describe: 'node-agent lifecycle + local registry',
     register(program, host) {
-        const deps = { host };
-        program.addCommand(createConductorCommand(deps));
-        registerDeployment(program, async () => {
-            const config = await resolveConfig(deps);
-            return resolveRemote(deps, config);
-        }, async () => {
-            const config = await resolveConfig(deps);
-            return config.project;
-        }, () => process.cwd());
+        program.addCommand(createConductorCommand({ host }));
     },
 };
 export default conductorCommandPlugin;
@@ -604,13 +598,6 @@ export function buildConductorProgram(deps = {}) {
     const program = new Command();
     program.name('gaia').description('GAIA conductor + client CLI');
     program.addCommand(createConductorCommand(deps));
-    registerDeployment(program, async () => {
-        const config = await resolveConfig(deps);
-        return resolveRemote(deps, config);
-    }, async () => {
-        const config = await resolveConfig(deps);
-        return config.project;
-    }, () => process.cwd());
     return program;
 }
 /** Parse argv against the conductor program (test entry). */

package/dist/src/config.d.ts

@@ -1,4 +1,6 @@
-import { type AgentCandidate, type ConductorEngineConfig, type ConductorFileConfig, type GaiaConnectionConfig } from '@gaia-ai/core';
+import { type GaiaConnectionConfig } from '@gaia-ai/core';
+import type { AgentCandidate } from './plugins/plugins.js';
+import type { ConductorEngineConfig, ConductorFileConfig } from './types.js';
 export { findGaiaDir, resolveConfigPath, } from '@gaia-ai/core';
 /**
  * Default agent prompt - the project instruction contract. One run works EXACTLY one state;
@@ -87,3 +89,15 @@ export declare function listConductorConfigFiles(gaiaDir: string): string[];
  * `substates:`/other key containing "states" is not matched.
  */
 export declare function stripStatesFromConfigSource(source: string): string;
+/**
+ * Strip the `site:` and `plugins:` properties from an engine config's
+ * `export default { … }` (with their leading comment/whitespace), plus the
+ * now-orphaned connection preamble consts. Returns the rewritten source and the
+ * list of object keys removed (`[]` — source returned unchanged — when there is
+ * nothing connection-related to remove). remote/executor/agent/workspace/hooks/
+ * project/machine_id/loadLocal are left intact.
+ */
+export declare function stripLegacyConnectionFromConfigSource(source: string): {
+    text: string;
+    removed: string[];
+};