@oyasmi/pipiclaw 0.4.0 → 0.5.1

package/README.md

@@ -11,7 +11,7 @@ npm package: [`@oyasmi/pipiclaw`](https://www.npmjs.com/package/@oyasmi/pipiclaw
 - 钉钉优先：原生支持 DingTalk Stream Mode，不需要自己再包一层消息桥
 - 过程可见：思考、工具执行和状态更新可以持续流式展示到 AI Card
 - 任务不中断：忙碌时支持 steer、follow-up 和 stop，而不是简单丢弃新消息
-- 有记忆，但不过载：`MEMORY.md` / `HISTORY.md` 分层管理，避免上下文无限膨胀
+- 有记忆，但不过载：`SESSION.md` / `MEMORY.md` / `HISTORY.md` 分层管理，避免上下文无限膨胀
 - 支持子代理：主代理可以把 review、research、planning 等任务委派给独立上下文的 sub-agent
 - 适合长期运行：每个私聊和群聊都有稳定的 channel workspace、日志和事件目录
 - 保持可编排：模型、技能、workspace 文件和事件都可以通过普通文件管理
@@ -22,7 +22,7 @@ npm package: [`@oyasmi/pipiclaw`](https://www.npmjs.com/package/@oyasmi/pipiclaw
 - 内置 slash commands：`/help`、`/new`、`/compact`、`/session`、`/model`
 - 忙碌时普通消息默认作为 steer 注入当前任务，也支持显式 `/steer`、`/followup`、`/stop`
 - workspace 级 `SOUL.md`、`AGENTS.md`、`MEMORY.md`
-- channel 级 `MEMORY.md`、`HISTORY.md`、`skills/`
+- channel 级 `SESSION.md`、`MEMORY.md`、`HISTORY.md`、`skills/`
 - 预定义 sub-agent 和临时 inline sub-agent
 - immediate / one-shot / periodic 事件调度
 - 自定义 provider / model 配置
@@ -228,6 +228,7 @@ Pipiclaw 的核心不是“一个机器人实例”，而是一组长期存在
     ├── skills/
     ├── sub-agents/
     ├── dm_{userId}/
+    │   ├── SESSION.md
     │   ├── MEMORY.md
     │   ├── HISTORY.md
     │   ├── .channel-meta.json
@@ -253,6 +254,7 @@ Pipiclaw 的核心不是“一个机器人实例”，而是一组长期存在
 默认不会直接注入上下文的内容：
 
 - `workspace/MEMORY.md`
+- `<channel>/SESSION.md`
 - `<channel>/MEMORY.md`
 - `<channel>/HISTORY.md`
 - `<channel>/log.jsonl`
@@ -260,23 +262,42 @@ Pipiclaw 的核心不是“一个机器人实例”，而是一组长期存在
 
 这意味着 Pipiclaw 的记忆策略是“按需读取”，而不是把所有历史永远塞进 prompt。
 
+不过，运行时现在会在当前轮明显需要时，自动从 `SESSION.md` / `MEMORY.md` / `HISTORY.md` 里挑出少量相关片段，作为一个很小的 runtime context 注入当前请求。这不是整文件预加载，而是受限的 relevant-memory prefetch。
+
 ## Memory Model
 
-Pipiclaw 把记忆分成三层：
+Pipiclaw 把记忆分成四层：
+
+- `<channel>/SESSION.md`
+  当前工作态。放现在正在做什么、最近卡点、下一步、活跃文件和短期约束。它是 runtime-managed working memory。
 
 - `workspace/MEMORY.md`
   稳定的全局背景，适合放团队长期约定和共享知识
 - `<channel>/MEMORY.md`
-  channel 级 durable facts、ongoing work、decisions、open loops
+  channel 级 durable facts、decisions、preferences、medium-horizon open loops
 - `<channel>/HISTORY.md`
   更老上下文的摘要历史
 
-运行时会在 compaction 或 session trimming 前自动做 consolidation：
+运行时行为分成两条线：
+
+- relevant recall
+  每轮可按需从 `SESSION.md` / `MEMORY.md` / `HISTORY.md` 里挑出少量最相关片段，预先送进当前 prompt
+- consolidation
+  在 compaction 或 session trimming 前刷新 `SESSION.md`，并把值得长期保留的内容沉淀到 `MEMORY.md` / `HISTORY.md`
+
+consolidation 会做这些事：
 
 - 从对话中提取值得保留的 memory entries
+- 更新 `SESSION.md` 中的当前工作态
 - 把旧对话块折叠进 `HISTORY.md`
 - 在必要时压缩过长的 memory/history 文件
 
+一个简单原则：
+
+- 现在正在做什么，看 `SESSION.md`
+- 稳定事实和决策，看 `MEMORY.md`
+- 更老的脉络和叙事，看 `HISTORY.md`
+
 ## Sub-Agents
 
 Pipiclaw 支持两种 sub-agent 用法：
@@ -296,6 +317,11 @@ name: reviewer
 description: Review code changes for correctness, regressions, and missing tests
 model: anthropic/claude-sonnet-4-5
 tools: read,bash
+contextMode: contextual
+memory: relevant
+paths:
+  - src/
+  - test/
 maxTurns: 24
 maxToolCalls: 48
 maxWallTimeSec: 300
@@ -314,6 +340,18 @@ Keep findings concise and actionable.
 - sub-agent 没有 `subagent` 工具，所以不能继续创建孙代理
 - sub-agent 隔离的是 LLM 对话上下文，不隔离文件系统
 - 运行摘要会记录到 `<channel>/subagent-runs.jsonl`
+- 如果后续启用 contextual sub-agent，runtime 还会把 relevant memory 和 `SESSION.md` 摘要按角色需要带给子代理，而不是只给它一个裸任务
+
+几个常用 frontmatter：
+
+- `contextMode: contextual`
+  让 runtime 在任务前自动注入受限的上下文块
+- `memory: session`
+  只带 `SESSION.md` 的关键工作态
+- `memory: relevant`
+  带 `SESSION.md` 关键工作态，再加少量从 `MEMORY.md` / `HISTORY.md` / workspace memory 里召回的相关片段
+- `paths`
+  给子代理一个明确的关注范围，既帮助它聚焦，也会参与 recall
 
 ## Scheduled Events
 

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,cAAc,EAAqB,MAAM,eAAe,CAAC;AAGvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAMrD,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAS/C,MAAM,WAAW,WAAW;IAC3B,GAAG,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvG,oBAAoB,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnF,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AA6zBD,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,CAOlH"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,cAAc,EAAqB,MAAM,eAAe,CAAC;AAGvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAQrD,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAS/C,MAAM,WAAW,WAAW;IAC3B,GAAG,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvG,oBAAoB,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnF,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAw+BD,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,CAOlH"}

package/dist/agent.js

@@ -7,7 +7,9 @@ import { renderBuiltInHelp } from "./commands.js";
 import { getAgentConfig, getApiKeyForModel, getSoul, loadPipiclawSkills } from "./config-loader.js";
 import { PipiclawSettingsManager } from "./context.js";
 import * as log from "./log.js";
+import { createMemoryCandidateCache } from "./memory-candidates.js";
 import { MemoryLifecycle } from "./memory-lifecycle.js";
+import { recallRelevantMemory } from "./memory-recall.js";
 import { resolveInitialModel } from "./model-utils.js";
 import { APP_HOME_DIR, AUTH_CONFIG_PATH, MODELS_CONFIG_PATH } from "./paths.js";
 import { buildAppendSystemPrompt } from "./prompt-builder.js";
@@ -37,12 +39,23 @@ function truncate(text, maxLen) {
         return text;
     return `${text.substring(0, maxLen - 3)}...`;
 }
+const MAX_USER_MESSAGE_CHARS = 12_000;
+const HAN_REGEX = /\p{Script=Han}/u;
 function sanitizeProgressText(text) {
     return text
         .replace(/\uFFFC/g, "")
         .replace(/\r/g, "")
         .trim();
 }
+function clipUserInput(text, maxChars) {
+    const normalized = text.replace(/\r/g, "").trim();
+    if (normalized.length <= maxChars) {
+        return normalized;
+    }
+    const headChars = Math.floor(maxChars * 0.6);
+    const tailChars = maxChars - headChars;
+    return `${normalized.slice(0, headChars)}\n\n[... omitted ${normalized.length - maxChars} chars ...]\n\n${normalized.slice(-tailChars)}`;
+}
 function formatProgressEntry(kind, text) {
     const cleaned = sanitizeProgressText(text);
     if (!cleaned)
@@ -139,6 +152,67 @@ function createEmptyRunState() {
         finalResponseDelivered: false,
     };
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isMessageWithRole(value) {
+    return isRecord(value) && typeof value.role === "string";
+}
+function isAssistantEventMessage(value) {
+    return (isMessageWithRole(value) && value.role === "assistant" && Array.isArray(value.content));
+}
+function isThinkingPart(part) {
+    return part.type === "thinking" && typeof part.thinking === "string";
+}
+function isTextPart(part) {
+    return part.type === "text" && typeof part.text === "string";
+}
+function extractLabelFromArgs(args) {
+    if (!isRecord(args)) {
+        return null;
+    }
+    return typeof args.label === "string" && args.label.trim() ? args.label.trim() : null;
+}
+function hasEventType(value, type) {
+    return isRecord(value) && value.type === type;
+}
+function isToolExecutionStartEvent(value) {
+    return (hasEventType(value, "tool_execution_start") &&
+        typeof value.toolCallId === "string" &&
+        typeof value.toolName === "string");
+}
+function isToolExecutionUpdateEvent(value) {
+    return (hasEventType(value, "tool_execution_update") &&
+        typeof value.toolCallId === "string" &&
+        typeof value.toolName === "string");
+}
+function isToolExecutionEndEvent(value) {
+    return (hasEventType(value, "tool_execution_end") &&
+        typeof value.toolCallId === "string" &&
+        typeof value.toolName === "string" &&
+        typeof value.isError === "boolean");
+}
+function isMessageStartEvent(value) {
+    return hasEventType(value, "message_start") && "message" in value;
+}
+function isMessageEndEvent(value) {
+    return hasEventType(value, "message_end") && "message" in value;
+}
+function isTurnEndEvent(value) {
+    return hasEventType(value, "turn_end") && "message" in value && Array.isArray(value.toolResults);
+}
+function isAutoCompactionStartEvent(value) {
+    return hasEventType(value, "auto_compaction_start") && (value.reason === "threshold" || value.reason === "overflow");
+}
+function isAutoCompactionEndEvent(value) {
+    return hasEventType(value, "auto_compaction_end");
+}
+function isAutoRetryStartEvent(value) {
+    return (hasEventType(value, "auto_retry_start") &&
+        typeof value.attempt === "number" &&
+        typeof value.maxAttempts === "number" &&
+        typeof value.errorMessage === "string");
+}
 // ============================================================================
 // ChannelRunner
 // ============================================================================
@@ -173,10 +247,12 @@ class ChannelRunner {
             getAvailableModels: () => this.modelRegistry.getAvailable(),
             resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
             workspaceDir: this.workspaceDir,
+            channelDir: this.channelDir,
             workspacePath: this.workspacePath,
             channelId: this.channelId,
             sandboxConfig: this.sandboxConfig,
             getSubAgentDiscovery: () => this.subAgentDiscovery,
+            getMemoryRecallSettings: () => this.settingsManager.getMemoryRecallSettings(),
         });
         // Create agent
         this.agent = new Agent({
@@ -196,6 +272,7 @@ class ChannelRunner {
             getSessionEntries: () => this.sessionManager.getBranch(),
             getModel: () => this.session.model ?? this.activeModel,
             resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
+            getSessionMemorySettings: () => this.settingsManager.getSessionMemorySettings(),
         });
         const resourceLoader = new DefaultResourceLoader({
             cwd: process.cwd(),
@@ -282,13 +359,39 @@ class ChannelRunner {
             await this.ensureSessionReady();
             // Ensure channel directory exists
             await mkdir(this.channelDir, { recursive: true });
-            const userMessage = this.formatUserMessage(ctx.message.text, ctx.message.userName);
-            const promptText = this.shouldPreserveRawInput(ctx.message.text) ? ctx.message.text.trim() : userMessage;
+            const candidateCache = createMemoryCandidateCache();
+            const clippedInput = clipUserInput(ctx.message.text, MAX_USER_MESSAGE_CHARS);
+            const userMessage = this.formatUserMessage(clippedInput, ctx.message.userName);
+            let promptText = this.shouldPreserveRawInput(ctx.message.text) ? clippedInput : userMessage;
+            let recalledContextText = "";
+            if (!this.shouldPreserveRawInput(ctx.message.text)) {
+                const recallSettings = this.settingsManager.getMemoryRecallSettings();
+                if (recallSettings.enabled) {
+                    const recall = await recallRelevantMemory({
+                        query: clippedInput,
+                        workspaceDir: this.workspaceDir,
+                        channelDir: this.channelDir,
+                        maxCandidates: recallSettings.maxCandidates,
+                        maxInjected: recallSettings.maxInjected,
+                        maxChars: recallSettings.maxChars,
+                        rerankWithModel: recallSettings.rerankWithModel,
+                        autoRerank: HAN_REGEX.test(clippedInput),
+                        model: this.session.model ?? this.activeModel,
+                        resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
+                        candidateCache,
+                    });
+                    if (recall.renderedText) {
+                        recalledContextText = recall.renderedText;
+                        promptText = `${recall.renderedText}\n\n<user_message>\n${promptText}\n</user_message>`;
+                    }
+                }
+            }
             // Debug: write context to last_prompt.json (only with PIPICLAW_DEBUG=1)
             if (process.env.PIPICLAW_DEBUG) {
                 const debugContext = {
                     systemPrompt: this.agent.state.systemPrompt,
                     messages: this.session.messages,
+                    recalledContext: recalledContextText || undefined,
                     newUserMessage: promptText,
                 };
                 await writeFile(join(this.channelDir, "last_prompt.json"), JSON.stringify(debugContext, null, 2));
@@ -429,7 +532,11 @@ class ChannelRunner {
         if (!this.session.isStreaming) {
             throw new Error("No task is currently running.");
         }
-        await this.session.prompt(this.formatUserMessage(text, userName), {
+        const clippedText = clipUserInput(text, MAX_USER_MESSAGE_CHARS);
+        if (clippedText !== text.trim()) {
+            log.logWarning(`[${this.channelId}] Queued message exceeded ${MAX_USER_MESSAGE_CHARS} chars and was clipped`);
+        }
+        await this.session.prompt(this.formatUserMessage(clippedText, userName), {
             streamingBehavior: delivery,
         });
     }
@@ -473,41 +580,37 @@ class ChannelRunner {
             if (!this.runState.ctx || !this.runState.logCtx || !this.runState.queue)
                 return;
             const { ctx, logCtx, queue, pendingTools, store } = this.runState;
-            if (event.type === "tool_execution_start") {
-                const agentEvent = event;
-                const args = agentEvent.args;
-                const label = args.label || agentEvent.toolName;
-                pendingTools.set(agentEvent.toolCallId, {
-                    toolName: agentEvent.toolName,
-                    args: agentEvent.args,
+            if (isToolExecutionStartEvent(event)) {
+                const label = extractLabelFromArgs(event.args) || event.toolName;
+                pendingTools.set(event.toolCallId, {
+                    toolName: event.toolName,
+                    args: event.args,
                     startTime: Date.now(),
                 });
-                log.logToolStart(logCtx, agentEvent.toolName, label, agentEvent.args);
+                this.memoryLifecycle.noteToolCall();
+                log.logToolStart(logCtx, event.toolName, label, isRecord(event.args) ? event.args : {});
                 queue.enqueue(() => ctx.respond(formatProgressEntry("tool", label), false), "tool label");
             }
-            else if (event.type === "tool_execution_update") {
-                const agentEvent = event;
-                if (agentEvent.toolName !== "subagent") {
+            else if (isToolExecutionUpdateEvent(event)) {
+                if (event.toolName !== "subagent") {
                     return;
                 }
-                const partialText = truncate(extractToolResultText(agentEvent.partialResult), 200);
+                const partialText = truncate(extractToolResultText(event.partialResult), 200);
                 if (!partialText.trim()) {
                     return;
                 }
                 queue.enqueue(() => ctx.respond(formatProgressEntry("tool", partialText), false), "tool update");
             }
-            else if (event.type === "tool_execution_end") {
-                const agentEvent = event;
-                const resultStr = extractToolResultText(agentEvent.result);
-                const pending = pendingTools.get(agentEvent.toolCallId);
-                pendingTools.delete(agentEvent.toolCallId);
+            else if (isToolExecutionEndEvent(event)) {
+                const resultStr = extractToolResultText(event.result);
+                const pending = pendingTools.get(event.toolCallId);
+                pendingTools.delete(event.toolCallId);
                 const durationMs = pending ? Date.now() - pending.startTime : 0;
-                const subAgentDetails = agentEvent.toolName === "subagent" &&
-                    agentEvent.result &&
-                    typeof agentEvent.result === "object" &&
-                    "details" in agentEvent.result &&
-                    isSubAgentToolDetails(agentEvent.result.details)
-                    ? agentEvent.result.details
+                const subAgentDetails = event.toolName === "subagent" &&
+                    isRecord(event.result) &&
+                    "details" in event.result &&
+                    isSubAgentToolDetails(event.result.details)
+                    ? event.result.details
                     : null;
                 if (subAgentDetails) {
                     mergeSubAgentUsage(this.runState.totalUsage, subAgentDetails);
@@ -519,7 +622,7 @@ class ChannelRunner {
                         : "subagent";
                     queue.enqueue(() => store?.logSubAgentRun(logCtx.channelId, {
                         date: new Date().toISOString(),
-                        toolCallId: agentEvent.toolCallId,
+                        toolCallId: event.toolCallId,
                         label,
                         agent: subAgentDetails.agent,
                         source: subAgentDetails.source,
@@ -538,26 +641,24 @@ class ChannelRunner {
                         },
                     }) ?? Promise.resolve(), "sub-agent run log");
                 }
-                const treatAsError = agentEvent.isError || Boolean(subAgentDetails?.failed);
+                const treatAsError = event.isError || Boolean(subAgentDetails?.failed);
                 if (treatAsError) {
-                    log.logToolError(logCtx, agentEvent.toolName, durationMs, resultStr);
+                    log.logToolError(logCtx, event.toolName, durationMs, resultStr);
                 }
                 else {
-                    log.logToolSuccess(logCtx, agentEvent.toolName, durationMs, resultStr);
+                    log.logToolSuccess(logCtx, event.toolName, durationMs, resultStr);
                 }
                 if (treatAsError) {
                     queue.enqueue(() => ctx.respond(formatProgressEntry("error", truncate(resultStr, 200)), false), "tool error");
                 }
             }
-            else if (event.type === "message_start") {
-                const agentEvent = event;
-                if (agentEvent.message.role === "assistant") {
+            else if (isMessageStartEvent(event)) {
+                if (isAssistantEventMessage(event.message)) {
                     log.logResponseStart(logCtx);
                 }
             }
-            else if (event.type === "message_end") {
-                const agentEvent = event;
-                const commandResultText = extractCustomCommandResultText(agentEvent.message);
+            else if (isMessageEndEvent(event)) {
+                const commandResultText = extractCustomCommandResultText(event.message);
                 if (commandResultText) {
                     this.runState.finalOutcome = { kind: "final", text: commandResultText };
                     log.logResponse(logCtx, commandResultText);
@@ -570,8 +671,8 @@ class ChannelRunner {
                     }, "command result");
                     return;
                 }
-                if (agentEvent.message.role === "assistant") {
-                    const assistantMsg = agentEvent.message;
+                if (isAssistantEventMessage(event.message)) {
+                    const assistantMsg = event.message;
                     if (assistantMsg.stopReason) {
                         this.runState.stopReason = assistantMsg.stopReason;
                     }
@@ -589,15 +690,15 @@ class ChannelRunner {
                         this.runState.totalUsage.cost.cacheWrite += assistantMsg.usage.cost.cacheWrite;
                         this.runState.totalUsage.cost.total += assistantMsg.usage.cost.total;
                     }
-                    const content = agentEvent.message.content;
+                    const content = assistantMsg.content;
                     const thinkingParts = [];
                     const textParts = [];
                     let hasToolCalls = false;
                     for (const part of content) {
-                        if (part.type === "thinking") {
+                        if (isThinkingPart(part)) {
                             thinkingParts.push(part.thinking);
                         }
-                        else if (part.type === "text") {
+                        else if (isTextPart(part)) {
                             textParts.push(part.text);
                         }
                         else if (part.type === "toolCall") {
@@ -614,14 +715,12 @@ class ChannelRunner {
                     }
                 }
             }
-            else if (event.type === "turn_end") {
-                const turnEvent = event;
-                if (turnEvent.message.role === "assistant" && turnEvent.toolResults.length === 0) {
-                    if (turnEvent.message.stopReason === "error" || turnEvent.message.stopReason === "aborted") {
+            else if (isTurnEndEvent(event)) {
+                if (isAssistantEventMessage(event.message) && event.toolResults.length === 0) {
+                    if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
                         return;
                     }
-                    const finalContent = turnEvent.message.content;
-                    const finalText = finalContent
+                    const finalText = event.message.content
                         .filter((part) => part.type === "text" && !!part.text)
                         .map((part) => part.text)
                         .join("\n");
@@ -631,6 +730,7 @@ class ChannelRunner {
                     }
                     if (trimmedFinalText === "[SILENT]" || trimmedFinalText.startsWith("[SILENT]")) {
                         this.runState.finalOutcome = { kind: "silent" };
+                        this.memoryLifecycle.noteCompletedAssistantTurn();
                         return;
                     }
                     if (this.runState.finalOutcome.kind === "final" &&
@@ -638,6 +738,7 @@ class ChannelRunner {
                         return;
                     }
                     this.runState.finalOutcome = { kind: "final", text: finalText };
+                    this.memoryLifecycle.noteCompletedAssistantTurn();
                     log.logResponse(logCtx, finalText);
                     queue.enqueue(async () => {
                         const delivered = await ctx.respondPlain(finalText);
@@ -647,23 +748,21 @@ class ChannelRunner {
                     }, "final response");
                 }
             }
-            else if (event.type === "auto_compaction_start") {
+            else if (isAutoCompactionStartEvent(event)) {
                 log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
                 queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", "Compacting context..."), false), "compaction start");
             }
-            else if (event.type === "auto_compaction_end") {
-                const compEvent = event;
-                if (compEvent.result) {
-                    log.logInfo(`Auto-compaction complete: ${compEvent.result.tokensBefore} tokens compacted`);
+            else if (isAutoCompactionEndEvent(event)) {
+                if (event.result) {
+                    log.logInfo(`Auto-compaction complete: ${event.result.tokensBefore} tokens compacted`);
                 }
-                else if (compEvent.aborted) {
+                else if (event.aborted) {
                     log.logInfo("Auto-compaction aborted");
                 }
             }
-            else if (event.type === "auto_retry_start") {
-                const retryEvent = event;
-                log.logWarning(`Retrying (${retryEvent.attempt}/${retryEvent.maxAttempts})`, retryEvent.errorMessage);
-                queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", `Retrying (${retryEvent.attempt}/${retryEvent.maxAttempts})...`), false), "retry");
+            else if (isAutoRetryStartEvent(event)) {
+                log.logWarning(`Retrying (${event.attempt}/${event.maxAttempts})`, event.errorMessage);
+                queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", `Retrying (${event.attempt}/${event.maxAttempts})...`), false), "retry");
             }
         });
     }