@gaia-ai/core 0.6.0 → 0.6.1

package/README.md

@@ -1,5 +1,5 @@
 # @gaia-ai/core
 
-GAIA global contract: plugin API, built-in remotes/workspaces/auth, shared primitives.
+GAIA surface-agnostic kernel: host contract, split-config helpers, addon preset/discovery machinery, shared primitives.
 
-Part of the GAIA conductor. Install the meta package `@gaia-ai/gaia` to get the `gaia` CLI with all plugins. Source: https://git.key-tec.de/keytec/gaia (conductor/).
+Part of the GAIA CLI. Install the meta package `@gaia-ai/gaia` to get the `gaia` CLI with all addons. Source: https://git.key-tec.de/keytec/gaia (gaia-cli/).

package/dist/src/cli/load-gaia-config.js

@@ -80,7 +80,14 @@ export async function loadGaiaConfig(host, opts = {}) {
     const site = isRecord(raw.site) ? raw.site : {};
     const baseUrl = typeof site.base_url === 'string' ? site.base_url : '';
     if (baseUrl.trim() === '') {
-        throw new Error(`gaia connection config requires site.base_url (${configPath})`);
+        // GAIA-218 (AC-9): a legible failure that names the resolved connection path
+        // and the file that was expected to supply `site.base_url`, so a mis-resolved
+        // or empty connection is diagnosable — never a downstream plugin error (auth
+        // no longer lives in the engine config, so no plugin resolution runs here).
+        const expected = resolution.fallback
+            ? 'the shipped machine-context fallback resolved no base_url — run `gaia conductor init` or create ~/.gaia/gaia.config.js'
+            : 'expected a gaia.config.js (project ./.gaia/gaia.config.js or home ~/.gaia/gaia.config.js) declaring site.base_url';
+        throw new Error(`gaia connection config requires site.base_url — resolved ${configPath}; ${expected}`);
     }
     const jsonapiPrefix = typeof site.jsonapi_prefix === 'string' && site.jsonapi_prefix.trim() !== ''
         ? site.jsonapi_prefix

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

@@ -28,7 +28,7 @@ export declare class CommandRunner {
 /**
  * Replace the module-level singleton runner used by {@link exec}.
  *
- * Note: out-of-package plugins (e.g. `@gaia-ai/plugin-herdr`) import `exec` via
+ * Note: out-of-package plugins (e.g. `@gaia-ai/addon-herdr`) import `exec` via
  * the `@gaia-ai/gaia/plugin` barrel, which resolves to the built `dist/`
  * copy of this module. This means `setDefaultCommandRunner` only shares the
  * runner with those plugins when the conductor itself runs from `dist`

package/dist/src/core/exec.js

@@ -64,7 +64,7 @@ let defaultRunner = new CommandRunner(noopLogger);
 /**
  * Replace the module-level singleton runner used by {@link exec}.
  *
- * Note: out-of-package plugins (e.g. `@gaia-ai/plugin-herdr`) import `exec` via
+ * Note: out-of-package plugins (e.g. `@gaia-ai/addon-herdr`) import `exec` via
  * the `@gaia-ai/gaia/plugin` barrel, which resolves to the built `dist/`
  * copy of this module. This means `setDefaultCommandRunner` only shares the
  * runner with those plugins when the conductor itself runs from `dist`

package/dist/src/index.d.ts

@@ -11,14 +11,6 @@ export { CommandRunner, ExecError, exec, setDefaultCommandRunner, } from './core
 export { type ConductorLogger, createLogger } from './core/logger.js';
 export { shellQuote } from './core/shell.js';
 export { DEFAULT_SLUG_MAX_LENGTH, slugify } from './core/slug.js';
-export { type AgentFootprint, emptyAgentFootprint, type GaiaAgent, } from './plugins/agent/agent.js';
 export { discoverAddons, type ResolvedConductorSlots, resolveConductorSlots, } from './plugins/discover-addons.js';
-export type * from './plugins/executor/executor.js';
-export type { AgentCandidate, AgentPlugin, ExecutorDeps, ExecutorPlugin, RemotePlugin, ResolvedAgent, WorkspacePlugin, } from './plugins/plugins.js';
-export { selectAgent, selectAgents } from './plugins/plugins.js';
-export { type AddonEntry, type CommandDescriptor, type DiscoveredContributions, emptyContributions, type GaiaPreset, type GaiaSurface, PRESET_FUNCTION_KEYS, SURFACE_KEYS, } from './plugins/preset.js';
-export type * from './plugins/remote/remote.js';
-export { loadInstructions } from './plugins/workspace/instructions.js';
-export type { EnsuredWorkspace, GaiaWorkspace, } from './plugins/workspace/workspace.js';
-export type * from './types.js';
+export { type AddonEntry, type CommandDescriptor, type DiscoveredContributions, emptyContributions, type GaiaPreset, type GaiaSurface, type OpaqueAccumulator, PRESET_FUNCTION_KEYS, SURFACE_KEYS, } from './plugins/preset.js';
 export { type ExpandedLoad, expandLoad, type InputDecl, parseStepValues, readSkillWhen, type SkillContract, type SkillWhen, StepContractError, type StepValues, type Triple, validateLoad, type WhenValue, WORKFLOW_STEPS, type WorkflowStep, } from './workflow/step-contract.js';

package/dist/src/index.js

@@ -9,14 +9,20 @@ export { CommandRunner, ExecError, exec, setDefaultCommandRunner, } from './core
 export { createLogger } from './core/logger.js';
 export { shellQuote } from './core/shell.js';
 export { DEFAULT_SLUG_MAX_LENGTH, slugify } from './core/slug.js';
-export { emptyAgentFootprint, } from './plugins/agent/agent.js';
 // GAIA-215: the Storybook-style preset contract + the shared addon discovery.
+// GAIA-224 (Finding 6): SURFACE-AGNOSTIC only. The conductor-surface interfaces
+// (`GaiaRemote`/`GaiaExecutor`/`GaiaWorkspace`/`GaiaAgent`, the four `*Plugin`
+// interfaces, `ExecutorDeps`, `AgentCandidate`/`ResolvedAgent`, the `select*`
+// selectors), the config contract (`ConductorSettings`/`ConductorFileConfig`/
+// `ConductorEngineConfig`) and every built-in IMPLEMENTATION have moved out of
+// this kernel — the contract to `@gaia-ai/conductor` (subpath
+// `@gaia-ai/conductor/contract`), the impls to their own addons
+// (`@gaia-ai/addon-remote-drupal`, `@gaia-ai/addon-workspace-git`,
+// `@gaia-ai/addon-auth-basic`, `@gaia-ai/addon-fake`). `loadInstructions` moved to
+// `@gaia-ai/addon-workspace-git`. Core ships NO plugin implementations.
 export { discoverAddons, resolveConductorSlots, } from './plugins/discover-addons.js';
-export { selectAgent, selectAgents } from './plugins/plugins.js';
 export { emptyContributions, PRESET_FUNCTION_KEYS, SURFACE_KEYS, } from './plugins/preset.js';
 // GAIA-194 AC-2: the agent-host contract (`AgentLaunchHost` / `HostedAgent` /
-// `supportsAgentHost`) moved OUT of core — it is the TUI renderer's own plugin
-// seam (`@gaia-ai/plugin-gaia-ui`), and herdr types its impl locally. Core is
-// the conductor engine contract only.
-export { loadInstructions } from './plugins/workspace/instructions.js';
+// `supportsAgentHost`) is likewise NOT here — it is the TUI renderer's own plugin
+// seam (`@gaia-ai/addon-gaia-ui`), and herdr types its impl locally.
 export { expandLoad, parseStepValues, readSkillWhen, StepContractError, validateLoad, WORKFLOW_STEPS, } from './workflow/step-contract.js';

package/dist/src/plugins/discover-addons.d.ts

@@ -1,5 +1,4 @@
 import type { ConductorLogger } from '../core/logger.js';
-import type { AgentCandidate, ExecutorPlugin, RemotePlugin, WorkspacePlugin } from './plugins.js';
 import { type AddonEntry, type DiscoveredContributions, type GaiaSurface } from './preset.js';
 /**
  * Discover + accumulate the `entries` for one `surface`. `bases` is the
@@ -11,12 +10,24 @@ import { type AddonEntry, type DiscoveredContributions, type GaiaSurface } from
 export declare function discoverAddons(entries: AddonEntry[] | undefined, surface: GaiaSurface, bases: string[], opts?: {
     logger?: ConductorLogger;
 }): Promise<DiscoveredContributions>;
-/** The resolved conductor slots (last-wins singletons + agent candidate list). */
-export interface ResolvedConductorSlots {
-    remote?: RemotePlugin;
-    executor?: ExecutorPlugin;
-    workspace?: WorkspacePlugin;
-    agents: AgentCandidate[];
+/**
+ * The resolved conductor slots (last-wins singletons + agent candidate list).
+ * Generic over the four element types so the kernel stays surface-agnostic while
+ * the caller keeps full type-safety: the engine passes its narrowed
+ * `ConductorContributions` (see `@gaia-ai/conductor`'s
+ * `narrowConductorContributions`) and gets `RemotePlugin`/`ExecutorPlugin`/
+ * `WorkspacePlugin`/`AgentCandidate` back.
+ */
+export interface ResolvedConductorSlots<R = unknown, E = unknown, W = unknown, A = unknown> {
+    remote?: R;
+    executor?: E;
+    workspace?: W;
+    agents: A[];
 }
 /** Resolve discovered conductor contributions into the four engine slots. */
-export declare function resolveConductorSlots(contributions: DiscoveredContributions, logger?: ConductorLogger): ResolvedConductorSlots;
+export declare function resolveConductorSlots<R, E, W, A>(contributions: {
+    remotes: R[];
+    executors: E[];
+    workspaces: W[];
+    agents: A[];
+}, logger?: ConductorLogger): ResolvedConductorSlots<R, E, W, A>;

package/dist/src/plugins/discover-addons.js

@@ -19,6 +19,13 @@
 // export adapted as a single contribution, logged) → run the surface's
 // accumulators with the entry's `with` → for `agents`, attach the entry's
 // `priority`. The runtime `.kind` guard is retained at singleton resolution.
+//
+// GAIA-224 (Finding 6, decision 7): surface-AGNOSTIC. The per-surface
+// accumulators are opaque `unknown[]` here (their element types belong to the
+// surface owner — `@gaia-ai/conductor` for the conductor surface), so this module
+// keeps zero `@gaia-ai/*` edges. Everything it needs from a contribution is
+// structural: the `.kind` tag for the singleton guard, `.id` for the warn line,
+// and `.priority` for the agent-candidate attach.
 import { pathToFileURL } from 'node:url';
 import { resolveModuleEslintStyle } from '../cli/resolve-module.js';
 import { emptyContributions, PRESET_FUNCTION_KEYS, SURFACE_KEYS, } from './preset.js';
@@ -205,12 +212,15 @@ function resolveSingleton(list, kind, logger) {
         return undefined;
     const warn = warnFrom(logger);
     if (list.length > 1) {
-        const ids = list.map((p) => p.id ?? '<?>').join(', ');
+        const ids = list
+            .map((p) => p.id ?? '<?>')
+            .join(', ');
         warn(`${kind}: ${list.length} addons contributed a ${kind} ([${ids}]); using the last (override wins)`);
     }
     const picked = list[list.length - 1];
-    if (picked.kind !== kind) {
-        throw new Error(`addon contributed a '${picked.kind}' into the ${kind} slot`);
+    const pickedKind = picked.kind;
+    if (pickedKind !== kind) {
+        throw new Error(`addon contributed a '${String(pickedKind)}' into the ${kind} slot`);
     }
     return picked;
 }

package/dist/src/plugins/preset.d.ts

@@ -1,6 +1,4 @@
 import type { DropSHPlugin } from 'dropsh/plugin';
-import type { AgentCandidate, ExecutorPlugin, RemotePlugin, WorkspacePlugin } from './plugins.js';
-import type { Ticket } from './remote/remote.js';
 /**
  * A lazy command pointer (moved here from the host, GAIA-201, + `describe`). The
  * command surface accumulates DESCRIPTORS — never constructed command plugins —
@@ -35,8 +33,15 @@ export type AddonEntry = string | {
     with?: unknown;
     /** Alias for `with`. */
     options?: unknown;
-    /** Agent-surface only: the static per-ticket priority (see `selectAgent`). */
-    priority?: (ticket: Ticket) => number;
+    /**
+     * Agent-surface only: the static per-ticket priority (see the conductor
+     * surface's `selectAgent`). The ticket type belongs to the conductor
+     * surface, so the kernel types the parameter as `never` — that makes ANY
+     * concretely-typed `(ticket: Ticket) => number` assignable here (a `never`
+     * parameter is contravariantly assignable to every parameter type) while
+     * keeping this module free of a conductor import.
+     */
+    priority?: (ticket: never) => number;
 };
 /**
  * The accumulated contributions across an `addons[]` list, one array per
@@ -46,12 +51,25 @@ export type AddonEntry = string | {
  */
 export interface DiscoveredContributions {
     commands: CommandDescriptor[];
-    remotes: RemotePlugin[];
-    executors: ExecutorPlugin[];
-    workspaces: WorkspacePlugin[];
-    agents: AgentCandidate[];
+    /** Opaque: `RemotePlugin[]` on the conductor surface. */
+    remotes: unknown[];
+    /** Opaque: `ExecutorPlugin[]` on the conductor surface. */
+    executors: unknown[];
+    /** Opaque: `WorkspacePlugin[]` on the conductor surface. */
+    workspaces: unknown[];
+    /** Opaque: `AgentCandidate[]` on the conductor surface. */
+    agents: unknown[];
     connectionPlugins: DropSHPlugin[];
 }
+/**
+ * An OPAQUE per-surface accumulator. The kernel threads it without knowing its
+ * element type; the surface owner declares the concrete signature (see
+ * `@gaia-ai/conductor`'s `Preset`). `never[]` on the input side is deliberate:
+ * it keeps a concretely-typed accumulator such as
+ * `(acc: RemotePlugin[], opts) => RemotePlugin[]` structurally assignable to
+ * this opaque form, so a conductor-surface `Preset` still satisfies `GaiaPreset`.
+ */
+export type OpaqueAccumulator<O> = (acc: never[], opts: O) => unknown[] | Promise<unknown[]>;
 /** The extension points each surface runs (the preset function names to call). */
 export declare const SURFACE_KEYS: Record<GaiaSurface, Array<keyof DiscoveredContributions>>;
 /**
@@ -64,10 +82,10 @@ export interface GaiaPreset<O = unknown> {
     /** Meta-addon composition: children apply depth-first BEFORE this preset. */
     addons?: AddonEntry[];
     commands?: (acc: CommandDescriptor[], opts: O) => CommandDescriptor[] | Promise<CommandDescriptor[]>;
-    remotes?: (acc: RemotePlugin[], opts: O) => RemotePlugin[] | Promise<RemotePlugin[]>;
-    executors?: (acc: ExecutorPlugin[], opts: O) => ExecutorPlugin[] | Promise<ExecutorPlugin[]>;
-    workspaces?: (acc: WorkspacePlugin[], opts: O) => WorkspacePlugin[] | Promise<WorkspacePlugin[]>;
-    agents?: (acc: AgentCandidate[], opts: O) => AgentCandidate[] | Promise<AgentCandidate[]>;
+    remotes?: OpaqueAccumulator<O>;
+    executors?: OpaqueAccumulator<O>;
+    workspaces?: OpaqueAccumulator<O>;
+    agents?: OpaqueAccumulator<O>;
     connectionPlugins?: (acc: DropSHPlugin[], opts: O) => DropSHPlugin[] | Promise<DropSHPlugin[]>;
 }
 /** The preset function keys, for shape-detection during discovery. */

package/dist/src/plugins/preset.js

@@ -14,6 +14,16 @@
 // Settings (machine_id / project / states / hooks / scheduler) are NEVER
 // preset-contributed — identity must not be composable — so this interface has
 // no such members and an unknown preset export is rejected loudly at discovery.
+//
+// GAIA-224 (Finding 6, decision 7): this module is surface-AGNOSTIC. It knows
+// the accumulator NAMES of every surface (`SURFACE_KEYS`) and the shape of the
+// pure-data command surface (`CommandDescriptor`), but the element types of the
+// CONDUCTOR surface (`RemotePlugin` / `ExecutorPlugin` / `WorkspacePlugin` /
+// `AgentCandidate`, and the `Ticket` an agent priority scores) live in
+// `@gaia-ai/conductor`. Importing them here would give the kernel an
+// `@gaia-ai/*` edge, which the acyclic guard forbids — so those four
+// accumulators are OPAQUE (see `OpaqueAccumulator`) and the concrete view is
+// declared by the surface owner (`@gaia-ai/conductor`'s `Preset`).
 /** The extension points each surface runs (the preset function names to call). */
 export const SURFACE_KEYS = {
     command: ['commands'],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gaia-ai/core",
-  "version": "0.6.0",
-  "description": "GAIA global contract: plugin API, built-in remotes/workspaces/auth, shared primitives.",
+  "version": "0.6.1",
+  "description": "GAIA surface-agnostic kernel: host contract, split-config helpers, addon preset/discovery machinery, shared primitives.",
   "type": "module",
   "license": "MIT",
   "engines": {
@@ -9,8 +9,6 @@
   },
   "exports": {
     ".": "./dist/src/index.js",
-    "./plugins": "./dist/src/plugins-index.js",
-    "./builtins": "./dist/src/plugins/builtins-preset.js",
     "./conductor-registry": "./dist/src/conductor-registry/index.js",
     "./package.json": "./package.json"
   },
@@ -26,9 +24,10 @@
   "repository": {
     "type": "git",
     "url": "git+https://git.key-tec.de/keytec/gaia.git",
-    "directory": "conductor/core"
+    "directory": "gaia-cli/core"
   },
   "dependencies": {
+    "@dropsh/plugin-markdown": "^0.5.8",
     "@dropsh/plugin-oauth2": "^0.5.7",
     "commander": "^12.1.0",
     "dropsh": "^0.5.8",

package/dist/src/plugins/agent/agent.d.ts

@@ -1,61 +0,0 @@
-/**
- * Per-agent effort footprint parsed from that agent's run transcript
- * (GAIA-132). The metrics are transcript-derived and therefore
- * **agent-specific** (each agent's transcript has its own format), so parsing
- * lives behind the agent abstraction (see {@link GaiaAgent.parseFootprint}) —
- * the conductor stays agent-agnostic and writes the footprint verbatim.
- * `duration_s` is likewise derived from the transcript (its first→last entry
- * timestamps), NOT recomputed by the conductor from a re-read `started_at`
- * (GAIA-151): the log is the single source of the run's wall-clock length, so
- * there is no timestamp round-trip through JSON:API to mis-parse.
- */
-export interface AgentFootprint {
-    /** Total tokens across every usage bucket of every assistant turn. */
-    tokens: number;
-    /**
-     * Wall-clock run length in seconds, derived from the transcript's first→last
-     * entry timestamps (GAIA-151). 0 when the transcript has fewer than two
-     * timestamped entries (empty/absent log).
-     */
-    duration_s: number;
-    /** Number of assistant turns in the transcript. */
-    agent_turns: number;
-    /** Number of tool-use calls across all assistant turns. */
-    tool_calls: number;
-    /** Number of user-submitted prompts. */
-    user_prompts: number;
-    /** Total words across those user prompts. */
-    user_prompt_words: number;
-    /** Model of the last assistant turn, when present (informational). */
-    model?: string;
-}
-/** An all-zero footprint — the honest result for an empty/absent transcript. */
-export declare function emptyAgentFootprint(): AgentFootprint;
-/**
- * A GAIA agent: the program the conductor runs to work a ticket (e.g. claude).
- * It knows how it is launched (CLI + model + flags) and where its per-run
- * transcript/log lives — so the conductor stays agent-agnostic and the CLI can
- * attach the run log on release without agent-specific knowledge.
- */
-export interface GaiaAgent {
-    /** Stable id, e.g. 'claude'. */
-    readonly id: string;
-    /**
-     * Build the full agent CLI invocation for a GAIA prompt. With an empty
-     * prompt, returns the bare launch command (no prompt argument).
-     */
-    launchCommand(prompt: string): string;
-    /**
-     * Locate and read this agent's run transcript for a run that executed in
-     * `worktreePath`. MUST return '' (never throw) when nothing is found.
-     */
-    getRunLog(worktreePath: string): Promise<string>;
-    /**
-     * Parse this agent's run transcript (as returned by {@link getRunLog}) into
-     * a footprint of effort metrics (GAIA-132). The transcript format is
-     * agent-specific, so each agent owns its own parser. MUST be tolerant of
-     * blank/partial/absent input (never throw) — an empty log yields
-     * {@link emptyAgentFootprint}.
-     */
-    parseFootprint(log: string): AgentFootprint;
-}

package/dist/src/plugins/agent/agent.js

@@ -1,11 +0,0 @@
-/** An all-zero footprint — the honest result for an empty/absent transcript. */
-export function emptyAgentFootprint() {
-    return {
-        tokens: 0,
-        duration_s: 0,
-        agent_turns: 0,
-        tool_calls: 0,
-        user_prompts: 0,
-        user_prompt_words: 0,
-    };
-}

package/dist/src/plugins/auth/basic.d.ts

@@ -1,12 +0,0 @@
-/**
- * Static HTTP Basic auth provider built from an inline base64 `user:pass` token
- * (conductor.config.local.js `auth.basic`, or the GAIA_E2E_BASIC env for tests).
- * Returns the `{ id, authProvider }` plugin shape that dropsh's resolveAuth reads
- * from `config.plugins`. Replaces the per-file basicAuthProvider that used to be
- * hand-written into each dropsh.config.js.
- */
-export declare function basicAuthProvider(tokenBase64: string): {
-    kind: 'auth';
-    id: string;
-    authProvider: unknown;
-};

package/dist/src/plugins/auth/basic.js

@@ -1,37 +0,0 @@
-/**
- * Static HTTP Basic auth provider built from an inline base64 `user:pass` token
- * (conductor.config.local.js `auth.basic`, or the GAIA_E2E_BASIC env for tests).
- * Returns the `{ id, authProvider }` plugin shape that dropsh's resolveAuth reads
- * from `config.plugins`. Replaces the per-file basicAuthProvider that used to be
- * hand-written into each dropsh.config.js.
- */
-export function basicAuthProvider(tokenBase64) {
-    const authProvider = {
-        id: 'basic_auth',
-        displayName: 'HTTP Basic (inline)',
-        capabilities: { login: false, logout: false, status: true },
-        async login() {
-            throw new Error('GAIA uses static inline HTTP Basic auth.');
-        },
-        async logout() { },
-        async status() {
-            return { loggedIn: true, provider: 'basic_auth' };
-        },
-        createAdapter() {
-            return {
-                async apply(req) {
-                    return {
-                        ...req,
-                        headers: {
-                            ...(req.headers ?? {}),
-                            Authorization: `Basic ${tokenBase64}`,
-                        },
-                    };
-                },
-            };
-        },
-    };
-    // GAIA-215: `.kind='auth'` makes the plugin tag total (every GAIA plugin
-    // self-identifies); dropsh ignores the extra field and reads `authProvider`.
-    return { kind: 'auth', id: 'gaia-basic-auth', authProvider };
-}

package/dist/src/plugins/builtins-preset.d.ts

@@ -1,5 +0,0 @@
-import type { GaiaPreset } from './preset.js';
-/** Conductor surface: the Drupal control-plane remote (the sole shipped remote). */
-export declare const remotes: GaiaPreset['remotes'];
-/** Connection surface: inline HTTP Basic auth, only when a `basic` token is set. */
-export declare const connectionPlugins: GaiaPreset['connectionPlugins'];

package/dist/src/plugins/builtins-preset.js

@@ -1,32 +0,0 @@
-// GAIA-215: the core built-ins preset, exposed as `@gaia-ai/core/builtins`. It
-// self-declares GAIA's shipped default contributions the way any addon does —
-// retiring the `@gaia-ai/core/plugins` barrel `export:` warts (`drupalRemote`,
-// `basicAuthProvider`). List it in `conductor.config.js` addons to auto-wire the
-// Drupal control-plane remote; list it in `gaia.config.js` addons with a
-// `{ basic: '<base64>' }` option for inline HTTP Basic auth. The barrel stays
-// for back-compat (the descriptor `export:` path); new configs name this preset.
-//
-// It deliberately does NOT contribute a workspace: every executor addon ships
-// its own paired workspace (herdr → herdrWorkspace, fake → fakeWorkspace), so a
-// builtin `gitWorkspace` would only fight the executor's workspace on the
-// canonical config (a guaranteed last-wins warning). A git-only setup can still
-// name `gitWorkspace` explicitly via the `@gaia-ai/core/plugins` barrel.
-//
-// It is deliberately light + dependency-free at the top level (factory calls
-// only), so the host can import it at boot without pulling the remote runtime.
-import { basicAuthProvider } from './auth/basic.js';
-import { drupalRemote } from './remote/drupal.js';
-/** Conductor surface: the Drupal control-plane remote (the sole shipped remote). */
-export const remotes = (acc) => [...acc, drupalRemote()];
-/** Connection surface: inline HTTP Basic auth, only when a `basic` token is set. */
-export const connectionPlugins = (acc, opts) => {
-    const o = (opts ?? {});
-    if (typeof o.basic !== 'string' || o.basic.trim() === '')
-        return acc;
-    // basicAuthProvider returns the dropsh auth-plugin shape ({ id, authProvider })
-    // minus `requiredModules` (dropsh tolerates its absence for auth-only plugins).
-    return [
-        ...acc,
-        basicAuthProvider(o.basic),
-    ];
-};

package/dist/src/plugins/executor/executor.d.ts

@@ -1,104 +0,0 @@
-export interface SpawnedSession {
-    sessionRef: string;
-}
-export interface ExecutorCapabilities {
-    persistent: boolean;
-}
-export interface SpawnRunInput {
-    ticket: {
-        uuid: string;
-        identifier: string;
-        title: string;
-        branchName: string;
-        state: string;
-        url?: string;
-    };
-    run: {
-        uuid: string;
-        id: number;
-        handler: string;
-    };
-    workspacePath: string;
-    instructions: {
-        path: string;
-        sha256: string;
-        text: string;
-    } | null;
-    command?: string;
-    env?: Record<string, string>;
-}
-/** The four lifecycle-hook slots, keyed exactly like `config.hooks`. */
-export type HookName = 'after_create' | 'before_run' | 'after_run' | 'after_done';
-/** Context for a hook invocation — carries the ticket for observable logging. */
-export interface HookContext {
-    /** The ticket identifier/uuid the hook is running for (log context). */
-    ticket: string;
-}
-export interface GaiaExecutor {
-    id: string;
-    capabilities(): ExecutorCapabilities;
-    /**
-     * Run the lifecycle hook `name` (command from `config.hooks[name]`) in `cwd`,
-     * best-effort. This is the SINGLE catch point for all lifecycle hooks:
-     *
-     * - MUST NEVER throw. No configured command → silent no-op. A failing command
-     *   → `logger.error({hook,worktree,ticket,err}, 'lifecycle hook failed')` then
-     *   return. So a hook failure never aborts dispatch or wedges a run in
-     *   `claimed`.
-     * - The underlying shell command still fails honestly (a non-zero exit
-     *   rejects); only the executor catches + logs + continues.
-     *
-     * `env`, when given, is the run's resolved environment (per-ticket env_vars
-     * merged with the core GAIA_* vars, GAIA-99), merged over the hook process's
-     * inherited env. Values may be sensitive — implementations must never log
-     * them (log key names only).
-     */
-    runHook(name: HookName, cwd: string, ctx: HookContext, env?: Record<string, string>): Promise<void>;
-    startRun(input: SpawnRunInput): Promise<SpawnedSession>;
-    /**
-     * Signal the run's agent to stop. Called by the conductor's run-finalise pass
-     * BEFORE it captures the agent transcript (GAIA-132), so a stop must not
-     * destroy the log. For herdr this is a NO-OP: at finalise time the agent is
-     * idle and its jsonl transcript is already fully written to disk, and the
-     * subsequent {@link cleanupRun} tab-close kills the PTY (the agent dies with
-     * it). The seam exists for executors whose agent outlives its UI surface.
-     * Best-effort; gated by the conductor on `capabilities().persistent`.
-     */
-    stopRun(branch: string): Promise<void>;
-    /**
-     * Tear down ONE run's hosted UI surface — for herdr, close only the tab whose
-     * label carries the `#<runId>` token (`startRun` labels every tab
-     * `<identifier> · <state> #<run.id>`), via `herdr tab close <tab_id>` (killing
-     * that PTY). Run-scoped by design (GAIA-183): a sibling run's tab in the same
-     * branch workspace — a still-open prior-state run or a concurrent re-claim —
-     * and any non-run tab are left untouched. Called as the LAST finalisation step,
-     * strictly after the transcript is captured, and again at dispatch to clear a
-     * reused workspace's leftover tab for the run being (re-)started. No matching
-     * tab → a quiet no-op. Does NOT touch the branch worktree (that is the
-     * reap/{@link removeWorktree} lifecycle). Best-effort: a failing tab-close is
-     * swallowed and never aborts finalisation or dispatch. A no-op for
-     * non-persistent executors.
-     */
-    cleanupRun(branch: string, runId: number): Promise<void>;
-    /**
-     * Tear down the branch's entire worktree (git worktree + hosted workspace),
-     * reclaiming its disk. Called by the conductor's ticket-cleanup pass once a
-     * ticket is done. A no-op for non-persistent executors (no hosted workspace);
-     * the conductor gates the call on `capabilities().persistent`.
-     *
-     * `worktreePath` is the stable, identifier-derived worktree path (from the
-     * ticket's latest run). Prefer it over `branch` to resolve the worktree: the
-     * checked-out branch is mutable (the coding agent may rename/switch it), the
-     * path is not.
-     *
-     * Returns whether the worktree was actually present on THIS host and torn
-     * down (or reclaimed on disk) — i.e. whether the teardown happened locally.
-     * `false` means nothing matched here: the worktree is either already gone or
-     * lives on another conductor's host. The reaper uses this to avoid marking a
-     * ticket `cleaned_up` for a worktree it did not actually tear down (a
-     * cross-host false-teardown), leaving it for the host that physically holds
-     * it. A genuine failure still throws (surfaced as a teardown miss); a `false`
-     * return is a clean "not here", not an error.
-     */
-    removeWorktree(branch: string, worktreePath?: string): Promise<boolean>;
-}

package/dist/src/plugins/executor/executor.js

@@ -1 +0,0 @@
-export {};

package/dist/src/plugins/plugins.d.ts

@@ -1,60 +0,0 @@
-import type { DropSHPlugin } from 'dropsh/plugin';
-import type { ConductorLogger } from '../core/logger.js';
-import type { ConductorFileConfig } from '../types.js';
-import type { GaiaAgent } from './agent/agent.js';
-import type { GaiaExecutor } from './executor/executor.js';
-import type { GaiaRemote, Ticket } from './remote/remote.js';
-import type { GaiaWorkspace } from './workspace/workspace.js';
-/** Runtime dependencies handed to a plugin factory at selection time. */
-export interface ExecutorDeps {
-    /** The in-scope conductor logger — the executor logs hook failures through it. */
-    logger: ConductorLogger;
-}
-export interface RemotePlugin extends DropSHPlugin {
-    readonly kind: 'remote';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createRemote(config: ConductorFileConfig): Promise<GaiaRemote>;
-}
-export interface ExecutorPlugin extends DropSHPlugin {
-    readonly kind: 'executor';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createExecutor(config: ConductorFileConfig, deps: ExecutorDeps): Promise<GaiaExecutor>;
-}
-export interface WorkspacePlugin extends DropSHPlugin {
-    readonly kind: 'workspace';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createWorkspace(config: ConductorFileConfig): Promise<GaiaWorkspace>;
-}
-export interface AgentPlugin extends DropSHPlugin {
-    readonly kind: 'agent';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createAgent(config: ConductorFileConfig): Promise<GaiaAgent>;
-}
-/** Resolves the remote from its named config slot. */
-export declare function selectRemote(config: ConductorFileConfig): Promise<GaiaRemote>;
-/** Resolves the executor from its named config slot, injecting the logger. */
-export declare function selectExecutor(config: ConductorFileConfig, logger: ConductorLogger): Promise<GaiaExecutor>;
-/** Resolves the workspace from its named config slot. */
-export declare function selectWorkspace(config: ConductorFileConfig): Promise<GaiaWorkspace>;
-/** A config-side agent choice: an agent plugin + an optional static priority over the ticket. */
-export interface AgentCandidate {
-    agent: AgentPlugin;
-    priority?: (ticket: Ticket) => number;
-}
-/** A constructed candidate: the agent id, its GaiaAgent, and the config-side priority. */
-export interface ResolvedAgent {
-    id: string;
-    agent: GaiaAgent;
-    priority?: (ticket: Ticket) => number;
-}
-/**
- * Pick the agent for a ticket: highest `priority(ticket)` wins; a candidate with
- * no `priority` scores lowest; ties resolve by config array order (stable sort).
- */
-export declare function selectAgent(candidates: ResolvedAgent[], ticket: Ticket): ResolvedAgent;
-/** Constructs every agent candidate from the resolved config slot (single or array). */
-export declare function selectAgents(config: ConductorFileConfig): Promise<ResolvedAgent[]>;