@gaia-ai/conductor 0.5.5 → 0.6.1

package/dist/src/config.js

@@ -1,17 +1,21 @@
-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';
+import { narrowConductorContributions } from './plugins/preset.js';
+// 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 +38,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 ` +
-    `(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.`;
+export const DEFAULT_AGENT_PROMPT = `You are working ticket {identifier}, current state: {state}. Read the ticket and all comments ` +
+    `(gaia dropsh --format md read gaia_ticket/gaia_ticket/$GAIA_ID --include comments), ` +
+    `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 +74,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 +136,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 +154,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.
- */
-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()).
+ * 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).
  */
-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));
@@ -278,14 +170,23 @@ export async function loadConductorConfig(configFile) {
     if (!isRecord(raw)) {
         throw new Error('conductor config default export must be an object');
     }
+    // GAIA-218 (AC-6): the engine config must not carry connection/auth material.
+    // A legacy config still declaring `site`/`plugins` gets exactly ONE actionable
+    // warning naming the file + the offending key(s); the values are never merged
+    // (`ConductorEngineConfig` omits both structurally).
+    const leftover = ['site', 'plugins'].filter((k) => k in raw);
+    if (leftover.length > 0) {
+        console.warn(`warning: ${configPath} declares ${leftover.join('/')} — ignored; ` +
+            'auth/connection belong in the sibling gaia.config.js (GAIA-218)');
+    }
     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 +199,51 @@ 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).
+    // GAIA-224: `discoverAddons` is surface-AGNOSTIC — it returns opaque
+    // accumulators. This is the single, reviewed narrowing seam where the engine
+    // reinterprets them as its own concrete conductor contributions; the runtime
+    // `.kind` guard inside `resolveConductorSlots` still fails loudly on a
+    // mis-declared contribution.
+    const discovered = narrowConductorContributions(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 +258,323 @@ 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, '');
+}
+// ---------------------------------------------------------------------------
+// GAIA-218 (AC-7): strip legacy connection/auth from an ENGINE config source.
+//
+// Unlike `stripStatesFromConfigSource`'s flat `\[[^\]]*\]` regex (nested-unsafe),
+// this is a balanced-delimiter, comment-aware source transform. The engine
+// config's `plugins: [ … ]` array holds nested `{}` (oauth2 profiles AND
+// `@gaia-ai/addon-essentials`), a sibling `agent: [ … ]` array, and the word
+// "plugins" also appears in comments — so the removal keys on the REAL `site:` /
+// `plugins:` *properties* of the default-export object, scanning each value from
+// its opening delimiter to the matching close while skipping string/comment
+// bytes. It also removes the now-orphaned connection preamble consts
+// (`baseUrl`/`clientId`/`clientSecret`) and a connection-only `loadMachine`
+// (with its `const machine = await loadMachine()`) when they become unreferenced.
+// ---------------------------------------------------------------------------
+const CLOSER = { '{': '}', '[': ']', '(': ')' };
+/** Skip a `//`-line comment; return the index of the terminating newline (or EOF). */
+function skipLineComment(src, i) {
+    const nl = src.indexOf('\n', i);
+    return nl === -1 ? src.length : nl;
+}
+/** Skip a `/* *\/` block comment; return the index just past it. */
+function skipBlockComment(src, i) {
+    const end = src.indexOf('*/', i + 2);
+    return end === -1 ? src.length : end + 2;
+}
+/** Skip a string/template literal (honouring `\` escapes and `${ … }`
+ *  interpolations in backtick strings); return the index just past the close. */
+function skipString(src, i) {
+    const quote = src[i];
+    i++;
+    while (i < src.length) {
+        const c = src[i];
+        if (c === '\\') {
+            i += 2;
+            continue;
+        }
+        if (quote === '`' && c === '$' && src[i + 1] === '{') {
+            i = matchDelimiter(src, i + 1) + 1;
+            continue;
+        }
+        if (c === quote)
+            return i + 1;
+        i++;
+    }
+    return i;
+}
+/** Given the index of an opening `{`/`[`/`(`, return the index of its matching
+ *  close, skipping nested delimiters, strings and comments. -1 if unbalanced. */
+function matchDelimiter(src, openIdx) {
+    const stack = [CLOSER[src[openIdx]]];
+    let i = openIdx + 1;
+    while (i < src.length && stack.length > 0) {
+        const c = src[i];
+        if (c === '/' && src[i + 1] === '/') {
+            i = skipLineComment(src, i);
+            continue;
+        }
+        if (c === '/' && src[i + 1] === '*') {
+            i = skipBlockComment(src, i);
+            continue;
+        }
+        if (c === "'" || c === '"' || c === '`') {
+            i = skipString(src, i);
+            continue;
+        }
+        if (c === '{' || c === '[' || c === '(') {
+            stack.push(CLOSER[c]);
+            i++;
+            continue;
+        }
+        if (c === '}' || c === ']' || c === ')') {
+            if (c === stack[stack.length - 1])
+                stack.pop();
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return stack.length === 0 ? i - 1 : -1;
+}
+/** Skip whitespace + comments starting at `i` (bounded by `limit`). */
+function skipTrivia(src, i, limit) {
+    while (i < limit) {
+        const c = src[i];
+        if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
+            i++;
+            continue;
+        }
+        if (c === '/' && src[i + 1] === '/') {
+            i = skipLineComment(src, i);
+            continue;
+        }
+        if (c === '/' && src[i + 1] === '*') {
+            i = skipBlockComment(src, i);
+            continue;
+        }
+        break;
+    }
+    return i;
+}
+/** Read a property key (bare identifier or quoted string) at `i`. */
+function readKey(src, i) {
+    const c = src[i];
+    if (c === "'" || c === '"') {
+        const end = skipString(src, i);
+        return { name: src.slice(i + 1, end - 1), end };
+    }
+    const m = /^[A-Za-z0-9_$]+/.exec(src.slice(i));
+    if (m)
+        return { name: m[0], end: i + m[0].length };
+    return { end: i };
+}
+/** From `from`, scan to just past the next top-level `,` (or to `limit` when the
+ *  value runs to the object close), skipping nested delimiters/strings/comments. */
+function scanToTopLevelComma(src, from, limit) {
+    let i = from;
+    while (i < limit) {
+        const c = src[i];
+        if (c === '/' && src[i + 1] === '/') {
+            i = skipLineComment(src, i);
+            continue;
+        }
+        if (c === '/' && src[i + 1] === '*') {
+            i = skipBlockComment(src, i);
+            continue;
+        }
+        if (c === "'" || c === '"' || c === '`') {
+            i = skipString(src, i);
+            continue;
+        }
+        if (c === '{' || c === '[' || c === '(') {
+            i = matchDelimiter(src, i) + 1;
+            continue;
+        }
+        if (c === ',')
+            return i + 1;
+        i++;
+    }
+    return limit;
+}
+/** Locate the `export default { … }` object; return the body span (exclusive of
+ *  the braces) or undefined when the default export is not an object literal. */
+function findDefaultExportObject(src) {
+    const m = /export\s+default\s*/.exec(src);
+    if (!m)
+        return undefined;
+    const braceIdx = m.index + m[0].length;
+    if (src[braceIdx] !== '{')
+        return undefined;
+    const end = matchDelimiter(src, braceIdx);
+    if (end === -1)
+        return undefined;
+    return { bodyStart: braceIdx + 1, bodyEnd: end };
+}
+/** Enumerate the top-level properties of the object body [bodyStart, bodyEnd). */
+function scanTopLevelProperties(src, bodyStart, bodyEnd) {
+    const entries = [];
+    let i = bodyStart;
+    while (i < bodyEnd) {
+        const entryStart = i;
+        const keyPos = skipTrivia(src, i, bodyEnd);
+        if (keyPos >= bodyEnd)
+            break;
+        const key = readKey(src, keyPos);
+        let j = skipTrivia(src, key.end, bodyEnd);
+        if (src[j] !== ':') {
+            // Not a `key: value` property (spread/computed/shorthand) — keep it.
+            const term = scanToTopLevelComma(src, keyPos, bodyEnd);
+            entries.push({ key: undefined, start: entryStart, end: term });
+            i = term;
+            continue;
+        }
+        j++;
+        const term = scanToTopLevelComma(src, j, bodyEnd);
+        entries.push({ key: key.name, start: entryStart, end: term });
+        i = term;
+    }
+    return entries;
+}
+/** Count word-boundary occurrences of an identifier in the source. */
+function countIdent(src, name) {
+    const re = new RegExp(`(?<![A-Za-z0-9_$])${name}(?![A-Za-z0-9_$])`, 'g');
+    return (src.match(re) ?? []).length;
+}
+/** Remove a single-line `const <name> = …;` declaration (no-op if absent). */
+function removeConstDecl(src, name) {
+    const re = new RegExp(`^[ \\t]*const ${name}\\b[^\\n]*\\n`, 'm');
+    return src.replace(re, '');
+}
+/** Remove an `[async ]function <name>(…) { … }` declaration (balanced body). */
+function removeFunctionDecl(src, name) {
+    const re = new RegExp(`(?:async[ \\t]+)?function[ \\t]+${name}[ \\t]*\\(`);
+    const m = re.exec(src);
+    if (!m)
+        return src;
+    const braceIdx = src.indexOf('{', m.index);
+    if (braceIdx === -1)
+        return src;
+    const end = matchDelimiter(src, braceIdx);
+    if (end === -1)
+        return src;
+    let e = end + 1;
+    if (src[e] === '\n')
+        e++;
+    return src.slice(0, m.index) + src.slice(e);
+}
+/**
+ * Is `machine` referenced anywhere OTHER than its own `const machine = …;` decl
+ * and inside the `loadMachine` function body? (The body's `…/machine.config.js`
+ * path string must not count as a live reference.) Used to decide whether a
+ * connection-only `loadMachine` has become orphaned.
+ */
+function machineReferencedElsewhere(src) {
+    let probe = removeFunctionDecl(src, 'loadMachine');
+    probe = removeConstDecl(probe, 'machine');
+    return countIdent(probe, 'machine') > 0;
+}
+/** Drop connection preamble that is orphaned once `site`/`plugins` are gone. */
+function removeOrphanedPreamble(src) {
+    let text = src;
+    for (const name of ['baseUrl', 'clientId', 'clientSecret']) {
+        if (countIdent(text, name) <= 1)
+            text = removeConstDecl(text, name);
+    }
+    // A connection-only `loadMachine`: remove `const machine = await loadMachine()`
+    // + the function itself only when `machine` is otherwise unreferenced (so an
+    // engine config that still composes `machine_id` from `machine.user_id` keeps
+    // its loadMachine — the "connection-only" qualifier).
+    if (/\bconst machine\b/.test(text) &&
+        /\bfunction loadMachine\b/.test(text) &&
+        !machineReferencedElsewhere(text)) {
+        text = removeConstDecl(text, 'machine');
+        text = removeFunctionDecl(text, 'loadMachine');
+    }
+    return text;
+}
+/**
+ * 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 function stripLegacyConnectionFromConfigSource(source) {
+    const obj = findDefaultExportObject(source);
+    if (!obj)
+        return { text: source, removed: [] };
+    const entries = scanTopLevelProperties(source, obj.bodyStart, obj.bodyEnd);
+    const targets = new Set(['site', 'plugins']);
+    const toRemove = entries.filter((e) => e.key !== undefined && targets.has(e.key));
+    if (toRemove.length === 0)
+        return { text: source, removed: [] };
+    let text = source;
+    for (const e of [...toRemove].sort((a, b) => b.start - a.start)) {
+        text = text.slice(0, e.start) + text.slice(e.end);
+    }
+    text = removeOrphanedPreamble(text);
+    // Report in source order for a stable `site/plugins` message.
+    const removed = ['site', 'plugins'].filter((k) => toRemove.some((e) => e.key === k));
+    return { text, removed };
+}

package/dist/src/contract.d.ts

@@ -0,0 +1,8 @@
+export { type AgentFootprint, emptyAgentFootprint, type GaiaAgent, } from './plugins/agent.js';
+export type { ExecutorCapabilities, GaiaExecutor, HookContext, HookName, SpawnedSession, SpawnRunInput, } from './plugins/executor.js';
+export type { AgentCandidate, AgentPlugin, ExecutorDeps, ExecutorPlugin, RemotePlugin, ResolvedAgent, WorkspacePlugin, } from './plugins/plugins.js';
+export { selectAgent, selectAgents, selectExecutor, selectRemote, selectWorkspace, } from './plugins/plugins.js';
+export { type ConductorAddonEntry, type ConductorContributions, narrowConductorContributions, type Preset, } from './plugins/preset.js';
+export type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunMetrics, RunWriteAttributes, Ticket, UncleanTicket, } from './plugins/remote.js';
+export type { EnsuredWorkspace, GaiaWorkspace, } from './plugins/workspace.js';
+export type { ConductorEngineConfig, ConductorFileConfig, ConductorSettings, } from './types.js';

package/dist/src/contract.js

@@ -0,0 +1,16 @@
+// GAIA-224 (Finding 6): the CONDUCTOR-SURFACE CONTRACT, exposed as the
+// runtime-light subpath `@gaia-ai/conductor/contract`.
+//
+// This is the module a conductor-surface addon (`addons/remote-drupal`,
+// `addons/workspace-git`, `addons/herdr`, `addons/claude`, …) imports. It carries
+// ONLY the surface interfaces, the config contract, the preset view, and the two
+// tiny runtime helpers (`emptyAgentFootprint`, the `select*` slot selectors) — it
+// imports NO engine, NO commander, NO dropsh runtime. Importing it therefore
+// costs an addon nothing at boot, unlike the package main (`@gaia-ai/conductor`),
+// which pulls the whole run engine + the `conductor` command plugin.
+//
+// The package main re-exports everything here too, so `import type { GaiaRemote }
+// from '@gaia-ai/conductor'` keeps working for type-only consumers.
+export { emptyAgentFootprint, } from './plugins/agent.js';
+export { selectAgent, selectAgents, selectExecutor, selectRemote, selectWorkspace, } from './plugins/plugins.js';
+export { narrowConductorContributions, } from './plugins/preset.js';

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

@@ -1,4 +1,9 @@
-import { type ConductorFileConfig, type ConductorLogger, type GaiaExecutor, type GaiaRemote, type GaiaWorkspace, type ResolvedAgent } from '@gaia-ai/core';
+import { type ConductorLogger } from '@gaia-ai/core';
+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';
 /**
  * Resolve the environment a run executes in (GAIA-99): parse the ticket's
  * effective env_vars, drop any reserved key (loud warn — key NAME only, never
@@ -66,5 +71,15 @@ export declare class Conductor {
     reap(): Promise<void>;
     private dispatch;
     serve(signal?: AbortSignal): Promise<void>;
+    /**
+     * True once this conductor's own checkout has been removed from disk (its
+     * worktree was reaped while the process kept running). Such a conductor is a
+     * pure liability: it still heartbeats and still claims runs, but every
+     * dispatch fails — no git command and no relative path can resolve from a
+     * deleted directory — so each claim burns one attempt and three of them park
+     * the ticket behind the circuit breaker. Observed as 30 orphans claiming and
+     * failing tickets they could never dispatch.
+     */
+    private checkoutGone;
     private pollLoop;
 }