@oyasmi/pipiclaw 0.5.1 → 0.5.3

package/dist/memory/recall.js

@@ -0,0 +1,501 @@
+import { parseJsonObject } from "../shared/llm-json.js";
+import { HAN_REGEX } from "../shared/text-utils.js";
+import { runSidecarTask } from "../sidecar-worker.js";
+import { buildMemoryCandidates } from "./candidates.js";
+import { COMMON_CHINESE_WORDS } from "./chinese-words.js";
+const RERANK_SYSTEM_PROMPT = `You are selecting which memory snippets are most relevant to the current user turn.
+
+Return strict JSON only:
+{
+  "selectedIds": ["candidate-id"]
+}
+
+Rules:
+- Select only snippets that are clearly useful for answering the current turn.
+- Prefer current work state, constraints, active files, recent corrections, and durable decisions.
+- If nothing is clearly useful, return an empty array.
+- Do not rewrite the candidates. Only return candidate ids.`;
+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 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",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "been",
+    "being",
+    "by",
+    "can",
+    "could",
+    "did",
+    "do",
+    "does",
+    "doing",
+    "for",
+    "from",
+    "had",
+    "has",
+    "have",
+    "here",
+    "how",
+    "i",
+    "in",
+    "is",
+    "it",
+    "its",
+    "me",
+    "my",
+    "of",
+    "on",
+    "or",
+    "our",
+    "please",
+    "should",
+    "that",
+    "the",
+    "their",
+    "them",
+    "there",
+    "these",
+    "they",
+    "this",
+    "to",
+    "was",
+    "we",
+    "were",
+    "what",
+    "when",
+    "where",
+    "which",
+    "who",
+    "why",
+    "with",
+    "would",
+    "you",
+    "your",
+]);
+const CHINESE_STOP_CHARS = new Set([
+    "的",
+    "了",
+    "在",
+    "是",
+    "有",
+    "不",
+    "和",
+    "与",
+    "个",
+    "把",
+    "被",
+    "从",
+    "对",
+    "而",
+    "给",
+    "将",
+    "就",
+    "让",
+    "向",
+    "也",
+    "以",
+    "因",
+    "又",
+    "于",
+    "则",
+    "之",
+    "这",
+    "那",
+    "其",
+    "它",
+    "他",
+    "她",
+    "们",
+    "都",
+    "要",
+    "会",
+    "能",
+    "很",
+    "得",
+    "地",
+    "着",
+    "过",
+    "吗",
+    "呢",
+    "吧",
+    "啊",
+    "哦",
+    "嗯",
+    "呀",
+]);
+function containsHanText(text) {
+    return HAN_REGEX.test(text);
+}
+function tokenizeHanPart(part) {
+    const chars = Array.from(part);
+    const covered = new Uint8Array(chars.length);
+    const tokens = [];
+    for (let index = 0; index < chars.length; index++) {
+        let matchedLength = 0;
+        const maxLength = Math.min(MAX_HAN_WORD_LENGTH, chars.length - index);
+        for (let size = maxLength; size >= 2; size--) {
+            const candidate = chars.slice(index, index + size).join("");
+            if (COMMON_CHINESE_WORDS.has(candidate)) {
+                tokens.push(candidate);
+                matchedLength = size;
+                break;
+            }
+        }
+        if (matchedLength > 0) {
+            for (let coveredIndex = index; coveredIndex < index + matchedLength; coveredIndex++) {
+                covered[coveredIndex] = 1;
+            }
+        }
+    }
+    for (let index = 0; index <= chars.length - 2; index++) {
+        if (covered[index] || covered[index + 1]) {
+            continue;
+        }
+        tokens.push(chars.slice(index, index + 2).join(""));
+    }
+    for (let index = 0; index < chars.length; index++) {
+        if (covered[index]) {
+            continue;
+        }
+        const char = chars[index];
+        if (!CHINESE_STOP_CHARS.has(char)) {
+            tokens.push(char);
+        }
+    }
+    return Array.from(new Set(tokens));
+}
+function tokenizeAsciiPart(part) {
+    const tokens = [];
+    const normalized = part.toLowerCase();
+    const segments = normalized.split(ASCII_SPLIT_REGEX).filter(Boolean);
+    if (normalized.length >= 2 && !LATIN_STOP_WORDS.has(normalized)) {
+        tokens.push(normalized);
+    }
+    for (const segment of segments) {
+        if (segment.length >= 2 && !LATIN_STOP_WORDS.has(segment)) {
+            tokens.push(segment);
+        }
+    }
+    return tokens;
+}
+function tokenize(text) {
+    const parts = text.toLowerCase().match(TOKEN_PART_REGEX) ?? [];
+    const tokens = [];
+    for (const part of parts) {
+        if (containsHanText(part)) {
+            tokens.push(...tokenizeHanPart(part));
+            continue;
+        }
+        tokens.push(...tokenizeAsciiPart(part));
+    }
+    return Array.from(new Set(tokens));
+}
+export function tokenizeRecallText(text) {
+    return tokenize(text);
+}
+function buildTokenSet(text) {
+    return new Set(tokenize(text));
+}
+function computeTokenMatchStats(queryTokens, text) {
+    if (queryTokens.length === 0 || !text.trim()) {
+        return { matchedCount: 0, coverage: 0 };
+    }
+    const haystack = buildTokenSet(text);
+    let matchedCount = 0;
+    for (const token of queryTokens) {
+        if (haystack.has(token)) {
+            matchedCount++;
+        }
+    }
+    return {
+        matchedCount,
+        coverage: matchedCount / queryTokens.length,
+    };
+}
+function collectMatchingQueryTokens(queryTokens, texts) {
+    const haystack = new Set();
+    for (const text of texts) {
+        for (const token of tokenize(text)) {
+            haystack.add(token);
+        }
+    }
+    const matches = new Set();
+    for (const token of queryTokens) {
+        if (haystack.has(token)) {
+            matches.add(token);
+        }
+    }
+    return matches;
+}
+function computeExactMatchBoost(query, candidate) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery) {
+        return 0;
+    }
+    const minLength = containsHanText(normalizedQuery) ? 2 : 4;
+    if (normalizedQuery.length < minLength) {
+        return 0;
+    }
+    let boost = 0;
+    const scoringFields = [
+        [candidate.title, 12],
+        [candidate.searchText ?? candidate.content, 8],
+        [candidate.path, 4],
+    ];
+    for (const [field, value] of scoringFields) {
+        if (field.toLowerCase().includes(normalizedQuery)) {
+            boost += value;
+        }
+    }
+    return boost;
+}
+function computeRecencyBoost(timestamp) {
+    if (!timestamp)
+        return 0;
+    const timestampMs = Date.parse(timestamp);
+    if (!Number.isFinite(timestampMs))
+        return 0;
+    const ageMs = Date.now() - timestampMs;
+    const dayMs = 24 * 60 * 60 * 1000;
+    if (ageMs <= dayMs)
+        return 6;
+    if (ageMs <= 7 * dayMs)
+        return 4;
+    if (ageMs <= 30 * dayMs)
+        return 2;
+    return 0;
+}
+function detectQueryIntents(query) {
+    const intents = new Set();
+    if (/\b(now|current|currently|status)\b/i.test(query) || /(现在|当前|目前|正在|状态)/u.test(query)) {
+        intents.add("current-state");
+    }
+    if (/\b(next|follow-?up|todo|plan)\b/i.test(query) || /(下一步|接下来|后续|怎么办|怎么做|该查什么)/u.test(query)) {
+        intents.add("next-steps");
+    }
+    if (/\b(constraint|requirement|guardrail|compatible|compatibility)\b/i.test(query) ||
+        /(约束|限制|要求|兼容|注意事项)/u.test(query)) {
+        intents.add("constraints");
+    }
+    if (/\b(decision|decided|why)\b/i.test(query) || /(决策|决定|方案|为什么)/u.test(query)) {
+        intents.add("decisions");
+    }
+    if (/\b(error|bug|failure|issue|regression)\b/i.test(query) || /(错误|异常|失败|问题|缺陷|回归)/u.test(query)) {
+        intents.add("errors");
+    }
+    if (/\b(history|previous|before|earlier|past)\b/i.test(query) || /(历史|之前|以前|过去|早先|曾经)/u.test(query)) {
+        intents.add("history");
+    }
+    return intents;
+}
+function computeSectionIntentBoost(intents, candidate) {
+    const kind = candidate.sectionKind ?? "";
+    let boost = 0;
+    if (intents.has("current-state") && kind === "current state")
+        boost += 10;
+    if (intents.has("next-steps") && kind === "next steps")
+        boost += 10;
+    if (intents.has("constraints") && kind.includes("constraint"))
+        boost += 8;
+    if (intents.has("decisions") && kind.includes("decision"))
+        boost += 8;
+    if (intents.has("errors") && kind === "errors & corrections")
+        boost += 8;
+    if (intents.has("history") && candidate.source === "channel-history")
+        boost += 8;
+    return boost;
+}
+function compareScoredCandidates(a, b) {
+    return (b.score - a.score ||
+        b.lexicalMatchCount - a.lexicalMatchCount ||
+        b.candidate.priority - a.candidate.priority ||
+        a.candidate.title.localeCompare(b.candidate.title));
+}
+function scoreCandidate(query, queryTokens, intents, candidate) {
+    const searchText = candidate.searchText ?? candidate.content;
+    const titleStats = computeTokenMatchStats(queryTokens, candidate.title);
+    const contentStats = computeTokenMatchStats(queryTokens, searchText);
+    const pathStats = computeTokenMatchStats(queryTokens, candidate.path);
+    const matchedTokens = collectMatchingQueryTokens(queryTokens, [candidate.title, searchText, candidate.path]);
+    const exactBoost = computeExactMatchBoost(query, candidate);
+    const intentBoost = computeSectionIntentBoost(intents, candidate);
+    const overallCoverage = queryTokens.length > 0 ? matchedTokens.size / queryTokens.length : 0;
+    const lexicalScore = overallCoverage * 48 +
+        titleStats.coverage * 18 +
+        contentStats.coverage * 22 +
+        pathStats.coverage * 8 +
+        exactBoost;
+    const structuralScore = candidate.priority + intentBoost + computeRecencyBoost(candidate.timestamp);
+    if (matchedTokens.size === 0 && exactBoost === 0) {
+        return null;
+    }
+    return {
+        candidate,
+        score: lexicalScore * (1 + structuralScore / 100),
+        lexicalMatchCount: matchedTokens.size,
+        intentBoost,
+    };
+}
+function seedIntentCandidates(request, candidates, existing, intents, queryTokens) {
+    if (intents.size === 0) {
+        return existing;
+    }
+    const seen = new Set(existing.map(({ candidate }) => candidate.id));
+    const seeded = [...existing];
+    const limit = Math.max(request.maxCandidates, request.maxInjected);
+    const intentCandidates = candidates
+        .map((candidate) => ({
+        candidate,
+        intentBoost: computeSectionIntentBoost(intents, candidate),
+    }))
+        .filter(({ candidate, intentBoost }) => intentBoost > 0 && !seen.has(candidate.id))
+        .sort((a, b) => b.intentBoost - a.intentBoost ||
+        b.candidate.priority - a.candidate.priority ||
+        a.candidate.title.localeCompare(b.candidate.title));
+    for (const { candidate, intentBoost } of intentCandidates) {
+        const matchedTokens = collectMatchingQueryTokens(queryTokens, [
+            candidate.title,
+            candidate.searchText ?? candidate.content,
+        ]);
+        if (matchedTokens.size === 0) {
+            continue;
+        }
+        seeded.push({
+            candidate,
+            score: (intentBoost + matchedTokens.size * 8) *
+                (1 + (candidate.priority + computeRecencyBoost(candidate.timestamp)) / 100),
+            lexicalMatchCount: matchedTokens.size,
+            intentBoost,
+        });
+        seen.add(candidate.id);
+        if (seeded.length >= limit) {
+            break;
+        }
+    }
+    return seeded;
+}
+async function rerankCandidates(request, candidates) {
+    if ((!request.rerankWithModel && !request.autoRerank) || candidates.length <= request.maxInjected) {
+        return candidates;
+    }
+    const renderedCandidates = candidates
+        .map(({ candidate, score, lexicalMatchCount, intentBoost }) => {
+        const clippedContent = candidate.content.length > RERANK_CONTENT_CLIP
+            ? `${candidate.content.slice(0, RERANK_CONTENT_CLIP)}...`
+            : candidate.content;
+        return [
+            `id: ${candidate.id}`,
+            `source: ${candidate.source}`,
+            `title: ${candidate.title}`,
+            `path: ${candidate.path}`,
+            `score: ${score}`,
+            `lexicalMatchCount: ${lexicalMatchCount}`,
+            `intentBoost: ${intentBoost}`,
+            `content: ${clippedContent}`,
+        ].join("\n");
+    })
+        .join("\n\n---\n\n");
+    try {
+        const result = await runSidecarTask({
+            name: "memory-recall-rerank",
+            model: request.model,
+            resolveApiKey: request.resolveApiKey,
+            systemPrompt: RERANK_SYSTEM_PROMPT,
+            prompt: `User turn:\n${request.query.trim()}\n\nCandidates:\n${renderedCandidates}`,
+            timeoutMs: MEMORY_RECALL_RERANK_TIMEOUT_MS,
+            parse: (text) => {
+                const parsed = parseJsonObject(text);
+                return Array.isArray(parsed.selectedIds)
+                    ? parsed.selectedIds.filter((id) => typeof id === "string" && id.trim().length > 0)
+                    : [];
+            },
+        });
+        const selectedIds = new Set(result.output);
+        if (selectedIds.size === 0) {
+            return candidates;
+        }
+        const selected = candidates.filter(({ candidate }) => selectedIds.has(candidate.id));
+        return selected.length > 0 ? selected : candidates;
+    }
+    catch {
+        return candidates;
+    }
+}
+function renderRecallResult(items, maxChars) {
+    if (items.length === 0) {
+        return "";
+    }
+    const lines = ["<runtime_context>", "Relevant context for this turn:"];
+    for (const item of items) {
+        lines.push("");
+        lines.push(`[${item.source}/${item.title}]`);
+        lines.push(`Path: ${item.path}`);
+        lines.push(item.content);
+    }
+    lines.push("</runtime_context>");
+    const rendered = lines.join("\n");
+    if (rendered.length <= maxChars) {
+        return rendered;
+    }
+    const clippedLines = ["<runtime_context>", "Relevant context for this turn:"];
+    let usedChars = clippedLines.join("\n").length + "</runtime_context>".length + 2;
+    for (const item of items) {
+        const block = ["", `[${item.source}/${item.title}]`, `Path: ${item.path}`, item.content].join("\n");
+        if (usedChars + block.length > maxChars) {
+            break;
+        }
+        clippedLines.push("", `[${item.source}/${item.title}]`, `Path: ${item.path}`, item.content);
+        usedChars += block.length;
+    }
+    clippedLines.push("</runtime_context>");
+    return clippedLines.join("\n");
+}
+export async function recallRelevantMemory(request) {
+    const query = request.query.trim();
+    if (!query) {
+        return { items: [], renderedText: "" };
+    }
+    const candidates = await buildMemoryCandidates({
+        workspaceDir: request.workspaceDir,
+        channelDir: request.channelDir,
+        cache: request.candidateCache,
+    });
+    const filteredCandidates = request.allowedSources?.length
+        ? candidates.filter((candidate) => request.allowedSources?.includes(candidate.source))
+        : candidates;
+    if (filteredCandidates.length === 0) {
+        return { items: [], renderedText: "" };
+    }
+    const queryTokens = tokenize(query);
+    const queryIntents = detectQueryIntents(query);
+    const scored = filteredCandidates
+        .map((candidate) => scoreCandidate(query, queryTokens, queryIntents, candidate))
+        .filter((candidate) => candidate !== null)
+        .sort(compareScoredCandidates);
+    const shortlist = seedIntentCandidates(request, filteredCandidates, scored, queryIntents, queryTokens)
+        .sort(compareScoredCandidates)
+        .slice(0, Math.max(request.maxCandidates, request.maxInjected));
+    if (shortlist.length === 0) {
+        return { items: [], renderedText: "" };
+    }
+    const reranked = await rerankCandidates(request, shortlist);
+    const items = reranked.slice(0, request.maxInjected).map(({ candidate, score }) => ({
+        source: candidate.source,
+        path: candidate.path,
+        title: candidate.title,
+        content: candidate.content,
+        score,
+    }));
+    return {
+        items,
+        renderedText: renderRecallResult(items, request.maxChars),
+    };
+}

