@gaia-ai/addon-claude 0.12.0 → 0.13.0

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-import type { AgentFootprint, AgentPlugin, GaiaAgent } from '@gaia-ai/conductor/contract';
+import type { AgentFootprint, AgentPlugin, AgentRunIdentity, GaiaAgent } from '@gaia-ai/conductor/contract';
 export { parseClaudeTranscript } from './footprint.js';
 /**
  * Encode an absolute cwd the way Claude Code names its per-project transcript
@@ -13,8 +13,16 @@ export declare class ClaudeAgent implements GaiaAgent {
     private readonly home;
     readonly id = "claude";
     constructor(options: ClaudeAgentOptions, home?: string);
-    launchCommand(prompt: string): string;
-    getRunLog(worktreePath: string): Promise<string>;
+    launchCommand(prompt: string, run?: AgentRunIdentity): string;
+    /**
+     * `claude --session-id <uuid>` refuses to start when that session already
+     * exists (GAIA-473 review round 2), so the conductor checks this before
+     * pinning the run's own UUID — a re-dispatch of the same run would
+     * otherwise mint the very id its first attempt already wrote and fail to
+     * launch at all, silently (`claude` exits 0 on that error).
+     */
+    sessionExists(worktreePath: string, sessionId: string): Promise<boolean>;
+    getRunLog(worktreePath: string, run?: AgentRunIdentity): Promise<string>;
     parseFootprint(log: string): AgentFootprint;
 }
 /** Config-facing factory: `claudeAgent({ model: 'claude-opus-4-8' })`. */

package/dist/src/index.js

@@ -19,7 +19,7 @@ export class ClaudeAgent {
         this.options = options;
         this.home = home;
     }
-    launchCommand(prompt) {
+    launchCommand(prompt, run) {
         if (prompt === '') {
             return 'claude';
         }
@@ -28,10 +28,85 @@ export class ClaudeAgent {
             parts.push('--model', this.options.model);
         }
         parts.push('--dangerously-skip-permissions');
+        // Pin the transcript's own session id to the run's UUID (GAIA-473), so
+        // `getRunLog` can read that ONE file directly instead of scanning the
+        // worktree-keyed directory by mtime — the scan is what let a
+        // resumed/re-dispatched/reused worktree finalise a foreign transcript.
+        if (run?.sessionId) {
+            parts.push('--session-id', run.sessionId);
+        }
         return parts.join(' ');
     }
-    async getRunLog(worktreePath) {
+    /**
+     * `claude --session-id <uuid>` refuses to start when that session already
+     * exists (GAIA-473 review round 2), so the conductor checks this before
+     * pinning the run's own UUID — a re-dispatch of the same run would
+     * otherwise mint the very id its first attempt already wrote and fail to
+     * launch at all, silently (`claude` exits 0 on that error).
+     */
+    async sessionExists(worktreePath, sessionId) {
         const dir = join(this.home, '.claude', 'projects', encodeClaudeProjectDir(worktreePath));
+        try {
+            await stat(join(dir, `${sessionId}.jsonl`));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getRunLog(worktreePath, run) {
+        const dir = join(this.home, '.claude', 'projects', encodeClaudeProjectDir(worktreePath));
+        const startedAtMs = run?.startedAt !== undefined ? new Date(run.startedAt).getTime() : null;
+        // GAIA-473: when the run's own session id is known (pinned at launch via
+        // `--session-id`), read that file directly — no directory scan, so a
+        // foreign transcript (resumed run, re-dispatch, reused worktree) can
+        // never be selected. AC-5: when the pinned file is missing (a run
+        // dispatched before this change, or the agent never wrote it), fall
+        // through to the scan below — bounded by `run.startedAt` where known —
+        // instead of returning '' and turning a wrong log into no log at all.
+        //
+        // Round 4 (review round 3, Critical 1): the pinned file can also be
+        // *stale* rather than missing — a re-dispatch omits `--session-id` (see
+        // `sessionExists`) precisely because attempt 1's file already owns this
+        // name, so a direct read here would silently keep returning attempt 1's
+        // transcript forever. `startedAt` is re-stamped by the conductor on
+        // every dispatch (`markRunning`), so a pinned file older than this
+        // attempt's own start can only be a leftover from a prior attempt —
+        // reject it and fall through to the scan, which is bounded by the same
+        // timestamp and will find the fresh, unpinned file this attempt wrote.
+        // GAIA-473 review round 4 (Critical 2): when the run's deterministic
+        // attempt family is known, select the HIGHEST-numbered attempt whose
+        // file actually exists — an IDENTITY, not the `startedAt` window below,
+        // which a sibling session newer than the bound could still beat. Each
+        // family member names a distinct attempt, so no staleness check is
+        // needed: whichever member exists IS that attempt's own transcript.
+        if (run?.attemptFamily?.length) {
+            for (let i = run.attemptFamily.length - 1; i >= 0; i--) {
+                try {
+                    return await readFile(join(dir, `${run.attemptFamily[i]}.jsonl`), 'utf8');
+                }
+                catch {
+                    // try the next, lower-numbered attempt.
+                }
+            }
+            // AC-5: none of the family's files exist yet — a run dispatched before
+            // this change, or the agent never wrote its pinned file — so fall
+            // through to the scan below instead of returning ''.
+        }
+        else if (run?.sessionId) {
+            try {
+                const path = join(dir, `${run.sessionId}.jsonl`);
+                const isStale = startedAtMs !== null &&
+                    Number.isFinite(startedAtMs) &&
+                    (await stat(path)).mtimeMs < startedAtMs;
+                if (!isStale) {
+                    return await readFile(path, 'utf8');
+                }
+            }
+            catch {
+                // fall through to the scan.
+            }
+        }
         let entries;
         try {
             entries = await readdir(dir);
@@ -47,6 +122,11 @@ export class ClaudeAgent {
             const full = join(dir, name);
             try {
                 const s = await stat(full);
+                if (startedAtMs !== null &&
+                    Number.isFinite(startedAtMs) &&
+                    s.mtimeMs < startedAtMs) {
+                    continue;
+                }
                 if (!latest || s.mtimeMs > latest.mtimeMs) {
                     latest = { path: full, mtimeMs: s.mtimeMs };
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/addon-claude",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "GAIA agent plugin for the Claude CLI.",
   "type": "module",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "directory": "gaia-cli/addons/claude"
   },
   "peerDependencies": {
-    "@gaia-ai/conductor": "^0.12.0",
-    "@gaia-ai/core": "^0.12.0"
+    "@gaia-ai/conductor": "^0.13.0",
+    "@gaia-ai/core": "^0.13.0"
   }
 }