@gaia-ai/core 0.4.3 → 0.4.5

package/dist/src/index.d.ts

@@ -3,7 +3,7 @@ export { CommandRunner, ExecError, exec, setDefaultCommandRunner, } from './core
 export { type ConductorLogger, createLogger } from './core/logger.js';
 export { shellQuote } from './core/shell.js';
 export { DEFAULT_SLUG_MAX_LENGTH, slugify } from './core/slug.js';
-export type { GaiaAgent } from './plugins/agent/agent.js';
+export { type AgentFootprint, emptyAgentFootprint, type GaiaAgent, } from './plugins/agent/agent.js';
 export type * from './plugins/executor/executor.js';
 export type { AgentPlugin, ExecutorDeps, ExecutorPlugin, RemotePlugin, WorkspacePlugin, } from './plugins/plugins.js';
 export type * from './plugins/remote/remote.js';

package/dist/src/index.js

@@ -3,4 +3,5 @@ export { CommandRunner, ExecError, exec, setDefaultCommandRunner, } from './core
 export { createLogger } from './core/logger.js';
 export { shellQuote } from './core/shell.js';
 export { DEFAULT_SLUG_MAX_LENGTH, slugify } from './core/slug.js';
+export { emptyAgentFootprint, } from './plugins/agent/agent.js';
 export { loadInstructions } from './plugins/workspace/instructions.js';

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

@@ -1,3 +1,27 @@
+/**
+ * Per-agent effort footprint parsed from that agent's run transcript
+ * (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.
+ */
+export interface AgentFootprint {
+    /** Total tokens across every usage bucket of every assistant turn. */
+    tokens: number;
+    /** Number of assistant turns in the transcript. */
+    agent_turns: number;
+    /** Number of tool-use calls across all assistant turns. */
+    tool_calls: number;
+    /** Number of user-submitted prompts. */
+    user_prompts: number;
+    /** Total words across those user prompts. */
+    user_prompt_words: number;
+    /** Model of the last assistant turn, when present (informational). */
+    model?: string;
+}
+/** An all-zero footprint — the honest result for an empty/absent transcript. */
+export declare function emptyAgentFootprint(): AgentFootprint;
 /**
  * A GAIA agent: the program the conductor runs to work a ticket (e.g. claude).
  * It knows how it is launched (CLI + model + flags) and where its per-run
@@ -17,4 +41,12 @@ export interface GaiaAgent {
      * `worktreePath`. MUST return '' (never throw) when nothing is found.
      */
     getRunLog(worktreePath: string): Promise<string>;
+    /**
+     * Parse this agent's run transcript (as returned by {@link getRunLog}) into
+     * a footprint of effort metrics (GAIA-132). The transcript format is
+     * agent-specific, so each agent owns its own parser. MUST be tolerant of
+     * blank/partial/absent input (never throw) — an empty log yields
+     * {@link emptyAgentFootprint}.
+     */
+    parseFootprint(log: string): AgentFootprint;
 }

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

@@ -1 +1,10 @@
-export {};
+/** An all-zero footprint — the honest result for an empty/absent transcript. */
+export function emptyAgentFootprint() {
+    return {
+        tokens: 0,
+        agent_turns: 0,
+        tool_calls: 0,
+        user_prompts: 0,
+        user_prompt_words: 0,
+    };
+}

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

@@ -1,6 +1,6 @@
 import type { JsonApiClient } from 'dropsh/plugin';
 import type { RemotePlugin } from '../plugins.js';
