clawdbot 2026.1.4-1

package/dist/auto-reply/reply/mentions.js

@@ -0,0 +1,38 @@
+export function stripStructuralPrefixes(text) {
+    // Ignore wrapper labels, timestamps, and sender prefixes so directive-only
+    // detection still works in group batches that include history/context.
+    const marker = "[Current message - respond to this]";
+    const afterMarker = text.includes(marker)
+        ? text.slice(text.indexOf(marker) + marker.length)
+        : text;
+    return afterMarker
+        .replace(/\[[^\]]+\]\s*/g, "")
+        .replace(/^[ \t]*[A-Za-z0-9+()\-_. ]+:\s*/gm, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function stripMentions(text, ctx, cfg) {
+    let result = text;
+    const patterns = cfg?.routing?.groupChat?.mentionPatterns ?? [];
+    for (const p of patterns) {
+        try {
+            const re = new RegExp(p, "gi");
+            result = result.replace(re, " ");
+        }
+        catch {
+            // ignore invalid regex
+        }
+    }
+    const selfE164 = (ctx.To ?? "").replace(/^whatsapp:/, "");
+    if (selfE164) {
+        const esc = selfE164.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        result = result
+            .replace(new RegExp(esc, "gi"), " ")
+            .replace(new RegExp(`@${esc}`, "gi"), " ");
+    }
+    // Generic mention patterns like @123456789 or plain digits
+    result = result.replace(/@[0-9+]{5,}/g, " ");
+    // Discord-style mentions (<@123> or <@!123>)
+    result = result.replace(/<@!?\d+>/g, " ");
+    return result.replace(/\s+/g, " ").trim();
+}

package/dist/auto-reply/reply/model-selection.js

@@ -0,0 +1,114 @@
+import { lookupContextTokens } from "../../agents/context.js";
+import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
+import { loadModelCatalog } from "../../agents/model-catalog.js";
+import { buildAllowedModelSet, modelKey, resolveModelRefFromString, resolveThinkingDefault, } from "../../agents/model-selection.js";
+import { saveSessionStore } from "../../config/sessions.js";
+export async function createModelSelectionState(params) {
+    const { cfg, agentCfg, sessionEntry, sessionStore, sessionKey, storePath, defaultProvider, } = params;
+    let provider = params.provider;
+    let model = params.model;
+    const hasAllowlist = (agentCfg?.allowedModels?.length ?? 0) > 0;
+    const hasStoredOverride = Boolean(sessionEntry?.modelOverride || sessionEntry?.providerOverride);
+    const needsModelCatalog = params.hasModelDirective || hasAllowlist || hasStoredOverride;
+    let allowedModelKeys = new Set();
+    let allowedModelCatalog = [];
+    let modelCatalog = null;
+    let resetModelOverride = false;
+    if (needsModelCatalog) {
+        modelCatalog = await loadModelCatalog({ config: cfg });
+        const allowed = buildAllowedModelSet({
+            cfg,
+            catalog: modelCatalog,
+            defaultProvider,
+        });
+        allowedModelCatalog = allowed.allowedCatalog;
+        allowedModelKeys = allowed.allowedKeys;
+    }
+    if (sessionEntry && sessionStore && sessionKey && hasStoredOverride) {
+        const overrideProvider = sessionEntry.providerOverride?.trim() || defaultProvider;
+        const overrideModel = sessionEntry.modelOverride?.trim();
+        if (overrideModel) {
+            const key = modelKey(overrideProvider, overrideModel);
+            if (allowedModelKeys.size > 0 && !allowedModelKeys.has(key)) {
+                delete sessionEntry.providerOverride;
+                delete sessionEntry.modelOverride;
+                sessionEntry.updatedAt = Date.now();
+                sessionStore[sessionKey] = sessionEntry;
+                if (storePath) {
+                    await saveSessionStore(storePath, sessionStore);
+                }
+                resetModelOverride = true;
+            }
+        }
+    }
+    const storedProviderOverride = sessionEntry?.providerOverride?.trim();
+    const storedModelOverride = sessionEntry?.modelOverride?.trim();
+    if (storedModelOverride) {
+        const candidateProvider = storedProviderOverride || defaultProvider;
+        const key = modelKey(candidateProvider, storedModelOverride);
+        if (allowedModelKeys.size === 0 || allowedModelKeys.has(key)) {
+            provider = candidateProvider;
+            model = storedModelOverride;
+        }
+    }
+    let defaultThinkingLevel;
+    const resolveDefaultThinkingLevel = async () => {
+        if (defaultThinkingLevel)
+            return defaultThinkingLevel;
+        let catalogForThinking = modelCatalog ?? allowedModelCatalog;
+        if (!catalogForThinking || catalogForThinking.length === 0) {
+            modelCatalog = await loadModelCatalog({ config: cfg });
+            catalogForThinking = modelCatalog;
+        }
+        defaultThinkingLevel = resolveThinkingDefault({
+            cfg,
+            provider,
+            model,
+            catalog: catalogForThinking,
+        });
+        return defaultThinkingLevel;
+    };
+    return {
+        provider,
+        model,
+        allowedModelKeys,
+        allowedModelCatalog,
+        resetModelOverride,
+        resolveDefaultThinkingLevel,
+        needsModelCatalog,
+    };
+}
+export function resolveModelDirectiveSelection(params) {
+    const { raw, defaultProvider, defaultModel, aliasIndex, allowedModelKeys } = params;
+    const resolved = resolveModelRefFromString({
+        raw,
+        defaultProvider,
+        aliasIndex,
+    });
+    if (!resolved) {
+        return {
+            error: `Unrecognized model "${raw}". Use /model to list available models.`,
+        };
+    }
+    const key = modelKey(resolved.ref.provider, resolved.ref.model);
+    if (allowedModelKeys.size > 0 && !allowedModelKeys.has(key)) {
+        return {
+            error: `Model "${resolved.ref.provider}/${resolved.ref.model}" is not allowed. Use /model to list available models.`,
+        };
+    }
+    const isDefault = resolved.ref.provider === defaultProvider &&
+        resolved.ref.model === defaultModel;
+    return {
+        selection: {
+            provider: resolved.ref.provider,
+            model: resolved.ref.model,
+            isDefault,
+            alias: resolved.alias,
+        },
+    };
+}
+export function resolveContextTokens(params) {
+    return (params.agentCfg?.contextTokens ??
+        lookupContextTokens(params.model) ??
+        DEFAULT_CONTEXT_TOKENS);
+}

package/dist/auto-reply/reply/queue.js

@@ -0,0 +1,399 @@
+import { parseDurationMs } from "../../cli/parse-duration.js";
+import { defaultRuntime } from "../../runtime.js";
+const DEFAULT_QUEUE_DEBOUNCE_MS = 1000;
+const DEFAULT_QUEUE_CAP = 20;
+const DEFAULT_QUEUE_DROP = "summarize";
+const FOLLOWUP_QUEUES = new Map();
+function normalizeQueueMode(raw) {
+    if (!raw)
+        return undefined;
+    const cleaned = raw.trim().toLowerCase();
+    if (cleaned === "queue" || cleaned === "queued")
+        return "steer";
+    if (cleaned === "interrupt" ||
+        cleaned === "interrupts" ||
+        cleaned === "abort")
+        return "interrupt";
+    if (cleaned === "steer" || cleaned === "steering")
+        return "steer";
+    if (cleaned === "followup" ||
+        cleaned === "follow-ups" ||
+        cleaned === "followups")
+        return "followup";
+    if (cleaned === "collect" || cleaned === "coalesce")
+        return "collect";
+    if (cleaned === "steer+backlog" ||
+        cleaned === "steer-backlog" ||
+        cleaned === "steer_backlog")
+        return "steer-backlog";
+    return undefined;
+}
+function normalizeQueueDropPolicy(raw) {
+    if (!raw)
+        return undefined;
+    const cleaned = raw.trim().toLowerCase();
+    if (cleaned === "old" || cleaned === "oldest")
+        return "old";
+    if (cleaned === "new" || cleaned === "newest")
+        return "new";
+    if (cleaned === "summarize" || cleaned === "summary")
+        return "summarize";
+    return undefined;
+}
+function parseQueueDebounce(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = parseDurationMs(raw.trim(), { defaultUnit: "ms" });
+        if (!parsed || parsed < 0)
+            return undefined;
+        return Math.round(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseQueueCap(raw) {
+    if (!raw)
+        return undefined;
+    const num = Number(raw);
+    if (!Number.isFinite(num))
+        return undefined;
+    const cap = Math.floor(num);
+    if (cap < 1)
+        return undefined;
+    return cap;
+}
+function parseQueueDirectiveArgs(raw) {
+    let i = 0;
+    const len = raw.length;
+    while (i < len && /\s/.test(raw[i]))
+        i += 1;
+    if (raw[i] === ":") {
+        i += 1;
+        while (i < len && /\s/.test(raw[i]))
+            i += 1;
+    }
+    let consumed = i;
+    let queueMode;
+    let queueReset = false;
+    let rawMode;
+    let debounceMs;
+    let cap;
+    let dropPolicy;
+    let rawDebounce;
+    let rawCap;
+    let rawDrop;
+    let hasOptions = false;
+    const takeToken = () => {
+        if (i >= len)
+            return null;
+        const start = i;
+        while (i < len && !/\s/.test(raw[i]))
+            i += 1;
+        if (start === i)
+            return null;
+        const token = raw.slice(start, i);
+        while (i < len && /\s/.test(raw[i]))
+            i += 1;
+        return token;
+    };
+    while (i < len) {
+        const token = takeToken();
+        if (!token)
+            break;
+        const lowered = token.trim().toLowerCase();
+        if (lowered === "default" || lowered === "reset" || lowered === "clear") {
+            queueReset = true;
+            consumed = i;
+            break;
+        }
+        if (lowered.startsWith("debounce:") || lowered.startsWith("debounce=")) {
+            rawDebounce = token.split(/[:=]/)[1] ?? "";
+            debounceMs = parseQueueDebounce(rawDebounce);
+            hasOptions = true;
+            consumed = i;
+            continue;
+        }
+        if (lowered.startsWith("cap:") || lowered.startsWith("cap=")) {
+            rawCap = token.split(/[:=]/)[1] ?? "";
+            cap = parseQueueCap(rawCap);
+            hasOptions = true;
+            consumed = i;
+            continue;
+        }
+        if (lowered.startsWith("drop:") || lowered.startsWith("drop=")) {
+            rawDrop = token.split(/[:=]/)[1] ?? "";
+            dropPolicy = normalizeQueueDropPolicy(rawDrop);
+            hasOptions = true;
+            consumed = i;
+            continue;
+        }
+        const mode = normalizeQueueMode(token);
+        if (mode) {
+            queueMode = mode;
+            rawMode = token;
+            consumed = i;
+            continue;
+        }
+        // Stop at first unrecognized token.
+        break;
+    }
+    return {
+        consumed,
+        queueMode,
+        queueReset,
+        rawMode,
+        debounceMs,
+        cap,
+        dropPolicy,
+        rawDebounce,
+        rawCap,
+        rawDrop,
+        hasOptions,
+    };
+}
+export function extractQueueDirective(body) {
+    if (!body)
+        return {
+            cleaned: "",
+            hasDirective: false,
+            queueReset: false,
+            hasOptions: false,
+        };
+    const re = /(?:^|\s)\/queue(?=$|\s|:)/i;
+    const match = re.exec(body);
+    if (!match) {
+        return {
+            cleaned: body.trim(),
+            hasDirective: false,
+            queueReset: false,
+            hasOptions: false,
+        };
+    }
+    const start = match.index + match[0].indexOf("/queue");
+    const argsStart = start + "/queue".length;
+    const args = body.slice(argsStart);
+    const parsed = parseQueueDirectiveArgs(args);
+    const cleanedRaw = body.slice(0, start) + body.slice(argsStart + parsed.consumed);
+    const cleaned = cleanedRaw.replace(/\s+/g, " ").trim();
+    return {
+        cleaned,
+        queueMode: parsed.queueMode,
+        queueReset: parsed.queueReset,
+        rawMode: parsed.rawMode,
+        debounceMs: parsed.debounceMs,
+        cap: parsed.cap,
+        dropPolicy: parsed.dropPolicy,
+        rawDebounce: parsed.rawDebounce,
+        rawCap: parsed.rawCap,
+        rawDrop: parsed.rawDrop,
+        hasDirective: true,
+        hasOptions: parsed.hasOptions,
+    };
+}
+function elideText(text, limit = 140) {
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+function buildQueueSummaryLine(run) {
+    const base = run.summaryLine?.trim() || run.prompt.trim();
+    const cleaned = base.replace(/\s+/g, " ").trim();
+    return elideText(cleaned, 160);
+}
+function getFollowupQueue(key, settings) {
+    const existing = FOLLOWUP_QUEUES.get(key);
+    if (existing) {
+        existing.mode = settings.mode;
+        existing.debounceMs =
+            typeof settings.debounceMs === "number"
+                ? Math.max(0, settings.debounceMs)
+                : existing.debounceMs;
+        existing.cap =
+            typeof settings.cap === "number" && settings.cap > 0
+                ? Math.floor(settings.cap)
+                : existing.cap;
+        existing.dropPolicy = settings.dropPolicy ?? existing.dropPolicy;
+        return existing;
+    }
+    const created = {
+        items: [],
+        draining: false,
+        lastEnqueuedAt: 0,
+        mode: settings.mode,
+        debounceMs: typeof settings.debounceMs === "number"
+            ? Math.max(0, settings.debounceMs)
+            : DEFAULT_QUEUE_DEBOUNCE_MS,
+        cap: typeof settings.cap === "number" && settings.cap > 0
+            ? Math.floor(settings.cap)
+            : DEFAULT_QUEUE_CAP,
+        dropPolicy: settings.dropPolicy ?? DEFAULT_QUEUE_DROP,
+        droppedCount: 0,
+        summaryLines: [],
+    };
+    FOLLOWUP_QUEUES.set(key, created);
+    return created;
+}
+export function enqueueFollowupRun(key, run, settings) {
+    const queue = getFollowupQueue(key, settings);
+    queue.lastEnqueuedAt = Date.now();
+    queue.lastRun = run.run;
+    const cap = queue.cap;
+    if (cap > 0 && queue.items.length >= cap) {
+        if (queue.dropPolicy === "new") {
+            return false;
+        }
+        const dropCount = queue.items.length - cap + 1;
+        const dropped = queue.items.splice(0, dropCount);
+        if (queue.dropPolicy === "summarize") {
+            for (const item of dropped) {
+                queue.droppedCount += 1;
+                queue.summaryLines.push(buildQueueSummaryLine(item));
+            }
+            while (queue.summaryLines.length > cap)
+                queue.summaryLines.shift();
+        }
+    }
+    queue.items.push(run);
+    return true;
+}
+async function waitForQueueDebounce(queue) {
+    const debounceMs = Math.max(0, queue.debounceMs);
+    if (debounceMs <= 0)
+        return;
+    while (true) {
+        const since = Date.now() - queue.lastEnqueuedAt;
+        if (since >= debounceMs)
+            return;
+        await new Promise((resolve) => setTimeout(resolve, debounceMs - since));
+    }
+}
+function buildSummaryPrompt(queue) {
+    if (queue.dropPolicy !== "summarize" || queue.droppedCount <= 0) {
+        return undefined;
+    }
+    const lines = [
+        `[Queue overflow] Dropped ${queue.droppedCount} message${queue.droppedCount === 1 ? "" : "s"} due to cap.`,
+    ];
+    if (queue.summaryLines.length > 0) {
+        lines.push("Summary:");
+        for (const line of queue.summaryLines) {
+            lines.push(`- ${line}`);
+        }
+    }
+    queue.droppedCount = 0;
+    queue.summaryLines = [];
+    return lines.join("\n");
+}
+function buildCollectPrompt(items, summary) {
+    const blocks = ["[Queued messages while agent was busy]"];
+    if (summary) {
+        blocks.push(summary);
+    }
+    items.forEach((item, idx) => {
+        blocks.push(`---\nQueued #${idx + 1}\n${item.prompt}`.trim());
+    });
+    return blocks.join("\n\n");
+}
+export function scheduleFollowupDrain(key, runFollowup) {
+    const queue = FOLLOWUP_QUEUES.get(key);
+    if (!queue || queue.draining)
+        return;
+    queue.draining = true;
+    void (async () => {
+        try {
+            while (queue.items.length > 0 || queue.droppedCount > 0) {
+                await waitForQueueDebounce(queue);
+                if (queue.mode === "collect") {
+                    const items = queue.items.splice(0, queue.items.length);
+                    const summary = buildSummaryPrompt(queue);
+                    const run = items.at(-1)?.run ?? queue.lastRun;
+                    if (!run)
+                        break;
+                    const prompt = buildCollectPrompt(items, summary);
+                    await runFollowup({
+                        prompt,
+                        run,
+                        enqueuedAt: Date.now(),
+                    });
+                    continue;
+                }
+                const summaryPrompt = buildSummaryPrompt(queue);
+                if (summaryPrompt) {
+                    const run = queue.lastRun;
+                    if (!run)
+                        break;
+                    await runFollowup({
+                        prompt: summaryPrompt,
+                        run,
+                        enqueuedAt: Date.now(),
+                    });
+                    continue;
+                }
+                const next = queue.items.shift();
+                if (!next)
+                    break;
+                await runFollowup(next);
+            }
+        }
+        catch (err) {
+            defaultRuntime.error?.(`followup queue drain failed for ${key}: ${String(err)}`);
+        }
+        finally {
+            queue.draining = false;
+            if (queue.items.length === 0 && queue.droppedCount === 0) {
+                FOLLOWUP_QUEUES.delete(key);
+            }
+            else {
+                scheduleFollowupDrain(key, runFollowup);
+            }
+        }
+    })();
+}
+function defaultQueueModeForSurface(surface) {
+    const normalized = surface?.trim().toLowerCase();
+    if (normalized === "discord")
+        return "collect";
+    if (normalized === "webchat")
+        return "collect";
+    if (normalized === "whatsapp")
+        return "collect";
+    if (normalized === "telegram")
+        return "collect";
+    if (normalized === "imessage")
+        return "collect";
+    if (normalized === "signal")
+        return "collect";
+    return "collect";
+}
+export function resolveQueueSettings(params) {
+    const surfaceKey = params.surface?.trim().toLowerCase();
+    const queueCfg = params.cfg.routing?.queue;
+    const surfaceModeRaw = surfaceKey && queueCfg?.bySurface
+        ? queueCfg.bySurface[surfaceKey]
+        : undefined;
+    const resolvedMode = params.inlineMode ??
+        normalizeQueueMode(params.sessionEntry?.queueMode) ??
+        normalizeQueueMode(surfaceModeRaw) ??
+        normalizeQueueMode(queueCfg?.mode) ??
+        defaultQueueModeForSurface(surfaceKey);
+    const debounceRaw = params.inlineOptions?.debounceMs ??
+        params.sessionEntry?.queueDebounceMs ??
+        queueCfg?.debounceMs ??
+        DEFAULT_QUEUE_DEBOUNCE_MS;
+    const capRaw = params.inlineOptions?.cap ??
+        params.sessionEntry?.queueCap ??
+        queueCfg?.cap ??
+        DEFAULT_QUEUE_CAP;
+    const dropRaw = params.inlineOptions?.dropPolicy ??
+        params.sessionEntry?.queueDrop ??
+        normalizeQueueDropPolicy(queueCfg?.drop) ??
+        DEFAULT_QUEUE_DROP;
+    return {
+        mode: resolvedMode,
+        debounceMs: typeof debounceRaw === "number" ? Math.max(0, debounceRaw) : undefined,
+        cap: typeof capRaw === "number" ? Math.max(1, Math.floor(capRaw)) : undefined,
+        dropPolicy: dropRaw,
+    };
+}

package/dist/auto-reply/reply/reply-tags.js

@@ -0,0 +1,26 @@
+export function extractReplyToTag(text, currentMessageId) {
+    if (!text)
+        return { cleaned: "", hasTag: false };
+    let cleaned = text;
+    let replyToId;
+    let hasTag = false;
+    const currentMatch = cleaned.match(/\[\[reply_to_current\]\]/i);
+    if (currentMatch) {
+        cleaned = cleaned.replace(/\[\[reply_to_current\]\]/gi, " ");
+        hasTag = true;
+        if (currentMessageId?.trim()) {
+            replyToId = currentMessageId.trim();
+        }
+    }
+    const idMatch = cleaned.match(/\[\[reply_to:([^\]\n]+)\]\]/i);
+    if (idMatch?.[1]) {
+        cleaned = cleaned.replace(/\[\[reply_to:[^\]\n]+\]\]/gi, " ");
+        replyToId = idMatch[1].trim();
+        hasTag = true;
+    }
+    cleaned = cleaned
+        .replace(/[ \t]+/g, " ")
+        .replace(/[ \t]*\n[ \t]*/g, "\n")
+        .trim();
+    return { cleaned, replyToId, hasTag };
+}

package/dist/auto-reply/reply/session-updates.js

@@ -0,0 +1,87 @@
+import crypto from "node:crypto";
+import { buildWorkspaceSkillSnapshot } from "../../agents/skills.js";
+import { saveSessionStore } from "../../config/sessions.js";
+import { buildProviderSummary } from "../../infra/provider-summary.js";
+import { drainSystemEvents } from "../../infra/system-events.js";
+export async function prependSystemEvents(params) {
+    if (!params.isMainSession)
+        return params.prefixedBodyBase;
+    const compactSystemEvent = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return null;
+        const lower = trimmed.toLowerCase();
+        if (lower.includes("reason periodic"))
+            return null;
+        if (lower.includes("heartbeat"))
+            return null;
+        if (trimmed.startsWith("Node:")) {
+            return trimmed.replace(/ · last input [^·]+/i, "").trim();
+        }
+        return trimmed;
+    };
+    const systemLines = [];
+    const queued = drainSystemEvents();
+    systemLines.push(...queued.map(compactSystemEvent).filter((v) => Boolean(v)));
+    if (params.isNewSession) {
+        const summary = await buildProviderSummary(params.cfg);
+        if (summary.length > 0)
+            systemLines.unshift(...summary);
+    }
+    if (systemLines.length === 0)
+        return params.prefixedBodyBase;
+    const block = systemLines.map((l) => `System: ${l}`).join("\n");
+    return `${block}\n\n${params.prefixedBodyBase}`;
+}
+export async function ensureSkillSnapshot(params) {
+    const { sessionEntry, sessionStore, sessionKey, storePath, sessionId, isFirstTurnInSession, workspaceDir, cfg, } = params;
+    let nextEntry = sessionEntry;
+    let systemSent = sessionEntry?.systemSent ?? false;
+    if (isFirstTurnInSession && sessionStore && sessionKey) {
+        const current = nextEntry ??
+            sessionStore[sessionKey] ?? {
+            sessionId: sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+        };
+        const skillSnapshot = isFirstTurnInSession || !current.skillsSnapshot
+            ? buildWorkspaceSkillSnapshot(workspaceDir, { config: cfg })
+            : current.skillsSnapshot;
+        nextEntry = {
+            ...current,
+            sessionId: sessionId ?? current.sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+            systemSent: true,
+            skillsSnapshot: skillSnapshot,
+        };
+        sessionStore[sessionKey] = nextEntry;
+        if (storePath) {
+            await saveSessionStore(storePath, sessionStore);
+        }
+        systemSent = true;
+    }
+    const skillsSnapshot = nextEntry?.skillsSnapshot ??
+        (isFirstTurnInSession
+            ? undefined
+            : buildWorkspaceSkillSnapshot(workspaceDir, { config: cfg }));
+    if (skillsSnapshot &&
+        sessionStore &&
+        sessionKey &&
+        !isFirstTurnInSession &&
+        !nextEntry?.skillsSnapshot) {
+        const current = nextEntry ?? {
+            sessionId: sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+        };
+        nextEntry = {
+            ...current,
+            sessionId: sessionId ?? current.sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+            skillsSnapshot,
+        };
+        sessionStore[sessionKey] = nextEntry;
+        if (storePath) {
+            await saveSessionStore(storePath, sessionStore);
+        }
+    }
+    return { sessionEntry: nextEntry, skillsSnapshot, systemSent };
+}