@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/hooks/bundled/session-memory/handler.js

@@ -1,26 +1,30 @@
 /**
  * Session memory hook handler
  *
- * Saves session context to memory when /new command is triggered
+ * Saves session context to memory when /new or /reset command is triggered
  * Creates a new dated memory file with LLM-generated slug
  */
 import fs from "node:fs/promises";
-import path from "node:path";
 import os from "node:os";
+import path from "node:path";
 import { resolveAgentWorkspaceDir } from "../../../agents/agent-scope.js";
+import { resolveStateDir } from "../../../config/paths.js";
+import { createSubsystemLogger } from "../../../logging/subsystem.js";
 import { resolveAgentIdFromSessionKey } from "../../../routing/session-key.js";
+import { hasInterSessionUserProvenance } from "../../../sessions/input-provenance.js";
+import { resolveHookConfig } from "../../config.js";
+import { generateSlugViaLLM } from "../../llm-slug-generator.js";
+const log = createSubsystemLogger("hooks/session-memory");
 /**
  * Read recent messages from session file for slug generation
  */
-async function getRecentSessionContent(sessionFilePath) {
+async function getRecentSessionContent(sessionFilePath, messageCount = 15) {
     try {
         const content = await fs.readFile(sessionFilePath, "utf-8");
         const lines = content.trim().split("\n");
-        // Get last 15 lines (recent conversation)
-        const recentLines = lines.slice(-15);
-        // Parse JSONL and extract messages
-        const messages = [];
-        for (const line of recentLines) {
+        // Parse JSONL and extract user/assistant messages first
+        const allMessages = [];
+        for (const line of lines) {
             try {
                 const entry = JSON.parse(line);
                 // Session files have entries with type="message" containing a nested message object
@@ -28,12 +32,16 @@ async function getRecentSessionContent(sessionFilePath) {
                     const msg = entry.message;
                     const role = msg.role;
                     if ((role === "user" || role === "assistant") && msg.content) {
+                        if (role === "user" && hasInterSessionUserProvenance(msg)) {
+                            continue;
+                        }
                         // Extract text content
                         const text = Array.isArray(msg.content)
-                            ? msg.content.find((c) => c.type === "text")?.text
+                            ? // biome-ignore lint/suspicious/noExplicitAny: required
+                                msg.content.find((c) => c.type === "text")?.text
                             : msg.content;
                         if (text && !text.startsWith("/")) {
-                            messages.push(`${role}: ${text}`);
+                            allMessages.push(`${role}: ${text}`);
                         }
                     }
                 }
@@ -42,71 +50,186 @@ async function getRecentSessionContent(sessionFilePath) {
                 // Skip invalid JSON lines
             }
         }
-        return messages.join("\n");
+        // Then slice to get exactly messageCount messages
+        const recentMessages = allMessages.slice(-messageCount);
+        return recentMessages.join("\n");
     }
     catch {
         return null;
     }
 }
 /**
- * Save session context to memory when /new command is triggered
+ * Try the active transcript first; if /new already rotated it,
+ * fallback to the latest .jsonl.reset.* sibling.
+ */
+async function getRecentSessionContentWithResetFallback(sessionFilePath, messageCount = 15) {
+    const primary = await getRecentSessionContent(sessionFilePath, messageCount);
+    if (primary) {
+        return primary;
+    }
+    try {
+        const dir = path.dirname(sessionFilePath);
+        const base = path.basename(sessionFilePath);
+        const resetPrefix = `${base}.reset.`;
+        const files = await fs.readdir(dir);
+        const resetCandidates = files.filter((name) => name.startsWith(resetPrefix)).toSorted();
+        if (resetCandidates.length === 0) {
+            return primary;
+        }
+        const latestResetPath = path.join(dir, resetCandidates[resetCandidates.length - 1]);
+        const fallback = await getRecentSessionContent(latestResetPath, messageCount);
+        if (fallback) {
+            log.debug("Loaded session content from reset fallback", {
+                sessionFilePath,
+                latestResetPath,
+            });
+        }
+        return fallback || primary;
+    }
+    catch {
+        return primary;
+    }
+}
+function stripResetSuffix(fileName) {
+    const resetIndex = fileName.indexOf(".reset.");
+    return resetIndex === -1 ? fileName : fileName.slice(0, resetIndex);
+}
+async function findPreviousSessionFile(params) {
+    try {
+        const files = await fs.readdir(params.sessionsDir);
+        const fileSet = new Set(files);
+        const baseFromReset = params.currentSessionFile
+            ? stripResetSuffix(path.basename(params.currentSessionFile))
+            : undefined;
+        if (baseFromReset && fileSet.has(baseFromReset)) {
+            return path.join(params.sessionsDir, baseFromReset);
+        }
+        const trimmedSessionId = params.sessionId?.trim();
+        if (trimmedSessionId) {
+            const canonicalFile = `${trimmedSessionId}.jsonl`;
+            if (fileSet.has(canonicalFile)) {
+                return path.join(params.sessionsDir, canonicalFile);
+            }
+            const topicVariants = files
+                .filter((name) => name.startsWith(`${trimmedSessionId}-topic-`) &&
+                name.endsWith(".jsonl") &&
+                !name.includes(".reset."))
+                .toSorted()
+                .toReversed();
+            if (topicVariants.length > 0) {
+                return path.join(params.sessionsDir, topicVariants[0]);
+            }
+        }
+        if (!params.currentSessionFile) {
+            return undefined;
+        }
+        const nonResetJsonl = files
+            .filter((name) => name.endsWith(".jsonl") && !name.includes(".reset."))
+            .toSorted()
+            .toReversed();
+        if (nonResetJsonl.length > 0) {
+            return path.join(params.sessionsDir, nonResetJsonl[0]);
+        }
+    }
+    catch {
+        // Ignore directory read errors.
+    }
+    return undefined;
+}
+/**
+ * Save session context to memory when /new or /reset command is triggered
  */
 const saveSessionToMemory = async (event) => {
-    // Only trigger on 'new' command
-    if (event.type !== "command" || event.action !== "new") {
+    // Only trigger on reset/new commands
+    const isResetCommand = event.action === "new" || event.action === "reset";
+    if (event.type !== "command" || !isResetCommand) {
         return;
     }
     try {
-        console.log("[session-memory] Hook triggered for /new command");
+        log.debug("Hook triggered for reset/new command", { action: event.action });
         const context = event.context || {};
         const cfg = context.cfg;
         const agentId = resolveAgentIdFromSessionKey(event.sessionKey);
         const workspaceDir = cfg
             ? resolveAgentWorkspaceDir(cfg, agentId)
-            : path.join(os.homedir(), "clawd");
+            : path.join(resolveStateDir(process.env, os.homedir), "workspace");
         const memoryDir = path.join(workspaceDir, "memory");
         await fs.mkdir(memoryDir, { recursive: true });
         // Get today's date for filename
         const now = new Date(event.timestamp);
         const dateStr = now.toISOString().split("T")[0]; // YYYY-MM-DD
         // Generate descriptive slug from session using LLM
+        // Prefer previousSessionEntry (old session before /new) over current (which may be empty)
         const sessionEntry = (context.previousSessionEntry || context.sessionEntry || {});
         const currentSessionId = sessionEntry.sessionId;
-        const currentSessionFile = sessionEntry.sessionFile;
-        console.log("[session-memory] Current sessionId:", currentSessionId);
-        console.log("[session-memory] Current sessionFile:", currentSessionFile);
-        console.log("[session-memory] cfg present:", !!cfg);
+        let currentSessionFile = sessionEntry.sessionFile || undefined;
+        // If sessionFile is empty or looks like a new/reset file, try to find the previous session file.
+        if (!currentSessionFile || currentSessionFile.includes(".reset.")) {
+            const sessionsDirs = new Set();
+            if (currentSessionFile) {
+                sessionsDirs.add(path.dirname(currentSessionFile));
+            }
+            sessionsDirs.add(path.join(workspaceDir, "sessions"));
+            for (const sessionsDir of sessionsDirs) {
+                const recoveredSessionFile = await findPreviousSessionFile({
+                    sessionsDir,
+                    currentSessionFile,
+                    sessionId: currentSessionId,
+                });
+                if (!recoveredSessionFile) {
+                    continue;
+                }
+                currentSessionFile = recoveredSessionFile;
+                log.debug("Found previous session file", { file: currentSessionFile });
+                break;
+            }
+        }
+        log.debug("Session context resolved", {
+            sessionId: currentSessionId,
+            sessionFile: currentSessionFile,
+            hasCfg: Boolean(cfg),
+        });
         const sessionFile = currentSessionFile || undefined;
+        // Read message count from hook config (default: 15)
+        const hookConfig = resolveHookConfig(cfg, "session-memory");
+        const messageCount = typeof hookConfig?.messages === "number" && hookConfig.messages > 0
+            ? hookConfig.messages
+            : 15;
         let slug = null;
         let sessionContent = null;
         if (sessionFile) {
-            // Get recent conversation content
-            sessionContent = await getRecentSessionContent(sessionFile);
-            console.log("[session-memory] sessionContent length:", sessionContent?.length || 0);
-            if (sessionContent && cfg) {
-                console.log("[session-memory] Calling generateSlugViaLLM...");
-                // Dynamically import the LLM slug generator (avoids module caching issues)
-                // When compiled, handler is at dist/hooks/bundled/session-memory/handler.js
-                // Going up ../.. puts us at dist/hooks/, so just add llm-slug-generator.js
-                const poolbotRoot = path.resolve(path.dirname(import.meta.url.replace("file://", "")), "../..");
-                const slugGenPath = path.join(poolbotRoot, "llm-slug-generator.js");
-                const { generateSlugViaLLM } = await import(slugGenPath);
+            // Get recent conversation content, with fallback to rotated reset transcript.
+            sessionContent = await getRecentSessionContentWithResetFallback(sessionFile, messageCount);
+            log.debug("Session content loaded", {
+                length: sessionContent?.length ?? 0,
+                messageCount,
+            });
+            // Avoid calling the model provider in unit tests; keep hooks fast and deterministic.
+            const isTestEnv = process.env.POOLBOT_TEST_FAST === "1" ||
+                process.env.VITEST === "true" ||
+                process.env.VITEST === "1" ||
+                process.env.NODE_ENV === "test";
+            const allowLlmSlug = !isTestEnv && hookConfig?.llmSlug !== false;
+            if (sessionContent && cfg && allowLlmSlug) {
+                log.debug("Calling generateSlugViaLLM...");
                 // Use LLM to generate a descriptive slug
                 slug = await generateSlugViaLLM({ sessionContent, cfg });
-                console.log("[session-memory] Generated slug:", slug);
+                log.debug("Generated slug", { slug });
             }
         }
         // If no slug, use timestamp
         if (!slug) {
             const timeSlug = now.toISOString().split("T")[1].split(".")[0].replace(/:/g, "");
             slug = timeSlug.slice(0, 4); // HHMM
-            console.log("[session-memory] Using fallback timestamp slug:", slug);
+            log.debug("Using fallback timestamp slug", { slug });
         }
         // Create filename with date and slug
         const filename = `${dateStr}-${slug}.md`;
         const memoryFilePath = path.join(memoryDir, filename);
-        console.log("[session-memory] Generated filename:", filename);
-        console.log("[session-memory] Full path:", memoryFilePath);
+        log.debug("Memory file path resolved", {
+            filename,
+            path: memoryFilePath.replace(os.homedir(), "~"),
+        });
         // Format time as HH:MM:SS UTC
         const timeStr = now.toISOString().split("T")[1].split(".")[0];
         // Extract context details
@@ -128,13 +251,22 @@ const saveSessionToMemory = async (event) => {
         const entry = entryParts.join("\n");
         // Write to new memory file
         await fs.writeFile(memoryFilePath, entry, "utf-8");
-        console.log("[session-memory] Memory file written successfully");
+        log.debug("Memory file written successfully");
         // Log completion (but don't send user-visible confirmation - it's internal housekeeping)
         const relPath = memoryFilePath.replace(os.homedir(), "~");
-        console.log(`[session-memory] Session context saved to ${relPath}`);
+        log.info(`Session context saved to ${relPath}`);
     }
     catch (err) {
-        console.error("[session-memory] Failed to save session memory:", err instanceof Error ? err.message : String(err));
+        if (err instanceof Error) {
+            log.error("Failed to save session memory", {
+                errorName: err.name,
+                errorMessage: err.message,
+                stack: err.stack,
+            });
+        }
+        else {
+            log.error("Failed to save session memory", { error: String(err) });
+        }
     }
 };
 export default saveSessionToMemory;

package/dist/hooks/frontmatter.js

@@ -1,10 +1,10 @@
 import { parseFrontmatterBlock } from "../markdown/frontmatter.js";
-import { getFrontmatterString, normalizeStringList, parsePoolbotManifestInstallBase, parseFrontmatterBool, resolvePoolbotManifestBlock, resolvePoolbotManifestInstall, resolvePoolbotManifestOs, resolvePoolbotManifestRequires, } from "../shared/frontmatter.js";
+import { getFrontmatterString, normalizeStringList, parsePoolBotManifestInstallBase, parseFrontmatterBool, resolvePoolBotManifestBlock, resolvePoolBotManifestInstall, resolvePoolBotManifestOs, resolvePoolBotManifestRequires, } from "../shared/frontmatter.js";
 export function parseFrontmatter(content) {
     return parseFrontmatterBlock(content);
 }
 function parseInstallSpec(input) {
-    const parsed = parsePoolbotManifestInstallBase(input, ["bundled", "npm", "git"]);
+    const parsed = parsePoolBotManifestInstallBase(input, ["bundled", "npm", "git"]);
     if (!parsed) {
         return undefined;
     }
@@ -30,13 +30,13 @@ function parseInstallSpec(input) {
     return spec;
 }
 export function resolvePoolbotMetadata(frontmatter) {
-    const metadataObj = resolvePoolbotManifestBlock({ frontmatter });
+    const metadataObj = resolvePoolBotManifestBlock({ frontmatter });
     if (!metadataObj) {
         return undefined;
     }
-    const requires = resolvePoolbotManifestRequires(metadataObj);
-    const install = resolvePoolbotManifestInstall(metadataObj, parseInstallSpec);
-    const osRaw = resolvePoolbotManifestOs(metadataObj);
+    const requires = resolvePoolBotManifestRequires(metadataObj);
+    const install = resolvePoolBotManifestInstall(metadataObj, parseInstallSpec);
+    const osRaw = resolvePoolBotManifestOs(metadataObj);
     const eventsRaw = normalizeStringList(metadataObj.events);
     return {
         always: typeof metadataObj.always === "boolean" ? metadataObj.always : undefined,

package/dist/hooks/gmail-watcher-lifecycle.js

@@ -0,0 +1,23 @@
+import { isTruthyEnvValue } from "../infra/env.js";
+import { startGmailWatcher } from "./gmail-watcher.js";
+export async function startGmailWatcherWithLogs(params) {
+    if (isTruthyEnvValue(process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
+        params.onSkipped?.();
+        return;
+    }
+    try {
+        const gmailResult = await startGmailWatcher(params.cfg);
+        if (gmailResult.started) {
+            params.log.info("gmail watcher started");
+            return;
+        }
+        if (gmailResult.reason &&
+            gmailResult.reason !== "hooks not enabled" &&
+            gmailResult.reason !== "no gmail account configured") {
+            params.log.warn(`gmail watcher not started: ${gmailResult.reason}`);
+        }
+    }
+    catch (err) {
+        params.log.error(`gmail watcher failed to start: ${String(err)}`);
+    }
+}

package/dist/hooks/gmail-watcher.js

@@ -8,8 +8,8 @@ import { spawn } from "node:child_process";
 import { hasBinary } from "../agents/skills.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
 import { runCommandWithTimeout } from "../process/exec.js";
-import { buildGogWatchServeArgs, buildGogWatchStartArgs, resolveGmailHookRuntimeConfig, } from "./gmail.js";
 import { ensureTailscaleEndpoint } from "./gmail-setup-utils.js";
+import { buildGogWatchServeArgs, buildGogWatchStartArgs, resolveGmailHookRuntimeConfig, } from "./gmail.js";
 const log = createSubsystemLogger("gmail-watcher");
 const ADDRESS_IN_USE_RE = /address already in use|EADDRINUSE/i;
 export function isAddressInUseError(line) {
@@ -58,13 +58,15 @@ function spawnGogServe(cfg) {
     });
     child.stdout?.on("data", (data) => {
         const line = data.toString().trim();
-        if (line)
+        if (line) {
             log.info(`[gog] ${line}`);
+        }
     });
     child.stderr?.on("data", (data) => {
         const line = data.toString().trim();
-        if (!line)
+        if (!line) {
             return;
+        }
         if (isAddressInUseError(line)) {
             addressInUse = true;
         }
@@ -74,8 +76,9 @@ function spawnGogServe(cfg) {
         log.error(`gog process error: ${String(err)}`);
     });
     child.on("exit", (code, signal) => {
-        if (shuttingDown)
+        if (shuttingDown) {
             return;
+        }
         if (addressInUse) {
             log.warn("gog serve failed to bind (address already in use); stopping restarts. " +
                 "Another watcher is likely running. Set POOLBOT_SKIP_GMAIL_WATCHER=1 or stop the other process.");
@@ -85,8 +88,9 @@ function spawnGogServe(cfg) {
         log.warn(`gog exited (code=${code}, signal=${signal}); restarting in 5s`);
         watcherProcess = null;
         setTimeout(() => {
-            if (shuttingDown || !currentConfig)
+            if (shuttingDown || !currentConfig) {
                 return;
+            }
             watcherProcess = spawnGogServe(currentConfig);
         }, 5000);
     });
@@ -146,8 +150,9 @@ export async function startGmailWatcher(cfg) {
     // Set up renewal interval
     const renewMs = runtimeConfig.renewEveryMinutes * 60_000;
     renewInterval = setInterval(() => {
-        if (shuttingDown)
+        if (shuttingDown) {
             return;
+        }
         void startGmailWatch(runtimeConfig);
     }, renewMs);
     log.info(`gmail watcher started for ${runtimeConfig.account} (renew every ${runtimeConfig.renewEveryMinutes}m)`);

package/dist/hooks/internal-hooks.js

@@ -4,8 +4,10 @@
  * Provides an extensible event-driven hook system for agent events
  * like command processing, session lifecycle, etc.
  */
+import { createSubsystemLogger } from "../logging/subsystem.js";
 /** Registry of hook handlers by event key */
 const handlers = new Map();
+const log = createSubsystemLogger("internal-hooks");
 /**
  * Register a hook handler for a specific event type or event:action combination
  *
@@ -87,7 +89,8 @@ export async function triggerInternalHook(event) {
             await handler(event);
         }
         catch (err) {
-            console.error(`Hook error [${event.type}:${event.action}]:`, err instanceof Error ? err.message : String(err));
+            const message = err instanceof Error ? err.message : String(err);
+            log.error(`Hook error [${event.type}:${event.action}]: ${message}`);
         }
     }
 }
@@ -122,6 +125,13 @@ export function isAgentBootstrapEvent(event) {
     }
     return Array.isArray(context.bootstrapFiles);
 }
+export function isGatewayStartupEvent(event) {
+    if (event.type !== "gateway" || event.action !== "startup") {
+        return false;
+    }
+    const context = event.context;
+    return Boolean(context && typeof context === "object");
+}
 export function isMessageReceivedEvent(event) {
     if (event.type !== "message" || event.action !== "received") {
         return false;

package/dist/hooks/llm-slug-generator.js

@@ -6,6 +6,8 @@ import os from "node:os";
 import path from "node:path";
 import { runEmbeddedPiAgent } from "../agents/pi-embedded.js";
 import { resolveDefaultAgentId, resolveAgentWorkspaceDir, resolveAgentDir, } from "../agents/agent-scope.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("llm-slug-generator");
 /**
  * Generate a short 1-2 word filename slug from session content using LLM
  */
@@ -53,7 +55,8 @@ Reply with ONLY the slug, nothing else. Examples: "vendor-pitch", "api-design",
         return null;
     }
     catch (err) {
-        console.error("[llm-slug-generator] Failed to generate slug:", err);
+        const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+        log.error(`Failed to generate slug: ${message}`);
         return null;
     }
     finally {

package/dist/hooks/workspace.js

@@ -1,17 +1,21 @@
 import fs from "node:fs";
 import path from "node:path";
-import { LEGACY_MANIFEST_KEY } from "../compat/legacy-names.js";
+import { MANIFEST_KEY } from "../compat/legacy-names.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { isPathInsideWithRealpath } from "../security/scan-paths.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
 import { resolveBundledHooksDir } from "./bundled-dir.js";
 import { shouldIncludeHook } from "./config.js";
 import { parseFrontmatter, resolvePoolbotMetadata, resolveHookInvocationPolicy, } from "./frontmatter.js";
+const log = createSubsystemLogger("hooks/workspace");
 function filterHookEntries(entries, config, eligibility) {
     return entries.filter((entry) => shouldIncludeHook({ entry, config, eligibility }));
 }
 function readHookPackageManifest(dir) {
     const manifestPath = path.join(dir, "package.json");
-    if (!fs.existsSync(manifestPath))
+    if (!fs.existsSync(manifestPath)) {
         return null;
+    }
     try {
         const raw = fs.readFileSync(manifestPath, "utf-8");
         return JSON.parse(raw);
@@ -21,15 +25,27 @@ function readHookPackageManifest(dir) {
     }
 }
 function resolvePackageHooks(manifest) {
-    const raw = manifest.poolbot?.hooks ?? manifest[LEGACY_MANIFEST_KEY]?.hooks;
-    if (!Array.isArray(raw))
+    const raw = manifest[MANIFEST_KEY]?.hooks;
+    if (!Array.isArray(raw)) {
         return [];
+    }
     return raw.map((entry) => (typeof entry === "string" ? entry.trim() : "")).filter(Boolean);
 }
+function resolveContainedDir(baseDir, targetDir) {
+    const base = path.resolve(baseDir);
+    const resolved = path.resolve(baseDir, targetDir);
+    if (!isPathInsideWithRealpath(base, resolved, {
+        requireRealpath: true,
+    })) {
+        return null;
+    }
+    return resolved;
+}
 function loadHookFromDir(params) {
     const hookMdPath = path.join(params.hookDir, "HOOK.md");
-    if (!fs.existsSync(hookMdPath))
+    if (!fs.existsSync(hookMdPath)) {
         return null;
+    }
     try {
         const content = fs.readFileSync(hookMdPath, "utf-8");
         const frontmatter = parseFrontmatter(content);
@@ -45,7 +61,7 @@ function loadHookFromDir(params) {
             }
         }
         if (!handlerPath) {
-            console.warn(`[hooks] Hook "${name}" has HOOK.md but no handler file in ${params.hookDir}`);
+            log.warn(`Hook "${name}" has HOOK.md but no handler file in ${params.hookDir}`);
             return null;
         }
         return {
@@ -59,7 +75,8 @@ function loadHookFromDir(params) {
         };
     }
     catch (err) {
-        console.warn(`[hooks] Failed to load hook from ${params.hookDir}:`, err);
+        const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+        log.warn(`Failed to load hook from ${params.hookDir}: ${message}`);
         return null;
     }
 }
@@ -68,30 +85,38 @@ function loadHookFromDir(params) {
  */
 function loadHooksFromDir(params) {
     const { dir, source, pluginId } = params;
-    if (!fs.existsSync(dir))
+    if (!fs.existsSync(dir)) {
         return [];
+    }
     const stat = fs.statSync(dir);
-    if (!stat.isDirectory())
+    if (!stat.isDirectory()) {
         return [];
+    }
     const hooks = [];
     const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-        if (!entry.isDirectory())
+        if (!entry.isDirectory()) {
             continue;
+        }
         const hookDir = path.join(dir, entry.name);
         const manifest = readHookPackageManifest(hookDir);
         const packageHooks = manifest ? resolvePackageHooks(manifest) : [];
         if (packageHooks.length > 0) {
             for (const hookPath of packageHooks) {
-                const resolvedHookDir = path.resolve(hookDir, hookPath);
+                const resolvedHookDir = resolveContainedDir(hookDir, hookPath);
+                if (!resolvedHookDir) {
+                    log.warn(`Ignoring out-of-package hook path "${hookPath}" in ${hookDir} (must be within package directory)`);
+                    continue;
+                }
                 const hook = loadHookFromDir({
                     hookDir: resolvedHookDir,
                     source,
                     pluginId,
                     nameHint: path.basename(resolvedHookDir),
                 });
-                if (hook)
+                if (hook) {
                     hooks.push(hook);
+                }
             }
             continue;
         }
@@ -101,8 +126,9 @@ function loadHooksFromDir(params) {
             pluginId,
             nameHint: entry.name,
         });
-        if (hook)
+        if (hook) {
             hooks.push(hook);
+        }
     }
     return hooks;
 }
@@ -165,14 +191,18 @@ function loadHookEntries(workspaceDir, opts) {
     });
     const merged = new Map();
     // Precedence: extra < bundled < managed < workspace (workspace wins)
-    for (const hook of extraHooks)
+    for (const hook of extraHooks) {
         merged.set(hook.name, hook);
-    for (const hook of bundledHooks)
+    }
+    for (const hook of bundledHooks) {
         merged.set(hook.name, hook);
-    for (const hook of managedHooks)
+    }
+    for (const hook of managedHooks) {
         merged.set(hook.name, hook);
-    for (const hook of workspaceHooks)
+    }
+    for (const hook of workspaceHooks) {
         merged.set(hook.name, hook);
+    }
     return Array.from(merged.values()).map((hook) => {
         let frontmatter = {};
         try {

package/dist/imessage/accounts.js

@@ -1,26 +1,13 @@
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
-function listConfiguredAccountIds(cfg) {
-    const accounts = cfg.channels?.imessage?.accounts;
-    if (!accounts || typeof accounts !== "object")
-        return [];
-    return Object.keys(accounts).filter(Boolean);
-}
-export function listIMessageAccountIds(cfg) {
-    const ids = listConfiguredAccountIds(cfg);
-    if (ids.length === 0)
-        return [DEFAULT_ACCOUNT_ID];
-    return ids.sort((a, b) => a.localeCompare(b));
-}
-export function resolveDefaultIMessageAccountId(cfg) {
-    const ids = listIMessageAccountIds(cfg);
-    if (ids.includes(DEFAULT_ACCOUNT_ID))
-        return DEFAULT_ACCOUNT_ID;
-    return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
+import { createAccountListHelpers } from "../channels/plugins/account-helpers.js";
+import { normalizeAccountId } from "../routing/session-key.js";
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("imessage");
+export const listIMessageAccountIds = listAccountIds;
+export const resolveDefaultIMessageAccountId = resolveDefaultAccountId;
 function resolveAccountConfig(cfg, accountId) {
     const accounts = cfg.channels?.imessage?.accounts;
-    if (!accounts || typeof accounts !== "object")
+    if (!accounts || typeof accounts !== "object") {
         return undefined;
+    }
     return accounts[accountId];
 }
 function mergeIMessageAccountConfig(cfg, accountId) {
@@ -43,6 +30,8 @@ export function resolveIMessageAccount(params) {
         merged.dmPolicy ||
         merged.groupPolicy ||
         typeof merged.includeAttachments === "boolean" ||
+        (merged.attachmentRoots && merged.attachmentRoots.length > 0) ||
+        (merged.remoteAttachmentRoots && merged.remoteAttachmentRoots.length > 0) ||
         typeof merged.mediaMaxMb === "number" ||
         typeof merged.textChunkLimit === "number" ||
         (merged.groups && Object.keys(merged.groups).length > 0));