@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/gateway/server-methods/send.js

@@ -1,11 +1,11 @@
+import { resolveSessionAgentId } from "../../agents/agent-scope.js";
 import { getChannelPlugin, normalizeChannelId } from "../../channels/plugins/index.js";
 import { DEFAULT_CHAT_CHANNEL } from "../../channels/registry.js";
-import { loadConfig } from "../../config/config.js";
 import { createOutboundSendDeps } from "../../cli/deps.js";
+import { loadConfig } from "../../config/config.js";
 import { deliverOutboundPayloads } from "../../infra/outbound/deliver.js";
-import { normalizeReplyPayloadsForDelivery } from "../../infra/outbound/payloads.js";
 import { ensureOutboundSessionEntry, resolveOutboundSessionRoute, } from "../../infra/outbound/outbound-session.js";
-import { resolveSessionAgentId } from "../../agents/agent-scope.js";
+import { normalizeReplyPayloadsForDelivery } from "../../infra/outbound/payloads.js";
 import { resolveOutboundTarget } from "../../infra/outbound/targets.js";
 import { normalizePollInput } from "../../polls.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validatePollParams, validateSendParams, } from "../protocol/index.js";
@@ -45,11 +45,27 @@ export const sendHandlers = {
             return;
         }
         const to = request.to.trim();
-        const message = request.message.trim();
-        const mediaUrls = Array.isArray(request.mediaUrls) ? request.mediaUrls : undefined;
+        const message = typeof request.message === "string" ? request.message.trim() : "";
+        const mediaUrl = typeof request.mediaUrl === "string" && request.mediaUrl.trim().length > 0
+            ? request.mediaUrl.trim()
+            : undefined;
+        const mediaUrls = Array.isArray(request.mediaUrls)
+            ? request.mediaUrls
+                .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+                .filter((entry) => entry.length > 0)
+            : undefined;
+        if (!message && !mediaUrl && (mediaUrls?.length ?? 0) === 0) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid send params: text or media is required"));
+            return;
+        }
         const channelInput = typeof request.channel === "string" ? request.channel : undefined;
         const normalizedChannel = channelInput ? normalizeChannelId(channelInput) : null;
         if (channelInput && !normalizedChannel) {
+            const normalizedInput = channelInput.trim().toLowerCase();
+            if (normalizedInput === "webchat") {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unsupported channel: webchat (internal-only). Use `chat.send` for WebChat UI messages or choose a deliverable channel."));
+                return;
+            }
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `unsupported channel: ${channelInput}`));
             return;
         }
@@ -57,6 +73,9 @@ export const sendHandlers = {
         const accountId = typeof request.accountId === "string" && request.accountId.trim().length
             ? request.accountId.trim()
             : undefined;
+        const threadId = typeof request.threadId === "string" && request.threadId.trim().length
+            ? request.threadId.trim()
+            : undefined;
         const outboundChannel = channel;
         const plugin = getChannelPlugin(channel);
         if (!plugin) {
@@ -82,7 +101,7 @@ export const sendHandlers = {
                 }
                 const outboundDeps = context.deps ? createOutboundSendDeps(context.deps) : undefined;
                 const mirrorPayloads = normalizeReplyPayloadsForDelivery([
-                    { text: message, mediaUrl: request.mediaUrl, mediaUrls },
+                    { text: message, mediaUrl, mediaUrls },
                 ]);
                 const mirrorText = mirrorPayloads
                     .map((payload) => payload.text)
@@ -101,6 +120,7 @@ export const sendHandlers = {
                         agentId: derivedAgentId,
                         accountId,
                         target: resolved.to,
+                        threadId,
                     })
                     : null;
                 if (derivedRoute) {
@@ -117,8 +137,12 @@ export const sendHandlers = {
                     channel: outboundChannel,
                     to: resolved.to,
                     accountId,
-                    payloads: [{ text: message, mediaUrl: request.mediaUrl, mediaUrls }],
+                    payloads: [{ text: message, mediaUrl, mediaUrls }],
+                    agentId: providedSessionKey
+                        ? resolveSessionAgentId({ sessionKey: providedSessionKey, config: cfg })
+                        : derivedAgentId,
                     gifPlayback: request.gifPlayback,
+                    threadId: threadId ?? null,
                     deps: outboundDeps,
                     mirror: providedSessionKey
                         ? {
@@ -145,12 +169,15 @@ export const sendHandlers = {
                     messageId: result.messageId,
                     channel,
                 };
-                if ("chatId" in result)
+                if ("chatId" in result) {
                     payload.chatId = result.chatId;
-                if ("channelId" in result)
+                }
+                if ("channelId" in result) {
                     payload.channelId = result.channelId;
-                if ("toJid" in result)
+                }
+                if ("toJid" in result) {
                     payload.toJid = result.toJid;
+                }
                 if ("conversationId" in result) {
                     payload.conversationId = result.conversationId;
                 }
@@ -207,12 +234,24 @@ export const sendHandlers = {
             return;
         }
         const channel = normalizedChannel ?? DEFAULT_CHAT_CHANNEL;
+        if (typeof request.durationSeconds === "number" && channel !== "telegram") {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "durationSeconds is only supported for Telegram polls"));
+            return;
+        }
+        if (typeof request.isAnonymous === "boolean" && channel !== "telegram") {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "isAnonymous is only supported for Telegram polls"));
+            return;
+        }
         const poll = {
             question: request.question,
             options: request.options,
             maxSelections: request.maxSelections,
+            durationSeconds: request.durationSeconds,
             durationHours: request.durationHours,
         };
