@poolzin/pool-bot 2026.2.23 → 2026.2.25

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

@@ -5,22 +5,26 @@
  * 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,12 +50,92 @@ 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;
     }
 }
+/**
+ * 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 command is triggered
  */
@@ -57,56 +145,90 @@ const saveSessionToMemory = async (event) => {
         return;
     }
     try {
-        console.log("[session-memory] Hook triggered for /new command");
+        log.debug("Hook triggered for /new command");
         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 +250,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/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/infra/archive-path.js

@@ -0,0 +1,49 @@
+import path from "node:path";
+import { resolveSafeBaseDir } from "./path-safety.js";
+export function isWindowsDrivePath(value) {
+    return /^[a-zA-Z]:[\\/]/.test(value);
+}
+export function normalizeArchiveEntryPath(raw) {
+    return raw.replaceAll("\\", "/");
+}
+export function validateArchiveEntryPath(entryPath, params) {
+    if (!entryPath || entryPath === "." || entryPath === "./") {
+        return;
+    }
+    if (isWindowsDrivePath(entryPath)) {
+        throw new Error(`archive entry uses a drive path: ${entryPath}`);
+    }
+    const normalized = path.posix.normalize(normalizeArchiveEntryPath(entryPath));
+    const escapeLabel = params?.escapeLabel ?? "destination";
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error(`archive entry escapes ${escapeLabel}: ${entryPath}`);
+    }
+    if (path.posix.isAbsolute(normalized) || normalized.startsWith("//")) {
+        throw new Error(`archive entry is absolute: ${entryPath}`);
+    }
+}
+export function stripArchivePath(entryPath, stripComponents) {
+    const raw = normalizeArchiveEntryPath(entryPath);
+    if (!raw || raw === "." || raw === "./") {
+        return null;
+    }
+    // Mimic tar --strip-components semantics (raw segments before normalization)
+    // so strip-induced escapes like "a/../b" are visible to validators.
+    const parts = raw.split("/").filter((part) => part.length > 0 && part !== ".");
+    const strip = Math.max(0, Math.floor(stripComponents));
+    const stripped = strip === 0 ? parts.join("/") : parts.slice(strip).join("/");
+    const result = path.posix.normalize(stripped);
+    if (!result || result === "." || result === "./") {
+        return null;
+    }
+    return result;
+}
+export function resolveArchiveOutputPath(params) {
+    const safeBase = resolveSafeBaseDir(params.rootDir);
+    const outPath = path.resolve(params.rootDir, params.relPath);
+    const escapeLabel = params.escapeLabel ?? "destination";
+    if (!outPath.startsWith(safeBase)) {
+        throw new Error(`archive entry escapes ${escapeLabel}: ${params.originalPath}`);
+    }
+    return outPath;
+}