@gaia-ai/core 0.5.5 → 0.6.1

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

@@ -1,104 +0,0 @@
-export interface SpawnedSession {
-    sessionRef: string;
-}
-export interface ExecutorCapabilities {
-    persistent: boolean;
-}
-export interface SpawnRunInput {
-    ticket: {
-        uuid: string;
-        identifier: string;
-        title: string;
-        branchName: string;
-        state: string;
-        url?: string;
-    };
-    run: {
-        uuid: string;
-        id: number;
-        handler: string;
-    };
-    workspacePath: string;
-    instructions: {
-        path: string;
-        sha256: string;
-        text: string;
-    } | null;
-    command?: string;
-    env?: Record<string, string>;
-}
-/** The four lifecycle-hook slots, keyed exactly like `config.hooks`. */
-export type HookName = 'after_create' | 'before_run' | 'after_run' | 'after_done';
-/** Context for a hook invocation — carries the ticket for observable logging. */
-export interface HookContext {
-    /** The ticket identifier/uuid the hook is running for (log context). */
-    ticket: string;
-}
-export interface GaiaExecutor {
-    id: string;
-    capabilities(): ExecutorCapabilities;
-    /**
-     * Run the lifecycle hook `name` (command from `config.hooks[name]`) in `cwd`,
-     * best-effort. This is the SINGLE catch point for all lifecycle hooks:
-     *
-     * - MUST NEVER throw. No configured command → silent no-op. A failing command
-     *   → `logger.error({hook,worktree,ticket,err}, 'lifecycle hook failed')` then
-     *   return. So a hook failure never aborts dispatch or wedges a run in
-     *   `claimed`.
-     * - The underlying shell command still fails honestly (a non-zero exit
-     *   rejects); only the executor catches + logs + continues.
-     *
-     * `env`, when given, is the run's resolved environment (per-ticket env_vars
-     * merged with the core GAIA_* vars, GAIA-99), merged over the hook process's
-     * inherited env. Values may be sensitive — implementations must never log
-     * them (log key names only).
-     */
-    runHook(name: HookName, cwd: string, ctx: HookContext, env?: Record<string, string>): Promise<void>;
-    startRun(input: SpawnRunInput): Promise<SpawnedSession>;
-    /**
-     * Signal the run's agent to stop. Called by the conductor's run-finalise pass
-     * BEFORE it captures the agent transcript (GAIA-132), so a stop must not
-     * destroy the log. For herdr this is a NO-OP: at finalise time the agent is
-     * idle and its jsonl transcript is already fully written to disk, and the
-     * subsequent {@link cleanupRun} tab-close kills the PTY (the agent dies with
-     * it). The seam exists for executors whose agent outlives its UI surface.
-     * Best-effort; gated by the conductor on `capabilities().persistent`.
-     */
-    stopRun(branch: string): Promise<void>;
-    /**
-     * Tear down ONE run's hosted UI surface — for herdr, close only the tab whose
-     * label carries the `#<runId>` token (`startRun` labels every tab
-     * `<identifier> · <state> #<run.id>`), via `herdr tab close <tab_id>` (killing
-     * that PTY). Run-scoped by design (GAIA-183): a sibling run's tab in the same
-     * branch workspace — a still-open prior-state run or a concurrent re-claim —
-     * and any non-run tab are left untouched. Called as the LAST finalisation step,
-     * strictly after the transcript is captured, and again at dispatch to clear a
-     * reused workspace's leftover tab for the run being (re-)started. No matching
-     * tab → a quiet no-op. Does NOT touch the branch worktree (that is the
-     * reap/{@link removeWorktree} lifecycle). Best-effort: a failing tab-close is
-     * swallowed and never aborts finalisation or dispatch. A no-op for
-     * non-persistent executors.
-     */
-    cleanupRun(branch: string, runId: number): Promise<void>;
-    /**
-     * Tear down the branch's entire worktree (git worktree + hosted workspace),
-     * reclaiming its disk. Called by the conductor's ticket-cleanup pass once a
-     * ticket is done. A no-op for non-persistent executors (no hosted workspace);
-     * the conductor gates the call on `capabilities().persistent`.
-     *
-     * `worktreePath` is the stable, identifier-derived worktree path (from the
-     * ticket's latest run). Prefer it over `branch` to resolve the worktree: the
-     * checked-out branch is mutable (the coding agent may rename/switch it), the
-     * path is not.
-     *
-     * Returns whether the worktree was actually present on THIS host and torn
-     * down (or reclaimed on disk) — i.e. whether the teardown happened locally.
-     * `false` means nothing matched here: the worktree is either already gone or
-     * lives on another conductor's host. The reaper uses this to avoid marking a
-     * ticket `cleaned_up` for a worktree it did not actually tear down (a
-     * cross-host false-teardown), leaving it for the host that physically holds
-     * it. A genuine failure still throws (surfaced as a teardown miss); a `false`
-     * return is a clean "not here", not an error.
-     */
-    removeWorktree(branch: string, worktreePath?: string): Promise<boolean>;
-}

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

