@gaia-ai/core 0.5.3 → 0.5.5

package/dist/src/core/exec.js

@@ -7,7 +7,13 @@ export class ExecError extends Error {
     exitCode;
     stderr;
     constructor(file, args, exitCode, stderr, options) {
-        super(`exec failed: ${file}`, options);
+        // Include exitCode + stderr in the message so a stringified ExecError
+        // (e.g. gaia_run.error_log = String(err)) carries the ACTUAL cause, not a
+        // bare "exec failed: herdr". Args are omitted on purpose — they can embed
+        // secrets (herdr's `KEY='value' <agent>` pane-run string, GAIA-99); stderr
+        // is the tool's own diagnostic output and is trimmed.
+        const detail = stderr.trim();
+        super(`exec failed: ${file} (exit ${exitCode ?? 'null'})${detail ? `: ${detail}` : ''}`, options);
         this.file = file;
         this.args = args;
         this.exitCode = exitCode;

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

@@ -3,12 +3,21 @@
  * (GAIA-132). The metrics are transcript-derived and therefore
  * **agent-specific** (each agent's transcript has its own format), so parsing
  * lives behind the agent abstraction (see {@link GaiaAgent.parseFootprint}) —
- * the conductor stays agent-agnostic and only adds `duration_s` (wall-clock,
- * agent-independent) before writing the run's footprint.
+ * the conductor stays agent-agnostic and writes the footprint verbatim.
+ * `duration_s` is likewise derived from the transcript (its first→last entry
+ * timestamps), NOT recomputed by the conductor from a re-read `started_at`
+ * (GAIA-151): the log is the single source of the run's wall-clock length, so
+ * there is no timestamp round-trip through JSON:API to mis-parse.
  */
 export interface AgentFootprint {
     /** Total tokens across every usage bucket of every assistant turn. */
     tokens: number;
+    /**
+     * Wall-clock run length in seconds, derived from the transcript's first→last
+     * entry timestamps (GAIA-151). 0 when the transcript has fewer than two
+     * timestamped entries (empty/absent log).
+     */
+    duration_s: number;
     /** Number of assistant turns in the transcript. */
     agent_turns: number;
     /** Number of tool-use calls across all assistant turns. */

package/dist/src/plugins/agent/agent.js

@@ -2,6 +2,7 @@
 export function emptyAgentFootprint() {
     return {
         tokens: 0,
+        duration_s: 0,
         agent_turns: 0,
         tool_calls: 0,
         user_prompts: 0,

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

@@ -55,19 +55,31 @@ export interface GaiaExecutor {
      */
     runHook(name: HookName, cwd: string, ctx: HookContext, env?: Record<string, string>): Promise<void>;
     startRun(input: SpawnRunInput): Promise<SpawnedSession>;
-    /** Send C-c to every open (non-`(done)`) tab in the branch workspace and
-     * append ` (done)` to its label. Best-effort, non-destructive: tabs stay open
-     * for the human to close. */
-    retire(branch: string): Promise<void>;
     /**
-     * Ask the agent in each open (non-`(done)`) tab of the branch workspace to
-     * exit gracefully by typing `/exit` + Enter into its pane — a clean shutdown
-     * vs {@link retire}'s C-c SIGINT. Called by the conductor's run-finalise pass
-     * once a run is done. Best-effort and non-destructive (tabs stay open); a
-     * no-op for non-persistent executors (no hosted agent pane), so the conductor
-     * gates the call on `capabilities().persistent`.
+     * Signal the run's agent to stop. Called by the conductor's run-finalise pass
+     * BEFORE it captures the agent transcript (GAIA-132), so a stop must not
+     * destroy the log. For herdr this is a NO-OP: at finalise time the agent is
+     * idle and its jsonl transcript is already fully written to disk, and the
+     * subsequent {@link cleanupRun} tab-close kills the PTY (the agent dies with
+     * it). The seam exists for executors whose agent outlives its UI surface.
+     * Best-effort; gated by the conductor on `capabilities().persistent`.
      */
-    stopAgent(branch: string): Promise<void>;
+    stopRun(branch: string): Promise<void>;
+    /**
+     * Tear down ONE run's hosted UI surface — for herdr, close only the tab whose
+     * label carries the `#<runId>` token (`startRun` labels every tab
+     * `<identifier> · <state> #<run.id>`), via `herdr tab close <tab_id>` (killing
+     * that PTY). Run-scoped by design (GAIA-183): a sibling run's tab in the same
+     * branch workspace — a still-open prior-state run or a concurrent re-claim —
+     * and any non-run tab are left untouched. Called as the LAST finalisation step,
+     * strictly after the transcript is captured, and again at dispatch to clear a
+     * reused workspace's leftover tab for the run being (re-)started. No matching
+     * tab → a quiet no-op. Does NOT touch the branch worktree (that is the
+     * reap/{@link removeWorktree} lifecycle). Best-effort: a failing tab-close is
+     * swallowed and never aborts finalisation or dispatch. A no-op for
+     * non-persistent executors.
+     */
+    cleanupRun(branch: string, runId: number): Promise<void>;
     /**
      * Tear down the branch's entire worktree (git worktree + hosted workspace),
      * reclaiming its disk. Called by the conductor's ticket-cleanup pass once a

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

@@ -17,6 +17,7 @@ export declare class DrupalGaiaRemote implements GaiaRemote {
     setConductorStatus(id: string, status: string): Promise<void>;
     listConductors(owner?: 'me'): Promise<ConductorStatus[]>;
     markRunning(uuid: string, attrs?: RunWriteAttributes): Promise<void>;
+    markFailed(uuid: string, errorLog: string): Promise<void>;
     fetchFinalizableRuns(id: string): Promise<FinalizableRun[]>;
     finalizeRun(uuid: string, log: string, metrics?: RunMetrics): Promise<void>;
     fetchUncleanedTickets(id: string): Promise<UncleanTicket[]>;

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

@@ -220,24 +220,36 @@ export class DrupalGaiaRemote {
             },
         });
     }
+    async markFailed(uuid, errorLog) {
+        const t = Math.floor(Date.now() / 1000);
+        await this.api.update('gaia_run', uuid, {
+            attributes: {
+                state: 'failed',
+                error_log: errorLog,
+                closed: true,
+                closed_date: t,
+            },
+        });
+    }
     async fetchFinalizableRuns(id) {
         const rows = await this.api
             .collection('gaia_run')
             .where('conductor_id.machine_id', '=', id)
             .where('state', '=', 'done')
             .where('closed', '=', '0')
-            .fields(['worktree_path', 'started_at', 'agent'])
+            .fields(['worktree_path', 'agent', 'drupal_internal__id'])
             .page(100)
             .list();
-        return rows.map((r) => {
-            const startedAt = r.attr('started_at');
-            return {
-                runUuid: r.id,
-                worktreePath: r.attr('worktree_path') ?? '',
-                ...(typeof startedAt === 'number' ? { startedAt } : {}),
-                agent: r.attr('agent') ?? '',
-            };
-        });
+        // No `started_at` read: the run's duration_s is derived from the agent
+        // transcript at finalize (GAIA-151), so the conductor no longer round-trips
+        // the timestamp back through JSON:API.
+        return rows.map((r) => ({
+            runUuid: r.id,
+            // The `#<runId>` tab-label token: scopes the run's tab-close (GAIA-183).
+            runId: Number(r.attr('drupal_internal__id')),
+            worktreePath: r.attr('worktree_path') ?? '',
+            agent: r.attr('agent') ?? '',
+        }));
     }
     async finalizeRun(uuid, log, metrics) {
         const t = Math.floor(Date.now() / 1000);

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

@@ -11,8 +11,6 @@ export interface FakeSeedRun {
     handler?: string;
     worktreePath?: string;
     closed?: boolean;
-    /** Unix timestamp (seconds) the run started — drives footprint duration_s. */
-    startedAt?: number;
     /** Id of the agent that ran (GAIA-144) — routes footprint parsing at finalize. */
     agent?: string;
 }
@@ -61,9 +59,14 @@ export interface FinalizeRunCall {
     log: string;
     metrics?: RunMetrics;
 }
+export interface MarkFailedCall {
+    runUuid: string;
+    errorLog: string;
+}
 export declare class FakeGaiaRemote implements GaiaRemote {
     readonly calls: {
         markRunning: MarkRunningCall[];
+        markFailed: MarkFailedCall[];
         finalizeRun: FinalizeRunCall[];
         closeTicket: string[];
         markCleanedUp: string[];
@@ -93,6 +96,7 @@ export declare class FakeGaiaRemote implements GaiaRemote {
     getRunTicketIdentifier(runUuid: string): Promise<string>;
     getRunTicketBranchName(runUuid: string): Promise<string>;
     markRunning(runUuid: string, attrs?: RunWriteAttributes): Promise<void>;
+    markFailed(runUuid: string, errorLog: string): Promise<void>;
     fetchFinalizableRuns(_conductorId: string): Promise<FinalizableRun[]>;
     finalizeRun(runUuid: string, log: string, metrics?: RunMetrics): Promise<void>;
     fetchUncleanedTickets(conductorId: string): Promise<UncleanTicket[]>;

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

@@ -2,6 +2,7 @@ const ACTIVE = ['claimed', 'running'];
 export class FakeGaiaRemote {
     calls = {
         markRunning: [],
+        markFailed: [],
         finalizeRun: [],
         closeTicket: [],
         markCleanedUp: [],
@@ -33,7 +34,6 @@ export class FakeGaiaRemote {
                 ...(r.worktreePath !== undefined
                     ? { worktreePath: r.worktreePath }
                     : {}),
-                ...(r.startedAt !== undefined ? { startedAt: r.startedAt } : {}),
                 ...(r.agent !== undefined ? { agent: r.agent } : {}),
                 ...(r.closed !== undefined ? { closed: r.closed } : {}),
             });
@@ -155,13 +155,21 @@ export class FakeGaiaRemote {
             }
         }
     }
+    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 ?? '',
-            ...(r.startedAt !== undefined ? { startedAt: r.startedAt } : {}),
             agent: r.agent ?? '',
         }));
     }

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

@@ -62,21 +62,18 @@ export interface ConductorStatus {
 }
 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;
-    /**
-     * Unix timestamp (seconds) the run started, or undefined when unset. The
-     * conductor derives the footprint `duration_s` as `now − startedAt` at close
-     * (GAIA-132).
-     */
-    startedAt?: number;
     /** 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: the five parsed from the agent transcript
- * plus `duration_s` computed from `started_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;
@@ -147,6 +144,16 @@ export interface GaiaRemote {
      */
     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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/core",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "GAIA global contract: plugin API, built-in remotes/workspaces/auth, shared primitives.",
   "type": "module",
   "license": "MIT",