Harden DCP chat transforms and clarify compacted output

lib/hooks.ts

@@ -104,53 +104,60 @@ export function createChatMessageTransformHandler(
     hostPermissions: HostPermissionSnapshot,
 ) {
     return async (input: {}, output: { messages: WithParts[] }) => {
-        const receivedMessages = Array.isArray(output.messages) ? output.messages.length : 0
-        const messages = filterMessagesInPlace(output.messages)
-        if (messages.length !== receivedMessages) {
-            logger.warn("Skipping messages with unexpected shape during chat transform", {
-                received: receivedMessages,
-                usable: messages.length,
-            })
-        }
+        // Fail-open: catch transform failures so DCP bugs do not abort the session.
+        try {
+            const receivedMessages = Array.isArray(output.messages) ? output.messages.length : 0
+            const messages = filterMessagesInPlace(output.messages)
+            if (messages.length !== receivedMessages) {
+                logger.warn("Skipping messages with unexpected shape during chat transform", {
+                    received: receivedMessages,
+                    usable: messages.length,
+                })
+            }
 
-        await checkSession(client, state, logger, output.messages, config.manualMode.enabled)
+            await checkSession(client, state, logger, output.messages, config.manualMode.enabled)
 
-        syncCompressPermissionState(state, config, hostPermissions, output.messages)
+            syncCompressPermissionState(state, config, hostPermissions, output.messages)
 
-        if (state.isSubAgent && !config.experimental.allowSubAgents) {
-            return
-        }
+            if (state.isSubAgent && !config.experimental.allowSubAgents) {
+                return
+            }
 
-        stripHallucinations(output.messages)
-        cacheSystemPromptTokens(state, output.messages)
-        assignMessageRefs(state, output.messages)
-        syncCompressionBlocks(state, logger, output.messages)
-        syncToolCache(state, config, logger, output.messages)
-        buildToolIdList(state, output.messages)
-        prune(state, logger, config, output.messages)
-        await injectExtendedSubAgentResults(
-            client,
-            state,
-            logger,
-            output.messages,
-            config.experimental.allowSubAgents,
-        )
-        const compressionPriorities = buildPriorityMap(config, state, output.messages)
-        prompts.reload()
-        injectCompressNudges(
-            state,
-            config,
-            logger,
-            output.messages,
-            prompts.getRuntimePrompts(),
-            compressionPriorities,
-        )
-        injectMessageIds(state, config, output.messages, compressionPriorities)
-        applyPendingManualTrigger(state, output.messages, logger)
-        stripStaleMetadata(output.messages)
+            stripHallucinations(output.messages)
+            cacheSystemPromptTokens(state, output.messages)
+            assignMessageRefs(state, output.messages)
+            syncCompressionBlocks(state, logger, output.messages)
+            syncToolCache(state, config, logger, output.messages)
+            buildToolIdList(state, output.messages)
+            prune(state, logger, config, output.messages)
+            await injectExtendedSubAgentResults(
+                client,
+                state,
+                logger,
+                output.messages,
+                config.experimental.allowSubAgents,
+            )
+            const compressionPriorities = buildPriorityMap(config, state, output.messages)
+            prompts.reload()
+            injectCompressNudges(
+                state,
+                config,
+                logger,
+                output.messages,
+                prompts.getRuntimePrompts(),
+                compressionPriorities,
+            )
+            injectMessageIds(state, config, output.messages, compressionPriorities)
+            applyPendingManualTrigger(state, output.messages, logger)
+            stripStaleMetadata(output.messages)
 
-        if (state.sessionId) {
-            await logger.saveContext(state.sessionId, output.messages)
+            if (state.sessionId) {
+                await logger.saveContext(state.sessionId, output.messages)
+            }
+        } catch (err) {
+            logger.error("DCP chat transform failed; continuing without mutations", {
+                error: err instanceof Error ? err.message : String(err),
+            })
         }
     }
 }

lib/message-ids.ts

@@ -136,14 +136,17 @@ export function assignMessageRefs(state: SessionState, messages: WithParts[]): n
         }
 
         const existingRef = state.messageIds.byRawId.get(rawMessageId)
-        if (existingRef) {
+        if (existingRef !== undefined) {
             if (state.messageIds.byRef.get(existingRef) !== rawMessageId) {
                 state.messageIds.byRef.set(existingRef, rawMessageId)
             }
             continue
         }
 
         const ref = allocateNextMessageRef(state)
+        if (!ref) {
+            break
+        }
         state.messageIds.byRawId.set(rawMessageId, ref)
         state.messageIds.byRef.set(ref, rawMessageId)
         assigned++
@@ -166,7 +169,9 @@ function allocateNextMessageRef(state: SessionState): string {
         candidate++
     }
 
-    throw new Error(
-        `Message ID alias capacity exceeded. Cannot allocate more than ${formatMessageRef(MESSAGE_REF_MAX_INDEX)} aliases in this session.`,
-    )
+    // Graceful degradation: stop allocating aliases instead of hard-throwing.
+    // This prevents DCP from crashing the session when message volume exceeds
+    // the referenceable range; downstream features that depend on message refs
+    // will simply see unassigned messages.
+    return ""
 }

lib/token-utils.ts

@@ -80,7 +80,7 @@ export function estimateTokensBatch(texts: string[]): number {
     return countTokens(texts.join(" "))
 }
 
-export const COMPACTED_TOOL_OUTPUT_PLACEHOLDER = "[Old tool result content cleared]"
+export const COMPACTED_TOOL_OUTPUT_PLACEHOLDER = "[Tool output compacted locally; original in session storage.]"
 
 function stringifyToolContent(value: unknown): string {
     return typeof value === "string" ? value : JSON.stringify(value)

tests/message-ids.test.ts

@@ -87,3 +87,42 @@ test("checkSession resets message id aliases after native compaction", async ()
     assert.equal(state.messageIds.byRef.get("m0002"), "msg-user-follow-up")
     assert.equal(state.messageIds.nextRef, 3)
 })
+
+test("assignMessageRefs stops cleanly when alias capacity is exhausted", () => {
+    const sessionID = `ses_message_ids_exhausted_${Date.now()}`
+    const state = createSessionState()
+    state.messageIds.nextRef = 10000
+
+    const messages: WithParts[] = [
+        {
+            info: {
+                id: "msg-a",
+                role: "assistant",
+                sessionID,
+                agent: "assistant",
+                time: { created: 1 },
+            } as WithParts["info"],
+            parts: [textPart("msg-a", sessionID, "msg-a-part", "A")],
+        },
+        {
+            info: {
+                id: "msg-b",
+                role: "assistant",
+                sessionID,
+                agent: "assistant",
+                time: { created: 2 },
+            } as WithParts["info"],
+            parts: [textPart("msg-b", sessionID, "msg-b-part", "B")],
+        },
+    ]
+
+    const firstAssigned = assignMessageRefs(state, messages)
+    const secondAssigned = assignMessageRefs(state, messages)
+
+    assert.equal(firstAssigned, 0)
+    assert.equal(secondAssigned, 0)
+    assert.equal(state.messageIds.byRawId.size, 0)
+    assert.equal(state.messageIds.byRef.size, 0)
+    assert.equal(state.messageIds.byRawId.get("msg-a"), undefined)
+    assert.equal(state.messageIds.byRawId.get("msg-b"), undefined)
+})