@oyasmi/pipiclaw 0.6.0 → 0.6.1

package/dist/agent/channel-runner.d.ts

@@ -16,6 +16,7 @@ export declare class ChannelRunner implements AgentRunner {
     private readonly settingsManager;
     private readonly modelRegistry;
     private readonly memoryLifecycle;
+    private readonly memoryCandidateStore;
     private readonly sessionResourceGate;
     private readonly sessionReady;
     private subAgentDiscovery;
@@ -42,7 +43,9 @@ export declare class ChannelRunner implements AgentRunner {
     private refreshSessionResources;
     private initializeSession;
     private reloadSessionResources;
+    private bindSessionExtensions;
     private ensureSessionReady;
+    private maybeRunPreventiveCompactionForIncomingText;
     private refreshSubAgentDiscovery;
     private reportSettingsDiagnostics;
     private reportConfigDiagnostics;

package/dist/agent/channel-runner.js

@@ -4,7 +4,7 @@ import { mkdir, readFile, writeFile } from "fs/promises";
 import { dirname, join, resolve } from "path";
 import * as log from "../log.js";
 import { buildFirstTurnMemoryBootstrap as renderFirstTurnMemoryBootstrap } from "../memory/bootstrap.js";
-import { createMemoryCandidateCache } from "../memory/candidates.js";
+import { createMemoryCandidateStore } from "../memory/candidates.js";
 import { getChannelMemoryPath } from "../memory/files.js";
 import { MemoryLifecycle } from "../memory/lifecycle.js";
 import { recallRelevantMemory } from "../memory/recall.js";
@@ -22,6 +22,7 @@ import { loadToolsConfigWithDiagnostics } from "../tools/config.js";
 import { createPipiclawTools } from "../tools/index.js";
 import { createCommandExtension } from "./command-extension.js";
 import { renderBuiltInHelp } from "./commands.js";
+import { estimateIncomingMessageTokens, getPreventiveCompactionDecision } from "./context-budget.js";
 import { clipUserInput } from "./progress-formatter.js";
 import { buildAppendSystemPrompt } from "./prompt-builder.js";
 import { createRunQueue } from "./run-queue.js";
@@ -68,6 +69,7 @@ export class ChannelRunner {
         this.sessionManager = SessionManager.open(contextFile, channelDir);
         this.settingsManager = new PipiclawSettingsManager(APP_HOME_DIR);
         this.reportSettingsDiagnostics();
+        this.memoryCandidateStore = createMemoryCandidateStore();
         // Create AuthStorage and ModelRegistry
         const authStorage = AuthStorage.create(AUTH_CONFIG_PATH);
         this.modelRegistry = createModelRegistry(authStorage, MODELS_CONFIG_PATH);
@@ -167,16 +169,17 @@ export class ChannelRunner {
         this.runState.queue = runQueue.queue;
         try {
             await this.ensureSessionReady();
-            // Ensure channel directory exists
-            await mkdir(this.channelDir, { recursive: true });
-            const candidateCache = createMemoryCandidateCache();
+            this.memoryLifecycle.noteUserTurnStarted();
             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;
+            const preserveRawInput = this.shouldPreserveRawInput(ctx.message.text);
+            await this.maybeRunPreventiveCompactionForIncomingText(preserveRawInput ? clippedInput : userMessage);
+            // Ensure channel directory exists
+            await mkdir(this.channelDir, { recursive: true });
+            let promptText = preserveRawInput ? clippedInput : userMessage;
             let recalledContextText = "";
             let durableMemoryBootstrapText = "";
-            this.memoryLifecycle.noteUserTurnStarted();
-            if (!this.shouldPreserveRawInput(ctx.message.text)) {
+            if (!preserveRawInput) {
                 const recallSettings = this.settingsManager.getMemoryRecallSettings();
                 if (recallSettings.enabled) {
                     const recall = await recallRelevantMemory({
@@ -190,7 +193,7 @@ export class ChannelRunner {
                         autoRerank: HAN_REGEX.test(clippedInput),
                         model: this.session.model ?? this.activeModel,
                         resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
-                        candidateCache,
+                        candidateStore: this.memoryCandidateStore,
                     });
                     if (recall.renderedText) {
                         recalledContextText = recall.renderedText;
@@ -234,10 +237,20 @@ export class ChannelRunner {
                     this.runState.errorMessage &&
                     !this.runState.finalResponseDelivered) {
                     try {
-                        const errorSummary = this.runState.errorMessage.length > 240
+                        const baseErrorSummary = this.runState.errorMessage.length > 240
                             ? `${this.runState.errorMessage.slice(0, 237)}...`
                             : this.runState.errorMessage;
-                        await ctx.replaceMessage(`_Sorry, something went wrong._\n\n\`${errorSummary}\``);
+                        const compactionSummary = this.runState.lastCompactionError &&
+                            this.runState.lastCompactionError !== this.runState.errorMessage
+                            ? this.runState.lastCompactionError.length > 240
+                                ? `${this.runState.lastCompactionError.slice(0, 237)}...`
+                                : this.runState.lastCompactionError
+                            : undefined;
+                        const detailLines = [`\`${baseErrorSummary}\``];
+                        if (compactionSummary) {
+                            detailLines.push(`Recovery: \`${compactionSummary}\``);
+                        }
+                        await ctx.replaceMessage(`_Sorry, something went wrong._\n\n${detailLines.join("\n\n")}`);
                     }
                     catch (err) {
                         const errMsg = err instanceof Error ? err.message : String(err);
@@ -370,8 +383,10 @@ export class ChannelRunner {
         if (clippedText !== text.trim()) {
             log.logWarning(`[${this.channelId}] Queued message exceeded ${MAX_USER_MESSAGE_CHARS} chars and was clipped`);
         }
+        const queuedMessage = this.formatUserMessage(clippedText, userName);
+        await this.maybeRunPreventiveCompactionForIncomingText(queuedMessage);
         await this.sessionResourceGate.runPrompt(async () => {
-            await this.session.prompt(this.formatUserMessage(clippedText, userName), {
+            await this.session.prompt(queuedMessage, {
                 streamingBehavior: delivery,
             });
         });
@@ -392,6 +407,7 @@ export class ChannelRunner {
     }
     async initializeSession() {
         await this.reloadSessionResources();
+        await this.bindSessionExtensions();
     }
     async reloadSessionResources() {
         this.settingsManager.reload();
@@ -402,9 +418,56 @@ export class ChannelRunner {
         this.rebuildSessionTools();
         await this.session.reload();
     }
+    async bindSessionExtensions() {
+        await this.session.bindExtensions({
+            commandContextActions: {
+                waitForIdle: () => this.session.agent.waitForIdle(),
+                newSession: async (options) => {
+                    const success = await this.session.newSession(options);
+                    return { cancelled: !success };
+                },
+                fork: async (entryId) => {
+                    const result = await this.session.fork(entryId);
+                    return { cancelled: result.cancelled };
+                },
+                navigateTree: async (targetId, options) => {
+                    const result = await this.session.navigateTree(targetId, options);
+                    return { cancelled: result.cancelled };
+                },
+                switchSession: async (sessionPath) => {
+                    const success = await this.session.switchSession(sessionPath);
+                    return { cancelled: !success };
+                },
+                reload: async () => {
+                    await this.refreshSessionResources();
+                },
+            },
+        });
+    }
     async ensureSessionReady() {
         await this.sessionReady;
     }
+    async maybeRunPreventiveCompactionForIncomingText(incomingText) {
+        const currentModel = this.session.model ?? this.activeModel;
+        const contextUsage = this.session.getContextUsage();
+        const contextTokens = contextUsage?.tokens;
+        const incomingTokens = estimateIncomingMessageTokens(incomingText);
+        const decision = getPreventiveCompactionDecision(contextTokens, incomingTokens, currentModel.contextWindow);
+        if (!decision.shouldCompact) {
+            return;
+        }
+        const currentTokens = contextTokens ?? 0;
+        const startedAt = Date.now();
+        log.logInfo(`[${this.channelId}] Preventive compaction triggered: projected ${decision.projectedTokens}/${currentModel.contextWindow} tokens (current=${currentTokens}, incoming≈${incomingTokens}), threshold=${decision.thresholdTokens}`);
+        try {
+            await this.session.compact();
+            log.logInfo(`[${this.channelId}] Preventive compaction complete in ${Date.now() - startedAt}ms`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log.logWarning(`[${this.channelId}] Preventive compaction failed`, message);
+        }
+    }
     refreshSubAgentDiscovery() {
         this.modelRegistry.refresh();
         const discovery = discoverSubAgents(this.workspaceDir, this.modelRegistry.getAvailable());
@@ -439,6 +502,7 @@ export class ChannelRunner {
             sandboxConfig: this.sandboxConfig,
             getSubAgentDiscovery: () => this.subAgentDiscovery,
             getMemoryRecallSettings: () => this.settingsManager.getMemoryRecallSettings(),
+            memoryCandidateStore: this.memoryCandidateStore,
             securityConfig: securityLoad.config,
             toolsConfig: toolsLoad.config,
         });

package/dist/agent/context-budget.d.ts

@@ -0,0 +1,9 @@
+export declare const PREVENTIVE_COMPACTION_THRESHOLD_RATIO = 0.75;
+export interface PreventiveCompactionDecision {
+    shouldCompact: boolean;
+    projectedTokens: number | null;
+    thresholdTokens: number;
+    ratio: number;
+}
+export declare function estimateIncomingMessageTokens(text: string): number;
+export declare function getPreventiveCompactionDecision(contextTokens: number | null | undefined, incomingTokens: number, contextWindow: number, thresholdRatio?: number): PreventiveCompactionDecision;

package/dist/agent/context-budget.js

@@ -0,0 +1,31 @@
+export const PREVENTIVE_COMPACTION_THRESHOLD_RATIO = 0.75;
+const ESTIMATED_CHARS_PER_TOKEN = 3;
+export function estimateIncomingMessageTokens(text) {
+    if (!text) {
+        return 0;
+    }
+    return Math.ceil(text.length / ESTIMATED_CHARS_PER_TOKEN);
+}
+export function getPreventiveCompactionDecision(contextTokens, incomingTokens, contextWindow, thresholdRatio = PREVENTIVE_COMPACTION_THRESHOLD_RATIO) {
+    const normalizedContextWindow = Number.isFinite(contextWindow) ? Math.max(0, Math.floor(contextWindow)) : 0;
+    const normalizedIncomingTokens = Number.isFinite(incomingTokens) && incomingTokens > 0 ? Math.floor(incomingTokens) : 0;
+    const normalizedRatio = Number.isFinite(thresholdRatio) && thresholdRatio > 0
+        ? Math.min(thresholdRatio, 1)
+        : PREVENTIVE_COMPACTION_THRESHOLD_RATIO;
+    const thresholdTokens = Math.floor(normalizedContextWindow * normalizedRatio);
+    if (contextTokens === null || contextTokens === undefined || !Number.isFinite(contextTokens) || contextTokens < 0) {
+        return {
+            shouldCompact: false,
+            projectedTokens: null,
+            thresholdTokens,
+            ratio: normalizedRatio,
+        };
+    }
+    const projectedTokens = Math.floor(contextTokens) + normalizedIncomingTokens;
+    return {
+        shouldCompact: normalizedContextWindow > 0 && projectedTokens >= thresholdTokens,
+        projectedTokens,
+        thresholdTokens,
+        ratio: normalizedRatio,
+    };
+}

package/dist/agent/session-events.js

@@ -195,16 +195,23 @@ export async function handleSessionEvent(event, context) {
         return;
     }
     if (isAutoCompactionStartEvent(event)) {
-        log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
-        queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", "Compacting context..."), false), "compaction start");
+        const label = event.reason === "manual" ? "Compacting context..." : "Compacting context...";
+        log.logInfo(`Compaction started (reason: ${event.reason})`);
+        queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", label), false), "compaction start");
         return;
     }
     if (isAutoCompactionEndEvent(event)) {
         if (event.result) {
-            log.logInfo(`Auto-compaction complete: ${event.result.tokensBefore} tokens compacted`);
+            runState.lastCompactionError = undefined;
+            log.logInfo(`Compaction complete: ${event.result.tokensBefore} tokens compacted`);
         }
         else if (event.aborted) {
-            log.logInfo("Auto-compaction aborted");
+            log.logInfo("Compaction aborted");
+        }
+        else if (event.errorMessage) {
+            runState.lastCompactionError = event.errorMessage;
+            log.logWarning("Compaction failed", event.errorMessage);
+            queue.enqueue(() => ctx.respond(formatProgressEntry("error", truncate(event.errorMessage ?? "Compaction failed", 200)), false), "compaction error");
         }
         return;
     }

package/dist/agent/type-guards.js

@@ -65,10 +65,12 @@ export function isTurnEndEvent(value) {
     return hasEventType(value, "turn_end") && "message" in value && Array.isArray(value.toolResults);
 }
 export function isAutoCompactionStartEvent(value) {
-    return hasEventType(value, "auto_compaction_start") && (value.reason === "threshold" || value.reason === "overflow");
+    return ((hasEventType(value, "auto_compaction_start") && (value.reason === "threshold" || value.reason === "overflow")) ||
+        (hasEventType(value, "compaction_start") &&
+            (value.reason === "threshold" || value.reason === "overflow" || value.reason === "manual")));
 }
 export function isAutoCompactionEndEvent(value) {
-    return hasEventType(value, "auto_compaction_end");
+    return hasEventType(value, "auto_compaction_end") || hasEventType(value, "compaction_end");
 }
 export function isAutoRetryStartEvent(value) {
     return (hasEventType(value, "auto_retry_start") &&

package/dist/agent/types.d.ts

@@ -44,6 +44,7 @@ export interface RunState {
     totalUsage: UsageTotals;
     stopReason: string;
     errorMessage: string | undefined;
+    lastCompactionError: string | undefined;
     finalOutcome: FinalOutcome;
     finalResponseDelivered: boolean;
 }
@@ -118,11 +119,17 @@ export type SessionEvent = {
     type: "auto_compaction_start";
     reason: "threshold" | "overflow";
 } | {
-    type: "auto_compaction_end";
+    type: "compaction_start";
+    reason: "manual" | "threshold" | "overflow";
+} | {
+    type: "auto_compaction_end" | "compaction_end";
+    reason?: "manual" | "threshold" | "overflow";
     result?: {
         tokensBefore: number;
     };
     aborted?: boolean;
+    errorMessage?: string;
+    willRetry?: boolean;
 } | {
     type: "auto_retry_start";
     attempt: number;
@@ -149,10 +156,10 @@ export type TurnEndEvent = Extract<SessionEvent, {
     type: "turn_end";
 }>;
 export type AutoCompactionStartEvent = Extract<SessionEvent, {
-    type: "auto_compaction_start";
+    type: "auto_compaction_start" | "compaction_start";
 }>;
 export type AutoCompactionEndEvent = Extract<SessionEvent, {
-    type: "auto_compaction_end";
+    type: "auto_compaction_end" | "compaction_end";
 }>;
 export type AutoRetryStartEvent = Extract<SessionEvent, {
     type: "auto_retry_start";

package/dist/agent/types.js

@@ -15,6 +15,7 @@ export function createEmptyRunState() {
         },
         stopReason: "stop",
         errorMessage: undefined,
+        lastCompactionError: undefined,
         finalOutcome: { kind: "none" },
         finalResponseDelivered: false,
     };

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { type BuiltInCommand, type BuiltInCommandName, parseBuiltInCommand, rend
 export { type AgentRunner, getOrCreateRunner } from "./agent/index.js";
 export { type AppendSystemPromptOptions, buildAppendSystemPrompt } from "./agent/prompt-builder.js";
 export { getAgentConfig, getSoul, loadPipiclawSkills, } from "./agent/workspace-resources.js";
-export { type BuildMemoryCandidatesOptions, buildMemoryCandidates, type MemoryCandidate, } from "./memory/candidates.js";
+export { type BuildMemoryCandidatesOptions, buildMemoryCandidates, createMemoryCandidateStore, type MemoryCandidate, type MemoryCandidateStore, } from "./memory/candidates.js";
 export { type BackgroundMaintenanceResult, type ConsolidationRunOptions, type InlineConsolidationResult, runBackgroundMaintenance, runInlineConsolidation, } from "./memory/consolidation.js";
 export { ensureChannelMemoryFiles, ensureChannelMemoryFilesSync, getChannelSessionPath, readChannelSession, rewriteChannelSession, } from "./memory/files.js";
 export { type ConsolidationReason, MemoryLifecycle, type MemoryLifecycleOptions } from "./memory/lifecycle.js";
@@ -16,7 +16,7 @@ export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_C
 export { ensureChannelDir, getChannelDir, getChannelDirName, } from "./runtime/channel-paths.js";
 export { createDingTalkContext } from "./runtime/delivery.js";
 export { type BusyMessageMode, DingTalkBot, type DingTalkConfig, type DingTalkContext, type DingTalkEvent, type DingTalkHandler, } from "./runtime/dingtalk.js";
-export { createEventsWatcher, EventsWatcher, type ImmediateEvent, type OneShotEvent, type PeriodicEvent, type ScheduledEvent, } from "./runtime/events.js";
+export { createEventsWatcher, type EventAction, EventsWatcher, type ImmediateEvent, type OneShotEvent, type PeriodicEvent, type ScheduledEvent, } from "./runtime/events.js";
 export { ChannelStore, type LoggedMessage, type LoggedSubAgentRun } from "./runtime/store.js";
 export { createExecutor, type ExecOptions, type ExecResult, type Executor, parseSandboxArg, type SandboxConfig, validateSandbox, } from "./sandbox.js";
 export { type PipiclawMemoryRecallSettings, type PipiclawSessionMemorySettings, type PipiclawSettings, PipiclawSettingsManager, } from "./settings.js";

package/dist/index.js

@@ -3,7 +3,7 @@ export { parseBuiltInCommand, renderBuiltInHelp, } from "./agent/commands.js";
 export { getOrCreateRunner } from "./agent/index.js";
 export { buildAppendSystemPrompt } from "./agent/prompt-builder.js";
 export { getAgentConfig, getSoul, loadPipiclawSkills, } from "./agent/workspace-resources.js";
-export { buildMemoryCandidates, } from "./memory/candidates.js";
+export { buildMemoryCandidates, createMemoryCandidateStore, } from "./memory/candidates.js";
 export { runBackgroundMaintenance, runInlineConsolidation, } from "./memory/consolidation.js";
 export { ensureChannelMemoryFiles, ensureChannelMemoryFilesSync, getChannelSessionPath, readChannelSession, rewriteChannelSession, } from "./memory/files.js";
 export { MemoryLifecycle } from "./memory/lifecycle.js";

package/dist/memory/candidates.d.ts

@@ -12,10 +12,13 @@ export interface MemoryCandidate {
 export interface BuildMemoryCandidatesOptions {
     workspaceDir: string;
     channelDir: string;
-    cache?: MemoryCandidateCache;
 }
-export interface MemoryCandidateCache {
-    entries: Map<string, Promise<MemoryCandidate[]>>;
+export declare class MemoryCandidateStore {
+    private files;
+    private inflight;
+    invalidate(path?: string): void;
+    getCandidates(options: BuildMemoryCandidatesOptions): Promise<MemoryCandidate[]>;
+    private loadFileCandidates;
 }
-export declare function createMemoryCandidateCache(): MemoryCandidateCache;
-export declare function buildMemoryCandidates(options: BuildMemoryCandidatesOptions): Promise<MemoryCandidate[]>;
+export declare function createMemoryCandidateStore(): MemoryCandidateStore;
+export declare function buildMemoryCandidates(options: BuildMemoryCandidatesOptions, store?: MemoryCandidateStore): Promise<MemoryCandidate[]>;

package/dist/memory/candidates.js

@@ -1,12 +1,7 @@
-import { readFile } from "fs/promises";
+import { readFile, stat } from "fs/promises";
 import { join } from "path";
 import { splitH1Sections, splitH2Sections } from "../shared/markdown-sections.js";
 import { getChannelHistoryPath, getChannelMemoryPath, getChannelSessionPath } from "./files.js";
-export function createMemoryCandidateCache() {
-    return {
-        entries: new Map(),
-    };
-}
 function normalizeContent(content) {
     return content.replace(/\r/g, "").trim();
 }
@@ -24,6 +19,9 @@ function slugify(value) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "") || "section");
 }
+function sameFingerprint(a, b) {
+    return a.exists === b.exists && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs && a.size === b.size;
+}
 function inferPriority(source, title) {
     const normalizedTitle = title.trim().toLowerCase();
     if (source === "channel-session") {
@@ -76,9 +74,6 @@ function buildCandidate(source, path, title, content, timestamp, searchText) {
         priority: inferPriority(source, title),
     };
 }
-function buildCacheKey(options) {
-    return `${options.workspaceDir}\u0000${options.channelDir}`;
-}
 function buildWorkspaceOrChannelMemoryCandidates(source, path, content) {
     const sections = splitH2Sections(content);
     if (sections.length === 0 && content) {
@@ -98,41 +93,96 @@ function buildSessionCandidates(path, content) {
         : `${sessionTitle.trim()}\n${section.content}`));
 }
 function buildHistoryCandidates(path, content) {
-    return splitH2Sections(content)
-        .filter((section) => section.content.trim())
-        .map((section) => buildCandidate("channel-history", path, section.heading, section.content, section.heading));
+    const sections = splitH2Sections(content).filter((section) => section.content.trim());
+    if (sections.length === 0) {
+        return [];
+    }
+    const foldedSections = sections.filter((section) => section.heading.startsWith("Folded History Through "));
+    const recentSectionLimit = 8;
+    const recentSections = sections.slice(-recentSectionLimit);
+    const selectedSections = Array.from(new Set([...foldedSections, ...recentSections]));
+    return selectedSections.map((section) => buildCandidate("channel-history", path, section.heading, section.content, section.heading));
 }
-async function buildMemoryCandidatesUncached(options) {
-    const workspaceMemoryPath = join(options.workspaceDir, "MEMORY.md");
-    const channelMemoryPath = getChannelMemoryPath(options.channelDir);
-    const channelSessionPath = getChannelSessionPath(options.channelDir);
-    const channelHistoryPath = getChannelHistoryPath(options.channelDir);
-    const [workspaceMemory, channelMemory, channelSession, channelHistory] = await Promise.all([
-        readOptionalFile(workspaceMemoryPath),
-        readOptionalFile(channelMemoryPath),
-        readOptionalFile(channelSessionPath),
-        readOptionalFile(channelHistoryPath),
-    ]);
-    return [
-        ...buildSessionCandidates(channelSessionPath, channelSession),
-        ...buildWorkspaceOrChannelMemoryCandidates("channel-memory", channelMemoryPath, channelMemory),
-        ...buildWorkspaceOrChannelMemoryCandidates("workspace-memory", workspaceMemoryPath, workspaceMemory),
-        ...buildHistoryCandidates(channelHistoryPath, channelHistory),
-    ];
+async function readFingerprint(path) {
+    try {
+        const stats = await stat(path);
+        return {
+            exists: true,
+            mtimeMs: stats.mtimeMs,
+            ctimeMs: stats.ctimeMs,
+            size: stats.size,
+        };
+    }
+    catch {
+        return {
+            exists: false,
+            mtimeMs: 0,
+            ctimeMs: 0,
+            size: 0,
+        };
+    }
 }
-export async function buildMemoryCandidates(options) {
-    if (!options.cache) {
-        return buildMemoryCandidatesUncached(options);
+export class MemoryCandidateStore {
+    constructor() {
+        this.files = new Map();
+        this.inflight = new Map();
+    }
+    invalidate(path) {
+        if (!path) {
+            this.files.clear();
+            this.inflight.clear();
+            return;
+        }
+        this.files.delete(path);
+        this.inflight.delete(path);
     }
-    const key = buildCacheKey(options);
-    const cached = options.cache.entries.get(key);
-    if (cached) {
-        return cached;
+    async getCandidates(options) {
+        const definitions = [
+            {
+                path: getChannelSessionPath(options.channelDir),
+                build: buildSessionCandidates,
+            },
+            {
+                path: getChannelMemoryPath(options.channelDir),
+                build: (path, content) => buildWorkspaceOrChannelMemoryCandidates("channel-memory", path, content),
+            },
+            {
+                path: join(options.workspaceDir, "MEMORY.md"),
+                build: (path, content) => buildWorkspaceOrChannelMemoryCandidates("workspace-memory", path, content),
+            },
+            {
+                path: getChannelHistoryPath(options.channelDir),
+                build: buildHistoryCandidates,
+            },
+        ];
+        const candidateGroups = await Promise.all(definitions.map(async (definition) => this.loadFileCandidates(definition.path, definition.build)));
+        return candidateGroups.flat();
+    }
+    async loadFileCandidates(path, build) {
+        const pending = this.inflight.get(path);
+        if (pending) {
+            return pending;
+        }
+        const work = (async () => {
+            const fingerprint = await readFingerprint(path);
+            const cached = this.files.get(path);
+            if (cached && sameFingerprint(cached.fingerprint, fingerprint)) {
+                return cached.candidates;
+            }
+            const content = fingerprint.exists ? await readOptionalFile(path) : "";
+            const candidates = build(path, content);
+            this.files.set(path, { fingerprint, candidates });
+            return candidates;
+        })().finally(() => {
+            this.inflight.delete(path);
+        });
+        this.inflight.set(path, work);
+        return work;
     }
-    const pending = buildMemoryCandidatesUncached(options).catch((error) => {
-        options.cache?.entries.delete(key);
-        throw error;
-    });
-    options.cache.entries.set(key, pending);
-    return pending;
+}
+export function createMemoryCandidateStore() {
+    return new MemoryCandidateStore();
+}
+export async function buildMemoryCandidates(options, store = createMemoryCandidateStore()) {
+    return store.getCandidates(options);
 }

package/dist/memory/consolidation.js

@@ -12,8 +12,8 @@ const HISTORY_LENGTH_THRESHOLD = 8_000;
 const HISTORY_BLOCK_THRESHOLD = 5;
 const HISTORY_RECENT_BLOCKS_TO_KEEP = 3;
 const INLINE_CONSOLIDATION_TIMEOUT_MS = 20_000;
-const MEMORY_CLEANUP_TIMEOUT_MS = 30_000;
-const HISTORY_FOLDING_TIMEOUT_MS = 30_000;
+const MEMORY_CLEANUP_TIMEOUT_MS = 120_000;
+const HISTORY_FOLDING_TIMEOUT_MS = 120_000;
 const INLINE_CONSOLIDATION_SYSTEM_PROMPT = `You are a runtime memory consolidation worker for Pipiclaw.
 
 Return strict JSON only. Do not wrap in Markdown fences.

package/dist/memory/recall.d.ts

@@ -1,5 +1,5 @@
 import type { Api, Model } from "@mariozechner/pi-ai";
-import { type MemoryCandidate, type MemoryCandidateCache } from "./candidates.js";
+import { type MemoryCandidate, type MemoryCandidateStore } from "./candidates.js";
 export interface RecallRequest {
     query: string;
     workspaceDir: string;
@@ -12,7 +12,7 @@ export interface RecallRequest {
     autoRerank?: boolean;
     model: Model<Api>;
     resolveApiKey: (model: Model<Api>) => Promise<string>;
-    candidateCache?: MemoryCandidateCache;
+    candidateStore?: MemoryCandidateStore;
 }
 export interface RecalledMemory {
     source: MemoryCandidate["source"];

package/dist/memory/recall.js

@@ -1,6 +1,6 @@
 import { parseJsonObject } from "../shared/llm-json.js";
 import { HAN_REGEX } from "../shared/text-utils.js";
-import { buildMemoryCandidates } from "./candidates.js";
+import { buildMemoryCandidates, createMemoryCandidateStore, } from "./candidates.js";
 import { COMMON_CHINESE_WORDS } from "./chinese-words.js";
 import { runSidecarTask } from "./sidecar-worker.js";
 const RERANK_SYSTEM_PROMPT = `You are selecting which memory snippets are most relevant to the current user turn.
@@ -466,8 +466,7 @@ export async function recallRelevantMemory(request) {
     const candidates = await buildMemoryCandidates({
         workspaceDir: request.workspaceDir,
         channelDir: request.channelDir,
-        cache: request.candidateCache,
-    });
+    }, request.candidateStore ?? createMemoryCandidateStore());
     const filteredCandidates = request.allowedSources?.length
         ? candidates.filter((candidate) => request.allowedSources?.includes(candidate.source))
         : candidates;

package/dist/runtime/bootstrap.js

@@ -137,7 +137,7 @@ const SECURITY_CONFIG_TEMPLATE = {
     },
 };
 const SHUTDOWN_WAIT_MS = 15000;
-const SHUTDOWN_FLUSH_WAIT_MS = 25000;
+const SHUTDOWN_FLUSH_WAIT_MS = 45000;
 const SHUTDOWN_ABORT_WAIT_MS = 5000;
 export const DEFAULT_BOOTSTRAP_PATHS = {
     appName: APP_NAME,
@@ -452,7 +452,7 @@ export function createRuntimeContext(options) {
         : new DingTalkBot(handler, options.dingtalkConfig);
     const eventsWatcher = options.createEventsWatcher
         ? options.createEventsWatcher(options.paths.workspaceDir, bot)
-        : createEventsWatcher(options.paths.workspaceDir, bot);
+        : createEventsWatcher(options.paths.workspaceDir, bot, loadSecurityConfigWithDiagnostics(options.paths.appHomeDir).config.commandGuard);
     const shutdownWithReason = async (reason = "manual") => {
         if (shutdownPromise) {
             return shutdownPromise;

package/dist/runtime/delivery.js

@@ -6,7 +6,9 @@ class ChannelDeliveryController {
         this.event = event;
         this.bot = bot;
         this.store = store;
-        this.progressText = "";
+        this.progressSegments = [];
+        this.cachedProgressText = "";
+        this.progressTextDirty = false;
         this.mode = "progress";
         this.desiredRevision = 0;
         this.appliedRevision = 0;
@@ -20,6 +22,9 @@ class ChannelDeliveryController {
         this.timer = null;
         this.cardWarmupTimer = null;
         this.flushWaiters = [];
+        this.sentProgressChars = 0;
+        this.replayRequired = false;
+        this.finalReplacementText = "";
     }
     buildContext() {
         return {
@@ -86,7 +91,11 @@ class ChannelDeliveryController {
         if (this.closed || this.finalResponseDelivered || !text.trim())
             return;
         this.clearCardWarmup();
-        this.progressText = this.progressText ? `${this.progressText}\n\n${text}` : text;
+        if (this.progressSegments.length > 0) {
+            this.progressSegments.push("\n\n");
+        }
+        this.progressSegments.push(text);
+        this.progressTextDirty = true;
         if (this.progressWindowStartedAt === 0) {
             this.progressWindowStartedAt = Date.now();
         }
@@ -116,7 +125,7 @@ class ChannelDeliveryController {
         if (this.closed || this.finalResponseDelivered)
             return;
         this.clearCardWarmup();
-        this.progressText = text;
+        this.finalReplacementText = text;
         this.mode = "finalize-with-fallback";
         this.bumpRevision(true);
     }
@@ -159,6 +168,7 @@ class ChannelDeliveryController {
         try {
             while (this.appliedRevision < this.desiredRevision) {
                 const mode = this.mode;
+                const progressText = this.getProgressText();
                 const throttleBaseAt = this.lastDeliveredAt > 0 ? this.lastDeliveredAt : this.progressWindowStartedAt;
                 if (mode === "progress" && throttleBaseAt > 0) {
                     const remaining = MIN_UPDATE_INTERVAL_MS - (Date.now() - throttleBaseAt);
@@ -171,31 +181,48 @@ class ChannelDeliveryController {
                     }
                 }
                 const revision = this.desiredRevision;
-                const content = this.progressText.trim();
+                const content = progressText.trim();
+                const replacementText = this.finalReplacementText;
                 let touchedRemote = false;
                 try {
                     if (mode === "progress") {
                         if (content) {
-                            touchedRemote = await this.bot.streamToCard(this.event.channelId, this.progressText);
+                            const nextSentChars = progressText.length;
+                            if (this.replayRequired) {
+                                touchedRemote = await this.bot.replaceCard(this.event.channelId, progressText);
+                            }
+                            else {
+                                const delta = progressText.slice(this.sentProgressChars);
+                                touchedRemote = delta ? await this.bot.appendToCard(this.event.channelId, delta) : true;
+                            }
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
+                                this.replayRequired = true;
+                            }
+                            else {
+                                this.sentProgressChars = nextSentChars;
+                                this.replayRequired = false;
                             }
                         }
                     }
                     else if (mode === "finalize-existing") {
                         if (content || this.cardWarmupTriggered) {
-                            touchedRemote = await this.bot.finalizeExistingCard(this.event.channelId, content ? this.progressText : NO_CONTENT);
+                            touchedRemote = await this.bot.replaceCard(this.event.channelId, content ? progressText : NO_CONTENT, true);
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
                             }
+                            else {
+                                this.sentProgressChars = progressText.length;
+                                this.replayRequired = false;
+                            }
                         }
                         else {
                             this.bot.discardCard(this.event.channelId);
                         }
                     }
                     else if (mode === "finalize-with-fallback") {
-                        if (content) {
-                            touchedRemote = await this.bot.finalizeCard(this.event.channelId, this.progressText);
+                        if (replacementText.trim()) {
+                            touchedRemote = await this.bot.finalizeCard(this.event.channelId, replacementText);
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
                             }
@@ -206,7 +233,7 @@ class ChannelDeliveryController {
                     }
                     else if (mode === "silent") {
                         if (this.cardWarmupTriggered) {
-                            touchedRemote = await this.bot.finalizeExistingCard(this.event.channelId, NO_CONTENT);
+                            touchedRemote = await this.bot.replaceCard(this.event.channelId, NO_CONTENT, true);
                         }
                         if (!touchedRemote) {
                             this.bot.discardCard(this.event.channelId);
@@ -216,6 +243,9 @@ class ChannelDeliveryController {
                 catch (err) {
                     log.logWarning(`[${this.event.channelId}] Delivery sync failed`, err instanceof Error ? err.message : String(err));
                     this.bot.discardCard(this.event.channelId);
+                    if (mode === "progress") {
+                        this.replayRequired = true;
+                    }
                 }
                 if (touchedRemote) {
                     this.lastDeliveredAt = Date.now();
@@ -262,6 +292,14 @@ class ChannelDeliveryController {
         this.clearCardWarmup();
         await this.flush();
     }
+    getProgressText() {
+        if (!this.progressTextDirty) {
+            return this.cachedProgressText;
+        }
+        this.cachedProgressText = this.progressSegments.join("");
+        this.progressTextDirty = false;
+        return this.cachedProgressText;
+    }
 }
 export function createDingTalkContext(event, bot, store) {
     return new ChannelDeliveryController(event, bot, store).buildContext();

package/dist/runtime/dingtalk.d.ts

@@ -94,7 +94,15 @@ export declare class DingTalkBot {
      */
     ensureCard(channelId: string): Promise<void>;
     /**
-     * Stream content to the active AI Card for a channel.
+     * Replace the active card content with a full snapshot.
+     */
+    replaceCard(channelId: string, content: string, finalize?: boolean, failed?: boolean): Promise<boolean>;
+    /**
+     * Append a delta to the active card transcript.
+     */
+    appendToCard(channelId: string, content: string, finalize?: boolean, failed?: boolean): Promise<boolean>;
+    /**
+     * Stream content to the active AI Card for a channel using full replacement semantics.
      */
     streamToCard(channelId: string, content: string, finalize?: boolean): Promise<boolean>;
     /**

package/dist/runtime/dingtalk.js

@@ -362,48 +362,80 @@ export class DingTalkBot {
         await this.createCard(channelId);
     }
     /**
-     * Stream content to the active AI Card for a channel.
+     * Replace the active card content with a full snapshot.
      */
-    async streamToCard(channelId, content, finalize = false) {
+    async replaceCard(channelId, content, finalize = false, failed = false) {
         let card = this.activeCards.get(channelId);
-        if ((!card || card.finished) && !finalize && this.config.cardTemplateId && content.trim()) {
+        if ((!card || card.finished) && this.config.cardTemplateId && (content.trim() || !finalize || failed)) {
             await this.ensureCard(channelId);
             card = this.activeCards.get(channelId);
         }
         if (!card || card.finished) {
-            if (finalize) {
+            if (finalize && content.trim()) {
                 return this.sendPlain(channelId, content);
             }
             return false;
         }
-        const streamed = await this.streamCard(card, content, finalize);
-        if (!streamed) {
+        const streamed = await this.streamCard(card, content, {
+            append: false,
+            finalize,
+            failed,
+        });
+        if (!streamed || finalize || failed) {
             this.activeCards.delete(channelId);
         }
         return streamed;
     }
     /**
-     * Finalize the active card for a channel without falling back to a plain message.
-     * Returns true if a card was finalized, false if no active card existed.
+     * Append a delta to the active card transcript.
      */
-    async finalizeExistingCard(channelId, content) {
+    async appendToCard(channelId, content, finalize = false, failed = false) {
+        if (!content && !finalize && !failed) {
+            return true;
+        }
         let card = this.activeCards.get(channelId);
-        if ((!card || card.finished) && this.config.cardTemplateId && content.trim()) {
+        if ((!card || card.finished) && !finalize && !failed && this.config.cardTemplateId && content.trim()) {
             await this.ensureCard(channelId);
             card = this.activeCards.get(channelId);
         }
         if (!card || card.finished) {
+            if (finalize && content.trim()) {
+                return this.sendPlain(channelId, content);
+            }
             return false;
         }
-        const finalized = await this.streamCard(card, content, true);
-        this.activeCards.delete(channelId);
-        return finalized;
+        const streamed = await this.streamCard(card, content, {
+            append: true,
+            finalize,
+            failed,
+        });
+        if (!streamed || finalize || failed) {
+            this.activeCards.delete(channelId);
+        }
+        return streamed;
+    }
+    /**
+     * Stream content to the active AI Card for a channel using full replacement semantics.
+     */
+    async streamToCard(channelId, content, finalize = false) {
+        return this.replaceCard(channelId, content, finalize, false);
+    }
+    /**
+     * Finalize the active card for a channel without falling back to a plain message.
+     * Returns true if a card was finalized, false if no active card existed.
+     */
+    async finalizeExistingCard(channelId, content) {
+        const finalized = await this.replaceCard(channelId, content, true, false);
+        if (!finalized) {
+            return false;
+        }
+        return true;
     }
     /**
      * Finalize and remove the active card for a channel.
      */
     async finalizeCard(channelId, content) {
-        const finalized = await this.finalizeExistingCard(channelId, content);
+        const finalized = await this.replaceCard(channelId, content, true, false);
         if (!finalized) {
             return this.sendPlain(channelId, content);
         }
@@ -529,7 +561,7 @@ export class DingTalkBot {
         this.activeCards.set(channelId, card);
         return card;
     }
-    async streamCard(card, content, finalize = false) {
+    async streamCard(card, content, options) {
         // Refresh token if needed
         const ageSecs = Date.now() / 1000 - card.createdAt;
         if (ageSecs > TOKEN_REFRESH_SECS) {
@@ -543,9 +575,12 @@ export class DingTalkBot {
             guid: `${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
             key: card.templateKey,
             content,
-            isFull: true,
-            isFinalize: finalize,
-            isError: false,
+            append: options.append,
+            finished: options.finalize,
+            failed: options.failed,
+            isFull: !options.append,
+            isFinalize: options.finalize,
+            isError: options.failed,
         };
         const start = Date.now();
         try {
@@ -560,8 +595,8 @@ export class DingTalkBot {
                 log.logWarning(`DingTalk Card: streaming request took ${duration}ms (slow)`);
             }
             card.lastUpdated = Date.now() / 1000;
-            card.content = content;
-            if (finalize) {
+            card.content = options.append ? `${card.content}${content}` : content;
+            if (options.finalize || options.failed) {
                 card.finished = true;
             }
             return true;

package/dist/runtime/events.d.ts

@@ -1,14 +1,22 @@
+import type { SecurityConfig } from "../security/types.js";
 import type { DingTalkBot } from "./dingtalk.js";
+export interface EventAction {
+    type: "bash";
+    command: string;
+    timeout?: number;
+}
 export interface ImmediateEvent {
     type: "immediate";
     channelId: string;
     text: string;
+    preAction?: EventAction;
 }
 export interface OneShotEvent {
     type: "one-shot";
     channelId: string;
     text: string;
     at: string;
+    preAction?: EventAction;
 }
 export interface PeriodicEvent {
     type: "periodic";
@@ -16,18 +24,20 @@ export interface PeriodicEvent {
     text: string;
     schedule: string;
     timezone: string;
+    preAction?: EventAction;
 }
 export type ScheduledEvent = ImmediateEvent | OneShotEvent | PeriodicEvent;
 export declare class EventsWatcher {
     private eventsDir;
     private bot;
+    private commandGuardConfig?;
     private timers;
     private crons;
     private debounceTimers;
     private startTime;
     private watcher;
     private knownFiles;
-    constructor(eventsDir: string, bot: DingTalkBot);
+    constructor(eventsDir: string, bot: DingTalkBot, commandGuardConfig?: SecurityConfig["commandGuard"] | undefined);
     start(): void;
     stop(): void;
     private debounce;
@@ -36,11 +46,13 @@ export declare class EventsWatcher {
     private handleDelete;
     private cancelScheduled;
     private handleFile;
+    private parsePreAction;
     private parseEvent;
     private handleImmediate;
     private handleOneShot;
     private handlePeriodic;
     private execute;
+    private runPreAction;
     private deleteFile;
     private getInvalidMarkerPath;
     private markInvalid;
@@ -50,4 +62,4 @@ export declare class EventsWatcher {
 /**
  * Create and start an events watcher.
  */
-export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot): EventsWatcher;
+export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot, commandGuardConfig?: SecurityConfig["commandGuard"]): EventsWatcher;

package/dist/runtime/events.js

@@ -1,8 +1,10 @@
+import { exec } from "child_process";
 import { Cron } from "croner";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, watch, writeFileSync } from "fs";
 import { readFile } from "fs/promises";
 import { join } from "path";
 import * as log from "../log.js";
+import { guardCommand } from "../security/command-guard.js";
 // ============================================================================
 // EventsWatcher
 // ============================================================================
@@ -11,9 +13,10 @@ const MAX_RETRIES = 3;
 const RETRY_BASE_MS = 100;
 const MAX_TIMEOUT_MS = 2_147_483_647;
 export class EventsWatcher {
-    constructor(eventsDir, bot) {
+    constructor(eventsDir, bot, commandGuardConfig) {
         this.eventsDir = eventsDir;
         this.bot = bot;
+        this.commandGuardConfig = commandGuardConfig;
         this.timers = new Map();
         this.crons = new Map();
         this.debounceTimers = new Map();
@@ -145,19 +148,39 @@ export class EventsWatcher {
                 break;
         }
     }
+    parsePreAction(data, filename) {
+        if (!data.preAction)
+            return undefined;
+        if (typeof data.preAction !== "object" || data.preAction === null) {
+            throw new Error(`Invalid 'preAction' field in ${filename}, expected an object`);
+        }
+        const action = data.preAction;
+        if (action.type !== "bash") {
+            throw new Error(`Unsupported preAction type '${String(action.type)}' in ${filename}, only 'bash' is supported`);
+        }
+        if (typeof action.command !== "string" || action.command.trim().length === 0) {
+            throw new Error(`Missing or empty 'preAction.command' in ${filename}`);
+        }
+        return {
+            type: "bash",
+            command: action.command,
+            ...(typeof action.timeout === "number" ? { timeout: action.timeout } : {}),
+        };
+    }
     parseEvent(content, filename) {
         const data = JSON.parse(content);
         if (!data.type || !data.channelId || !data.text) {
             throw new Error(`Missing required fields (type, channelId, text) in ${filename}`);
         }
+        const preAction = this.parsePreAction(data, filename);
         switch (data.type) {
             case "immediate":
-                return { type: "immediate", channelId: data.channelId, text: data.text };
+                return { type: "immediate", channelId: data.channelId, text: data.text, preAction };
             case "one-shot":
                 if (!data.at) {
                     throw new Error(`Missing 'at' field for one-shot event in ${filename}`);
                 }
-                return { type: "one-shot", channelId: data.channelId, text: data.text, at: data.at };
+                return { type: "one-shot", channelId: data.channelId, text: data.text, at: data.at, preAction };
             case "periodic":
                 if (!data.schedule) {
                     throw new Error(`Missing 'schedule' field for periodic event in ${filename}`);
@@ -171,12 +194,13 @@ export class EventsWatcher {
                     text: data.text,
                     schedule: data.schedule,
                     timezone: data.timezone,
+                    preAction,
                 };
             default:
                 throw new Error(`Unknown event type '${data.type}' in ${filename}`);
         }
     }
-    handleImmediate(filename, event) {
+    async handleImmediate(filename, event) {
         const filePath = join(this.eventsDir, filename);
         try {
             const stat = statSync(filePath);
@@ -190,7 +214,7 @@ export class EventsWatcher {
             return;
         }
         log.logInfo(`Executing immediate event: ${filename}`);
-        this.execute(filename, event);
+        await this.execute(filename, event);
     }
     handleOneShot(filename, event) {
         const atTime = new Date(event.at).getTime();
@@ -212,18 +236,28 @@ export class EventsWatcher {
             return;
         }
         log.logInfo(`Scheduling one-shot event: ${filename} in ${Math.round(delay / 1000)}s`);
-        const timer = setTimeout(() => {
+        const timer = setTimeout(async () => {
             this.timers.delete(filename);
-            log.logInfo(`Executing one-shot event: ${filename}`);
-            this.execute(filename, event);
+            try {
+                log.logInfo(`Executing one-shot event: ${filename}`);
+                await this.execute(filename, event);
+            }
+            catch (err) {
+                log.logWarning(`One-shot event execution failed: ${filename}`, String(err));
+            }
         }, delay);
         this.timers.set(filename, timer);
     }
     handlePeriodic(filename, event) {
         try {
-            const cron = new Cron(event.schedule, { timezone: event.timezone }, () => {
-                log.logInfo(`Executing periodic event: ${filename}`);
-                this.execute(filename, event, false);
+            const cron = new Cron(event.schedule, { timezone: event.timezone }, async () => {
+                try {
+                    log.logInfo(`Executing periodic event: ${filename}`);
+                    await this.execute(filename, event, false);
+                }
+                catch (err) {
+                    log.logWarning(`Periodic event execution failed: ${filename}`, String(err));
+                }
             });
             this.crons.set(filename, cron);
             const next = cron.nextRun();
@@ -234,7 +268,17 @@ export class EventsWatcher {
             this.markInvalid(filename, `Invalid cron schedule: ${event.schedule}\n${String(err)}`);
         }
     }
-    execute(filename, event, deleteAfter = true) {
+    async execute(filename, event, deleteAfter = true) {
+        if (event.preAction) {
+            try {
+                await this.runPreAction(event.preAction, filename);
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                log.logInfo(`Pre-action gate blocked event: ${filename} (${reason})`);
+                return;
+            }
+        }
         let scheduleInfo;
         switch (event.type) {
             case "immediate":
@@ -270,6 +314,25 @@ export class EventsWatcher {
             }
         }
     }
+    runPreAction(action, filename) {
+        if (this.commandGuardConfig?.enabled) {
+            const guardResult = guardCommand(action.command, this.commandGuardConfig);
+            if (!guardResult.allowed) {
+                log.logWarning(`Pre-action command blocked by guard for ${filename}: ${guardResult.reason}`);
+                return Promise.reject(new Error(`guard: ${guardResult.reason}`));
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const child = exec(action.command, { timeout: action.timeout ?? 10_000 });
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`exit ${code}`));
+            });
+            child.on("error", reject);
+        });
+    }
     deleteFile(filename) {
         const filePath = join(this.eventsDir, filename);
         try {
@@ -313,7 +376,7 @@ export class EventsWatcher {
 /**
  * Create and start an events watcher.
  */
-export function createEventsWatcher(workspaceDir, bot) {
+export function createEventsWatcher(workspaceDir, bot, commandGuardConfig) {
     const eventsDir = join(workspaceDir, "events");
-    return new EventsWatcher(eventsDir, bot);
+    return new EventsWatcher(eventsDir, bot, commandGuardConfig);
 }

package/dist/subagents/tool.d.ts

@@ -1,5 +1,6 @@
 import { type AgentEvent, type AgentMessage, type AgentTool } from "@mariozechner/pi-agent-core";
 import type { Api, Model } from "@mariozechner/pi-ai";
+import type { MemoryCandidateStore } from "../memory/candidates.js";
 import type { Executor } from "../sandbox.js";
 import type { SecurityConfig } from "../security/types.js";
 import type { PipiclawMemoryRecallSettings } from "../settings.js";
@@ -44,6 +45,7 @@ export interface SubAgentToolOptions {
     channelDir: string;
     getSubAgentDiscovery?: () => SubAgentDiscoveryResult;
     getMemoryRecallSettings?: () => PipiclawMemoryRecallSettings;
+    memoryCandidateStore?: MemoryCandidateStore;
     securityConfig?: SecurityConfig;
     webConfig?: PipiclawWebToolsConfig;
     runtimeContext: {

package/dist/subagents/tool.js

@@ -1,7 +1,6 @@
 import { Agent } from "@mariozechner/pi-agent-core";
 import { convertToLlm } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { createMemoryCandidateCache } from "../memory/candidates.js";
 import { readChannelSession } from "../memory/files.js";
 import { recallRelevantMemory } from "../memory/recall.js";
 import { formatModelReference } from "../models/utils.js";
@@ -187,7 +186,7 @@ function stripRuntimeContextWrapper(renderedText) {
         .replace(/\s*<\/runtime_context>$/i, "")
         .trim();
 }
-async function buildContextualBlocks(task, config, options, currentModel, candidateCache = createMemoryCandidateCache()) {
+async function buildContextualBlocks(task, config, options, currentModel) {
     if (config.contextMode !== "contextual") {
         return [];
     }
@@ -226,7 +225,7 @@ async function buildContextualBlocks(task, config, options, currentModel, candid
         model: currentModel,
         resolveApiKey: options.resolveApiKey,
         allowedSources: ["workspace-memory", "channel-memory", "channel-history"],
-        candidateCache,
+        candidateStore: options.memoryCandidateStore,
     });
     const recalledText = stripRuntimeContextWrapper(recalled.renderedText);
     if (recalledText) {

package/dist/tools/index.d.ts

@@ -1,5 +1,6 @@
 import type { AgentTool } from "@mariozechner/pi-agent-core";
 import type { Api, Model } from "@mariozechner/pi-ai";
+import type { MemoryCandidateStore } from "../memory/candidates.js";
 import type { Executor, SandboxConfig } from "../sandbox.js";
 import type { SecurityConfig, SecurityRuntimeContext } from "../security/types.js";
 import type { PipiclawMemoryRecallSettings } from "../settings.js";
@@ -17,6 +18,7 @@ export interface CreatePipiclawToolsOptions {
     sandboxConfig: SandboxConfig;
     getSubAgentDiscovery: () => SubAgentDiscoveryResult;
     getMemoryRecallSettings: () => PipiclawMemoryRecallSettings;
+    memoryCandidateStore: MemoryCandidateStore;
     securityConfig?: SecurityConfig;
     toolsConfig?: PipiclawToolsConfig;
 }

package/dist/tools/index.js

@@ -65,6 +65,7 @@ export function createPipiclawTools(options) {
             channelDir: options.channelDir,
             getSubAgentDiscovery: options.getSubAgentDiscovery,
             getMemoryRecallSettings: options.getMemoryRecallSettings,
+            memoryCandidateStore: options.memoryCandidateStore,
             securityConfig,
             webConfig: toolsConfig.tools.web,
             runtimeContext: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oyasmi/pipiclaw",
-	"version": "0.6.0",
+	"version": "0.6.1",
 	"description": "An AI assistant runtime for coding and team workflows, with DingTalk AI Cards, sub-agents, memory, and scheduled events.",
 	"type": "module",
 	"bin": {