@gaia-ai/core 0.6.0 → 0.6.2

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

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

package/dist/src/plugins/remote/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;

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

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

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

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

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

@@ -1 +0,0 @@
-export * from './plugins/registry-exports.js';

package/dist/src/plugins-index.js

@@ -1 +0,0 @@
-export * from './plugins/registry-exports.js';