@gaia-ai/gaia 0.2.0 → 0.4.0

package/dist/src/plugins/remote/fake.js

@@ -1,203 +0,0 @@
-const ACTIVE = ['claimed', 'running'];
-export class FakeGaiaRemote {
-    calls = {
-        markRunning: [],
-        finalizeRun: [],
-        closeTicket: [],
-    };
-    /**
-     * Override for reconcile tests: when set, `fetchActiveRuns` returns this
-     * list verbatim instead of deriving it from the internal runs map.
-     */
-    activeRuns = null;
-    runs = new Map();
-    queue = [];
-    tickets;
-    conductorStatus = 'online';
-    /** Stable counter for assigning numeric ids to unseeded runs. */
-    runIdCounter = 0;
-    constructor(seed = {}) {
-        this.tickets = seed.tickets ?? {};
-        for (const r of seed.runs ?? []) {
-            const handler = r.handler ?? 'code';
-            // Use the seeded id when provided; otherwise assign a deterministic counter.
-            const runId = r.id ?? ++this.runIdCounter;
-            this.runs.set(r.runUuid, {
-                runUuid: r.runUuid,
-                runId,
-                ticketUuid: r.ticketUuid,
-                handler,
-                state: r.state ?? r.stateAtStart,
-                stateAtStart: r.stateAtStart,
-                ...(r.worktreePath !== undefined
-                    ? { worktreePath: r.worktreePath }
-                    : {}),
-                ...(r.closed !== undefined ? { closed: r.closed } : {}),
-            });
-            this.queue.push({
-                runUuid: r.runUuid,
-                runId,
-                ticketUuid: r.ticketUuid,
-                stateAtStart: r.stateAtStart,
-                handler,
-            });
-        }
-    }
-    async registerConductor(_reg) {
-        this.conductorStatus = 'online';
-        return 'fake-conductor-uuid';
-    }
-    async heartbeat() {
-        // Mirrors the server: a heartbeat always brings the conductor online.
-        this.conductorStatus = 'online';
-        return this.conductorStatus;
-    }
-    async getConductorStatus(_conductorId) {
-        return this.conductorStatus;
-    }
-    async setConductorStatus(_conductorId, status) {
-        this.conductorStatus = status;
-    }
-    async listConductors(_owner) {
-        return [];
-    }
-    async activeRunCount(_conductorId) {
-        return this.internalActiveRuns().length;
-    }
-    async fetchActiveRuns(_conductorId) {
-        if (this.activeRuns !== null) {
-            return this.activeRuns;
-        }
-        return this.internalActiveRuns().map((r) => {
-            const ticket = this.tickets[r.ticketUuid];
-            const identifier = ticket?.identifier ?? '';
-            const branchName = ticket?.branchName ??
-                (identifier ? `gaia/${identifier.toLowerCase()}` : '');
-            return {
-                runUuid: r.runUuid,
-                ticketUuid: r.ticketUuid,
-                ticketIdentifier: identifier,
-                branchName,
-                state: r.state,
-                stateAtStart: r.stateAtStart,
-                worktreePath: r.worktreePath ?? '',
-            };
-        });
-    }
-    async claimNext(_claim) {
-        return this.queue.shift() ?? null;
-    }
-    async getTicket(ticketUuid) {
-        const t = this.tickets[ticketUuid];
-        if (!t) {
-            throw new Error(`fake remote: ticket ${ticketUuid} not seeded`);
-        }
-        const branchName = t.branchName ?? `gaia/${t.identifier.toLowerCase()}`;
-        return {
-            uuid: ticketUuid,
-            identifier: t.identifier,
-            title: t.title,
-            state: t.state,
-            branchName,
-            ...(t.baseBranch ? { baseBranch: t.baseBranch } : {}),
-            comments: t.comments ?? [],
-            ...(t.url ? { issueUrl: t.url } : {}),
-        };
-    }
-    async getRunWorktree(runUuid) {
-        return this.runs.get(runUuid)?.worktreePath ?? '';
-    }
-    async getRunTicketIdentifier(runUuid) {
-        const ticketUuid = this.runs.get(runUuid)?.ticketUuid;
-        if (!ticketUuid) {
-            return '';
-        }
-        return this.tickets[ticketUuid]?.identifier ?? '';
-    }
-    async getRunTicketBranchName(runUuid) {
-        const ticketUuid = this.runs.get(runUuid)?.ticketUuid;
-        if (!ticketUuid) {
-            return '';
-        }
-        const ticket = this.tickets[ticketUuid];
-        if (!ticket) {
-            return '';
-        }
-        return ticket.branchName ?? `gaia/${ticket.identifier.toLowerCase()}`;
-    }
-    async markRunning(runUuid, attrs) {
-        this.calls.markRunning.push({
-            runUuid,
-            ...(attrs
-                ? {
-                    attrs: {
-                        ...(attrs.worktree_path
-                            ? { worktree_path: attrs.worktree_path }
-                            : {}),
-                    },
-                }
-                : {}),
-        });
-        const run = this.runs.get(runUuid);
-        if (run) {
-            run.state = 'running';
-            if (attrs?.worktree_path) {
-                run.worktreePath = attrs.worktree_path;
-            }
-        }
-    }
-    async fetchFinalizableRuns(_conductorId) {
-        return [...this.runs.values()]
-            .filter((r) => r.state === 'done' && !r.closed)
-            .map((r) => ({ runUuid: r.runUuid, worktreePath: r.worktreePath ?? '' }));
-    }
-    async finalizeRun(runUuid, log) {
-        this.calls.finalizeRun.push({ runUuid, log });
-        const run = this.runs.get(runUuid);
-        if (run) {
-            run.closed = true;
-            if (log)
-                run.log = log;
-        }
-    }
-    async fetchFinalizableTickets(_conductorId) {
-        return Object.entries(this.tickets)
-            .filter(([, t]) => t.state === 'done' && !t.closed)
-            .map(([ticketUuid, t]) => ({
-            ticketUuid,
-            branchName: t.branchName ?? `gaia/${t.identifier.toLowerCase()}`,
-            worktreePath: this.latestRunWorktree(ticketUuid),
-        }));
-    }
-    async closeTicket(uuid) {
-        this.calls.closeTicket.push(uuid);
-        const t = this.tickets[uuid];
-        if (t) {
-            t.closed = true;
-        }
-    }
-    /** Worktree path of the ticket's most recently seeded run, or '' when none. */
-    latestRunWorktree(ticketUuid) {
-        let worktree = '';
-        for (const r of this.runs.values()) {
-            if (r.ticketUuid === ticketUuid && r.worktreePath) {
-                worktree = r.worktreePath;
-            }
-        }
-        return worktree;
-    }
-    internalActiveRuns() {
-        return [...this.runs.values()].filter((r) => ACTIVE.includes(r.state));
-    }
-}
-export function fakeRemote(seed = {}) {
-    const remote = new FakeGaiaRemote(seed);
-    return {
-        kind: 'remote',
-        id: 'fake',
-        requiredModules: [],
-        async createRemote(_config) {
-            return remote;
-        },
-    };
-}

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

