@gaia-ai/conductor 0.6.0 → 0.6.2

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

@@ -0,0 +1,104 @@
+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.js

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

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

@@ -0,0 +1,60 @@
+import type { ConductorLogger } from '@gaia-ai/core';
+import type { DropSHPlugin } from 'dropsh/plugin';
+import type { ConductorFileConfig } from '../types.js';
+import type { GaiaAgent } from './agent.js';
+import type { GaiaExecutor } from './executor.js';
+import type { GaiaRemote, Ticket } from './remote.js';
+import type { GaiaWorkspace } from './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

@@ -0,0 +1,42 @@
+/** 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/preset.d.ts

@@ -0,0 +1,48 @@
+import type { AddonEntry, DiscoveredContributions, GaiaPreset } from '@gaia-ai/core';
+import type { AgentCandidate, ExecutorPlugin, RemotePlugin, WorkspacePlugin } from './plugins.js';
+import type { Ticket } from './remote.js';
+/**
+ * The conductor surface's concrete contributions — the strongly-typed view of
+ * the four conductor accumulators `discoverAddons(entries, 'conductor', …)`
+ * fills. Core returns them as opaque `unknown[]`; the engine narrows once, at
+ * the discovery call site (see {@link narrowConductorContributions}).
+ */
+export interface ConductorContributions {
+    remotes: RemotePlugin[];
+    executors: ExecutorPlugin[];
+    workspaces: WorkspacePlugin[];
+    agents: AgentCandidate[];
+}
+/**
+ * One `addons[]` entry on the conductor surface: core's surface-agnostic
+ * `AddonEntry` with the agent `priority` narrowed to the real `Ticket`.
+ */
+export type ConductorAddonEntry = string | (Exclude<AddonEntry, string> & {
+    priority?: (ticket: Ticket) => number;
+});
+/**
+ * A preset as a CONDUCTOR-surface addon writes it: core's `GaiaPreset` with the
+ * four conductor accumulators concretely typed.
+ *
+ * It literally `extends GaiaPreset`, so the compiler — not a comment — enforces
+ * that this view stays a faithful narrowing of the kernel contract. That only
+ * type-checks because core's `OpaqueAccumulator` takes `never[]` on the input
+ * side: `never[]` is assignable to `RemotePlugin[]`, so the concrete member below
+ * satisfies the opaque one contravariantly. If core ever widened that parameter
+ * to `unknown[]`, this `extends` would fail loudly here instead of the two views
+ * silently drifting apart.
+ */
+export interface Preset<O = unknown> extends GaiaPreset<O> {
+    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[]>;
+}
+/**
+ * The single, reviewed narrowing at the engine's discovery seam: reinterpret
+ * core's opaque conductor accumulators as this surface's concrete contribution
+ * lists. Safe because every conductor-surface preset is typed against
+ * {@link Preset}, and `resolveConductorSlots` still runs the runtime `.kind`
+ * guard on whatever actually landed in a singleton slot.
+ */
+export declare function narrowConductorContributions(discovered: Pick<DiscoveredContributions, 'remotes' | 'executors' | 'workspaces' | 'agents'>): ConductorContributions;

package/dist/src/plugins/preset.js

@@ -0,0 +1,23 @@
+// GAIA-224 (Finding 6, decision 7): the CONDUCTOR-SURFACE view of the preset
+// contract. `@gaia-ai/core` owns the surface-AGNOSTIC machinery — it knows the
+// accumulator NAMES (`SURFACE_KEYS`) and threads them (`discoverAddons`), but its
+// per-surface accumulators are OPAQUE (`OpaqueAccumulator`), because the element
+// types of the conductor surface (`RemotePlugin`, `ExecutorPlugin`,
+// `WorkspacePlugin`, `AgentCandidate`) live HERE, in the package that owns the
+// surface. Without that split, `core/src/plugins/preset.ts` would have to import
+// the conductor contract and core would edge `@gaia-ai/conductor` — breaking the
+// "core has zero @gaia-ai/* edges" rule.
+//
+// A conductor-surface addon therefore types its `./preset` accumulators against
+// THIS `Preset` (e.g. `export const agents: Preset['agents'] = …`) instead of
+// core's `GaiaPreset`, and stays structurally assignable to it.
+/**
+ * The single, reviewed narrowing at the engine's discovery seam: reinterpret
+ * core's opaque conductor accumulators as this surface's concrete contribution
+ * lists. Safe because every conductor-surface preset is typed against
+ * {@link Preset}, and `resolveConductorSlots` still runs the runtime `.kind`
+ * guard on whatever actually landed in a singleton slot.
+ */
+export function narrowConductorContributions(discovered) {
+    return discovered;
+}

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

