@oyasmi/pipiclaw 0.6.3 → 0.6.5

package/dist/memory/post-turn-review.js

@@ -0,0 +1,244 @@
+import { serializeConversation } from "@mariozechner/pi-coding-agent";
+import { parseJsonObject } from "../shared/llm-json.js";
+import { clipText } from "../shared/text-utils.js";
+import { buildStandardMessages, isRecord } from "../shared/type-guards.js";
+import { manageWorkspaceSkill } from "../tools/skill-manage.js";
+import { appendChannelMemoryUpdate, readChannelHistory, readChannelMemory, readChannelSession } from "./files.js";
+import { shouldAutoWriteMemory, shouldAutoWriteSkill, } from "./promotion.js";
+import { appendMemoryReviewLog } from "./review-log.js";
+import { runRetriedSidecarTask } from "./sidecar-worker.js";
+const POST_TURN_REVIEW_SYSTEM_PROMPT = `You are Pipiclaw's post-turn memory reviewer.
+
+Return strict JSON only:
+{
+  "memoryCandidates": [
+    {
+      "target": "channel-memory",
+      "content": "standalone durable memory bullet without '-'",
+      "confidence": 0.0,
+      "necessity": "low|medium|high",
+      "reason": "why it should or should not be stored"
+    }
+  ],
+  "skillCandidates": [
+    {
+      "action": "create|patch|write_file",
+      "name": "skill-name",
+      "content": "full SKILL.md or supporting file content",
+      "filePath": "optional supporting file path",
+      "find": "exact patch find text",
+      "replace": "exact patch replacement text",
+      "confidence": 0.0,
+      "necessity": "low|medium|high",
+      "reason": "why this procedural memory matters"
+    }
+  ],
+  "discarded": [{"content": "string", "reason": "string"}]
+}
+
+Rules:
+- Channel MEMORY.md is only for durable facts, durable decisions, user/team preferences, stable constraints, and medium-horizon open loops.
+- Do not promote current step-by-step execution state, short-lived debugging observations, completed worklog, or acknowledgement chatter.
+- Workspace skills are procedural memory: reusable workflows, checklists, playbooks, templates, or scripts.
+- Propose skill writes only when the workflow is clearly reusable across future tasks.
+- Use action=create only for new self-contained skills with YAML frontmatter and a non-empty body.
+- Skill names must be lowercase kebab-case.
+- Be conservative. Empty arrays are correct when nothing should be stored.`;
+function normalizeConfidence(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0;
+}
+function normalizeNecessity(value) {
+    return value === "high" || value === "medium" || value === "low" ? value : "low";
+}
+function normalizeMemoryCandidate(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (value.target !== "channel-memory") {
+        return null;
+    }
+    const target = "channel-memory";
+    const content = typeof value.content === "string" ? value.content.trim() : "";
+    if (!content) {
+        return null;
+    }
+    return {
+        target,
+        content,
+        confidence: normalizeConfidence(value.confidence),
+        necessity: normalizeNecessity(value.necessity),
+        reason: typeof value.reason === "string" ? value.reason.trim() : "",
+    };
+}
+function normalizeSkillCandidate(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const action = value.action;
+    if (action !== "create" && action !== "patch" && action !== "write_file") {
+        return null;
+    }
+    const name = typeof value.name === "string" ? value.name.trim() : "";
+    if (!name) {
+        return null;
+    }
+    return {
+        action,
+        name,
+        content: typeof value.content === "string" ? value.content : undefined,
+        filePath: typeof value.filePath === "string" ? value.filePath : undefined,
+        find: typeof value.find === "string" ? value.find : undefined,
+        replace: typeof value.replace === "string" ? value.replace : undefined,
+        confidence: normalizeConfidence(value.confidence),
+        necessity: normalizeNecessity(value.necessity),
+        reason: typeof value.reason === "string" ? value.reason.trim() : "",
+    };
+}
+export function parsePostTurnReviewResult(value) {
+    const record = isRecord(value) ? value : {};
+    const memoryCandidates = Array.isArray(record.memoryCandidates)
+        ? record.memoryCandidates.map(normalizeMemoryCandidate).filter((item) => !!item)
+        : [];
+    const skillCandidates = Array.isArray(record.skillCandidates)
+        ? record.skillCandidates.map(normalizeSkillCandidate).filter((item) => !!item)
+        : [];
+    const discarded = Array.isArray(record.discarded)
+        ? record.discarded
+            .filter(isRecord)
+            .map((item) => ({
+            content: typeof item.content === "string" ? item.content : "",
+            reason: typeof item.reason === "string" ? item.reason : "",
+        }))
+            .filter((item) => item.content.trim() || item.reason.trim())
+        : [];
+    return { memoryCandidates, skillCandidates, discarded };
+}
+async function runPostTurnReviewWorker(options) {
+    const [currentSession, currentMemory, currentHistory] = await Promise.all([
+        readChannelSession(options.channelDir),
+        readChannelMemory(options.channelDir),
+        readChannelHistory(options.channelDir),
+    ]);
+    const transcript = clipText(serializeConversation(buildStandardMessages(options.messages)), 22_000, {
+        headRatio: 0.35,
+    });
+    const skills = options.loadedSkills
+        .map((skill) => `- ${skill.name}${skill.description ? `: ${skill.description}` : ""}`)
+        .join("\n");
+    const prompt = `Current SESSION.md:
+${clipText(currentSession, 6_000, { headRatio: 0.5 }) || "(empty)"}
+
+Current channel MEMORY.md:
+${clipText(currentMemory, 6_000, { headRatio: 0.5 }) || "(empty)"}
+
+Current channel HISTORY.md:
+${clipText(currentHistory, 2_000, { headRatio: 0.3 }) || "(empty)"}
+
+Loaded workspace skills:
+${skills || "(none)"}
+
+Recent transcript:
+${transcript || "(empty)"}`;
+    const result = await runRetriedSidecarTask({
+        name: "memory-post-turn-review",
+        model: options.model,
+        resolveApiKey: options.resolveApiKey,
+        systemPrompt: POST_TURN_REVIEW_SYSTEM_PROMPT,
+        prompt,
+        timeoutMs: options.timeoutMs,
+        parse: (text) => parsePostTurnReviewResult(parseJsonObject(text)),
+    });
+    return result.output;
+}
+async function applyMemoryCandidate(options, candidate, result, timestamp) {
+    if (!options.autoWriteChannelMemory || !shouldAutoWriteMemory(candidate, options.minMemoryAutoWriteConfidence)) {
+        result.suggestions.push({ type: "memory", candidate });
+        return;
+    }
+    await appendChannelMemoryUpdate(options.channelDir, {
+        timestamp,
+        entries: [candidate.content],
+    });
+    const action = { target: "MEMORY.md", action: "append", content: candidate.content, reason: candidate.reason };
+    result.actions.push(action);
+    result.notices.push("已沉淀：更新 channel memory。");
+}
+async function applySkillCandidate(options, candidate, result) {
+    if (!options.autoWriteWorkspaceSkills || !shouldAutoWriteSkill(candidate, options.minSkillAutoWriteConfidence)) {
+        result.suggestions.push({ type: "skill", candidate });
+        return;
+    }
+    try {
+        const managed = await manageWorkspaceSkill({ workspaceDir: options.workspaceDir, workspacePath: options.workspacePath }, {
+            action: candidate.action,
+            name: candidate.name,
+            content: candidate.content,
+            filePath: candidate.filePath,
+            find: candidate.find,
+            replace: candidate.replace,
+        });
+        result.actions.push({ target: "workspace-skill", ...managed, reason: candidate.reason });
+        result.notices.push(managed.notice);
+        if (managed.requiresResourceRefresh && options.refreshWorkspaceResources) {
+            await options.refreshWorkspaceResources();
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result.skipped.push({ type: "skill", candidate, reason: message });
+        result.suggestions.push({ type: "skill", candidate, blockedReason: message });
+    }
+}
+export async function applyPostTurnReviewResult(options, review) {
+    const timestamp = new Date().toISOString();
+    const result = {
+        actions: [],
+        suggestions: [],
+        skipped: [],
+        notices: [],
+    };
+    for (const candidate of review.memoryCandidates) {
+        await applyMemoryCandidate(options, candidate, result, timestamp);
+    }
+    for (const candidate of review.skillCandidates) {
+        await applySkillCandidate(options, candidate, result);
+    }
+    for (const discarded of review.discarded) {
+        result.skipped.push({ type: "discarded", ...discarded });
+    }
+    await appendMemoryReviewLog(options.channelDir, {
+        timestamp,
+        channelId: options.channelId,
+        reason: "post-turn",
+        candidates: [...review.memoryCandidates, ...review.skillCandidates],
+        actions: result.actions,
+        suggestions: result.suggestions,
+        skipped: result.skipped,
+    });
+    for (const notice of Array.from(new Set(result.notices))) {
+        try {
+            await options.emitNotice?.(notice);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    return result;
+}
+export async function runPostTurnReview(options) {
+    try {
+        const review = await runPostTurnReviewWorker(options);
+        return await applyPostTurnReviewResult(options, review);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await appendMemoryReviewLog(options.channelDir, {
+            timestamp: new Date().toISOString(),
+            channelId: options.channelId,
+            reason: "post-turn",
+            error: message,
+            skipped: [{ target: "post-turn-review", reason: "failed" }],
+        });
+        return { actions: [], suggestions: [], skipped: [{ reason: message }], notices: [] };
+    }
+}

package/dist/memory/promotion-signals.d.ts

@@ -0,0 +1,5 @@
+export interface PromotionSignalScanResult {
+    hasSignal: boolean;
+    matchedSignals: string[];
+}
+export declare function scanPromotionSignals(text: string): PromotionSignalScanResult;

package/dist/memory/promotion-signals.js

@@ -0,0 +1,34 @@
+const PROMOTION_SIGNAL_PATTERNS = [
+    /以后/,
+    /默认/,
+    /记住/,
+    /偏好/,
+    /决定/,
+    /确认/,
+    /采用/,
+    /不再/,
+    /流程/,
+    /步骤/,
+    /规范/,
+    /checklist/i,
+    /每次/,
+    /后续/,
+    /待办/,
+    /需要跟进/,
+    /\bprefer(?:s|red|ence)?\b/i,
+    /\bdefault\b/i,
+    /\bremember\b/i,
+    /\bdecision\b/i,
+    /\badopt\b/i,
+    /\bworkflow\b/i,
+    /\bprocess\b/i,
+    /\bnext steps?\b/i,
+    /\bfollow[- ]?up\b/i,
+];
+export function scanPromotionSignals(text) {
+    const matchedSignals = PROMOTION_SIGNAL_PATTERNS.filter((pattern) => pattern.test(text)).map((pattern) => pattern.toString());
+    return {
+        hasSignal: matchedSignals.length > 0,
+        matchedSignals,
+    };
+}

package/dist/memory/promotion.d.ts

@@ -0,0 +1,32 @@
+export type MemoryPromotionTarget = "channel-memory";
+export type SkillPromotionAction = "create" | "patch" | "write_file";
+export interface MemoryPromotionCandidate {
+    target: MemoryPromotionTarget;
+    content: string;
+    confidence: number;
+    reason: string;
+    necessity: "low" | "medium" | "high";
+}
+export interface SkillPromotionCandidate {
+    action: SkillPromotionAction;
+    name: string;
+    content?: string;
+    filePath?: string;
+    find?: string;
+    replace?: string;
+    confidence: number;
+    necessity: "low" | "medium" | "high";
+    reason: string;
+}
+export interface PostTurnReviewResult {
+    memoryCandidates: MemoryPromotionCandidate[];
+    skillCandidates: SkillPromotionCandidate[];
+    discarded: Array<{
+        content: string;
+        reason: string;
+    }>;
+}
+export declare const DEFAULT_MEMORY_AUTO_WRITE_CONFIDENCE = 0.85;
+export declare const DEFAULT_SKILL_AUTO_WRITE_CONFIDENCE = 0.9;
+export declare function shouldAutoWriteMemory(candidate: MemoryPromotionCandidate, threshold?: number): boolean;
+export declare function shouldAutoWriteSkill(candidate: SkillPromotionCandidate, threshold?: number): boolean;

package/dist/memory/promotion.js

@@ -0,0 +1,11 @@
+export const DEFAULT_MEMORY_AUTO_WRITE_CONFIDENCE = 0.85;
+export const DEFAULT_SKILL_AUTO_WRITE_CONFIDENCE = 0.9;
+function isHighNecessity(value) {
+    return value === "high";
+}
+export function shouldAutoWriteMemory(candidate, threshold = DEFAULT_MEMORY_AUTO_WRITE_CONFIDENCE) {
+    return (candidate.confidence >= threshold && isHighNecessity(candidate.necessity) && candidate.content.trim().length > 0);
+}
+export function shouldAutoWriteSkill(candidate, threshold = DEFAULT_SKILL_AUTO_WRITE_CONFIDENCE) {
+    return candidate.confidence >= threshold && candidate.necessity === "high";
+}

package/dist/memory/recall.d.ts

@@ -8,7 +8,7 @@ export interface RecallRequest {
     maxCandidates: number;
     maxInjected: number;
     maxChars: number;
-    rerankWithModel: boolean;
+    rerankWithModel: boolean | "auto";
     autoRerank?: boolean;
     model: Model<Api>;
     resolveApiKey: (model: Model<Api>) => Promise<string>;

package/dist/memory/recall.js

@@ -19,6 +19,8 @@ const TOKEN_PART_REGEX = /[\p{Script=Han}]+|[\p{L}\p{N}_./-]+/gu;
 const ASCII_SPLIT_REGEX = /[._/-]+/g;
 const MEMORY_RECALL_RERANK_TIMEOUT_MS = 8_000;
 const RERANK_CONTENT_CLIP = 800;
+const HIGH_CONFIDENCE_SCORE = 36;
+const CLOSE_SCORE_DELTA = 8;
 const MAX_HAN_WORD_LENGTH = Array.from(COMMON_CHINESE_WORDS).reduce((max, word) => Math.max(max, word.length), 2);
 const LATIN_STOP_WORDS = new Set([
     "a",
@@ -383,7 +385,7 @@ function seedIntentCandidates(request, candidates, existing, intents, queryToken
     return seeded;
 }
 async function rerankCandidates(request, candidates) {
-    if ((!request.rerankWithModel && !request.autoRerank) || candidates.length <= request.maxInjected) {
+    if (!shouldUseModelRerank(request, candidates)) {
         return candidates;
     }
     const renderedCandidates = candidates
@@ -429,6 +431,36 @@ async function rerankCandidates(request, candidates) {
         return candidates;
     }
 }
+function hasMemorySensitiveQueryIntent(query) {
+    if (HAN_REGEX.test(query)) {
+        return /(之前|上次|记得|记住|偏好|决定|历史|纠正|不要再|以后|默认)/.test(query);
+    }
+    return /\b(previous|previously|last time|remember|preference|decision|history|correction|again|default)\b/i.test(query);
+}
+function shouldUseModelRerank(request, candidates) {
+    if (candidates.length <= request.maxInjected) {
+        return false;
+    }
+    if (request.rerankWithModel === true) {
+        return true;
+    }
+    if (request.rerankWithModel === false && !request.autoRerank) {
+        return false;
+    }
+    const top = candidates[0];
+    const next = candidates[1];
+    if (!top || !next) {
+        return false;
+    }
+    const highLocalConfidence = top.score >= HIGH_CONFIDENCE_SCORE && top.score - next.score >= CLOSE_SCORE_DELTA;
+    if (highLocalConfidence) {
+        return false;
+    }
+    if (!request.autoRerank && !hasMemorySensitiveQueryIntent(request.query)) {
+        return false;
+    }
+    return true;
+}
 function renderRecallResult(items, maxChars) {
     if (items.length === 0) {
         return "";

package/dist/memory/review-log.d.ts

@@ -0,0 +1,13 @@
+export type MemoryReviewReason = "idle" | "compaction" | "new-session" | "shutdown" | "post-turn" | "session-refresh-job" | "durable-consolidation-job" | "growth-review-job" | "structural-maintenance-job";
+export interface MemoryReviewLogEntry {
+    timestamp: string;
+    channelId: string;
+    reason: MemoryReviewReason;
+    candidates?: unknown[];
+    actions?: unknown[];
+    suggestions?: unknown[];
+    skipped?: unknown[];
+    error?: string;
+}
+export declare function getMemoryReviewLogPath(channelDir: string): string;
+export declare function appendMemoryReviewLog(channelDir: string, entry: MemoryReviewLogEntry): Promise<void>;

package/dist/memory/review-log.js

@@ -0,0 +1,38 @@
+import { appendFile, mkdir, readFile, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { writeFileAtomically } from "../shared/atomic-file.js";
+import { createSerialQueue } from "../shared/serial-queue.js";
+const REVIEW_LOG_MAX_BYTES = 1_024 * 1_024; // 1 MB
+const writeQueue = createSerialQueue();
+export function getMemoryReviewLogPath(channelDir) {
+    return join(channelDir, "memory-review.jsonl");
+}
+async function rotateIfNeeded(path, incomingBytes) {
+    try {
+        const stats = await stat(path);
+        if (stats.size + incomingBytes < REVIEW_LOG_MAX_BYTES) {
+            return;
+        }
+        const rotated = `${path}.1`;
+        const current = await readFile(path, "utf-8");
+        const lines = current.split("\n").filter(Boolean);
+        const keepLines = lines.slice(-Math.floor(lines.length / 2));
+        await writeFileAtomically(rotated, keepLines.length > 0 ? `${keepLines.join("\n")}\n` : "");
+        await writeFileAtomically(path, "");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return;
+        }
+        // Rotation failure is non-fatal
+    }
+}
+export async function appendMemoryReviewLog(channelDir, entry) {
+    const path = getMemoryReviewLogPath(channelDir);
+    const line = `${JSON.stringify(entry)}\n`;
+    await writeQueue.run(path, async () => {
+        await mkdir(dirname(path), { recursive: true });
+        await rotateIfNeeded(path, Buffer.byteLength(line, "utf-8"));
+        await appendFile(path, line, "utf-8");
+    });
+}

package/dist/memory/scheduler.d.ts

@@ -0,0 +1,52 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { Api, Model } from "@mariozechner/pi-ai";
+import type { SessionEntry } from "@mariozechner/pi-coding-agent";
+import type { PipiclawMemoryGrowthSettings, PipiclawMemoryMaintenanceSettings, PipiclawSessionMemorySettings } from "../settings.js";
+export interface MemoryMaintenanceRuntimeContext {
+    channelId: string;
+    channelDir: string;
+    workspaceDir: string;
+    workspacePath: string;
+    messages: AgentMessage[];
+    sessionEntries: SessionEntry[];
+    model: Model<Api>;
+    resolveApiKey: (model: Model<Api>) => Promise<string>;
+    settings: {
+        sessionMemory: PipiclawSessionMemorySettings;
+        memoryGrowth: PipiclawMemoryGrowthSettings;
+        memoryMaintenance: PipiclawMemoryMaintenanceSettings;
+    };
+    loadedSkills: Array<{
+        name: string;
+        description?: string;
+    }>;
+    refreshWorkspaceResources?: () => Promise<void>;
+}
+export interface MemoryMaintenanceSchedulerOptions {
+    appHomeDir: string;
+    workspaceDir: string;
+    getKnownChannelIds?: () => Iterable<string>;
+    getRuntimeContext: (channelId: string) => Promise<MemoryMaintenanceRuntimeContext | null>;
+    isChannelActive: (channelId: string) => boolean;
+    getSettings: () => {
+        memoryMaintenance: PipiclawMemoryMaintenanceSettings;
+    };
+    emitNotice?: (channelId: string, notice: string) => Promise<void>;
+    intervalMs?: number;
+}
+export declare function discoverMemoryMaintenanceChannels(input: {
+    appHomeDir: string;
+    workspaceDir: string;
+    knownChannelIds?: Iterable<string>;
+}): Promise<string[]>;
+export declare class MemoryMaintenanceScheduler {
+    private readonly options;
+    private timer;
+    private running;
+    private nextChannelIndex;
+    constructor(options: MemoryMaintenanceSchedulerOptions);
+    start(): void;
+    stop(): void;
+    runOnce(now?: Date): Promise<void>;
+    private runChannelOnce;
+}

package/dist/memory/scheduler.js

@@ -0,0 +1,152 @@
+import { readdir } from "node:fs/promises";
+import { basename } from "node:path";
+import * as log from "../log.js";
+import { runDurableConsolidationJob, runGrowthReviewJob, runSessionRefreshJob, runStructuralMaintenanceJob, } from "./maintenance-jobs.js";
+import { getMemoryMaintenanceStateDir } from "./maintenance-state.js";
+const DEFAULT_TICK_INTERVAL_MS = 60_000;
+const CHANNEL_ID_PATTERN = /^(dm|group)_[A-Za-z0-9._:-]+$/;
+function isChannelId(value) {
+    return CHANNEL_ID_PATTERN.test(value);
+}
+async function listWorkspaceChannels(workspaceDir) {
+    try {
+        const entries = await readdir(workspaceDir, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory() && isChannelId(entry.name)).map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function listStateChannels(appHomeDir) {
+    try {
+        const entries = await readdir(getMemoryMaintenanceStateDir(appHomeDir), { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => basename(entry.name, ".json"))
+            .filter(isChannelId);
+    }
+    catch {
+        return [];
+    }
+}
+export async function discoverMemoryMaintenanceChannels(input) {
+    const channels = new Set();
+    for (const channelId of input.knownChannelIds ?? []) {
+        if (isChannelId(channelId)) {
+            channels.add(channelId);
+        }
+    }
+    for (const channelId of await listWorkspaceChannels(input.workspaceDir)) {
+        channels.add(channelId);
+    }
+    for (const channelId of await listStateChannels(input.appHomeDir)) {
+        channels.add(channelId);
+    }
+    return Array.from(channels).sort();
+}
+function normalizeMaxConcurrentChannels(value) {
+    return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : 1;
+}
+export class MemoryMaintenanceScheduler {
+    constructor(options) {
+        this.options = options;
+        this.timer = null;
+        this.running = false;
+        this.nextChannelIndex = 0;
+    }
+    start() {
+        if (this.timer || !this.options.getSettings().memoryMaintenance.enabled) {
+            return;
+        }
+        this.timer = setInterval(() => {
+            void this.runOnce().catch((error) => {
+                log.logWarning("Memory maintenance scheduler tick failed", error instanceof Error ? error.message : String(error));
+            });
+        }, this.options.intervalMs ?? DEFAULT_TICK_INTERVAL_MS);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (!this.timer) {
+            return;
+        }
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+    async runOnce(now = new Date()) {
+        const settings = this.options.getSettings().memoryMaintenance;
+        if (!settings.enabled || this.running) {
+            return;
+        }
+        this.running = true;
+        try {
+            const channelIds = await discoverMemoryMaintenanceChannels({
+                appHomeDir: this.options.appHomeDir,
+                workspaceDir: this.options.workspaceDir,
+                knownChannelIds: this.options.getKnownChannelIds?.(),
+            });
+            const maxConcurrent = normalizeMaxConcurrentChannels(settings.maxConcurrentChannels);
+            if (channelIds.length === 0) {
+                return;
+            }
+            const selected = [];
+            let scanned = 0;
+            let index = this.nextChannelIndex % channelIds.length;
+            while (scanned < channelIds.length && selected.length < maxConcurrent) {
+                const channelId = channelIds[index];
+                if (channelId && !this.options.isChannelActive(channelId)) {
+                    selected.push(channelId);
+                }
+                index = (index + 1) % channelIds.length;
+                scanned++;
+            }
+            this.nextChannelIndex = index;
+            await Promise.all(selected.map((channelId) => this.runChannelOnce(channelId, now)));
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async runChannelOnce(channelId, now) {
+        if (this.options.isChannelActive(channelId)) {
+            return;
+        }
+        const context = await this.options.getRuntimeContext(channelId);
+        if (!context) {
+            return;
+        }
+        const common = {
+            appHomeDir: this.options.appHomeDir,
+            channelId,
+            channelDir: context.channelDir,
+            channelActive: this.options.isChannelActive(channelId),
+            now,
+            settings: context.settings,
+            model: context.model,
+            resolveApiKey: context.resolveApiKey,
+            messages: context.messages,
+            sessionEntries: context.sessionEntries,
+        };
+        const session = await runSessionRefreshJob(common);
+        if (session.ran) {
+            return;
+        }
+        const durable = await runDurableConsolidationJob(common);
+        if (durable.ran) {
+            return;
+        }
+        const growth = await runGrowthReviewJob({
+            ...common,
+            workspaceDir: context.workspaceDir,
+            workspacePath: context.workspacePath,
+            loadedSkills: context.loadedSkills,
+            emitNotice: this.options.emitNotice
+                ? async (notice) => this.options.emitNotice?.(channelId, notice)
+                : undefined,
+            refreshWorkspaceResources: context.refreshWorkspaceResources,
+        });
+        if (growth.ran) {
+            return;
+        }
+        await runStructuralMaintenanceJob(common);
+    }
+}

package/dist/memory/session-corpus.d.ts

@@ -0,0 +1,18 @@
+export type SessionSearchSource = "context" | "session" | "log";
+export type SessionSearchRole = "user" | "assistant" | "tool" | "system" | "unknown";
+export interface SessionSearchDocument {
+    id: string;
+    source: SessionSearchSource;
+    path: string;
+    timestamp?: string;
+    role: SessionSearchRole;
+    text: string;
+    sessionId?: string;
+}
+export interface BuildSessionCorpusOptions {
+    channelDir: string;
+    maxFiles: number;
+    maxCharsPerDocument?: number;
+    maxDocumentsTotal?: number;
+}
+export declare function buildSessionCorpus(options: BuildSessionCorpusOptions): Promise<SessionSearchDocument[]>;