@zhushanwen/pi-smart-context 0.3.2 → 0.3.3

package/README.md

@@ -8,10 +8,10 @@
 - **双模式生成接管**（`session_before_compact`，覆盖工具 / `/compact` / 内建 auto 三条路径）：
   - same-model：完整原始上下文 + 会话原 system prompt + tools + 末尾追加压缩指令——前缀缓存全命中，成本≈增量指令+输出，且模型看全量上下文（质量上限最高）
   - cross-model：调用 pi 原生 `compact()` 仅换模型与凭证——split-turn / fileOps / previousSummary 原生组装
-- **3 档阈值提醒**（默认 400K/500K/600K）：`agent_settled` 越档检查，每档一次、多档合并、压缩后重置，followUp 投递；措辞是数据投递不是指令
+- **3 档阈值提醒**（默认 400K/500K/600K）：`agent_settled` 越档检查，每档一次、多档合并、压缩后重置。投递是**静默注入**（`pi.sendMessage` custom message + `triggerTurn:false` + `display:false`）——只进 LLM 上下文，不触发新 turn、不进对话流，用户继续对话时模型在下一轮自然看到；已提醒档位经 `pi.appendEntry` 落在 session entries（`smart-context:fired`），reload / 进程重启后从 entries 重建，同一档不会重复提醒。提醒文案两行以内，措辞是数据投递不是指令
 - **排除模型**（精准 `provider/modelId` 匹配）：工具拒绝 + 不提醒 + 回落 pi 原生生成；切换跨界时注入一条可用性通知，downshift（切小窗模型将触线）时建议先压缩
-- **健壮性**：摘要收缩校验、max-tokens 截断 fail-closed、接管失败 3 次熔断、transcript 回查指针、压缩后最近文件内容重注入（≤5 文件/50K）、多轮压缩降智提示
-- **subagent 进程**自动静默（`PI_SUBAGENT_ROOT_SESSION_ID` 标记）
+- **健壮性**：摘要收缩校验、max-tokens 截断 fail-closed、接管失败 3 次熔断（本 session 内停止接管）、transcript 回查指针、压缩后最近文件内容重注入（≤5 文件/50K）、多轮压缩降智提示（累计压缩 ≥2 次后附加）
+- **subagent 进程**自动静默（`TAIJI_AGENT_SUBAGENT` 标记）
 
 ## 行为门控
 
@@ -23,7 +23,13 @@
 | compactModel 未配置/无效 | 放行（same-model 不依赖该配置） | 生效 | same-model 生效；cross-model 回退当前模型，压缩不失败 |
 | 模型切换跨界（model_select） | 常驻不变 | 注入一条可用性变化通知（仅跨界时） | 按新模型即时重判 |
 