+        const threadId = typeof request.threadId === "string" && request.threadId.trim().length
+            ? request.threadId.trim()
+            : undefined;
         const accountId = typeof request.accountId === "string" && request.accountId.trim().length
             ? request.accountId.trim()
             : undefined;
@@ -243,20 +282,27 @@ export const sendHandlers = {
                 to: resolved.to,
                 poll: normalized,
                 accountId,
+                threadId,
+                silent: request.silent,
+                isAnonymous: request.isAnonymous,
             });
             const payload = {
                 runId: idem,
                 messageId: result.messageId,
                 channel,
             };
-            if (result.toJid)
+            if (result.toJid) {
                 payload.toJid = result.toJid;
-            if (result.channelId)
+            }
+            if (result.channelId) {
                 payload.channelId = result.channelId;
-            if (result.conversationId)
+            }
+            if (result.conversationId) {
                 payload.conversationId = result.conversationId;
-            if (result.pollId)
+            }
+            if (result.pollId) {
                 payload.pollId = result.pollId;
+            }
             context.dedupe.set(`poll:${idem}`, {
                 ts: Date.now(),
                 ok: true,

package/dist/gateway/server-methods/sessions.js

@@ -1,18 +1,91 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
+import { resolveDefaultAgentId } from "../../agents/agent-scope.js";
 import { abortEmbeddedPiRun, waitForEmbeddedPiRunEnd } from "../../agents/pi-embedded.js";
 import { stopSubagentsForRequester } from "../../auto-reply/reply/abort.js";
 import { clearSessionQueues } from "../../auto-reply/reply/queue.js";
 import { loadConfig } from "../../config/config.js";
 import { loadSessionStore, snapshotSessionOrigin, resolveMainSessionKey, updateSessionStore, } from "../../config/sessions.js";
-import { ErrorCodes, errorShape, formatValidationErrors, validateSessionsCompactParams, validateSessionsDeleteParams, validateSessionsListParams, validateSessionsPatchParams, validateSessionsPreviewParams, validateSessionsResetParams, validateSessionsResolveParams, } from "../protocol/index.js";
-import { archiveFileOnDisk, listSessionsFromStore, loadCombinedSessionStoreForGateway, loadSessionEntry, readSessionPreviewItemsFromTranscript, resolveGatewaySessionStoreTarget, resolveSessionTranscriptCandidates, } from "../session-utils.js";
+import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
+import { normalizeAgentId, parseAgentSessionKey } from "../../routing/session-key.js";
+import { ErrorCodes, errorShape, validateSessionsCompactParams, validateSessionsDeleteParams, validateSessionsListParams, validateSessionsPatchParams, validateSessionsPreviewParams, validateSessionsResetParams, validateSessionsResolveParams, } from "../protocol/index.js";
+import { archiveFileOnDisk, archiveSessionTranscripts, listSessionsFromStore, loadCombinedSessionStoreForGateway, loadSessionEntry, pruneLegacyStoreKeys, readSessionPreviewItemsFromTranscript, resolveGatewaySessionStoreTarget, resolveSessionModelRef, resolveSessionTranscriptCandidates, } from "../session-utils.js";
 import { applySessionsPatchToStore } from "../sessions-patch.js";
 import { resolveSessionKeyFromResolveParams } from "../sessions-resolve.js";
+import { assertValidParams } from "./validation.js";
+function requireSessionKey(key, respond) {
+    const raw = typeof key === "string"
+        ? key
+        : typeof key === "number"
+            ? String(key)
+            : typeof key === "bigint"
+                ? String(key)
+                : "";
+    const normalized = raw.trim();
+    if (!normalized) {
+        respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
+        return null;
+    }
+    return normalized;
+}
+function resolveGatewaySessionTargetFromKey(key) {
+    const cfg = loadConfig();
+    const target = resolveGatewaySessionStoreTarget({ cfg, key });
+    return { cfg, target, storePath: target.storePath };
+}
+function migrateAndPruneSessionStoreKey(params) {
+    const target = resolveGatewaySessionStoreTarget({
+        cfg: params.cfg,
+        key: params.key,
+        store: params.store,
+    });
+    const primaryKey = target.canonicalKey;
+    if (!params.store[primaryKey]) {
+        const existingKey = target.storeKeys.find((candidate) => Boolean(params.store[candidate]));
+        if (existingKey) {
+            params.store[primaryKey] = params.store[existingKey];
+        }
+    }
+    pruneLegacyStoreKeys({
+        store: params.store,
+        canonicalKey: primaryKey,
+        candidates: target.storeKeys,
+    });
+    return { target, primaryKey, entry: params.store[primaryKey] };
+}
+function archiveSessionTranscriptsForSession(params) {
+    if (!params.sessionId) {
+        return [];
+    }
+    return archiveSessionTranscripts({
+        sessionId: params.sessionId,
+        storePath: params.storePath,
+        sessionFile: params.sessionFile,
+        agentId: params.agentId,
+        reason: params.reason,
+    });
+}
+async function ensureSessionRuntimeCleanup(params) {
+    const queueKeys = new Set(params.target.storeKeys);
+    queueKeys.add(params.target.canonicalKey);
+    if (params.sessionId) {
+        queueKeys.add(params.sessionId);
+    }
+    clearSessionQueues([...queueKeys]);
+    stopSubagentsForRequester({ cfg: params.cfg, requesterSessionKey: params.target.canonicalKey });
+    if (!params.sessionId) {
+        return undefined;
+    }
+    abortEmbeddedPiRun(params.sessionId);
+    const ended = await waitForEmbeddedPiRunEnd(params.sessionId, 15_000);
+    if (ended) {
+        return undefined;
+    }
+    return errorShape(ErrorCodes.UNAVAILABLE, `Session ${params.key} is still active; try again in a moment.`);
+}
 export const sessionsHandlers = {
     "sessions.list": ({ params, respond }) => {
-        if (!validateSessionsListParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.list params: ${formatValidationErrors(validateSessionsListParams.errors)}`));
+        if (!assertValidParams(params, validateSessionsListParams, "sessions.list", respond)) {
             return;
         }
         const p = params;
@@ -27,8 +100,7 @@ export const sessionsHandlers = {
         respond(true, result, undefined);
     },
     "sessions.preview": ({ params, respond }) => {
-        if (!validateSessionsPreviewParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.preview params: ${formatValidationErrors(validateSessionsPreviewParams.errors)}`));
+        if (!assertValidParams(params, validateSessionsPreviewParams, "sessions.preview", respond)) {
             return;
         }
         const p = params;
@@ -50,11 +122,15 @@ export const sessionsHandlers = {
         const previews = [];
         for (const key of keys) {
             try {
-                const target = resolveGatewaySessionStoreTarget({ cfg, key });
-                const store = storeCache.get(target.storePath) ?? loadSessionStore(target.storePath);
-                storeCache.set(target.storePath, store);
-                const entry = target.storeKeys.map((candidate) => store[candidate]).find(Boolean) ??
-                    store[target.canonicalKey];
+                const storeTarget = resolveGatewaySessionStoreTarget({ cfg, key, scanLegacyKeys: false });
+                const store = storeCache.get(storeTarget.storePath) ?? loadSessionStore(storeTarget.storePath);
+                storeCache.set(storeTarget.storePath, store);
+                const target = resolveGatewaySessionStoreTarget({
+                    cfg,
+                    key,
+                    store,
+                });
+                const entry = target.storeKeys.map((candidate) => store[candidate]).find(Boolean);
                 if (!entry?.sessionId) {
                     previews.push({ key, status: "missing", items: [] });
                     continue;
@@ -72,14 +148,13 @@ export const sessionsHandlers = {
         }
         respond(true, { ts: Date.now(), previews }, undefined);
     },
-    "sessions.resolve": ({ params, respond }) => {
-        if (!validateSessionsResolveParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.resolve params: ${formatValidationErrors(validateSessionsResolveParams.errors)}`));
+    "sessions.resolve": async ({ params, respond }) => {
+        if (!assertValidParams(params, validateSessionsResolveParams, "sessions.resolve", respond)) {
             return;
         }
         const p = params;
         const cfg = loadConfig();
-        const resolved = resolveSessionKeyFromResolveParams({ cfg, p });
+        const resolved = await resolveSessionKeyFromResolveParams({ cfg, p });
         if (!resolved.ok) {
             respond(false, undefined, resolved.error);
             return;
@@ -87,26 +162,17 @@ export const sessionsHandlers = {
         respond(true, { ok: true, key: resolved.key }, undefined);
     },
     "sessions.patch": async ({ params, respond, context }) => {
-        if (!validateSessionsPatchParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.patch params: ${formatValidationErrors(validateSessionsPatchParams.errors)}`));
+        if (!assertValidParams(params, validateSessionsPatchParams, "sessions.patch", respond)) {
             return;
         }
         const p = params;
-        const key = String(p.key ?? "").trim();
+        const key = requireSessionKey(p.key, respond);
         if (!key) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
             return;
         }
-        const cfg = loadConfig();
-        const target = resolveGatewaySessionStoreTarget({ cfg, key });
-        const storePath = target.storePath;
+        const { cfg, target, storePath } = resolveGatewaySessionTargetFromKey(key);
         const applied = await updateSessionStore(storePath, async (store) => {
-            const primaryKey = target.storeKeys[0] ?? key;
-            const existingKey = target.storeKeys.find((candidate) => store[candidate]);
-            if (existingKey && existingKey !== primaryKey && !store[primaryKey]) {
-                store[primaryKey] = store[existingKey];
-                delete store[existingKey];
-            }
+            const { primaryKey } = migrateAndPruneSessionStoreKey({ cfg, key, store });
             return await applySessionsPatchToStore({
                 cfg,
                 store,
@@ -119,36 +185,53 @@ export const sessionsHandlers = {
             respond(false, undefined, applied.error);
             return;
         }
+        const parsed = parseAgentSessionKey(target.canonicalKey ?? key);
+        const agentId = normalizeAgentId(parsed?.agentId ?? resolveDefaultAgentId(cfg));
+        const resolved = resolveSessionModelRef(cfg, applied.entry, agentId);
         const result = {
             ok: true,
             path: storePath,
             key: target.canonicalKey,
             entry: applied.entry,
+            resolved: {
+                modelProvider: resolved.provider,
+                model: resolved.model,
+            },
         };
         respond(true, result, undefined);
     },
     "sessions.reset": async ({ params, respond }) => {
-        if (!validateSessionsResetParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.reset params: ${formatValidationErrors(validateSessionsResetParams.errors)}`));
+        if (!assertValidParams(params, validateSessionsResetParams, "sessions.reset", respond)) {
             return;
         }
         const p = params;
-        const key = String(p.key ?? "").trim();
+        const key = requireSessionKey(p.key, respond);
         if (!key) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
             return;
         }
-        const cfg = loadConfig();
-        const target = resolveGatewaySessionStoreTarget({ cfg, key });
-        const storePath = target.storePath;
+        const { cfg, target, storePath } = resolveGatewaySessionTargetFromKey(key);
+        const { entry } = loadSessionEntry(key);
+        const commandReason = p.reason === "new" ? "new" : "reset";
+        const hookEvent = createInternalHookEvent("command", commandReason, target.canonicalKey ?? key, {
+            sessionEntry: entry,
+            previousSessionEntry: entry,
+            commandSource: "gateway:sessions.reset",
+            cfg,
+        });
+        await triggerInternalHook(hookEvent);
+        const sessionId = entry?.sessionId;
+        const cleanupError = await ensureSessionRuntimeCleanup({ cfg, key, target, sessionId });
+        if (cleanupError) {
+            respond(false, undefined, cleanupError);
+            return;
+        }
+        let oldSessionId;
+        let oldSessionFile;
         const next = await updateSessionStore(storePath, (store) => {
-            const primaryKey = target.storeKeys[0] ?? key;
-            const existingKey = target.storeKeys.find((candidate) => store[candidate]);
-            if (existingKey && existingKey !== primaryKey && !store[primaryKey]) {
-                store[primaryKey] = store[existingKey];
-                delete store[existingKey];
-            }
+            const { primaryKey } = migrateAndPruneSessionStoreKey({ cfg, key, store });
             const entry = store[primaryKey];
+            oldSessionId = entry?.sessionId;
+            oldSessionFile = entry?.sessionFile;
             const now = Date.now();
             const nextEntry = {
                 sessionId: randomUUID(),
@@ -171,100 +254,79 @@ export const sessionsHandlers = {
                 inputTokens: 0,
                 outputTokens: 0,
                 totalTokens: 0,
+                totalTokensFresh: true,
             };
             store[primaryKey] = nextEntry;
             return nextEntry;
         });
+        // Archive old transcript so it doesn't accumulate on disk (#14869).
+        archiveSessionTranscriptsForSession({
+            sessionId: oldSessionId,
+            storePath,
+            sessionFile: oldSessionFile,
+            agentId: target.agentId,
+            reason: "reset",
+        });
         respond(true, { ok: true, key: target.canonicalKey, entry: next }, undefined);
     },
     "sessions.delete": async ({ params, respond }) => {
-        if (!validateSessionsDeleteParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.delete params: ${formatValidationErrors(validateSessionsDeleteParams.errors)}`));
+        if (!assertValidParams(params, validateSessionsDeleteParams, "sessions.delete", respond)) {
             return;
         }
         const p = params;
-        const key = String(p.key ?? "").trim();
+        const key = requireSessionKey(p.key, respond);
         if (!key) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
             return;
         }
-        const cfg = loadConfig();
+        const { cfg, target, storePath } = resolveGatewaySessionTargetFromKey(key);
         const mainKey = resolveMainSessionKey(cfg);
-        const target = resolveGatewaySessionStoreTarget({ cfg, key });
         if (target.canonicalKey === mainKey) {
             respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `Cannot delete the main session (${mainKey}).`));
             return;
         }
         const deleteTranscript = typeof p.deleteTranscript === "boolean" ? p.deleteTranscript : true;
-        const storePath = target.storePath;
         const { entry } = loadSessionEntry(key);
         const sessionId = entry?.sessionId;
         const existed = Boolean(entry);
-        const queueKeys = new Set(target.storeKeys);
-        queueKeys.add(target.canonicalKey);
-        if (sessionId)
-            queueKeys.add(sessionId);
-        clearSessionQueues([...queueKeys]);
-        stopSubagentsForRequester({ cfg, requesterSessionKey: target.canonicalKey });
-        if (sessionId) {
-            abortEmbeddedPiRun(sessionId);
-            const ended = await waitForEmbeddedPiRunEnd(sessionId, 15_000);
-            if (!ended) {
-                respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, `Session ${key} is still active; try again in a moment.`));
-                return;
-            }
+        const cleanupError = await ensureSessionRuntimeCleanup({ cfg, key, target, sessionId });
+        if (cleanupError) {
+            respond(false, undefined, cleanupError);
+            return;
         }
         await updateSessionStore(storePath, (store) => {
-            const primaryKey = target.storeKeys[0] ?? key;
-            const existingKey = target.storeKeys.find((candidate) => store[candidate]);
-            if (existingKey && existingKey !== primaryKey && !store[primaryKey]) {
-                store[primaryKey] = store[existingKey];
-                delete store[existingKey];
-            }
-            if (store[primaryKey])
+            const { primaryKey } = migrateAndPruneSessionStoreKey({ cfg, key, store });
+            if (store[primaryKey]) {
                 delete store[primaryKey];
-        });
-        const archived = [];
-        if (deleteTranscript && sessionId) {
-            for (const candidate of resolveSessionTranscriptCandidates(sessionId, storePath, entry?.sessionFile, target.agentId)) {
-                if (!fs.existsSync(candidate))
-                    continue;
-                try {
-                    archived.push(archiveFileOnDisk(candidate, "deleted"));
-                }
-                catch {
-                    // Best-effort.
-                }
             }
-        }
+        });
+        const archived = deleteTranscript
+            ? archiveSessionTranscriptsForSession({
+                sessionId,
+                storePath,
+                sessionFile: entry?.sessionFile,
+                agentId: target.agentId,
+                reason: "deleted",
+            })
+            : [];
         respond(true, { ok: true, key: target.canonicalKey, deleted: existed, archived }, undefined);
     },
     "sessions.compact": async ({ params, respond }) => {
-        if (!validateSessionsCompactParams(params)) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid sessions.compact params: ${formatValidationErrors(validateSessionsCompactParams.errors)}`));
+        if (!assertValidParams(params, validateSessionsCompactParams, "sessions.compact", respond)) {
             return;
         }
         const p = params;
-        const key = String(p.key ?? "").trim();
+        const key = requireSessionKey(p.key, respond);
         if (!key) {
-            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "key required"));
             return;
         }
         const maxLines = typeof p.maxLines === "number" && Number.isFinite(p.maxLines)
             ? Math.max(1, Math.floor(p.maxLines))
             : 400;
-        const cfg = loadConfig();
-        const target = resolveGatewaySessionStoreTarget({ cfg, key });
-        const storePath = target.storePath;
+        const { cfg, target, storePath } = resolveGatewaySessionTargetFromKey(key);
         // Lock + read in a short critical section; transcript work happens outside.
         const compactTarget = await updateSessionStore(storePath, (store) => {
-            const primaryKey = target.storeKeys[0] ?? key;
-            const existingKey = target.storeKeys.find((candidate) => store[candidate]);
-            if (existingKey && existingKey !== primaryKey && !store[primaryKey]) {
-                store[primaryKey] = store[existingKey];
-                delete store[existingKey];
-            }
-            return { entry: store[primaryKey], primaryKey };
+            const { entry, primaryKey } = migrateAndPruneSessionStoreKey({ cfg, key, store });
+            return { entry, primaryKey };
         });
         const entry = compactTarget.entry;
         const sessionId = entry?.sessionId;
@@ -304,11 +366,13 @@ export const sessionsHandlers = {
         await updateSessionStore(storePath, (store) => {
             const entryKey = compactTarget.primaryKey;
             const entryToUpdate = store[entryKey];
-            if (!entryToUpdate)
+            if (!entryToUpdate) {
                 return;
+            }
             delete entryToUpdate.inputTokens;
             delete entryToUpdate.outputTokens;
             delete entryToUpdate.totalTokens;
+            delete entryToUpdate.totalTokensFresh;
             entryToUpdate.updatedAt = Date.now();
         });
         respond(true, {

package/dist/gateway/server-methods/system.js

@@ -4,6 +4,7 @@ import { setHeartbeatsEnabled } from "../../infra/heartbeat-runner.js";
 import { enqueueSystemEvent, isSystemEventContextChanged } from "../../infra/system-events.js";
 import { listSystemPresence, updateSystemPresence } from "../../infra/system-presence.js";
 import { ErrorCodes, errorShape } from "../protocol/index.js";
+import { broadcastPresenceSnapshot } from "../server/presence-events.js";
 export const systemHandlers = {
     "last-heartbeat": ({ respond }) => {
         respond(true, getLastHeartbeatEvent(), undefined);
@@ -109,13 +110,10 @@ export const systemHandlers = {
         else {
             enqueueSystemEvent(text, { sessionKey });
         }
-        const nextPresenceVersion = context.incrementPresenceVersion();
-        context.broadcast("presence", { presence: listSystemPresence() }, {
-            dropIfSlow: true,
-            stateVersion: {
-                presence: nextPresenceVersion,
-                health: context.getHealthVersion(),
-            },
+        broadcastPresenceSnapshot({
+            broadcast: context.broadcast,
+            incrementPresenceVersion: context.incrementPresenceVersion,
+            getHealthVersion: context.getHealthVersion,
         });
         respond(true, { ok: true }, undefined);
     },

package/dist/gateway/server-methods-list.js

@@ -23,14 +23,22 @@ const BASE_METHODS = [
     "exec.approvals.node.get",
     "exec.approvals.node.set",
     "exec.approval.request",
+    "exec.approval.waitDecision",
     "exec.approval.resolve",
     "wizard.start",
     "wizard.next",
     "wizard.cancel",
     "wizard.status",
+    "talk.config",
     "talk.mode",
     "models.list",
     "agents.list",
+    "agents.create",
+    "agents.update",
+    "agents.delete",
+    "agents.files.list",
+    "agents.files.get",
+    "agents.files.set",
     "skills.status",
     "skills.bins",
     "skills.install",