@@ -1,143 +0,0 @@
-export interface ConductorRegistration {
-    id: string;
-    project: string;
-    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;
-}
-/** A ticket comment, as the conductor injects it into the dispatch prompt. */
-export interface TicketComment {
-    /** comment | spec | plan | debug_diagnose | summary | acceptance | test */
-    type: string;
-    /** Raw body (gaia_rich HTML). */
-    body: string;
-    /** ISO 8601 creation timestamp. */
-    created: 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;
-    issueUrl?: string;
-    /**
-     * Comments on the ticket, oldest first. The conductor renders these into the
-     * dispatch prompt so a review→coding bounce carries the review summary to the
-     * coder. Empty when the ticket has none — or when the session role lacks
-     * `view gaia_comment` (the include degrades to an empty set, never an error).
-     */
-    comments: TicketComment[];
-}
-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;
-    /** Absolute path of the per-run git worktree, or '' when unset. */
-    worktreePath: string;
-}
-/**
- * A ticket this conductor owns that is state=done but not yet closed — the
- * conductor's ticket-cleanup work list (worktree teardown + close), symmetric
- * to {@link FinalizableRun}.
- */
-export interface FinalizableTicket {
-    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 cleanup command runs in.
-     */
-    worktreePath: string;
-}
-/** 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;
-}
-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>;
-    /**
-     * 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 and (when non-empty) log. No state
-     * change — the run is already done.
-     */
-    finalizeRun(uuid: string, log: string): Promise<void>;
-    /**
-     * Tickets this conductor owns that are state=done but not yet closed — the
-     * conductor's one-shot ticket-cleanup work list. Durable-query driven (no
-     * in-memory state), mirroring {@link fetchFinalizableRuns}.
-     */
-    fetchFinalizableTickets(conductorId: string): Promise<FinalizableTicket[]>;
-    /**
-     * Close a ticket: set closed=true + closed_date so it is not reprocessed on
-     * the next tick. No state change — the ticket is already done. Mirrors
-     * {@link finalizeRun}.
-     */
-    closeTicket(uuid: string): Promise<void>;
-}