@@ -0,0 +1,203 @@
+export interface ConductorRegistration {
+    id: string;
+    project: string;
+    /** Empty = serve all claimable states in the project (GAIA-207). */
+    states: string[];
+    workspace: string;
+    label: string;
+    max_parallel: number;
+}
+export interface ClaimOptions {
+    leaseSeconds: number;
+    conductorId: string;
+}
+export interface ClaimedRun {
+    runUuid: string;
+    runId: number;
+    ticketUuid: string;
+    stateAtStart: string;
+    handler: string;
+}
+export interface Ticket {
+    uuid: string;
+    identifier: string;
+    title: string;
+    state: string;
+    branchName: string;
+    /** Branch the ticket's work is based on (computed server-side): parent branch, project default, or 'main'. */
+    baseBranch?: string;
+    /**
+     * Effective environment variables (GAIA-99), resolved server-side along the
+     * parent_id chain (child wins) as canonical `.env`-style `KEY=value` lines.
+     * The conductor parses this, strips reserved keys, overlays the core GAIA_*
+     * vars, and injects the result into the agent run env AND the workspace hooks.
+     * Omitted when the ticket (and its ancestors) set none. Values may be secret.
+     */
+    effectiveEnvVars?: string;
+    issueUrl?: string;
+    /** Ticket label term names (gaia_labels vocab), sideloaded for agent selection. Empty when none. */
+    labels: string[];
+    /** Ticket environments (gaia_environment refs), each as name + tier, sideloaded for agent selection. Empty when none. */
+    environments: {
+        name: string;
+        tier: string;
+    }[];
+}
+export interface ActiveRun {
+    runUuid: string;
+    ticketUuid: string;
+    ticketIdentifier: string;
+    branchName: string;
+    state: string;
+    stateAtStart: string;
+    /** Absolute path of the per-run git worktree, or '' when unset. */
+    worktreePath: string;
+}
+export interface ConductorStatus {
+    id: string;
+    project: string;
+    label: string;
+    status: string;
+    lastSeen: number;
+    load: number;
+}
+export interface FinalizableRun {
+    runUuid: string;
+    /** Numeric run id (the `#<runId>` tab-label token); scopes the run's tab-close at finalise (GAIA-183). */
+    runId: number;
+    /** Absolute path of the per-run git worktree, or '' when unset. */
+    worktreePath: string;
+    /** Id of the agent that ran (GAIA-144); routes footprint parsing at finalize. '' / undefined when unset. */
+    agent?: string;
+}
+/**
+ * Per-run effort footprint the conductor writes onto `gaia_run` at close
+ * (GAIA-132). Six integer metrics, all parsed from the agent transcript —
+ * including `duration_s`, the run's wall-clock length derived from the
+ * transcript's first→last timestamps (GAIA-151), not a re-read `started_at`.
+ */
+export interface RunMetrics {
+    tokens: number;
+    duration_s: number;
+    agent_turns: number;
+    tool_calls: number;
+    user_prompts: number;
+    user_prompt_words: number;
+}
+/**
+ * A finished ticket whose worktree has not yet been torn down — the
+ * conductor's teardown work list, driven by the durable `cleaned_up` flag
+ * (GAIA-89). "Finished" = reached `done` OR already `closed`; `cleaned_up=0`
+ * means the herdr worktree still needs reclaiming. The reconciliation is NOT
+ * scoped to a conductor's machine_id, so it also surfaces tickets whose
+ * conductor was down at `done` or whose `conductor_id` was reassigned.
+ */
+export interface UncleanTicket {
+    ticketUuid: string;
+    /** The ticket's git branch — the key herdr resolves the worktree by. */
+    branchName: string;
+    /**
+     * Absolute path of the ticket's worktree (from its latest run's
+     * `worktree_path`), or '' when unresolved. The cwd the teardown runs in.
+     */
+    worktreePath: string;
+    /** Workflow state (e.g. `coding`, `done`). */
+    state: string;
+    /** Whether the ticket's lifecycle has already been closed out. */
+    closed: boolean;
+}
+/** Extra conductor-writable gaia_run attributes (besides state/lease). */
+export interface RunWriteAttributes {
+    /** Absolute path of the per-run git worktree (set by the conductor). */
+    worktree_path?: string;
+    /** Id of the agent the conductor chose for this run (GAIA-144), for footprint routing. */
+    agent?: string;
+}
+export interface GaiaRemote {
+    /** Upserts by machine_id; sets status=online. Returns the Drupal entity uuid. */
+    registerConductor(reg: ConductorRegistration): Promise<string>;
+    /**
+     * Records a heartbeat server-side: upserts by machine_id (recreating a
+     * vanished registration), refreshes last_seen/lease/load, and brings the
+     * conductor online. Keyed on machine_id, so it never 404s — the self-heal
+     * lives on the server, not the client. Returns the resulting status
+     * (`online` | `offline`).
+     */
+    heartbeat(reg: ConductorRegistration, currentLoad: number, leaseSeconds?: number): Promise<string>;
+    getConductorStatus(conductorId: string): Promise<string | null>;
+    setConductorStatus(conductorId: string, status: 'offline' | 'online'): Promise<void>;
+    listConductors(owner?: 'me'): Promise<ConductorStatus[]>;
+    activeRunCount(conductorId: string): Promise<number>;
+    fetchActiveRuns(conductorId: string): Promise<ActiveRun[]>;
+    claimNext(claim: ClaimOptions): Promise<ClaimedRun | null>;
+    getTicket(ticketUuid: string): Promise<Ticket>;
+    /** Returns the run's worktree_path, or '' when unset. */
+    getRunWorktree(runUuid: string): Promise<string>;
+    /**
+     * Returns the identifier of the run's ticket, or '' when unresolved. Lets the
+     * release path derive the tab matching ref (the ticket identifier) from a run
+     * uuid alone.
+     */
+    getRunTicketIdentifier(runUuid: string): Promise<string>;
+    /**
+     * Returns the branch_name of the run's ticket, or '' when unresolved. Used
+     * by dispatch for the per-(branch,state) herdr tab model.
+     */
+    getRunTicketBranchName(runUuid: string): Promise<string>;
+    markRunning(runUuid: string, attrs?: RunWriteAttributes): Promise<void>;
+    /**
+     * Terminalise a run to the `failed` state on a dispatch/setup error (GAIA-149).
+     * PATCHes state=failed, records the failure detail in `error_log`, and closes
+     * the run (closed + closed_date). `failed` is a terminal sibling of `expired`
+     * (dispatch error vs lease lapse), so the run stops counting toward capacity
+     * and its ticket is no longer blocked by the single-active-run gate — instead
+     * of the old "leave it `claimed` to expire after ~300s" silent stall. The
+     * failure is visible immediately and its cause is recorded.
+     */
+    markFailed(runUuid: string, errorLog: string): Promise<void>;
+    /**
+     * Runs this conductor owns that are state=done but not yet closed — the
+     * conductor's one-shot finalisation work list.
+     */
+    fetchFinalizableRuns(conductorId: string): Promise<FinalizableRun[]>;
+    /**
+     * Finalise a run: set closed + closed_date, (when non-empty) log, and (when
+     * given) the per-run footprint metrics (GAIA-132). No state change — the run
+     * is already done.
+     */
+    finalizeRun(uuid: string, log: string, metrics?: RunMetrics): Promise<void>;
+    /**
+     * Finished tickets (state=done OR closed) whose worktree is not yet torn
+     * down (cleaned_up=0) — the conductor's teardown work list (GAIA-89). Driven
+     * by the durable `cleaned_up` flag AND scoped to the reaping conductor
+     * (GAIA-121): only tickets assigned to `conductorId` are loaded, so every
+     * ticket on the list is unambiguously this conductor's — a missing worktree
+     * means "already torn down on this host", not "belongs to another host". The
+     * same query backs the live tick and the standalone `gaia conductor reap`.
+     * Empty once every finished ticket this conductor owns is cleaned.
+     */
+    fetchUncleanedTickets(conductorId: string): Promise<UncleanTicket[]>;
+    /**
+     * Close a ticket: set closed=true + closed_date. Ticket-lifecycle only, and
+     * decoupled from teardown — a done ticket is closed even if its worktree
+     * teardown later fails. No state change (the ticket is already done).
+     */
+    closeTicket(uuid: string): Promise<void>;
+    /**
+     * Mark a ticket's worktree torn down: set cleaned_up=true so it drops off the
+     * {@link fetchUncleanedTickets} work list. Written ONLY after a verified
+     * teardown, so a teardown miss leaves cleaned_up=0 and the next reconciliation
+     * retries — one miss never orphans the workspace, and a re-run on an
+     * already-cleaned ticket is a no-op (it is no longer on the list).
+     */
+    markTicketCleanedUp(uuid: string): Promise<void>;
+    /**
+     * Resolve a ticket identifier (e.g. "GAIA-134") to its uuid+title within a
+     * project, or null when no such ticket exists. Used by the
+     * `gaia deployment tickets` helper to turn commit-message identifiers into tickets.
+     */
+    resolveTicketByIdentifier(project: string, identifier: string): Promise<{
+        uuid: string;
+        title: string;
+    } | null>;
+}

