@rubytech/taskmaster 1.0.63 → 1.0.65

package/dist/agents/pi-embedded-runner/compact.js

@@ -30,7 +30,7 @@ import { acquireSessionWriteLock } from "../session-write-lock.js";
 import { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, loadWorkspaceSkillEntries, resolveSkillsPromptForRun, } from "../skills.js";
 import { buildEmbeddedExtensionPaths } from "./extensions.js";
 import { logToolSchemasForGoogle, sanitizeSessionHistory, sanitizeToolsForGoogle, } from "./google.js";
-import { getEffectiveHistoryLimit, limitHistoryTurns, loadPreviousSessionMessages } from "./history.js";
+import { getEffectiveHistoryLimit, limitHistoryTurns, loadPreviousSessionMessages, } from "./history.js";
 import { resolveGlobalLane, resolveSessionLane } from "./lanes.js";
 import { log } from "./logger.js";
 import { buildModelAliasLines, resolveModel } from "./model.js";

package/dist/agents/pi-embedded-runner/history.js

@@ -1,11 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
 /**
- * Default rolling window: keep the last 50 user turns.
+ * Default rolling window: keep the last 20 user turns.
  * Prevents context overflow without needing slow compaction.
- * ~50 turns × ~2k tokens/turn ≈ 100k tokens, well within 200k context windows.
+ * Turns can contain large tool results, so a conservative default is essential.
+ * ~20 turns × ~4k tokens/turn ≈ 80k tokens, leaving room for system prompt + tools.
  */
