@takibeiy/moltbot_cn 2026.1.27 → 2026.2.1-beta.1

package/dist/config/schema.js

@@ -1,6 +1,6 @@
 import { CHANNEL_IDS } from "../channels/registry.js";
 import { VERSION } from "../version.js";
-import { MoltbotSchema } from "./zod-schema.js";
+import { OpenClawSchema } from "./zod-schema.js";
 const GROUP_LABELS = {
     wizard: "Wizard",
     update: "Update",
@@ -176,6 +176,7 @@ const FIELD_LABELS = {
     "agents.defaults.memorySearch": "Memory Search",
     "agents.defaults.memorySearch.enabled": "Enable Memory Search",
     "agents.defaults.memorySearch.sources": "Memory Search Sources",
+    "agents.defaults.memorySearch.extraPaths": "Extra Memory Paths",
     "agents.defaults.memorySearch.experimental.sessionMemory": "Memory Search Session Index (Experimental)",
     "agents.defaults.memorySearch.provider": "Memory Search Provider",
     "agents.defaults.memorySearch.remote.baseUrl": "Remote Embedding Base URL",
@@ -279,6 +280,8 @@ const FIELD_LABELS = {
     "channels.discord.maxLinesPerMessage": "Discord Max Lines Per Message",
     "channels.discord.intents.presence": "Discord Presence Intent",
     "channels.discord.intents.guildMembers": "Discord Guild Members Intent",
+    "channels.discord.pluralkit.enabled": "Discord PluralKit Enabled",
+    "channels.discord.pluralkit.token": "Discord PluralKit Token",
     "channels.slack.dm.policy": "Slack DM Policy",
     "channels.slack.allowBots": "Slack Allow Bot Messages",
     "channels.discord.token": "Discord Bot Token",
@@ -315,7 +318,7 @@ const FIELD_LABELS = {
     "plugins.installs.*.installedAt": "Plugin Install Time",
 };
 const FIELD_HELP = {
-    "meta.lastTouchedVersion": "Auto-set when Moltbot writes the config.",
+    "meta.lastTouchedVersion": "Auto-set when OpenClaw writes the config.",
     "meta.lastTouchedAt": "ISO timestamp of the last config write (auto-set).",
     "update.channel": 'Update channel for git + npm installs ("stable", "beta", or "dev").',
     "update.checkOnStart": "Check for npm updates when the gateway starts (default: true).",
@@ -327,7 +330,7 @@ const FIELD_HELP = {
     "discovery.mdns.mode": 'mDNS broadcast mode ("minimal" default, "full" includes cliPath/sshPort, "off" disables mDNS).',
     "gateway.auth.token": "Required by default for gateway access (unless using Tailscale Serve identity); required for non-loopback binds.",
     "gateway.auth.password": "Required for Tailscale funnel.",
-    "gateway.controlUi.basePath": "Optional URL prefix where the Control UI is served (e.g. /moltbot).",
+    "gateway.controlUi.basePath": "Optional URL prefix where the Control UI is served (e.g. /openclaw).",
     "gateway.controlUi.allowInsecureAuth": "Allow Control UI auth over insecure HTTP (token-only; not recommended).",
     "gateway.controlUi.dangerouslyDisableDeviceAuth": "DANGEROUS. Disable Control UI device identity checks (token/password only).",
     "gateway.http.endpoints.chatCompletions.enabled": "Enable the OpenAI-compatible `POST /v1/chat/completions` endpoint (default: false).",
@@ -341,7 +344,7 @@ const FIELD_HELP = {
     "nodeHost.browserProxy.allowProfiles": "Optional allowlist of browser profile names exposed via the node proxy.",
     "diagnostics.flags": 'Enable targeted diagnostics logs by flag (e.g. ["telegram.http"]). Supports wildcards like "telegram.*" or "*".',
     "diagnostics.cacheTrace.enabled": "Log cache trace snapshots for embedded agent runs (default: false).",
-    "diagnostics.cacheTrace.filePath": "JSONL output path for cache trace logs (default: $CLAWDBOT_STATE_DIR/logs/cache-trace.jsonl).",
+    "diagnostics.cacheTrace.filePath": "JSONL output path for cache trace logs (default: $OPENCLAW_STATE_DIR/logs/cache-trace.jsonl).",
     "diagnostics.cacheTrace.includeMessages": "Include full message payloads in trace output (default: true).",
     "diagnostics.cacheTrace.includePrompt": "Include prompt text in trace output (default: true).",
     "diagnostics.cacheTrace.includeSystem": "Include system prompt in trace output (default: true).",
@@ -401,6 +404,7 @@ const FIELD_HELP = {
     "agents.defaults.models": "Configured model catalog (keys are full provider/model IDs).",
     "agents.defaults.memorySearch": "Vector search over MEMORY.md and memory/*.md (per-agent overrides supported).",
     "agents.defaults.memorySearch.sources": 'Sources to index for memory search (default: ["memory"]; add "sessions" to include session transcripts).',
+    "agents.defaults.memorySearch.extraPaths": "Extra paths to include in memory search (directories or .md files; relative paths resolved from workspace).",
     "agents.defaults.memorySearch.experimental.sessionMemory": "Enable experimental session transcript indexing for memory search (default: false).",
     "agents.defaults.memorySearch.provider": 'Embedding provider ("openai", "gemini", or "local").',
     "agents.defaults.memorySearch.remote.baseUrl": "Custom base URL for remote embeddings (OpenAI-compatible proxies or Gemini overrides).",
@@ -413,7 +417,7 @@ const FIELD_HELP = {
     "agents.defaults.memorySearch.remote.batch.timeoutMinutes": "Timeout in minutes for batch indexing (default: 60).",
     "agents.defaults.memorySearch.local.modelPath": "Local GGUF model path or hf: URI (node-llama-cpp).",
     "agents.defaults.memorySearch.fallback": 'Fallback provider when embeddings fail ("openai", "gemini", "local", or "none").',
-    "agents.defaults.memorySearch.store.path": "SQLite index path (default: ~/.clawdbot/memory/{agentId}.sqlite).",
+    "agents.defaults.memorySearch.store.path": "SQLite index path (default: ~/.openclaw/memory/{agentId}.sqlite).",
     "agents.defaults.memorySearch.store.vector.enabled": "Enable sqlite-vec extension for vector search (default: true).",
     "agents.defaults.memorySearch.store.vector.extensionPath": "Optional override path to sqlite-vec extension library (.dylib/.so/.dll).",
     "agents.defaults.memorySearch.query.hybrid.enabled": "Enable hybrid BM25 + vector search for memory (default: true).",
@@ -435,11 +439,11 @@ const FIELD_HELP = {
     "plugins.entries": "Per-plugin settings keyed by plugin id (enable/disable + config payloads).",
     "plugins.entries.*.enabled": "Overrides plugin enable/disable for this entry (restart required).",
     "plugins.entries.*.config": "Plugin-defined config payload (schema is provided by the plugin).",
-    "plugins.installs": "CLI-managed install metadata (used by `moltbot plugins update` to locate install sources).",
+    "plugins.installs": "CLI-managed install metadata (used by `openclaw plugins update` to locate install sources).",
     "plugins.installs.*.source": 'Install source ("npm", "archive", or "path").',
     "plugins.installs.*.spec": "Original npm spec used for install (if source is npm).",
     "plugins.installs.*.sourcePath": "Original archive/path used for install (if any).",
-    "plugins.installs.*.installPath": "Resolved install directory (usually ~/.clawdbot/extensions/<id>).",
+    "plugins.installs.*.installPath": "Resolved install directory (usually ~/.openclaw/extensions/<id>).",
     "plugins.installs.*.version": "Version recorded at install time (if available).",
     "plugins.installs.*.installedAt": "ISO timestamp of last install/update.",
     "agents.list.*.identity.avatar": "Agent avatar (workspace-relative path, http(s) URL, or data URI).",
@@ -506,36 +510,42 @@ const FIELD_HELP = {
     "channels.discord.maxLinesPerMessage": "Soft max line count per Discord message (default: 17).",
     "channels.discord.intents.presence": "Enable the Guild Presences privileged intent. Must also be enabled in the Discord Developer Portal. Allows tracking user activities (e.g. Spotify). Default: false.",
     "channels.discord.intents.guildMembers": "Enable the Guild Members privileged intent. Must also be enabled in the Discord Developer Portal. Default: false.",
+    "channels.discord.pluralkit.enabled": "Resolve PluralKit proxied messages and treat system members as distinct senders.",
+    "channels.discord.pluralkit.token": "Optional PluralKit token for resolving private systems or members.",
     "channels.slack.dm.policy": 'Direct message access control ("pairing" recommended). "open" requires channels.slack.dm.allowFrom=["*"].',
 };
 const FIELD_PLACEHOLDERS = {
     "gateway.remote.url": "ws://host:18789",
     "gateway.remote.tlsFingerprint": "sha256:ab12cd34…",
     "gateway.remote.sshTarget": "user@host",
-    "gateway.controlUi.basePath": "/moltbot",
+    "gateway.controlUi.basePath": "/openclaw",
     "channels.mattermost.baseUrl": "https://chat.example.com",
-    "agents.list[].identity.avatar": "avatars/clawd.png",
+    "agents.list[].identity.avatar": "avatars/openclaw.png",
 };
 const SENSITIVE_PATTERNS = [/token/i, /password/i, /secret/i, /api.?key/i];
 function isSensitivePath(path) {
     return SENSITIVE_PATTERNS.some((pattern) => pattern.test(path));
 }
 function cloneSchema(value) {
-    if (typeof structuredClone === "function")
+    if (typeof structuredClone === "function") {
         return structuredClone(value);
+    }
     return JSON.parse(JSON.stringify(value));
 }
 function asSchemaObject(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
+    }
     return value;
 }
 function isObjectSchema(schema) {
     const type = schema.type;
-    if (type === "object")
+    if (type === "object") {
         return true;
-    if (Array.isArray(type) && type.includes("object"))
+    }
+    if (Array.isArray(type) && type.includes("object")) {
         return true;
+    }
     return Boolean(schema.properties || schema.additionalProperties);
 }
 function mergeObjectSchema(base, extension) {
@@ -552,8 +562,9 @@ function mergeObjectSchema(base, extension) {
         merged.required = Array.from(mergedRequired);
     }
     const additional = extension.additionalProperties ?? base.additionalProperties;
-    if (additional !== undefined)
+    if (additional !== undefined) {
         merged.additionalProperties = additional;
+    }
     return merged;
 }
 function buildBaseHints() {
@@ -592,8 +603,9 @@ function applyPluginHints(hints, plugins) {
     const next = { ...hints };
     for (const plugin of plugins) {
         const id = plugin.id.trim();
-        if (!id)
+        if (!id) {
             continue;
+        }
         const name = (plugin.name ?? id).trim() || id;
         const basePath = `plugins.entries.${id}`;
         next[basePath] = {
@@ -615,8 +627,9 @@ function applyPluginHints(hints, plugins) {
         const uiHints = plugin.configUiHints ?? {};
         for (const [relPathRaw, hint] of Object.entries(uiHints)) {
             const relPath = relPathRaw.trim().replace(/^\./, "");
-            if (!relPath)
+            if (!relPath) {
                 continue;
+            }
             const key = `${basePath}.config.${relPath}`;
             next[key] = {
                 ...next[key],
@@ -630,8 +643,9 @@ function applyChannelHints(hints, channels) {
     const next = { ...hints };
     for (const channel of channels) {
         const id = channel.id.trim();
-        if (!id)
+        if (!id) {
             continue;
+        }
         const basePath = `channels.${id}`;
         const current = next[basePath] ?? {};
         const label = channel.label?.trim();
@@ -644,8 +658,9 @@ function applyChannelHints(hints, channels) {
         const uiHints = channel.configUiHints ?? {};
         for (const [relPathRaw, hint] of Object.entries(uiHints)) {
             const relPath = relPathRaw.trim().replace(/^\./, "");
-            if (!relPath)
+            if (!relPath) {
                 continue;
+            }
             const key = `${basePath}.${relPath}`;
             next[key] = {
                 ...next[key],
@@ -660,15 +675,17 @@ function listHeartbeatTargetChannels(channels) {
     const ordered = [];
     for (const id of CHANNEL_IDS) {
         const normalized = id.trim().toLowerCase();
-        if (!normalized || seen.has(normalized))
+        if (!normalized || seen.has(normalized)) {
             continue;
+        }
         seen.add(normalized);
         ordered.push(normalized);
     }
     for (const channel of channels) {
         const normalized = channel.id.trim().toLowerCase();
-        if (!normalized || seen.has(normalized))
+        if (!normalized || seen.has(normalized)) {
             continue;
+        }
         seen.add(normalized);
         ordered.push(normalized);
     }
@@ -695,14 +712,16 @@ function applyPluginSchemas(schema, plugins) {
     const root = asSchemaObject(next);
     const pluginsNode = asSchemaObject(root?.properties?.plugins);
     const entriesNode = asSchemaObject(pluginsNode?.properties?.entries);
-    if (!entriesNode)
+    if (!entriesNode) {
         return next;
+    }
     const entryBase = asSchemaObject(entriesNode.additionalProperties);
     const entryProperties = entriesNode.properties ?? {};
     entriesNode.properties = entryProperties;
     for (const plugin of plugins) {
-        if (!plugin.configSchema)
+        if (!plugin.configSchema) {
             continue;
+        }
         const entrySchema = entryBase
             ? cloneSchema(entryBase)
             : { type: "object" };
@@ -727,13 +746,15 @@ function applyChannelSchemas(schema, channels) {
     const next = cloneSchema(schema);
     const root = asSchemaObject(next);
     const channelsNode = asSchemaObject(root?.properties?.channels);
-    if (!channelsNode)
+    if (!channelsNode) {
         return next;
+    }
     const channelProps = channelsNode.properties ?? {};
     channelsNode.properties = channelProps;
     for (const channel of channels) {
-        if (!channel.configSchema)
+        if (!channel.configSchema) {
             continue;
+        }
         const existing = asSchemaObject(channelProps[channel.id]);
         const incoming = asSchemaObject(channel.configSchema);
         if (existing && incoming && isObjectSchema(existing) && isObjectSchema(incoming)) {
@@ -749,8 +770,9 @@ let cachedBase = null;
 function stripChannelSchema(schema) {
     const next = cloneSchema(schema);
     const root = asSchemaObject(next);
-    if (!root || !root.properties)
+    if (!root || !root.properties) {
         return next;
+    }
     const channelsNode = asSchemaObject(root.properties.channels);
     if (channelsNode) {
         channelsNode.properties = {};
@@ -760,13 +782,14 @@ function stripChannelSchema(schema) {
     return next;
 }
 function buildBaseConfigSchema() {
-    if (cachedBase)
+    if (cachedBase) {
         return cachedBase;
-    const schema = MoltbotSchema.toJSONSchema({
+    }
+    const schema = OpenClawSchema.toJSONSchema({
         target: "draft-07",
         unrepresentable: "any",
     });
-    schema.title = "MoltbotConfig";
+    schema.title = "OpenClawConfig";
     const hints = applySensitiveHints(buildBaseHints());
     const next = {
         schema: stripChannelSchema(schema),
@@ -781,8 +804,9 @@ export function buildConfigSchema(params) {
     const base = buildBaseConfigSchema();
     const plugins = params?.plugins ?? [];
     const channels = params?.channels ?? [];
-    if (plugins.length === 0 && channels.length === 0)
+    if (plugins.length === 0 && channels.length === 0) {
         return base;
+    }
     const mergedHints = applySensitiveHints(applyHeartbeatTargetHints(applyChannelHints(applyPluginHints(base.uiHints, plugins), channels), channels));
     const mergedSchema = applyChannelSchemas(applyPluginSchemas(base.schema, plugins), channels);
     return {

package/dist/config/sessions/group.d.ts

@@ -0,0 +1,11 @@
+import type { MsgContext } from "../../auto-reply/templating.js";
+import type { GroupKeyResolution } from "./types.js";
+export declare function buildGroupDisplayName(params: {
+    provider?: string;
+    subject?: string;
+    groupChannel?: string;
+    space?: string;
+    id?: string;
+    key: string;
+}): string;
+export declare function resolveGroupSessionKey(ctx: MsgContext): GroupKeyResolution | null;

package/dist/config/sessions/group.js

@@ -2,18 +2,21 @@ import { listDeliverableMessageChannels } from "../../utils/message-channel.js";
 const getGroupSurfaces = () => new Set([...listDeliverableMessageChannels(), "webchat"]);
 function normalizeGroupLabel(raw) {
     const trimmed = raw?.trim().toLowerCase() ?? "";
-    if (!trimmed)
+    if (!trimmed) {
         return "";
+    }
     const dashed = trimmed.replace(/\s+/g, "-");
     const cleaned = dashed.replace(/[^a-z0-9#@._+-]+/g, "-");
     return cleaned.replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
 }
 function shortenGroupId(value) {
     const trimmed = value?.trim() ?? "";
-    if (!trimmed)
+    if (!trimmed) {
         return "";
-    if (trimmed.length <= 14)
+    }
+    if (trimmed.length <= 14) {
         return trimmed;
+    }
     return `${trimmed.slice(0, 6)}...${trimmed.slice(-4)}`;
 }
 export function buildGroupDisplayName(params) {
@@ -48,8 +51,9 @@ export function resolveGroupSessionKey(ctx) {
         from.includes(":group:") ||
         from.includes(":channel:") ||
         isWhatsAppGroupId;
-    if (!looksLikeGroup)
+    if (!looksLikeGroup) {
         return null;
+    }
     const providerHint = ctx.Provider?.trim().toLowerCase();
     const parts = from.split(":").filter(Boolean);
     const head = parts[0]?.trim().toLowerCase() ?? "";
@@ -57,8 +61,9 @@ export function resolveGroupSessionKey(ctx) {
     const provider = headIsSurface
         ? head
         : (providerHint ?? (isWhatsAppGroupId ? "whatsapp" : undefined));
-    if (!provider)
+    if (!provider) {
         return null;
+    }
     const second = parts[1]?.trim().toLowerCase();
     const secondIsKind = second === "group" || second === "channel";
     const kind = secondIsKind
@@ -72,8 +77,9 @@ export function resolveGroupSessionKey(ctx) {
             : parts.slice(1).join(":")
         : from;
     const finalId = id.trim().toLowerCase();
-    if (!finalId)
+    if (!finalId) {
         return null;
+    }
     return {
         key: `${provider}:${kind}:${finalId}`,
         channel: provider,

package/dist/config/sessions/main-session.d.ts

@@ -0,0 +1,43 @@
+import type { SessionScope } from "./types.js";
+import { resolveAgentIdFromSessionKey } from "../../routing/session-key.js";
+export declare function resolveMainSessionKey(cfg?: {
+    session?: {
+        scope?: SessionScope;
+        mainKey?: string;
+    };
+    agents?: {
+        list?: Array<{
+            id?: string;
+            default?: boolean;
+        }>;
+    };
+}): string;
+export declare function resolveMainSessionKeyFromConfig(): string;
+export { resolveAgentIdFromSessionKey };
+export declare function resolveAgentMainSessionKey(params: {
+    cfg?: {
+        session?: {
+            mainKey?: string;
+        };
+    };
+    agentId: string;
+}): string;
+export declare function resolveExplicitAgentSessionKey(params: {
+    cfg?: {
+        session?: {
+            scope?: SessionScope;
+            mainKey?: string;
+        };
+    };
+    agentId?: string | null;
+}): string | undefined;
+export declare function canonicalizeMainSessionAlias(params: {
+    cfg?: {
+        session?: {
+            scope?: SessionScope;
+            mainKey?: string;
+        };
+    };
+    agentId: string;
+    sessionKey: string;
+}): string;

package/dist/config/sessions/main-session.js

@@ -1,8 +1,9 @@
 import { buildAgentMainSessionKey, DEFAULT_AGENT_ID, normalizeAgentId, normalizeMainKey, resolveAgentIdFromSessionKey, } from "../../routing/session-key.js";
 import { loadConfig } from "../config.js";
 export function resolveMainSessionKey(cfg) {
-    if (cfg?.session?.scope === "global")
+    if (cfg?.session?.scope === "global") {
         return "global";
+    }
     const agents = cfg?.agents?.list ?? [];
     const defaultAgentId = agents.find((agent) => agent?.default)?.id ?? agents[0]?.id ?? DEFAULT_AGENT_ID;
     const agentId = normalizeAgentId(defaultAgentId);
@@ -19,14 +20,16 @@ export function resolveAgentMainSessionKey(params) {
 }
 export function resolveExplicitAgentSessionKey(params) {
     const agentId = params.agentId?.trim();
-    if (!agentId)
+    if (!agentId) {
         return undefined;
+    }
     return resolveAgentMainSessionKey({ cfg: params.cfg, agentId });
 }
 export function canonicalizeMainSessionAlias(params) {
     const raw = params.sessionKey.trim();
-    if (!raw)
+    if (!raw) {
         return raw;
+    }
     const agentId = normalizeAgentId(params.agentId);
     const mainKey = normalizeMainKey(params.cfg?.session?.mainKey);
     const agentMainSessionKey = buildAgentMainSessionKey({ agentId, mainKey });
@@ -35,9 +38,11 @@ export function canonicalizeMainSessionAlias(params) {
         mainKey: "main",
     });
     const isMainAlias = raw === "main" || raw === mainKey || raw === agentMainSessionKey || raw === agentMainAliasKey;
-    if (params.cfg?.session?.scope === "global" && isMainAlias)
+    if (params.cfg?.session?.scope === "global" && isMainAlias) {
         return "global";
-    if (isMainAlias)
+    }
+    if (isMainAlias) {
         return agentMainSessionKey;
+    }
     return raw;
 }

package/dist/config/sessions/metadata.d.ts

@@ -0,0 +1,16 @@
+import type { MsgContext } from "../../auto-reply/templating.js";
+import type { GroupKeyResolution, SessionEntry, SessionOrigin } from "./types.js";
+export declare function deriveSessionOrigin(ctx: MsgContext): SessionOrigin | undefined;
+export declare function snapshotSessionOrigin(entry?: SessionEntry): SessionOrigin | undefined;
+export declare function deriveGroupSessionPatch(params: {
+    ctx: MsgContext;
+    sessionKey: string;
+    existing?: SessionEntry;
+    groupResolution?: GroupKeyResolution | null;
+}): Partial<SessionEntry> | null;
+export declare function deriveSessionMetaPatch(params: {
+    ctx: MsgContext;
+    sessionKey: string;
+    existing?: SessionEntry;
+    groupResolution?: GroupKeyResolution | null;
+}): Partial<SessionEntry> | null;

package/dist/config/sessions/metadata.js

@@ -5,25 +5,34 @@ import { normalizeChannelId } from "../../channels/plugins/index.js";
 import { normalizeMessageChannel } from "../../utils/message-channel.js";
 import { buildGroupDisplayName, resolveGroupSessionKey } from "./group.js";
 const mergeOrigin = (existing, next) => {
-    if (!existing && !next)
+    if (!existing && !next) {
         return undefined;
+    }
     const merged = existing ? { ...existing } : {};
-    if (next?.label)
+    if (next?.label) {
         merged.label = next.label;
-    if (next?.provider)
+    }
+    if (next?.provider) {
         merged.provider = next.provider;
-    if (next?.surface)
+    }
+    if (next?.surface) {
         merged.surface = next.surface;
-    if (next?.chatType)
+    }
+    if (next?.chatType) {
         merged.chatType = next.chatType;
-    if (next?.from)
+    }
+    if (next?.from) {
         merged.from = next.from;
-    if (next?.to)
+    }
+    if (next?.to) {
         merged.to = next.to;
-    if (next?.accountId)
+    }
+    if (next?.accountId) {
         merged.accountId = next.accountId;
-    if (next?.threadId != null && next.threadId !== "")
+    }
+    if (next?.threadId != null && next.threadId !== "") {
         merged.threadId = next.threadId;
+    }
     return Object.keys(merged).length > 0 ? merged : undefined;
 };
 export function deriveSessionOrigin(ctx) {
@@ -39,33 +48,43 @@ export function deriveSessionOrigin(ctx) {
     const accountId = ctx.AccountId?.trim();
     const threadId = ctx.MessageThreadId ?? undefined;
     const origin = {};
-    if (label)
+    if (label) {
         origin.label = label;
-    if (provider)
+    }
+    if (provider) {
         origin.provider = provider;
-    if (surface)
+    }
+    if (surface) {
         origin.surface = surface;
-    if (chatType)
+    }
+    if (chatType) {
         origin.chatType = chatType;
-    if (from)
+    }
+    if (from) {
         origin.from = from;
-    if (to)
+    }
+    if (to) {
         origin.to = to;
-    if (accountId)
+    }
+    if (accountId) {
         origin.accountId = accountId;
-    if (threadId != null && threadId !== "")
+    }
+    if (threadId != null && threadId !== "") {
         origin.threadId = threadId;
+    }
     return Object.keys(origin).length > 0 ? origin : undefined;
 }
 export function snapshotSessionOrigin(entry) {
-    if (!entry?.origin)
+    if (!entry?.origin) {
         return undefined;
+    }
     return { ...entry.origin };
 }
 export function deriveGroupSessionPatch(params) {
     const resolution = params.groupResolution ?? resolveGroupSessionKey(params.ctx);
-    if (!resolution?.channel)
+    if (!resolution?.channel) {
         return null;
+    }
     const channel = resolution.channel;
     const subject = params.ctx.GroupSubject?.trim();
     const space = params.ctx.GroupSpace?.trim();
@@ -83,12 +102,15 @@ export function deriveGroupSessionPatch(params) {
         channel,
         groupId: resolution.id,
     };
-    if (nextSubject)
+    if (nextSubject) {
         patch.subject = nextSubject;
-    if (nextGroupChannel)
+    }
+    if (nextGroupChannel) {
         patch.groupChannel = nextGroupChannel;
-    if (space)
+    }
+    if (space) {
         patch.space = space;
+    }
     const displayName = buildGroupDisplayName({
         provider: channel,
         subject: nextSubject ?? params.existing?.subject,
@@ -97,18 +119,21 @@ export function deriveGroupSessionPatch(params) {
         id: resolution.id,
         key: params.sessionKey,
     });
-    if (displayName)
+    if (displayName) {
         patch.displayName = displayName;
+    }
     return patch;
 }
 export function deriveSessionMetaPatch(params) {
     const groupPatch = deriveGroupSessionPatch(params);
     const origin = deriveSessionOrigin(params.ctx);
-    if (!groupPatch && !origin)
+    if (!groupPatch && !origin) {
         return null;
+    }
     const patch = groupPatch ? { ...groupPatch } : {};
     const mergedOrigin = mergeOrigin(params.existing?.origin, origin);
-    if (mergedOrigin)
+    if (mergedOrigin) {
         patch.origin = mergedOrigin;
+    }
     return Object.keys(patch).length > 0 ? patch : null;
 }

package/dist/config/sessions/paths.d.ts

@@ -0,0 +1,11 @@
+import type { SessionEntry } from "./types.js";
+export declare function resolveSessionTranscriptsDir(env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare function resolveSessionTranscriptsDirForAgent(agentId?: string, env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare function resolveDefaultSessionStorePath(agentId?: string): string;
+export declare function resolveSessionTranscriptPath(sessionId: string, agentId?: string, topicId?: string | number): string;
+export declare function resolveSessionFilePath(sessionId: string, entry?: SessionEntry, opts?: {
+    agentId?: string;
+}): string;
+export declare function resolveStorePath(store?: string, opts?: {
+    agentId?: string;
+}): string;

package/dist/config/sessions/paths.js

@@ -31,8 +31,9 @@ export function resolveSessionFilePath(sessionId, entry, opts) {
 }
 export function resolveStorePath(store, opts) {
     const agentId = normalizeAgentId(opts?.agentId ?? DEFAULT_AGENT_ID);
-    if (!store)
+    if (!store) {
         return resolveDefaultSessionStorePath(agentId);
+    }
     if (store.includes("{agentId}")) {
         const expanded = store.replaceAll("{agentId}", agentId);
         if (expanded.startsWith("~")) {
@@ -40,7 +41,8 @@ export function resolveStorePath(store, opts) {
         }
         return path.resolve(expanded);
     }
-    if (store.startsWith("~"))
+    if (store.startsWith("~")) {
         return path.resolve(store.replace(/^~(?=$|[\\/])/, os.homedir()));
+    }
     return path.resolve(store);
 }