package/dist/src/plugins/remote.js

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

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

@@ -0,0 +1,35 @@
+export interface EnsuredWorkspace {
+    path: string;
+    instructions: {
+        path: string;
+        sha256: string;
+        text: string;
+    } | null;
+    /**
+     * Whether this call CREATED the worktree (true) or reused an existing one
+     * (false). The core runs the `after_create` lifecycle hook only on a fresh
+     * worktree, so it needs to know which happened. Lifecycle hooks themselves
+     * are no longer a workspace concern (GAIA-84): the executor owns and runs
+     * them best-effort.
+     */
+    created: boolean;
+}
+export interface GaiaWorkspace {
+    /**
+     * Ensure a per-ticket worktree exists. `branch`, when given, is the branch
+     * name the dispatcher computed for the ticket. The git plugin treats it as a
+     * readable title to slug into its branch template; the herdr plugin uses it
+     * verbatim as the worktree branch. The worktree directory key/path stays
+     * identifier- or branch-derived so reuse is stable across runs.
+     *
+     * `baseRef`, when given, overrides the base the new branch is created from
+     * (e.g. `origin/<base_branch>` so a sub-ticket stacks on its parent); if it
+     * does not resolve on the remote the implementation falls back to its default
+     * base — never a hard error.
+     *
+     * Reports `created` so the caller can run the `after_create` hook only on a
+     * fresh worktree. Lifecycle-hook invocation is NOT a workspace responsibility
+     * anymore — the executor owns all hooks (GAIA-84).
+     */
+    ensure(identifier: string, branch?: string, baseRef?: string): Promise<EnsuredWorkspace>;
+}