@@ -1,60 +0,0 @@
-import type { DropSHPlugin } from 'dropsh/plugin';
-import type { ConductorLogger } from '../core/logger.js';
-import type { ConductorFileConfig } from '../types.js';
-import type { GaiaAgent } from './agent/agent.js';
-import type { GaiaExecutor } from './executor/executor.js';
-import type { GaiaRemote, Ticket } from './remote/remote.js';
-import type { GaiaWorkspace } from './workspace/workspace.js';
-/** Runtime dependencies handed to a plugin factory at selection time. */
-export interface ExecutorDeps {
-    /** The in-scope conductor logger — the executor logs hook failures through it. */
-    logger: ConductorLogger;
-}
-export interface RemotePlugin extends DropSHPlugin {
-    readonly kind: 'remote';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createRemote(config: ConductorFileConfig): Promise<GaiaRemote>;
-}
-export interface ExecutorPlugin extends DropSHPlugin {
-    readonly kind: 'executor';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createExecutor(config: ConductorFileConfig, deps: ExecutorDeps): Promise<GaiaExecutor>;
-}
-export interface WorkspacePlugin extends DropSHPlugin {
-    readonly kind: 'workspace';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createWorkspace(config: ConductorFileConfig): Promise<GaiaWorkspace>;
-}
-export interface AgentPlugin extends DropSHPlugin {
-    readonly kind: 'agent';
-    readonly id: string;
-    readonly requiredModules: string[];
-    createAgent(config: ConductorFileConfig): Promise<GaiaAgent>;
-}
-/** Resolves the remote from its named config slot. */
-export declare function selectRemote(config: ConductorFileConfig): Promise<GaiaRemote>;
-/** Resolves the executor from its named config slot, injecting the logger. */
-export declare function selectExecutor(config: ConductorFileConfig, logger: ConductorLogger): Promise<GaiaExecutor>;
-/** Resolves the workspace from its named config slot. */
-export declare function selectWorkspace(config: ConductorFileConfig): Promise<GaiaWorkspace>;
-/** A config-side agent choice: an agent plugin + an optional static priority over the ticket. */
-export interface AgentCandidate {
-    agent: AgentPlugin;
-    priority?: (ticket: Ticket) => number;
-}
-/** A constructed candidate: the agent id, its GaiaAgent, and the config-side priority. */
-export interface ResolvedAgent {
-    id: string;
-    agent: GaiaAgent;
-    priority?: (ticket: Ticket) => number;
-}
-/**
- * Pick the agent for a ticket: highest `priority(ticket)` wins; a candidate with
- * no `priority` scores lowest; ties resolve by config array order (stable sort).
- */
-export declare function selectAgent(candidates: ResolvedAgent[], ticket: Ticket): ResolvedAgent;
-/** Constructs every agent candidate from the resolved config slot (single or array). */
-export declare function selectAgents(config: ConductorFileConfig): Promise<ResolvedAgent[]>;

package/dist/src/plugins/plugins.js

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

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

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

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

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

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

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

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