package/dist/{session-memory.d.ts → memory/session.d.ts}

@@ -16,7 +16,7 @@ export interface SessionMemoryUpdateOptions {
     messages: AgentMessage[];
     model: Model<Api>;
     resolveApiKey: (model: Model<Api>) => Promise<string>;
+    timeoutMs?: number;
 }
 export declare function renderSessionMemory(state: SessionMemoryState): string;
 export declare function updateChannelSessionMemory(options: SessionMemoryUpdateOptions): Promise<SessionMemoryState>;
-//# sourceMappingURL=session-memory.d.ts.map

package/dist/{session-memory.js → memory/session.js}

@@ -1,16 +1,17 @@
 import { serializeConversation } from "@mariozechner/pi-coding-agent";
 import { writeFile } from "fs/promises";
 import { join } from "path";
-import { parseJsonObject } from "./llm-json.js";
-import { splitLevelOneSections } from "./markdown-sections.js";
-import { readChannelMemory } from "./memory-files.js";
-import { readChannelSession, rewriteChannelSession } from "./session-memory-files.js";
-import { runSidecarTask, SidecarParseError } from "./sidecar-worker.js";
+import { parseJsonObject } from "../shared/llm-json.js";
+import { splitH1Sections } from "../shared/markdown-sections.js";
+import { clipText } from "../shared/text-utils.js";
+import { buildStandardMessages, isRecord } from "../shared/type-guards.js";
+import { runSidecarTask, SidecarParseError } from "../sidecar-worker.js";
+import { readChannelMemory, readChannelSession, rewriteChannelSession } from "./files.js";
 const SESSION_TRANSCRIPT_MAX_CHARS = 20_000;
 const SESSION_MEMORY_MAX_CHARS = 4_000;
 const SESSION_ITEM_LIMIT = 12;
 const SESSION_ITEM_MAX_CHARS = 300;