-const DEFAULT_HISTORY_TURNS = 50;
+const DEFAULT_HISTORY_TURNS = 20;
 const THREAD_SUFFIX_REGEX = /^(.*)(?::(?:thread|topic):\d+)$/i;
 function stripThreadSuffix(value) {
     const match = value.match(THREAD_SUFFIX_REGEX);
@@ -69,7 +70,7 @@ export function getDmHistoryLimitFromSessionKey(sessionKey, config) {
 }
 /**
  * Resolves the effective history turn limit for any session.
- * Priority: per-DM/channel config → agents.defaults.historyTurns → built-in default (50).
+ * Priority: per-DM/channel config → agents.defaults.historyTurns → built-in default (20).
  * This ensures ALL sessions have a rolling window, preventing context overflow and compaction.
  */
 export function getEffectiveHistoryLimit(sessionKey, config) {
@@ -86,10 +87,50 @@ export function getEffectiveHistoryLimit(sessionKey, config) {
     return DEFAULT_HISTORY_TURNS;
 }
 /**
- * Loads messages from all previous sessions for a given session key.
- * Returns them in chronological order (oldest first) as AgentMessage[].
- * Used to prepend historical context to the current session's messages,
- * creating one continuous conversation that the rolling window then trims.
+ * Conversation-only roles: user messages and assistant text responses.
+ * Tool calls and tool results are operational artifacts that bloat the context
+ * without adding conversational value — they are excluded from historical context.
+ */
+const CONVERSATION_ROLES = new Set(["user", "assistant"]);
+/**
+ * Strips tool-call content blocks from assistant messages, keeping only text.
+ * An assistant message that contained only tool calls becomes a text-only message
+ * (or is skipped if it has no text content at all).
+ */
+function stripToolCallBlocks(msg) {
+    if (msg.role !== "assistant")
+        return msg;
+    const content = msg.content;
+    if (!Array.isArray(content))
+        return msg;
+    const textBlocks = content.filter((b) => b && typeof b === "object" && b.type === "text");
+    if (textBlocks.length === 0)
+        return null; // assistant message was tool-calls only
+    return { ...msg, content: textBlocks };
+}
+/**
+ * Strips an array of agent messages down to conversational content only.
+ * Keeps user messages and assistant text responses; drops tool calls,
+ * tool results, and other operational message types.
+ * Used to ensure the rolling window operates on clean conversational text,
+ * preventing tool-result bloat from inflating token counts.
+ */
+export function stripToConversationMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+        if (!msg?.role || !CONVERSATION_ROLES.has(msg.role))
+            continue;
+        const cleaned = stripToolCallBlocks(msg);
+        if (cleaned)
+            result.push(cleaned);
+    }
+    return result;
+}
+/**
+ * Loads conversation messages from all previous sessions for a given session key.
+ * Returns user + assistant text messages in chronological order (oldest first).
+ * Tool calls, tool results, and other operational messages are excluded —
+ * this is purely conversational context for the rolling window.
  */
 export function loadPreviousSessionMessages(sessionFile, sessionKey) {
     if (!sessionKey)
@@ -112,10 +153,7 @@ export function loadPreviousSessionMessages(sessionFile, sessionKey) {
     for (const prev of entry.previousSessions) {
         if (!prev.sessionId)
             continue;
-        const candidates = [
-            prev.sessionFile,
-            path.join(sessionsDir, `${prev.sessionId}.jsonl`),
-        ].filter(Boolean);
+        const candidates = [prev.sessionFile, path.join(sessionsDir, `${prev.sessionId}.jsonl`)].filter(Boolean);
         const filePath = candidates.find((p) => fs.existsSync(p));
         if (!filePath)
             continue;
@@ -126,9 +164,13 @@ export function loadPreviousSessionMessages(sessionFile, sessionKey) {
                     continue;
                 try {
                     const parsed = JSON.parse(line);
-                    if (parsed?.message?.role) {
-                        messages.push(parsed.message);
-                    }
+                    const msg = parsed?.message;
+                    if (!msg?.role || !CONVERSATION_ROLES.has(msg.role))
+                        continue;
+                    // Strip tool-call blocks from assistant messages
+                    const cleaned = stripToolCallBlocks(msg);
+                    if (cleaned)
+                        messages.push(cleaned);
                 }
                 catch {
                     // skip malformed lines

package/dist/agents/pi-embedded-runner/run/attempt.js

@@ -38,7 +38,7 @@ import { buildEmbeddedExtensionPaths } from "../extensions.js";
 import { applyExtraParamsToAgent } from "../extra-params.js";
 import { appendCacheTtlTimestamp, isCacheTtlEligibleProvider } from "../cache-ttl.js";
 import { logToolSchemasForGoogle, sanitizeSessionHistory, sanitizeToolsForGoogle, } from "../google.js";
-import { getEffectiveHistoryLimit, limitHistoryTurns, loadPreviousSessionMessages } from "../history.js";
+import { getEffectiveHistoryLimit, limitHistoryTurns, loadPreviousSessionMessages, stripToConversationMessages, } from "../history.js";
 import { log } from "../logger.js";
 import { buildModelAliasLines } from "../model.js";
 import { clearActiveEmbeddedRun, setActiveEmbeddedRun, } from "../runs.js";
@@ -360,6 +360,18 @@ export async function runEmbeddedAttempt(params) {
                 settingsManager,
                 minReserveTokens: resolveCompactionReserveTokensFloor(params.config),
             });
+            // Disable auto-compaction entirely. The rolling history window
+            // (limitHistoryTurns + stripToConversationMessages) prevents context
+            // overflow by sending only clean conversational text to the model.
+            // Auto-compaction replaces history with a thin summary the agent cannot
+            // use, causing complete context loss. Manual /compact is unaffected
+            // (it creates its own session and SettingsManager).
+            settingsManager.setCompactionEnabled(false);
+            // Disable auto-compaction entirely. The rolling history window
+            // (limitHistoryTurns) prevents context overflow between runs.
+            // Auto-compaction replaces conversation history with a thin summary,
+            // causing the agent to lose all context. Manual /compact is unaffected.
+            settingsManager.setCompactionEnabled(false);
             const additionalExtensionPaths = buildEmbeddedExtensionPaths({
                 cfg: params.config,
                 sessionManager,
@@ -409,6 +421,7 @@ export async function runEmbeddedAttempt(params) {
                 throw new Error("Embedded agent session missing");
             }
             const activeSession = session;
+            activeSession.setAutoCompactionEnabled(false);
             const cacheTrace = createCacheTrace({
                 cfg: params.config,
                 env: process.env,
@@ -445,12 +458,17 @@ export async function runEmbeddedAttempt(params) {
                 activeSession.agent.streamFn = anthropicPayloadLogger.wrapStreamFn(activeSession.agent.streamFn);
             }
             try {
-                // Load messages from previous sessions to create one continuous conversation.
-                // The rolling window then keeps only the last N turns for context.
+                // Build a clean conversational history for the rolling window.
+                // Both previous-session and current-session messages are stripped
+                // to user + assistant text only — tool calls and tool results are
+                // operational artifacts that bloat token counts without adding
+                // conversational value. This ensures the 20-turn window stays
+                // within context limits regardless of how many tools were used.
                 const previousMessages = loadPreviousSessionMessages(params.sessionFile, params.sessionKey);
+                const currentConversation = stripToConversationMessages(activeSession.messages);
                 const combinedMessages = previousMessages.length > 0
-                    ? [...previousMessages, ...activeSession.messages]
-                    : activeSession.messages;
+                    ? [...previousMessages, ...currentConversation]
+                    : currentConversation;
                 const prior = await sanitizeSessionHistory({
                     messages: combinedMessages,
                     modelApi: params.model.api,

package/dist/agents/pi-embedded-runner/run.js

@@ -12,7 +12,6 @@ import { normalizeProviderId } from "../model-selection.js";
 import { ensureTaskmasterModelsJson } from "../models-config.js";
 import { classifyFailoverReason, formatAssistantErrorText, isAuthAssistantError, isCompactionFailureError, isContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, parseImageDimensionError, isRateLimitAssistantError, isTimeoutErrorMessage, pickFallbackThinkingLevel, } from "../pi-embedded-helpers.js";
 import { normalizeUsage } from "../usage.js";
-import { compactEmbeddedPiSessionDirect } from "./compact.js";
 import { resolveGlobalLane, resolveSessionLane } from "./lanes.js";
 import { log } from "./logger.js";
 import { resolveModel } from "./model.js";
@@ -213,7 +212,6 @@ export async function runEmbeddedPiAgent(params) {
                 throwAuthProfileFailover({ allInCooldown: false, error: err });
             }
         }
-        let overflowCompactionAttempted = false;
         try {
             while (true) {
                 attemptedThinking.add(thinkLevel);
@@ -280,35 +278,12 @@ export async function runEmbeddedPiAgent(params) {
                     const errorText = describeUnknownError(promptError);
                     if (isContextOverflowError(errorText)) {
                         const isCompactionFailure = isCompactionFailureError(errorText);
-                        // Attempt auto-compaction on context overflow (not compaction_failure)
-                        if (!isCompactionFailure && !overflowCompactionAttempted) {
-                            log.warn(`context overflow detected; attempting auto-compaction for ${provider}/${modelId}`);
-                            overflowCompactionAttempted = true;
-                            const compactResult = await compactEmbeddedPiSessionDirect({
-                                sessionId: params.sessionId,
-                                sessionKey: params.sessionKey,
-                                messageChannel: params.messageChannel,
-                                messageProvider: params.messageProvider,
-                                agentAccountId: params.agentAccountId,
-                                authProfileId: lastProfileId,
-                                sessionFile: params.sessionFile,
-                                workspaceDir: params.workspaceDir,
-                                agentDir,
-                                config: params.config,
-                                skillsSnapshot: params.skillsSnapshot,
-                                provider,
-                                model: modelId,
-                                thinkLevel,
-                                reasoningLevel: params.reasoningLevel,
-                                bashElevated: params.bashElevated,
-                                extraSystemPrompt: params.extraSystemPrompt,
-                                ownerNumbers: params.ownerNumbers,
-                            });
-                            if (compactResult.compacted) {
-                                log.info(`auto-compaction succeeded for ${provider}/${modelId}; retrying prompt`);
-                                continue;
-                            }
-                            log.warn(`auto-compaction failed for ${provider}/${modelId}: ${compactResult.reason ?? "nothing to compact"}`);
+                        // No auto-compaction. The rolling window strips tool calls and
+                        // limits to 20 conversational turns, so overflow should not occur.
+                        // If it does (e.g. extremely large single message), return the
+                        // error and let the user /reset to start a new session.
+                        if (!isCompactionFailure) {
+                            log.warn(`context overflow despite rolling window for ${provider}/${modelId}; user should /reset`);
                         }
                         const kind = isCompactionFailure ? "compaction_failure" : "context_overflow";
                         return {

package/dist/agents/pi-embedded-runner.js

@@ -1,7 +1,7 @@
 export { compactEmbeddedPiSession } from "./pi-embedded-runner/compact.js";
 export { applyExtraParamsToAgent, resolveExtraParams } from "./pi-embedded-runner/extra-params.js";
 export { applyGoogleTurnOrderingFix } from "./pi-embedded-runner/google.js";
-export { getDmHistoryLimitFromSessionKey, getEffectiveHistoryLimit, limitHistoryTurns, loadPreviousSessionMessages, } from "./pi-embedded-runner/history.js";
+export { getDmHistoryLimitFromSessionKey, getEffectiveHistoryLimit, limitHistoryTurns, loadPreviousSessionMessages, stripToConversationMessages, } from "./pi-embedded-runner/history.js";
 export { resolveEmbeddedSessionLane } from "./pi-embedded-runner/lanes.js";
 export { runEmbeddedPiAgent } from "./pi-embedded-runner/run.js";
 export { abortEmbeddedPiRun, isEmbeddedPiRunActive, isEmbeddedPiRunStreaming, queueEmbeddedPiMessage, waitForEmbeddedPiRunEnd, } from "./pi-embedded-runner/runs.js";

package/dist/agents/system-prompt.js

@@ -29,6 +29,24 @@ function buildMemorySection(params) {
         "",
     ];
 }
+function buildMessageHistorySection(params) {
+    if (params.isMinimal)
+        return [];
+    if (!params.availableTools.has("message_history"))
+        return [];
+    return [
+        "## Message History",
+        "When asked about recent messages, what was said, or conversation history from any channel (WhatsApp, webchat, groups):",
+        '- Use `message_history` — it reads the conversation archive directly and returns messages with accurate timestamps. Pass source="current" for this conversation, "admin" for admin/webchat, a phone number for a WhatsApp DM, or a group JID for group chat.',
+        '- Pass source="discover" to list all available conversations (with type and last-activity date) when you need to find which conversations exist.',
+        '- Pass source="all" to retrieve recent messages across all conversations at once — each message includes its source identifier.',
+        "- Filter with: search (text substring), date (YYYY-MM-DD), after/before (HH:MM time range within a date), channel (whatsapp/webchat/imessage).",
+        "- Do NOT use memory_search for recent message retrieval — it is semantic search and cannot reliably return the most recent messages or accurate timestamps.",
+        "- Do NOT use sessions_history for message retrieval — use it only for session management. message_history is the correct tool for looking up what was said.",
+        "- Never guess, fabricate, or infer message content or timestamps. If message_history returns no results, say so.",
+        "",
+    ];
+}
 function buildUserIdentitySection(ownerLine, isMinimal) {
     if (!ownerLine || isMinimal)
         return [];
@@ -244,6 +262,7 @@ export function buildAgentSystemPrompt(params) {
         readToolName: skillReadToolName,
     });
     const memorySection = buildMemorySection({ isMinimal, availableTools });
+    const messageHistorySection = buildMessageHistorySection({ isMinimal, availableTools });
     const docsSection = buildDocsSection({
         docsPath: params.docsPath,
         isMinimal,
@@ -299,6 +318,7 @@ export function buildAgentSystemPrompt(params) {
         "",
         ...skillsSection,
         ...memorySection,
+        ...messageHistorySection,
         // Skip self-update for subagent/none modes
         hasGateway && !isMinimal ? "## Taskmaster Self-Update" : "",
         hasGateway && !isMinimal

package/dist/agents/taskmaster-tools.js

@@ -8,6 +8,7 @@ import { createDocumentTool } from "./tools/document-tool.js";
 import { createGatewayTool } from "./tools/gateway-tool.js";
 import { createImageTool } from "./tools/image-tool.js";
 import { createMemoryGetTool, createMemorySaveMediaTool, createMemorySearchTool, createMemoryWriteTool, } from "./tools/memory-tool.js";
+import { createMessageHistoryTool } from "./tools/message-history-tool.js";
 import { createMemoryReindexTool } from "./tools/memory-reindex-tool.js";
 import { createMessageTool } from "./tools/message-tool.js";
 import { createNodesTool } from "./tools/nodes-tool.js";
@@ -144,6 +145,7 @@ export function createTaskmasterTools(options) {
     const memoryWriteTool = createMemoryWriteTool(memoryToolOptions);
     const memorySaveMediaTool = createMemorySaveMediaTool(memoryToolOptions);
     const memoryReindexTool = createMemoryReindexTool(memoryToolOptions);
+    const messageHistoryTool = createMessageHistoryTool(memoryToolOptions);
     if (memorySearchTool)
         tools.push(memorySearchTool);
     if (memoryGetTool)
@@ -154,6 +156,8 @@ export function createTaskmasterTools(options) {
         tools.push(memorySaveMediaTool);
     if (memoryReindexTool)
         tools.push(memoryReindexTool);
+    if (messageHistoryTool)
+        tools.push(messageHistoryTool);
     const pluginTools = resolvePluginTools({
         context: {
             config: options?.config,

package/dist/agents/tool-policy.js

@@ -10,6 +10,7 @@ export const TOOL_GROUPS = {
         "memory_write",
         "memory_save_media",
         "memory_reindex",
+        "message_history",
         "document_read",
     ],
     "group:web": ["web_search", "web_fetch"],
@@ -54,6 +55,7 @@ export const TOOL_GROUPS = {
         "memory_search",
         "memory_get",
         "memory_write",
+        "message_history",
         "document_read",
         "web_search",
         "web_fetch",