@@ -1,369 +0,0 @@
-import { resolveAuth } from 'dropsh';
-import { createHttpClient, createJsonApiClient } from 'dropsh/plugin';
-const ACTIVE = ['claimed', 'running'];
-export class DrupalGaiaRemote {
-    api;
-    constructor(api) {
-        this.api = api;
-    }
-    async fetchActiveRuns(id) {
-        // The conductor identity `id` is the machine_id (hash of hostname+path).
-        // gaia_run links to its owning conductor via the `conductor_id` entity-ref;
-        // filter on the related conductor's `machine_id` (nested relationship filter).
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .whereIn('state', ACTIVE)
-            .fields(['state', 'state_at_start', 'worktree_path'])
-            .page(100)
-            .list();
-        return Promise.all(rows.map(async (r) => ({
-            runUuid: r.id,
-            ticketUuid: r.rel('ticket_id') ?? '',
-            ticketIdentifier: await this.getRunTicketIdentifier(r.id),
-            branchName: await this.getRunTicketBranchName(r.id),
-            state: r.attr('state') ?? '',
-            stateAtStart: r.attr('state_at_start') ?? '',
-            worktreePath: r.attr('worktree_path') ?? '',
-        })));
-    }
-    async activeRunCount(id) {
-        // Filter on the related conductor's `machine_id` (nested relationship filter).
-        return this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .whereIn('state', ACTIVE)
-            .fields(['drupal_internal__id'])
-            .page(100)
-            .count();
-    }
-    async claimNext(c) {
-        const res = (await this.api.post('gaia/claim-next', {
-            data: {
-                attributes: {
-                    lease_seconds: c.leaseSeconds,
-                    // Server (`ConductorResolverTrait`) narrows to the caller's conductor
-                    // by the `machine_id` attribute; `c.conductorId` IS the machine_id.
-                    machine_id: c.conductorId,
-                },
-            },
-        }));
-        if (!res?.data) {
-            return null;
-        }
-        const d = res.data;
-        const rawId = d.attributes?.drupal_internal__id;
-        if (rawId === undefined || rawId === null) {
-            throw new Error(`claimNext: missing drupal_internal__id on run ${d.id}`);
-        }
-        return {
-            runUuid: d.id,
-            runId: Number(rawId),
-            ticketUuid: d.relationships?.ticket_id?.data?.id ?? '',
-            stateAtStart: String(d.attributes?.state_at_start ?? ''),
-            // handler_id was dropped; the handler is the work the run does, i.e. the
-            // ticket state the run started in.
-            handler: String(d.attributes?.state_at_start ?? ''),
-        };
-    }
-    async getTicket(uuid) {
-        // The agent self-reads the ticket + its comments at run start (GAIA-112),
-        // so getTicket needs no ?include=comments — but it DOES sideload labels +
-        // environments (GAIA-144) so a config-side priority(ticket) can read them
-        // without fetching (AC-5).
-        const doc = (await this.api.get(`gaia_ticket/gaia_ticket/${uuid}?include=labels,environments`));
-        const attrs = doc.data?.attributes ?? {};
-        const issueUrl = typeof attrs.origin === 'string' ? attrs.origin : undefined;
-        const included = Array.isArray(doc.included) ? doc.included : [];
-        const byId = new Map(included.map((r) => [`${r.type}:${r.id}`, r]));
-        const refs = (name) => {
-            const data = doc.data?.relationships?.[name]?.data;
-            return Array.isArray(data) ? data : [];
-        };
-        const labels = refs('labels')
-            .map((ref) => byId.get(`${ref.type}:${ref.id}`)?.attributes?.name)
-            .filter((n) => typeof n === 'string');
-        const environments = refs('environments')
-            .map((ref) => {
-            const a = byId.get(`${ref.type}:${ref.id}`)?.attributes ?? {};
-            return {
-                name: typeof a.name === 'string' ? a.name : '',
-                tier: typeof a.tier === 'string' ? a.tier : '',
-            };
-        })
-            .filter((e) => e.name !== '');
-        return {
-            uuid: doc.data?.id ?? uuid,
-            identifier: typeof attrs.identifier === 'string' ? attrs.identifier : uuid,
-            title: typeof attrs.title === 'string' ? attrs.title : '',
-            state: typeof attrs.state === 'string' ? attrs.state : '',
-            branchName: typeof attrs.branch_name === 'string' ? attrs.branch_name : '',
-            ...(typeof attrs.base_branch === 'string' && attrs.base_branch !== ''
-                ? { baseBranch: attrs.base_branch }
-                : {}),
-            ...(typeof attrs.effective_env_vars === 'string' &&
-                attrs.effective_env_vars !== ''
-                ? { effectiveEnvVars: attrs.effective_env_vars }
-                : {}),
-            ...(issueUrl ? { issueUrl } : {}),
-            labels,
-            environments,
-        };
-    }
-    async getRunWorktree(uuid) {
-        const r = await this.api.resource('gaia_run', uuid);
-        return r.attr('worktree_path') ?? '';
-    }
-    async getRunTicketIdentifier(uuid) {
-        const run = await this.api.resource('gaia_run', uuid);
-        const ticketUuid = run.rel('ticket_id');
-        if (!ticketUuid) {
-            return '';
-        }
-        const ticket = await this.api.resource('gaia_ticket', ticketUuid);
-        return ticket.attr('identifier') ?? '';
-    }
-    async getRunTicketBranchName(uuid) {
-        const run = await this.api.resource('gaia_run', uuid);
-        const ticketUuid = run.rel('ticket_id');
-        if (!ticketUuid) {
-            return '';
-        }
-        const ticket = await this.api.resource('gaia_ticket', ticketUuid);
-        return ticket.attr('branch_name') ?? '';
-    }
-    async registerConductor(reg) {
-        const r = await this.api.upsert('gaia_conductor', { path: 'machine_id', value: reg.id }, {
-            attributes: {
-                machine_id: reg.id,
-                status: 'online',
-                workspace_root: reg.workspace,
-                label: reg.label,
-                states: reg.states,
-                max_parallel: reg.max_parallel,
-            },
-            relationships: {
-                owner_user_id: {
-                    data: { type: 'user--user', id: await this.api.me() },
-                },
-                project_id: {
-                    data: {
-                        type: 'gaia_project--gaia_project',
-                        id: await this.projectUuid(reg.project),
-                    },
-                },
-            },
-        });
-        return r.id; // drupal uuid
-    }
-    async heartbeat(reg, load, lease = 300) {
-        // Server-side upsert by machine_id (see HeartbeatResource): never 404s,
-        // heals a vanished registration, and returns the resulting status. Sending
-        // the full registration lets the server recreate the entity when missing.
-        const res = (await this.api.post('gaia/heartbeat', {
-            data: {
-                attributes: {
-                    machine_id: reg.id,
-                    project: reg.project,
-                    states: reg.states,
-                    workspace_root: reg.workspace,
-                    label: reg.label,
-                    max_parallel: reg.max_parallel,
-                    current_load: load,
-                    lease_seconds: lease,
-                },
-            },
-        }));
-        const status = res?.data?.attributes?.status;
-        return typeof status === 'string' ? status : 'online';
-    }
-    async getConductorStatus(id) {
-        const c = await this.api
-            .collection('gaia_conductor')
-            .where('machine_id', '=', id)
-            .fields(['status'])
-            .first();
-        return c ? (c.attr('status') ?? null) : null;
-    }
-    async setConductorStatus(id, status) {
-        const c = await this.api
-            .collection('gaia_conductor')
-            .where('machine_id', '=', id)
-            .first();
-        if (c) {
-            await this.api.update('gaia_conductor', c.id, { attributes: { status } });
-        }
-    }
-    async listConductors(owner) {
-        let col = this.api.collection('gaia_conductor');
-        if (owner === 'me') {
-            col = col.where('owner_user_id.id', '=', await this.api.me());
-        }
-        const rows = await col.page(200).list();
-        return rows.map((r) => ({
-            id: r.attr('machine_id') ?? r.id,
-            project: '',
-            label: r.attr('label') ?? '',
-            status: r.attr('status') ?? '',
-            lastSeen: r.attr('last_seen') ?? 0,
-            load: r.attr('current_load') ?? 0,
-        }));
-    }
-    async markRunning(uuid, attrs) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_run', uuid, {
-            attributes: {
-                state: 'running',
-                heartbeat: t,
-                ...(attrs?.worktree_path ? { worktree_path: attrs.worktree_path } : {}),
-                ...(attrs?.agent ? { agent: attrs.agent } : {}),
-            },
-        });
-    }
-    async markFailed(uuid, errorLog) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_run', uuid, {
-            attributes: {
-                state: 'failed',
-                error_log: errorLog,
-                closed: true,
-                closed_date: t,
-            },
-        });
-    }
-    async fetchFinalizableRuns(id) {
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('conductor_id.machine_id', '=', id)
-            .where('state', '=', 'done')
-            .where('closed', '=', '0')
-            .fields(['worktree_path', 'agent', 'drupal_internal__id'])
-            .page(100)
-            .list();
-        // No `started_at` read: the run's duration_s is derived from the agent
-        // transcript at finalize (GAIA-151), so the conductor no longer round-trips
-        // the timestamp back through JSON:API.
-        return rows.map((r) => ({
-            runUuid: r.id,
-            // The `#<runId>` tab-label token: scopes the run's tab-close (GAIA-183).
-            runId: Number(r.attr('drupal_internal__id')),
-            worktreePath: r.attr('worktree_path') ?? '',
-            agent: r.attr('agent') ?? '',
-        }));
-    }
-    async finalizeRun(uuid, log, metrics) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_run', uuid, {
-            attributes: {
-                closed: true,
-                closed_date: t,
-                ...(log ? { log } : {}),
-                ...(metrics ?? {}),
-            },
-        }); // NO state — the run is already done.
-    }
-    async fetchUncleanedTickets(id) {
-        // Finished tickets whose worktree is not yet torn down (cleaned_up=0),
-        // driven by the durable `cleaned_up` flag (GAIA-89) AND scoped to this
-        // conductor (GAIA-121): only tickets assigned to `id` are loaded, so a
-        // ticket owned by another conductor never reaches the reaper loop. "Finished"
-        // = reached `done` OR already `closed`; the collection builder has no OR, so
-        // this is two AND-queries merged + de-duped by uuid. The `conductor_id`
-        // relationship carries the assigned conductor's `machine_id` — the same
-        // nested filter the sibling reaper queries (`fetchFinalizableRuns` etc.) use.
-        const fields = ['branch_name', 'state', 'closed'];
-        const done = await this.api
-            .collection('gaia_ticket')
-            .where('conductor_id.machine_id', '=', id)
-            .where('state', '=', 'done')
-            .where('cleaned_up', '=', '0')
-            .fields(fields)
-            .page(100)
-            .list();
-        const closed = await this.api
-            .collection('gaia_ticket')
-            .where('conductor_id.machine_id', '=', id)
-            .where('closed', '=', '1')
-            .where('cleaned_up', '=', '0')
-            .fields(fields)
-            .page(100)
-            .list();
-        const byUuid = new Map();
-        for (const r of [...done, ...closed]) {
-            byUuid.set(r.id, r);
-        }
-        return Promise.all([...byUuid.values()].map(async (r) => ({
-            ticketUuid: r.id,
-            branchName: r.attr('branch_name') ?? '',
-            state: r.attr('state') ?? '',
-            closed: r.attr('closed') ?? false,
-            worktreePath: await this.latestRunWorktree(r.id),
-        })));
-    }
-    async closeTicket(uuid) {
-        const t = Math.floor(Date.now() / 1000);
-        await this.api.update('gaia_ticket', uuid, {
-            attributes: { closed: true, closed_date: t },
-        }); // NO state — the ticket is already done.
-    }
-    async markTicketCleanedUp(uuid) {
-        await this.api.update('gaia_ticket', uuid, {
-            attributes: { cleaned_up: true },
-        }); // NO state/closed — teardown flag only, decoupled from the lifecycle.
-    }
-    /**
-     * Absolute worktree path of the ticket's latest run (highest run id with a
-     * non-empty worktree_path), or '' when none — the cwd the cleanup command
-     * runs in. The conductor persists worktree_path on markRunning, so a done
-     * ticket's run carries the path even after the run closed.
-     */
-    async latestRunWorktree(ticketUuid) {
-        const rows = await this.api
-            .collection('gaia_run')
-            .where('ticket_id.id', '=', ticketUuid)
-            .fields(['worktree_path', 'drupal_internal__id'])
-            .sort('-drupal_internal__id')
-            .page(100)
-            .list();
-        for (const r of rows) {
-            const path = r.attr('worktree_path');
-            if (path) {
-                return path;
-            }
-        }
-        return '';
-    }
-    async projectUuid(name) {
-        const p = await this.api
-            .collection('gaia_project')
-            .where('name', '=', name)
-            .first();
-        if (!p) {
-            throw new Error(`gaia project "${name}" not found`);
-        }
-        return p.id;
-    }
-}
-export function drupalRemote() {
-    return {
-        kind: 'remote',
-        id: 'drupal',
-        requiredModules: [],
-        async createRemote(config) {
-            const http = createHttpClient();
-            const auth = await resolveAuth({
-                baseUrl: config.site.base_url,
-                plugins: config.plugins ?? [],
-                http,
-                now: Date.now,
-                // stateDir omitted → dropsh defaultStateDir() (~/.config/dropsh)
-            });
-            return new DrupalGaiaRemote(createJsonApiClient({
-                baseUrl: config.site.base_url,
-                prefix: config.site.jsonapi_prefix,
-                http,
-                auth: auth,
-            }));
-        },
-    };
-}