@gaia-ai/gaia 0.2.0 → 0.4.0

package/dist/src/core/conductor.js

@@ -1,287 +0,0 @@
-import { conductorId } from './conductor-id.js';
-function sleep(ms, signal) {
-    return new Promise((resolve) => {
-        if (signal?.aborted) {
-            resolve();
-            return;
-        }
-        const timer = setTimeout(() => {
-            signal?.removeEventListener('abort', onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            resolve();
-        };
-        signal?.addEventListener('abort', onAbort, { once: true });
-    });
-}
-/**
- * Formats a ticket's comments into the `{comments}` prompt block, oldest first.
- * The conductor injects this so a review→coding bounce reaches the coder with the
- * review summary in hand, independent of whether the agent remembers to fetch it.
- *
- * The body is the raw gaia_rich markup — the agent reads HTML fine, so we don't
- * strip it (a tag/entity stripper is a maintenance footgun that buys nothing for
- * an LLM reader).
- */
-function renderComments(comments) {
-    if (comments.length === 0) {
-        return '(no comments on this ticket yet)';
-    }
-    return comments
-        .map((c, i) => {
-        const when = c.created ? ` (${c.created})` : '';
-        return `[#${i + 1}] type=${c.type}${when}\n${c.body}`;
-    })
-        .join('\n\n---\n\n');
-}
-function renderPrompt(template, values) {
-    return template
-        .replaceAll('{identifier}', values.identifier)
-        .replaceAll('{state}', values.state)
-        .replaceAll('{runUuid}', values.runUuid)
-        .replaceAll('{comments}', renderComments(values.comments));
-}
-export class Conductor {
-    config;
-    remote;
-    executor;
-    workspace;
-    agent;
-    logger;
-    checkoutRoot;
-    uuid = null;
-    constructor(config, remote, executor, workspace, agent, logger, checkoutRoot = process.cwd()) {
-        this.config = config;
-        this.remote = remote;
-        this.executor = executor;
-        this.workspace = workspace;
-        this.agent = agent;
-        this.logger = logger;
-        this.checkoutRoot = checkoutRoot;
-    }
-    get id() {
-        return this.config.machine_id ?? conductorId(this.checkoutRoot);
-    }
-    /** This conductor's registration payload, built from config. */
-    registration() {
-        return {
-            id: this.id,
-            project: this.config.project,
-            states: this.config.states,
-            workspace: this.checkoutRoot,
-            label: this.config.label,
-            max_parallel: this.config.max_parallel,
-        };
-    }
-    async start() {
-        this.uuid = await this.remote.registerConductor(this.registration());
-        this.logger.info({ conductorId: this.id, uuid: this.uuid, project: this.config.project }, 'conductor started');
-    }
-    async tick() {
-        if (!this.uuid)
-            throw new Error('not started');
-        let count = await this.remote.activeRunCount(this.id);
-        // A heartbeat is the server-side self-heal: it upserts by machine_id (so it
-        // never 404s and recreates a vanished registration) and refreshes the lease
-        // — no client-side re-register, no separate status read.
-        await this.remote.heartbeat(this.registration(), count, this.config.lease_seconds);
-        this.logger.info({ conductorId: this.id, active: count }, 'conductor tick');
-        await this.finalizeDoneRuns();
-        await this.cleanupDoneTickets();
-        let claimed = 0;
-        while (count < this.config.max_parallel) {
-            const run = await this.remote.claimNext({
-                leaseSeconds: this.config.lease_seconds,
-                conductorId: this.id,
-            });
-            if (!run)
-                break;
-            this.logger.info({ conductorId: this.id, run: run.runUuid, ticket: run.ticketUuid }, 'claimed run');
-            try {
-                await this.dispatch(run);
-            }
-            catch (err) {
-                // A failed dispatch must NOT terminalise the run. The run lifecycle is
-                // server-owned; a client-side releaseRun('done') here fabricated a
-                // terminal state on failure, which reopened the ticket for claiming and
-                // re-dispatched it every tick — the GAIA-41 runaway. Leaving the run
-                // `claimed` lets the server's same-state claim conflict
-                // (TicketClaimService::retireSupersededRuns) block a re-claim of the
-                // same ticket, so we just log and move on. A run stuck `claimed` on a
-                // persistently-failing dispatch is freed by the lease-expiry reaper
-                // (separate follow-up), not here.
-                this.logger.error({ run: run.runUuid, err: String(err) }, 'dispatch failed');
-            }
-            count += 1;
-            claimed += 1;
-        }
-        if (claimed === 0) {
-            this.logger.info({
-                conductorId: this.id,
-                active: count,
-                capacity: this.config.max_parallel,
-            }, count >= this.config.max_parallel
-                ? 'at capacity, nothing claimed'
-                : 'idle, nothing to claim');
-        }
-    }
-    /**
-     * One-shot finalisation: for each of this conductor's runs that is
-     * state=done but not yet closed, read the agent transcript from its worktree
-     * and write it as the final log, then mark the run closed. Keyed off the
-     * durable `state=done AND closed=false` query — no in-memory state, so a
-     * restarted conductor still finalises any unclosed done run on its next tick.
-     */
-    async finalizeDoneRuns() {
-        const runs = await this.remote.fetchFinalizableRuns(this.id);
-        for (const r of runs) {
-            try {
-                // Ask the agent to exit gracefully (/exit) before capturing its log.
-                // Best-effort and gated on the persistent capability (only hosted
-                // executors have a live agent pane) — mirrors removeWorktree's gate.
-                // A stop failure must never block finalisation.
-                if (this.executor.capabilities().persistent) {
-                    const branch = await this.remote.getRunTicketBranchName(r.runUuid);
-                    if (branch) {
-                        try {
-                            await this.executor.stopAgent(branch);
-                        }
-                        catch (err) {
-                            this.logger.warn({ run: r.runUuid, err: String(err) }, 'agent stop failed');
-                        }
-                    }
-                }
-                const log = r.worktreePath
-                    ? await this.agent.getRunLog(r.worktreePath)
-                    : '';
-                await this.remote.finalizeRun(r.runUuid, log);
-                this.logger.info({ run: r.runUuid }, 'run finalised');
-            }
-            catch (err) {
-                this.logger.warn({ run: r.runUuid, err: String(err) }, 'run finalise failed');
-            }
-        }
-    }
-    /**
-     * One-shot ticket cleanup, symmetric to {@link finalizeDoneRuns} on the
-     * ticket axis: for each of this conductor's tickets that is state=done but not
-     * yet closed, run the workspace's `after_done` hook in the ticket's worktree,
-     * tear the worktree down (herdr), then mark the ticket closed. Keyed off the
-     * durable `state=done AND closed=false` query — no in-memory state, so a
-     * restarted conductor still cleans up.
-     *
-     * Error handling mirrors finalise: each ticket is isolated in a try/catch so
-     * one failure never wedges the tick. The `after_done` hook itself is
-     * best-effort — its failure is logged but does not block the teardown/close
-     * (reclaiming the worktree matters more than a clean environment teardown).
-     */
-    async cleanupDoneTickets() {
-        const tickets = await this.remote.fetchFinalizableTickets(this.id);
-        for (const t of tickets) {
-            try {
-                if (t.worktreePath) {
-                    try {
-                        await this.workspace.afterDone(t.worktreePath);
-                    }
-                    catch (err) {
-                        this.logger.warn({ ticket: t.ticketUuid, err: String(err) }, 'ticket after_done hook failed');
-                    }
-                }
-                // Only persistent executors host a workspace to tear down; the abstract
-                // capability keeps this executor-agnostic (mirrors the release path).
-                // Pass the stable worktreePath so the executor resolves the worktree by
-                // path, not by the mutable checked-out branch (which the coding agent
-                // may have renamed). Teardown is idempotent: a worktree herdr no longer
-                // tracks is a no-op (already gone) or a direct on-disk reclaim, not a
-                // failure — foreign worktrees in herdr's machine-global list are never
-                // surfaced. A genuine teardown failure is best-effort like after_done:
-                // logged but must not block the close (a still-closed ticket beats a
-                // wedged cleanup loop).
-                if (this.executor.capabilities().persistent) {
-                    try {
-                        await this.executor.removeWorktree(t.branchName, t.worktreePath || undefined);
-                    }
-                    catch (err) {
-                        this.logger.warn({
-                            ticket: t.ticketUuid,
-                            branch: t.branchName,
-                            worktreePath: t.worktreePath,
-                            err: String(err),
-                        }, 'worktree teardown failed');
-                    }
-                }
-                await this.remote.closeTicket(t.ticketUuid);
-                this.logger.info({ ticket: t.ticketUuid }, 'ticket cleaned up');
-            }
-            catch (err) {
-                this.logger.warn({ ticket: t.ticketUuid, err: String(err) }, 'ticket cleanup failed');
-            }
-        }
-    }
-    async dispatch(run) {
-        const t = await this.remote.getTicket(run.ticketUuid);
-        const baseRef = t.baseBranch ? `origin/${t.baseBranch}` : undefined;
-        const ws = await this.workspace.ensure(t.identifier, t.branchName, baseRef);
-        await this.workspace.beforeRun(ws.path);
-        await this.executor.retire(t.branchName);
-        const prompt = ws.instructions
-            ? renderPrompt(this.config.prompt, {
-                identifier: t.identifier,
-                state: t.state || 'triage',
-                runUuid: run.runUuid,
-                comments: t.comments,
-            })
-            : '';
-        await this.executor.startRun({
-            ticket: {
-                uuid: t.uuid,
-                identifier: t.identifier,
-                title: t.title,
-                branchName: t.branchName,
-                state: t.state,
-                ...(t.issueUrl ? { url: t.issueUrl } : {}),
-            },
-            run: { uuid: run.runUuid, id: run.runId, handler: run.handler },
-            workspacePath: ws.path,
-            instructions: ws.instructions,
-            command: this.agent.launchCommand(prompt),
-            env: {
-                GAIA_URL: this.config.site.base_url,
-                GAIA_ID: run.ticketUuid,
-                GAIA_RUN_UUID: run.runUuid,
-                WORKSPACE_ROOT: this.checkoutRoot,
-                ...(t.issueUrl ? { TICKET_URL: t.issueUrl } : {}),
-            },
-        });
-        this.logger.info({
-            ticket: t.identifier,
-            run: run.runUuid,
-            state: t.state,
-            workspace: ws.path,
-        }, 'dispatched run');
-        // The conductor — not the agent — knows the per-run git worktree path, so
-        // it persists `worktree_path` to gaia_run here alongside the running state.
-        await this.remote.markRunning(run.runUuid, { worktree_path: ws.path });
-    }
-    async serve(signal) {
-        await this.pollLoop(signal);
-    }
-    async pollLoop(signal) {
-        while (!signal?.aborted) {
-            try {
-                await this.tick();
-            }
-            catch (err) {
-                this.logger.error({ conductorId: this.id, err: String(err) }, 'tick failed');
-            }
-            await sleep(this.config.poll_interval_ms, signal);
-        }
-        // NB: the poll loop never writes status=offline itself. A graceful stop
-        // (`gaia conductor stop`) writes offline directly server-side; a crash or
-        // hard-kill leaves a stale lease that the Drupal cron reaper flips to
-        // offline (gaia_core cron → ConductorReaper). Liveness is thus always
-        // derived from status + last_seen/lease_expires_at, never from the loop.
-    }
-}

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

@@ -1,33 +0,0 @@
-import type { ConductorLogger } from './logger.js';
-export declare class ExecError extends Error {
-    readonly file: string;
-    readonly args: string[];
-    readonly exitCode: number | null;
-    readonly stderr: string;
-    constructor(file: string, args: string[], exitCode: number | null, stderr: string, options?: {
-        cause?: unknown;
-    });
-}
-export declare class CommandRunner {
-    private readonly logger;
-    constructor(logger: ConductorLogger);
-    run(file: string, args: string[], opts?: {
-        cwd?: string;
-    }): Promise<string>;
-}
-/**
- * Replace the module-level singleton runner used by {@link exec}.
- *
- * Note: out-of-package plugins (e.g. `@gaia-ai/plugin-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`
- * (production / after `pnpm build`). Under `tsx`/dev, the entry point loads
- * this module from source while the plugin loads it from dist — two separate
- * module instances — so plugin exec calls fall back to the noop logger.
- * This is functionally harmless; logging only.
- */
-export declare function setDefaultCommandRunner(r: CommandRunner): void;
-export declare function exec(file: string, args: string[], opts?: {
-    cwd?: string;
-}): Promise<string>;

package/dist/src/core/exec.js

@@ -1,65 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-export class ExecError extends Error {
-    file;
-    args;
-    exitCode;
-    stderr;
-    constructor(file, args, exitCode, stderr, options) {
-        super(`exec failed: ${file}`, options);
-        this.file = file;
-        this.args = args;
-        this.exitCode = exitCode;
-        this.stderr = stderr;
-        this.name = 'ExecError';
-    }
-}
-export class CommandRunner {
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    async run(file, args, opts = {}) {
-        try {
-            const { stdout } = await execFileAsync(file, args, {
-                encoding: 'utf8',
-                ...opts,
-            });
-            this.logger.debug({ file, args, cwd: opts.cwd }, 'exec ok');
-            return stdout;
-        }
-        catch (err) {
-            const e = err;
-            const exitCode = typeof e.code === 'number' ? e.code : null;
-            const stderr = e.stderr ?? '';
-            this.logger.error({ file, args, cwd: opts.cwd, exitCode, stderr }, 'exec failed');
-            throw new ExecError(file, args, exitCode, stderr, { cause: err });
-        }
-    }
-}
-const noopLogger = {
-    debug() { },
-    info() { },
-    warn() { },
-    error() { },
-};
-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
- * 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`
- * (production / after `pnpm build`). Under `tsx`/dev, the entry point loads
- * this module from source while the plugin loads it from dist — two separate
- * module instances — so plugin exec calls fall back to the noop logger.
- * This is functionally harmless; logging only.
- */
-export function setDefaultCommandRunner(r) {
-    defaultRunner = r;
-}
-export function exec(file, args, opts = {}) {
-    return defaultRunner.run(file, args, opts);
-}

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

@@ -1,31 +0,0 @@
-export type LogSink = {
-    kind: 'stdout';
-} | {
-    kind: 'file';
-    path: string;
-};
-export interface ConductorLogger {
-    debug(obj: object, msg?: string): void;
-    info(obj: object, msg?: string): void;
-    warn(obj: object, msg?: string): void;
-    error(obj: object, msg?: string): void;
-}
-/**
- * Pick the log sink. Precedence: explicit CLI override (`sink`) > the
- * GAIA_CONDUCTOR_LOG env var > TTY default (stdout on a TTY, file otherwise).
- */
-export declare function resolveSink(env: NodeJS.ProcessEnv, isTTY: boolean, checkoutRoot: string, override?: string): LogSink;
-/**
- * Pick the log level. Precedence: explicit CLI override (`level`) >
- * the GAIA_LOG_LEVEL env var > info.
- */
-export declare function resolveLevel(env: NodeJS.ProcessEnv, override?: string): string;
-export declare function createLogger(opts: {
-    checkoutRoot: string;
-    isTTY?: boolean;
-    env?: NodeJS.ProcessEnv;
-    /** CLI override for the level — beats env + default. */
-    level?: string;
-    /** CLI override for the sink — beats env + default. */
-    sink?: string;
-}): ConductorLogger;

package/dist/src/core/logger.js

@@ -1,36 +0,0 @@
-import { join } from 'node:path';
-import pino from 'pino';
-import pretty from 'pino-pretty';
-/**
- * Pick the log sink. Precedence: explicit CLI override (`sink`) > the
- * GAIA_CONDUCTOR_LOG env var > TTY default (stdout on a TTY, file otherwise).
- */
-export function resolveSink(env, isTTY, checkoutRoot, override) {
-    const fileSink = {
-        kind: 'file',
-        path: join(checkoutRoot, 'log.txt'),
-    };
-    const choice = override ?? env.GAIA_CONDUCTOR_LOG;
-    if (choice === 'stdout')
-        return { kind: 'stdout' };
-    if (choice === 'file')
-        return fileSink;
-    return isTTY ? { kind: 'stdout' } : fileSink;
-}
-/**
- * Pick the log level. Precedence: explicit CLI override (`level`) >
- * the GAIA_LOG_LEVEL env var > info.
- */
-export function resolveLevel(env, override) {
-    return override ?? env.GAIA_LOG_LEVEL ?? 'info';
-}
-export function createLogger(opts) {
-    const env = opts.env ?? process.env;
-    const isTTY = opts.isTTY ?? Boolean(process.stdout.isTTY);
-    const level = resolveLevel(env, opts.level);
-    const sink = resolveSink(env, isTTY, opts.checkoutRoot, opts.sink);
-    if (sink.kind === 'stdout') {
-        return pino({ level }, pretty({ colorize: true, sync: true }));
-    }
-    return pino({ level }, pino.destination({ dest: sink.path, append: true, mkdir: true }));
-}

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

@@ -1,9 +0,0 @@
-/** Default cap for a title slug — keeps tab labels and branch names short. */
-export declare const DEFAULT_SLUG_MAX_LENGTH = 40;
-/**
- * Turn free text (a ticket title) into a short, ref-safe slug:
- * lowercase, non-alphanumeric runs collapsed to `-`, trimmed, and capped to
- * `maxLength` characters without leaving a trailing separator. Returns `''`
- * for input that has no usable characters.
- */
-export declare function slugify(text: string, maxLength?: number): string;

package/dist/src/core/slug.js

@@ -1,18 +0,0 @@
-/** Default cap for a title slug — keeps tab labels and branch names short. */
-export const DEFAULT_SLUG_MAX_LENGTH = 40;
-/**
- * Turn free text (a ticket title) into a short, ref-safe slug:
- * lowercase, non-alphanumeric runs collapsed to `-`, trimmed, and capped to
- * `maxLength` characters without leaving a trailing separator. Returns `''`
- * for input that has no usable characters.
- */
-export function slugify(text, maxLength = DEFAULT_SLUG_MAX_LENGTH) {
-    const slug = text
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    if (slug.length <= maxLength) {
-        return slug;
-    }
-    return slug.slice(0, maxLength).replace(/-+$/g, '');
-}

package/dist/src/index.d.ts

@@ -1,16 +0,0 @@
-export type { GaiaCliDeps } from './cli/gaia.js';
-export { main, runGaiaCli } from './cli/gaia.js';
-export type { ConductorRegistryEntry } from './cli/local-registry.js';
-export { DEFAULT_AGENT_PROMPT, loadConductorConfig } from './config.js';
-export { Conductor } from './core/conductor.js';
-export { conductorId } from './core/conductor-id.js';
-export type { GaiaExecutor } from './plugins/executor/executor.js';
-export type { ExecutorPlugin, RemotePlugin, WorkspacePlugin, } from './plugins/plugins.js';
-export { selectExecutor, selectRemote, selectWorkspace, } from './plugins/plugins.js';
-export { DrupalGaiaRemote, drupalRemote } from './plugins/remote/drupal.js';
-export { FakeGaiaRemote, fakeRemote } from './plugins/remote/fake.js';
-export type { GaiaRemote } from './plugins/remote/remote.js';
-export { FakeWorkspace, fakeWorkspace } from './plugins/workspace/fake.js';
-export { GitWorkspace, gitWorkspace } from './plugins/workspace/git.js';
-export type { GaiaWorkspace } from './plugins/workspace/workspace.js';
-export type * from './types.js';

package/dist/src/index.js

@@ -1,9 +0,0 @@
-export { main, runGaiaCli } from './cli/gaia.js';
-export { DEFAULT_AGENT_PROMPT, loadConductorConfig } from './config.js';
-export { Conductor } from './core/conductor.js';
-export { conductorId } from './core/conductor-id.js';
-export { selectExecutor, selectRemote, selectWorkspace, } from './plugins/plugins.js';
-export { DrupalGaiaRemote, drupalRemote } from './plugins/remote/drupal.js';
-export { FakeGaiaRemote, fakeRemote } from './plugins/remote/fake.js';
-export { FakeWorkspace, fakeWorkspace } from './plugins/workspace/fake.js';
-export { GitWorkspace, gitWorkspace } from './plugins/workspace/git.js';

package/dist/src/plugin-api.d.ts

@@ -1,7 +0,0 @@
-export { CommandRunner, ExecError, exec, setDefaultCommandRunner, } from './core/exec.js';
-export { DEFAULT_SLUG_MAX_LENGTH, slugify } from './core/slug.js';
-export type { GaiaAgent } from './plugins/agent/agent.js';
-export type * from './plugins/executor/executor.js';
-export type { AgentPlugin, ExecutorPlugin, RemotePlugin, WorkspacePlugin, } from './plugins/plugins.js';
-export { loadInstructions } from './plugins/workspace/instructions.js';
-export type { EnsuredWorkspace, GaiaWorkspace, } from './plugins/workspace/workspace.js';

package/dist/src/plugin-api.js

@@ -1,3 +0,0 @@
-export { CommandRunner, ExecError, exec, setDefaultCommandRunner, } from './core/exec.js';
-export { DEFAULT_SLUG_MAX_LENGTH, slugify } from './core/slug.js';
-export { loadInstructions } from './plugins/workspace/instructions.js';

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

@@ -1,20 +0,0 @@
-/**
- * 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>;
-}

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

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

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

@@ -1,11 +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): {
-    id: string;
-    authProvider: unknown;
-};

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

@@ -1,35 +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}`,
-                        },
-                    };
-                },
-            };
-        },
-    };
-    return { id: 'gaia-basic-auth', authProvider };
-}

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

@@ -1,61 +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>;
-}
-export interface GaiaExecutor {
-    id: string;
-    capabilities(): ExecutorCapabilities;
-    startRun(input: SpawnRunInput): Promise<SpawnedSession>;
-    /** Send C-c to every open (non-`(done)`) tab in the branch workspace and
-     * append ` (done)` to its label. Best-effort, non-destructive: tabs stay open
-     * for the human to close. */
-    retire(branch: string): Promise<void>;
-    /**
-     * Ask the agent in each open (non-`(done)`) tab of the branch workspace to
-     * exit gracefully by typing `/exit` + Enter into its pane — a clean shutdown
-     * vs {@link retire}'s C-c SIGINT. Called by the conductor's run-finalise pass
-     * once a run is done. Best-effort and non-destructive (tabs stay open); a
-     * no-op for non-persistent executors (no hosted agent pane), so the conductor
-     * gates the call on `capabilities().persistent`.
-     */
-    stopAgent(branch: string): 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. Implementations MUST NOT silently succeed when no worktree
-     * matches — surface the miss (throw with the wanted branch/path and what the
-     * executor actually lists) so it is visible rather than a silent skip.
-     */
-    removeWorktree(branch: string, worktreePath?: string): Promise<void>;
-}

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

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