@getpaseo/server 0.1.17 → 0.1.20

package/dist/src/server/agent/providers/claude-agent.js

@@ -11,6 +11,24 @@ import { buildClaudeModelFamilyAliases, buildClaudeSelectableModelIds, listClaud
 import { buildToolCallDisplayModel } from "../../../shared/tool-call-display.js";
 import { applyProviderEnv, isProviderCommandAvailable, } from "../provider-launch-config.js";
 import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";
+/*
+ * Routing invariant:
+ * While a foreground Claude turn is active, identifier-less assistant/stream/result
+ * events must stay attached to that foreground run unless we have explicit evidence
+ * that a distinct autonomous run has started.
+ *
+ * We previously allowed task_notification metadata to reserve autonomous ownership,
+ * then consumed that reservation on the next unbound chunk. In practice Claude often
+ * emits task_notification records and foreground tool-use stream chunks interleaved
+ * within the same turn. That let a foreground turn's terminal result get misrouted
+ * into an autonomous side run, which stranded the agent in "running" because the
+ * foreground stream never received turn_completed.
+ *
+ * The rule below is intentionally conservative: foreground turns get first claim on
+ * same-turn traffic, and autonomous wake reservations are only consumed once no
+ * foreground turn is active. This keeps task_notification advisory instead of letting
+ * it steal ownership from the active user turn.
+ */
 const fsPromises = promises;
 const CLAUDE_SETTING_SOURCES = [
     "user",
@@ -157,15 +175,18 @@ const REWIND_COMMAND = {
 };
 const INTERRUPT_TOOL_USE_PLACEHOLDER = "[Request interrupted by user for tool use]";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function resolveClaudeBinary() {
+function whichClaude() {
     try {
-        const claudePath = execSync("which claude", { encoding: "utf8" }).trim();
-        if (claudePath) {
-            return claudePath;
-        }
+        return execSync("which claude", { encoding: "utf8" }).trim() || null;
     }
     catch {
-        // fall through
+        return null;
+    }
+}
+function resolveClaudeBinary() {
+    const claudePath = whichClaude();
+    if (claudePath) {
+        return claudePath;
     }
     throw new Error("Claude CLI not found. Install claude or configure agents.providers.claude.command.mode='replace'.");
 }
@@ -942,11 +963,18 @@ export class ClaudeAgentClient {
         this.defaults = options.defaults;
         this.logger = options.logger.child({ module: "agent", provider: "claude" });
         this.runtimeSettings = options.runtimeSettings;
-        try {
-            this.claudePath = execSync("which claude", { encoding: "utf8" }).trim() || null;
+        this.claudePath = whichClaude();
+        if (this.claudePath) {
+            try {
+                const version = execSync(`${this.claudePath} --version`, { encoding: "utf8" }).trim();
+                this.logger.trace({ claudePath: this.claudePath, version }, "Resolved Claude binary");
+            }
+            catch {
+                this.logger.trace({ claudePath: this.claudePath }, "Resolved Claude binary (version unknown)");
+            }
         }
-        catch {
-            this.claudePath = null;
+        else {
+            this.logger.trace("Claude binary not found in PATH; SDK will use bundled binary");
         }
     }
     async createSession(config) {
@@ -2008,8 +2036,10 @@ class ClaudeAgentSession {
     }
     routeMessage(normalized) {
         if (normalized.metadataOnly) {
-            if (normalized.message.type === "user" &&
-                isTaskNotificationUserContent(normalized.message.message?.content)) {
+            if ((normalized.message.type === "user" &&
+                isTaskNotificationUserContent(normalized.message.message?.content)) ||
+                (normalized.message.type === "system" &&
+                    normalized.message.subtype === "task_notification")) {
                 this.reserveAutonomousWake("task_notification");
             }
             this.notePreReplayMetadata(normalized.message);
@@ -2022,12 +2052,6 @@ class ClaudeAgentSession {
         if (byIdentifiers.run) {
             return byIdentifiers;
         }
-        if (this.turnState === "autonomous") {
-            const activeAutonomousRun = this.runTracker.getLatestActiveRun("autonomous");
-            if (activeAutonomousRun) {
-                return { run: activeAutonomousRun, reason: "unbound_autonomous" };
-            }
-        }
         const foregroundRun = this.activeForegroundTurn
             ? this.runTracker.getRun(this.activeForegroundTurn.runId)
             : null;
@@ -2059,26 +2083,48 @@ class ClaudeAgentSession {
             })) {
             return { run: foregroundRun, reason: "foreground" };
         }
+        if (this.pendingAutonomousWakeReservations > 0 &&
+            !normalized.identifiers.taskId &&
+            !normalized.identifiers.parentMessageId &&
+            !normalized.identifiers.messageId) {
+            const reservedAutonomousRun = this.claimOrCreateAutonomousRun("reservation_unbound");
+            return {
+                run: reservedAutonomousRun,
+                reason: "reserved_autonomous",
+            };
+        }
         if (!hasIdentifiers) {
-            if (this.pendingAutonomousWakeReservations > 0) {
-                const reservedAutonomousRun = this.claimOrCreateAutonomousRun("reservation_unbound");
-                return {
-                    run: reservedAutonomousRun,
-                    reason: "unbound_autonomous",
-                };
-            }
             const activeAutonomousRun = this.runTracker.getLatestActiveRun("autonomous");
             if (activeAutonomousRun) {
                 return { run: activeAutonomousRun, reason: "unbound_autonomous" };
             }
+            if (!foregroundRun &&
+                (normalized.message.type === "assistant" ||
+                    normalized.message.type === "stream_event" ||
+                    normalized.message.type === "result" ||
+                    normalized.message.type === "tool_progress")) {
+                const autonomousRun = this.claimOrCreateAutonomousRun("unbound_implicit");
+                return { run: autonomousRun, reason: "unbound_autonomous" };
+            }
         }
         if (this.pendingAutonomousWakeReservations > 0) {
             const reservedAutonomousRun = this.claimOrCreateAutonomousRun("reservation_fallback");
-            return { run: reservedAutonomousRun, reason: "fallback" };
+            return { run: reservedAutonomousRun, reason: "reserved_autonomous" };
         }
-        const autonomousRun = this.createRun("autonomous", null);
-        this.emitRunEvent(autonomousRun, { type: "turn_started", provider: "claude" });
-        return { run: autonomousRun, reason: "fallback" };
+        this.logger.debug({
+            messageType: normalized.message.type,
+            hasIdentifiers,
+            taskId: normalized.identifiers.taskId,
+            parentMessageId: normalized.identifiers.parentMessageId,
+            messageId: normalized.identifiers.messageId,
+            turnState: this.turnState,
+            pendingAutonomousWakeReservations: this.pendingAutonomousWakeReservations,
+        }, "Ignoring unmatched Claude SDK message without explicit run start signal");
+        return {
+            run: null,
+            reason: "ignored_unmatched",
+            dispatchWithoutRun: false,
+        };
     }
     shouldPreferForegroundRun(input) {
         const { run, message } = input;
@@ -2135,7 +2181,12 @@ class ClaudeAgentSession {
         if (!foregroundRun || foregroundRun.promptReplaySeen) {
             return;
         }
-        if (message.type === "system" && message.subtype === "init") {
+        // Most system metadata (init/hook callbacks/etc.) can precede the first prompt
+        // replay for a legitimate foreground run. Treating all of it as churn strands
+        // one-shot helper runs. task_notification is the exception: it represents
+        // background agent activity and should suppress pre-replay foreground routing.
+        if (message.type === "system" &&
+            message.subtype !== "task_notification") {
             return;
         }
         this.preReplayMetadataSeen = true;
@@ -2177,7 +2228,7 @@ class ClaudeAgentSession {
             return;
         }
         const pump = this.runQueryPump().catch((error) => {
-            this.logger.warn({ err: error }, "Claude query pump exited unexpectedly");
+            this.logger.trace({ err: error }, "Claude query pump exited unexpectedly");
         });
         this.queryPumpPromise = pump;
         pump.finally(() => {
@@ -2197,17 +2248,22 @@ class ClaudeAgentSession {
                 q = await this.ensureQuery();
             }
             catch (error) {
-                this.logger.warn({ err: error }, "Failed to initialize Claude query pump");
+                this.logger.trace({ err: error }, "Failed to initialize Claude query pump");
                 await this.waitForLiveHistoryPoll();
                 continue;
             }
             let next;
             try {
                 next = await q.next();
-                this.logger.info({ claudeSessionId: this.claudeSessionId, next }, "Claude query pump raw next()");
+                this.logger.trace({ claudeSessionId: this.claudeSessionId, next }, "Claude query pump raw next()");
             }
             catch (error) {
-                this.logger.warn({ err: error }, "Claude query pump next() failed");
+                if (this.query !== q) {
+                    this.logger.trace({ err: error, staleQuery: true }, "Ignoring Claude query pump next() failure from replaced query");
+                    await this.awaitWithTimeout(q.return?.(), "query pump return after stale failure");
+                    continue;
+                }
+                this.logger.trace({ err: error }, "Claude query pump next() failed");
                 for (const run of this.runTracker.listActiveRuns()) {
                     this.failRun(run, error instanceof Error ? error.message : "Claude stream failed");
                 }
@@ -2221,6 +2277,15 @@ class ClaudeAgentSession {
                 continue;
             }
             if (next.done) {
+                if (this.query !== q) {
+                    this.logger.trace({
+                        claudeSessionId: this.claudeSessionId,
+                        activeRunCount: this.runTracker.listActiveRuns().length,
+                        staleQuery: true,
+                    }, "Ignoring replaced Claude query pump completion");
+                    await this.awaitWithTimeout(q.return?.(), "query pump return on stale done");
+                    continue;
+                }
                 this.logger.trace({
                     claudeSessionId: this.claudeSessionId,
                     activeRunCount: this.runTracker.listActiveRuns().length,
@@ -2244,11 +2309,23 @@ class ClaudeAgentSession {
             if (!sdkMessage) {
                 continue;
             }
+            if (this.query !== q) {
+                this.logger.trace({
+                    claudeSessionId: this.claudeSessionId,
+                    messageType: sdkMessage.type,
+                    staleQuery: true,
+                }, "Ignoring Claude SDK message from replaced query");
+                await this.awaitWithTimeout(q.return?.(), "query pump return on stale message");
+                continue;
+            }
+            if (await this.handleMissingResumedConversation(sdkMessage, q)) {
+                continue;
+            }
             try {
                 this.routeSdkMessageFromPump(sdkMessage);
             }
             catch (error) {
-                this.logger.warn({ err: error }, "Failed to route Claude SDK message from query pump");
+                this.logger.trace({ err: error }, "Failed to route Claude SDK message from query pump");
             }
         }
     }
@@ -2303,6 +2380,9 @@ class ClaudeAgentSession {
             return;
         }
         if (!route.run) {
+            if (route.dispatchWithoutRun === false) {
+                return;
+            }
             this.dispatchMetadataEvents(events);
             return;
         }
@@ -2310,6 +2390,33 @@ class ClaudeAgentSession {
             this.emitRunEvent(route.run, event);
         }
     }
+    async handleMissingResumedConversation(message, query) {
+        const staleResumeError = this.readMissingResumedConversationError(message);
+        if (!staleResumeError) {
+            return false;
+        }
+        this.logger.warn({
+            claudeSessionId: this.claudeSessionId,
+            error: staleResumeError,
+        }, "Claude resumed session no longer exists; invalidating persisted session");
+        for (const run of this.runTracker.listActiveRuns()) {
+            this.failRun(run, staleResumeError);
+        }
+        this.transitionTurnStateFromActiveRuns("missing resumed conversation");
+        this.input?.end();
+        await this.awaitWithTimeout(query.return?.(), "query pump return on missing resumed conversation");
+        if (this.query === query) {
+            this.query = null;
+            this.input = null;
+        }
+        this.claudeSessionId = null;
+        this.persistence = null;
+        this.persistedHistory = [];
+        this.historyPending = false;
+        this.cachedRuntimeInfo = null;
+        this.queryRestartNeeded = false;
+        return true;
+    }
     shouldSuppressReplayResultTerminal(input) {
         const { run, message } = input;
         if (!run || run.owner !== "foreground" || message.type !== "result") {
@@ -2428,22 +2535,22 @@ class ClaudeAgentSession {
     async interruptActiveTurn() {
         const queryToInterrupt = this.query;
         if (!queryToInterrupt || typeof queryToInterrupt.interrupt !== "function") {
-            this.logger.debug("interruptActiveTurn: no query to interrupt");
+            this.logger.trace("interruptActiveTurn: no query to interrupt");
             return;
         }
         try {
-            this.logger.debug("interruptActiveTurn: calling query.interrupt()...");
+            this.logger.trace("interruptActiveTurn: calling query.interrupt()...");
             const t0 = Date.now();
             await queryToInterrupt.interrupt();
-            this.logger.debug({ durationMs: Date.now() - t0 }, "interruptActiveTurn: query.interrupt() returned");
+            this.logger.trace({ durationMs: Date.now() - t0 }, "interruptActiveTurn: query.interrupt() returned");
             // After interrupt(), the query iterator is done (returns done: true).
             // Clear it so ensureQuery() creates a fresh query for the next turn.
             // Also end the input stream and call return() to clean up the SDK process.
             this.input?.end();
-            this.logger.debug("interruptActiveTurn: calling query.return()...");
+            this.logger.trace("interruptActiveTurn: calling query.return()...");
             const t1 = Date.now();
             await queryToInterrupt.return?.();
-            this.logger.debug({ durationMs: Date.now() - t1 }, "interruptActiveTurn: query.return() returned");
+            this.logger.trace({ durationMs: Date.now() - t1 }, "interruptActiveTurn: query.return() returned");
             this.query = null;
             this.input = null;
             this.queryRestartNeeded = false;
@@ -2902,6 +3009,28 @@ class ClaudeAgentSession {
         }
         return threadStartedSessionId;
     }
+    readMissingResumedConversationError(message) {
+        if (message.type !== "result" || message.subtype !== "error_during_execution") {
+            return null;
+        }
+        if (!this.claudeSessionId) {
+            return null;
+        }
+        const errors = "errors" in message && Array.isArray(message.errors) ? message.errors : [];
+        for (const entry of errors) {
+            if (typeof entry !== "string") {
+                continue;
+            }
+            const match = entry.match(/^No conversation found with session ID:\s*(.+)$/);
+            if (!match) {
+                continue;
+            }
+            if (match[1]?.trim() === this.claudeSessionId) {
+                return entry.trim();
+            }
+        }
+        return null;
+    }
     convertUsage(message) {
         if (!message.usage) {
             return undefined;