@rubytech/taskmaster 1.0.10 → 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

@@ -138,6 +138,10 @@ export async function compactEmbeddedPiSessionDirect(params) {
             sessionId: params.sessionId,
             warn: makeBootstrapWarn({ sessionLabel, warn: (message) => log.warn(message) }),
         });
+        // Extract skill base dirs for scoped skill_read tool
+        const skillBaseDirs = (params.skillsSnapshot?.resolvedSkills ?? [])
+            .map((s) => s.baseDir)
+            .filter(Boolean);
         const runAbortController = new AbortController();
         const toolsRaw = createTaskmasterCodingTools({
             exec: {
@@ -159,6 +163,7 @@ export async function compactEmbeddedPiSessionDirect(params) {
             modelProvider: model.provider,
             modelId,
             modelAuthMode: resolveModelAuthMode(model.provider, params.config),
+            skillBaseDirs,
         });
         const tools = sanitizeToolsForGoogle({ tools: toolsRaw, provider });
         logToolSchemasForGoogle({ tools, provider });

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

@@ -143,6 +143,10 @@ export async function runEmbeddedAttempt(params) {
             ? ["Reminder: commit your changes in this workspace after edits."]
             : undefined;
         const agentDir = params.agentDir ?? resolveTaskmasterAgentDir();
+        // Extract skill base dirs for scoped skill_read tool
+        const skillBaseDirs = (params.skillsSnapshot?.resolvedSkills ?? [])
+            .map((s) => s.baseDir)
+            .filter(Boolean);
         // Check if the model supports native image input
         const modelHasVision = params.model.input?.includes("image") ?? false;
         const toolsRaw = params.disableTools
@@ -175,6 +179,7 @@ export async function runEmbeddedAttempt(params) {
                 hasRepliedRef: params.hasRepliedRef,
                 modelHasVision,
                 skipMessageDelivery: params.skipMessageDelivery,
+                skillBaseDirs,
             });
         const tools = sanitizeToolsForGoogle({ tools: toolsRaw, provider: params.provider });
         logToolSchemasForGoogle({ tools, provider: params.provider });

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-tools.js

@@ -218,6 +218,7 @@ export function createTaskmasterCodingTools(options) {
             modelHasVision: options?.modelHasVision,
             requesterAgentIdOverride: agentId,
             messageSkipDelivery: options?.skipMessageDelivery,
+            skillBaseDirs: options?.skillBaseDirs,
         }),
     ];
     const coreToolNames = new Set(tools

package/dist/agents/skills/workspace.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { formatSkillsForPrompt, loadSkillsFromDir, } from "@mariozechner/pi-coding-agent";
+import { loadSkillsFromDir } from "@mariozechner/pi-coding-agent";
 import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { CONFIG_DIR, resolveUserPath } from "../../utils.js";
 import { resolveBundledSkillsDir } from "./bundled-dir.js";
@@ -10,6 +10,41 @@ import { resolvePluginSkillDirs } from "./plugin-skills.js";
 import { serializeByKey } from "./serialize.js";
 const fsp = fs.promises;
 const skillsLogger = createSubsystemLogger("skills");
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Format skills for inclusion in a system prompt.
+ * Identical to the library's formatSkillsForPrompt except it references
+ * `skill_read` instead of `read` so agents denied group:fs can still
+ * load skill content.
+ */
+function formatSkillsForPromptTaskmaster(skills) {
+    const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+    if (visibleSkills.length === 0)
+        return "";
+    const lines = [
+        "\n\nThe following skills provide specialized instructions for specific tasks.",
+        "Use the skill_read tool to load a skill's file when the task matches its description.",
+        "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+        "",
+        "<available_skills>",
+    ];
+    for (const skill of visibleSkills) {
+        lines.push("  <skill>");
+        lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+        lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+        lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+        lines.push("  </skill>");
+    }
+    lines.push("</available_skills>");
+    return lines.join("\n");
+}
 const skillCommandDebugOnce = new Set();
 function debugSkillCommandOnce(messageKey, message, meta) {
     if (skillCommandDebugOnce.has(messageKey))
@@ -141,7 +176,9 @@ export function buildWorkspaceSkillSnapshot(workspaceDir, opts) {
     const promptEntries = eligible.filter((entry) => entry.invocation?.disableModelInvocation !== true);
     const resolvedSkills = promptEntries.map((entry) => entry.skill);
     const remoteNote = opts?.eligibility?.remote?.note?.trim();
-    const prompt = [remoteNote, formatSkillsForPrompt(resolvedSkills)].filter(Boolean).join("\n");
+    const prompt = [remoteNote, formatSkillsForPromptTaskmaster(resolvedSkills)]
+        .filter(Boolean)
+        .join("\n");
     return {
         prompt,
         skills: eligible.map((entry) => ({
@@ -157,7 +194,7 @@ export function buildWorkspaceSkillsPrompt(workspaceDir, opts) {
     const eligible = filterSkillEntries(skillEntries, opts?.config, opts?.skillFilter, opts?.eligibility);
     const promptEntries = eligible.filter((entry) => entry.invocation?.disableModelInvocation !== true);
     const remoteNote = opts?.eligibility?.remote?.note?.trim();
-    return [remoteNote, formatSkillsForPrompt(promptEntries.map((entry) => entry.skill))]
+    return [remoteNote, formatSkillsForPromptTaskmaster(promptEntries.map((entry) => entry.skill))]
         .filter(Boolean)
         .join("\n");
 }

package/dist/agents/system-prompt.js

@@ -132,9 +132,11 @@ export function buildAgentSystemPrompt(params) {
         sessions_spawn: "Spawn a sub-agent session",
         session_status: "Show a /status-equivalent status card (usage + time + Reasoning/Verbose/Elevated); use for model-use questions (📊 session_status); optional per-session model override",
         image: "Analyze an image with the configured image model",
+        skill_read: "Read files within skill directories (SKILL.md, references)",
     };
     const toolOrder = [
         "read",
+        "skill_read",
         "write",
         "edit",
         "apply_patch",
@@ -192,6 +194,10 @@ export function buildAgentSystemPrompt(params) {
     }
     const hasGateway = availableTools.has("gateway");
     const readToolName = resolveToolName("read");
+    // For skills section: prefer skill_read when agent has it but not read
+    const skillReadToolName = availableTools.has("skill_read") && !availableTools.has("read")
+        ? resolveToolName("skill_read")
+        : readToolName;
     const execToolName = resolveToolName("exec");
     const processToolName = resolveToolName("process");
     const extraSystemPrompt = params.extraSystemPrompt?.trim();
@@ -231,7 +237,7 @@ export function buildAgentSystemPrompt(params) {
     const skillsSection = buildSkillsSection({
         skillsPrompt,
         isMinimal,
-        readToolName,
+        readToolName: skillReadToolName,
     });
     const memorySection = buildMemorySection({ isMinimal, availableTools });
     const docsSection = buildDocsSection({
@@ -272,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.",

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";
@@ -23,6 +24,7 @@ import { createLicenseGenerateTool } from "./tools/license-tool.js";
 import { createCustomerLookupTool } from "./tools/customer-lookup-tool.js";
 import { createCustomerUpdateTool } from "./tools/customer-update-tool.js";
 import { createRelayMessageTool } from "./tools/relay-message-tool.js";
+import { createSkillReadTool } from "./tools/skill-read-tool.js";
 export function createTaskmasterTools(options) {
     const imageTool = options?.agentDir?.trim()
         ? createImageTool({
@@ -127,6 +129,11 @@ export function createTaskmasterTools(options) {
         createCustomerUpdateTool(),
         createRelayMessageTool(),
     ];
+    // Add scoped skill_read tool when skill directories are provided
+    const skillDirs = (options?.skillBaseDirs ?? []).filter(Boolean);
+    if (skillDirs.length > 0) {
+        tools.push(createSkillReadTool({ allowedSkillDirs: skillDirs }));
+    }
     // Add memory tools (conditionally based on config)
     const memoryToolOptions = {
         config: options?.config,
@@ -136,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)
@@ -144,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-display.json

@@ -40,6 +40,11 @@
             "title": "Read",
             "detailKeys": ["path"]
         },
+        "skill_read": {
+            "emoji": "📖",
+            "title": "Skill Read",
+            "detailKeys": ["path"]
+        },
         "write": {
             "emoji": "✍️",
             "title": "Write",

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/agents/tools/skill-read-tool.js

@@ -0,0 +1,75 @@
+import fs from "node:fs/promises";
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+import { Type } from "@sinclair/typebox";
+import { readStringParam } from "./common.js";
+const SkillReadSchema = Type.Object({
+    path: Type.String({ description: "Absolute or relative path to the file to read" }),
+    skill_dir: Type.Optional(Type.String({
+        description: "Skill directory for resolving relative paths. If omitted, path must be absolute.",
+    })),
+});
+/**
+ * Create a scoped file-read tool that only allows reading files within
+ * the provided skill directories. This gives agents access to skill
+ * content (SKILL.md, references/) without exposing the full filesystem.
+ */
+export function createSkillReadTool(opts) {
+    // Pre-resolve allowed dirs at creation time (async realpath done at call time).
+    const allowedDirs = opts.allowedSkillDirs.filter(Boolean);
+    return {
+        label: "Skill Read",
+        name: "skill_read",
+        description: "Read a file within a skill directory (SKILL.md, references, etc.). " +
+            "Use this to load skill content on demand. " +
+            "Only files inside skill directories are accessible.",
+        parameters: SkillReadSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const rawPath = readStringParam(params, "path", { required: true });
+            const skillDir = readStringParam(params, "skill_dir");
+            // Resolve the target path
+            let targetPath;
+            if (path.isAbsolute(rawPath)) {
+                targetPath = path.resolve(rawPath);
+            }
+            else if (skillDir) {
+                targetPath = path.resolve(skillDir, rawPath);
+            }
+            else {
+                throw new Error("Relative path requires skill_dir. Provide an absolute path or include skill_dir.");
+            }
+            // Security: resolve symlinks on the target and check containment
+            let realTarget;
+            try {
+                realTarget = await realpath(targetPath);
+            }
+            catch {
+                throw new Error(`File not found: ${targetPath}`);
+            }
+            let allowed = false;
+            for (const dir of allowedDirs) {
+                let realDir;
+                try {
+                    realDir = await realpath(dir);
+                }
+                catch {
+                    continue;
+                }
+                const prefix = realDir.endsWith("/") ? realDir : `${realDir}/`;
+                if (realTarget === realDir || realTarget.startsWith(prefix)) {
+                    allowed = true;
+                    break;
+                }
+            }
+            if (!allowed) {
+                throw new Error(`Access denied: ${rawPath} is outside all skill directories.`);
+            }
+            const content = await fs.readFile(realTarget, "utf-8");
+            return {
+                content: [{ type: "text", text: content }],
+                details: { path: realTarget },
+            };
+        },
+    };
+}

package/dist/agents/workspace.js

@@ -20,7 +20,7 @@ export const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
 export const DEFAULT_USER_FILENAME = "USER.md";
 export const DEFAULT_HEARTBEAT_FILENAME = "HEARTBEAT.md";
 export const DEFAULT_BOOTSTRAP_FILENAME = "BOOTSTRAP.md";
-const TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../docs/reference/templates");
+const TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../templates/customer/agents/admin");
 function stripFrontMatter(content) {
     if (!content.startsWith("---"))
         return content;
@@ -39,7 +39,7 @@ async function loadTemplate(name) {
         return stripFrontMatter(content);
     }
     catch {
-        throw new Error(`Missing workspace template: ${name} (${templatePath}). Ensure docs/reference/templates are packaged.`);
+        throw new Error(`Missing workspace template: ${name} (${templatePath}). Ensure templates/customer is packaged.`);
     }
 }
 async function writeFileIfMissing(filePath, content) {

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",