@gaia-ai/core 0.5.5 → 0.6.1

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

@@ -1,109 +0,0 @@
-import type { RemotePlugin } from '../plugins.js';
-import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunMetrics, RunWriteAttributes, Ticket, UncleanTicket } from './remote.js';
-export interface FakeSeedRun {
-    runUuid: string;
-    /** Numeric (drupal_internal__id) run id. Defaults to a stable 1-based counter when omitted. */
-    id?: number;
-    ticketUuid: string;
-    stateAtStart: string;
-    /** Override the initial state (defaults to stateAtStart). */
-    state?: string;
-    handler?: string;
-    worktreePath?: string;
-    closed?: boolean;
-    /** Id of the agent that ran (GAIA-144) — routes footprint parsing at finalize. */
-    agent?: string;
-}
-export interface FakeSeedTicket {
-    identifier: string;
-    title: string;
-    state: string;
-    branchName?: string;
-    /** Computed base branch (parent branch / project default / 'main'). */
-    baseBranch?: string;
-    /** Effective env vars (parent-chain resolved) as `.env`-style lines. */
-    effectiveEnvVars?: string;
-    url?: string;
-    workflow?: string;
-    /** Label term names sideloaded for agent selection (GAIA-144). */
-    labels?: string[];
-    /** Environments sideloaded for agent selection (GAIA-144). */
-    environments?: {
-        name: string;
-        tier: string;
-    }[];
-    /** Whether the ticket is already closed (its lifecycle wound up). */
-    closed?: boolean;
-    /** Whether the ticket's worktree is already torn down (cleaned_up flag). */
-    cleanedUp?: boolean;
-    /**
-     * machine_id of the conductor this ticket is assigned to (GAIA-121). Omit to
-     * mean "belongs to the querying conductor" (the common case for reaper tests);
-     * set an explicit value to test conductor-scoping, or `''` for unassigned.
-     */
-    conductorId?: string;
-}
-export interface FakeRemoteSeed {
-    runs?: FakeSeedRun[];
-    tickets?: Record<string, FakeSeedTicket>;
-}
-export interface MarkRunningCall {
-    runUuid: string;
-    attrs?: {
-        worktree_path?: string;
-        agent?: string;
-    };
-}
-export interface FinalizeRunCall {
-    runUuid: string;
-    log: string;
-    metrics?: RunMetrics;
-}
-export interface MarkFailedCall {
-    runUuid: string;
-    errorLog: string;
-}
-export declare class FakeGaiaRemote implements GaiaRemote {
-    readonly calls: {
-        markRunning: MarkRunningCall[];
-        markFailed: MarkFailedCall[];
-        finalizeRun: FinalizeRunCall[];
-        closeTicket: string[];
-        markCleanedUp: string[];
-    };
-    /**
-     * Override for reconcile tests: when set, `fetchActiveRuns` returns this
-     * list verbatim instead of deriving it from the internal runs map.
-     */
-    activeRuns: ActiveRun[] | null;
-    private readonly runs;
-    private readonly queue;
-    private readonly tickets;
-    private conductorStatus;
-    /** Stable counter for assigning numeric ids to unseeded runs. */
-    private runIdCounter;
-    constructor(seed?: FakeRemoteSeed);
-    registerConductor(_reg: ConductorRegistration): Promise<string>;
-    heartbeat(): 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>;
-    getRunWorktree(runUuid: string): Promise<string>;
-    getRunTicketIdentifier(runUuid: string): Promise<string>;
-    getRunTicketBranchName(runUuid: string): Promise<string>;
-    markRunning(runUuid: string, attrs?: RunWriteAttributes): Promise<void>;
-    markFailed(runUuid: string, errorLog: string): Promise<void>;
-    fetchFinalizableRuns(_conductorId: string): Promise<FinalizableRun[]>;
-    finalizeRun(runUuid: string, log: string, metrics?: RunMetrics): Promise<void>;
-    fetchUncleanedTickets(conductorId: string): Promise<UncleanTicket[]>;
-    closeTicket(uuid: string): Promise<void>;
-    markTicketCleanedUp(uuid: string): Promise<void>;
-    /** Worktree path of the ticket's most recently seeded run, or '' when none. */
-    private latestRunWorktree;
-    private internalActiveRuns;
-}
-export declare function fakeRemote(seed?: FakeRemoteSeed): RemotePlugin;

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

