@gaia-ai/addon-grok 0.12.0 → 0.13.1

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 { parseGrokTranscript } from './footprint.js';
 export type GrokReasoningEffort = 'high' | 'medium' | 'low';
 export interface GrokAgentOptions {
@@ -12,8 +12,16 @@ export declare class GrokAgent implements GaiaAgent {
     private readonly home;
     readonly id = "grok";
     constructor(options?: GrokAgentOptions, home?: string);
-    launchCommand(prompt: string): string;
-    getRunLog(worktreePath: string): Promise<string>;
+    launchCommand(prompt: string, run?: AgentRunIdentity): string;
+    /**
+     * `grok --session-id <uuid>` documents "new conversation… must not already
+     * exist" (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 id its first attempt already wrote and fail to
+     * launch.
+     */
+    sessionExists(worktreePath: string, sessionId: string): Promise<boolean>;
+    getRunLog(worktreePath: string, run?: AgentRunIdentity): Promise<string>;
     parseFootprint(log: string): AgentFootprint;
 }
 export declare function grokAgent(options?: GrokAgentOptions): AgentPlugin;

package/dist/src/index.js

@@ -36,7 +36,7 @@ export class GrokAgent {
         this.options = options;
         this.home = home;
     }
-    launchCommand(prompt) {
+    launchCommand(prompt, run) {
         const parts = ['grok'];
         if (prompt !== '') {
             // Positional — the interactive form Grok Build documents
@@ -49,10 +49,100 @@ export class GrokAgent {
         if (this.options.reasoningEffort) {
             parts.push('--reasoning-effort', this.options.reasoningEffort);
         }
+        // Pin the session dir name to the run's UUID (GAIA-473), so `getRunLog`
+        // can select it directly instead of scanning every session dir under the
+        // cwd for the newest match — the scan is what let a foreign transcript
+        // (resumed run, re-dispatch, reused worktree) get finalised.
+        if (run?.sessionId) {
+            parts.push('--session-id', run.sessionId);
+        }
         return parts.join(' ');
     }
-    async getRunLog(worktreePath) {
+    /**
+     * `grok --session-id <uuid>` documents "new conversation… must not already
+     * exist" (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 id its first attempt already wrote and fail to
+     * launch.
+     */
+    async sessionExists(worktreePath, sessionId) {
+        const dir = join(this.home, '.grok', 'sessions', encodeGrokSessionCwd(worktreePath), sessionId);
+        return (await readJson(join(dir, 'summary.json'))) !== null;
+    }
+    async getRunLog(worktreePath, run) {
         const root = join(this.home, '.grok', 'sessions', encodeGrokSessionCwd(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 session dir directly — no directory scan,
+        // so a foreign transcript can never be selected. AC-5: when the pinned
+        // session dir 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 dir can also be
+        // *stale* — a re-dispatch omits `--session-id` (see `sessionExists`)
+        // because attempt 1's dir already owns this name, so a direct read here
+        // would silently keep returning attempt 1's transcript. `startedAt` is
+        // re-stamped on every dispatch, so a pinned dir older than this
+        // attempt's own start can only be a prior attempt's leftover — reject it
+        // and fall through to the scan, bounded by the same timestamp.
+        // GAIA-473 review round 4 (Critical 2): prefer the deterministic attempt
+        // family — the HIGHEST-numbered attempt whose session dir actually
+        // exists — over 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.
+        if (run?.attemptFamily?.length) {
+            for (let i = run.attemptFamily.length - 1; i >= 0; i--) {
+                const candidate = run.attemptFamily[i];
+                if (!candidate)
+                    continue;
+                const dir = join(root, candidate);
+                const summary = await readJson(join(dir, 'summary.json'));
+                if (!summary) {
+                    continue; // try the next, lower-numbered attempt.
+                }
+                const [signals, chatHistory, updates] = await Promise.all([
+                    readJson(join(dir, 'signals.json')),
+                    readText(join(dir, 'chat_history.jsonl')),
+                    readText(join(dir, 'updates.jsonl')),
+                ]);
+                return JSON.stringify({
+                    summary,
+                    signals: signals ?? {},
+                    chatHistory,
+                    updates,
+                });
+            }
+            // AC-5: none of the family's dirs exist yet — fall through to the scan.
+        }
+        else if (run?.sessionId) {
+            const dir = join(root, run.sessionId);
+            const summary = await readJson(join(dir, 'summary.json'));
+            let isStale = false;
+            if (summary && startedAtMs !== null && Number.isFinite(startedAtMs)) {
+                try {
+                    isStale = (await stat(dir)).mtimeMs < startedAtMs;
+                }
+                catch {
+                    isStale = true;
+                }
+            }
+            if (summary && !isStale) {
+                const [signals, chatHistory, updates] = await Promise.all([
+                    readJson(join(dir, 'signals.json')),
+                    readText(join(dir, 'chat_history.jsonl')),
+                    readText(join(dir, 'updates.jsonl')),
+                ]);
+                return JSON.stringify({
+                    summary,
+                    signals: signals ?? {},
+                    chatHistory,
+                    updates,
+                });
+            }
+            // fall through to the scan.
+        }
         let names;
         try {
             names = await readdir(root);
@@ -84,6 +174,11 @@ export class GrokAgent {
                     continue;
                 }
             }
+            if (startedAtMs !== null &&
+                Number.isFinite(startedAtMs) &&
+                updated < startedAtMs) {
+                continue;
+            }
             if (!latest || updated > latest.updated) {
                 latest = { dir, summary, updated };
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/addon-grok",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "GAIA agent plugin for xAI Grok Build, with a real session footprint.",
   "type": "module",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "directory": "gaia-cli/addons/grok"
   },
   "peerDependencies": {
-    "@gaia-ai/conductor": "^0.12.0",
-    "@gaia-ai/core": "^0.12.0"
+    "@gaia-ai/conductor": "^0.13.1",
+    "@gaia-ai/core": "^0.13.1"
   }
 }