kernel authorization request: signature-only thinking blocks share one message id, so after a Claude Code compact new thinking blocks take over old folds #5180

diff --git a/kernel/package-lock.json b/kernel/package-lock.json
index bbe88cba..9a50787c 100644
--- a/kernel/package-lock.json
+++ b/kernel/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "acp-kernel",
-  "version": "0.0.170",
+  "version": "0.0.171",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "acp-kernel",
-      "version": "0.0.170",
+      "version": "0.0.171",
       "license": "MIT",
       "devDependencies": {
         "@types/node": "^22.0.0",
diff --git a/kernel/package.json b/kernel/package.json
index 28b2aac6..37f51d6a 100644
--- a/kernel/package.json
+++ b/kernel/package.json
@@ -1,6 +1,6 @@
 {
   "name": "acp-kernel",
-  "version": "0.0.170",
+  "version": "0.0.171",
   "description": "Framework-agnostic context-compression engine (model-driven, 3-tier LSM). Pure core: no host dependency.",
   "license": "MIT",
   "author": "ranxianglei",
diff --git a/kernel/src/wire/anthropic.ts b/kernel/src/wire/anthropic.ts
index 0af98bd7..d801dd90 100644
--- a/kernel/src/wire/anthropic.ts
+++ b/kernel/src/wire/anthropic.ts
@@ -5,6 +5,7 @@ import {
   canonicalToolArgs,
   deriveCanonicalMessageId,
   imageMediaFingerprint,
+  thinkingPayloadFingerprint,
 } from "./identity.js";
 import { hashId } from "./util.js";
 import { ClusterCounter } from "./message-id.js";
@@ -202,6 +203,7 @@ export function anthropicToCore(body: AnthropicRequestBody): Flat {
             "assistant",
             "reasoning",
             b.thinking,
+            { payloadFingerprint: thinkingPayloadFingerprint(b.thinking, b.signature) },
           );
           msgs.push({
             id: clusters.next(base),
@@ -261,6 +263,7 @@ export function anthropicToCore(body: AnthropicRequestBody): Flat {
             m.role,
             "text",
             CANONICAL_REDACTED_THINKING_TEXT,
+            { payloadFingerprint: thinkingPayloadFingerprint("", b.data) },
           );
           msgs.push({
             id: clusters.next(base),
diff --git a/kernel/src/wire/identity.ts b/kernel/src/wire/identity.ts
index 6f9da6d3..c97aee69 100644
--- a/kernel/src/wire/identity.ts
+++ b/kernel/src/wire/identity.ts
@@ -93,14 +93,36 @@ export function deriveCanonicalMessageId(
   role: string,
   contentType: string,
   text: string,
-  options: { toolName?: string; mediaFingerprint?: string } = {},
+  options: { toolName?: string; mediaFingerprint?: string; payloadFingerprint?: string } = {},
 ): string {
   const seed =
     `${idSalt ? idSalt + "|" : ""}${role}|${contentType}||${options.toolName ?? ""}|${text}` +
-    (options.mediaFingerprint !== undefined ? `|${options.mediaFingerprint}` : "");
+    (options.mediaFingerprint !== undefined ? `|${options.mediaFingerprint}` : "") +
+    (options.payloadFingerprint !== undefined ? `|payload:${options.payloadFingerprint}` : "");
   return "h_" + hashId(seed);
 }
 
+let legacyThinkingIds = false;
+
+/** TEST ONLY: mint thinking-family ids the pre-fingerprint way, to
+ * test a session saved under them. Production code never sets this. */
+export function __setLegacyThinkingIdsForTests(on: boolean): void {
+  legacyThinkingIds = on;
+}
+
+/** Payload fingerprint for thinking-family blocks that carry no
+ * text of their own: signature-only thinking (Claude Code with Opus 5.x sends
+ * every thinking block that way) and redacted_thinking. They all shared one
+ * base id, told apart only by `_N` ordinals, so when the client compacted,
+ * the ordinals restarted and new blocks took over the ids, refs and fold
+ * coverage of old ones — the never-reused id contract broken. The signature
+ * or data is unique per block and replayed byte-exact, so it addresses the
+ * id the way #3751's image payload does. Thinking with text keeps its id. */
+export function thinkingPayloadFingerprint(text: string, payload: unknown): string | undefined {
+  if (legacyThinkingIds || text !== "" || typeof payload !== "string" || payload === "") return undefined;
+  return hashId(payload);
+}
+
 /** #3751 — media fingerprint for image-bearing cores.
  *
  * Pre-#3751 every image core shared the same canonical text ("[image]"), so
diff --git a/kernel/tests/thinking-payload-identity.test.ts b/kernel/tests/thinking-payload-identity.test.ts
new file mode 100644
index 00000000..5ec5244f
--- /dev/null
+++ b/kernel/tests/thinking-payload-identity.test.ts
@@ -0,0 +1,63 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { anthropicToCore, type AnthropicRequestBody } from "../src/wire/anthropic.js";
+import { CANONICAL_REDACTED_THINKING_TEXT, __setLegacyThinkingIdsForTests, deriveCanonicalMessageId } from "../src/wire/identity.js";
+
+// Thinking-family blocks without text of their own (signature-only
+// thinking, redacted_thinking) are addressed by their payload, so a compact
+// that restarts the client's history cannot hand an old block's id to a new
+// one. The end-to-end case is tests/thinking-identity-after-compact.test.ts.
+
+function idsOf(content: unknown[]): string[] {
+    const body = { messages: [{ role: "user", content: "go" }, { role: "assistant", content }] } as unknown as AnthropicRequestBody;
+    return anthropicToCore(body).msgs.filter((m) => m.role === "assistant").map((m) => m.id);
+}
+
+test("signature-only thinking blocks get one id each, whatever their position", () => {
+    const [a, b] = idsOf([
+        { type: "thinking", thinking: "", signature: "sig-A" },
+        { type: "thinking", thinking: "", signature: "sig-B" },
+    ]);
+    const [bAlone] = idsOf([{ type: "thinking", thinking: "", signature: "sig-B" }]);
+    assert.notEqual(a!.replace(/_\d+$/, ""), b!.replace(/_\d+$/, ""), "different signatures, different base ids");
+    assert.equal(b, bAlone, "a block keeps its id when the blocks before it are gone");
+});
+
+test("thinking with text keeps the id it always had", () => {
+    const [id] = idsOf([{ type: "thinking", thinking: "plan the filters", signature: "sig-A" }]);
+    assert.equal(id, deriveCanonicalMessageId("assistant", "reasoning", "plan the filters"));
+});
+
+test("redacted thinking is addressed by its data", () => {
+    const [a, b] = idsOf([
+        { type: "redacted_thinking", data: "data-A" },
+        { type: "redacted_thinking", data: "data-B" },
+    ]);
+    const [bAlone] = idsOf([{ type: "redacted_thinking", data: "data-B" }]);
+    assert.notEqual(a!.replace(/_\d+$/, ""), b!.replace(/_\d+$/, ""));
+    assert.equal(b, bAlone);
+});
+
+test("a true duplicate still shares its base id and takes the next ordinal", () => {
+    const [a, again] = idsOf([
+        { type: "thinking", thinking: "", signature: "sig-A" },
+        { type: "thinking", thinking: "", signature: "sig-A" },
+    ]);
+    assert.equal(again, `${a}_1`);
+});
+
+test("the test-only legacy switch mints the old shared ids", () => {
+    __setLegacyThinkingIdsForTests(true);
+    try {
+        const [t1, t2, r1] = idsOf([
+            { type: "thinking", thinking: "", signature: "sig-A" },
+            { type: "thinking", thinking: "", signature: "sig-B" },
+            { type: "redacted_thinking", data: "data-A" },
+        ]);
+        const base = deriveCanonicalMessageId("assistant", "reasoning", "");
+        assert.deepEqual([t1, t2], [base, `${base}_1`]);
+        assert.equal(r1, deriveCanonicalMessageId("assistant", "text", CANONICAL_REDACTED_THINKING_TEXT));
+    } finally {
+        __setLegacyThinkingIdsForTests(false);
+    }
+});
diff --git a/package-lock.json b/package-lock.json
index eced96ec..bfc642e9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -50,7 +50,7 @@
     },
     "kernel": {
       "name": "acp-kernel",
-      "version": "0.0.170",
+      "version": "0.0.171",
       "dev": true,
       "license": "MIT",
       "devDependencies": {
diff --git a/tests/thinking-identity-after-compact.test.ts b/tests/thinking-identity-after-compact.test.ts
new file mode 100644
index 00000000..5e50f1c0
--- /dev/null
+++ b/tests/thinking-identity-after-compact.test.ts
@@ -0,0 +1,297 @@
+// Claude Code with Opus 5.x sends every thinking block with empty
+// text and only a signature. Their ids hashed the text alone, so all of them
+// shared one base id, told apart only by the `_N` ordinal of their position.
+// When Claude Code compacts, its history restarts and so do the ordinals: the
+// new thinking blocks took over the ids, refs and fold coverage of thinking
+// blocks folded before the compact. Seen 2026-10-29 in a production session:
+// 8 pre-compact blocks stayed active and kept their summaries in the context,
+// 99 of 119 new thinking blocks counted as folded and were dropped from the
+// wire, and refs like m00282 reappeared on new messages.
+//
+// End to end through the proxy: a fold over turns with signature-only
+// thinking, then (1) a normal next request, (2) the same for a session folded
+// under the old ids, (3) a request after a Claude Code compact. The scripted
+// upstream enforces the Anthropic wire ledger.
+import assert from "node:assert/strict";
+import http from "node:http";
+import { once } from "node:events";
+import test from "node:test";
+
+process.env.NODE_ENV = "test";
+
+import { defaultConfig } from "acp-kernel";
+import { __setLegacyThinkingIdsForTests } from "acp-kernel/wire";
+import { startServer } from "../src/server.ts";
+import type { ProxyOptions } from "../src/config.ts";
+import { SessionStore, _setStoreForTest } from "../src/persist.ts";
+import { _setForTest as setRegistryForTest } from "../src/registry.ts";
+import { VALIDATORS } from "./wire-contract-fakes.ts";
+
+type Block = Record<string, unknown>;
+type Msg = { role: string; content: string | Block[] };
+
+const sse = (event: string, data: unknown): string => `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+
+const FILLER = (seed: string, kb: number): string => {
+    const para = `Note ${seed}: the stock list filters by location, expiry and supplier, and the export keeps the same columns. `;
+    return Array.from({ length: Math.ceil((kb * 1024) / para.length) }, (_, i) => para.replace(seed, `${seed}.${i}`)).join("");
+};
+
+const sig = (turn: number, part: string) => `EqQBCkYIBxgCKkA-sig-${turn}-${part}-` + "x".repeat(40);
+
+/** One Claude Code tool turn: user asks, the model thinks and runs a tool, then thinks and answers. */
+function turn(n: number): Msg[] {
+    return [
+        { role: "user", content: [{ type: "text", text: `request ${n}: move list ${n} onto the shared filters. ${FILLER(`u${n}`, 3)}` }] },
+        { role: "assistant", content: [
+            { type: "thinking", thinking: "", signature: sig(n, "a") },
+            { type: "tool_use", id: `toolu_${n}`, name: "Bash", input: { command: `grep -n filters list${n}.tsx` } },
+        ] },
+        { role: "user", content: [{ type: "tool_result", tool_use_id: `toolu_${n}`, content: `list${n}.tsx: ${FILLER(`r${n}`, 3)}` }] },
+        { role: "assistant", content: [
+            { type: "thinking", thinking: "", signature: sig(n, "b") },
+            { type: "text", text: `done ${n}: list ${n} now uses the shared filters. ${FILLER(`a${n}`, 2)}` },
+        ] },
+    ];
+}
+
+const SUMMARY = "Folded the first turns: the first lists were moved onto the shared filter system and checked.";
+
+function signaturesIn(messages: Msg[]): string[] {
+    return messages.flatMap((m) => (typeof m.content === "string" ? [] : m.content.filter((b) => b.type === "thinking").map((b) => String(b.signature))));
+}
+
+function refsIn(messages: Msg[]): number[] {
+    return [...JSON.stringify(messages).matchAll(/m(\d{5})/g)].map((x) => Number(x[1]));
+}
+
+/** The ref the proxy tagged onto the first text block containing `needle`. */
+function refOf(messages: Msg[], needle: string): string {
+    for (const m of messages) {
+        if (typeof m.content === "string") continue;
+        for (const b of m.content) {
+            if (b.type === "text" && String(b.text).includes(needle)) {
+                const r = String(b.text).match(/m\d{5}/);
+                if (r) return r[0];
+            }
+        }
+    }
+    throw new Error(`no ref tagged on a text block containing ${needle}`);
+}
+
+const textSse = (t: string) => [
+    sse("message_start", { type: "message_start", message: { id: "msg_t", role: "assistant", usage: { input_tokens: 20 } } }),
+    sse("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } }),
+    sse("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: t } }),
+    sse("content_block_stop", { type: "content_block_stop", index: 0 }),
+    sse("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: 4 } }),
+    sse("message_stop", { type: "message_stop" }),
+].join("");
+
+function compressSse(startId: string, endId: string): string {
+    const args = JSON.stringify({ startId, endId, topic: "lists 1-3", summary: SUMMARY });
+    return [
+        sse("message_start", { type: "message_start", message: { id: "msg_c", role: "assistant", usage: { input_tokens: 55 } } }),
+        sse("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "tool_use", id: "toolu_compress", name: "compress", input: {} } }),
+        sse("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "input_json_delta", partial_json: args } }),
+        sse("content_block_stop", { type: "content_block_stop", index: 0 }),
+        sse("message_delta", { type: "message_delta", delta: { stop_reason: "tool_use", stop_sequence: null }, usage: { output_tokens: 12 } }),
+        sse("message_stop", { type: "message_stop" }),
+    ].join("");
+}
+
+interface Harness {
+    send(messages: Msg[]): Promise<string>;
+    bodies: Msg[][];
+    violations: string[][];
+    close(): Promise<void>;
+}
+
+async function startHarness(session: string): Promise<Harness> {
+    const bodies: Msg[][] = [];
+    const violations: string[][] = [];
+    const upstream = http.createServer((req, res) => {
+        const chunks: Buffer[] = [];
+        req.on("data", (c: Buffer) => chunks.push(c));
+        req.on("end", () => {
+            const body = JSON.parse(Buffer.concat(chunks).toString("utf8")) as { messages: Msg[] };
+            const found = VALIDATORS.anthropic(body);
+            bodies.push(body.messages);
+            violations.push(found);
+            if (found.length > 0) {
+                res.writeHead(400, { "content-type": "application/json" });
+                res.end(JSON.stringify({ type: "error", error: { type: "invalid_request_error", message: found.join("; ") } }));
+                return;
+            }
+            res.writeHead(200, { "content-type": "text/event-stream" });
+            // The first body asks to fold turns 1-3; everything after answers plainly.
+            res.end(bodies.length === 1 ? compressSse(refOf(body.messages, "request 1:"), refOf(body.messages, "done 3:")) : textSse("ok"));
+        });
+    });
+    upstream.listen(0, "127.0.0.1");
+    await once(upstream, "listening");
+    const upstreamPort = (upstream.address() as { port: number }).port;
+
+    _setStoreForTest(new SessionStore({ enabled: false }));
+    setRegistryForTest({});
+    const proxy = await startServer({
+        port: 0,
+        host: "127.0.0.1",
+        upstream: "http://127.0.0.1",
+        routes: { [`http://127.0.0.1:${upstreamPort}`]: { models: { "claude-test": { context: 400_000 } } } },
+        modelContextLimit: 400_000,
+        kernelConfig: defaultConfig(400_000),
+        compress: { injectTool: true, injectNudge: true },
+        promptCache: { routing: "auto" },
+        sessionHeader: "x-acp-session",
+        log: false,
+        debug: false,
+        passthrough: false,
+        autoUpdate: false,
+        compat: { roles: {} },
+        streamErrorShape: "protocol",
+        passthroughSource: null,
+        autoRestartOnUpdate: false,
+        updateTag: "latest",
+        advisoryCheck: false,
+        releaseNotesCheck: false,
+        mitm: { enabled: false, domains: [] },
+    } as ProxyOptions);
+    await once(proxy, "listening");
+    const proxyPort = (proxy.address() as { port: number }).port;
+    const url = `http://127.0.0.1:${proxyPort}/bili/http://127.0.0.1:${upstreamPort}/v1/messages`;
+    return {
+        bodies,
+        violations,
+        async send(messages) {
+            const resp = await fetch(url, {
+                method: "POST",
+                headers: { "content-type": "application/json", "x-acp-session": session },
+                body: JSON.stringify({ model: "claude-test", max_tokens: 1024, stream: true, thinking: { type: "adaptive" }, system: "You are a coding agent.", messages }),
+            });
+            assert.equal(resp.status, 200);
+            return resp.text();
+        },
+        close: async () => {
+            proxy.close();
+            proxy.closeIdleConnections?.();
+            await once(proxy, "close");
+            upstream.close();
+            upstream.closeIdleConnections?.();
+            await once(upstream, "close");
+        },
+    };
+}
+
+const trigger = (t: string): Msg => ({ role: "user", content: [{ type: "text", text: t }] });
+const reply = (t: string): Msg => ({ role: "assistant", content: [{ type: "text", text: t }] });
+
+/** Six turns and a fold asked for over turns 1-3, committed on the first
+ *  request. The kernel may keep the last of those turns out (it did: turn 3
+ *  stays whole), so `folded` is what the follow-up request left out. */
+async function foldedSession(session: string): Promise<{ h: Harness; history: Msg[]; folded: string[] }> {
+    const h = await startHarness(session);
+    const history = [1, 2, 3, 4, 5, 6].flatMap(turn);
+    await h.send([...history, trigger("now do the parts list")]);
+    assert.ok(h.bodies.length >= 2, "the fold's follow-up request went out");
+    assert.ok(JSON.stringify(h.bodies[1]).includes(SUMMARY), "the fold committed");
+    const kept = signaturesIn(h.bodies[1]!);
+    const folded = signaturesIn(h.bodies[0]!).filter((s) => !kept.includes(s));
+    return { h, history: [...history, trigger("now do the parts list"), reply("ok")], folded };
+}
+
+test("a fold over signature-only thinking still holds on the next request", async () => {
+    const { h, history, folded } = await foldedSession("thinking-id-no-compact");
+    try {
+        const before = h.bodies.length;
+        await h.send([...history, trigger("and the purchasing list")]);
+        const out = h.bodies[before]!;
+        assert.deepEqual(h.violations[before], [], "legal on the wire");
+        assert.ok(JSON.stringify(out).includes(SUMMARY), "the summary still stands in for the folded turns");
+        assert.deepEqual(signaturesIn(out), signaturesIn(h.bodies[1]!), "the same thinking blocks are folded and visible as right after the fold");
+        assert.ok(folded.length >= 2, `the fold took thinking blocks: ${folded.length}`);
+    } finally {
+        await h.close();
+    }
+});
+
+test("a session folded under the old thinking ids keeps its fold after the upgrade", async () => {
+    __setLegacyThinkingIdsForTests(true);
+    let session: Awaited<ReturnType<typeof foldedSession>>;
+    try {
+        session = await foldedSession("thinking-id-upgrade");
+    } finally {
+        __setLegacyThinkingIdsForTests(false);
+    }
+    const { h, history, folded } = session;
+    try {
+        const before = h.bodies.length;
+        await h.send([...history, trigger("and the purchasing list")]);
+        const out = h.bodies[before]!;
+        assert.deepEqual(h.violations[before], [], "legal on the wire");
+        assert.ok(JSON.stringify(out).includes(SUMMARY), "the summary still stands in for the folded turns");
+        assert.deepEqual(signaturesIn(out), signaturesIn(h.bodies[1]!), "the same thinking blocks are folded and visible as right after the fold");
+        assert.ok(folded.length >= 2, `the fold took thinking blocks: ${folded.length}`);
+    } finally {
+        await h.close();
+    }
+});
+
+/** Claude Code's history right after it compacted: its summary, then new turns. */
+const compactedHistory = (turns: number[]): Msg[] => [
+    { role: "user", content: [{ type: "text", text: `This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.\n\nSummary:\n1. Lists 1-6 were moved onto the shared filters. ${FILLER("summary", 2)}` }] },
+    ...turns.flatMap(turn),
+    trigger("now the sales list"),
+];
+
+// OPEN (2026-10-29): not healed. After the upgrade the stale fold still holds
+// thinking 7a-8b and its summary stays in the context: the reconcile carries
+// its coverage over to the new ids by position. The fix stops new cases; a
+// session hit before it keeps its stale folds. Kept as a todo so it runs and
+// reports until it is fixed.
+test("a session already hit by the reused ids is healed by the upgrade", { todo: "open: stale folds survive the upgrade" }, async () => {
+    // The production state: folded and compacted under the old ids, so the old
+    // fold has taken over new thinking blocks.
+    __setLegacyThinkingIdsForTests(true);
+    let session: Awaited<ReturnType<typeof foldedSession>>;
+    try {
+        session = await foldedSession("thinking-id-heal");
+        await session.h.send(compactedHistory([7, 8, 9]));
+        const hit = session.h.bodies.at(-1)!;
+        assert.ok(JSON.stringify(hit).includes(SUMMARY), "under the old ids the stale summary is in the context (the bug)");
+    } finally {
+        __setLegacyThinkingIdsForTests(false);
+    }
+    const { h } = session;
+    try {
+        const before = h.bodies.length;
+        await h.send([...compactedHistory([7, 8, 9]), reply("ok"), trigger("and the purchasing list")]);
+        const out = h.bodies[before]!;
+        assert.deepEqual(h.violations[before], [], "legal on the wire");
+        assert.ok(!JSON.stringify(out).includes(SUMMARY), "the stale summary is gone");
+        const sent = signaturesIn(out);
+        for (const n of [7, 8, 9]) for (const p of ["a", "b"]) assert.ok(sent.includes(sig(n, p)), `thinking ${n}${p} is sent again`);
+    } finally {
+        await h.close();
+    }
+});
+
+test("after a Claude Code compact, new thinking blocks are not taken for old folded ones", async () => {
+    const { h, history } = await foldedSession("thinking-id-compact");
+    try {
+        const refsBefore = refsIn(h.bodies.flat());
+        const compacted = compactedHistory([7, 8, 9]);
+        assert.ok(history.length > compacted.length, "the compact shortened the history");
+        const before = h.bodies.length;
+        await h.send(compacted);
+        const out = h.bodies[before]!;
+        assert.deepEqual(h.violations[before], [], "legal on the wire");
+        const sent = signaturesIn(out);
+        for (const n of [7, 8, 9]) for (const p of ["a", "b"]) assert.ok(sent.includes(sig(n, p)), `new thinking ${n}${p} is sent, not taken for a folded one`);
+        assert.ok(!JSON.stringify(out).includes(SUMMARY), "the summary of compacted-away turns is not put back into the context");
+        const reused = refsIn(out).filter((r) => r <= Math.max(...refsBefore));
+        assert.deepEqual(reused, [], "new messages get new refs; old numbers are never reused");
+    } finally {
+        await h.close();
+    }
+});