npm - @rubytech/taskmaster - Versions diffs - 1.0.62 → 1.0.64 - Mend

@rubytech/taskmaster 1.0.62 → 1.0.64

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/dist/agents/pi-embedded-runner/compact.js +7 -3
package/dist/agents/pi-embedded-runner/history.js +106 -0
package/dist/agents/pi-embedded-runner/run/attempt.js +9 -3
package/dist/agents/pi-embedded-runner.js +1 -1
package/dist/auto-reply/commands-registry.data.js +6 -0
package/dist/auto-reply/reply/commands-core.js +2 -0
package/dist/auto-reply/reply/commands-restore.js +64 -0
package/dist/auto-reply/reply/session.js +6 -1
package/dist/build-info.json +3 -3
package/dist/config/sessions/reset.js +4 -1
package/dist/config/zod-schema.session.js +1 -1
package/dist/control-ui/assets/{index-CV7xcGIS.js → index-BPvR6pln.js} +4 -4
package/dist/control-ui/assets/{index-CV7xcGIS.js.map → index-BPvR6pln.js.map} +1 -1
package/dist/control-ui/index.html +1 -1
package/dist/gateway/chat-sanitize.js +75 -0
package/dist/gateway/protocol/schema/logs-chat.js +1 -1
package/dist/gateway/server-chat.js +0 -9
package/dist/gateway/server-methods/chat.js +31 -34
package/dist/gateway/server-startup.js +7 -0
package/dist/infra/session-recovery.js +379 -0
package/package.json +1 -1

package/dist/control-ui/index.html CHANGED Viewed

@@ -6,7 +6,7 @@
     <title>Taskmaster Control</title>
     <meta name="color-scheme" content="dark light" />
     <link rel="icon" type="image/png" href="./favicon.png" />
-    <script type="module" crossorigin src="./assets/index-CV7xcGIS.js"></script>
+    <script type="module" crossorigin src="./assets/index-BPvR6pln.js"></script>
     <link rel="stylesheet" crossorigin href="./assets/index-mweBpmCT.css">
   </head>
   <body>

package/dist/gateway/chat-sanitize.js CHANGED Viewed

@@ -118,3 +118,78 @@ export function stripEnvelopeFromMessages(messages) {
     });
     return changed ? next : messages;
 }
+// ---------------------------------------------------------------------------
+// Base64 image stripping
+// ---------------------------------------------------------------------------
+// Images must be stored as physical files on disk and referenced by path —
+// never as inline base64 in transcripts or chat history responses.
+// These functions remove base64 data from image content blocks wherever
+// they appear (user, assistant, tool messages).
+// ---------------------------------------------------------------------------
+function isBase64ImageBlock(block) {
+    if (!block || typeof block !== "object")
+        return false;
+    const b = block;
+    if (b.type === "image") {
+        // Format: { type: "image", data: "<base64>", mimeType: "..." }
+        if (typeof b.data === "string" && b.data.length > 256)
+            return true;
+        // Format: { type: "image", source: { type: "base64", data: "..." } }
+        const source = b.source;
+        if (source?.type === "base64" && typeof source.data === "string" && source.data.length > 256) {
+            return true;
+        }
+    }
+    if (b.type === "image_url") {
+        // OpenAI format with inline data URL
+        const imageUrl = b.image_url;
+        if (typeof imageUrl?.url === "string" && imageUrl.url.startsWith("data:"))
+            return true;
+    }
+    return false;
+}
+function stripBase64FromContentBlocks(content) {
+    let changed = false;
+    const next = content.map((block) => {
+        if (!isBase64ImageBlock(block))
+            return block;
+        changed = true;
+        const b = block;
+        const mimeType = b.mimeType ??
+            b.media_type ??
+            b.source?.media_type ??
+            "image";
+        return { type: "text", text: `[${mimeType}]` };
+    });
+    return { content: next, changed };
+}
+/**
+ * Remove inline base64 image data from a single message.
+ * Replaces image content blocks with a text placeholder.
+ */
+export function stripBase64ImagesFromMessage(message) {
+    if (!message || typeof message !== "object")
+        return message;
+    const entry = message;
+    if (!Array.isArray(entry.content))
+        return message;
+    const { content, changed } = stripBase64FromContentBlocks(entry.content);
+    if (!changed)
+        return message;
+    return { ...entry, content };
+}
+/**
+ * Remove inline base64 image data from an array of messages.
+ */
+export function stripBase64ImagesFromMessages(messages) {
+    if (messages.length === 0)
+        return messages;
+    let changed = false;
+    const next = messages.map((message) => {
+        const stripped = stripBase64ImagesFromMessage(message);
+        if (stripped !== message)
+            changed = true;
+        return stripped;
+    });
+    return changed ? next : messages;
+}

