@rubytech/taskmaster 1.0.11 → 1.0.12

package/dist/agents/pi-embedded-helpers/errors.js

@@ -248,10 +248,10 @@ export function formatAssistantErrorText(msg, opts) {
         return ("Context overflow: prompt too large for the model. " +
             "Try again with less input or a larger-context model.");
     }
-    // Catch role ordering errors - including JSON-wrapped and "400" prefix variants
-    if (/incorrect role information|roles must alternate|400.*role|"message".*role.*information/i.test(raw)) {
-        return ("Message ordering conflict - please try again. " +
-            "If this persists, use /new to start a fresh session.");
+    // Conversation history corruption — role ordering, orphaned tool results, etc.
+    // The session is stuck; every subsequent message will fail until reset.
+    if (/incorrect role information|roles must alternate|400.*role|"message".*role.*information|tool_use_id|tool_result.*tool_use|tool_use.*tool_result/i.test(raw)) {
+        return "This conversation got into a bad state. Use /new to start fresh.";
     }
     const invalidRequest = raw.match(/"type":"invalid_request_error".*?"message":"([^"]+)"/);
     if (invalidRequest?.[1]) {
@@ -276,9 +276,8 @@ export function sanitizeUserFacingText(text) {
     const trimmed = stripped.trim();
     if (!trimmed)
         return stripped;
-    if (/incorrect role information|roles must alternate/i.test(trimmed)) {
-        return ("Message ordering conflict - please try again. " +
-            "If this persists, use /new to start a fresh session.");
+    if (/incorrect role information|roles must alternate|tool_use_id|tool_result.*tool_use|tool_use.*tool_result/i.test(trimmed)) {
+        return "This conversation got into a bad state. Use /new to start fresh.";
     }
     if (isContextOverflowError(trimmed)) {
         return ("Context overflow: prompt too large for the model. " +

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

@@ -259,7 +259,6 @@ export async function compactEmbeddedPiSessionDirect(params) {
             extraSystemPrompt: params.extraSystemPrompt,
             ownerNumbers: params.ownerNumbers,
             reasoningTagHint,
-            finalTagHint: !reasoningTagHint,
             heartbeatPrompt: isDefaultAgent
                 ? resolveHeartbeatPrompt(params.config?.agents?.defaults?.heartbeat?.prompt)
                 : undefined,

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

@@ -284,7 +284,6 @@ export async function runEmbeddedAttempt(params) {
             extraSystemPrompt: params.extraSystemPrompt,
             ownerNumbers: params.ownerNumbers,
             reasoningTagHint,
-            finalTagHint: !reasoningTagHint,
             heartbeatPrompt: isDefaultAgent
                 ? resolveHeartbeatPrompt(params.config?.agents?.defaults?.heartbeat?.prompt)
                 : undefined,

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

@@ -30,10 +30,10 @@ export function buildEmbeddedRunPayloads(params) {
         : null;
     const normalizedErrorText = errorText ? normalizeTextForComparison(errorText) : null;
     const genericErrorText = "The AI service returned an error. Please try again.";
-    if (errorText) {
-        // Suppress raw API errors for public-facing agents
-        const displayError = params.suppressRawErrors ? genericErrorText : errorText;
-        replyItems.push({ text: displayError, isError: true });
+    // Public-facing agents: silently swallow errors — no error text of any kind.
+    // Admin agent: show the formatted error from formatAssistantErrorText.
+    if (errorText && !params.suppressRawErrors) {
+        replyItems.push({ text: errorText, isError: true });
     }
     const inlineToolResults = params.inlineToolResultsAllowed && params.verboseLevel !== "off" && params.toolMetas.length > 0;
     if (inlineToolResults) {

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

@@ -331,13 +331,13 @@ export async function runEmbeddedPiAgent(params) {
                             },
                         };
                     }
-                    // Handle role ordering errors with a user-friendly message
-                    if (/incorrect role information|roles must alternate/i.test(errorText)) {
+                    // Handle session corruption errors (role ordering, orphaned tool results)
+                    // Returning kind: "role_ordering" triggers auto-recovery (session reset) upstream.
+                    if (/incorrect role information|roles must alternate|tool_use_id|tool_result.*tool_use|tool_use.*tool_result/i.test(errorText)) {
                         return {
                             payloads: [
                                 {
-                                    text: "Message ordering conflict - please try again. " +
-                                        "If this persists, use /new to start a fresh session.",
+                                    text: "This conversation got into a bad state — resetting now.",
                                     isError: true,
                                 },
                             ],

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

@@ -8,7 +8,6 @@ export function buildEmbeddedSystemPrompt(params) {
         extraSystemPrompt: params.extraSystemPrompt,
         ownerNumbers: params.ownerNumbers,
         reasoningTagHint: params.reasoningTagHint,
-        finalTagHint: params.finalTagHint,
         heartbeatPrompt: params.heartbeatPrompt,
         skillsPrompt: params.skillsPrompt,
         docsPath: params.docsPath,

package/dist/agents/system-prompt.js

@@ -217,15 +217,6 @@ export function buildAgentSystemPrompt(params) {
             "<final>Hey there! What would you like to do next?</final>",
         ].join(" ")
         : undefined;
-    // For providers with native thinking (e.g. Anthropic), we only need the <final> instruction
-    // to prevent internal reasoning/planning text from leaking to the user.
-    const finalOnlyHint = !reasoningHint && params.finalTagHint
-        ? [
-            "Wrap every user-facing reply in <final>...</final> tags.",
-            "Only text inside <final> is shown to the user; everything outside is discarded.",
-            "Do not narrate your plan or next steps outside <final> — the user cannot see it.",
-        ].join(" ")
-        : undefined;
     const reasoningLevel = params.reasoningLevel ?? "off";
     const userTimezone = params.userTimezone?.trim();
     const skillsPrompt = params.skillsPrompt?.trim();
@@ -287,11 +278,11 @@ export function buildAgentSystemPrompt(params) {
         "If a task is more complex or takes longer, spawn a sub-agent. It will do the work for you and ping you when it's done. You can always check up on it.",
         "",
         "## Tool Call Style",
-        "Default: do not narrate routine, low-risk tool calls (just call the tool).",
-        "Narrate only when it helps: multi-step work, complex/challenging problems, sensitive actions (e.g., deletions), or when the user explicitly asks.",
-        "Keep narration brief and value-dense; avoid repeating obvious steps.",
-        "Use plain human language for narration unless in a technical context.",
-        "Never narrate internal housekeeping to the user: creating profiles, looking up records, checking memory, saving notes. Do those silently. The user sees the finished result, not the process.",
+        "Every text block you produce is delivered as a separate message. Unnecessary text blocks = unnecessary messages sent to the user.",
+        "Call tools silently by default. Do not announce what you are about to do, explain what you just did, or summarise completed steps.",
+        "If a task requires multiple tool calls, execute them without commentary. The user sees only your final response.",
+        "Narrate only when the user needs to know why there is a delay, or when an action has consequences they should be aware of (e.g. a deletion or sending on their behalf).",
+        "Never produce process narration like 'I'll check...', 'Let me look up...', 'Perfect — found it', 'Done — I've sent...'. These become unwanted messages.",
         "",
         "## Taskmaster CLI Quick Reference",
         "Taskmaster is controlled via subcommands. Do not invent commands.",
@@ -432,9 +423,6 @@ export function buildAgentSystemPrompt(params) {
     if (reasoningHint) {
         lines.push("## Reasoning Format", reasoningHint, "");
     }
-    else if (finalOnlyHint) {
-        lines.push("## Output Format", finalOnlyHint, "");
-    }
     const contextFiles = params.contextFiles ?? [];
     if (contextFiles.length > 0) {
         const hasSoulFile = contextFiles.some((file) => {

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 { createMemoryReindexTool } from "./tools/memory-reindex-tool.js";
 import { createMessageTool } from "./tools/message-tool.js";
 import { createNodesTool } from "./tools/nodes-tool.js";
 import { createSessionStatusTool } from "./tools/session-status-tool.js";
@@ -142,6 +143,7 @@ export function createTaskmasterTools(options) {
     const memoryGetTool = createMemoryGetTool(memoryToolOptions);
     const memoryWriteTool = createMemoryWriteTool(memoryToolOptions);
     const memorySaveMediaTool = createMemorySaveMediaTool(memoryToolOptions);
+    const memoryReindexTool = createMemoryReindexTool(memoryToolOptions);
     if (memorySearchTool)
         tools.push(memorySearchTool);
     if (memoryGetTool)
@@ -150,6 +152,8 @@ export function createTaskmasterTools(options) {
         tools.push(memoryWriteTool);
     if (memorySaveMediaTool)
         tools.push(memorySaveMediaTool);
+    if (memoryReindexTool)
+        tools.push(memoryReindexTool);
     const pluginTools = resolvePluginTools({
         context: {
             config: options?.config,

package/dist/agents/tool-policy.js

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

package/dist/agents/tools/memory-reindex-tool.js

@@ -0,0 +1,67 @@
+import { Type } from "@sinclair/typebox";
+import { getMemorySearchManager } from "../../memory/index.js";
+import { resolveSessionAgentId } from "../agent-scope.js";
+import { resolveMemorySearchConfig } from "../memory-search.js";
+import { jsonResult, readStringParam } from "./common.js";
+const MemoryReindexSchema = Type.Object({
+    action: Type.String({
+        description: "Action to perform: 'reindex' (force full reindex) or 'status' (return index stats)",
+    }),
+});
+export function createMemoryReindexTool(options) {
+    const cfg = options.config;
+    if (!cfg)
+        return null;
+    const agentId = resolveSessionAgentId({
+        sessionKey: options.agentSessionKey,
+        config: cfg,
+    });
+    if (!resolveMemorySearchConfig(cfg, agentId))
+        return null;
+    return {
+        label: "Memory Reindex",
+        name: "memory_reindex",
+        description: "Trigger a memory index rebuild or check index status. " +
+            "Use action='reindex' to force a full reindex of all memory files and sessions. " +
+            "Use action='status' to return current index stats (file counts, provider, sources).",
+        parameters: MemoryReindexSchema,
+        execute: async (_toolCallId, params) => {
+            const action = readStringParam(params, "action", { required: true });
+            const { manager, error } = await getMemorySearchManager({ cfg, agentId });
+            if (!manager) {
+                return jsonResult({ ok: false, error: error ?? "memory index unavailable" });
+            }
+            if (action === "status") {
+                const status = manager.status();
+                return jsonResult({
+                    ok: true,
+                    action: "status",
+                    files: status.files,
+                    chunks: status.chunks,
+                    sources: status.sources,
+                    sourceCounts: status.sourceCounts,
+                    provider: status.provider,
+                    model: status.model,
+                    dirty: status.dirty,
+                });
+            }
+            // Default: reindex
+            try {
+                await manager.sync({ reason: "agent-tool", force: true });
+                const status = manager.status();
+                return jsonResult({
+                    ok: true,
+                    action: "reindex",
+                    files: status.files,
+                    chunks: status.chunks,
+                    sources: status.sources,
+                    sourceCounts: status.sourceCounts,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return jsonResult({ ok: false, action: "reindex", error: message });
+            }
+        },
+    };
+}

package/dist/auto-reply/reply/agent-runner-execution.js

@@ -1,5 +1,4 @@
 import crypto from "node:crypto";
-import fs from "node:fs";
 import { resolveAgentModelFallbacksOverride, resolveDefaultAgentId, } from "../../agents/agent-scope.js";
 import { runCliAgent } from "../../agents/cli-runner.js";
 import { getCliSessionId } from "../../agents/cli-session.js";
@@ -7,7 +6,7 @@ import { runWithModelFallback } from "../../agents/model-fallback.js";
 import { isCliProvider } from "../../agents/model-selection.js";
 import { runEmbeddedPiAgent } from "../../agents/pi-embedded.js";
 import { isCompactionFailureError, isContextOverflowError, isLikelyContextOverflowError, sanitizeUserFacingText, } from "../../agents/pi-embedded-helpers.js";
-import { resolveAgentIdFromSessionKey, resolveGroupSessionKey, resolveSessionTranscriptPath, updateSessionStore, } from "../../config/sessions.js";
+import { resolveAgentIdFromSessionKey, resolveGroupSessionKey, } from "../../config/sessions.js";
 import { logVerbose } from "../../globals.js";
 import { emitAgentEvent, registerAgentRunContext } from "../../infra/agent-events.js";
 import { defaultRuntime } from "../../runtime.js";
@@ -198,7 +197,9 @@ export async function runAgentTurnWithFallback(params) {
                         ownerNumbers: params.followupRun.run.ownerNumbers,
                         enforceFinalTag: resolveEnforceFinalTag(params.followupRun.run, provider),
                         senderE164: params.sessionCtx.SenderE164,
-                        // Suppress raw API errors for non-default agents (public-facing)
+                        // Suppress raw API errors for non-default agents (public-facing).
+                        // Default (admin) agent gets formatted error text from formatAssistantErrorText
+                        // which provides human-readable messages for known error types.
                         suppressRawErrors: (() => {
                             const cfg = params.followupRun.run.config;
                             if (!cfg)
@@ -405,7 +406,7 @@ export async function runAgentTurnWithFallback(params) {
                     return {
                         kind: "final",
                         payload: {
-                            text: "⚠️ Message ordering conflict. I've reset the conversation - please try again.",
+                            text: "⚠️ Conversation got into a bad state. I've reset it - please try again.",
                         },
                     };
                 }
@@ -417,7 +418,7 @@ export async function runAgentTurnWithFallback(params) {
             const isContextOverflow = isLikelyContextOverflowError(message);
             const isCompactionFailure = isCompactionFailureError(message);
             const isSessionCorruption = /function call turn comes immediately after/i.test(message);
-            const isRoleOrderingError = /incorrect role information|roles must alternate/i.test(message);
+            const isRoleOrderingError = /incorrect role information|roles must alternate|tool_use_id|tool_result.*tool_use|tool_use.*tool_result/i.test(message);
             if (isCompactionFailure &&
                 !didResetAfterCompactionFailure &&
                 (await params.resetSessionAfterCompactionFailure(message))) {
@@ -435,52 +436,28 @@ export async function runAgentTurnWithFallback(params) {
                     return {
                         kind: "final",
                         payload: {
-                            text: "⚠️ Message ordering conflict. I've reset the conversation - please try again.",
+                            text: "⚠️ Conversation got into a bad state. I've reset it - please try again.",
                         },
                     };
                 }
             }
             // Auto-recover from Gemini session corruption by resetting the session
-            if (isSessionCorruption &&
-                params.sessionKey &&
-                params.activeSessionStore &&
-                params.storePath) {
-                const sessionKey = params.sessionKey;
-                const corruptedSessionId = params.getActiveSessionEntry()?.sessionId;
-                defaultRuntime.error(`Session history corrupted (Gemini function call ordering). Resetting session: ${params.sessionKey}`);
-                try {
-                    // Delete transcript file if it exists
-                    if (corruptedSessionId) {
-                        const transcriptPath = resolveSessionTranscriptPath(corruptedSessionId);
-                        try {
-                            fs.unlinkSync(transcriptPath);
-                        }
-                        catch {
-                            // Ignore if file doesn't exist
-                        }
-                    }
-                    // Keep the in-memory snapshot consistent with the on-disk store reset.
-                    delete params.activeSessionStore[sessionKey];
-                    // Remove session entry from store using a fresh, locked snapshot.
-                    await updateSessionStore(params.storePath, (store) => {
-                        delete store[sessionKey];
-                    });
-                }
-                catch (cleanupErr) {
-                    defaultRuntime.error(`Failed to reset corrupted session ${params.sessionKey}: ${String(cleanupErr)}`);
+            if (isSessionCorruption) {
+                const didReset = await params.resetSessionAfterRoleOrderingConflict(message);
+                if (didReset) {
+                    return {
+                        kind: "final",
+                        payload: {
+                            text: "⚠️ Conversation got into a bad state. I've reset it - please try again.",
+                        },
+                    };
                 }
-                return {
-                    kind: "final",
-                    payload: {
-                        text: "⚠️ Session history was corrupted. I've reset the conversation - please try again!",
-                    },
-                };
             }
             defaultRuntime.error(`Embedded agent failed before reply: ${message}`);
             const fallbackText = isContextOverflow
                 ? "⚠️ Context overflow — prompt too large for this model. Try a shorter message or a larger-context model."
                 : isRoleOrderingError
-                    ? "⚠️ Message ordering conflict - please try again. If this persists, use /new to start a fresh session."
+                    ? "⚠️ Conversation got into a bad state. Use /new to start a fresh session."
                     : "Sorry, I'm having trouble right now. Please try again in a few minutes.";
             return {
                 kind: "final",

package/dist/auto-reply/reply/agent-runner.js

@@ -1,12 +1,11 @@
 import crypto from "node:crypto";
-import fs from "node:fs";
 import { lookupContextTokens } from "../../agents/context.js";
 import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
 import { resolveModelAuthMode } from "../../agents/model-auth.js";
 import { isCliProvider } from "../../agents/model-selection.js";
 import { queueEmbeddedPiMessage } from "../../agents/pi-embedded.js";
 import { hasNonzeroUsage } from "../../agents/usage.js";
-import { resolveAgentIdFromSessionKey, resolveSessionFilePath, resolveSessionTranscriptPath, updateSessionStore, updateSessionStoreEntry, } from "../../config/sessions.js";
+import { resolveAgentIdFromSessionKey, resolveSessionTranscriptPath, updateSessionStore, updateSessionStoreEntry, } from "../../config/sessions.js";
 import { defaultRuntime } from "../../runtime.js";
 import { estimateUsageCost, resolveModelCostConfig } from "../../utils/usage-format.js";
 import { resolveResponseUsageMode } from "../thinking.js";
@@ -128,20 +127,29 @@ export async function runReplyAgent(params) {
         agentCfgContextTokens,
     });
     let responseUsageLine;
-    const resetSession = async ({ failureLabel, buildLogMessage, cleanupTranscripts, }) => {
+    const resetSession = async ({ failureLabel, buildLogMessage, }) => {
         if (!sessionKey || !activeSessionStore || !storePath)
             return false;
         const prevEntry = activeSessionStore[sessionKey] ?? activeSessionEntry;
         if (!prevEntry)
             return false;
-        const prevSessionId = cleanupTranscripts ? prevEntry.sessionId : undefined;
         const nextSessionId = crypto.randomUUID();
+        // Archive the previous session so it remains accessible via sessions_history.
+        const prevArchive = prevEntry.sessionId && prevEntry.sessionId !== nextSessionId
+            ? {
+                sessionId: prevEntry.sessionId,
+                sessionFile: prevEntry.sessionFile,
+                endedAt: Date.now(),
+            }
+            : undefined;
+        const existingArchive = prevEntry.previousSessions ?? [];
         const nextEntry = {
             ...prevEntry,
             sessionId: nextSessionId,
             updatedAt: Date.now(),
             systemSent: false,
             abortedLastRun: false,
+            previousSessions: prevArchive ? [...existingArchive, prevArchive] : existingArchive,
         };
         const agentId = resolveAgentIdFromSessionKey(sessionKey);
         const nextSessionFile = resolveSessionTranscriptPath(nextSessionId, agentId, sessionCtx.MessageThreadId);
@@ -160,21 +168,6 @@ export async function runReplyAgent(params) {
         activeSessionEntry = nextEntry;
         activeIsNewSession = true;
         defaultRuntime.error(buildLogMessage(nextSessionId));
-        if (cleanupTranscripts && prevSessionId) {
-            const transcriptCandidates = new Set();
-            const resolved = resolveSessionFilePath(prevSessionId, prevEntry, { agentId });
-            if (resolved)
-                transcriptCandidates.add(resolved);
-            transcriptCandidates.add(resolveSessionTranscriptPath(prevSessionId, agentId));
-            for (const candidate of transcriptCandidates) {
-                try {
-                    fs.unlinkSync(candidate);
-                }
-                catch {
-                    // Best-effort cleanup.
-                }
-            }
-        }
         return true;
     };
     const resetSessionAfterCompactionFailure = async (reason) => resetSession({
@@ -182,9 +175,8 @@ export async function runReplyAgent(params) {
         buildLogMessage: (nextSessionId) => `Auto-compaction failed (${reason}). Restarting session ${sessionKey} -> ${nextSessionId} and retrying.`,
     });
     const resetSessionAfterRoleOrderingConflict = async (reason) => resetSession({
-        failureLabel: "role ordering conflict",
-        buildLogMessage: (nextSessionId) => `Role ordering conflict (${reason}). Restarting session ${sessionKey} -> ${nextSessionId}.`,
-        cleanupTranscripts: true,
+        failureLabel: "session corruption",
+        buildLogMessage: (nextSessionId) => `Session corruption (${reason}). Restarting session ${sessionKey} -> ${nextSessionId}.`,
     });
     try {
         const runStartedAt = Date.now();
@@ -207,8 +199,6 @@ export async function runReplyAgent(params) {
             isHeartbeat,
             sessionKey,
             getActiveSessionEntry: () => activeSessionEntry,
-            activeSessionStore,
-            storePath,
             resolvedVerboseLevel,
         });
         if (runOutcome.kind === "final") {

package/dist/auto-reply/reply/get-reply-run.js

@@ -9,6 +9,7 @@ import { resolveGroupSessionKey, resolveSessionFilePath, } from "../../config/se
 import { logVerbose } from "../../globals.js";
 import { clearCommandLane, getQueueSize } from "../../process/command-queue.js";
 import { normalizeMainKey } from "../../routing/session-key.js";
+import { isReasoningTagProvider } from "../../utils/provider-utils.js";
 import { hasControlCommand } from "../command-detection.js";
 import { buildInboundMediaNote } from "../media-note.js";
 import { formatXHighModelHint, normalizeThinkLevel, supportsXHighThinking, } from "../thinking.js";
@@ -256,7 +257,7 @@ export async function runPreparedReply(params) {
             blockReplyBreak: resolvedBlockStreamingBreak,
             ownerNumbers: command.ownerList.length > 0 ? command.ownerList : undefined,
             extraSystemPrompt: extraSystemPrompt || undefined,
-            enforceFinalTag: true,
+            ...(isReasoningTagProvider(provider) ? { enforceFinalTag: true } : {}),
             skipMessageDelivery: opts?.skipMessageDelivery,
         },
     };

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

@@ -260,7 +260,7 @@ export async function initSessionState(params) {
             sessionFile: previousSessionEntry.sessionFile,
             endedAt: Date.now(),
         };
-        const existing = baseEntry?.previousSessions ?? [];
+        const existing = entry?.previousSessions ?? [];
         sessionEntry.previousSessions = [...existing, prev];
     }
     // Preserve per-session overrides while resetting compaction state on /new.

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.11",
-  "commit": "b6abbf7e2a7a62f677e6a5969f4d7c9054ad2894",
-  "builtAt": "2026-02-15T10:55:15.410Z"
+  "version": "1.0.12",
+  "commit": "6dc7c493b6d2366a818b586385a62ef76901bb16",
+  "builtAt": "2026-02-15T17:45:58.862Z"
 }