-const SESSION_MEMORY_TIMEOUT_MS = 10_000;
+const DEFAULT_SESSION_MEMORY_TIMEOUT_MS = 30_000;
 const SESSION_MEMORY_SYSTEM_PROMPT = `You maintain a Pipiclaw SESSION.md file.
 
 Return strict JSON only. Do not use Markdown fences.
@@ -37,15 +38,6 @@ Rules:
 - "nextSteps" should reflect the most likely immediate follow-up actions.
 - "worklog" must stay terse and recent.
 - If a field has nothing useful, return an empty string or empty array.`;
-function clipText(text, maxChars) {
-    const normalized = text.replace(/\r/g, "").trim();
-    if (normalized.length <= maxChars) {
-        return normalized;
-    }
-    const headChars = Math.floor(maxChars * 0.45);
-    const tailChars = maxChars - headChars;
-    return `${normalized.slice(0, headChars)}\n\n[... omitted middle section ...]\n\n${normalized.slice(-tailChars)}`;
-}
 function normalizeItem(value) {
     if (typeof value !== "string") {
         return null;
@@ -70,33 +62,22 @@ function normalizeItems(value) {
 function normalizeTitle(value) {
     return typeof value === "string" ? value.trim().slice(0, 120) : "";
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
 function parseStateUpdate(text) {
     const parsed = parseJsonObject(text);
     if (!isRecord(parsed)) {
         throw new Error("Session memory response was not a JSON object");
     }
-    const next = {};
-    if ("title" in parsed)
-        next.title = normalizeTitle(parsed.title);
-    if ("currentState" in parsed)
-        next.currentState = normalizeItems(parsed.currentState);
-    if ("userIntent" in parsed)
-        next.userIntent = normalizeItems(parsed.userIntent);
-    if ("activeFiles" in parsed)
-        next.activeFiles = normalizeItems(parsed.activeFiles);
-    if ("decisions" in parsed)
-        next.decisions = normalizeItems(parsed.decisions);
-    if ("constraints" in parsed)
-        next.constraints = normalizeItems(parsed.constraints);
-    if ("errorsAndCorrections" in parsed)
-        next.errorsAndCorrections = normalizeItems(parsed.errorsAndCorrections);
-    if ("nextSteps" in parsed)
-        next.nextSteps = normalizeItems(parsed.nextSteps);
-    if ("worklog" in parsed)
-        next.worklog = normalizeItems(parsed.worklog);
+    const next = {
+        title: normalizeTitle(parsed.title),
+        currentState: normalizeItems(parsed.currentState),
+        userIntent: normalizeItems(parsed.userIntent),
+        activeFiles: normalizeItems(parsed.activeFiles),
+        decisions: normalizeItems(parsed.decisions),
+        constraints: normalizeItems(parsed.constraints),
+        errorsAndCorrections: normalizeItems(parsed.errorsAndCorrections),
+        nextSteps: normalizeItems(parsed.nextSteps),
+        worklog: normalizeItems(parsed.worklog),
+    };
     return next;
 }
 function createEmptySessionMemoryState() {
@@ -138,7 +119,7 @@ function parseSectionItems(content) {
 }
 function parseRenderedSessionMemory(markdown) {
     const state = createEmptySessionMemoryState();
-    for (const section of splitLevelOneSections(markdown)) {
+    for (const section of splitH1Sections(markdown)) {
         switch (section.heading.toLowerCase()) {
             case "session title":
                 state.title = stripHtmlComments(section.content).split("\n")[0]?.trim().slice(0, 120) || "";
@@ -171,19 +152,17 @@ function parseRenderedSessionMemory(markdown) {
     }
     return state;
 }
-function mergeSessionMemoryState(current, update) {
+function mergeSessionMemoryState(_current, update) {
     return {
-        title: typeof update.title === "string" ? update.title : current.title,
-        currentState: Array.isArray(update.currentState) ? update.currentState : current.currentState,
-        userIntent: Array.isArray(update.userIntent) ? update.userIntent : current.userIntent,
-        activeFiles: Array.isArray(update.activeFiles) ? update.activeFiles : current.activeFiles,
-        decisions: Array.isArray(update.decisions) ? update.decisions : current.decisions,
-        constraints: Array.isArray(update.constraints) ? update.constraints : current.constraints,
-        errorsAndCorrections: Array.isArray(update.errorsAndCorrections)
-            ? update.errorsAndCorrections
-            : current.errorsAndCorrections,
-        nextSteps: Array.isArray(update.nextSteps) ? update.nextSteps : current.nextSteps,
-        worklog: Array.isArray(update.worklog) ? update.worklog : current.worklog,
+        title: typeof update.title === "string" ? update.title : "",
+        currentState: Array.isArray(update.currentState) ? update.currentState : [],
+        userIntent: Array.isArray(update.userIntent) ? update.userIntent : [],
+        activeFiles: Array.isArray(update.activeFiles) ? update.activeFiles : [],
+        decisions: Array.isArray(update.decisions) ? update.decisions : [],
+        constraints: Array.isArray(update.constraints) ? update.constraints : [],
+        errorsAndCorrections: Array.isArray(update.errorsAndCorrections) ? update.errorsAndCorrections : [],
+        nextSteps: Array.isArray(update.nextSteps) ? update.nextSteps : [],
+        worklog: Array.isArray(update.worklog) ? update.worklog : [],
     };
 }
 async function writeSessionMemoryDebugFile(channelDir, error, rawText) {
@@ -200,15 +179,6 @@ async function writeSessionMemoryDebugFile(channelDir, error, rawText) {
 function renderSection(heading, items) {
     return [`# ${heading}`, "", ...items.map((item) => `- ${item}`)].join("\n");
 }
-function isStandardAgentMessage(message) {
-    return (typeof message === "object" &&
-        message !== null &&
-        "role" in message &&
-        (message.role === "user" || message.role === "assistant" || message.role === "toolResult"));
-}
-function buildMessagesForSessionMemory(messages) {
-    return messages.filter(isStandardAgentMessage);
-}
 export function renderSessionMemory(state) {
     const sections = [];
     if (state.title.trim()) {
@@ -246,7 +216,7 @@ ${transcript || "(empty)"}`;
 export async function updateChannelSessionMemory(options) {
     const currentSession = await readChannelSession(options.channelDir);
     const currentMemory = await readChannelMemory(options.channelDir);
-    const messages = buildMessagesForSessionMemory(options.messages);
+    const messages = buildStandardMessages(options.messages);
     const currentState = parseRenderedSessionMemory(currentSession);
     let update;
     try {
@@ -257,7 +227,7 @@ export async function updateChannelSessionMemory(options) {
             systemPrompt: SESSION_MEMORY_SYSTEM_PROMPT,
             prompt: buildSessionPrompt(currentSession, currentMemory, messages),
             parse: parseStateUpdate,
-            timeoutMs: SESSION_MEMORY_TIMEOUT_MS,
+            timeoutMs: options.timeoutMs ?? DEFAULT_SESSION_MEMORY_TIMEOUT_MS,
         });
         update = result.output;
     }
@@ -271,4 +241,3 @@ export async function updateChannelSessionMemory(options) {
     await rewriteChannelSession(options.channelDir, rendered);
     return parseRenderedSessionMemory(rendered);
 }
-//# sourceMappingURL=session-memory.js.map

package/dist/model-utils.d.ts

@@ -8,4 +8,3 @@ export declare function findExactModelReferenceMatch(modelReference: string, ava
 };
 export declare function formatModelList(models: Model<Api>[], currentModel: Model<Api> | undefined, limit?: number): string;
 export declare function resolveInitialModel(modelRegistry: ModelRegistry, settingsManager: PipiclawSettingsManager): Model<Api>;
-//# sourceMappingURL=model-utils.d.ts.map

package/dist/model-utils.js

@@ -70,4 +70,3 @@ export function resolveInitialModel(modelRegistry, settingsManager) {
     }
     return defaultModel;
 }
-//# sourceMappingURL=model-utils.js.map

package/dist/paths.d.ts

@@ -7,4 +7,3 @@ export declare const CHANNEL_CONFIG_PATH: string;
 export declare const AUTH_CONFIG_PATH: string;
 export declare const MODELS_CONFIG_PATH: string;
 export declare const SETTINGS_CONFIG_PATH: string;
-//# sourceMappingURL=paths.d.ts.map