@poolzin/pool-bot 2026.2.25 → 2026.2.26

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

@@ -1,9 +1,9 @@
+import { clearSessionAuthProfileOverride } from "../../agents/auth-profiles/session-override.js";
 import { lookupContextTokens } from "../../agents/context.js";
 import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
 import { loadModelCatalog } from "../../agents/model-catalog.js";
 import { buildAllowedModelSet, modelKey, normalizeProviderId, resolveModelRefFromString, resolveThinkingDefault, } from "../../agents/model-selection.js";
 import { updateSessionStore } from "../../config/sessions.js";
-import { clearSessionAuthProfileOverride } from "../../agents/auth-profiles/session-override.js";
 import { applyModelOverrideToSessionEntry } from "../../sessions/model-overrides.js";
 import { resolveThreadParentSessionKey } from "../../sessions/session-key-utils.js";
 const FUZZY_VARIANT_TOKENS = [
@@ -18,14 +18,17 @@ const FUZZY_VARIANT_TOKENS = [
     "nano",
 ];
 function boundedLevenshteinDistance(a, b, maxDistance) {
-    if (a === b)
+    if (a === b) {
         return 0;
-    if (!a || !b)
+    }
+    if (!a || !b) {
         return null;
+    }
     const aLen = a.length;
     const bLen = b.length;
-    if (Math.abs(aLen - bLen) > maxDistance)
+    if (Math.abs(aLen - bLen) > maxDistance) {
         return null;
+    }
     // Standard DP with early exit. O(maxDistance * minLen) in common cases.
     const prev = Array.from({ length: bLen + 1 }, (_, idx) => idx);
     const curr = Array.from({ length: bLen + 1 }, () => 0);
@@ -36,49 +39,59 @@ function boundedLevenshteinDistance(a, b, maxDistance) {
         for (let j = 1; j <= bLen; j++) {
             const cost = aChar === b.charCodeAt(j - 1) ? 0 : 1;
             curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
-            if (curr[j] < rowMin)
+            if (curr[j] < rowMin) {
                 rowMin = curr[j];
+            }
         }
-        if (rowMin > maxDistance)
+        if (rowMin > maxDistance) {
             return null;
-        for (let j = 0; j <= bLen; j++)
+        }
+        for (let j = 0; j <= bLen; j++) {
             prev[j] = curr[j] ?? 0;
+        }
     }
     const dist = prev[bLen] ?? null;
-    if (dist == null || dist > maxDistance)
+    if (dist == null || dist > maxDistance) {
         return null;
+    }
     return dist;
 }
 function resolveModelOverrideFromEntry(entry) {
     const model = entry?.modelOverride?.trim();
-    if (!model)
+    if (!model) {
         return null;
+    }
     const provider = entry?.providerOverride?.trim() || undefined;
     return { provider, model };
 }
 function resolveParentSessionKeyCandidate(params) {
     const explicit = params.parentSessionKey?.trim();
-    if (explicit && explicit !== params.sessionKey)
+    if (explicit && explicit !== params.sessionKey) {
         return explicit;
+    }
     const derived = resolveThreadParentSessionKey(params.sessionKey);
-    if (derived && derived !== params.sessionKey)
+    if (derived && derived !== params.sessionKey) {
         return derived;
+    }
     return null;
 }
 export function resolveStoredModelOverride(params) {
     const direct = resolveModelOverrideFromEntry(params.sessionEntry);
-    if (direct)
+    if (direct) {
         return { ...direct, source: "session" };
+    }
     const parentKey = resolveParentSessionKeyCandidate({
         sessionKey: params.sessionKey,
         parentSessionKey: params.parentSessionKey,
     });
-    if (!parentKey || !params.sessionStore)
+    if (!parentKey || !params.sessionStore) {
         return null;
+    }
     const parentEntry = params.sessionStore[parentKey];
     const parentOverride = resolveModelOverrideFromEntry(parentEntry);
-    if (!parentOverride)
+    if (!parentOverride) {
         return null;
+    }
     return { ...parentOverride, source: "parent" };
 }
 function scoreFuzzyMatch(params) {
@@ -90,15 +103,19 @@ function scoreFuzzyMatch(params) {
     const haystack = `${providerLower}/${modelLower}`;
     const key = modelKey(provider, model);
     const scoreFragment = (value, weights) => {
-        if (!fragment)
+        if (!fragment) {
             return 0;
+        }
         let score = 0;
-        if (value === fragment)
+        if (value === fragment) {
             score = Math.max(score, weights.exact);
-        if (value.startsWith(fragment))
+        }
+        if (value.startsWith(fragment)) {
             score = Math.max(score, weights.starts);
-        if (value.includes(fragment))
+        }
+        if (value.includes(fragment)) {
             score = Math.max(score, weights.includes);
+        }
         return score;
     };
     let score = 0;
@@ -138,15 +155,18 @@ function scoreFuzzyMatch(params) {
         score -= variantCount * 30;
     }
     else if (fragmentVariants.length > 0) {
-        if (variantMatchCount > 0)
+        if (variantMatchCount > 0) {
             score += variantMatchCount * 40;
-        if (variantMatchCount === 0)
+        }
+        if (variantMatchCount === 0) {
             score -= 20;
+        }
     }
     const defaultProvider = normalizeProviderId(params.defaultProvider);
     const isDefault = provider === defaultProvider && model === params.defaultModel;
-    if (isDefault)
+    if (isDefault) {
         score += 20;
+    }
     return {
         score,
         isDefault,
@@ -212,7 +232,11 @@ export async function createModelSelectionState(params) {
         sessionKey,
         parentSessionKey,
     });
-    if (storedOverride?.model) {
+    // Skip stored session model override only when an explicit heartbeat.model
+    // was resolved. Heartbeat runs without heartbeat.model should still inherit
+    // the regular session/parent model override behavior.
+    const skipStoredOverride = params.hasResolvedHeartbeatModelOverride === true;
+    if (storedOverride?.model && !skipStoredOverride) {
         const candidateProvider = storedOverride.provider || defaultProvider;
         const key = modelKey(candidateProvider, storedOverride.model);
         if (allowedModelKeys.size === 0 || allowedModelKeys.has(key)) {
@@ -238,8 +262,9 @@ export async function createModelSelectionState(params) {
     }
     let defaultThinkingLevel;
     const resolveDefaultThinkingLevel = async () => {
-        if (defaultThinkingLevel)
+        if (defaultThinkingLevel) {
             return defaultThinkingLevel;
+        }
         let catalogForThinking = modelCatalog ?? allowedModelCatalog;
         if (!catalogForThinking || catalogForThinking.length === 0) {
             modelCatalog = await loadModelCatalog({ config: cfg });
@@ -281,26 +306,30 @@ export function resolveModelDirectiveSelection(params) {
     };
     const resolveFuzzy = (params) => {
         const fragment = params.fragment.trim().toLowerCase();
-        if (!fragment)
+        if (!fragment) {
             return {};
+        }
         const providerFilter = params.provider ? normalizeProviderId(params.provider) : undefined;
         const candidates = [];
         for (const key of allowedModelKeys) {
             const slash = key.indexOf("/");
-            if (slash <= 0)
+            if (slash <= 0) {
                 continue;
+            }
             const provider = normalizeProviderId(key.slice(0, slash));
             const model = key.slice(slash + 1);
-            if (providerFilter && provider !== providerFilter)
+            if (providerFilter && provider !== providerFilter) {
                 continue;
+            }
             candidates.push({ provider, model });
         }
         // Also allow partial alias matches when the user didn't specify a provider.
         if (!params.provider) {
             const aliasMatches = [];
             for (const [aliasKey, entry] of aliasIndex.byAlias.entries()) {
-                if (!aliasKey.includes(fragment))
+                if (!aliasKey.includes(fragment)) {
                     continue;
+                }
                 aliasMatches.push({
                     provider: entry.ref.provider,
                     model: entry.ref.model,
@@ -308,15 +337,17 @@ export function resolveModelDirectiveSelection(params) {
             }
             for (const match of aliasMatches) {
                 const key = modelKey(match.provider, match.model);
-                if (!allowedModelKeys.has(key))
+                if (!allowedModelKeys.has(key)) {
                     continue;
+                }
                 if (!candidates.some((c) => c.provider === match.provider && c.model === match.model)) {
                     candidates.push(match);
                 }
             }
         }
-        if (candidates.length === 0)
+        if (candidates.length === 0) {
             return {};
+        }
         const scored = candidates
             .map((candidate) => {
             const details = scoreFuzzyMatch({
@@ -330,25 +361,32 @@ export function resolveModelDirectiveSelection(params) {
             return Object.assign({ candidate }, details);
         })
             .toSorted((a, b) => {
-            if (b.score !== a.score)
+            if (b.score !== a.score) {
                 return b.score - a.score;
-            if (a.isDefault !== b.isDefault)
+            }
+            if (a.isDefault !== b.isDefault) {
                 return a.isDefault ? -1 : 1;
-            if (a.variantMatchCount !== b.variantMatchCount)
+            }
+            if (a.variantMatchCount !== b.variantMatchCount) {
                 return b.variantMatchCount - a.variantMatchCount;
-            if (a.variantCount !== b.variantCount)
+            }
+            if (a.variantCount !== b.variantCount) {
                 return a.variantCount - b.variantCount;
-            if (a.modelLength !== b.modelLength)
+            }
+            if (a.modelLength !== b.modelLength) {
                 return a.modelLength - b.modelLength;
+            }
             return a.key.localeCompare(b.key);
         });
         const bestScored = scored[0];
         const best = bestScored?.candidate;
-        if (!best || !bestScored)
+        if (!best || !bestScored) {
             return {};
+        }
         const minScore = providerFilter ? 90 : 120;
-        if (bestScored.score < minScore)
+        if (bestScored.score < minScore) {
             return {};
+        }
         return { selection: buildSelection(best.provider, best.model) };
     };
     const resolved = resolveModelRefFromString({
@@ -358,8 +396,9 @@ export function resolveModelDirectiveSelection(params) {
     });
     if (!resolved) {
         const fuzzy = resolveFuzzy({ fragment: rawTrimmed });
-        if (fuzzy.selection || fuzzy.error)
+        if (fuzzy.selection || fuzzy.error) {
             return fuzzy;
+        }
         return {
             error: `Unrecognized model "${rawTrimmed}". Use /models to list providers, or /models <provider> to list models.`,
         };
@@ -382,13 +421,15 @@ export function resolveModelDirectiveSelection(params) {
         const provider = normalizeProviderId(rawTrimmed.slice(0, slash).trim());
         const fragment = rawTrimmed.slice(slash + 1).trim();
         const fuzzy = resolveFuzzy({ provider, fragment });
-        if (fuzzy.selection || fuzzy.error)
+        if (fuzzy.selection || fuzzy.error) {
             return fuzzy;
+        }
     }
     // Otherwise, try fuzzy matching across allowlisted models.
     const fuzzy = resolveFuzzy({ fragment: rawTrimmed });
-    if (fuzzy.selection || fuzzy.error)
+    if (fuzzy.selection || fuzzy.error) {
         return fuzzy;
+    }
     return {
         error: `Model "${resolved.ref.provider}/${resolved.ref.model}" is not allowed. Use /models to list providers, or /models <provider> to list models.`,
     };

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

@@ -9,8 +9,9 @@ function isRunAlreadyQueued(run, items, allowPromptFallback = false) {
     if (messageId) {
         return items.some((item) => item.messageId?.trim() === messageId && hasSameRouting(item));
     }
-    if (!allowPromptFallback)
+    if (!allowPromptFallback) {
         return false;
+    }
     return items.some((item) => item.prompt === run.prompt && hasSameRouting(item));
 }
 export function enqueueFollowupRun(key, run, settings, dedupeMode = "message-id") {
@@ -19,25 +20,29 @@ export function enqueueFollowupRun(key, run, settings, dedupeMode = "message-id"
         ? undefined
         : (item, items) => isRunAlreadyQueued(item, items, dedupeMode === "prompt");
     // Deduplicate: skip if the same message is already queued.
-    if (shouldSkipQueueItem({ item: run, items: queue.items, dedupe }))
+    if (shouldSkipQueueItem({ item: run, items: queue.items, dedupe })) {
         return false;
+    }
     queue.lastEnqueuedAt = Date.now();
     queue.lastRun = run.run;
     const shouldEnqueue = applyQueueDropPolicy({
         queue,
         summarize: (item) => item.summaryLine?.trim() || item.prompt.trim(),
     });
-    if (!shouldEnqueue)
+    if (!shouldEnqueue) {
         return false;
+    }
     queue.items.push(run);
     return true;
 }
 export function getFollowupQueueDepth(key) {
     const cleaned = key.trim();
-    if (!cleaned)
+    if (!cleaned) {
         return 0;
+    }
     const queue = FOLLOWUP_QUEUES.get(cleaned);
-    if (!queue)
+    if (!queue) {
         return 0;
+    }
     return queue.items.length;
 }

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

@@ -1,3 +1,4 @@
+import { applyQueueRuntimeSettings } from "../../../utils/queue-helpers.js";
 export const DEFAULT_QUEUE_DEBOUNCE_MS = 1000;
 export const DEFAULT_QUEUE_CAP = 20;
 export const DEFAULT_QUEUE_DROP = "summarize";
@@ -5,16 +6,10 @@ export const FOLLOWUP_QUEUES = new Map();
 export 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;
+        applyQueueRuntimeSettings({
+            target: existing,
+            settings,
+        });
         return existing;
     }
     const created = {
@@ -32,16 +27,22 @@ export function getFollowupQueue(key, settings) {
         droppedCount: 0,
         summaryLines: [],
     };
+    applyQueueRuntimeSettings({
+        target: created,
+        settings,
+    });
     FOLLOWUP_QUEUES.set(key, created);
     return created;
 }
 export function clearFollowupQueue(key) {
     const cleaned = key.trim();
-    if (!cleaned)
+    if (!cleaned) {
         return 0;
+    }
     const queue = FOLLOWUP_QUEUES.get(cleaned);
-    if (!queue)
+    if (!queue) {
         return 0;
+    }
     const cleared = queue.items.length + queue.droppedCount;
     queue.items.length = 0;
     queue.droppedCount = 0;

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

@@ -1,34 +1,40 @@
 import { isMessagingToolDuplicate } from "../../agents/pi-embedded-helpers.js";
 import { normalizeTargetForProvider } from "../../infra/outbound/target-normalization.js";
+import { normalizeOptionalAccountId } from "../../routing/account-id.js";
 import { extractReplyToTag } from "./reply-tags.js";
 import { createReplyToModeFilterForChannel } from "./reply-threading.js";
-export function applyReplyTagsToPayload(payload, currentMessageId) {
-    if (typeof payload.text !== "string") {
-        if (!payload.replyToCurrent || payload.replyToId)
-            return payload;
-        return {
-            ...payload,
-            replyToId: currentMessageId?.trim() || undefined,
+function resolveReplyThreadingForPayload(params) {
+    const implicitReplyToId = params.implicitReplyToId?.trim() || undefined;
+    const currentMessageId = params.currentMessageId?.trim() || undefined;
+    // 1) Apply implicit reply threading first (replyToMode will strip later if needed).
+    let resolved = params.payload.replyToId || params.payload.replyToCurrent === false || !implicitReplyToId
+        ? params.payload
+        : { ...params.payload, replyToId: implicitReplyToId };
+    // 2) Parse explicit reply tags from text (if present) and clean them.
+    if (typeof resolved.text === "string" && resolved.text.includes("[[")) {
+        const { cleaned, replyToId, replyToCurrent, hasTag } = extractReplyToTag(resolved.text, currentMessageId);
+        resolved = {
+            ...resolved,
+            text: cleaned ? cleaned : undefined,
+            replyToId: replyToId ?? resolved.replyToId,
+            replyToTag: hasTag || resolved.replyToTag,
+            replyToCurrent: replyToCurrent || resolved.replyToCurrent,
         };
     }
-    const shouldParseTags = payload.text.includes("[[");
-    if (!shouldParseTags) {
-        if (!payload.replyToCurrent || payload.replyToId)
-            return payload;
-        return {
-            ...payload,
-            replyToId: currentMessageId?.trim() || undefined,
-            replyToTag: payload.replyToTag ?? true,
+    // 3) If replyToCurrent was set out-of-band (e.g. tags already stripped upstream),
+    // ensure replyToId is set to the current message id when available.
+    if (resolved.replyToCurrent && !resolved.replyToId && currentMessageId) {
+        resolved = {
+            ...resolved,
+            replyToId: currentMessageId,
         };
     }
-    const { cleaned, replyToId, replyToCurrent, hasTag } = extractReplyToTag(payload.text, currentMessageId);
-    return {
-        ...payload,
-        text: cleaned ? cleaned : undefined,
-        replyToId: replyToId ?? payload.replyToId,
-        replyToTag: hasTag || payload.replyToTag,
-        replyToCurrent: replyToCurrent || payload.replyToCurrent,
-    };
+    return resolved;
+}
+// Backward-compatible helper: apply explicit reply tags/directives to a single payload.
+// This intentionally does not apply implicit threading.
+export function applyReplyTagsToPayload(payload, currentMessageId) {
+    return resolveReplyThreadingForPayload({ payload, currentMessageId });
 }
 export function isRenderablePayload(payload) {
     return Boolean(payload.text ||
@@ -40,41 +46,66 @@ export function isRenderablePayload(payload) {
 export function applyReplyThreading(params) {
     const { payloads, replyToMode, replyToChannel, currentMessageId } = params;
     const applyReplyToMode = createReplyToModeFilterForChannel(replyToMode, replyToChannel);
+    const implicitReplyToId = currentMessageId?.trim() || undefined;
     return payloads
-        .map((payload) => applyReplyTagsToPayload(payload, currentMessageId))
+        .map((payload) => resolveReplyThreadingForPayload({ payload, implicitReplyToId, currentMessageId }))
         .filter(isRenderablePayload)
         .map(applyReplyToMode);
 }
 export function filterMessagingToolDuplicates(params) {
     const { payloads, sentTexts } = params;
-    if (sentTexts.length === 0)
+    if (sentTexts.length === 0) {
         return payloads;
+    }
     return payloads.filter((payload) => !isMessagingToolDuplicate(payload.text ?? "", sentTexts));
 }
-function normalizeAccountId(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed.toLowerCase() : undefined;
+export function filterMessagingToolMediaDuplicates(params) {
+    const { payloads, sentMediaUrls } = params;
+    if (sentMediaUrls.length === 0) {
+        return payloads;
+    }
+    const sentSet = new Set(sentMediaUrls);
+    return payloads.map((payload) => {
+        const mediaUrl = payload.mediaUrl;
+        const mediaUrls = payload.mediaUrls;
+        const stripSingle = mediaUrl && sentSet.has(mediaUrl);
+        const filteredUrls = mediaUrls?.filter((u) => !sentSet.has(u));
+        if (!stripSingle && (!mediaUrls || filteredUrls?.length === mediaUrls.length)) {
+            return payload; // No change
+        }
+        return {
+            ...payload,
+            mediaUrl: stripSingle ? undefined : mediaUrl,
+            mediaUrls: filteredUrls?.length ? filteredUrls : undefined,
+        };
+    });
 }
 export function shouldSuppressMessagingToolReplies(params) {
     const provider = params.messageProvider?.trim().toLowerCase();
-    if (!provider)
+    if (!provider) {
         return false;
+    }
     const originTarget = normalizeTargetForProvider(provider, params.originatingTo);
-    if (!originTarget)
+    if (!originTarget) {
         return false;
-    const originAccount = normalizeAccountId(params.accountId);
+    }
+    const originAccount = normalizeOptionalAccountId(params.accountId);
     const sentTargets = params.messagingToolSentTargets ?? [];
-    if (sentTargets.length === 0)
+    if (sentTargets.length === 0) {
         return false;
+    }
     return sentTargets.some((target) => {
-        if (!target?.provider)
+        if (!target?.provider) {
             return false;
-        if (target.provider.trim().toLowerCase() !== provider)
+        }
+        if (target.provider.trim().toLowerCase() !== provider) {
             return false;
+        }
         const targetKey = normalizeTargetForProvider(provider, target.to);
-        if (!targetKey)
+        if (!targetKey) {
             return false;
-        const targetAccount = normalizeAccountId(target.accountId);
+        }
+        const targetAccount = normalizeOptionalAccountId(target.accountId);
         if (originAccount && targetAccount && originAccount !== targetAccount) {
             return false;
         }

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

@@ -4,23 +4,24 @@ export function createReplyReferencePlanner(options) {
     const existingId = options.existingId?.trim();
     const startId = options.startId?.trim();
     const use = () => {
-        if (!allowReference)
+        if (!allowReference) {
             return undefined;
-        if (existingId) {
-            hasReplied = true;
-            return existingId;
         }
-        if (!startId)
+        if (options.replyToMode === "off") {
             return undefined;
-        if (options.replyToMode === "off")
+        }
+        const id = existingId ?? startId;
+        if (!id) {
             return undefined;
+        }
         if (options.replyToMode === "all") {
             hasReplied = true;
-            return startId;
+            return id;
         }
+        // "first": only the first reply gets a reference.
         if (!hasReplied) {
             hasReplied = true;
-            return startId;
+            return id;
         }
         return undefined;
     };

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

@@ -9,7 +9,7 @@
 import { resolveSessionAgentId } from "../../agents/agent-scope.js";
 import { resolveEffectiveMessagesConfig } from "../../agents/identity.js";
 import { normalizeChannelId } from "../../channels/plugins/index.js";
-import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
+import { INTERNAL_MESSAGE_CHANNEL, normalizeMessageChannel } from "../../utils/message-channel.js";
 import { normalizeReplyPayload } from "./normalize-reply.js";
 /**
  * Routes a reply payload to the specified channel.
@@ -21,20 +21,25 @@ import { normalizeReplyPayload } from "./normalize-reply.js";
  */
 export async function routeReply(params) {
     const { payload, channel, to, accountId, threadId, cfg, abortSignal } = params;
-    // Debug: `pnpm test src/auto-reply/reply/route-reply.test.ts`
-    const responsePrefix = params.sessionKey
-        ? resolveEffectiveMessagesConfig(cfg, resolveSessionAgentId({
+    const normalizedChannel = normalizeMessageChannel(channel);
+    const resolvedAgentId = params.sessionKey
+        ? resolveSessionAgentId({
             sessionKey: params.sessionKey,
             config: cfg,
-        })).responsePrefix
+        })
+        : undefined;
+    // Debug: `pnpm test src/auto-reply/reply/route-reply.test.ts`
+    const responsePrefix = params.sessionKey
+        ? resolveEffectiveMessagesConfig(cfg, resolvedAgentId ?? resolveSessionAgentId({ config: cfg }), { channel: normalizedChannel, accountId }).responsePrefix
         : cfg.messages?.responsePrefix === "auto"
             ? undefined
             : cfg.messages?.responsePrefix;
     const normalized = normalizeReplyPayload(payload, {
         responsePrefix,
     });
-    if (!normalized)
+    if (!normalized) {
         return { ok: true };
+    }
     let text = normalized.text ?? "";
     let mediaUrls = (normalized.mediaUrls?.filter(Boolean) ?? []).length
         ? normalized.mediaUrls?.filter(Boolean)
@@ -74,11 +79,12 @@ export async function routeReply(params) {
             payloads: [normalized],
             replyToId: resolvedReplyToId ?? null,
             threadId: resolvedThreadId,
+            agentId: resolvedAgentId,
             abortSignal,
             mirror: params.mirror !== false && params.sessionKey
                 ? {
                     sessionKey: params.sessionKey,
-                    agentId: resolveSessionAgentId({ sessionKey: params.sessionKey, config: cfg }),
+                    agentId: resolvedAgentId,
                     text,
                     mediaUrls,
                 }
@@ -102,7 +108,8 @@ export async function routeReply(params) {
  * this generic interface.
  */
 export function isRoutableChannel(channel) {
-    if (!channel || channel === INTERNAL_MESSAGE_CHANNEL)
+    if (!channel || channel === INTERNAL_MESSAGE_CHANNEL) {
         return false;
+    }
     return normalizeChannelId(channel) !== null;
 }

package/dist/auto-reply/reply/session-reset-prompt.js

@@ -1 +1 @@
-export const BARE_SESSION_RESET_PROMPT = "A new session was started via /new or /reset. Greet the user in your configured persona, if one is provided. Be yourself - use your defined voice, mannerisms, and mood. Keep it to 1-3 sentences and ask what they want to do. If the runtime model differs from default_model in the system prompt, mention the default model. Do not mention internal steps, files, tools, or reasoning.";
+export const BARE_SESSION_RESET_PROMPT = "A new session was started via /new or /reset. Execute your Session Startup sequence now - read the required files before responding to the user. Then greet the user in your configured persona, if one is provided. Be yourself - use your defined voice, mannerisms, and mood. Keep it to 1-3 sentences and ask what they want to do. If the runtime model differs from default_model in the system prompt, mention the default model. Do not mention internal steps, files, tools, or reasoning.";