@gaia-ai/gaia 0.1.4

package/dist/index.js

@@ -0,0 +1,2041 @@
+// src/cli/gaia.ts
+import { dirname as dirname4 } from "node:path";
+import { createInterface } from "node:readline";
+import { Command } from "commander";
+import { authStatus, buildProgram as buildDropshProgram } from "dropsh";
+
+// src/config.ts
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/core/conductor-id.ts
+import { createHash } from "node:crypto";
+import { hostname } from "node:os";
+function conductorId(absPath) {
+  return createHash("sha256").update(`${hostname()}:${absPath}`).digest("hex").slice(0, 16);
+}
+
+// src/config.ts
+var DEFAULT_AGENT_PROMPT = `You are a GAIA agent working ticket {identifier}, current state: {state}. Follow the "{state}" section of ./WORKFLOW.md in this repository. This run covers EXACTLY the {state} state - do only its work. Do not start, prepare, or perform any later state's work, even if WORKFLOW.md mentions transitioning onward. When the {state} work is done and you have no open questions, STOP - do not pick up or work any further state or ticket. If blocked or you need a human, stop and surface the blocker. After you have written the ticket's next state, run /exit to end this session.
+
+The ticket's comments are included below (oldest first). Read them before acting: the latest \`summary\` is the review feedback you MUST address, and any \`spec\`/\`debug_diagnose\` is the agreed plan/diagnosis. Treat their points as in-scope acceptance criteria.
+
+--- Ticket comments ---
+{comments}`;
+function requirePlugin(value, kind) {
+  if (!isRecord(value) || value.kind !== kind) {
+    throw new Error(
+      `conductor config requires a ${kind} plugin in the "${kind}" slot`
+    );
+  }
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireNonEmptyString(value, key) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`conductor config requires non-empty ${key}`);
+  }
+  return value;
+}
+function optionalPositiveInteger(value, fallback, key) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new Error(`conductor config requires positive integer ${key}`);
+  }
+  return value;
+}
+async function loadConductorConfig(configFile) {
+  const configPath = resolve(configFile);
+  const module = await import(pathToFileURL(configPath).href);
+  const raw = module.default;
+  if (!isRecord(raw)) {
+    throw new Error("conductor config default export must be an object");
+  }
+  const config = raw;
+  const site = isRecord(config.site) ? config.site : {};
+  const baseUrl = requireNonEmptyString(site.base_url, "site.base_url");
+  const project = requireNonEmptyString(config.project, "project");
+  if (!Array.isArray(config.states) || config.states.length === 0) {
+    throw new Error("conductor config requires non-empty states");
+  }
+  const states = config.states.map(
+    (state) => requireNonEmptyString(state, "states")
+  );
+  const checkoutRoot = dirname(configPath);
+  const machineId = typeof config.machine_id === "string" && config.machine_id.trim() !== "" ? config.machine_id : conductorId(checkoutRoot);
+  const label = typeof config.label === "string" && config.label.trim() !== "" ? config.label : machineId;
+  return {
+    site: {
+      base_url: baseUrl,
+      jsonapi_prefix: typeof site.jsonapi_prefix === "string" && site.jsonapi_prefix.trim() !== "" ? site.jsonapi_prefix : "/jsonapi"
+    },
+    ...Array.isArray(config.plugins) ? { plugins: config.plugins } : {},
+    remote: requirePlugin(config.remote, "remote"),
+    executor: requirePlugin(config.executor, "executor"),
+    agent: requirePlugin(config.agent, "agent"),
+    workspace: requirePlugin(config.workspace, "workspace"),
+    label,
+    machine_id: machineId,
+    project,
+    states,
+    prompt: typeof config.prompt === "string" && config.prompt.trim() !== "" ? config.prompt : DEFAULT_AGENT_PROMPT,
+    max_parallel: optionalPositiveInteger(
+      config.max_parallel,
+      1,
+      "max_parallel"
+    ),
+    poll_interval_ms: optionalPositiveInteger(
+      config.poll_interval_ms,
+      5e3,
+      "poll_interval_ms"
+    ),
+    lease_seconds: optionalPositiveInteger(
+      config.lease_seconds,
+      300,
+      "lease_seconds"
+    ),
+    ...config.hooks !== void 0 ? { hooks: config.hooks } : {},
+    config_path: configPath
+  };
+}
+
+// src/core/conductor.ts
+function sleep(ms, signal) {
+  return new Promise((resolve5) => {
+    if (signal?.aborted) {
+      resolve5();
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve5();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve5();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+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}
+${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));
+}
+var Conductor = class {
+  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;
+  }
+  config;
+  remote;
+  executor;
+  workspace;
+  agent;
+  logger;
+  checkoutRoot;
+  uuid = null;
+  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);
+    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) {
+        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 {
+        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"
+            );
+          }
+        }
+        if (this.executor.capabilities().persistent) {
+          try {
+            await this.executor.removeWorktree(
+              t.branchName,
+              t.worktreePath || void 0
+            );
+          } 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}` : void 0;
+    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"
+    );
+    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);
+    }
+  }
+};
+
+// src/core/exec.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var ExecError = class extends Error {
+  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";
+  }
+  file;
+  args;
+  exitCode;
+  stderr;
+};
+var CommandRunner = class {
+  constructor(logger) {
+    this.logger = 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 });
+    }
+  }
+};
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+var defaultRunner = new CommandRunner(noopLogger);
+function setDefaultCommandRunner(r) {
+  defaultRunner = r;
+}
+function exec(file, args, opts = {}) {
+  return defaultRunner.run(file, args, opts);
+}
+
+// src/core/logger.ts
+import { join } from "node:path";
+import pino from "pino";
+import pretty from "pino-pretty";
+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;
+}
+function resolveLevel(env, override) {
+  return override ?? env.GAIA_LOG_LEVEL ?? "info";
+}
+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 })
+  );
+}
+
+// src/plugins/plugins.ts
+async function selectRemote(config) {
+  return config.remote.createRemote(config);
+}
+async function selectExecutor(config) {
+  return config.executor.createExecutor(config);
+}
+async function selectWorkspace(config) {
+  return config.workspace.createWorkspace(config);
+}
+async function selectAgent(config) {
+  return config.agent.createAgent(config);
+}
+
+// src/cli/init.ts
+import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { hostname as hostname2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+function q(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function renderCommittedConfig(inputs) {
+  return `// Canonical GAIA conductor config \u2014 committed. Connection + identity come from
+// your user-global machine context (~/.config/conductor/conductor.config.machine.js:
+// { machine_id, user_id, base_url, client_id, client_secret }); machine_id is
+// composed here as \`\${user_id}-\${machine_id}-\${project}\`. \`project\` is the only
+// per-repo value and is baked in below. The client_secret is read from the
+// machine context (gitignored, user-only) \u2014 never committed here.
+// A global \`@gaia-ai/gaia\` install exposes the whole plugin surface from one entry.
+import {
+  claudeAgent,
+  drupalRemote,
+  herdrExecutor,
+  herdrWorkspace,
+  oauth2Plugin,
+} from '@gaia-ai/gaia/plugins';
+
+// The user-global machine context: identity + connection (incl. secret), shared
+// by every project on this machine. Never committed.
+async function loadMachine() {
+  try {
+    return (await import(\`\${process.env.HOME}/.config/conductor/conductor.config.machine.js\`)).default ?? {};
+  } catch {}
+  return {};
+}
+
+// OPTIONAL per-project override \u2014 create conductor.config.local.js beside this
+// file to override any field (machine_id, base_url, model, \u2026). It is loaded only
+// if present and is NOT created by \`gaia conductor init\`.
+async function loadLocal() {
+  try { return (await import('./conductor.config.local.js')).default ?? {}; } catch {}
+  return {};
+}
+
+const machine = await loadMachine();
+const local = await loadLocal();
+const project = local.project ?? ${q(inputs.project)};
+const baseUrl = local.base_url ?? machine.base_url;
+const clientId = local.oauth?.client_id ?? machine.client_id ?? 'gaia-agent';
+const clientSecret = local.oauth?.client_secret ?? machine.client_secret;
+const composedMachineId =
+  machine.user_id && machine.machine_id
+    ? \`\${machine.user_id}-\${machine.machine_id}-\${project}\`
+    : undefined;
+
+export default {
+  site: { base_url: baseUrl, jsonapi_prefix: local.jsonapi_prefix ?? '/jsonapi' },
+  project,
+  machine_id: local.machine_id ?? composedMachineId,
+  states: ['spec', 'diagnose', 'coding', 'review'],
+  max_parallel: 5,
+  remote: drupalRemote(),
+  executor: herdrExecutor({
+    states: {
+      review: { panes: [{ direction: 'right', command: 'git -C {workspacePath} diff' }] },
+    },
+  }),
+  agent: claudeAgent({ model: local.model ?? 'claude-opus-4-8' }),
+  workspace: herdrWorkspace({
+    hooks: { after_create: 'ddev init-worktree', after_done: 'ddev delete -Oy' },
+  }),
+  plugins: [
+    oauth2Plugin({
+      id: 'session',
+      default: true,
+      type: 'oauth2_client_credentials',
+      client_id: clientId,
+      client_secret: clientSecret,
+      token_url: \`\${baseUrl}/oauth/token\`,
+      scope: 'gaia:session',
+    }),
+    oauth2Plugin({
+      id: 'pm',
+      type: 'oauth2_client_credentials',
+      client_id: clientId,
+      client_secret: clientSecret,
+      token_url: \`\${baseUrl}/oauth/token\`,
+      scope: 'gaia:project_manager',
+    }),
+  ],
+};
+`;
+}
+function renderMachineContext(ctx) {
+  return `// User-global conductor context \u2014 gitignored, user-only (chmod 0600), never
+// committed. A plain importable module holding your machine identity +
+// connection, incl. the OAuth client secret. Committed conductor.config.js files
+// import this to compose machine_id (\`\${user_id}-\${machine_id}-\${project}\`) and
+// read base_url / client_id / client_secret. Created and gap-filled by
+// \`gaia conductor init\`; existing values are never overwritten.
+export default {
+  machine_id: ${q(ctx.machine_id)},
+  user_id: ${q(ctx.user_id)},
+  base_url: ${q(ctx.base_url)},
+  client_id: ${q(ctx.client_id)},
+  client_secret: ${q(ctx.client_secret)},
+};
+`;
+}
+function machineContextPath() {
+  return join2(
+    process.env.HOME ?? "",
+    ".config",
+    "conductor",
+    "conductor.config.machine.js"
+  );
+}
+async function readMachineContext(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const mod = await import(`${pathToFileURL2(path).href}?t=${Date.now()}`);
+    const raw = mod.default;
+    return raw && typeof raw === "object" ? raw : {};
+  } catch {
+    return {};
+  }
+}
+async function scaffoldMachineContext(opts) {
+  const existing = await readMachineContext(opts.path);
+  const derived = {
+    machine_id: opts.machineId ?? hostname2(),
+    user_id: opts.userId,
+    base_url: opts.baseUrl,
+    client_id: opts.clientId,
+    client_secret: opts.secret
+  };
+  const filledKeys = [];
+  const merged = { ...derived, ...existing };
+  for (const key of [
+    "machine_id",
+    "user_id",
+    "base_url",
+    "client_id",
+    "client_secret"
+  ]) {
+    const cur = existing[key];
+    if (typeof cur !== "string" || cur.trim() === "") {
+      merged[key] = derived[key];
+      filledKeys.push(key);
+    }
+  }
+  const created = !existsSync(opts.path);
+  if (filledKeys.length > 0 || created) {
+    mkdirSync(dirname2(opts.path), { recursive: true });
+    writeFileSync(opts.path, renderMachineContext(merged), "utf8");
+  }
+  if (existsSync(opts.path)) chmodSync(opts.path, 384);
+  return { path: opts.path, created, filledKeys };
+}
+async function scaffold(inputs, opts) {
+  const committedPath = opts.configPath;
+  mkdirSync(dirname2(committedPath), { recursive: true });
+  let wroteCommitted = false;
+  if (!existsSync(committedPath) || opts.force) {
+    writeFileSync(committedPath, renderCommittedConfig(inputs), "utf8");
+    wroteCommitted = true;
+  }
+  const machine = await scaffoldMachineContext({
+    path: opts.machinePath ?? machineContextPath(),
+    userId: inputs.userId ?? "",
+    baseUrl: inputs.baseUrl,
+    clientId: inputs.clientId,
+    secret: inputs.secret,
+    ...inputs.machineId !== void 0 ? { machineId: inputs.machineId } : {}
+  });
+  return { committedPath, wroteCommitted, machine };
+}
+
+// src/cli/local-registry.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
+function registryPath() {
+  const home = process.env.GAIA_HOME ?? homedir();
+  return join3(home, ".gaia", "conductors.json");
+}
+async function read() {
+  let raw;
+  try {
+    raw = await readFile(registryPath(), "utf8");
+  } catch {
+    return {};
+  }
+  if (raw.trim() === "") {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+async function write(data) {
+  const path = registryPath();
+  await mkdir(dirname3(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+}
+async function register(entry) {
+  const data = await read();
+  data[entry.id] = entry;
+  await write(data);
+}
+async function remove(id) {
+  const data = await read();
+  if (data[id]) {
+    delete data[id];
+    await write(data);
+  }
+}
+async function list() {
+  return Object.values(await read());
+}
+async function get(id) {
+  const data = await read();
+  return data[id] ?? null;
+}
+
+// src/cli/gaia.ts
+function defaultConfigPath(override) {
+  return override ?? process.env.GAIA_CONDUCTOR_CONFIG ?? "./.gaia/conductor.config.js";
+}
+async function resolveConfig(deps, configPathOverride) {
+  if (deps.config) {
+    return deps.config;
+  }
+  return loadConductorConfig(defaultConfigPath(configPathOverride));
+}
+async function resolveRemote(deps, config) {
+  return deps.remote ?? await selectRemote(config);
+}
+function checkoutRootOf(config) {
+  return dirname4(config.config_path);
+}
+function conductorIdOf(config) {
+  return config.machine_id ?? conductorId(checkoutRootOf(config));
+}
+function logOptsOf(cmd) {
+  const opts = cmd.optsWithGlobals();
+  return {
+    ...opts.logLevel !== void 0 ? { level: opts.logLevel } : {},
+    ...opts.logSink !== void 0 ? { sink: opts.logSink } : {}
+  };
+}
+function loggerFor(checkoutRoot, log = {}) {
+  const logger = createLogger({ checkoutRoot, ...log });
+  setDefaultCommandRunner(new CommandRunner(logger));
+  return logger;
+}
+function parseHerdrJson(output, command) {
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`herdr ${command} returned invalid JSON`);
+  }
+}
+async function spawnViaHerdr(label, cwd, cmd) {
+  const created = await exec("herdr", [
+    "workspace",
+    "create",
+    "--cwd",
+    cwd,
+    "--label",
+    label,
+    "--no-focus"
+  ]);
+  const parsed = parseHerdrJson(created, "workspace create");
+  const paneId = parsed.result?.root_pane?.pane_id;
+  if (!paneId) {
+    throw new Error("herdr workspace create returned no pane id");
+  }
+  await exec("herdr", ["pane", "run", paneId, cmd]);
+}
+async function killViaHerdr(label) {
+  const listed = await exec("herdr", ["workspace", "list"]);
+  const parsed = parseHerdrJson(listed, "workspace list");
+  const ws = (parsed.result?.workspaces ?? []).find((w) => w.label === label);
+  if (ws?.workspace_id) {
+    await exec("herdr", ["workspace", "close", ws.workspace_id]);
+  }
+}
+var DEFAULT_FRESH_S = 120;
+function freshnessThresholdS(config) {
+  return config ? Math.max(DEFAULT_FRESH_S, config.lease_seconds * 2) : DEFAULT_FRESH_S;
+}
+function classify(hub, freshS) {
+  if (!hub) {
+    return "registry-only";
+  }
+  if (hub.status === "offline") {
+    return "stopped";
+  }
+  const nowS = Math.floor(Date.now() / 1e3);
+  const fresh = hub.lastSeen > 0 && nowS - hub.lastSeen <= freshS;
+  return fresh ? "running" : "wedged";
+}
+async function buildLsRows(remote, config, onlyId) {
+  const entries = await list();
+  let hub = [];
+  try {
+    hub = await remote.listConductors("me");
+  } catch {
+    hub = [];
+  }
+  const hubById = new Map(hub.map((c) => [c.id, c]));
+  const freshS = freshnessThresholdS(config);
+  const ids = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    ids.add(e.id);
+  }
+  for (const c of hub) {
+    ids.add(c.id);
+  }
+  const rows = [];
+  for (const id of ids) {
+    if (onlyId && id !== onlyId) {
+      continue;
+    }
+    const entry = entries.find((e) => e.id === id);
+    const h = hubById.get(id);
+    rows.push({
+      id,
+      project: entry?.project ?? h?.project ?? "",
+      label: entry?.label ?? h?.label ?? "",
+      host: entry?.host ?? "-",
+      status: classify(h, freshS)
+    });
+  }
+  return rows;
+}
+function printRows(rows) {
+  if (rows.length === 0) {
+    console.log("no conductors registered");
+    return;
+  }
+  for (const r of rows) {
+    console.log(`${r.id}	${r.status}	${r.host}	${r.project}	${r.label}`);
+  }
+}
+async function ensureAuthenticated(config, logger) {
+  const st = await authStatus({
+    baseUrl: config.site.base_url,
+    plugins: config.plugins ?? []
+  });
+  if (!st.loggedIn) {
+    logger.error(
+      { baseUrl: config.site.base_url },
+      `not logged in against ${config.site.base_url} \u2014 run 'gaia dropsh auth login'`
+    );
+    return false;
+  }
+  return true;
+}
+async function cmdPoll(deps, log = {}) {
+  const config = await resolveConfig(deps);
+  const checkoutRoot = checkoutRootOf(config);
+  const logger = loggerFor(checkoutRoot, log);
+  if (!await ensureAuthenticated(config, logger)) return;
+  const remote = await resolveRemote(deps, config);
+  const executor = deps.executor ?? await selectExecutor(config);
+  const workspace = deps.workspace ?? await selectWorkspace(config);
+  const agent = deps.agent ?? await selectAgent(config);
+  const conductor = new Conductor(
+    config,
+    remote,
+    executor,
+    workspace,
+    agent,
+    logger,
+    checkoutRoot
+  );
+  await conductor.start();
+  await conductor.tick();
+}
+async function cmdStartForeground(deps, log = {}) {
+  const config = await resolveConfig(deps);
+  const checkoutRoot = checkoutRootOf(config);
+  const logger = loggerFor(checkoutRoot, log);
+  if (!await ensureAuthenticated(config, logger)) return;
+  const remote = await resolveRemote(deps, config);
+  const executor = deps.executor ?? await selectExecutor(config);
+  const workspace = deps.workspace ?? await selectWorkspace(config);
+  const agent = deps.agent ?? await selectAgent(config);
+  const conductor = new Conductor(
+    config,
+    remote,
+    executor,
+    workspace,
+    agent,
+    logger,
+    checkoutRoot
+  );
+  await conductor.start();
+  const controller = new AbortController();
+  const onSignal = () => controller.abort();
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  try {
+    await conductor.serve(controller.signal);
+  } finally {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+  }
+}
+async function cmdStart(deps, log = {}) {
+  const config = await resolveConfig(deps);
+  const checkoutRoot = checkoutRootOf(config);
+  const logger = loggerFor(checkoutRoot, log);
+  if (!await ensureAuthenticated(config, logger)) return;
+  const remote = await resolveRemote(deps, config);
+  const id = conductorIdOf(config);
+  const existing = await get(id);
+  if (existing) {
+    const hubStatus = await remote.getConductorStatus(id);
+    if (hubStatus !== null && hubStatus !== "offline") {
+      console.log(`conductor already running for ${config.project}`);
+      return;
+    }
+  }
+  const handle = `gaia-conductor:${id}`;
+  await register({
+    id,
+    path: checkoutRoot,
+    project: config.project,
+    label: config.label,
+    host: "herdr",
+    handle
+  });
+  const fgFlags = [
+    log.level ? `--log-level ${log.level}` : "",
+    log.sink ? `--log-sink ${log.sink}` : ""
+  ].filter(Boolean).join(" ");
+  const fgCmd = `GAIA_CONDUCTOR_LOG=file gaia conductor ${fgFlags} start --foreground`.replace(
+    /\s+/g,
+    " "
+  );
+  try {
+    await spawnViaHerdr(handle, checkoutRoot, fgCmd);
+    logger.info({ id, handle }, "started conductor via herdr");
+  } catch (err) {
+    logger.error(
+      { id, err: err.message },
+      "could not start via herdr"
+    );
+    logger.warn(
+      {},
+      "Hint: run `gaia conductor start --foreground` under a service manager (systemd-user / docker) on hosts without herdr."
+    );
+  }
+}
+async function cmdStop(deps, now) {
+  const config = await resolveConfig(deps);
+  const remote = await resolveRemote(deps, config);
+  const id = conductorIdOf(config);
+  if (now) {
+    const entry2 = await get(id);
+    if (entry2 && entry2.host === "herdr") {
+      await killViaHerdr(entry2.handle);
+      console.log(`hard-stopped conductor ${id} (${entry2.handle})`);
+    } else {
+      console.log(`no herdr-hosted conductor to hard-stop for ${id}`);
+    }
+    return;
+  }
+  const entry = await get(id);
+  if (entry && entry.host === "herdr") {
+    await killViaHerdr(entry.handle);
+  }
+  await remote.setConductorStatus(id, "offline");
+  console.log(`stopped conductor ${id} (offline)`);
+}
+async function cmdLs(deps) {
+  const config = deps.config ?? await tryConfig(deps);
+  const remote = await resolveRemote(
+    deps,
+    config ?? await resolveConfig(deps)
+  );
+  const rows = await buildLsRows(remote, config);
+  printRows(rows);
+}
+async function cmdStatus(deps) {
+  const config = await resolveConfig(deps);
+  const remote = await resolveRemote(deps, config);
+  const id = conductorIdOf(config);
+  const rows = await buildLsRows(remote, config, id);
+  printRows(rows);
+}
+async function cmdRm(deps) {
+  const config = await resolveConfig(deps);
+  const id = conductorIdOf(config);
+  await remove(id);
+  console.log(`removed conductor ${id} from registry`);
+}
+async function tryConfig(deps) {
+  if (deps.config) {
+    return deps.config;
+  }
+  try {
+    return await loadConductorConfig(defaultConfigPath());
+  } catch {
+    return void 0;
+  }
+}
+async function promptUserId() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise(
+      (resolve5) => rl.question("Your K\xFCrzel / user id: ", resolve5)
+    );
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+async function promptSecret() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  rl._writeToOutput = (s) => {
+    if (!rl.muted || s.includes("\n")) process.stdout.write(s);
+  };
+  try {
+    const answer = await new Promise((resolve5) => {
+      rl.question("OAuth client secret: ", (a) => {
+        process.stdout.write("\n");
+        resolve5(a);
+      });
+      rl.muted = true;
+    });
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+function buildProgram(deps) {
+  const program = new Command();
+  program.name("gaia").description("GAIA conductor + client CLI");
+  const conductor = program.command("conductor").description("node-agent lifecycle + local registry").option(
+    "--log-level <level>",
+    "log verbosity: debug | info | warn | error (overrides GAIA_LOG_LEVEL)"
+  ).option(
+    "--log-sink <sink>",
+    "log sink: stdout | file (overrides GAIA_CONDUCTOR_LOG)"
+  ).addHelpText(
+    "after",
+    `
+Logging (precedence: CLI flag > env var > default):
+  --log-level <level>  debug | info (default) | warn | error.
+                       Set debug to see per-poll ticks, claims, and idle cycles.
+  --log-sink <sink>    stdout | file (writes <checkoutRoot>/log.txt).
+                       Default: stdout on a TTY, file otherwise.
+  GAIA_LOG_LEVEL       env fallback for --log-level.
+  GAIA_CONDUCTOR_LOG   env fallback for --log-sink.
+
+Examples:
+  gaia conductor --log-level debug start --foreground
+  gaia conductor --log-level debug poll
+  GAIA_LOG_LEVEL=debug gaia conductor poll`
+  );
+  conductor.command("start").description("start the conductor loop (herdr-hosted by default)").option("--foreground", "run the loop in this process", false).action(async function(opts) {
+    if (opts.foreground) {
+      await cmdStartForeground(deps, logOptsOf(this));
+    } else {
+      await cmdStart(deps, logOptsOf(this));
+    }
+  });
+  conductor.command("poll").description("run one conductor cycle then exit").action(async function() {
+    await cmdPoll(deps, logOptsOf(this));
+  });
+  conductor.command("stop").description(
+    "stop the conductor: graceful offline (default) or hard kill (--now)"
+  ).option(
+    "--now",
+    "hard-kill via host and let the cron reaper mark it offline",
+    false
+  ).action(async (opts) => {
+    await cmdStop(deps, opts.now);
+  });
+  conductor.command("ls").description("list conductors on this machine + status").action(async () => {
+    await cmdLs(deps);
+  });
+  conductor.command("status").description("status of the conductor for this checkout").action(async () => {
+    await cmdStatus(deps);
+  });
+  conductor.command("rm").description("deregister the conductor for this checkout").action(async () => {
+    await cmdRm(deps);
+  });
+  conductor.command("init").description(
+    "scaffold the committed .gaia/conductor.config.js for this repo plus the user-global conductor.config.machine.js context (identity + connection incl. secret)"
+  ).requiredOption(
+    "--base-url <url>",
+    "control-plane base URL (site.base_url)"
+  ).requiredOption("--project <name>", "GAIA project name").option(
+    "--secret-env <VAR>",
+    "env var name to read the oauth client secret from (else TTY prompt)"
+  ).option("--client-id <id>", "oauth consumer id", "gaia-agent").option(
+    "--machine-id <id>",
+    "machine host token for the context (defaults to hostname())"
+  ).option(
+    "--user-id <kuerzel>",
+    "developer K\xFCrzel for the user-global context"
+  ).option(
+    "--machine-path <path>",
+    "user-global machine context path (defaults to ~/.config/conductor/conductor.config.machine.js)"
+  ).option(
+    "--config <path>",
+    "target committed config path",
+    "./.gaia/conductor.config.js"
+  ).option("--force", "overwrite an existing committed config", false).action(
+    async (opts) => {
+      let userId = opts.userId;
+      if (userId === void 0 || userId.trim() === "") {
+        if (process.stdin.isTTY) {
+          userId = await promptUserId();
+        }
+        if (userId === void 0 || userId.trim() === "") {
+          throw new Error(
+            "--user-id is required (or run in a TTY to be prompted)"
+          );
+        }
+      }
+      const machinePath = opts.machinePath ?? machineContextPath();
+      const existing = await readMachineContext(machinePath);
+      let secret = "";
+      if (typeof existing.client_secret !== "string" || existing.client_secret.trim() === "") {
+        secret = opts.secretEnv !== void 0 ? process.env[opts.secretEnv] ?? "" : "";
+        if (secret.trim() === "") {
+          if (process.stdin.isTTY) {
+            secret = await promptSecret();
+          }
+          if (secret.trim() === "") {
+            throw new Error(
+              "OAuth client secret required: pass --secret-env <VAR> (exported) or run in a TTY to be prompted"
+            );
+          }
+        }
+      }
+      const inputs = {
+        baseUrl: opts.baseUrl,
+        project: opts.project,
+        clientId: opts.clientId,
+        secret,
+        userId,
+        ...opts.machineId !== void 0 ? { machineId: opts.machineId } : {}
+      };
+      const res = await scaffold(inputs, {
+        configPath: opts.config,
+        force: opts.force,
+        machinePath
+      });
+      console.log(
+        res.wroteCommitted ? `wrote ${res.committedPath}` : `kept ${res.committedPath} (exists \u2014 pass --force to replace)`
+      );
+      const m = res.machine;
+      console.log(
+        m.created ? `wrote ${m.path} (user-global machine context)` : m.filledKeys.length > 0 ? `updated ${m.path} (filled: ${m.filledKeys.join(", ")})` : `kept ${m.path} (already complete)`
+      );
+      console.log(
+        `
+Next steps:
+  gaia dropsh auth login --provider session
+  gaia dropsh auth login --provider pm
+  gaia dropsh auth status   # both profiles present`
+      );
+    }
+  );
+  return program;
+}
+async function attachDropsh(program, deps) {
+  const config = deps.config ?? await tryConfig(deps);
+  if (!config) {
+    return;
+  }
+  if (!process.env.DROPSH_CONFIG) {
+    process.env.DROPSH_CONFIG = config.config_path;
+  }
+  program.addCommand(
+    buildDropshProgram({ plugins: config.plugins ?? [] })
+  );
+}
+async function runGaiaCli(argv, deps = {}) {
+  const program = buildProgram(deps);
+  await attachDropsh(program, deps);
+  await program.parseAsync(argv, { from: "user" });
+}
+async function main(argv) {
+  await runGaiaCli(argv.slice(2));
+}
+
+// src/plugins/remote/drupal.ts
+import { resolveAuth } from "dropsh";
+import { createHttpClient, createJsonApiClient } from "dropsh/plugin";
+var ACTIVE = ["claimed", "running"];
+function parseTicketComments(included) {
+  if (!Array.isArray(included)) {
+    return [];
+  }
+  const comments = [];
+  for (const res of included) {
+    if (res?.type !== "gaia_comment--gaia_comment") {
+      continue;
+    }
+    const attrs = res.attributes ?? {};
+    const body = attrs.body;
+    const value = typeof body === "string" ? body : typeof body?.value === "string" ? body.value : "";
+    comments.push({
+      type: typeof attrs.gaia_comment_type === "string" ? attrs.gaia_comment_type : "comment",
+      body: value,
+      created: typeof attrs.created === "string" ? attrs.created : ""
+    });
+  }
+  return comments;
+}
+var DrupalGaiaRemote = class {
+  constructor(api) {
+    this.api = api;
+  }
+  api;
+  async fetchActiveRuns(id) {
+    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) {
+    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 === void 0 || 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) {
+    const doc = await this.api.get(
+      `gaia_ticket/gaia_ticket/${uuid}?include=comments`
+    );
+    const attrs = doc.data?.attributes ?? {};
+    const issueUrl = typeof attrs.origin === "string" ? attrs.origin : void 0;
+    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 } : {},
+      comments: parseTicketComments(doc.included),
+      ...issueUrl ? { issueUrl } : {}
+    };
+  }
+  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;
+  }
+  async heartbeat(reg, load, lease = 300) {
+    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() / 1e3);
+    await this.api.update("gaia_run", uuid, {
+      attributes: {
+        state: "running",
+        heartbeat: t,
+        ...attrs?.worktree_path ? { worktree_path: attrs.worktree_path } : {}
+      }
+    });
+  }
+  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"]).page(100).list();
+    return rows.map((r) => ({
+      runUuid: r.id,
+      worktreePath: r.attr("worktree_path") ?? ""
+    }));
+  }
+  async finalizeRun(uuid, log) {
+    const t = Math.floor(Date.now() / 1e3);
+    await this.api.update("gaia_run", uuid, {
+      attributes: {
+        closed: true,
+        closed_date: t,
+        ...log ? { log } : {}
+      }
+    });
+  }
+  async fetchFinalizableTickets(id) {
+    const rows = await this.api.collection("gaia_ticket").where("conductor_id.machine_id", "=", id).where("state", "=", "done").where("closed", "=", "0").fields(["branch_name"]).page(100).list();
+    return Promise.all(
+      rows.map(async (r) => ({
+        ticketUuid: r.id,
+        branchName: r.attr("branch_name") ?? "",
+        worktreePath: await this.latestRunWorktree(r.id)
+      }))
+    );
+  }
+  async closeTicket(uuid) {
+    const t = Math.floor(Date.now() / 1e3);
+    await this.api.update("gaia_ticket", uuid, {
+      attributes: { closed: true, closed_date: t }
+    });
+  }
+  /**
+   * 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;
+  }
+};
+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
+        })
+      );
+    }
+  };
+}
+
+// src/plugins/remote/fake.ts
+var ACTIVE2 = ["claimed", "running"];
+var FakeGaiaRemote = class {
+  calls = {
+    markRunning: [],
+    finalizeRun: [],
+    closeTicket: []
+  };
+  /**
+   * Override for reconcile tests: when set, `fetchActiveRuns` returns this
+   * list verbatim instead of deriving it from the internal runs map.
+   */
+  activeRuns = null;
+  runs = /* @__PURE__ */ 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";
+      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 !== void 0 ? { worktreePath: r.worktreePath } : {},
+        ...r.closed !== void 0 ? { 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() {
+    this.conductorStatus = "online";
+    return this.conductorStatus;
+  }
+  async getConductorStatus(_conductorId) {
+    return this.conductorStatus;
+  }
+  async setConductorStatus(_conductorId, status) {
+    this.conductorStatus = status;
+  }
+  async listConductors(_owner) {
+    return [];
+  }
+  async activeRunCount(_conductorId) {
+    return this.internalActiveRuns().length;
+  }
+  async fetchActiveRuns(_conductorId) {
+    if (this.activeRuns !== null) {
+      return this.activeRuns;
+    }
+    return this.internalActiveRuns().map((r) => {
+      const ticket = this.tickets[r.ticketUuid];
+      const identifier = ticket?.identifier ?? "";
+      const branchName = ticket?.branchName ?? (identifier ? `gaia/${identifier.toLowerCase()}` : "");
+      return {
+        runUuid: r.runUuid,
+        ticketUuid: r.ticketUuid,
+        ticketIdentifier: identifier,
+        branchName,
+        state: r.state,
+        stateAtStart: r.stateAtStart,
+        worktreePath: r.worktreePath ?? ""
+      };
+    });
+  }
+  async claimNext(_claim) {
+    return this.queue.shift() ?? null;
+  }
+  async getTicket(ticketUuid) {
+    const t = this.tickets[ticketUuid];
+    if (!t) {
+      throw new Error(`fake remote: ticket ${ticketUuid} not seeded`);
+    }
+    const branchName = t.branchName ?? `gaia/${t.identifier.toLowerCase()}`;
+    return {
+      uuid: ticketUuid,
+      identifier: t.identifier,
+      title: t.title,
+      state: t.state,
+      branchName,
+      ...t.baseBranch ? { baseBranch: t.baseBranch } : {},
+      comments: t.comments ?? [],
+      ...t.url ? { issueUrl: t.url } : {}
+    };
+  }
+  async getRunWorktree(runUuid) {
+    return this.runs.get(runUuid)?.worktreePath ?? "";
+  }
+  async getRunTicketIdentifier(runUuid) {
+    const ticketUuid = this.runs.get(runUuid)?.ticketUuid;
+    if (!ticketUuid) {
+      return "";
+    }
+    return this.tickets[ticketUuid]?.identifier ?? "";
+  }
+  async getRunTicketBranchName(runUuid) {
+    const ticketUuid = this.runs.get(runUuid)?.ticketUuid;
+    if (!ticketUuid) {
+      return "";
+    }
+    const ticket = this.tickets[ticketUuid];
+    if (!ticket) {
+      return "";
+    }
+    return ticket.branchName ?? `gaia/${ticket.identifier.toLowerCase()}`;
+  }
+  async markRunning(runUuid, attrs) {
+    this.calls.markRunning.push({
+      runUuid,
+      ...attrs ? {
+        attrs: {
+          ...attrs.worktree_path ? { worktree_path: attrs.worktree_path } : {}
+        }
+      } : {}
+    });
+    const run = this.runs.get(runUuid);
+    if (run) {
+      run.state = "running";
+      if (attrs?.worktree_path) {
+        run.worktreePath = attrs.worktree_path;
+      }
+    }
+  }
+  async fetchFinalizableRuns(_conductorId) {
+    return [...this.runs.values()].filter((r) => r.state === "done" && !r.closed).map((r) => ({ runUuid: r.runUuid, worktreePath: r.worktreePath ?? "" }));
+  }
+  async finalizeRun(runUuid, log) {
+    this.calls.finalizeRun.push({ runUuid, log });
+    const run = this.runs.get(runUuid);
+    if (run) {
+      run.closed = true;
+      if (log) run.log = log;
+    }
+  }
+  async fetchFinalizableTickets(_conductorId) {
+    return Object.entries(this.tickets).filter(([, t]) => t.state === "done" && !t.closed).map(([ticketUuid, t]) => ({
+      ticketUuid,
+      branchName: t.branchName ?? `gaia/${t.identifier.toLowerCase()}`,
+      worktreePath: this.latestRunWorktree(ticketUuid)
+    }));
+  }
+  async closeTicket(uuid) {
+    this.calls.closeTicket.push(uuid);
+    const t = this.tickets[uuid];
+    if (t) {
+      t.closed = true;
+    }
+  }
+  /** Worktree path of the ticket's most recently seeded run, or '' when none. */
+  latestRunWorktree(ticketUuid) {
+    let worktree = "";
+    for (const r of this.runs.values()) {
+      if (r.ticketUuid === ticketUuid && r.worktreePath) {
+        worktree = r.worktreePath;
+      }
+    }
+    return worktree;
+  }
+  internalActiveRuns() {
+    return [...this.runs.values()].filter((r) => ACTIVE2.includes(r.state));
+  }
+};
+function fakeRemote(seed = {}) {
+  const remote = new FakeGaiaRemote(seed);
+  return {
+    kind: "remote",
+    id: "fake",
+    requiredModules: [],
+    async createRemote(_config) {
+      return remote;
+    }
+  };
+}
+
+// src/plugins/workspace/fake.ts
+var FakeWorkspace = class {
+  async ensure(identifier, _title) {
+    return { path: `/fake/${identifier}`, instructions: null };
+  }
+  async beforeRun(_path) {
+  }
+  async afterRun(_path) {
+  }
+  async afterDone(_path) {
+  }
+};
+function fakeWorkspace() {
+  const workspace = new FakeWorkspace();
+  return {
+    kind: "workspace",
+    id: "fake",
+    requiredModules: [],
+    async createWorkspace(_config) {
+      return workspace;
+    }
+  };
+}
+
+// src/plugins/workspace/git.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname5, join as join4, resolve as resolve3 } from "node:path";
+
+// src/core/slug.ts
+var DEFAULT_SLUG_MAX_LENGTH = 40;
+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, "");
+}
+
+// src/plugins/workspace/instructions.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+function loadInstructions(workspacePath) {
+  const path = resolve2(workspacePath, "WORKFLOW.md");
+  if (!existsSync2(path)) {
+    return null;
+  }
+  const text = readFileSync(path, "utf8");
+  return {
+    path,
+    sha256: createHash2("sha256").update(text).digest("hex"),
+    text
+  };
+}
+
+// src/plugins/workspace/git.ts
+var DEFAULT_BRANCH_TEMPLATE = "{branchPrefix}{key}-{titleSlug}";
+function renderBranchTemplate(template, vars) {
+  const rendered = template.replace(/\{(\w+)\}/g, (whole, key) => {
+    const value = vars[key];
+    return value === void 0 ? whole : value;
+  });
+  return rendered.replace(/[-_./]+$/g, "");
+}
+var defaultHookRunner = async (command, cwd) => {
+  await exec("sh", ["-c", command], { cwd });
+};
+var defaultGitRunner = async (args, cwd) => {
+  await exec("git", args, { cwd });
+};
+var GitWorkspace = class {
+  constructor(options) {
+    this.options = options;
+    this.runHook = options.runHook ?? defaultHookRunner;
+    this.runGit = options.runGit ?? defaultGitRunner;
+    this.root = resolve3(options.root);
+    this.worktreesRoot = options.worktreesRoot ? resolve3(options.worktreesRoot) : `${this.root}-worktrees`;
+    this.branchPrefix = options.branchPrefix ?? "gaia/";
+    this.branchTemplate = options.branchTemplate ?? DEFAULT_BRANCH_TEMPLATE;
+  }
+  options;
+  runHook;
+  runGit;
+  root;
+  worktreesRoot;
+  branchPrefix;
+  branchTemplate;
+  /** 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 resolve3(join4(this.worktreesRoot, key));
+  }
+  async ensure(identifier, title, _baseRef) {
+    const key = this.keyFor(identifier);
+    if (key === "" || key.startsWith(".")) {
+      throw new Error(`invalid workspace identifier: ${identifier}`);
+    }
+    const path = this.pathFor(key);
+    if (existsSync3(path)) {
+      return { path, instructions: loadInstructions(path) };
+    }
+    const branch = this.branchFor(identifier, title);
+    await this.runGit(
+      ["-C", this.root, "worktree", "add", "--force", "-B", branch, path],
+      this.root
+    );
+    if (this.options.hooks?.after_create) {
+      await this.runHook(this.options.hooks.after_create, path);
+    }
+    return { path, instructions: loadInstructions(path) };
+  }
+  async remove(identifier) {
+    const key = this.keyFor(identifier);
+    const path = this.pathFor(key);
+    await this.runGit(
+      ["-C", this.root, "worktree", "remove", "--force", path],
+      this.root
+    );
+  }
+  async beforeRun(path) {
+    if (this.options.hooks?.before_run) {
+      await this.runHook(this.options.hooks.before_run, path);
+    }
+  }
+  async afterRun(path) {
+    if (this.options.hooks?.after_run) {
+      await this.runHook(this.options.hooks.after_run, path);
+    }
+  }
+  async afterDone(path) {
+    if (this.options.hooks?.after_done) {
+      await this.runHook(this.options.hooks.after_done, path);
+    }
+  }
+};
+function gitWorkspace(opts = {}) {
+  return {
+    kind: "workspace",
+    id: "git",
+    requiredModules: [],
+    async createWorkspace(config) {
+      const root = config.config_path ? dirname5(config.config_path) : process.cwd();
+      return new GitWorkspace({
+        root,
+        ...opts.hooks ? { hooks: opts.hooks } : {},
+        ...opts.branchPrefix ? { branchPrefix: opts.branchPrefix } : {},
+        ...opts.branchTemplate ? { branchTemplate: opts.branchTemplate } : {}
+      });
+    }
+  };
+}
+
+// src/plugins/workspace/herdr.ts
+import { dirname as dirname6, join as join5, resolve as resolve4 } from "node:path";
+var defaultExec = (args) => exec("herdr", args);
+var defaultGitExec = (args) => exec("git", args);
+var defaultHookRunner2 = async (command, cwd) => {
+  await exec("sh", ["-c", command], { cwd });
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJson(output, command) {
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`herdr ${command} returned invalid JSON`);
+  }
+}
+function parseWorktreeList(output) {
+  const parsed = parseJson(output, "worktree list");
+  const worktrees = isRecord2(parsed) ? parsed.result?.worktrees : void 0;
+  if (!Array.isArray(worktrees)) {
+    throw new Error("herdr worktree list returned invalid schema");
+  }
+  return worktrees.filter(isRecord2).filter((w) => typeof w.branch === "string" && typeof w.path === "string").map((w) => ({
+    branch: w.branch,
+    path: w.path,
+    ...typeof w.open_workspace_id === "string" ? { open_workspace_id: w.open_workspace_id } : {}
+  }));
+}
+function parseWorktreePath(output, command) {
+  const parsed = parseJson(output, command);
+  const path = isRecord2(parsed) ? parsed.result?.worktree?.path : void 0;
+  if (typeof path !== "string") {
+    throw new Error(`herdr ${command} returned invalid schema`);
+  }
+  return path;
+}
+function validateBranch(branch) {
+  if (!/^[A-Za-z0-9._/-]+$/.test(branch) || branch.startsWith(".") || branch.includes("..")) {
+    throw new Error(`invalid workspace branch: ${branch}`);
+  }
+}
+var HerdrWorkspace = class {
+  constructor(options) {
+    this.options = options;
+    this.execHerdr = options.execHerdr ?? defaultExec;
+    this.execGit = options.execGit ?? defaultGitExec;
+    this.runHook = options.runHook ?? defaultHookRunner2;
+    this.root = resolve4(options.root);
+    this.worktreeDir = options.worktreeDir ?? ".gaia-worktrees";
+  }
+  options;
+  execHerdr;
+  execGit;
+  runHook;
+  root;
+  worktreeDir;
+  /**
+   * Resolve the base ref for a new worktree branch. Prefers the configured
+   * `baseBranch`; otherwise the remote tracking branch of the repo's HEAD
+   * (e.g. `origin/develop`). Best-effort: a repo with no upstream returns
+   * `undefined`, leaving herdr to fall back to the parent workspace HEAD.
+   */
+  async resolveBaseRef() {
+    if (this.options.baseBranch) {
+      return this.options.baseBranch;
+    }
+    try {
+      const ref = (await this.execGit([
+        "-C",
+        this.root,
+        "rev-parse",
+        "--abbrev-ref",
+        "--symbolic-full-name",
+        "@{u}"
+      ])).trim();
+      return ref || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Fetch the base ref's remote branch so the new worktree starts from the
+   * latest pushed state. Best-effort: offline / unknown remote is non-fatal.
+   */
+  async fetchBaseRef(baseRef) {
+    const slash = baseRef.indexOf("/");
+    if (slash <= 0) {
+      return;
+    }
+    const remote = baseRef.slice(0, slash);
+    const branch = baseRef.slice(slash + 1);
+    try {
+      await this.execGit(["-C", this.root, "fetch", remote, branch]);
+    } catch {
+    }
+  }
+  /**
+   * Verify a base-ref candidate resolves on the remote (after fetching it).
+   * Returns the ref when it exists, else undefined so the caller falls back.
+   */
+  async verifyRemoteRef(ref) {
+    await this.fetchBaseRef(ref);
+    try {
+      await this.execGit([
+        "-C",
+        this.root,
+        "rev-parse",
+        "--verify",
+        "--quiet",
+        `${ref}^{commit}`
+      ]);
+      return ref;
+    } catch {
+      return void 0;
+    }
+  }
+  async ensure(_identifier, branch, baseRefOverride) {
+    if (branch === void 0) {
+      throw new Error("herdr workspace requires a branch name");
+    }
+    validateBranch(branch);
+    const worktrees = parseWorktreeList(
+      await this.execHerdr(["worktree", "list", "--cwd", this.root, "--json"])
+    );
+    const existing = worktrees.find((w) => w.branch === branch);
+    if (existing) {
+      let path2 = existing.path;
+      if (!existing.open_workspace_id) {
+        path2 = parseWorktreePath(
+          await this.execHerdr([
+            "worktree",
+            "open",
+            "--cwd",
+            this.root,
+            "--branch",
+            branch,
+            "--no-focus",
+            "--json"
+          ]),
+          "worktree open"
+        );
+      }
+      return { path: path2, instructions: loadInstructions(path2) };
+    }
+    let baseRef;
+    if (baseRefOverride !== void 0) {
+      baseRef = await this.verifyRemoteRef(baseRefOverride);
+    }
+    if (baseRef === void 0) {
+      baseRef = await this.resolveBaseRef();
+      if (baseRef !== void 0) {
+        await this.fetchBaseRef(baseRef);
+      }
+    }
+    const path = parseWorktreePath(
+      await this.execHerdr([
+        "worktree",
+        "create",
+        "--cwd",
+        this.root,
+        "--branch",
+        branch,
+        ...baseRef !== void 0 ? ["--base", baseRef] : [],
+        "--label",
+        branch,
+        "--path",
+        join5(this.worktreeDir, branch),
+        "--no-focus",
+        "--json"
+      ]),
+      "worktree create"
+    );
+    if (this.options.hooks?.after_create) {
+      await this.runHook(this.options.hooks.after_create, path);
+    }
+    return { path, instructions: loadInstructions(path) };
+  }
+  async beforeRun(path) {
+    if (this.options.hooks?.before_run) {
+      await this.runHook(this.options.hooks.before_run, path);
+    }
+  }
+  async afterRun(path) {
+    if (this.options.hooks?.after_run) {
+      await this.runHook(this.options.hooks.after_run, path);
+    }
+  }
+  async afterDone(path) {
+    if (this.options.hooks?.after_done) {
+      await this.runHook(this.options.hooks.after_done, path);
+    }
+  }
+};
+function herdrWorkspace(opts = {}) {
+  return {
+    kind: "workspace",
+    id: "herdr",
+    requiredModules: [],
+    async createWorkspace(config) {
+      const root = config.config_path ? dirname6(config.config_path) : process.cwd();
+      return new HerdrWorkspace({
+        root,
+        ...opts.hooks ? { hooks: opts.hooks } : {},
+        ...opts.worktreeDir ? { worktreeDir: opts.worktreeDir } : {},
+        ...opts.baseBranch ? { baseBranch: opts.baseBranch } : {}
+      });
+    }
+  };
+}
+export {
+  Conductor,
+  DEFAULT_AGENT_PROMPT,
+  DrupalGaiaRemote,
+  FakeGaiaRemote,
+  FakeWorkspace,
+  GitWorkspace,
+  HerdrWorkspace,
+  conductorId,
+  drupalRemote,
+  fakeRemote,
+  fakeWorkspace,
+  gitWorkspace,
+  herdrWorkspace,
+  loadConductorConfig,
+  main,
+  runGaiaCli,
+  selectExecutor,
+  selectRemote,
+  selectWorkspace
+};