fix: fall back to live context when assembly lacks user turns

Reviewed as no-fix-needed. Validation from review worker: focused engine tests passed; TypeScript no-emit failure reproduced on origin/main and was treated as baseline noise. Includes patch changeset .changeset/fix-cold-cache-prefill-error.md.

Author: Copilot

.changeset/fix-cold-cache-prefill-error.md

@@ -0,0 +1,17 @@
+---
+"@martian-engineering/lossless-claw": patch
+---
+
+Fix prefill errors on cold-cache new sessions that start with only an assistant greeting.
+
+When a session begins with an agent greeting before any user message and the Anthropic
+prompt cache goes cold (>5 min), `assemble()` could return a context containing only
+the assistant greeting with no user turns. Providers that require conversations to end
+with a user message would then reject the LLM call, silently dropping the user's first
+real message.
+
+`assemble()` now detects when the assembled context contains no user-role messages at
+all (raw-message-only DB state where every stored message is `assistant` or `toolResult`)
+and falls back to the live context, which correctly ends with the user's current message.
+Sessions with compaction summaries are unaffected because summaries are always stored
+with `role: "user"`.

src/engine.ts

@@ -5327,6 +5327,22 @@ export class LcmContextEngine implements ContextEngine {
         };
       }
 
+      // Guard: if assembled context contains no user turns at all (e.g. a new session
+      // that starts with an agent greeting before the first user message, cold-cache),
+      // fall back to live context to prevent LLM prefill errors.  Summaries always
+      // have role "user", so this only fires for raw-message-only DB states where
+      // every stored message is role "assistant" or "toolResult".
+      const assembledHasUserTurn = assembled.messages.some((m) => m.role === "user");
+      if (!assembledHasUserTurn && params.messages.length > 0) {
+        this.deps.log.info(
+          `[lcm] assemble: assembled context has no user turns, falling back to live context to prevent prefill errors conversation=${conversation.conversationId} ${sessionLabel} assembledMessages=${assembled.messages.length} duration=${formatDurationMs(Date.now() - startedAt)}`,
+        );
+        return {
+          messages: params.messages,
+          estimatedTokens: 0,
+        };
+      }
+
       this.deps.log.info(
         `[lcm] assemble: done conversation=${conversation.conversationId} ${sessionLabel} contextItems=${contextItems.length} hasSummaryItems=${hasSummaryItems} inputMessages=${params.messages.length} outputMessages=${assembled.messages.length} tokenBudget=${tokenBudget} estimatedTokens=${assembled.estimatedTokens} duration=${formatDurationMs(Date.now() - startedAt)}`,
       );

test/engine.test.ts

@@ -4144,6 +4144,68 @@ describe("LcmContextEngine.assemble canonical path", () => {
     expect(result.estimatedTokens).toBe(0);
   });
 
+  it("falls back to live context when assembled result has no user turns (cold-cache new session)", async () => {
+    // Reproduces the cold-cache new session scenario:
+    // Session starts with only an assistant greeting before any user message.
+    // When the cache goes cold and assemble() is called, the assembled DB context
+    // contains only the assistant greeting — no user turns.  This would cause a
+    // prefill error on providers that require conversations to end with a user message.
+    // The guard should detect the missing user turns and fall back to live context.
+    const engine = createEngine();
+    const sessionId = "session-cold-cache-no-user-turns";
+
+    await engine.ingest({
+      sessionId,
+      message: { role: "assistant", content: "Hello! How can I help you today?" } as AgentMessage,
+    });
+
+    // Simulate the first real user message arriving (params.messages = current turn only)
+    const liveMessages: AgentMessage[] = [
+      { role: "user", content: "Hi, I need help with something." },
+    ] as AgentMessage[];
+    const result = await engine.assemble({
+      sessionId,
+      messages: liveMessages,
+      tokenBudget: 10_000,
+    });
+
+    // Should fall back to live context, not return the assistant-only DB context
+    expect(result.messages).toBe(liveMessages);
+    expect(result.estimatedTokens).toBe(0);
+  });
+
+  it("does not fall back when assembled result has user turns even if it ends with assistant", async () => {
+    // Normal session: DB has [user, assistant].  The assembled result ends with an
+    // assistant turn, but it contains user turns — this is valid because the framework
+    // appends the current user turn after the assembled context.
+    const engine = createEngine();
+    const sessionId = "session-ends-with-assistant-has-user-turns";
+
+    await engine.ingest({
+      sessionId,
+      message: { role: "user", content: "persisted message one" } as AgentMessage,
+    });
+    await engine.ingest({
+      sessionId,
+      message: { role: "assistant", content: "persisted message two" } as AgentMessage,
+    });
+
+    const liveMessages: AgentMessage[] = [
+      { role: "user", content: "live turn" },
+    ] as AgentMessage[];
+    const result = await engine.assemble({
+      sessionId,
+      messages: liveMessages,
+      tokenBudget: 10_000,
+    });
+
+    // Should use the DB context (has user turns), not fall back to live
+    expect(result.messages).not.toBe(liveMessages);
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0].role).toBe("user");
+    expect(result.messages[1].role).toBe("assistant");
+  });
+
   it("drops orphan tool results during assembled transcript repair", async () => {
     const engine = createEngine();
     const sessionId = "session-orphan-tool-result";