@oyasmi/pipiclaw 0.5.9 → 0.6.1

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

@@ -4,6 +4,7 @@ import { type SandboxConfig } from "../sandbox.js";
 import { type BuiltInCommand } from "./commands.js";
 import { type AgentRunner } from "./types.js";
 export declare class ChannelRunner implements AgentRunner {
+    private readonly executor;
     private readonly sandboxConfig;
     private readonly channelId;
     private readonly channelDir;
@@ -15,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;
@@ -41,8 +43,14 @@ export declare class ChannelRunner implements AgentRunner {
     private refreshSessionResources;
     private initializeSession;
     private reloadSessionResources;
+    private bindSessionExtensions;
     private ensureSessionReady;
+    private maybeRunPreventiveCompactionForIncomingText;
     private refreshSubAgentDiscovery;
+    private reportSettingsDiagnostics;
+    private reportConfigDiagnostics;
+    private buildRuntimeTools;
+    private rebuildSessionTools;
     private subscribeToSessionEvents;
     private buildFirstTurnMemoryBootstrap;
 }

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";
@@ -12,13 +12,17 @@ import { getApiKeyForModel } from "../models/api-keys.js";
 import { resolveInitialModel } from "../models/utils.js";
 import { APP_HOME_DIR, AUTH_CONFIG_PATH, MODELS_CONFIG_PATH } from "../paths.js";
 import { createExecutor } from "../sandbox.js";
+import { loadSecurityConfigWithDiagnostics } from "../security/config.js";
 import { PipiclawSettingsManager } from "../settings.js";
+import { formatConfigDiagnostic } from "../shared/config-diagnostics.js";
 import { HAN_REGEX } from "../shared/text-utils.js";
 import { isRecord } from "../shared/type-guards.js";
 import { discoverSubAgents, formatSubAgentList } from "../subagents/discovery.js";
+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";
@@ -54,6 +58,7 @@ export class ChannelRunner {
         this.channelId = channelId;
         this.channelDir = channelDir;
         const executor = createExecutor(sandboxConfig);
+        this.executor = executor;
         this.workspaceDir = resolve(dirname(channelDir));
         this.workspacePath = executor.getWorkspacePath(this.workspaceDir);
         // Initial skill summaries
@@ -63,6 +68,8 @@ export class ChannelRunner {
         const contextFile = join(channelDir, "context.jsonl");
         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);
@@ -71,19 +78,7 @@ export class ChannelRunner {
         log.logInfo(`Using model: ${this.activeModel.provider}/${this.activeModel.id} (${this.activeModel.name})`);
         this.subAgentDiscovery = this.refreshSubAgentDiscovery();
         // Create tools
-        const tools = createPipiclawTools({
-            executor,
-            getCurrentModel: () => this.activeModel,
-            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(),
-        });
+        const tools = this.buildRuntimeTools();
         // Create agent
         this.agent = new Agent({
             initialState: {
@@ -174,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({
@@ -197,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;
@@ -241,7 +237,20 @@ export class ChannelRunner {
                     this.runState.errorMessage &&
                     !this.runState.finalResponseDelivered) {
                     try {
-                        await ctx.replaceMessage("_Sorry, something went wrong_");
+                        const baseErrorSummary = this.runState.errorMessage.length > 240
+                            ? `${this.runState.errorMessage.slice(0, 237)}...`
+                            : this.runState.errorMessage;
+                        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);
@@ -258,6 +267,16 @@ export class ChannelRunner {
                         log.logWarning("Failed to delete message for silent response", errMsg);
                     }
                 }
+                else if (this.runState.stopReason === "aborted" && !this.runState.finalResponseDelivered) {
+                    try {
+                        await ctx.deleteMessage();
+                        log.logInfo("Aborted response - discarded active delivery state");
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        log.logWarning("Failed to discard active delivery state after abort", errMsg);
+                    }
+                }
                 else if (finalOutcomeText && !this.runState.finalResponseDelivered) {
                     try {
                         await ctx.replaceMessage(finalOutcomeText);
@@ -364,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,
             });
         });
@@ -386,17 +407,67 @@ export class ChannelRunner {
     }
     async initializeSession() {
         await this.reloadSessionResources();
+        await this.bindSessionExtensions();
     }
     async reloadSessionResources() {
+        this.settingsManager.reload();
+        this.reportSettingsDiagnostics();
         const skills = loadPipiclawSkills(this.channelDir, this.workspacePath);
         this.currentSkills = skills;
         this.subAgentDiscovery = this.refreshSubAgentDiscovery();
-        this.firstTurnMemoryBootstrapPending = true;
+        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());
@@ -405,6 +476,43 @@ export class ChannelRunner {
         }
         return discovery;
     }
+    reportSettingsDiagnostics() {
+        for (const { scope, error } of this.settingsManager.drainErrors()) {
+            log.logWarning(`[${this.channelId}] Failed to load ${scope} settings`, `${error.message}\n${join(APP_HOME_DIR, "settings.json")}`);
+        }
+    }
+    reportConfigDiagnostics(diagnostics) {
+        for (const diagnostic of diagnostics) {
+            log.logWarning(`[${this.channelId}] ${formatConfigDiagnostic(diagnostic)}`, diagnostic.path);
+        }
+    }
+    buildRuntimeTools() {
+        const securityLoad = loadSecurityConfigWithDiagnostics(APP_HOME_DIR);
+        const toolsLoad = loadToolsConfigWithDiagnostics(APP_HOME_DIR);
+        this.reportConfigDiagnostics([...securityLoad.diagnostics, ...toolsLoad.diagnostics]);
+        return createPipiclawTools({
+            executor: this.executor,
+            getCurrentModel: () => this.activeModel,
+            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(),
+            memoryCandidateStore: this.memoryCandidateStore,
+            securityConfig: securityLoad.config,
+            toolsConfig: toolsLoad.config,
+        });
+    }
+    rebuildSessionTools() {
+        const tools = this.buildRuntimeTools();
+        this.agent.setTools(tools);
+        this.session._baseToolsOverride =
+            Object.fromEntries(tools.map((tool) => [tool.name, tool]));
+    }
     // === Session event subscription ===
     subscribeToSessionEvents() {
         this.session.subscribe(async (event) => {

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";
@@ -12,11 +12,11 @@ export { renderSessionMemory, type SessionMemoryState, type SessionMemoryUpdateO
 export { runSidecarTask, type SidecarResult, type SidecarTask, } from "./memory/sidecar-worker.js";
 export { getApiKeyForModel } from "./models/api-keys.js";
 export { findExactModelReferenceMatch, findModelReferenceMatch, formatModelList, formatModelReference, resolveInitialModel, } from "./models/utils.js";
-export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
+export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SECURITY_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
 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";
@@ -12,7 +12,7 @@ export { renderSessionMemory, updateChannelSessionMemory, } from "./memory/sessi
 export { runSidecarTask, } from "./memory/sidecar-worker.js";
 export { getApiKeyForModel } from "./models/api-keys.js";
 export { findExactModelReferenceMatch, findModelReferenceMatch, formatModelList, formatModelReference, resolveInitialModel, } from "./models/utils.js";
-export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
+export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SECURITY_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
 export { ensureChannelDir, getChannelDir, getChannelDirName, } from "./runtime/channel-paths.js";
 export { createDingTalkContext } from "./runtime/delivery.js";
 export { DingTalkBot, } from "./runtime/dingtalk.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);
 }