-import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunWriteAttributes, Ticket, UncleanTicket } from './remote.js';
+import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunMetrics, RunWriteAttributes, Ticket, UncleanTicket } from './remote.js';
 export declare class DrupalGaiaRemote implements GaiaRemote {
     private readonly api;
     constructor(api: JsonApiClient);
@@ -18,8 +18,8 @@ export declare class DrupalGaiaRemote implements GaiaRemote {
     listConductors(owner?: 'me'): Promise<ConductorStatus[]>;
     markRunning(uuid: string, attrs?: RunWriteAttributes): Promise<void>;
     fetchFinalizableRuns(id: string): Promise<FinalizableRun[]>;
-    finalizeRun(uuid: string, log: string): Promise<void>;
-    fetchUncleanedTickets(): Promise<UncleanTicket[]>;
+    finalizeRun(uuid: string, log: string, metrics?: RunMetrics): Promise<void>;
+    fetchUncleanedTickets(id: string): Promise<UncleanTicket[]>;
     closeTicket(uuid: string): Promise<void>;
     markTicketCleanedUp(uuid: string): Promise<void>;
     /**

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

@@ -204,35 +204,42 @@ export class DrupalGaiaRemote {
             .where('conductor_id.machine_id', '=', id)
             .where('state', '=', 'done')
             .where('closed', '=', '0')
-            .fields(['worktree_path'])
+            .fields(['worktree_path', 'started_at'])
             .page(100)
             .list();
-        return rows.map((r) => ({
-            runUuid: r.id,
-            worktreePath: r.attr('worktree_path') ?? '',
-        }));
+        return rows.map((r) => {
+            const startedAt = r.attr('started_at');
+            return {
+                runUuid: r.id,
+                worktreePath: r.attr('worktree_path') ?? '',
+                ...(typeof startedAt === 'number' ? { startedAt } : {}),
+            };
+        });
     }
-    async finalizeRun(uuid, log) {
+    async finalizeRun(uuid, log, metrics) {
         const t = Math.floor(Date.now() / 1000);
         await this.api.update('gaia_run', uuid, {
             attributes: {
                 closed: true,
                 closed_date: t,
                 ...(log ? { log } : {}),
+                ...(metrics ?? {}),
             },
         }); // NO state — the run is already done.
     }
-    async fetchUncleanedTickets() {
+    async fetchUncleanedTickets(id) {
         // Finished tickets whose worktree is not yet torn down (cleaned_up=0),
-        // driven by the durable `cleaned_up` flag (GAIA-89). "Finished" = reached
-        // `done` OR already `closed`; the collection builder has no OR, so this is
-        // two AND-queries merged + de-duped by uuid. NOT machine-scoped, so the
-        // same query backs both the tick and the standalone `gaia conductor reap`
-        // and catches tickets orphaned while a conductor was down / after a restart
-        // / after a `conductor_id` reassignment (RC2/RC3).
+        // driven by the durable `cleaned_up` flag (GAIA-89) AND scoped to this
+        // conductor (GAIA-121): only tickets assigned to `id` are loaded, so a
+        // ticket owned by another conductor never reaches the reaper loop. "Finished"
+        // = reached `done` OR already `closed`; the collection builder has no OR, so
+        // this is two AND-queries merged + de-duped by uuid. The `conductor_id`
+        // relationship carries the assigned conductor's `machine_id` — the same
+        // nested filter the sibling reaper queries (`fetchFinalizableRuns` etc.) use.
         const fields = ['branch_name', 'state', 'closed'];
         const done = await this.api
             .collection('gaia_ticket')
+            .where('conductor_id.machine_id', '=', id)
             .where('state', '=', 'done')
             .where('cleaned_up', '=', '0')
             .fields(fields)
@@ -240,6 +247,7 @@ export class DrupalGaiaRemote {
             .list();
         const closed = await this.api
             .collection('gaia_ticket')
+            .where('conductor_id.machine_id', '=', id)
             .where('closed', '=', '1')
             .where('cleaned_up', '=', '0')
             .fields(fields)

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

@@ -1,5 +1,5 @@
 import type { RemotePlugin } from '../plugins.js';
-import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunWriteAttributes, Ticket, UncleanTicket } from './remote.js';
+import type { ActiveRun, ClaimedRun, ClaimOptions, ConductorRegistration, ConductorStatus, FinalizableRun, GaiaRemote, RunMetrics, RunWriteAttributes, Ticket, UncleanTicket } from './remote.js';
 export interface FakeSeedRun {
     runUuid: string;
     /** Numeric (drupal_internal__id) run id. Defaults to a stable 1-based counter when omitted. */
@@ -11,6 +11,8 @@ export interface FakeSeedRun {
     handler?: string;
     worktreePath?: string;
     closed?: boolean;
+    /** Unix timestamp (seconds) the run started — drives footprint duration_s. */
+    startedAt?: number;
 }
 export interface FakeSeedTicket {
     identifier: string;
@@ -27,6 +29,12 @@ export interface FakeSeedTicket {
     closed?: boolean;
     /** Whether the ticket's worktree is already torn down (cleaned_up flag). */
     cleanedUp?: boolean;
+    /**
+     * machine_id of the conductor this ticket is assigned to (GAIA-121). Omit to
+     * mean "belongs to the querying conductor" (the common case for reaper tests);
+     * set an explicit value to test conductor-scoping, or `''` for unassigned.
+     */
+    conductorId?: string;
 }
 export interface FakeRemoteSeed {
     runs?: FakeSeedRun[];
@@ -41,6 +49,7 @@ export interface MarkRunningCall {
 export interface FinalizeRunCall {
     runUuid: string;
     log: string;
+    metrics?: RunMetrics;
 }
 export declare class FakeGaiaRemote implements GaiaRemote {
     readonly calls: {
@@ -75,8 +84,8 @@ export declare class FakeGaiaRemote implements GaiaRemote {
     getRunTicketBranchName(runUuid: string): Promise<string>;
     markRunning(runUuid: string, attrs?: RunWriteAttributes): Promise<void>;
     fetchFinalizableRuns(_conductorId: string): Promise<FinalizableRun[]>;
-    finalizeRun(runUuid: string, log: string): Promise<void>;
-    fetchUncleanedTickets(): Promise<UncleanTicket[]>;
+    finalizeRun(runUuid: string, log: string, metrics?: RunMetrics): Promise<void>;
+    fetchUncleanedTickets(conductorId: string): Promise<UncleanTicket[]>;
     closeTicket(uuid: string): Promise<void>;
     markTicketCleanedUp(uuid: string): Promise<void>;
     /** Worktree path of the ticket's most recently seeded run, or '' when none. */

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

@@ -33,6 +33,7 @@ export class FakeGaiaRemote {
                 ...(r.worktreePath !== undefined
                     ? { worktreePath: r.worktreePath }
                     : {}),
+                ...(r.startedAt !== undefined ? { startedAt: r.startedAt } : {}),
                 ...(r.closed !== undefined ? { closed: r.closed } : {}),
             });
             this.queue.push({
@@ -150,10 +151,18 @@ export class FakeGaiaRemote {
     async fetchFinalizableRuns(_conductorId) {
         return [...this.runs.values()]
             .filter((r) => r.state === 'done' && !r.closed)
-            .map((r) => ({ runUuid: r.runUuid, worktreePath: r.worktreePath ?? '' }));
+            .map((r) => ({
+            runUuid: r.runUuid,
+            worktreePath: r.worktreePath ?? '',
+            ...(r.startedAt !== undefined ? { startedAt: r.startedAt } : {}),
+        }));
     }
-    async finalizeRun(runUuid, log) {
-        this.calls.finalizeRun.push({ runUuid, log });
+    async finalizeRun(runUuid, log, metrics) {
+        this.calls.finalizeRun.push({
+            runUuid,
+            log,
+            ...(metrics ? { metrics } : {}),
+        });
         const run = this.runs.get(runUuid);
         if (run) {
             run.closed = true;
@@ -161,9 +170,14 @@ export class FakeGaiaRemote {
                 run.log = log;
         }
     }
-    async fetchUncleanedTickets() {
+    async fetchUncleanedTickets(conductorId) {
+        // Scoped to the querying conductor (GAIA-121). A seed without an explicit
+        // `conductorId` defaults to the querying conductor (the common reaper-test
+        // case); an explicit value scopes it, and `''` models an unassigned ticket.
         return Object.entries(this.tickets)
-            .filter(([, t]) => (t.state === 'done' || t.closed) && !t.cleanedUp)
+            .filter(([, t]) => (t.state === 'done' || t.closed) &&
+            !t.cleanedUp &&
+            (t.conductorId ?? conductorId) === conductorId)
             .map(([ticketUuid, t]) => ({
             ticketUuid,
             branchName: t.branchName ?? `gaia/${t.identifier.toLowerCase()}`,

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

@@ -57,6 +57,25 @@ export interface FinalizableRun {
     runUuid: string;
     /** 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;
+}
+/**
+ * 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`.
+ */
+export interface RunMetrics {
+    tokens: number;
+    duration_s: number;
+    agent_turns: number;
+    tool_calls: number;
+    user_prompts: number;
+    user_prompt_words: number;
 }
 /**
  * A finished ticket whose worktree has not yet been torn down — the
@@ -123,19 +142,22 @@ export interface GaiaRemote {
      */
     fetchFinalizableRuns(conductorId: string): Promise<FinalizableRun[]>;
     /**
-     * Finalise a run: set closed + closed_date and (when non-empty) log. No state
-     * change — the run is already done.
+     * Finalise a run: set closed + closed_date, (when non-empty) log, and (when
+     * given) the per-run footprint metrics (GAIA-132). No state change — the run
+     * is already done.
      */
-    finalizeRun(uuid: string, log: string): Promise<void>;
+    finalizeRun(uuid: string, log: string, metrics?: RunMetrics): Promise<void>;
     /**
      * Finished tickets (state=done OR closed) whose worktree is not yet torn
      * down (cleaned_up=0) — the conductor's teardown work list (GAIA-89). Driven
-     * by the durable `cleaned_up` flag, NOT machine-scoped: the same query backs
-     * both the live tick and the standalone `gaia conductor reap`, so it catches
-     * orphans a conductor missed while down / after a restart / after a
-     * `conductor_id` reassignment. Empty once every finished ticket is cleaned.
+     * by the durable `cleaned_up` flag AND scoped to the reaping conductor
+     * (GAIA-121): only tickets assigned to `conductorId` are loaded, so every
+     * ticket on the list is unambiguously this conductor's — a missing worktree
+     * means "already torn down on this host", not "belongs to another host". The
+     * same query backs the live tick and the standalone `gaia conductor reap`.
+     * Empty once every finished ticket this conductor owns is cleaned.
      */
-    fetchUncleanedTickets(): Promise<UncleanTicket[]>;
+    fetchUncleanedTickets(conductorId: string): Promise<UncleanTicket[]>;
     /**
      * Close a ticket: set closed=true + closed_date. Ticket-lifecycle only, and
      * decoupled from teardown — a done ticket is closed even if its worktree

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/core",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "GAIA global contract: plugin API, built-in remotes/workspaces/auth, shared primitives.",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,7 @@
     "directory": "conductor/packages/core"
   },
   "dependencies": {
-    "dropsh": "^0.5.3",
+    "dropsh": "^0.5.6",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0"
   }