@rubytech/taskmaster 1.0.62 → 1.0.64

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 { getDmHistoryLimitFromSessionKey, limitHistoryTurns } 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";
@@ -338,8 +338,12 @@ export async function compactEmbeddedPiSessionDirect(params) {
                 resourceLoader,
             }));
             try {
+                const previousMessages = loadPreviousSessionMessages(params.sessionFile, params.sessionKey);
+                const combinedMessages = previousMessages.length > 0
+                    ? [...previousMessages, ...session.messages]
+                    : session.messages;
                 const prior = await sanitizeSessionHistory({
-                    messages: session.messages,
+                    messages: combinedMessages,
                     modelApi: model.api,
                     modelId,
                     provider,
@@ -353,7 +357,7 @@ export async function compactEmbeddedPiSessionDirect(params) {
                 const validated = transcriptPolicy.validateAnthropicTurns
                     ? validateAnthropicTurns(validatedGemini)
                     : validatedGemini;
-                const limited = limitHistoryTurns(validated, getDmHistoryLimitFromSessionKey(params.sessionKey, params.config));
+                const limited = limitHistoryTurns(validated, getEffectiveHistoryLimit(params.sessionKey, params.config));
                 if (limited.length > 0) {
                     session.agent.replaceMessages(limited);
                 }

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

@@ -1,3 +1,12 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Default rolling window: keep the last 20 user turns.
+ * Prevents context overflow without needing slow compaction.
+ * 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 = 20;
 const THREAD_SUFFIX_REGEX = /^(.*)(?::(?:thread|topic):\d+)$/i;
 function stripThreadSuffix(value) {
     const match = value.match(THREAD_SUFFIX_REGEX);
@@ -59,3 +68,100 @@ export function getDmHistoryLimitFromSessionKey(sessionKey, config) {
     };
     return getLimit(resolveProviderConfig(config, provider));
 }
+/**
+ * Resolves the effective history turn limit for any session.
+ * Priority: per-DM/channel config → agents.defaults.historyTurns → built-in default (50).
+ * This ensures ALL sessions have a rolling window, preventing context overflow and compaction.
+ */
+export function getEffectiveHistoryLimit(sessionKey, config) {
+    // Check per-channel DM limit first
+    const channelLimit = getDmHistoryLimitFromSessionKey(sessionKey, config);
+    if (channelLimit !== undefined)
+        return channelLimit;
+    // Check agents.defaults.historyTurns
+    const configDefault = config?.agents?.defaults
+        ?.historyTurns;
+    if (typeof configDefault === "number" && Number.isFinite(configDefault) && configDefault > 0) {
+        return configDefault;
+    }
+    return DEFAULT_HISTORY_TURNS;
+}
+/**
+ * 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 };
+}
+/**
+ * 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)
+        return [];
+    const sessionsDir = path.dirname(sessionFile);
+    const storePath = path.join(sessionsDir, "sessions.json");
+    if (!fs.existsSync(storePath))
+        return [];
+    let store;
+    try {
+        store = JSON.parse(fs.readFileSync(storePath, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+    const entry = store[sessionKey];
+    if (!entry?.previousSessions?.length)
+        return [];
+    const messages = [];
+    for (const prev of entry.previousSessions) {
+        if (!prev.sessionId)
+            continue;
+        const candidates = [prev.sessionFile, path.join(sessionsDir, `${prev.sessionId}.jsonl`)].filter(Boolean);
+        const filePath = candidates.find((p) => fs.existsSync(p));
+        if (!filePath)
+            continue;
+        try {
+            const lines = fs.readFileSync(filePath, "utf-8").split(/\r?\n/);
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    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
+                }
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return messages;
+}

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 { getDmHistoryLimitFromSessionKey, limitHistoryTurns } from "../history.js";
+import { getEffectiveHistoryLimit, limitHistoryTurns, loadPreviousSessionMessages, } from "../history.js";
 import { log } from "../logger.js";
 import { buildModelAliasLines } from "../model.js";
 import { clearActiveEmbeddedRun, setActiveEmbeddedRun, } from "../runs.js";
@@ -445,8 +445,14 @@ 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.
+                const previousMessages = loadPreviousSessionMessages(params.sessionFile, params.sessionKey);
+                const combinedMessages = previousMessages.length > 0
+                    ? [...previousMessages, ...activeSession.messages]
+                    : activeSession.messages;
                 const prior = await sanitizeSessionHistory({
-                    messages: activeSession.messages,
+                    messages: combinedMessages,
                     modelApi: params.model.api,
                     modelId: params.modelId,
                     provider: params.provider,
@@ -461,7 +467,7 @@ export async function runEmbeddedAttempt(params) {
                 const validated = transcriptPolicy.validateAnthropicTurns
                     ? validateAnthropicTurns(validatedGemini)
                     : validatedGemini;
-                const limited = limitHistoryTurns(validated, getDmHistoryLimitFromSessionKey(params.sessionKey, params.config));
+                const limited = limitHistoryTurns(validated, getEffectiveHistoryLimit(params.sessionKey, params.config));
                 cacheTrace?.recordStage("session:limited", { messages: limited });
                 if (limited.length > 0) {
                     activeSession.agent.replaceMessages(limited);

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, limitHistoryTurns, } from "./pi-embedded-runner/history.js";
+export { getDmHistoryLimitFromSessionKey, getEffectiveHistoryLimit, limitHistoryTurns, loadPreviousSessionMessages, } 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/auto-reply/commands-registry.data.js

@@ -319,6 +319,12 @@ function buildChatCommands() {
             textAlias: "/new",
             acceptsArgs: true,
         }),
+        defineChatCommand({
+            key: "restore",
+            nativeName: "restore",
+            description: "Restore the most recent previous session.",
+            textAlias: "/restore",
+        }),
         defineChatCommand({
             key: "compact",
             description: "Compact the session context.",

package/dist/auto-reply/reply/commands-core.js

@@ -5,6 +5,7 @@ import { createInternalHookEvent, triggerInternalHook } from "../../hooks/intern
 import { routeReply } from "./route-reply.js";
 import { handleBashCommand } from "./commands-bash.js";
 import { handleCompactCommand } from "./commands-compact.js";
+import { handleRestoreCommand } from "./commands-restore.js";
 import { handleConfigCommand, handleDebugCommand } from "./commands-config.js";
 import { handleCommandsListCommand, handleContextCommand, handleHelpCommand, handleStatusCommand, handleWhoamiCommand, } from "./commands-info.js";
 import { handleAllowlistCommand } from "./commands-allowlist.js";
@@ -35,6 +36,7 @@ const HANDLERS = [
     handleDebugCommand,
     handleModelsCommand,
     handleStopCommand,
+    handleRestoreCommand,
     handleCompactCommand,
     handleAbortTrigger,
 ];

package/dist/auto-reply/reply/commands-restore.js

@@ -0,0 +1,64 @@
+import { updateSessionStore } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+export const handleRestoreCommand = async (params) => {
+    const normalized = params.command.commandBodyNormalized;
+    if (normalized !== "/restore" && !normalized.startsWith("/restore "))
+        return null;
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /restore from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    if (!params.sessionEntry || !params.sessionStore || !params.sessionKey || !params.storePath) {
+        return {
+            shouldContinue: false,
+            reply: { text: "⚙️ Restore unavailable (missing session state)." },
+        };
+    }
+    const previousSessions = params.sessionEntry.previousSessions;
+    if (!Array.isArray(previousSessions) || previousSessions.length === 0) {
+        return {
+            shouldContinue: false,
+            reply: { text: "⚙️ No previous session to restore." },
+        };
+    }
+    // Pop the most recent previous session.
+    const target = previousSessions[previousSessions.length - 1];
+    if (!target?.sessionId) {
+        return {
+            shouldContinue: false,
+            reply: { text: "⚙️ Previous session entry is invalid." },
+        };
+    }
+    // Remove the restored entry from the archive.
+    const remaining = previousSessions.slice(0, -1);
+    // Build the restored session entry, keeping per-session overrides intact.
+    const restored = {
+        ...params.sessionEntry,
+        sessionId: target.sessionId,
+        sessionFile: target.sessionFile,
+        updatedAt: Date.now(),
+        previousSessions: remaining.length > 0 ? remaining : undefined,
+        // Reset flags so bootstrap files are re-sent into the restored context.
+        systemSent: false,
+    };
+    params.sessionStore[params.sessionKey] = restored;
+    try {
+        await updateSessionStore(params.storePath, (store) => {
+            store[params.sessionKey] = restored;
+        });
+    }
+    catch (err) {
+        return {
+            shouldContinue: false,
+            reply: { text: `⚙️ Restore failed: ${String(err)}` },
+        };
+    }
+    // Update the in-memory entry so subsequent handlers see the restored state.
+    Object.assign(params.sessionEntry, restored);
+    return {
+        shouldContinue: false,
+        reply: {
+            text: `⚙️ Restored previous session (${target.sessionId.slice(0, 8)}). Your next message will continue where you left off.`,
+        },
+    };
+};

package/dist/auto-reply/reply/session.js

@@ -125,7 +125,7 @@ export async function initSessionState(params) {
     }
     sessionKey = resolveSessionKey(sessionScope, sessionCtxForState, mainKey);
     const entry = sessionStore[sessionKey];
-    const previousSessionEntry = resetTriggered && entry ? { ...entry } : undefined;
+    let previousSessionEntry = resetTriggered && entry ? { ...entry } : undefined;
     const now = Date.now();
     const isThread = resolveThreadFlag({
         sessionKey,
@@ -166,6 +166,11 @@ export async function initSessionState(params) {
         systemSent = false;
         abortedLastRun = false;
     }
+    // Archive the expiring session for implicit resets (daily/idle expiry).
+    // Explicit resets (/new, /reset) already captured previousSessionEntry above.
+    if (isNewSession && !previousSessionEntry && entry) {
+        previousSessionEntry = { ...entry };
+    }
     const baseEntry = !isNewSession && freshEntry ? entry : undefined;
     // Track the originating channel/to for announce routing (subagent announce-back).
     const lastChannelRaw = ctx.OriginatingChannel || baseEntry?.lastChannel;

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.62",
-  "commit": "358be66d0ca40bfa45f0202dbf343bd73f4ed05e",
-  "builtAt": "2026-02-17T20:29:11.804Z"
+  "version": "1.0.64",
+  "commit": "894760f8c77c4a2e07270875031e811654b2b2c7",
+  "builtAt": "2026-02-18T00:26:04.061Z"
 }

package/dist/config/sessions/reset.js

@@ -1,6 +1,6 @@
 import { DEFAULT_IDLE_MINUTES } from "./types.js";
 import { normalizeMessageChannel } from "../../utils/message-channel.js";
-export const DEFAULT_RESET_MODE = "daily";
+export const DEFAULT_RESET_MODE = "never";
 export const DEFAULT_RESET_AT_HOUR = 4;
 const THREAD_SESSION_MARKERS = [":thread:", ":topic:"];
 const GROUP_SESSION_MARKERS = [":group:", ":channel:"];
@@ -75,6 +75,9 @@ export function resolveChannelResetConfig(params) {
     return resetByChannel[key] ?? resetByChannel[key.toLowerCase()];
 }
 export function evaluateSessionFreshness(params) {
+    if (params.policy.mode === "never") {
+        return { fresh: true };
+    }
     const dailyResetAt = params.policy.mode === "daily"
         ? resolveDailyResetAtMs(params.now, params.policy.atHour)
         : undefined;

package/dist/config/zod-schema.session.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { GroupChatSchema, InboundDebounceSchema, NativeCommandsSettingSchema, QueueSchema, TtsConfigSchema, } from "./zod-schema.core.js";
 const SessionResetConfigSchema = z
     .object({
-    mode: z.union([z.literal("daily"), z.literal("idle")]).optional(),
+    mode: z.union([z.literal("never"), z.literal("daily"), z.literal("idle")]).optional(),
     atHour: z.number().int().min(0).max(23).optional(),
     idleMinutes: z.number().int().positive().optional(),
 })