package/dist/src/plugins/remote/remote.js

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

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

@@ -1,9 +0,0 @@
-import type { WorkspacePlugin } from '../plugins.js';
-import type { EnsuredWorkspace, GaiaWorkspace } from './workspace.js';
-export declare class FakeWorkspace implements GaiaWorkspace {
-    ensure(identifier: string, _title?: string): Promise<EnsuredWorkspace>;
-    beforeRun(_path: string): Promise<void>;
-    afterRun(_path: string): Promise<void>;
-    afterDone(_path: string): Promise<void>;
-}
-export declare function fakeWorkspace(): WorkspacePlugin;

package/dist/src/plugins/workspace/fake.js

@@ -1,19 +0,0 @@
-export class FakeWorkspace {
-    async ensure(identifier, _title) {
-        return { path: `/fake/${identifier}`, instructions: null };
-    }
-    async beforeRun(_path) { }
-    async afterRun(_path) { }
-    async afterDone(_path) { }
-}
-export function fakeWorkspace() {
-    const workspace = new FakeWorkspace();
-    return {
-        kind: 'workspace',
-        id: 'fake',
-        requiredModules: [],
-        async createWorkspace(_config) {
-            return workspace;
-        },
-    };
-}

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

@@ -1,53 +0,0 @@
-import type { WorkspacePlugin } from '../plugins.js';
-import type { EnsuredWorkspace, GaiaWorkspace } from './workspace.js';
-/** Default branch template: `<prefix><key>-<title-slug>` (readable). */
-export declare const DEFAULT_BRANCH_TEMPLATE = "{branchPrefix}{key}-{titleSlug}";
-export type HookRunner = (command: string, cwd: string) => Promise<void>;
-export type GitRunner = (args: string[], cwd: string) => Promise<void>;
-export interface WorkspaceHooks {
-    after_create?: string;
-    before_run?: string;
-    after_run?: string;
-    /** Run in the worktree once its ticket is done, before teardown. */
-    after_done?: string;
-}
-export interface GitWorkspaceOptions {
-    /** Main clone (a git repo): config source + worktree base. */
-    root: string;
-    /** Where per-ticket worktrees live. Default: `${root}-worktrees`. */
-    worktreesRoot?: string;
-    /** Branch name prefix per ticket. Default: 'gaia/'. */
-    branchPrefix?: string;
-    /**
-     * Branch name template. Vars: {branchPrefix}, {key} (sanitized identifier),
-     * {identifier}, {titleSlug}. Default: `{branchPrefix}{key}-{titleSlug}`.
-     */
-    branchTemplate?: string;
-    hooks?: WorkspaceHooks;
-    runHook?: HookRunner;
-    runGit?: GitRunner;
-}
-export declare class GitWorkspace implements GaiaWorkspace {
-    private readonly options;
-    private readonly runHook;
-    private readonly runGit;
-    private readonly root;
-    private readonly worktreesRoot;
-    private readonly branchPrefix;
-    private readonly branchTemplate;
-    constructor(options: GitWorkspaceOptions);
-    /** Render the branch name for a ticket from the configured template. */
-    branchFor(identifier: string, title?: string): string;
-    keyFor(identifier: string): string;
-    private pathFor;
-    ensure(identifier: string, title?: string, _baseRef?: string): Promise<EnsuredWorkspace>;
-    remove(identifier: string): Promise<void>;
-    beforeRun(path: string): Promise<void>;
-    afterRun(path: string): Promise<void>;
-    afterDone(path: string): Promise<void>;
-}
-export declare function gitWorkspace(opts?: {
-    hooks?: WorkspaceHooks;
-    branchPrefix?: string;
-    branchTemplate?: string;
-}): WorkspacePlugin;