@@ -1,243 +0,0 @@
-const ACTIVE = ['claimed', 'running'];
-export class FakeGaiaRemote {
-    calls = {
-        markRunning: [],
-        markFailed: [],
-        finalizeRun: [],
-        closeTicket: [],
-        markCleanedUp: [],
-    };
-    /**
-     * 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.agent !== undefined ? { agent: r.agent } : {}),
-                ...(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 } : {}),
-            ...(t.effectiveEnvVars ? { effectiveEnvVars: t.effectiveEnvVars } : {}),
-            ...(t.url ? { issueUrl: t.url } : {}),
-            labels: t.labels ?? [],
-            environments: t.environments ?? [],
-        };
-    }
-    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 }
-                            : {}),
-                        ...(attrs.agent ? { agent: attrs.agent } : {}),
-                    },
-                }
-                : {}),
-        });
-        const run = this.runs.get(runUuid);
-        if (run) {
-            run.state = 'running';
-            if (attrs?.worktree_path) {
-                run.worktreePath = attrs.worktree_path;
-            }
-            if (attrs?.agent) {
-                run.agent = attrs.agent;
-            }
-        }
-    }
-    async markFailed(runUuid, errorLog) {
-        this.calls.markFailed.push({ runUuid, errorLog });
-        const run = this.runs.get(runUuid);
-        if (run) {
-            run.state = 'failed';
-            run.closed = true;
-        }
-    }
-    async fetchFinalizableRuns(_conductorId) {
-        return [...this.runs.values()]
-            .filter((r) => r.state === 'done' && !r.closed)
-            .map((r) => ({
-            runUuid: r.runUuid,
-            runId: r.runId,
-            worktreePath: r.worktreePath ?? '',
-            agent: r.agent ?? '',
-        }));
-    }
-    async finalizeRun(runUuid, log, metrics) {
-        this.calls.finalizeRun.push({
-            runUuid,
-            log,
-            ...(metrics ? { metrics } : {}),
-        });
-        const run = this.runs.get(runUuid);
-        if (run) {
-            run.closed = true;
-            if (log)
-                run.log = log;
-        }
-    }
-    async fetchUncleanedTickets(conductorId) {
-        // Scoped to the querying conductor (GAIA-121). A seed without an explicit
-        // `conductorId` defaults to the querying conductor (the common reaper-test
-        // case); an explicit value scopes it, and `''` models an unassigned ticket.
-        return Object.entries(this.tickets)
-            .filter(([, t]) => (t.state === 'done' || t.closed) &&
-            !t.cleanedUp &&
-            (t.conductorId ?? conductorId) === conductorId)
-            .map(([ticketUuid, t]) => ({
-            ticketUuid,
-            branchName: t.branchName ?? `gaia/${t.identifier.toLowerCase()}`,
-            worktreePath: this.latestRunWorktree(ticketUuid),
-            state: t.state,
-            closed: t.closed ?? false,
-        }));
-    }
-    async closeTicket(uuid) {
-        this.calls.closeTicket.push(uuid);
-        const t = this.tickets[uuid];
-        if (t) {
-            t.closed = true;
-        }
-    }
-    async markTicketCleanedUp(uuid) {
-        this.calls.markCleanedUp.push(uuid);
-        const t = this.tickets[uuid];
-        if (t) {
-            t.cleanedUp = 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,193 +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;
-}
-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>;
-}

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

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

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

@@ -1,6 +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>;
-}
-export declare function fakeWorkspace(): WorkspacePlugin;

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

@@ -1,16 +0,0 @@
-export class FakeWorkspace {
-    async ensure(identifier, _title) {
-        return { path: `/fake/${identifier}`, instructions: null, created: true };
-    }
-}
-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,37 +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 GitRunner = (args: string[], cwd: string) => Promise<void>;
-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;
-    runGit?: GitRunner;
-}
-export declare class GitWorkspace implements GaiaWorkspace {
-    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>;
-}
-export declare function gitWorkspace(opts?: {
-    branchPrefix?: string;
-    branchTemplate?: string;
-}): WorkspacePlugin;