-行为正确性由 execute / handler 现场校验兜底，每次事件回调重新读配置（热加载，改完下一 turn 生效，无需重启）。
+行为正确性由 execute / handler 现场校验兜底，每次事件回调重新读配置（热加载，改完下一次压缩 / 提醒 / 工具调用即生效，无需重启）。
+
+## 安装
+
+```bash
+pi install npm:@zhushanwen/pi-smart-context
+```
 
 ## 配置
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-smart-context",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
   "main": "index.ts",
   "taiji": {
@@ -38,7 +38,7 @@
   "dependencies": {
     "@zhushanwen/pi-ext-guards": "0.4.1",
     "@zhushanwen/pi-extension-logger": "0.6.1",
-    "@zhushanwen/pi-llm-shared": "0.8.1"
+    "@zhushanwen/pi-llm-shared": "0.9.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.1.9",

package/skills/smart-context-ext-config/SKILL.md

@@ -9,7 +9,7 @@ description: "配置 @zhushanwen/pi-smart-context（智能上下文压缩：agen
 
 - `compact_context` 工具：agent 在「任务阶段性完成 && 压缩不影响后续 && 上下文超阈值」时自决调用
 - 双模式摘要生成：压缩模型 = 当前模型 → same-model 模式（KV 缓存命中，成本最低质量最高）；不同 → cross-model 模式（廉价模型 + 最小输入）
-- 3 档阈值提醒：越过档位时 agent 收到一次性提示（自行判断，不强制）
+- 3 档阈值提醒：越过档位时 agent 收到一次性提示（自行判断，不强制）。投递为静默注入——只进下一轮 LLM 上下文，不触发新 turn、不进对话流；同一档位不会重复提醒（已提醒档位随 session 持久化，reload / 重启后不丢）
 - 排除模型：命中列表的会话模型整体关闭本功能（回落 pi 原生压缩）
 - pi 内建自动压缩的触发线保留为最后防线，其压缩执行也走本扩展逻辑
 

package/src/__tests__/index-generation.test.ts

@@ -38,7 +38,7 @@ vi.mock("../tool.js", () => ({
 
 import smartContextExtension from "../index.js";
 
-/** 最小 fake pi：装配路径只消费 on（事件接线）；registerTool/sendUserMessage 兜底。 */
+/** 最小 fake pi：装配路径只消费 on（事件接线）；registerTool/sendMessage 兜底。 */
 function createMockPi(): {
 	pi: ExtensionAPI
 	events: Map<string, (...args: unknown[]) => void>
@@ -47,7 +47,7 @@ function createMockPi(): {
 	const pi = {
 		registerTool: vi.fn(),
 		on: (event: string, handler: (...args: unknown[]) => void) => events.set(event, handler),
-		sendUserMessage: vi.fn(),
+		sendMessage: vi.fn(),
 	} as unknown as ExtensionAPI;
 	return { pi, events };
 }

package/src/__tests__/index-reminder-delivery.test.ts

@@ -0,0 +1,227 @@
+// src/__tests__/index-reminder-delivery.test.ts
+//
+// D4' + D15 装配回归：越档提醒的「静默注入 + 档位持久化」两条语义在 index.ts 装配点成立。
+//
+// 现场（2026-09-19 会话 01a0b8b3）：taiji skill-reload 发 `/__taiji_reload__` → pi ctx.reload()
+// 重跑 extension factory（jiti moduleCache:false 重新 import）→ firedThresholds 归零，且 reload
+// 补发的 session_start reason 是 `startup`（区分不了重载与新会话）→ 同一档被提醒两次；同时
+// sendUserMessage(followUp) 恒触发一轮（pi 语义），用户收工后仍被唤醒烧掉一整轮全量上下文。
+//
+// 本文件锁两件事：
+//   ① 投递形态 = sendMessage({customType, display:false}, {triggerTurn:false})，且不再用 sendUserMessage；
+//   ② fired 档位写入 session entries（appendEntry marker），工厂重跑（reload 等价拓扑）后
+//      从 entries 重建 → 同档不重复、跨档照常提醒。
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { loggerMock } = vi.hoisted(() => ({
+	loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("@zhushanwen/pi-extension-logger", () => ({
+	getLogger: () => loggerMock,
+	createLogger: () => loggerMock,
+	setPiHandle: vi.fn(),
+}));
+
+// 工具注册短路（本文件只测提醒链路装配；compact 工具装配由 index-generation.test.ts 覆盖）
+vi.mock("../tool.js", () => ({
+	registerCompactContextTool: vi.fn(),
+}));
+
+// 配置冻结：loadSmartContextConfig 走 llm-shared loadConfig（读真实 agentDir 磁盘文件），
+// 测试必须确定（不随本机 ~/.taiji 配置漂移）→ 只覆写该函数，pure.js 其余纯函数保持实装。
+const TEST_CONFIG = {
+	enabled: true,
+	compactModel: { type: "ref" as const, ref: "" },
+	reminderThresholds: [200_000, 400_000, 600_000],
+	excludedModels: [] as string[],
+};
+vi.mock("../pure.js", async (importOriginal) => ({
+	...(await importOriginal<typeof import("../pure.js")>()),
+	loadSmartContextConfig: () => structuredClone(TEST_CONFIG),
+}));
+
+import { FIRED_ENTRY_CUSTOM_TYPE, THRESHOLD_REMINDER_CUSTOM_TYPE } from "../pure.js";
+import smartContextExtension from "../index.js";
+
+interface MockPi {
+	pi: ExtensionAPI
+	events: Map<string, (...args: unknown[]) => void>
+	sendMessage: ReturnType<typeof vi.fn>
+	sendUserMessage: ReturnType<typeof vi.fn>
+	appendEntry: ReturnType<typeof vi.fn>
+}
+
+/** 最小 fake pi：本文件消费 on / sendMessage / sendUserMessage / appendEntry。 */
+function createMockPi(): MockPi {
+	const events = new Map<string, (...args: unknown[]) => void>();
+	const sendMessage = vi.fn();
+	const sendUserMessage = vi.fn();
+	const appendEntry = vi.fn();
+	const pi = {
+		registerTool: vi.fn(),
+		on: (event: string, handler: (...args: unknown[]) => void) => events.set(event, handler),
+		sendMessage,
+		sendUserMessage,
+		appendEntry,
+	} as unknown as ExtensionAPI;
+	return { pi, events, sendMessage, sendUserMessage, appendEntry };
+}
+
+/** 最小 fake ctx：提醒链路只消费 model / getContextUsage / sessionManager.getEntries。 */
+function makeCtx(tokens: number, entries: ReadonlyArray<unknown> = []): ExtensionContext {
+	return {
+		model: { provider: "zai", id: "glm" },
+		getContextUsage: () => ({ tokens, contextWindow: 1_000_000 }),
+		sessionManager: { getEntries: () => entries, getSessionId: () => "s1" },
+	} as unknown as ExtensionContext;
+}
+
+/** fired marker entry 的持久形态（与 index.ts 写入口径一致）。 */
+function markerEntry(tiers: number[], tokens: number) {
+	return { type: "custom", customType: FIRED_ENTRY_CUSTOM_TYPE, data: { tiers, tokens } };
+}
+
+/** 触发 agent_settled（提醒唯一触发点）。 */
+function settle(pi: MockPi, ctx: ExtensionContext): void {
+	pi.events.get("agent_settled")!({ type: "agent_settled" }, ctx);
+}
+
+/** 触发 session_start（factory 重跑后的状态装配点）。 */
+function fireSessionStart(pi: MockPi, ctx: ExtensionContext): void {
+	pi.events.get("session_start")!({ type: "session_start", reason: "startup" }, ctx);
+}
+
+describe("D4': 越档提醒静默注入（不触发 turn、不进对话流）", () => {
+	it("命中档位 → sendMessage(customType, display:false) + {triggerTurn:false}；不再 sendUserMessage", () => {
+		const mock = createMockPi();
+		smartContextExtension(mock.pi);
+		fireSessionStart(mock, makeCtx(0));
+		settle(mock, makeCtx(250_000));
+
+		expect(mock.sendUserMessage).not.toHaveBeenCalled();
+		expect(mock.sendMessage).toHaveBeenCalledTimes(1);
+		const [message, options] = mock.sendMessage.mock.calls[0]!;
+		expect(message).toMatchObject({ customType: THRESHOLD_REMINDER_CUSTOM_TYPE, display: false });
+		expect(String(message.content)).toContain("[smart-context]");
+		expect(options).toEqual({ triggerTurn: false });
+	});
+
+	it("命中档位 → 先写 fired marker（session entries 持久化）", () => {
+		const mock = createMockPi();
+		smartContextExtension(mock.pi);
+		fireSessionStart(mock, makeCtx(0));
+		settle(mock, makeCtx(250_000));
+
+		expect(mock.appendEntry).toHaveBeenCalledTimes(1);
+		expect(mock.appendEntry.mock.calls[0]![0]).toBe(FIRED_ENTRY_CUSTOM_TYPE);
+		expect(mock.appendEntry.mock.calls[0]![1]).toEqual({ tiers: [200_000], tokens: 250_000 });
+	});
+
+	it("未达首档 → 不投递不写 marker", () => {
+		const mock = createMockPi();
+		smartContextExtension(mock.pi);
+		fireSessionStart(mock, makeCtx(0));
+		settle(mock, makeCtx(150_000));
+
+		expect(mock.sendMessage).not.toHaveBeenCalled();
+		expect(mock.appendEntry).not.toHaveBeenCalled();
+	});
+
+	it("同档二次 settle 不重复投递；跨下一档只带新增档位", () => {
+		const mock = createMockPi();
+		smartContextExtension(mock.pi);
+		fireSessionStart(mock, makeCtx(0));
+
+		settle(mock, makeCtx(250_000));
+		settle(mock, makeCtx(260_000)); // 同档 → 静默
+		expect(mock.sendMessage).toHaveBeenCalledTimes(1);
+
+		settle(mock, makeCtx(450_000)); // 跨 400K → 只报新档
+		expect(mock.sendMessage).toHaveBeenCalledTimes(2);
+		expect(mock.appendEntry.mock.calls[1]![1]).toEqual({ tiers: [400_000], tokens: 450_000 });
+	});
+});
+
+describe("D15: 档位持久化跨 factory 重跑（reload 等价拓扑）", () => {
+	it("marker 已在 entries → 新实例同档不重复提醒，跨下一档仍提醒", () => {
+		// 第一代：命中 200K 档并落 marker
+		const first = createMockPi();
+		smartContextExtension(first.pi);
+		fireSessionStart(first, makeCtx(0));
+		settle(first, makeCtx(250_000));
+		expect(first.sendMessage).toHaveBeenCalledTimes(1);
+
+		// 第二代（reload 等价：factory 重跑 + 新模块态 + session_start）——entries 里带着 marker
+		const entries = [markerEntry([200_000], 250_000)];
+		const second = createMockPi();
+		smartContextExtension(second.pi);
+		fireSessionStart(second, makeCtx(250_000, entries));
+
+		settle(second, makeCtx(255_000, entries)); // 同档 → 不重复
+		expect(second.sendMessage).not.toHaveBeenCalled();
+		expect(second.appendEntry).not.toHaveBeenCalled();
+
+		settle(second, makeCtx(450_000, entries)); // 跨 400K → 照常提醒
+		expect(second.sendMessage).toHaveBeenCalledTimes(1);
+		expect(second.appendEntry.mock.calls[0]![1]).toEqual({ tiers: [400_000], tokens: 450_000 });
+	});
+
+	it("session_start 未送达新实例时，首次 settle 兜底 seed（reload 先 settle 后 start 的窗口）", () => {
+		const entries = [markerEntry([200_000, 400_000], 450_000)];
+		const mock = createMockPi();
+		smartContextExtension(mock.pi); // 只重跑 factory，不 fire session_start
+		settle(mock, makeCtx(460_000, entries));
+
+		expect(mock.sendMessage).not.toHaveBeenCalled();
+	});
+
+	it("compaction entry 之后档位重置（同档再次提醒）", () => {
+		const entries = [markerEntry([200_000], 250_000), { type: "compaction" }];
+		const mock = createMockPi();
+		smartContextExtension(mock.pi);
+		fireSessionStart(mock, makeCtx(0, entries));
+		settle(mock, makeCtx(250_000, entries));
+
+		expect(mock.sendMessage).toHaveBeenCalledTimes(1);
+		expect(mock.appendEntry.mock.calls[0]![1]).toEqual({ tiers: [200_000], tokens: 250_000 });
+	});
+
+	it("session_compact 事件清空内存档位（D3 既有契约不回退）", () => {
+		const mock = createMockPi();
+		smartContextExtension(mock.pi);
+		fireSessionStart(mock, makeCtx(0));
+		settle(mock, makeCtx(250_000));
+		expect(mock.sendMessage).toHaveBeenCalledTimes(1);
+
+		mock.events.get("session_compact")!({ type: "session_compact" }, makeCtx(250_000));
+		settle(mock, makeCtx(255_000));
+		expect(mock.sendMessage).toHaveBeenCalledTimes(2);
+	});
+});
+
+describe("D15: entries 读取异常降级（不阻断提醒链路）", () => {
+	beforeEach(() => {
+		loggerMock.debug.mockClear();
+	});
+
+	it("getEntries 抛错 → seed 降级为空集，提醒照常投递", () => {
+		const mock = createMockPi();
+		smartContextExtension(mock.pi);
+		const brokenCtx = {
+			model: { provider: "zai", id: "glm" },
+			getContextUsage: () => ({ tokens: 250_000, contextWindow: 1_000_000 }),
+			sessionManager: {
+				getEntries: () => {
+					throw new Error("boom");
+				},
+			},
+		} as unknown as ExtensionContext;
+
+		fireSessionStart(mock, brokenCtx);
+		settle(mock, brokenCtx);
+
+		expect(mock.sendMessage).toHaveBeenCalledTimes(1);
+	});
+});

package/src/__tests__/pure.test.ts

@@ -2,9 +2,11 @@ import { describe, expect, it } from "vitest";
 
 import {
 	DEFAULT_SMART_CONTEXT_CONFIG,
+	FIRED_ENTRY_CUSTOM_TYPE,
 	buildReinjectSection,
 	checkToolThresholdGuard,
 	computeFileListsLike,
+	deriveFiredThresholds,
 	estimateShadowedTokens,
 	estimateTextTokens,
 	findCrossedThresholds,
@@ -136,6 +138,51 @@ describe("摘要后处理纯函数（D11/D13）", () => {
 	});
 });
 
+describe("deriveFiredThresholds（D15：session entries → 已提醒档位）", () => {
+	const marker = (tiers: unknown, extra?: Record<string, unknown>) => ({
+		type: "custom",
+		customType: FIRED_ENTRY_CUSTOM_TYPE,
+		data: { tiers, tokens: 1, ...extra },
+	});
+
+	it("累加 marker 的 tiers（跨多条 marker）", () => {
+		const fired = deriveFiredThresholds([marker([200_000]), { type: "message" }, marker([400_000])]);
+		expect([...fired].sort((a, b) => a - b)).toEqual([200_000, 400_000]);
+	});
+
+	it("compaction entry 清空此前 marker（压缩后档位重置，D3）", () => {
+		const fired = deriveFiredThresholds([marker([200_000]), { type: "compaction" }]);
+		expect(fired.size).toBe(0);
+	});
+
+	it("compaction 之后的新 marker 重新生效（压缩后再跨档仍会提醒）", () => {
+		const fired = deriveFiredThresholds([marker([200_000]), { type: "compaction" }, marker([200_000])]);
+		expect([...fired]).toEqual([200_000]);
+	});
+
+	it("只认本扩展的 marker：其他 custom entry / custom_message 不参与", () => {
+		const fired = deriveFiredThresholds([
+			{ type: "custom", customType: "goal-state", data: { tiers: [200_000] } },
+			{ type: "custom_message", customType: FIRED_ENTRY_CUSTOM_TYPE, data: { tiers: [200_000] } },
+		]);
+		expect(fired.size).toBe(0);
+	});
+
+	it("畸形态逐条降级：data 非对象 / tiers 非数组 / 元素非数字", () => {
+		const fired = deriveFiredThresholds([
+			{ type: "custom", customType: FIRED_ENTRY_CUSTOM_TYPE },
+			{ type: "custom", customType: FIRED_ENTRY_CUSTOM_TYPE, data: "x" },
+			{ type: "custom", customType: FIRED_ENTRY_CUSTOM_TYPE, data: { tiers: "x" } },
+			{ type: "custom", customType: FIRED_ENTRY_CUSTOM_TYPE, data: { tiers: [200_000, "x", null, Number.NaN] } },
+		]);
+		expect([...fired]).toEqual([200_000]);
+	});
+
+	it("空 entries → 空集", () => {
+		expect(deriveFiredThresholds([]).size).toBe(0);
+	});
+});
+
 describe("estimateShadowedTokens 口径契约（D2：与 pi estimateTokens 同源）", () => {
 	// 合法 AssistantMessage 形状的 fixture（block 数组 content，禁止 as 硬塞 string content——
 	// estimateTokens 对 string content 计 0，口径用例会静默失去判别力；设计 §8.3）。

package/src/__tests__/reminder.test.ts

@@ -9,14 +9,18 @@ import {
 import { buildSameModelInstruction, buildTranscriptPointer, CHECKPOINT_PREAMBLE } from "../prompts.js";
 
 describe("buildThresholdReminder（D3/D4：数据投递不强制）", () => {
-	it("含用量数据、档位、三条件自查清单、可忽略出口", () => {
+	it("含用量数据、档位、三条件自查、可忽略出口，且固定两行（D4' 短文约束）", () => {
 		const msg = buildThresholdReminder([200_000], 215_000, 1_000_000, 0);
 		expect(msg).toContain("215K / 1000K");
 		expect(msg).toContain("21.5%");
 		expect(msg).toContain("200K");
 		expect(msg).toContain("compact_context");
-		expect(msg).toContain("1. 当前任务的一个阶段已完成");
+		// 三条件压缩进一行序号列表，语义不减
+		expect(msg).toContain("①当前任务的一个阶段已完成并验证");
+		expect(msg).toContain("②后续工作不再依赖将被压缩的早期细节");
+		expect(msg).toContain("③上下文已超阈值");
 		expect(msg).toContain("忽略本提示继续工作");
+		expect(msg.split("\n")).toHaveLength(2);
 	});
 
 	it("多档合并为一条消息", () => {
@@ -29,6 +33,7 @@ describe("buildThresholdReminder（D3/D4：数据投递不强制）", () => {
 		const with_ = buildThresholdReminder([200_000], 215_000, 1_000_000, 2);
 		expect(without).not.toContain("compacted multiple times");
 		expect(with_).toContain("compacted multiple times");
+		expect(with_.split("\n")).toHaveLength(3);
 	});
 });
 

package/src/__tests__/tool.test.ts

@@ -9,7 +9,7 @@ vi.mock("../pure.js", async (importOriginal) => {
 	};
 });
 
-import { DEFAULT_SMART_CONTEXT_CONFIG, loadSmartContextConfig } from "../pure.js";
+import { DEFAULT_SMART_CONTEXT_CONFIG, COMPACT_RESULT_CUSTOM_TYPE, loadSmartContextConfig } from "../pure.js";
 import { registerCompactContextTool } from "../tool.js";
 import { countCompactions } from "../pure.js";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -26,12 +26,12 @@ type CompactOpts = {
 	onError: (e: Error) => void;
 };
 
-function makePi(): { pi: ExtensionAPI & { sendUserMessage: ReturnType<typeof vi.fn> }; tools: RegisteredTool[] } {
+function makePi(): { pi: ExtensionAPI & { sendMessage: ReturnType<typeof vi.fn> }; tools: RegisteredTool[] } {
 	const tools: RegisteredTool[] = [];
 	const pi = {
 		registerTool: (t: RegisteredTool) => tools.push(t),
-		sendUserMessage: vi.fn(),
-	} as unknown as ExtensionAPI & { sendUserMessage: ReturnType<typeof vi.fn> };
+		sendMessage: vi.fn(),
+	} as unknown as ExtensionAPI & { sendMessage: ReturnType<typeof vi.fn> };
 	return { pi, tools };
 }
 
@@ -94,18 +94,20 @@ describe("compact_context 工具（R2 降级态：fire-and-forget + 结果注入
 		expect(result.details).toMatchObject({ mode: "same-model", launched: true, fellBack: false, compactionCount: 1 });
 	});
 
-	it("onComplete 兑现后 sendUserMessage 注入结果（含模式/前后 tokens/成本；降智提示按次数）", async () => {
+	it("onComplete 兑现后 sendMessage custom message 注入结果（customType/display/triggerTurn 三要素；模式/前后 tokens/成本；降智提示按次数）", async () => {
 		const { pi, tools } = makePi();
 		registerCompactContextTool(pi, { getEntries: () => [{ type: "compaction" }, { type: "compaction" }] });
 		await tools[0].execute("t1", {}, undefined, undefined, makeCtx());
-		expect(pi.sendUserMessage).toHaveBeenCalledTimes(1);
-		const [message, options] = pi.sendUserMessage.mock.calls[0];
-		expect(message).toContain("压缩完成");
-		expect(message).toContain("same-model");
-		expect(message).toContain("500K");
-		expect(message).toContain("24K");
-		expect(message).toContain("compacted multiple times");
-		expect(options).toEqual({ deliverAs: "steer" });
+		expect(pi.sendMessage).toHaveBeenCalledTimes(1);
+		const [message, options] = pi.sendMessage.mock.calls[0]!;
+		expect(message).toMatchObject({ customType: COMPACT_RESULT_CUSTOM_TYPE, display: true });
+		expect(String(message.content)).toContain("压缩完成");
+		expect(String(message.content)).toContain("same-model");
+		expect(String(message.content)).toContain("500K");
+		expect(String(message.content)).toContain("24K");
+		expect(String(message.content)).toContain("compacted multiple times");
+		// A6 投递时机：triggerTurn:true 唤醒轮次消费压缩结果（streaming 时 pi 缺省走 steer 队列）
+		expect(options).toEqual({ triggerTurn: true });
 	});
 
 	it("onComplete 无 engine 标记 → 注入消息含回退说明与修复指引（D7）", async () => {
@@ -113,17 +115,21 @@ describe("compact_context 工具（R2 降级态：fire-and-forget + 结果注入
 		registerCompactContextTool(pi);
 		const ctx = makeCtx((options) => options.onComplete({ tokensBefore: 1, estimatedTokensAfter: 1 }));
 		await tools[0].execute("t1", {}, undefined, undefined, ctx);
-		expect(pi.sendUserMessage).toHaveBeenCalledTimes(1);
-		expect(pi.sendUserMessage.mock.calls[0][0]).toContain("回退");
+		expect(pi.sendMessage).toHaveBeenCalledTimes(1);
+		expect(String(pi.sendMessage.mock.calls[0]![0].content)).toContain("回退");
 	});
 
-	it("onError → 注入失败消息带重试指引", async () => {
+	it("onError → 注入失败消息带重试指引（display:true 失败必须用户可见 + triggerTurn:true）", async () => {
 		const { pi, tools } = makePi();
 		registerCompactContextTool(pi);
 		const ctx = makeCtx((options) => options.onError(new Error("Nothing to compact")));
 		await tools[0].execute("t1", {}, undefined, undefined, ctx);
-		expect(pi.sendUserMessage.mock.calls[0][0]).toContain("压缩失败");
-		expect(pi.sendUserMessage.mock.calls[0][0]).toContain("Nothing to compact");
+		expect(pi.sendMessage).toHaveBeenCalledTimes(1);
+		const [message, options] = pi.sendMessage.mock.calls[0]!;
+		expect(message).toMatchObject({ customType: COMPACT_RESULT_CUSTOM_TYPE, display: true });
+		expect(String(message.content)).toContain("压缩失败");
+		expect(String(message.content)).toContain("Nothing to compact");
+		expect(options).toEqual({ triggerTurn: true });
 	});
 
 	it("custom_instructions 透传给 ctx.compact", async () => {

package/src/index.ts

@@ -1,11 +1,12 @@
 /**
  * @zhushanwen/pi-smart-context 入口：事件接线 + 门控。
  *
- * - session_start：session 级闭包状态重建（规范 Session 隔离：fired 档位/熔断计数不跨 session）
+ * - session_start：session 级闭包状态重建（规范 Session 隔离：熔断计数不跨 session）
+ *   + fired 档位从 session entries 重建（D15：reload/进程重启同 session 不重复提醒）
  * - subagent 进程（R6）：不注册工具、不提醒（宁缺勿污）
  * - session_before_compact：双模式接管（compact-handler）
  * - session_compact：重置提醒 fired（D3）
- * - agent_settled：越档检查 + followUp 投递一次性提醒（D3/D4）
+ * - agent_settled：越档检查 + marker 持久化 + 静默注入（D3/D4/D15）
  * - model_select：跨界通知 + downshift 提醒（D5）
  */
 
@@ -23,10 +24,15 @@ import { buildDownshiftNotice, buildSwitchNotice, buildThresholdReminder } from
 import { registerCompactContextTool } from "./tool.js";
 import {
 	countCompactions,
+	deriveFiredThresholds,
 	findCrossedThresholds,
+	FIRED_ENTRY_CUSTOM_TYPE,
 	getCurrentModelId,
 	isGatingActive,
 	loadSmartContextConfig,
+	SWITCH_NOTICE_CUSTOM_TYPE,
+	DOWNSHIFT_NOTICE_CUSTOM_TYPE,
+	THRESHOLD_REMINDER_CUSTOM_TYPE,
 	type EntryLike,
 } from "./pure.js";
 
@@ -35,11 +41,13 @@ interface SessionState {
 	takeover: TakeoverState;
 	/** 已提醒档位（token 值为键；session_compact 清空，D3）。 */
 	firedThresholds: Set<number>;
+	/** fired 是否已从 session entries seed 过（D15：每次状态重建恰好 seed 一次）。 */
+	firedSeeded: boolean;
 }
 
 /** session 级状态唯一构造点（初始态与 session_start 重建同源，新增字段不落两处）。 */
 function createSessionState(): SessionState {
-	return { takeover: createTakeoverState(), firedThresholds: new Set() };
+	return { takeover: createTakeoverState(), firedThresholds: new Set(), firedSeeded: false };
 }
 
 // G1 代际检测（crash-resilience D1，同 scheduler/src/index.ts 的模块级代数计数器范式）：
@@ -76,12 +84,51 @@ export default function smartContextExtension(pi: ExtensionAPI): void {
 	// pi 错误文案。首个 session_start 前无 session，恒 false 为安全默认。
 	let isCtxStale: () => boolean = () => false;
 
-	pi.on("session_start", (_event: unknown, _ctx: ExtensionContext) => {
+	/**
+	 * fired 档位 seed（D15）：从 session entries 重建已提醒档位。
+	 *
+	 * reload 会重跑 factory（+ jiti 重新 import）清零闭包/模块态，且 pi 发的 session_start
+	 * reason 是 `startup`（见 pure.ts FIRED_ENTRY_CUSTOM_TYPE 注释）——只能从 session 自身
+	 * 的 marker entry 恢复。`firedSeeded` 保证每次状态重建只 seed 一次（settle 热路径不重复扫 entries）。
+	 *
+	 * ctx 可能缺 sessionManager（测试 / 极早期窗口）→ 逐层降级为空集，不阻断提醒链路。
+	 */
+	const seedFiredThresholds = (ctx: ExtensionContext): void => {
+		if (state.firedSeeded) return;
+		state.firedSeeded = true;
+		try {
+			const entries = ctx.sessionManager.getEntries() as ReadonlyArray<EntryLike>;
+			state.firedThresholds = deriveFiredThresholds(entries);
+			if (state.firedThresholds.size > 0) {
+				debugLog(`fired thresholds restored from session entries: ${[...state.firedThresholds].join(",")}`);
+			}
+		} catch (error) {
+			// 恢复失败降级为空集（最坏结果 = 同档多提醒一次，不阻断主流程）
+			debugLog(`fired thresholds restore failed: ${toErrorMessage(error)}`);
+		}
+	};
+
+	/**
+	 * compaction 计数读取（D13-12 降智提示判据）：entries 读取异常 → 0。
+	 * 拆函数是为了不走同一条 try：提醒投递本身不依赖 entries（marker 写入 / 静默注入都能成），
+	 * 降智提示只是附加行——读失败不得把整条提醒一起拆掉。
+	 */
+	const readCompactionCount = (ctx: ExtensionContext): number => {
+		try {
+			return countCompactions(ctx.sessionManager.getEntries() as ReadonlyArray<EntryLike>);
+		} catch (error) {
+			debugLog(`compaction count read failed: ${toErrorMessage(error)}`);
+			return 0;
+		}
+	};
+
+	pi.on("session_start", (_event: unknown, ctx: ExtensionContext) => {
 		// 先递增模块级代数再装配：自此同模块环境内所有前代闭包的 isCtxStale 返回 true
 		sessionGeneration += 1;
 		const myGeneration = sessionGeneration;
 		isCtxStale = () => sessionGeneration !== myGeneration;
 		state = createSessionState();
+		seedFiredThresholds(ctx);
 	});
 
 	// ── 压缩生成接管（D1/D12）──
@@ -104,27 +151,45 @@ export default function smartContextExtension(pi: ExtensionAPI): void {
 	// 守卫的前置代际检查恒不生效。wrapper 每次调用读闭包当前绑定。
 	registerCompactContextTool(pi, { isCtxStale: () => isCtxStale() });
 
-	// ── 阈值提醒（D3/D4）：agent_settled 越档检查 + followUp 一次性投递 ──
+	// ── 阈值提醒（D3/D4/D4'）：agent_settled 越档检查 + 静默注入（不触发 turn） ──
 	pi.on("agent_settled", (_event, ctx) => {
 		const config = loadSmartContextConfig();
 		const modelId = getCurrentModelId(ctx.model);
 		if (!isGatingActive(config, modelId)) return;
 
+		// D15 兜底 seed：session_start 未送达本代实例（reload 后先 settle 后 start 的窗口）时补上
+		seedFiredThresholds(ctx);
+
 		const usage = ctx.getContextUsage();
 		if (!usage) return; // R7：tokens 可能 null（压缩后首响应前）——findCrossedThresholds 容错
 		const crossed = findCrossedThresholds(config.reminderThresholds, usage.tokens, state.firedThresholds);
 		if (crossed.length === 0) return;
 
 		for (const t of crossed) state.firedThresholds.add(t);
-		const compactionCount = countCompactions(ctx.sessionManager.getEntries() as ReadonlyArray<EntryLike>);
+		const compactionCount = readCompactionCount(ctx);
 		const message = buildThresholdReminder(crossed, usage.tokens ?? 0, usage.contextWindow, compactionCount);
 		debugLog(`reminder fired: tiers=${crossed.join(",")} tokens=${usage.tokens}`);
-		// D4：followUp（agent 空闲后投递并触发一个 turn，可立即决定压缩）；
-		// 防循环：crossed 全部已标记 fired，提醒触发的 settled 不会重复发。
+		// D15：marker 落 session entries（先写，fire-once 语义优先于投递）——下次
+		// reload/进程重启从这里重建 fired，同一档不再重复提醒。
+		guardStaleCtx(() => {
+			pi.appendEntry(FIRED_ENTRY_CUSTOM_TYPE, { tiers: crossed, tokens: usage.tokens ?? 0 });
+		}, {
+			isCtxStale,
+			label: "smart-context:fired-marker",
+			onStale: (error) => debugLog(`fired marker skipped (stale ctx): ${toErrorMessage(error)}`),
+		});
+		// D4'：静默注入——custom message + triggerTurn:false = 只进 LLM 上下文，不触发新 turn、
+		// 不进对话流（display:false）。不再用 sendUserMessage（pi 语义：user message 恒触发
+		// 一轮），避免用户已收工时被提醒强行唤醒烧一整轮全量上下文。
+		// 用户继续对话时，模型在下一轮自然看到本提醒并自行决定是否 compact。
+		// 防循环：crossed 全部已标记 fired，marker 也不会产生新 turn。
 		// 事件回调内直接调用捕获的 pi——session 替换窗口可能 stale（crash-resilience D1
 		// 普查接入点），守卫 stale 静默降级（不杀 pi 进程），非 stale 错误原样上抛。
 		guardStaleCtx(() => {
-			pi.sendUserMessage(message, { deliverAs: "followUp" });
+			pi.sendMessage(
+				{ customType: THRESHOLD_REMINDER_CUSTOM_TYPE, content: message, display: false },
+				{ triggerTurn: false },
+			);
 		}, {
 			isCtxStale,
 			label: "smart-context:threshold-reminder",
@@ -147,9 +212,14 @@ export default function smartContextExtension(pi: ExtensionAPI): void {
 		if (config.enabled && nowExcluded !== wasExcluded) {
 			const notice = buildSwitchNotice(nowExcluded ? "unavailable" : "available", modelId);
 			debugLog(`switch notice: ${nowExcluded ? "unavailable" : "available"} (${modelId})`);
+			// 状态通知（非紧急）：triggerTurn:false 不唤醒轮次——LLM 在下一轮自然看到并自行
+			// 调整（compact 工具 execute 有运行时门控校验兜底），不为通知烧一整轮全量上下文。
 			// session 替换窗口可能 stale（D1 普查接入点）——守卫 stale 静默降级
 			guardStaleCtx(() => {
-				pi.sendUserMessage(notice, { deliverAs: "steer" });
+				pi.sendMessage(
+					{ customType: SWITCH_NOTICE_CUSTOM_TYPE, content: notice, display: false },
+					{ triggerTurn: false },
+				);
 			}, {
 				isCtxStale,
 				label: "smart-context:switch-notice",
@@ -167,9 +237,13 @@ export default function smartContextExtension(pi: ExtensionAPI): void {
 		);
 		if (downshift && isGatingActive(config, modelId)) {
 			debugLog("downshift notice fired");
-			// session 替换窗口可能 stale（D1 普查接入点）——守卫 stale 静默降级
+			// "建议"非紧急（同 S1 裁决）：triggerTurn:false 不唤醒轮次，用户继续对话时
+			// LLM 自行决策是否先压缩。session 替换窗口可能 stale（D1 普查接入点）——守卫 stale 静默降级
 			guardStaleCtx(() => {
-				pi.sendUserMessage(downshift, { deliverAs: "steer" });
+				pi.sendMessage(
+					{ customType: DOWNSHIFT_NOTICE_CUSTOM_TYPE, content: downshift, display: false },
+					{ triggerTurn: false },
+				);
 			}, {
 				isCtxStale,
 				label: "smart-context:downshift-notice",

package/src/pure.ts

@@ -249,6 +249,10 @@ export function buildReinjectSection(contents: ReadonlyArray<{ path: string; con
 /** sessionManager entries 的宽松形状（降智计数）。 */
 export interface EntryLike {
 	type: string;
+	/** custom entry 的类型标识（deriveFiredThresholds 读 marker 用；非 custom entry 缺省）。 */
+	customType?: string;
+	/** custom entry 的载荷（同上；形状由写入方定义）。 */
+	data?: unknown;
 }
 
 /** 累计 compaction 次数（D13-12 判据）。 */
@@ -256,6 +260,65 @@ export function countCompactions(entries: ReadonlyArray<EntryLike>): number {
 	return entries.filter((e) => e.type === "compaction").length;
 }
 
+/**
+ * 已提醒档位 marker 的 custom entry 类型（session entries 持久化）。
+ *
+ * 为什么必须持久化：pi reload（taiji 的 skill reload 走 `/__taiji_reload__` → ctx.reload()）会
+ * 重建 extension runner 并**重新 import 扩展模块**（pi loader `moduleCache: false`）——闭包态与
+ * 模块级态一律归零；reload 随后补发的 `session_start` 的 reason 还是 `startup`（pi
+ * `_buildRuntime` → bindExtensions 发的是 `_sessionStartEvent` 默认值），用它区分不了
+ * 「真新 session」与「同 session 重载」。故 fired 档位以 custom entry 写入 session 自身，
+ * 每次重建从 entries 推导：同 session 的 reload / 进程重启 / 切回都不再重复提醒同一档。
+ */
+export const FIRED_ENTRY_CUSTOM_TYPE = "smart-context:fired";
+
+/** 越档提醒注入的 custom message 类型（静默通道：只进 LLM 上下文，不进对话流）。 */
+export const THRESHOLD_REMINDER_CUSTOM_TYPE = "smart-context:threshold-reminder";
+
+/** 模型跨界通知注入的 custom message 类型（静默通道：不触发 turn，LLM 下轮自然可见）。 */
+export const SWITCH_NOTICE_CUSTOM_TYPE = "smart-context:switch-notice";
+
+/** downshift 建议压缩注入的 custom message 类型（静默通道：不触发 turn，用户继续对话时 LLM 自行决策）。 */
+export const DOWNSHIFT_NOTICE_CUSTOM_TYPE = "smart-context:downshift-notice";
+
+/** compact 完成/失败注入的 custom message 类型（用户可见系统消息 + 唤醒一轮消费压缩结果）。 */
+export const COMPACT_RESULT_CUSTOM_TYPE = "smart-context:compact-result";
+
+/** fired marker 的载荷形状（写入方 index.ts 与本文件推导函数共用的唯一定义点）。 */
+export interface FiredMarkerData {
+	/** 本次标记已提醒的档位（token 值）。 */
+	tiers: number[];
+	/** 标记时刻的上下文用量（排查用，不参与语义）。 */
+	tokens: number;
+}
+
+/**
+ * 已提醒档位重建（D15：session entries → Set）。
+ *
+ * 语义与内存态一致：遇 `compaction` entry **清空**（压缩后档位重置，D3 既有契约），
+ * 其上方的 fired marker 累加 tiers。marker 载荷畸形（非对象 / tiers 非数组 / 元素非数）
+ * 逐条降级跳过——session JSONL 被截断或手改过时不抛错。
+ *
+ * 调用点：session_start（本代状态装配）+ agent_settled 首次使用前的兜底 seed
+ * （reload 后新模块实例可能先收到 settle 再收到 session_start）。
+ */
+export function deriveFiredThresholds(entries: ReadonlyArray<EntryLike>): Set<number> {
+	const fired = new Set<number>();
+	for (const entry of entries) {
+		if (entry.type === "compaction") {
+			fired.clear();
+			continue;
+		}
+		if (entry.type !== "custom" || entry.customType !== FIRED_ENTRY_CUSTOM_TYPE) continue;
+		const data = isRecord(entry.data) ? entry.data : undefined;
+		const tiers = Array.isArray(data?.tiers) ? data.tiers : [];
+		for (const tier of tiers) {
+			if (typeof tier === "number" && Number.isFinite(tier)) fired.add(tier);
+		}
+	}
+	return fired;
+}
+
 /**
  * 保留段已 Read 的文件集合（D13-11 去重：重注入跳过保留段已有的 Read 结果）。
  * 保留段 = branchEntries 中 firstKeptEntryId 之后的 message entries；从其 toolCall 参数提取 path。

package/src/reminder.ts

@@ -1,7 +1,8 @@
 /**
  * 提醒与通知文案构造（D3/D4/D5/D13-12）。
  *
- * 全部为纯函数：文案 + 越档判定。注入由 src/index.ts 用 pi.sendUserMessage 执行。
+ * 全部为纯函数：文案 + 越档判定。注入由 src/index.ts / src/tool.ts 用 pi.sendMessage
+ * custom message 执行。
  * 措辞原则（目标 3）：提醒是数据投递不是指令——给三条件自查清单 + 明确的"可忽略"出口，
  * 避免 agent 见提醒就压缩。
  */
@@ -17,8 +18,13 @@ const PERCENT_SCALE = 100;
 const PI_DEFAULT_RESERVE_TOKENS = 16_384;
 
 /**
- * 阈值提醒消息（D3/D4）：越档信息 + 用量数据 + 工具名 + 三条件自查 + 可忽略出口。
+ * 阈值提醒消息（D3/D4/D4'）：越档信息 + 工具名 + 三条件自查 + 可忽略出口。
  * 多档同时越过合并为一条（D3 去重规则）。
+ *
+ * D4' 短文约束：提醒是静默注入（不触发 turn、不进对话流），长度直接计入每次请求的
+ * 上下文——固定两行（降智提示另加一行），三条件压进一行序号列表，不再分点铺开。
+ * 语义不减：三条件、工具名、「可忽略」出口与「同档只提醒一次」全部保留（措辞仍是
+ * 数据投递不是指令——避免 agent 见提醒就压缩）。
  */
 export function buildThresholdReminder(
 	crossedThresholds: readonly number[],
@@ -31,17 +37,11 @@ export function buildThresholdReminder(
 		.map((t, index) => `${formatK(t)}（第 ${index + 1} 档）`)
 		.join("、");
 	const lines = [
-		`[smart-context 提示] 上下文当前 ${formatK(tokens)} / ${formatK(contextWindow)} tokens（${percent}%），已超过提醒阈值 ${tiers}。`,
-		``,
-		`compact_context 工具可用于压缩上下文。请自行判断是否现在压缩——仅当以下三个条件同时满足时才调用：`,
-		`1. 当前任务的一个阶段已完成并验证（如一批文件改完、测试通过）；`,
-		`2. 后续工作不再依赖将被压缩的早期细节；`,
-		`3. 上下文已超过阈值（本提示即第 3 条的数据依据）。`,
-		``,
-		`若任务仍在进行中、或近期仍需引用早期上下文，忽略本提示继续工作即可（本档位不会重复提醒，压缩后会重置）。`,
+		`[smart-context] 上下文 ${formatK(tokens)} / ${formatK(contextWindow)}（${percent}%），已越提醒阈值 ${tiers}。`,
+		`达阶段边界且后续不依赖早期细节时才调用 compact_context（三条件同时满足：①当前任务的一个阶段已完成并验证 ②后续工作不再依赖将被压缩的早期细节 ③上下文已超阈值）；否则忽略本提示继续工作（同档只提醒一次，压缩后重置）。`,
 	];
 	if (compactionCount >= DEGRADATION_HINT_MIN_COMPACTIONS) {
-		lines.push(``, buildDegradationHintLine());
+		lines.push(buildDegradationHintLine());
 	}
 	return lines.join("\n");
 }

package/src/tool.ts

@@ -5,7 +5,7 @@
  * （R2 实测 2026-08-22：tool execute 内 await ctx.compact() 不可行——AgentSession.compact
  * 开头的 abort() 会中止当前 agent 循环，挂起的 Promise 永不兑现、session 无 toolResult。
  * 故走 §3.2 降级态：execute 立即返回"压缩已启动"，onComplete/onError 后经
- * pi.sendUserMessage 注入结果消息——此时无进行中回合，abort 为 no-op）。
+ * pi.sendMessage custom message 注入结果——此时无进行中回合，abort 为 no-op）。
  * 压缩生成由 session_before_compact 接管 handler 完成（工具只触发，不生成）。
  */
 
@@ -18,6 +18,7 @@ import { buildDegradationHintLine } from "./reminder.js";
 import {
 	DEGRADATION_HINT_MIN_COMPACTIONS,
 	checkToolThresholdGuard,
+	COMPACT_RESULT_CUSTOM_TYPE,
 	countCompactions,
 	formatK,
 	getCurrentModelId,
@@ -160,8 +161,9 @@ export function registerCompactContextTool(
 			const compactionCount = countCompactions(getEntries(ctx));
 
 			// R2 降级态：fire-and-forget。工具立即返回"已启动"；压缩完成后（此时无进行中
-			// 回合，compact 内部的 abort 为 no-op）经 sendUserMessage 注入结果（steer：
-			// 下一个 LLM 调用前投递，agent 立即看到结果）
+			// 回合，compact 内部的 abort 为 no-op）经 sendMessage custom message 注入结果
+			// （triggerTurn:true 唤醒一轮让 agent 立即消费结果——工具已承诺"完成后你会收到
+			// 结果消息"；若此刻仍在 streaming，pi 缺省走 steer 队列，下一 LLM 调用前投递）
 			const mode = pickMode(config, gating.modelId);
 			ctx.compact({
 				customInstructions:
@@ -170,8 +172,10 @@ export function registerCompactContextTool(
 						: undefined,
 				// E1 实锤崩溃点（9/3 pi-crash log）：两个回调由 compact 的内部 Promise 链异步
 				// 调用，不在 pi runner emit() 的 try/catch 内——session 替换窗口（GUI 切
-				// session/新建/重载高频触发）下 pi.sendUserMessage 命中 stale ctx 同步抛错即
-				// 杀死 pi 进程。守卫 stale 静默降级（结果不投递，用户可重试 /compact），非
+				// session/新建/重载高频触发）下 pi.sendMessage 命中 stale ctx 同步抛错即
+				// 杀死 pi 进程（pi 0.84.4 实装：dist/core/extensions/loader.js 的 assertActive
+				// 214-219 wrapper → 142-146 staleMessage throw，在 runtime 调用前同步 throw）。
+				// 守卫 stale 静默降级（结果不投递，用户可重试 /compact），非
 				// stale 错误原样上抛（守卫不吞真实 bug）。
 				onComplete: (r: unknown) => {
 					guardStaleCtx(() => {
@@ -189,7 +193,12 @@ export function registerCompactContextTool(
 							`压缩前 ${formatK(result.tokensBefore ?? 0)} tokens → 压缩后约 ${formatK(result.estimatedTokensAfter ?? 0)} tokens；摘要生成成本：${cost}。`,
 							showHint ? buildDegradationHintLine() : "",
 						].filter((l) => l !== "");
-						pi.sendUserMessage(lines.join("\n"), { deliverAs: "steer" });
+						// display:true 进对话流（系统消息形态，非用户气泡）；对齐
+						// base-tool-enhance 完成通知先例（失败必须用户可见，不压 display:false）
+						pi.sendMessage(
+							{ customType: COMPACT_RESULT_CUSTOM_TYPE, content: lines.join("\n"), display: true },
+							{ triggerTurn: true },
+						);
 					}, {
 						isCtxStale: deps?.isCtxStale,
 						label: "smart-context:compact-onComplete",
@@ -200,9 +209,13 @@ export function registerCompactContextTool(
 					// 压缩本身的失败信息先落日志（守卫体外——stale 降级时该观测保留）
 					debugLog(`compact_context error: ${err.message}`);
 					guardStaleCtx(() => {
-						pi.sendUserMessage(
-							`[smart-context] 压缩失败：${err.message}。上下文未变化，可稍后重试（若反复失败，检查 smart-context 配置或使用 /compact）。`,
-							{ deliverAs: "steer" },
+						pi.sendMessage(
+							{
+								customType: COMPACT_RESULT_CUSTOM_TYPE,
+								content: `[smart-context] 压缩失败：${err.message}。上下文未变化，可稍后重试（若反复失败，检查 smart-context 配置或使用 /compact）。`,
+								display: true,
+							},
+							{ triggerTurn: true },
 						);
 					}, {
 						isCtxStale: deps?.isCtxStale,