@gaia-ai/core 0.6.0 → 0.6.2

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.2",
+  "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[]>;

package/dist/src/plugins/plugins.js

@@ -1,42 +0,0 @@
-/** Resolves the remote from its named config slot. */
-export async function selectRemote(config) {
-    return config.remote.createRemote(config);
-}
-/** Resolves the executor from its named config slot, injecting the logger. */
-export async function selectExecutor(config, logger) {
-    return config.executor.createExecutor(config, { logger });
-}
-/** Resolves the workspace from its named config slot. */
-export async function selectWorkspace(config) {
-    return config.workspace.createWorkspace(config);
-}
-/** A missing `priority` scores strictly below any real number (AC-4). */
-const DEFAULT_PRIORITY = Number.NEGATIVE_INFINITY;
-/**
- * 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 function selectAgent(candidates, ticket) {
-    const best = candidates
-        .map((c, index) => ({
-        c,
-        index,
-        score: c.priority ? c.priority(ticket) : DEFAULT_PRIORITY,
-    }))
-        .sort((a, b) => b.score - a.score || a.index - b.index)[0];
-    if (!best) {
-        throw new Error('selectAgent: no agent candidates configured');
-    }
-    return best.c;
-}
-/** Constructs every agent candidate from the resolved config slot (single or array). */
-export async function selectAgents(config) {
-    const candidates = Array.isArray(config.agent)
-        ? config.agent
-        : [config.agent];
-    return Promise.all(candidates.map(async (c) => ({
-        id: c.agent.id,
-        agent: await c.agent.createAgent(config),
-        ...(c.priority ? { priority: c.priority } : {}),
-    })));
-}

package/dist/src/plugins/registry-exports.d.ts

@@ -1,6 +0,0 @@
-export { basicAuthProvider } from './auth/basic.js';
-export { type AgentCandidate, type ResolvedAgent, selectAgent, selectAgents, selectExecutor, selectRemote, selectWorkspace, } from './plugins.js';
-export { DrupalGaiaRemote, drupalRemote } from './remote/drupal.js';
-export { FakeGaiaRemote, type FakeRemoteSeed, fakeRemote, } from './remote/fake.js';
-export { FakeWorkspace, fakeWorkspace } from './workspace/fake.js';
-export { GitWorkspace, gitWorkspace } from './workspace/git.js';

package/dist/src/plugins/registry-exports.js

@@ -1,6 +0,0 @@
-export { basicAuthProvider } from './auth/basic.js';
-export { selectAgent, selectAgents, selectExecutor, selectRemote, selectWorkspace, } from './plugins.js';
-export { DrupalGaiaRemote, drupalRemote } from './remote/drupal.js';
-export { FakeGaiaRemote, fakeRemote, } from './remote/fake.js';
-export { FakeWorkspace, fakeWorkspace } from './workspace/fake.js';
-export { GitWorkspace, gitWorkspace } from './workspace/git.js';

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

@@ -1,40 +0,0 @@
-import type { JsonApiClient } from 'dropsh/plugin';
-import type { RemotePlugin } from '../plugins.js';
-import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunMetrics, RunWriteAttributes, Ticket, UncleanTicket } from './remote.js';
-export declare class DrupalGaiaRemote implements GaiaRemote {
-    private readonly api;
-    constructor(api: JsonApiClient);
-    fetchActiveRuns(id: string): Promise<ActiveRun[]>;
-    activeRunCount(id: string): Promise<number>;
-    claimNext(c: ClaimOptions): Promise<ClaimedRun | null>;
-    getTicket(uuid: string): Promise<Ticket>;
-    getRunWorktree(uuid: string): Promise<string>;
-    getRunTicketIdentifier(uuid: string): Promise<string>;
-    getRunTicketBranchName(uuid: string): Promise<string>;
-    registerConductor(reg: ConductorRegistration): Promise<string>;
-    heartbeat(reg: ConductorRegistration, load: number, lease?: number): Promise<string>;
-    getConductorStatus(id: string): Promise<string | null>;
-    setConductorStatus(id: string, status: string): Promise<void>;
-    listConductors(owner?: 'me'): Promise<ConductorStatus[]>;
-    markRunning(uuid: string, attrs?: RunWriteAttributes): Promise<void>;
-    markFailed(uuid: string, errorLog: string): Promise<void>;
-    fetchFinalizableRuns(id: string): Promise<FinalizableRun[]>;
-    finalizeRun(uuid: string, log: string, metrics?: RunMetrics): Promise<void>;
-    fetchUncleanedTickets(id: string): Promise<UncleanTicket[]>;
-    closeTicket(uuid: string): Promise<void>;
-    markTicketCleanedUp(uuid: string): Promise<void>;
-    /**
-     * Absolute worktree path of the ticket's latest run (highest run id with a
-     * non-empty worktree_path), or '' when none — the cwd the cleanup command
-     * runs in. The conductor persists worktree_path on markRunning, so a done
-     * ticket's run carries the path even after the run closed.
-     */
-    private latestRunWorktree;
-    resolveTicketByIdentifier(project: string, identifier: string): Promise<{
-        uuid: string;
-        title: string;
-    } | null>;
-    private readonly projectUuidCache;
-    private projectUuid;
-}
-export declare function drupalRemote(): RemotePlugin;