package/dist/gateway/protocol/schema/logs-chat.js CHANGED Viewed

@@ -16,7 +16,7 @@ export const LogsTailResultSchema = Type.Object({
 // WebChat/WebSocket-native chat methods
 export const ChatHistoryParamsSchema = Type.Object({
     sessionKey: NonEmptyString,
-    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 1000 })),
+    limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 10_000 })),
     /** When set, read from this specific session transcript instead of the current one. */
     sessionId: Type.Optional(NonEmptyString),
 }, { additionalProperties: false });

package/dist/gateway/server-chat.js CHANGED Viewed

@@ -1,7 +1,6 @@
 import { normalizeVerboseLevel } from "../auto-reply/thinking.js";
 import { isSilentReplyText } from "../auto-reply/tokens.js";
 import { getAgentRunContext } from "../infra/agent-events.js";
-import { fireSuggestion } from "../suggestions/broadcast.js";
 import { loadSessionEntry } from "./session-utils.js";
 import { formatForLog } from "./ws-log.js";
 export function createChatRunRegistry() {
@@ -108,14 +107,6 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
             };
             broadcast("chat", payload);
             nodeSendToSession(sessionKey, "chat", payload);
-            // Fire follow-up suggestion for successful responses with text
-            if (text) {
-                fireSuggestion({
-                    sessionKey,
-                    broadcast,
-                    lastAssistantReply: text,
-                });
-            }
             return;
         }
         const payload = {

package/dist/gateway/server-methods/chat.js CHANGED Viewed

@@ -14,11 +14,9 @@ import { createInternalHookEvent, triggerInternalHook } from "../../hooks/intern
 import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
 import { abortChatRunById, abortChatRunsForSessionKey, isChatStopCommandText, resolveChatRunExpiresAtMs, } from "../chat-abort.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateChatAbortParams, validateChatHistoryParams, validateChatInjectParams, validateChatSendParams, } from "../protocol/index.js";
-import { getMaxChatHistoryMessagesBytes } from "../server-constants.js";
-import { capArrayByJsonBytes, loadSessionEntry, readSessionMessages, resolveSessionModelRef, } from "../session-utils.js";
-import { stripEnvelopeFromMessages } from "../chat-sanitize.js";
+import { loadSessionEntry, readSessionMessages, resolveSessionModelRef } from "../session-utils.js";
+import { stripBase64ImagesFromMessages, stripEnvelopeFromMessages } from "../chat-sanitize.js";
 import { formatForLog } from "../ws-log.js";
-import { fireSuggestion } from "../../suggestions/broadcast.js";
 function resolveTranscriptPath(params) {
     const { sessionId, storePath, sessionFile } = params;
     if (sessionFile)
@@ -128,11 +126,13 @@ export const chatHandlers = {
         }
         const { sessionKey, limit, sessionId: requestedSessionId, } = params;
         const { cfg, storePath, entry } = loadSessionEntry(sessionKey);
-        // When a specific sessionId is requested, resolve the matching transcript file
-        // from previousSessions (or the current entry if it matches).
+        // When a specific sessionId is requested, resolve only that transcript.
+        // Otherwise, stitch all previous sessions + current into one continuous history.
         let sessionId = entry?.sessionId;
         let sessionFile = entry?.sessionFile;
+        let rawMessages = [];
         if (requestedSessionId && entry) {
+            // Single-session mode: resolve the requested transcript.
             if (requestedSessionId === entry.sessionId) {
                 // Already pointing at current — no change needed.
             }
@@ -143,22 +143,37 @@ export const chatHandlers = {
                     sessionFile = prev.sessionFile;
                 }
                 else {
-                    // Unknown sessionId — fall through with empty result rather than erroring,
-                    // so the caller gets an empty messages array instead of a hard failure.
                     sessionId = undefined;
                 }
             }
+            rawMessages =
+                sessionId && storePath ? readSessionMessages(sessionId, storePath, sessionFile) : [];
         }
-        const rawMessages = sessionId && storePath ? readSessionMessages(sessionId, storePath, sessionFile) : [];
-        const hardMax = 1000;
-        const defaultLimit = 200;
+        else if (entry && storePath) {
+            // Stitched mode: read previous sessions (oldest first) + current session.
+            const previous = entry.previousSessions ?? [];
+            for (const prev of previous) {
+                if (!prev.sessionId)
+                    continue;
+                const msgs = readSessionMessages(prev.sessionId, storePath, prev.sessionFile);
+                if (msgs.length > 0)
+                    rawMessages.push(...msgs);
+            }
+            // Append current session messages.
+            if (sessionId) {
+                const current = readSessionMessages(sessionId, storePath, sessionFile);
+                rawMessages.push(...current);
+            }
+        }
+        const hardMax = 10_000;
+        const defaultLimit = 5000;
         const requested = typeof limit === "number" ? limit : defaultLimit;
         const max = Math.min(hardMax, requested);
-        const sliced = rawMessages.length > max ? rawMessages.slice(-max) : rawMessages;
-        const sanitized = stripEnvelopeFromMessages(sliced);
-        const { items: capped, bytes: cappedBytes } = capArrayByJsonBytes(sanitized, getMaxChatHistoryMessagesBytes());
+        const messages = rawMessages.length > max ? rawMessages.slice(-max) : rawMessages;
+        const sanitized = stripBase64ImagesFromMessages(stripEnvelopeFromMessages(messages));
         // Diagnostic: log resolution details so we can trace "lost history" reports.
-        context.logGateway.info(`chat.history: sessionKey=${sessionKey} resolvedSessionId=${sessionId ?? "none"} storePath=${storePath ?? "none"} entryExists=${!!entry} rawMessages=${rawMessages.length} sliced=${sliced.length} capped=${capped.length} cappedBytes=${cappedBytes}`);
+        const prevCount = entry?.previousSessions?.length ?? 0;
+        context.logGateway.info(`chat.history: sessionKey=${sessionKey} resolvedSessionId=${sessionId ?? "none"} storePath=${storePath ?? "none"} entryExists=${!!entry} previousSessions=${prevCount} rawMessages=${rawMessages.length} sent=${sanitized.length}`);
         if (!entry) {
             context.logGateway.warn(`chat.history: no session entry found for sessionKey=${sessionKey}`);
         }
@@ -183,21 +198,13 @@ export const chatHandlers = {
         respond(true, {
             sessionKey,
             sessionId,
-            messages: capped,
+            messages: sanitized,
             thinkingLevel,
             modelProvider,
             model: modelId,
             verboseLevel: entry?.verboseLevel ?? null,
             fillerEnabled: entry?.fillerEnabled ?? null,
         });
-        // Fire suggestion for empty sessions (onboarding opener)
-        if (capped.length === 0) {
-            fireSuggestion({
-                sessionKey,
-                broadcast: context.broadcast,
-                cfg,
-            });
-        }
     },
     "chat.abort": ({ params, respond, context }) => {
         if (!validateChatAbortParams(params)) {
@@ -559,16 +566,6 @@ export const chatHandlers = {
                         sessionKey: p.sessionKey,
                         message,
                     });
-                    // Fire follow-up suggestion after successful response
-                    if (combinedReply) {
-                        fireSuggestion({
-                            sessionKey: p.sessionKey,
-                            broadcast: context.broadcast,
-                            cfg,
-                            lastUserMessage: p.message,
-                            lastAssistantReply: combinedReply,
-                        });
-                    }
                 }
                 // Fire message:outbound hook for conversation archiving
                 const outboundText = finalReplyParts.join("\n\n").trim();

package/dist/gateway/server-startup.js CHANGED Viewed

@@ -6,6 +6,7 @@ import { startGmailWatcher } from "../hooks/gmail-watcher.js";
 import { clearInternalHooks, createInternalHookEvent, triggerInternalHook, } from "../hooks/internal-hooks.js";
 import { loadInternalHooks } from "../hooks/loader.js";
 import { startPluginServices } from "../plugins/services.js";
+import { recoverOrphanedSessions, stripBase64FromTranscripts } from "../infra/session-recovery.js";
 import { startBrowserControlServerIfEnabled } from "./server-browser.js";
 import { scheduleRestartSentinelWake, shouldWakeFromRestartSentinel, } from "./server-restart-sentinel.js";
 import { cacheLastUpdateSentinel } from "./server-methods/update.js";
@@ -18,6 +19,12 @@ export async function startGatewaySidecars(params) {
     catch (err) {
         params.logBrowser.error(`server failed to start: ${String(err)}`);
     }
+    // Recover orphaned session JSONL files left by old daily/idle resets,
+    // then strip any inline base64 image data from transcripts.
+    // Fire-and-forget — never blocks startup.
+    void recoverOrphanedSessions()
+        .then(() => stripBase64FromTranscripts())
+        .catch(() => { });
     // Start Gmail watcher if configured (hooks.gmail.account).
     if (!isTruthyEnvValue(process.env.TASKMASTER_SKIP_GMAIL_WATCHER)) {
         try {

package/dist/infra/session-recovery.js ADDED Viewed

@@ -0,0 +1,379 @@
+/**
+ * Recovers orphaned session JSONL files that exist on disk but are not
+ * referenced by any session store entry (neither as a current session nor
+ * in any `previousSessions` array).
+ *
+ * This situation arises when daily/idle resets silently replaced session
+ * entries without archiving the previous session. The JSONL files were
+ * preserved on disk but the store lost track of them.
+ *
+ * The recovery runs once at gateway startup, is idempotent, and classifies
+ * each orphan by reading its first user message to determine which session
+ * key it belongs to (cron, WhatsApp DM, or webchat main).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "../config/paths.js";
+import { updateSessionStore } from "../config/sessions.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("session-recovery");
+// ---------- Classification helpers ----------
+const CRON_PATTERN = /^\[cron:([0-9a-f-]{36})\b/i;
+const WHATSAPP_PATTERN = /^\[WhatsApp\s+(\+\d+)\b/i;
+/**
+ * Read the session header (first JSONL line) to get the timestamp,
+ * and the first user message to classify the channel.
+ */
+function classifyOrphan(filePath, agentId, knownSessionKeys) {
+    const uuid = path.basename(filePath, ".jsonl");
+    let headerTimestamp = 0;
+    let firstUserMessage = null;
+    let fd = null;
+    try {
+        fd = fs.openSync(filePath, "r");
+        // Read enough to cover the header + first few messages
+        const buf = Buffer.alloc(16384);
+        const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+        if (bytesRead === 0)
+            return null;
+        const chunk = buf.toString("utf-8", 0, bytesRead);
+        const lines = chunk.split(/\r?\n/).slice(0, 20);
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                // Session header line
+                if (parsed?.type === "session" && parsed?.timestamp) {
+                    const ts = typeof parsed.timestamp === "number"
+                        ? parsed.timestamp
+                        : new Date(parsed.timestamp).getTime();
+                    if (Number.isFinite(ts))
+                        headerTimestamp = ts;
+                }
+                // First user message
+                if (parsed?.type === "message" && !firstUserMessage) {
+                    const msg = parsed?.message;
+                    if (msg?.role === "user") {
+                        const content = msg.content;
+                        if (typeof content === "string") {
+                            firstUserMessage = content;
+                        }
+                        else if (Array.isArray(content)) {
+                            for (const block of content) {
+                                if (block?.type === "text" && typeof block.text === "string") {
+                                    firstUserMessage = block.text;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (headerTimestamp && firstUserMessage)
+                    break;
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null)
+            fs.closeSync(fd);
+    }
+    // Fall back to file mtime if no header timestamp
+    if (!headerTimestamp) {
+        try {
+            headerTimestamp = fs.statSync(filePath).mtimeMs;
+        }
+        catch {
+            headerTimestamp = 0;
+        }
+    }
+    // Classify by first user message content
+    let sessionKey = null;
+    if (firstUserMessage) {
+        const cronMatch = firstUserMessage.match(CRON_PATTERN);
+        if (cronMatch) {
+            const cronId = cronMatch[1];
+            const candidate = `agent:${agentId}:cron:${cronId}`;
+            // Only assign to a cron key that exists in the store
+            sessionKey = knownSessionKeys.has(candidate) ? candidate : null;
+        }
+        if (!sessionKey) {
+            const waMatch = firstUserMessage.match(WHATSAPP_PATTERN);
+            if (waMatch) {
+                const phone = waMatch[1];
+                const candidate = `agent:${agentId}:dm:${phone}`;
+                sessionKey = knownSessionKeys.has(candidate) ? candidate : null;
+            }
+        }
+    }
+    // Default: assign to the agent's main webchat session
+    if (!sessionKey) {
+        const mainKey = `agent:${agentId}:main`;
+        if (knownSessionKeys.has(mainKey)) {
+            sessionKey = mainKey;
+        }
+    }
+    return { uuid, filePath, headerTimestamp, sessionKey };
+}
+// ---------- Main recovery ----------
+export async function recoverOrphanedSessions(params) {
+    const stateDir = params?.stateDir ?? resolveStateDir();
+    const agentsDir = path.join(stateDir, "agents");
+    if (!fs.existsSync(agentsDir)) {
+        return { recovered: 0, agents: 0 };
+    }
+    let totalRecovered = 0;
+    let agentsProcessed = 0;
+    let agentEntries;
+    try {
+        agentEntries = fs.readdirSync(agentsDir, { withFileTypes: true });
+    }
+    catch {
+        return { recovered: 0, agents: 0 };
+    }
+    for (const agentEntry of agentEntries) {
+        if (!agentEntry.isDirectory())
+            continue;
+        const agentId = agentEntry.name;
+        const sessionsDir = path.join(agentsDir, agentId, "sessions");
+        const storePath = path.join(sessionsDir, "sessions.json");
+        if (!fs.existsSync(storePath))
+            continue;
+        // Load the store
+        let store;
+        try {
+            const raw = fs.readFileSync(storePath, "utf-8");
+            store = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        // Collect all referenced session IDs
+        const referencedIds = new Set();
+        const knownSessionKeys = new Set();
+        for (const [key, entry] of Object.entries(store)) {
+            knownSessionKeys.add(key);
+            if (entry.sessionId)
+                referencedIds.add(entry.sessionId);
+            if (Array.isArray(entry.previousSessions)) {
+                for (const prev of entry.previousSessions) {
+                    if (prev.sessionId)
+                        referencedIds.add(prev.sessionId);
+                }
+            }
+        }
+        // List JSONL files on disk
+        let files;
+        try {
+            files = fs.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        // Find orphans
+        const orphans = [];
+        for (const file of files) {
+            const uuid = file.replace(".jsonl", "");
+            if (referencedIds.has(uuid))
+                continue;
+            const info = classifyOrphan(path.join(sessionsDir, file), agentId, knownSessionKeys);
+            if (info?.sessionKey) {
+                orphans.push(info);
+            }
+        }
+        if (orphans.length === 0)
+            continue;
+        agentsProcessed++;
+        // Group orphans by session key
+        const byKey = new Map();
+        for (const orphan of orphans) {
+            if (!orphan.sessionKey)
+                continue;
+            const group = byKey.get(orphan.sessionKey) ?? [];
+            group.push(orphan);
+            byKey.set(orphan.sessionKey, group);
+        }
+        // Update the store: prepend orphans to each entry's previousSessions
+        try {
+            await updateSessionStore(storePath, (currentStore) => {
+                for (const [sessionKey, orphanGroup] of byKey.entries()) {
+                    const entry = currentStore[sessionKey];
+                    if (!entry)
+                        continue;
+                    // Re-check: skip any that are now referenced (in case of concurrent update)
+                    const nowReferenced = new Set();
+                    if (entry.sessionId)
+                        nowReferenced.add(entry.sessionId);
+                    if (Array.isArray(entry.previousSessions)) {
+                        for (const prev of entry.previousSessions) {
+                            if (prev.sessionId)
+                                nowReferenced.add(prev.sessionId);
+                        }
+                    }
+                    const toAdd = orphanGroup
+                        .filter((o) => !nowReferenced.has(o.uuid))
+                        .sort((a, b) => a.headerTimestamp - b.headerTimestamp);
+                    if (toAdd.length === 0)
+                        continue;
+                    const existingPrev = entry.previousSessions ?? [];
+                    const newPrev = [
+                        ...toAdd.map((o) => ({
+                            sessionId: o.uuid,
+                            sessionFile: o.filePath,
+                            endedAt: o.headerTimestamp,
+                        })),
+                        ...existingPrev,
+                    ];
+                    entry.previousSessions = newPrev;
+                    totalRecovered += toAdd.length;
+                }
+            });
+        }
+        catch (err) {
+            log.warn(`failed to update store for agent ${agentId}: ${String(err)}`);
+        }
+    }
+    if (totalRecovered > 0) {
+        log.info(`recovered ${totalRecovered} orphaned session(s) across ${agentsProcessed} agent(s)`);
+    }
+    return { recovered: totalRecovered, agents: agentsProcessed };
+}
+// ---------- Base64 image stripping from JSONL transcripts ----------
+/**
+ * Returns true if a content block contains inline base64 image data
+ * that should have been stored as a physical file instead.
+ */
+function hasInlineBase64(block) {
+    if (block.type === "image") {
+        if (typeof block.data === "string" && block.data.length > 256)
+            return true;
+        const source = block.source;
+        if (source?.type === "base64" && typeof source.data === "string" && source.data.length > 256) {
+            return true;
+        }
+    }
+    if (block.type === "image_url") {
+        const imageUrl = block.image_url;
+        if (typeof imageUrl?.url === "string" && imageUrl.url.startsWith("data:"))
+            return true;
+    }
+    return false;
+}
+/**
+ * Replace base64 image blocks in a content array with text placeholders.
+ * Returns null if no changes were made.
+ */
+function stripBase64FromContent(content) {
+    let changed = false;
+    const result = content.map((block) => {
+        if (!block || typeof block !== "object")
+            return block;
+        const b = block;
+        if (!hasInlineBase64(b))
+            return block;
+        changed = true;
+        const mime = b.mimeType ??
+            b.media_type ??
+            b.source?.media_type ??
+            "image";
+        return { type: "text", text: `[${mime}]` };
+    });
+    return changed ? result : null;
+}
+/**
+ * Scans all JSONL transcript files across all agents and removes inline
+ * base64 image data, replacing with text placeholders.
+ *
+ * Idempotent — files with no base64 are left untouched.
+ */
+export async function stripBase64FromTranscripts(params) {
+    const stateDir = params?.stateDir ?? resolveStateDir();
+    const agentsDir = path.join(stateDir, "agents");
+    if (!fs.existsSync(agentsDir)) {
+        return { cleaned: 0, bytesReclaimed: 0 };
+    }
+    let totalCleaned = 0;
+    let totalBytesReclaimed = 0;
+    let agentEntries;
+    try {
+        agentEntries = fs.readdirSync(agentsDir, { withFileTypes: true });
+    }
+    catch {
+        return { cleaned: 0, bytesReclaimed: 0 };
+    }
+    for (const agentEntry of agentEntries) {
+        if (!agentEntry.isDirectory())
+            continue;
+        const sessionsDir = path.join(agentsDir, agentEntry.name, "sessions");
+        let files;
+        try {
+            files = fs.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const filePath = path.join(sessionsDir, file);
+            let raw;
+            try {
+                raw = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const lines = raw.split(/\r?\n/);
+            let fileChanged = false;
+            const rewritten = [];
+            for (const line of lines) {
+                if (!line.trim()) {
+                    rewritten.push(line);
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    const msg = parsed?.message;
+                    if (msg && Array.isArray(msg.content)) {
+                        const stripped = stripBase64FromContent(msg.content);
+                        if (stripped) {
+                            parsed.message = { ...msg, content: stripped };
+                            rewritten.push(JSON.stringify(parsed));
+                            fileChanged = true;
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    // keep line as-is
+                }
+                rewritten.push(line);
+            }
+            if (!fileChanged)
+                continue;
+            const newContent = rewritten.join("\n");
+            const oldSize = Buffer.byteLength(raw, "utf-8");
+            const newSize = Buffer.byteLength(newContent, "utf-8");
+            try {
+                // Atomic write: write to tmp, then rename
+                const tmpPath = `${filePath}.tmp`;
+                fs.writeFileSync(tmpPath, newContent, "utf-8");
+                fs.renameSync(tmpPath, filePath);
+                totalCleaned++;
+                totalBytesReclaimed += oldSize - newSize;
+            }
+            catch (err) {
+                log.warn(`failed to clean ${file}: ${String(err)}`);
+            }
+        }
+    }
+    if (totalCleaned > 0) {
+        const mb = (totalBytesReclaimed / (1024 * 1024)).toFixed(1);
+        log.info(`stripped base64 images from ${totalCleaned} transcript(s), reclaimed ${mb} MB`);
+    }
+    return { cleaned: totalCleaned, bytesReclaimed: totalBytesReclaimed };
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"