package/dist/src/plugins/workspace.js

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

package/dist/src/preset.d.ts

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

package/dist/src/types.d.ts

@@ -0,0 +1,65 @@
+import type { DropSHPlugin } from 'dropsh/plugin';
+import type { AgentCandidate, ExecutorPlugin, RemotePlugin, WorkspacePlugin } from './plugins/plugins.js';
+/** Normalized single conductor. */
+export interface ConductorSettings {
+    /** Default: `${project} @ ${checkoutRoot}`. */
+    label: string;
+    /**
+     * Stable node identity (gaia_conductor.machine_id) this process registers as.
+     * Defaults to a hash of hostname + checkout path. Set it to pin a conductor to
+     * a known identity — e.g. so a ticket can be pre-assigned to it (conductor
+     * assignment is the run-start trigger), which the e2e fixtures rely on.
+     */
+    machine_id?: string;
+    /** Project name (gaia_project.name); resolved at registration. */
+    project: string;
+    /**
+     * Workflow states this conductor serves. An empty list means it serves every
+     * claimable state in its project; a non-empty list narrows it to those
+     * states (GAIA-207).
+     */
+    states: string[];
+    /**
+     * Agent prompt template - the GAIA run contract, NOT project workflow. Bounds
+     * the agent to exactly one state and tells it to release + stop, keeping run
+     * mechanics out of the repo's WORKFLOW.md. Placeholders: `{identifier}`,
+     * `{state}`, `{runUuid}`. Defaults to `DEFAULT_AGENT_PROMPT`.
+     */
+    prompt: string;
+    /** Default: 1. */
+    max_parallel: number;
+    poll_interval_ms: number;
+    lease_seconds: number;
+    hooks?: {
+        after_create?: string;
+        before_run?: string;
+        after_run?: string;
+        after_done?: string;
+    };
+    /** Control-plane site settings used for dropsh and agent env. */
+    site: {
+        base_url: string;
+        jsonapi_prefix: string;
+    };
+    /** Absolute path of the loaded config. */
+    config_path: string;
+}
+/** Whole conductor.config.js (dropsh-superset): site + named plugin slots. */
+export interface ConductorFileConfig extends ConductorSettings {
+    remote: RemotePlugin;
+    executor: ExecutorPlugin;
+    /** The agent slot: a single candidate or an array of candidates (shape preserved as authored). Selection normalizes + picks one per dispatch. */
+    agent: AgentCandidate | AgentCandidate[];
+    workspace: WorkspacePlugin;
+    /** dropsh-layer plugins (auth etc.); separate from the GAIA slots. */
+    plugins?: DropSHPlugin[];
+}
+/**
+ * GAIA-201 split config model: the ENGINE half of a conductor config —
+ * everything a `conductor.config.js` carries EXCEPT the connection (`site`) and
+ * the auth `plugins`, which now live in a separate `gaia.config.js`
+ * (`GaiaConnectionConfig`). `loadConductorConfig` returns this; the conductor
+ * command composes it with the connection (`composeConductorConfig`) into the
+ * full `ConductorFileConfig` the engine consumes.
+ */
+export type ConductorEngineConfig = Omit<ConductorFileConfig, 'site' | 'plugins'>;

package/dist/src/types.js

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

package/package.json

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

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

@@ -1,7 +0,0 @@
-export type { ConductorRegistryEntry } from '@gaia-ai/core';
-import { conductorRegistryPath, getRegisteredConductor, listRegisteredConductors, registerConductor, removeConductor } from '@gaia-ai/core';
-export { conductorRegistryPath };
-export declare const list: typeof listRegisteredConductors;
-export declare const get: typeof getRegisteredConductor;
-export declare const register: typeof registerConductor;
-export declare const remove: typeof removeConductor;

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

@@ -1,6 +0,0 @@
-import { conductorRegistryPath, getRegisteredConductor, listRegisteredConductors, registerConductor, removeConductor, } from '@gaia-ai/core';
-export { conductorRegistryPath };
-export const list = listRegisteredConductors;
-export const get = getRegisteredConductor;
-export const register = registerConductor;
-export const remove = removeConductor;