@oyasmi/pipiclaw 0.6.0 → 0.6.2

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/files.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "crypto";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { mkdir, readFile, rename, writeFile } from "fs/promises";
 import { dirname, join } from "path";
@@ -62,7 +63,7 @@ function normalizeContent(content) {
 }
 async function writeAtomically(path, content) {
     await mkdir(dirname(path), { recursive: true });
-    const tempPath = `${path}.tmp`;
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
     await writeFile(tempPath, content, "utf-8");
     await rename(tempPath, path);
 }

package/dist/memory/lifecycle.d.ts

@@ -14,7 +14,7 @@ export interface MemoryLifecycleOptions {
 }
 export declare class MemoryLifecycle {
     private options;
-    private backgroundQueue;
+    private durableMemoryQueue;
     private sessionRefreshQueue;
     private turnsSinceSessionUpdate;
     private toolCallsSinceSessionUpdate;
@@ -39,12 +39,14 @@ export declare class MemoryLifecycle {
     private refreshSessionMemory;
     private runSessionRefreshSerial;
     private requestThresholdSessionRefresh;
-    private enqueueBackgroundJob;
+    private runDurableMemoryJobSerial;
+    private enqueueDurableMemoryJob;
     private hasPendingAssistantSnapshot;
     private markDurableConsolidationCheckpoint;
     private logConsolidationResult;
     private scheduleIdleConsolidation;
     private runPreflightConsolidation;
+    private runPreflightConsolidationNow;
     private handleSessionBeforeCompact;
     private handleSessionCompact;
     private handleSessionBeforeSwitch;