package/dist/src/plugins/workspace/git.js

@@ -1,113 +0,0 @@
-import { existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { exec } from '../../core/exec.js';
-import { slugify } from '../../core/slug.js';
-import { loadInstructions } from './instructions.js';
-/** Default branch template: `<prefix><key>-<title-slug>` (readable). */
-export const DEFAULT_BRANCH_TEMPLATE = '{branchPrefix}{key}-{titleSlug}';
-function renderBranchTemplate(template, vars) {
-    const rendered = template.replace(/\{(\w+)\}/g, (whole, key) => {
-        const value = vars[key];
-        return value === undefined ? whole : value;
-    });
-    // An empty title slug leaves a dangling separator (e.g. `gaia/GL-9-`) —
-    // trim trailing branch separators so the branch stays a valid, tidy ref.
-    return rendered.replace(/[-_./]+$/g, '');
-}
-const defaultHookRunner = async (command, cwd) => {
-    await exec('sh', ['-c', command], { cwd });
-};
-const defaultGitRunner = async (args, cwd) => {
-    await exec('git', args, { cwd });
-};
-export class GitWorkspace {
-    options;
-    runHook;
-    runGit;
-    root;
-    worktreesRoot;
-    branchPrefix;
-    branchTemplate;
-    constructor(options) {
-        this.options = options;
-        this.runHook = options.runHook ?? defaultHookRunner;
-        this.runGit = options.runGit ?? defaultGitRunner;
-        this.root = resolve(options.root);
-        this.worktreesRoot = options.worktreesRoot
-            ? resolve(options.worktreesRoot)
-            : `${this.root}-worktrees`;
-        this.branchPrefix = options.branchPrefix ?? 'gaia/';
-        this.branchTemplate = options.branchTemplate ?? DEFAULT_BRANCH_TEMPLATE;
-    }
-    /** Render the branch name for a ticket from the configured template. */
-    branchFor(identifier, title) {
-        return renderBranchTemplate(this.branchTemplate, {
-            branchPrefix: this.branchPrefix,
-            key: this.keyFor(identifier),
-            identifier,
-            titleSlug: slugify(title ?? ''),
-        });
-    }
-    keyFor(identifier) {
-        return identifier.replace(/[^A-Za-z0-9._-]/g, '_');
-    }
-    pathFor(key) {
-        return resolve(join(this.worktreesRoot, key));
-    }
-    async ensure(identifier, title, _baseRef) {
-        const key = this.keyFor(identifier);
-        // Reject empty and dot-leading keys: a dot-leading key would produce an
-        // invalid git ref (e.g. `gaia/.hidden`) and covers '.'/'..' too.
-        if (key === '' || key.startsWith('.')) {
-            throw new Error(`invalid workspace identifier: ${identifier}`);
-        }
-        const path = this.pathFor(key);
-        if (existsSync(path)) {
-            return { path, instructions: loadInstructions(path) };
-        }
-        const branch = this.branchFor(identifier, title);
-        await this.runGit(['-C', this.root, 'worktree', 'add', '--force', '-B', branch, path], this.root);
-        if (this.options.hooks?.after_create) {
-            await this.runHook(this.options.hooks.after_create, path);
-        }
-        return { path, instructions: loadInstructions(path) };
-    }
-    async remove(identifier) {
-        const key = this.keyFor(identifier);
-        const path = this.pathFor(key);
-        await this.runGit(['-C', this.root, 'worktree', 'remove', '--force', path], this.root);
-    }
-    async beforeRun(path) {
-        if (this.options.hooks?.before_run) {
-            await this.runHook(this.options.hooks.before_run, path);
-        }
-    }
-    async afterRun(path) {
-        if (this.options.hooks?.after_run) {
-            await this.runHook(this.options.hooks.after_run, path);
-        }
-    }
-    async afterDone(path) {
-        if (this.options.hooks?.after_done) {
-            await this.runHook(this.options.hooks.after_done, path);
-        }
-    }
-}
-export function gitWorkspace(opts = {}) {
-    return {
-        kind: 'workspace',
-        id: 'git',
-        requiredModules: [],
-        async createWorkspace(config) {
-            const root = config.config_path
-                ? dirname(config.config_path)
-                : process.cwd();
-            return new GitWorkspace({
-                root,
-                ...(opts.hooks ? { hooks: opts.hooks } : {}),
-                ...(opts.branchPrefix ? { branchPrefix: opts.branchPrefix } : {}),
-                ...(opts.branchTemplate ? { branchTemplate: opts.branchTemplate } : {}),
-            });
-        },
-    };
-}

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

@@ -1,6 +0,0 @@
-/** Loads ./WORKFLOW.md from the workspace, hashing its content. */
-export declare function loadInstructions(workspacePath: string): {
-    path: string;
-    sha256: string;
-    text: string;
-} | null;

package/dist/src/plugins/workspace/instructions.js

@@ -1,16 +0,0 @@
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-/** Loads ./WORKFLOW.md from the workspace, hashing its content. */
-export function loadInstructions(workspacePath) {
-    const path = resolve(workspacePath, 'WORKFLOW.md');
-    if (!existsSync(path)) {
-        return null;
-    }
-    const text = readFileSync(path, 'utf8');
-    return {
-        path,
-        sha256: createHash('sha256').update(text).digest('hex'),
-        text,
-    };
-}

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

@@ -1,33 +0,0 @@
-export interface EnsuredWorkspace {
-    path: string;
-    instructions: {
-        path: string;
-        sha256: string;
-        text: string;
-    } | null;
-}
-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.
-     */
-    ensure(identifier: string, branch?: string, baseRef?: string): Promise<EnsuredWorkspace>;
-    beforeRun(path: string): Promise<void>;
-    afterRun(path: string): Promise<void>;
-    /**
-     * Run the `after_done` hook in the worktree once its ticket is done, just
-     * before the executor tears the worktree down — the ticket-lifecycle
-     * counterpart to the `after_create` setup hook. Lets a configured command
-     * (e.g. `ddev delete`) reclaim environment state. A no-op when no hook is
-     * configured.
-     */
-    afterDone(path: string): Promise<void>;
-}

package/dist/src/plugins/workspace/workspace.js

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

package/dist/src/types.d.ts

@@ -1,51 +0,0 @@
-import type { DropSHPlugin } from 'dropsh/plugin';
-import type { AgentPlugin, 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. */
-    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;
-    agent: AgentPlugin;
-    workspace: WorkspacePlugin;
-    /** dropsh-layer plugins (auth etc.); separate from the GAIA slots. */
-    plugins?: DropSHPlugin[];
-}

package/dist/src/types.js

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