@koda-sl/baker-bridge 0.39.2 → 0.39.6-dev.8ba3c150

package/README.md

@@ -72,10 +72,16 @@ The bridge picks a Claude model per turn before calling the Agent SDK:
 | `GET` | `/landings/:slug/definition` | None | Return landing `_definition.md` as `{ content, title }` |
 | `GET` | `/flows/:slug` | None | Read flow `_data.json` (decrypted) |
 | `PUT` | `/flows/:slug` | None | Write flow `_data.json` (encrypts at rest) |
-| `POST` | `/message/async` | Bearer token | Dispatch a chat turn — fire-and-forget, 202 immediately |
+| `POST` | `/message/async` | Bearer token | Dispatch a chat turn — fire-and-forget, 202 immediately. Convex must include `turnId` and may include rendered `history` for deterministic rehydration |
 | `POST` | `/message/abort` | Bearer token | Abort a running query — kills the SDK iterator |
 | `POST` | `/answer-question` | Bearer token | Resolve a pending `AskUserQuestion` |
 
+## Agent scheduling
+
+The bridge disables Claude Code's native cron tools (`CronCreate`, `CronDelete`,
+`CronList`, and `ScheduleWakeup`) in Agent SDK sessions. Scheduled work must use
+Baker's product surface instead: `baker scheduled-actions create/update/delete/trigger`.
+
 ## Chat flow
 
 ```
@@ -106,7 +112,12 @@ Convex action ──POST /message/async──▶ Bridge AgentSession
 - **Stop button** flips the thread to `cancelled` via Convex first (UI is
   freed immediately) and best-effort POSTs `/message/abort` to kill the SDK.
 - **AskUserQuestion** posts `/api/chat/input-request` and blocks until the
-  dashboard answers via Convex action → bridge `/answer-question`.
+  dashboard answers via Convex action → bridge `/answer-question`. Convex
+  persists the answer before proxying it so a bridge restart does not erase the
+  user's response.
+- **Context source diagnostics** go to `/api/chat/context` so support can tell
+  whether a turn used `local_resume`, `rehydrated_missing_session`, or
+  `rehydrated_invalid_resume`.
 
 ## Attachment validation
 
@@ -141,6 +152,16 @@ oversized images still block the commit.
   when no SDK events are flowing. Without it, the 2 min stale-thread cron
   would falsely timeout active threads.
 - The session registry evicts entries idle for >24h to bound memory.
+- Convex dispatches include a bounded rendered current-thread history snapshot.
+  The bridge uses the local SDK session id when valid, but falls back to this
+  persisted transcript when the session file is missing or invalid; invalid
+  resume is retried at most once before surfacing an error. Prior attachment
+  metadata is rendered by Convex, capped, and counted against the same
+  deterministic history budget.
+- Each dispatched turn carries an explicit `turnId`; bridge callbacks preserve
+  that run-scoped id through stream, input, heartbeat, diagnostics, completion,
+  and background completion retries so stale callbacks cannot be retagged as a
+  newer turn.
 - A new chat that arrives while a previous one is still running aborts the
   previous run with a 30s timeout cap — a hung run cannot block the next message.
 
@@ -159,8 +180,9 @@ returned in the dispatch response besides 202.
 ## Architecture
 
 - **One session per thread** — `getOrCreateSession(threadId)` ensures every
-  message on the same thread shares an `AgentSession`. Multi-turn context is
-  preserved across bridge restarts via `~/.baker/sessions/<threadId>.json`.
+  message on the same thread shares an `AgentSession`. Multi-turn context uses
+  `~/.baker/sessions/<threadId>.json` as the fast path and Convex persisted
+  current-thread history as the fallback when local continuity is unavailable.
 - **Run-token cancellation** — each call to `sendAndStream` mints a Symbol; if
   the symbol changes (abort, replace) the run cleans up and exits without
   writing further. No globally-mutable abort flag.

package/dist/cli.d.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 declare const args: string[];
 declare const command: string;
-declare const VERSION = "0.39.1";
+declare const VERSION = "0.39.6";
 declare function printUsage(): void;
 declare function main(): Promise<void>;
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -2,7 +2,7 @@
 "use strict";
 const args = process.argv.slice(2);
 const command = args[0];
-const VERSION = "0.39.1";
+const VERSION = "0.39.6";
 function printUsage() {
     console.error("Usage: baker-bridge <command>");
     console.error("");

package/dist/hono/agent.d.ts

@@ -1,11 +1,11 @@
 import type { SlashCommand } from "@anthropic-ai/claude-agent-sdk";
-import type { ChatAttachment } from "./types.ts";
+import type { ChatAttachment, DispatchHistorySnapshot } from "./types.ts";
+export declare function buildRehydratedPrompt(content: string, history?: DispatchHistorySnapshot): string;
+export declare function isResumeSessionError(error: unknown): boolean;
 declare class AgentSession {
     readonly threadId: string;
     private sessionId;
     private pendingQuestions;
-    private handlerCtx;
-    private options;
     /** Identity token for the currently-running stream. abort() nulls this; if a
      *  later check sees a different value, the run knows it was abandoned. This
      *  replaces a global `aborted` flag whose reset-on-entry was racy. */
@@ -19,18 +19,32 @@ declare class AgentSession {
      *  assistant event when the SDK doesn't emit one (pure-text, no tool calls). */
     private turnText;
     private postedAssistantEvent;
+    private sawSdkEvent;
     lastUsedAt: number;
     constructor(threadId: string);
     /** Cancel any in-flight run. The next status check inside runStream will trip. */
     abort(): void;
     setSessionId(id: string): void;
     resolveQuestion(toolUseId: string, answers: Record<string, string>): boolean;
-    sendAndStream(content: string, attachments?: ChatAttachment[]): Promise<void>;
+    sendAndStream(content: string, attachments: ChatAttachment[] | undefined, history: DispatchHistorySnapshot | undefined, turnId: string): Promise<void>;
     private runStream;
+    private startRun;
+    private streamPreparedRun;
+    private startWatchdog;
+    private runWithResumeFallback;
+    private recordInitialContextSource;
+    private canRetryWithRehydration;
+    private recordInvalidResumeFallback;
+    private runQueryOnce;
+    private consumeSdkMessage;
+    private completeSuccessfulRun;
+    private postSyntheticAssistantEvent;
+    private recordRehydrationFailure;
     private handleStreamEvent;
     private handleContentBlockStart;
     private handleMessage;
     private preparePrompt;
+    private selectPreparedPrompt;
     private completeWithCancel;
     private completeWithError;
 }

package/dist/hono/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/hono/agent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAmBxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AA+CjD,cAAM,YAAY;IAChB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,gBAAgB,CAAsC;IAC9D,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,OAAO,CAAU;IAEzB;;0EAEsE;IACtE,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,WAAW,CAAgC;IACnD,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,KAAK,CAAqB;IAClC;oFACgF;IAChF,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,oBAAoB,CAAS;IACrC,UAAU,EAAE,MAAM,CAAc;gBAEpB,QAAQ,EAAE,MAAM;IAM5B,kFAAkF;IAClF,KAAK,IAAI,IAAI;IAgBb,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI9B,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IAUtE,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;YA8BrE,SAAS;IAsGvB,OAAO,CAAC,iBAAiB;IAoBzB,OAAO,CAAC,uBAAuB;YAiBjB,aAAa;YAgBb,aAAa;YAoBb,kBAAkB;YAalB,iBAAiB;CAiBhC;AAiHD,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAahF;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAOtD;AAWD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAuBhE"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/hono/agent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAoBxF,OAAO,KAAK,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAsB1E,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,MAAM,CAMhG;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAa5D;AAuCD,cAAM,YAAY;IAChB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,gBAAgB,CAAsC;IAE9D;;0EAEsE;IACtE,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,WAAW,CAAgC;IACnD,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,KAAK,CAAqB;IAClC;oFACgF;IAChF,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,oBAAoB,CAAS;IACrC,OAAO,CAAC,WAAW,CAAS;IAC5B,UAAU,EAAE,MAAM,CAAc;gBAEpB,QAAQ,EAAE,MAAM;IAI5B,kFAAkF;IAClF,KAAK,IAAI,IAAI;IAgBb,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI9B,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IAUtE,aAAa,CACjB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,cAAc,EAAE,GAAG,SAAS,EACzC,OAAO,EAAE,uBAAuB,GAAG,SAAS,EAC5C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;YAoCF,SAAS;IAgCvB,OAAO,CAAC,QAAQ;YAYF,iBAAiB;IAyB/B,OAAO,CAAC,aAAa;YAeP,qBAAqB;IA8CnC,OAAO,CAAC,0BAA0B;IAiClC,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,2BAA2B;YAcrB,YAAY;YAyBZ,iBAAiB;YAuBjB,qBAAqB;YAYrB,2BAA2B;IAYzC,OAAO,CAAC,wBAAwB;IAchC,OAAO,CAAC,iBAAiB;IAoBzB,OAAO,CAAC,uBAAuB;YAiBjB,aAAa;YAgBb,aAAa;YAiBb,oBAAoB;YAQpB,kBAAkB;YAalB,iBAAiB;CAgBhC;AAkHD,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAahF;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAOtD;AAWD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAuBhE"}

package/dist/hono/agent.js

@@ -1,9 +1,9 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { buildAttachmentPromptSuffix, downloadAttachments } from "./attachments.js";
-import { clearStreamBuffer, enqueueStreamingTools, enqueueStreamText, flushStream, markStreamReplace, postEvent, postHeartbeat, postInputRequest, postInputResolved, postRouterSample, signalComplete, } from "./convex.js";
+import { clearStreamBuffer, enqueueStreamingTools, enqueueStreamText, flushStream, markStreamReplace, postEvent, postHeartbeat, postInputRequest, postInputResolved, postRouterSample, recordContextSource, signalComplete, } from "./convex.js";
 import { selectModel } from "./model-router.js";
 import { recoverStalledPublish } from "./publish-recovery.js";
-import { loadSessionId, saveSessionId } from "./session-store.js";
+import { clearSessionId, loadSessionId, saveSessionId } from "./session-store.js";
 // ---------------------------------------------------------------------------
 // Tunables
 // ---------------------------------------------------------------------------
@@ -22,6 +22,24 @@ const SESSION_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
  *  hangs sooner so users see a real error instead of an indefinite spinner. */
 const ASK_USER_QUESTION_TIMEOUT_MS = 15 * 60 * 1000;
 const HEARTBEAT_INTERVAL_MS = 45_000;
+export function buildRehydratedPrompt(content, history) {
+    if (!history?.renderedContext) {
+        return content;
+    }
+    return `${history.renderedContext}\n\n--- Current user request\n${content}`;
+}
+export function isResumeSessionError(error) {
+    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    if (!message.includes("session") && !message.includes("resume")) {
+        return false;
+    }
+    return (message.includes("resume") &&
+        (message.includes("not found") ||
+            message.includes("invalid") ||
+            message.includes("expired") ||
+            message.includes("unknown") ||
+            message.includes("does not exist")));
+}
 // ---------------------------------------------------------------------------
 // AgentSession — one per thread, persists across messages so SDK resume works.
 // ---------------------------------------------------------------------------
@@ -29,8 +47,6 @@ class AgentSession {
     threadId;
     sessionId;
     pendingQuestions = new Map();
-    handlerCtx;
-    options;
     /** Identity token for the currently-running stream. abort() nulls this; if a
      *  later check sees a different value, the run knows it was abandoned. This
      *  replaces a global `aborted` flag whose reset-on-entry was racy. */
@@ -44,11 +60,10 @@ class AgentSession {
      *  assistant event when the SDK doesn't emit one (pure-text, no tool calls). */
     turnText = "";
     postedAssistantEvent = false;
+    sawSdkEvent = false;
     lastUsedAt = Date.now();
     constructor(threadId) {
         this.threadId = threadId;
-        this.handlerCtx = { threadId, pendingQuestions: this.pendingQuestions };
-        this.options = buildSessionOptions(this.handlerCtx);
     }
     /** Cancel any in-flight run. The next status check inside runStream will trip. */
     abort() {
@@ -79,13 +94,14 @@ class AgentSession {
         this.pendingQuestions.delete(toolUseId);
         return true;
     }
-    async sendAndStream(content, attachments) {
+    async sendAndStream(content, attachments, history, turnId) {
         if (this.streamingPromise) {
+            const previousPromise = this.streamingPromise;
             this.replacingStream = true;
             this.abort();
             try {
                 await Promise.race([
-                    this.streamingPromise,
+                    previousPromise,
                     new Promise((_, reject) => setTimeout(() => reject(new Error("previous stream timed out")), REPLACE_STREAM_TIMEOUT_MS)),
                 ]);
             }
@@ -93,123 +109,222 @@ class AgentSession {
                 console.error(`[AgentSession] previous stream did not drain on thread ${this.threadId} — forcing reset:`, err instanceof Error ? err.message : err);
             }
             finally {
-                this.streamingPromise = null;
+                if (this.streamingPromise === previousPromise) {
+                    this.streamingPromise = null;
+                }
                 this.replacingStream = false;
             }
         }
-        this.streamingPromise = this.runStream(content, attachments);
+        const runPromise = this.runStream(content, attachments, history, turnId);
+        this.streamingPromise = runPromise;
         try {
-            await this.streamingPromise;
+            await runPromise;
         }
         finally {
-            this.streamingPromise = null;
+            if (this.streamingPromise === runPromise) {
+                this.streamingPromise = null;
+            }
         }
     }
-    async runStream(content, attachments) {
+    async runStream(content, attachments, history, turnId) {
+        const runToken = this.startRun();
+        let result = { costUsd: 0, attemptedRehydration: false };
+        try {
+            const prepared = await this.preparePrompt(content, attachments, runToken, history);
+            if (!prepared) {
+                await this.completeWithCancel(0, turnId);
+                return;
+            }
+            result = await this.streamPreparedRun(prepared, history, runToken, turnId);
+            if (this.activeRun !== runToken) {
+                await this.completeWithCancel(result.costUsd, turnId);
+                return;
+            }
+            await this.completeSuccessfulRun(result.costUsd, turnId);
+        }
+        catch (error) {
+            if (result.attemptedRehydration) {
+                this.recordRehydrationFailure(history, error, turnId);
+            }
+            await this.completeWithError(result.costUsd, error, runToken, turnId);
+        }
+    }
+    startRun() {
         const runToken = Symbol("agent-run");
         this.activeRun = runToken;
         this.lastUsedAt = Date.now();
         this.currentTurnTools = [];
         this.turnText = "";
         this.postedAssistantEvent = false;
-        let costUsd = 0;
+        this.sawSdkEvent = false;
         this.model = undefined;
+        return runToken;
+    }
+    async streamPreparedRun(prepared, history, runToken, turnId) {
+        const abortController = new AbortController();
+        this.activeAbort = abortController;
+        let lastEventAt = Date.now();
+        const watchdog = this.startWatchdog(() => lastEventAt, abortController);
+        const heartbeat = setInterval(() => void postHeartbeat(this.threadId, turnId), HEARTBEAT_INTERVAL_MS).unref();
         try {
-            const prepared = await this.preparePrompt(content, attachments, runToken);
-            if (!prepared) {
-                await this.completeWithCancel(0);
+            return await this.runWithResumeFallback(prepared, history, runToken, turnId, abortController, (timestamp) => {
+                lastEventAt = timestamp;
+            });
+        }
+        finally {
+            clearInterval(watchdog);
+            clearInterval(heartbeat);
+            if (this.activeAbort === abortController) {
+                this.activeAbort = null;
+            }
+        }
+    }
+    startWatchdog(getLastEventAt, abortController) {
+        return setInterval(() => {
+            if (Date.now() - getLastEventAt() <= SDK_WATCHDOG_MS) {
                 return;
             }
+            console.error(`[AgentSession] watchdog: no SDK event for ${SDK_WATCHDOG_MS}ms — aborting thread ${this.threadId}`);
+            abortController.abort();
+        }, 30_000).unref();
+    }
+    async runWithResumeFallback(prepared, history, runToken, turnId, abortController, markEvent) {
+        const attemptedResumeSessionId = this.sessionId;
+        const result = { costUsd: 0, attemptedRehydration: false };
+        result.attemptedRehydration = this.recordInitialContextSource(Boolean(attemptedResumeSessionId), history, turnId);
+        try {
             this.model = prepared.model;
-            void postRouterSample(this.threadId, prepared.model, prepared.routerMessages);
-            this.activeAbort = new AbortController();
-            const opts = {
-                ...this.options,
-                model: prepared.model,
-                abortController: this.activeAbort,
-                ...(this.sessionId && { resume: this.sessionId }),
-            };
-            const q = query({ prompt: prepared.prompt, options: opts });
-            let lastEventAt = Date.now();
-            const watchdog = setInterval(() => {
-                if (Date.now() - lastEventAt > SDK_WATCHDOG_MS) {
-                    console.error(`[AgentSession] watchdog: no SDK event for ${SDK_WATCHDOG_MS}ms — aborting thread ${this.threadId}`);
-                    clearInterval(watchdog);
-                    this.activeAbort?.abort();
-                }
-            }, 30_000).unref();
-            const heartbeat = setInterval(() => {
-                void postHeartbeat(this.threadId);
-            }, HEARTBEAT_INTERVAL_MS).unref();
-            try {
-                for await (const msg of q) {
-                    lastEventAt = Date.now();
-                    this.lastUsedAt = lastEventAt;
-                    if (this.activeRun !== runToken) {
-                        break;
-                    }
-                    if (msg.session_id) {
-                        this.sessionId = msg.session_id;
-                        void saveSessionId(this.threadId, msg.session_id);
-                    }
-                    await this.handleMessage(msg);
-                    if (msg.type === "result") {
-                        costUsd = msg.total_cost_usd;
-                    }
-                }
+            result.costUsd = await this.runQueryOnce(Boolean(attemptedResumeSessionId), prepared, runToken, turnId, abortController, markEvent);
+            void postRouterSample(this.threadId, prepared.model, prepared.routerMessages, turnId);
+            return result;
+        }
+        catch (error) {
+            if (!this.canRetryWithRehydration(attemptedResumeSessionId, error)) {
+                throw error;
             }
-            finally {
-                clearInterval(watchdog);
-                clearInterval(heartbeat);
+            this.sessionId = undefined;
+            await clearSessionId(this.threadId);
+            this.recordInvalidResumeFallback(history, turnId);
+            result.attemptedRehydration = true;
+            const fallbackPrepared = await this.selectPreparedPrompt(buildRehydratedPrompt(prepared.prompt, history), runToken);
+            if (!fallbackPrepared) {
+                return result;
             }
-            this.activeAbort = null;
+            this.model = fallbackPrepared.model;
+            result.costUsd = await this.runQueryOnce(false, fallbackPrepared, runToken, turnId, abortController, markEvent);
+            void postRouterSample(this.threadId, fallbackPrepared.model, fallbackPrepared.routerMessages, turnId);
+            return result;
+        }
+    }
+    recordInitialContextSource(hasResumeSession, history, turnId) {
+        if (hasResumeSession) {
+            void recordContextSource(this.threadId, "local_resume", {
+                historyEntryCount: history?.entries.length ?? 0,
+                historyTruncated: history?.truncated ?? false,
+            }, turnId);
+            return false;
+        }
+        if (!history || (history.entries.length === 0 && history.omittedEntryCount === 0)) {
+            return false;
+        }
+        void recordContextSource(this.threadId, "rehydrated_missing_session", {
+            historyEntryCount: history.entries.length,
+            omittedEntryCount: history.omittedEntryCount,
+            historyTruncated: history.truncated,
+        }, turnId);
+        return true;
+    }
+    canRetryWithRehydration(attemptedResumeSessionId, error) {
+        return Boolean(attemptedResumeSessionId && isResumeSessionError(error) && !this.sawSdkEvent);
+    }
+    recordInvalidResumeFallback(history, turnId) {
+        console.warn(`[AgentSession] clearing invalid local session for thread ${this.threadId} and retrying once`);
+        void recordContextSource(this.threadId, "rehydrated_invalid_resume", {
+            historyEntryCount: history?.entries.length ?? 0,
+            omittedEntryCount: history?.omittedEntryCount ?? 0,
+            historyTruncated: history?.truncated ?? false,
+        }, turnId);
+    }
+    async runQueryOnce(useResume, prepared, runToken, turnId, abortController, markEvent) {
+        let costUsd = 0;
+        const opts = {
+            ...buildSessionOptions({ threadId: this.threadId, pendingQuestions: this.pendingQuestions, turnId }),
+            model: prepared.model,
+            abortController,
+            ...(useResume && this.sessionId && { resume: this.sessionId }),
+        };
+        const q = query({ prompt: prepared.prompt, options: opts });
+        for await (const msg of q) {
+            costUsd = await this.consumeSdkMessage(msg, costUsd, runToken, turnId, markEvent);
             if (this.activeRun !== runToken) {
-                await this.completeWithCancel(costUsd);
-                return;
-            }
-            if (this.pendingQuestions.size > 0) {
-                console.warn(`[AgentSession] SDK completed but ${String(this.pendingQuestions.size)} question(s) still pending on thread ${this.threadId}`);
+                break;
             }
-            // The Agent SDK doesn't emit a `type: "assistant"` message for pure-text
-            // turns (no tool calls). Synthesize one from the accumulated stream deltas
-            // so the response is persisted and visible in the conversation.
-            if (!this.postedAssistantEvent && this.turnText.length > 0) {
-                const syntheticAssistant = {
-                    type: "assistant",
-                    message: {
-                        role: "assistant",
-                        content: [{ type: "text", text: this.turnText }],
-                        stop_reason: "end_turn",
-                    },
-                };
-                await postEvent(this.threadId, syntheticAssistant, this.model);
-            }
-            await signalComplete(this.threadId, costUsd, false, undefined, this.model);
         }
-        catch (error) {
-            await this.completeWithError(costUsd, error, runToken);
+        return costUsd;
+    }
+    async consumeSdkMessage(msg, costUsd, runToken, turnId, markEvent) {
+        const timestamp = Date.now();
+        markEvent(timestamp);
+        this.lastUsedAt = timestamp;
+        if (this.activeRun !== runToken) {
+            return costUsd;
+        }
+        this.sawSdkEvent = true;
+        if (msg.session_id) {
+            this.sessionId = msg.session_id;
+            void saveSessionId(this.threadId, msg.session_id);
+        }
+        await this.handleMessage(msg, turnId);
+        return msg.type === "result" ? msg.total_cost_usd : costUsd;
+    }
+    async completeSuccessfulRun(costUsd, turnId) {
+        if (this.pendingQuestions.size > 0) {
+            console.warn(`[AgentSession] SDK completed but ${String(this.pendingQuestions.size)} question(s) still pending on thread ${this.threadId}`);
         }
+        if (!this.postedAssistantEvent && this.turnText.length > 0) {
+            await this.postSyntheticAssistantEvent(turnId);
+        }
+        await signalComplete(this.threadId, costUsd, false, undefined, this.model, turnId);
+    }
+    async postSyntheticAssistantEvent(turnId) {
+        const syntheticAssistant = {
+            type: "assistant",
+            message: {
+                role: "assistant",
+                content: [{ type: "text", text: this.turnText }],
+                stop_reason: "end_turn",
+            },
+        };
+        await postEvent(this.threadId, syntheticAssistant, this.model, turnId);
     }
-    handleStreamEvent(event) {
+    recordRehydrationFailure(history, error, turnId) {
+        void recordContextSource(this.threadId, "rehydration_failed", {
+            historyEntryCount: history?.entries.length ?? 0,
+            omittedEntryCount: history?.omittedEntryCount ?? 0,
+            historyTruncated: history?.truncated ?? false,
+            reason: error instanceof Error ? error.name : typeof error,
+        }, turnId);
+    }
+    handleStreamEvent(event, turnId) {
         if (event.type === "message_start") {
             this.currentTurnTools = [];
             this.turnText = "";
-            markStreamReplace(this.threadId);
+            markStreamReplace(this.threadId, turnId);
             return;
         }
         if (event.type === "content_block_start") {
-            this.handleContentBlockStart(event);
+            this.handleContentBlockStart(event, turnId);
             return;
         }
         if (event.type === "content_block_delta") {
             const delta = event.delta;
             if (delta?.type === "text_delta" && typeof delta.text === "string") {
                 this.turnText += delta.text;
-                enqueueStreamText(this.threadId, delta.text);
+                enqueueStreamText(this.threadId, delta.text, turnId);
             }
         }
     }
-    handleContentBlockStart(event) {
+    handleContentBlockStart(event, turnId) {
         const block = event.content_block;
         if (block?.type !== "tool_use") {
             return;
@@ -223,25 +338,25 @@ class AgentSession {
             tool.input = block.input;
         }
         this.currentTurnTools = [...this.currentTurnTools, tool];
-        enqueueStreamingTools(this.threadId, this.currentTurnTools);
+        enqueueStreamingTools(this.threadId, this.currentTurnTools, turnId);
     }
-    async handleMessage(msg) {
+    async handleMessage(msg, turnId) {
         if (msg.type === "stream_event") {
             const event = msg.event;
             if (event) {
-                this.handleStreamEvent(event);
+                this.handleStreamEvent(event, turnId);
             }
             return;
         }
         if (msg.type === "assistant") {
             this.currentTurnTools = [];
             this.postedAssistantEvent = true;
-            await postEvent(this.threadId, msg, this.model);
+            await postEvent(this.threadId, msg, this.model, turnId);
         }
         // system / result messages are not persisted; result.cost_usd is captured above.
     }
-    async preparePrompt(content, attachments, runToken) {
-        let prompt = content;
+    async preparePrompt(content, attachments, runToken, history) {
+        let prompt = this.sessionId ? content : buildRehydratedPrompt(content, history);
         if (attachments && attachments.length > 0) {
             const paths = await downloadAttachments(attachments);
             prompt += buildAttachmentPromptSuffix(paths);
@@ -249,28 +364,30 @@ class AgentSession {
         if (this.activeRun !== runToken) {
             return null;
         }
+        return this.selectPreparedPrompt(prompt, runToken);
+    }
+    async selectPreparedPrompt(prompt, runToken) {
         const routerResult = await selectModel(prompt);
         if (this.activeRun !== runToken) {
             return null;
         }
         return { prompt, model: routerResult.model, routerMessages: routerResult.messages };
     }
-    async completeWithCancel(costUsd) {
+    async completeWithCancel(costUsd, turnId) {
         // Don't fire signalComplete if we're being replaced by another stream — the
         // new stream's signalComplete will run instead, and the cancelThread mutation
         // already flipped the thread. (Convex completeThread is idempotent regardless.)
-        await flushStream(this.threadId);
-        clearStreamBuffer(this.threadId);
+        await flushStream(this.threadId, turnId);
+        clearStreamBuffer(this.threadId, turnId);
         if (this.replacingStream) {
             return;
         }
-        await signalComplete(this.threadId, costUsd, true, ["Cancelled by user"], this.model);
+        await signalComplete(this.threadId, costUsd, true, ["Cancelled by user"], this.model, turnId);
         void recoverStalledPublish();
     }
-    async completeWithError(costUsd, error, runToken) {
-        this.activeAbort = null;
+    async completeWithError(costUsd, error, runToken, turnId) {
         if (this.activeRun !== runToken) {
-            await this.completeWithCancel(costUsd);
+            await this.completeWithCancel(costUsd, turnId);
             return;
         }
         const rawMessage = error instanceof Error ? error.message : "Unknown error";
@@ -279,7 +396,7 @@ class AgentSession {
         if (this.pendingQuestions.size > 0) {
             console.warn(`[AgentSession] SDK errored with ${String(this.pendingQuestions.size)} question(s) still pending on thread ${this.threadId}`);
         }
-        await signalComplete(this.threadId, costUsd, true, [message], this.model);
+        await signalComplete(this.threadId, costUsd, true, [message], this.model, turnId);
         void recoverStalledPublish();
     }
 }
@@ -297,7 +414,7 @@ function enrichImageError(message) {
 }
 async function handleAskUserQuestion(input, toolUseID, ctx, signal) {
     console.warn(`[AskUserQuestion] blocking for ${toolUseID} on thread ${ctx.threadId}`);
-    const posted = await postInputRequest(ctx.threadId, toolUseID, input.questions);
+    const posted = await postInputRequest(ctx.threadId, toolUseID, input.questions, ctx.turnId);
     if (!posted) {
         console.error(`[AskUserQuestion] failed to post input-request for ${toolUseID} — frontend may not show question UI`);
     }
@@ -327,7 +444,7 @@ async function handleAskUserQuestion(input, toolUseID, ctx, signal) {
         }, { once: true });
     });
     console.warn(`[AskUserQuestion] ${toolUseID} answered, resuming`);
-    void postInputResolved(ctx.threadId);
+    void postInputResolved(ctx.threadId, ctx.turnId);
     return {
         behavior: "allow",
         updatedInput: { questions: input.questions, answers },
@@ -341,6 +458,7 @@ function buildSessionOptions(handlerCtx) {
         cwd: process.cwd(),
         settingSources: ["project"],
         includePartialMessages: true,
+        disallowedTools: ["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"],
         canUseTool: (toolName, input, opts) => {
             if (toolName === "AskUserQuestion") {
                 return handleAskUserQuestion(input, opts.toolUseID, handlerCtx, opts.signal);