@gaia-ai/conductor 0.5.0 → 0.5.4

package/dist/src/cli/gaia.js

@@ -396,8 +396,9 @@ export function buildProgram(deps) {
     program
         .name('gaia')
         .description('GAIA conductor + client CLI')
-        .option('--conductor <name>', 'select a named .gaia/<name>.config.js (default: the sole config; env $GAIA_CONDUCTOR)');
-    // GAIA-126: a repo may hold several named .gaia/<stem>.config.js conductors.
+        .option('--conductor <name>', 'select a conductor by stem (conductor→conductor.config.js, else <name>.conductor.config.js; default: conductor.config.js, else the sole config; env $GAIA_CONDUCTOR)');
+    // GAIA-126/137: a repo may hold several .gaia/ conductor configs — the default
+    // conductor.config.js plus <stem>.conductor.config.js variants.
     // resolveConfigPath already honours $GAIA_CONDUCTOR; thread the global
     // --conductor flag into it (flag wins over env) so every command selects the
     // named config without per-command wiring. A per-invocation flag beats any

package/dist/src/config.d.ts

@@ -5,9 +5,9 @@ import type { AgentCandidate, ConductorFileConfig } from '@gaia-ai/core';
  * is closed automatically when the ticket state changes on the next claim - the
  * agent does not release it. Run mechanics live here (not in the repo's
  * WORKFLOW.md). The prompt routes through the gaia skill (`ticket:run`) rather
- * than pointing at WORKFLOW.md directly (GAIA-125): the intake splash + state
+ * than pointing at WORKFLOW.md directly (GAIA-125): the intake line + state
  * engine are a skill mechanic, so a bare "follow WORKFLOW.md" pointer left the
- * splash unrendered unless an external skill-forcing hook happened to fire. A
+ * intake line unprinted unless an external skill-forcing hook happened to fire. A
  * conductor config may override via the `prompt` field.
  *
  * The ticket + its comments are NOT embedded (GAIA-112): embedding unbounded
@@ -47,12 +47,14 @@ export declare function resolveAgents(raw: unknown, configPath: string): Promise
  * Resolve the conductor config path from `cwd`.
  *
  * 1. An explicit `--config` / `$GAIA_CONDUCTOR_CONFIG` wins verbatim (no walk).
- * 2. Otherwise walk root-ward to the nearest `.gaia/` dir holding `*.config.js`
+ * 2. Otherwise walk root-ward to the nearest `.gaia/` dir holding a conductor config
  *    — so any subdirectory of a project/worktree resolves the same dir.
- *    - A `--conductor <name>` / `$GAIA_CONDUCTOR` selector resolves
- *      `<gaiaDir>/<name>.config.js` (error listing the stems if absent).
- *    - No selector: exactly one config → use it (back-compat: the lone
- *      `conductor.config.js`); many → error naming the stems + the selector.
+ *    - A `--conductor <name>` / `$GAIA_CONDUCTOR` selector resolves the stem's
+ *      file (`conductor` → `conductor.config.js`, else
+ *      `<name>.conductor.config.js`; error listing the stems if absent).
+ *    - No selector: `conductor.config.js` present → it is the default; else
+ *      exactly one config → use it (back-compat); else → error naming the
+ *      stems + the selector.
  * 3. No `.gaia/` config anywhere up the tree → an actionable `gaia init` error
  *    (never leak a raw "Cannot find module" from a later import()).
  */

package/dist/src/config.js

@@ -8,9 +8,9 @@ import { pathToFileURL } from 'node:url';
  * is closed automatically when the ticket state changes on the next claim - the
  * agent does not release it. Run mechanics live here (not in the repo's
  * WORKFLOW.md). The prompt routes through the gaia skill (`ticket:run`) rather
- * than pointing at WORKFLOW.md directly (GAIA-125): the intake splash + state
+ * than pointing at WORKFLOW.md directly (GAIA-125): the intake line + state
  * engine are a skill mechanic, so a bare "follow WORKFLOW.md" pointer left the
- * splash unrendered unless an external skill-forcing hook happened to fire. A
+ * intake line unprinted unless an external skill-forcing hook happened to fire. A
  * conductor config may override via the `prompt` field.
  *
  * The ticket + its comments are NOT embedded (GAIA-112): embedding unbounded
@@ -40,7 +40,7 @@ export const DEFAULT_AGENT_PROMPT = `You are a GAIA agent working ticket {identi
     `Invoke the gaia skill and run \`ticket:run {identifier} {state}\` — it first ` +
     `reads the ticket + all comments ` +
     `(gaia dropsh read gaia_ticket/gaia_ticket/$GAIA_ID --include comments), ` +
-    `renders the intake splash, runs the {state} engine, and applies ` +
+    `prints an intake line, runs the {state} engine, and applies ` +
     `WORKFLOW.md's {state} policy. Do ONLY the {state} work — never start or ` +
     `prepare a later state.`;
 function requirePlugin(value, kind) {
@@ -179,18 +179,36 @@ function optionalPositiveInteger(value, fallback, key) {
     }
     return value;
 }
-/** A repo's config files live in this dir, one `<stem>.config.js` per conductor. */
+/** A repo's config files live in this dir, one conductor config per conductor. */
 const GAIA_DIR = '.gaia';
-/** List the `*.config.js` stems in a `.gaia/` dir (e.g. `shop.config.js` → `shop`). */
+/** The default conductor's file name; its stem is `conductor`. */
+const DEFAULT_CONFIG = 'conductor.config.js';
+/** Variant files are `<stem>.conductor.config.js`. */
+const VARIANT_SUFFIX = '.conductor.config.js';
+/**
+ * List the conductor-config stems in a `.gaia/` dir. A file is a conductor
+ * config iff it is exactly `conductor.config.js` (stem `conductor`, the
+ * default) or ends with `.conductor.config.js` (stem = the leading part).
+ * Every other file (`vite.config.js`, the near-miss `myconductor.config.js`)
+ * is ignored.
+ */
 function configStems(gaiaDir) {
     return readdirSync(gaiaDir)
-        .filter((f) => f.endsWith('.config.js'))
-        .map((f) => f.slice(0, -'.config.js'.length))
+        .map((f) => f === DEFAULT_CONFIG
+        ? 'conductor'
+        : f.endsWith(VARIANT_SUFFIX)
+            ? f.slice(0, -VARIANT_SUFFIX.length)
+            : undefined)
+        .filter((s) => s !== undefined)
         .sort();
 }
+/** Map a conductor stem back to its file name. */
+function fileForStem(stem) {
+    return stem === 'conductor' ? DEFAULT_CONFIG : `${stem}${VARIANT_SUFFIX}`;
+}
 /**
  * Walk from `cwd` root-ward (git/eslint style) to the nearest ancestor whose
- * `.gaia/` dir holds at least one `*.config.js`; return that `.gaia/` dir, or
+ * `.gaia/` dir holds at least one conductor config; return that `.gaia/` dir, or
  * `undefined` if none is found up to the filesystem root.
  */
 function findGaiaDir(cwd) {
@@ -211,12 +229,14 @@ function findGaiaDir(cwd) {
  * Resolve the conductor config path from `cwd`.
  *
  * 1. An explicit `--config` / `$GAIA_CONDUCTOR_CONFIG` wins verbatim (no walk).
- * 2. Otherwise walk root-ward to the nearest `.gaia/` dir holding `*.config.js`
+ * 2. Otherwise walk root-ward to the nearest `.gaia/` dir holding a conductor config
  *    — so any subdirectory of a project/worktree resolves the same dir.
- *    - A `--conductor <name>` / `$GAIA_CONDUCTOR` selector resolves
- *      `<gaiaDir>/<name>.config.js` (error listing the stems if absent).
- *    - No selector: exactly one config → use it (back-compat: the lone
- *      `conductor.config.js`); many → error naming the stems + the selector.
+ *    - A `--conductor <name>` / `$GAIA_CONDUCTOR` selector resolves the stem's
+ *      file (`conductor` → `conductor.config.js`, else
+ *      `<name>.conductor.config.js`; error listing the stems if absent).
+ *    - No selector: `conductor.config.js` present → it is the default; else
+ *      exactly one config → use it (back-compat); else → error naming the
+ *      stems + the selector.
  * 3. No `.gaia/` config anywhere up the tree → an actionable `gaia init` error
  *    (never leak a raw "Cannot find module" from a later import()).
  */
@@ -232,14 +252,21 @@ export function resolveConfigPath(override, cwd = process.cwd(), conductorName)
     const stems = configStems(gaiaDir);
     const name = conductorName ?? process.env.GAIA_CONDUCTOR;
     if (name !== undefined && name !== '') {
-        const candidate = join(gaiaDir, `${name}.config.js`);
+        const candidate = join(gaiaDir, fileForStem(name));
         if (!existsSync(candidate)) {
             throw new Error(`no conductor '${name}' in ${gaiaDir}; available: ${stems.join(', ')}`);
         }
         return candidate;
     }
+    // No selector: the file named conductor.config.js is the default (AC-1, AC-2).
+    // Two conductor.config.js files cannot coexist in one dir, so ">1 default"
+    // (AC-5) is structurally impossible — no ambiguity branch is needed.
+    if (stems.includes('conductor')) {
+        return join(gaiaDir, DEFAULT_CONFIG);
+    }
+    // Back-compat: a lone config resolves even without the default name.
     if (stems.length === 1) {
-        return join(gaiaDir, `${stems[0]}.config.js`);
+        return join(gaiaDir, fileForStem(stems[0]));
     }
     throw new Error(`${stems.length} conductors in ${gaiaDir} (${stems.join(', ')}); ` +
         'select one with --conductor <name> or $GAIA_CONDUCTOR');

package/dist/src/core/conductor.js

@@ -141,16 +141,24 @@ export class Conductor {
                 await this.dispatch(run);
             }
             catch (err) {
-                // A failed dispatch must NOT terminalise the run. The run lifecycle is
-                // server-owned; a client-side releaseRun('done') here fabricated a
-                // terminal state on failure, which reopened the ticket for claiming and
-                // re-dispatched it every tick — the GAIA-41 runaway. Leaving the run
-                // `claimed` lets the server's same-state claim conflict
-                // (TicketClaimService::retireSupersededRuns) block a re-claim of the
-                // same ticket, so we just log and move on. A run stuck `claimed` on a
-                // persistently-failing dispatch is freed by the lease-expiry reaper
-                // (separate follow-up), not here.
+                // GAIA-149: terminalise the run to `failed` with the error captured,
+                // instead of leaving it `claimed` to expire after the ~300s lease (the
+                // old silent stall). `failed` is a terminal sibling of `expired`
+                // (dispatch/setup error vs lease lapse); it does NOT reopen the ticket
+                // the way the GAIA-41-era fabricated `done` did, so there is no runaway.
+                // Marking it now frees the ticket immediately and records *why* it
+                // failed; a persistently-failing setup is then parked by the server-side
+                // circuit breaker (TicketClaimService::assertNotCircuitBroken) after the
+                // retry cap, not by a hot re-dispatch loop. Best-effort: a markFailed
+                // that itself errors must not stop the claim loop, so it is swallowed
+                // (the run then falls back to lease-expiry recovery).
                 this.logger.error({ run: run.runUuid, err: String(err) }, 'dispatch failed');
+                try {
+                    await this.remote.markFailed(run.runUuid, String(err));
+                }
+                catch (markErr) {
+                    this.logger.warn({ run: run.runUuid, err: String(markErr) }, 'markFailed failed');
+                }
             }
             count += 1;
             claimed += 1;
@@ -176,15 +184,16 @@ export class Conductor {
         const runs = await this.remote.fetchFinalizableRuns(this.id);
         for (const r of runs) {
             try {
-                // Ask the agent to exit gracefully (/exit) before capturing its log.
-                // Best-effort and gated on the persistent capability (only hosted
-                // executors have a live agent pane) — mirrors removeWorktree's gate.
-                // A stop failure must never block finalisation.
+                // Signal the agent to stop before capturing its log. Best-effort and
+                // gated on the persistent capability (only hosted executors have a live
+                // agent) — mirrors removeWorktree's gate. For herdr this is a no-op
+                // (the tab-close in cleanupRun kills the PTY); a stop failure must
+                // never block finalisation.
                 if (this.executor.capabilities().persistent) {
                     const branch = await this.remote.getRunTicketBranchName(r.runUuid);
                     if (branch) {
                         try {
-                            await this.executor.stopAgent(branch);
+                            await this.executor.stopRun(branch);
                         }
                         catch (err) {
                             this.logger.warn({ run: r.runUuid, err: String(err) }, 'agent stop failed');
@@ -202,14 +211,16 @@ export class Conductor {
                     ? await resolved.agent.getRunLog(r.worktreePath)
                     : '';
                 // Footprint (GAIA-132): the agent parses its own transcript for the
-                // effort metrics (transcript format is agent-specific); the conductor
-                // adds duration_s from started_at → now. The conductor owns the run, so
-                // this write always lands (the agent session could not).
+                // effort metrics AND its wall-clock duration_s (from the transcript's
+                // first→last timestamps — GAIA-151). Deriving duration from the log
+                // keeps it a single source with one format, avoiding the earlier
+                // `started_at` re-read that mis-parsed the JSON:API ISO string to 0.
+                // The conductor owns the run, so this write always lands (the agent
+                // session could not).
                 const parsed = resolved.agent.parseFootprint(log);
-                const now = Math.floor(Date.now() / 1000);
                 const metrics = {
                     tokens: parsed.tokens,
-                    duration_s: r.startedAt !== undefined ? Math.max(0, now - r.startedAt) : 0,
+                    duration_s: parsed.duration_s,
                     agent_turns: parsed.agent_turns,
                     tool_calls: parsed.tool_calls,
                     user_prompts: parsed.user_prompts,
@@ -217,6 +228,21 @@ export class Conductor {
                 };
                 await this.remote.finalizeRun(r.runUuid, log, metrics);
                 this.logger.info({ run: r.runUuid, footprint: metrics }, 'run finalised');
+                // Tab-close is the LAST finalisation step (GAIA-171): the transcript is
+                // now captured, so killing the PTY is safe. Best-effort + gated on the
+                // persistent capability (only hosted executors have a tab), self-guarded
+                // so a close failure never mislabels the run as "finalise failed".
+                if (this.executor.capabilities().persistent) {
+                    const branch = await this.remote.getRunTicketBranchName(r.runUuid);
+                    if (branch) {
+                        try {
+                            await this.executor.cleanupRun(branch);
+                        }
+                        catch (err) {
+                            this.logger.warn({ run: r.runUuid, err: String(err) }, 'run tab cleanup failed');
+                        }
+                    }
+                }
             }
             catch (err) {
                 this.logger.warn({ run: r.runUuid, err: String(err) }, 'run finalise failed');
@@ -360,7 +386,8 @@ export class Conductor {
             await this.executor.runHook('after_create', ws.path, { ticket: t.identifier }, env);
         }
         await this.executor.runHook('before_run', ws.path, { ticket: t.identifier }, env);
-        await this.executor.retire(t.branchName);
+        // Clear any leftover tabs of a reused workspace before starting the run.
+        await this.executor.cleanupRun(t.branchName);
         const prompt = ws.instructions
             ? renderPrompt(this.config.prompt, {
                 identifier: t.identifier,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/conductor",
-  "version": "0.5.0",
+  "version": "0.5.4",
   "description": "GAIA conductor engine + CLI: registers, claims tickets via JSON:API, dispatches agents.",
   "type": "module",
   "license": "MIT",
@@ -25,7 +25,7 @@
     "directory": "conductor/packages/conductor"
   },
   "dependencies": {
-    "@gaia-ai/core": "^0.5.0",
+    "@gaia-ai/core": "^0.5.4",
     "@dropsh/plugin-oauth2": "^0.5.7",
     "@dropsh/plugin-jsonapi-schema": "^0.5.7",
     "commander": "^12.1.0",