@rubytech/taskmaster 1.23.1 → 1.25.1

package/dist/agents/cli-runner/helpers.js

@@ -161,7 +161,7 @@ export function buildSystemPrompt(params) {
         },
     });
     const ttsHint = params.config ? buildTtsSystemPromptHint(params.config) : undefined;
-    return buildAgentSystemPrompt({
+    const prompt = buildAgentSystemPrompt({
         workspaceDir: params.workspaceDir,
         defaultThinkLevel: params.defaultThinkLevel,
         extraSystemPrompt: params.extraSystemPrompt,
@@ -178,6 +178,11 @@ export function buildSystemPrompt(params) {
         contextFiles: params.contextFiles,
         ttsHint,
     });
+    return {
+        prompt,
+        bootstrapFiles: params.bootstrapFiles ?? [],
+        skillsPrompt: params.skillsPrompt ?? "",
+    };
 }
 export function normalizeCliModel(modelId, backend) {
     const trimmed = modelId.trim();

package/dist/agents/cli-runner.js

@@ -10,7 +10,9 @@ import { makeBootstrapWarn, resolveBootstrapContextForRun } from "./bootstrap-fi
 import { resolveCliBackendConfig } from "./cli-backends.js";
 import { appendImagePathsToPrompt, buildCliArgs, buildSystemPrompt, cleanupResumeProcesses, cleanupSuspendedCliProcesses, enqueueCliRun, normalizeCliModel, parseCliJson, parseCliJsonl, resolvePromptInput, resolveSessionIdToSend, resolveSystemPromptUsage, writeCliImages, } from "./cli-runner/helpers.js";
 import { FailoverError, resolveFailoverStatus } from "./failover-error.js";
-import { classifyFailoverReason, isFailoverErrorMessage } from "./pi-embedded-helpers.js";
+import { classifyFailoverReason, isFailoverErrorMessage, resolveBootstrapMaxChars, } from "./pi-embedded-helpers.js";
+import { buildSystemPromptReport } from "./system-prompt-report.js";
+import { writeSystemPromptLog } from "./system-prompt-log.js";
 const log = createSubsystemLogger("agent/claude-cli");
 export async function runCliAgent(params) {
     const started = Date.now();
@@ -31,7 +33,7 @@ export async function runCliAgent(params) {
         .filter(Boolean)
         .join("\n");
     const sessionLabel = params.sessionKey ?? params.sessionId;
-    const { contextFiles } = await resolveBootstrapContextForRun({
+    const { bootstrapFiles, contextFiles } = await resolveBootstrapContextForRun({
         workspaceDir,
         config: params.config,
         sessionKey: params.sessionKey,
@@ -51,7 +53,7 @@ export async function runCliAgent(params) {
         cwd: process.cwd(),
         moduleUrl: import.meta.url,
     });
-    const systemPrompt = buildSystemPrompt({
+    const { prompt: systemPrompt, skillsPrompt } = buildSystemPrompt({
         workspaceDir,
         config: params.config,
         defaultThinkLevel: params.thinkLevel,
@@ -63,7 +65,28 @@ export async function runCliAgent(params) {
         contextFiles,
         modelDisplay,
         agentId: sessionAgentId,
+        bootstrapFiles,
     });
+    const systemPromptReport = buildSystemPromptReport({
+        source: "run",
+        generatedAt: Date.now(),
+        sessionId: params.sessionId,
+        sessionKey: params.sessionKey,
+        provider: params.provider,
+        model: modelId,
+        workspaceDir,
+        bootstrapMaxChars: resolveBootstrapMaxChars(params.config),
+        systemPrompt,
+        bootstrapFiles,
+        injectedFiles: contextFiles,
+        skillsPrompt,
+        tools: [],
+    });
+    // Fire-and-forget: log full system prompt to disk
+    const sessionKeyForLog = params.sessionKey ?? params.sessionId;
+    if (sessionKeyForLog) {
+        writeSystemPromptLog(sessionKeyForLog, systemPrompt).catch(() => { });
+    }
     const { sessionId: cliSessionIdToSend, isNew } = resolveSessionIdToSend({
         backend,
         cliSessionId: params.cliSessionId,
@@ -219,6 +242,7 @@ export async function runCliAgent(params) {
                     model: modelId,
                     usage: output.usage,
                 },
+                systemPromptReport,
             },
         };
     }

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

@@ -32,6 +32,7 @@ import { acquireSessionWriteLock } from "../../session-write-lock.js";
 import { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, loadWorkspaceSkillEntries, resolveSkillsPromptForRun, } from "../../skills.js";
 import { DEFAULT_BOOTSTRAP_FILENAME } from "../../workspace.js";
 import { buildSystemPromptReport } from "../../system-prompt-report.js";
+import { writeSystemPromptLog } from "../../system-prompt-log.js";
 import { resolveDefaultModelForAgent } from "../../model-selection.js";
 import { isAbortError } from "../abort.js";
 import { buildEmbeddedExtensionPaths } from "../extensions.js";
@@ -326,6 +327,11 @@ export async function runEmbeddedAttempt(params) {
             tools,
         });
         const systemPrompt = createSystemPromptOverride(appendPrompt);
+        // Fire-and-forget: log the full system prompt text to disk
+        const sessionKeyForLog = params.sessionKey ?? params.sessionId;
+        if (sessionKeyForLog) {
+            writeSystemPromptLog(sessionKeyForLog, appendPrompt).catch(() => { });
+        }
         const sessionLock = await acquireSessionWriteLock({
             sessionFile: params.sessionFile,
         });

package/dist/agents/system-prompt-log.js

@@ -0,0 +1,24 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("system-prompt-log");
+const DEFAULT_DIR = path.join(os.homedir(), ".taskmaster", "logs", "system-prompts");
+const MAX_KEY_LENGTH = 128;
+export function sanitiseSessionKey(key) {
+    const cleaned = key.replace(/[:/\\]/g, "_").trim();
+    if (!cleaned)
+        return "_unknown_";
+    return cleaned.slice(0, MAX_KEY_LENGTH);
+}
+export async function writeSystemPromptLog(sessionKey, systemPrompt, dir = DEFAULT_DIR) {
+    try {
+        const fileName = `${sanitiseSessionKey(sessionKey)}.txt`;
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(path.join(dir, fileName), systemPrompt, "utf-8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log.warn(`Failed to write system prompt log: ${message}`);
+    }
+}

package/dist/agents/system-prompt.js

@@ -300,9 +300,17 @@ export function buildAgentSystemPrompt(params) {
                 "- cron: manage scheduled events and wake events (use for reminders; when scheduling a reminder, write the systemEvent text as something that will read like a reminder when it fires, and mention that it is a reminder depending on the time gap between setting and firing; include recent context in reminder text if appropriate)",
                 "- sessions_list: list sessions",
                 "- sessions_history: fetch session history",
+                "- sessions_spawn: spawn a background sub-agent for a task (returns immediately; result is announced when done)",
             ].join("\n"),
         "TOOLS.md does not control tool availability; it is user guidance for how to use external tools.",
-        "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.",
+        "## Delegation",
+        "Your default mode is to delegate work to sub-agents. Any task beyond a straightforward conversational reply should be handled by a sub-agent via `sessions_spawn`.",
+        "Delegation keeps you responsive — you hand off the work and continue chatting. The sub-agent runs in the background; when it finishes, its result is announced back into this conversation automatically.",
+        "",
+        "**Delegate when the task involves:** tool calls (file reads/writes, memory operations, web searches, document reading, image generation, research, calculations, composing longer content, or any multi-step work).",
+        "**Handle inline only when:** the response is purely conversational — a greeting, a quick factual answer from your own knowledge, a yes/no, or a brief opinion that requires no tool calls.",
+        "",
+        "When spawning, provide a clear `task` description and a short `label` so you can track it. You don't need to tell the user you're delegating — just do it. The result will flow back naturally.",
         "",
         "## Tool Call Style",
         "Every text block you produce is delivered as a separate message. Unnecessary text blocks = unnecessary messages sent to the user.",

package/dist/agents/workspace-migrations.js

@@ -29,7 +29,12 @@ const PUBLIC_AGENT_INDICATORS = [
 /** Formatting section headers commonly found at the end of AGENTS files. */
 const FORMATTING_HEADERS = ["## WhatsApp Formatting", "## Message Formatting", "## Formatting"];
 /** Section headers that typically precede "## Capabilities" in admin agents. */
-const CAPABILITIES_HEADERS = ["## Capabilities", "## Stripe CLI Operations", "## User Management"];
+const CAPABILITIES_HEADERS = [
+    "## Capabilities",
+    "## Tools",
+    "## Stripe CLI Operations",
+    "## User Management",
+];
 function isPublicAgent(content) {
     return PUBLIC_AGENT_INDICATORS.some((p) => content.includes(p));
 }
@@ -703,6 +708,67 @@ async function patchBeagleAdminDriverContactTone(_agentsPath, content) {
         return null;
     return content.replace(ADMIN_DRIVER_CONTACT_OLD, ADMIN_DRIVER_CONTACT_NEW);
 }
+// ---------------------------------------------------------------------------
+// Migration: Sub-Agent Delegation (v1.24)
+// ---------------------------------------------------------------------------
+const DELEGATION_SECTION = `## Delegation — Sub-Agents
+
+**Default to delegation.** Any task that requires tool calls — reading files, searching memory, generating content, web lookups, document processing, image work — should be spawned as a sub-agent using \`sessions_spawn\`. You stay free to keep chatting with the business owner.
+
+**How it works:**
+1. Call \`sessions_spawn\` with a clear \`task\` and a short \`label\`
+2. The sub-agent runs in the background with the same tools and memory access you have
+3. When it finishes, its result is announced back into your conversation automatically
+4. You summarise the result naturally — don't mention sub-agents or background tasks
+
+**Delegate:**
+- Memory searches and lookups
+- File reading/writing
+- Document reading (PDFs, DOCX, etc.)
+- Web searches and fetches
+- Content creation (drafts, summaries, reports)
+- Image generation
+- Multi-step research tasks
+- Anything that takes more than a moment
+
+**Handle inline (no delegation):**
+- Quick conversational replies (greetings, opinions, yes/no)
+- Brief factual answers you already know
+- Clarifying questions before starting work
+- Confirming or acknowledging something the owner said
+
+When multiple independent tasks come up, spawn multiple sub-agents in parallel. Don't wait for one to finish before starting the next.`;
+function hasDelegationSection(content) {
+    return content.includes("## Delegation") || content.includes("sessions_spawn");
+}
+async function patchDelegationSection(_agentsPath, content) {
+    if (isPublicAgent(content))
+        return null;
+    if (hasDelegationSection(content))
+        return null;
+    return insertSection(content, DELEGATION_SECTION, findCapabilitiesInsertPoint);
+}
+// ---------------------------------------------------------------------------
+// SOUL.md Migration: Sub-Agent Delegation (v1.24)
+// ---------------------------------------------------------------------------
+const SOUL_DELEGATION_SECTION = `## How You Work
+
+**Delegate everything that isn't a quick reply.** Your role is to stay responsive — thinking, conversing, and directing. Actual work (research, file operations, document reading, content creation, memory lookups, calculations) gets handed to sub-agents via \`sessions_spawn\`. They run in the background and report back when done. You keep chatting.`;
+function soulHasDelegation(content) {
+    return content.includes("## How You Work") || content.includes("sessions_spawn");
+}
+async function patchSoulDelegation(content) {
+    if (soulHasDelegation(content))
+        return null;
+    // Insert before "## What You Don't Do" if present
+    const insertBefore = "## What You Don't Do";
+    const idx = content.indexOf(insertBefore);
+    if (idx !== -1) {
+        return content.slice(0, idx) + SOUL_DELEGATION_SECTION + "\n\n" + content.slice(idx);
+    }
+    // Fallback: append
+    return content.trimEnd() + "\n\n" + SOUL_DELEGATION_SECTION + "\n";
+}
 const MIGRATIONS = [
     { name: "skill-recommendations", apply: patchSkillRecommendations },
     { name: "owner-learning", apply: patchOwnerLearning },
@@ -720,6 +786,7 @@ const MIGRATIONS = [
     { name: "beagle-public-tourist-phone", apply: patchBeaglePublicTouristPhone },
     { name: "beagle-admin-driver-reply-explicit", apply: patchBeagleAdminDriverReplyExplicit },
     { name: "beagle-admin-driver-contact-tone", apply: patchBeagleAdminDriverContactTone },
+    { name: "delegation-section", apply: patchDelegationSection },
 ];
 /**
  * Run all workspace migrations for every configured agent.
@@ -760,5 +827,20 @@ export async function runWorkspaceMigrations(cfg) {
                 log.warn(`failed to write AGENTS.md for agent "${agentId}": ${String(err)}`);
             }
         }
+        // SOUL.md migrations (admin agents only)
+        const soulPath = path.join(wsDir, "SOUL.md");
+        try {
+            const soulContent = await fs.readFile(soulPath, "utf-8");
+            if (!isPublicAgent(content)) {
+                const soulResult = await patchSoulDelegation(soulContent);
+                if (soulResult !== null) {
+                    await fs.writeFile(soulPath, soulResult, "utf-8");
+                    log.info(`patched SOUL.md for agent "${agentId}": delegation`);
+                }
+            }
+        }
+        catch {
+            // No SOUL.md or read error — skip.
+        }
     }
 }

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.23.1",
-  "commit": "ed5fa161fab1aa78aa580e7ac3a2349155a1e160",
-  "builtAt": "2026-03-07T08:06:37.703Z"
+  "version": "1.25.1",
+  "commit": "cab74729d527161291e19519e78fd0f9202db79e",
+  "builtAt": "2026-03-07T12:55:01.318Z"
 }

package/dist/config/agent-tools-reconcile.js

@@ -294,6 +294,41 @@ export function reconcileSkillReadTool(params) {
     }
     return { config, changes };
 }
+/**
+ * Add `sessions_spawn` to admin agents whose explicit allow list has
+ * `sessions_list` but lacks `sessions_spawn`.
+ *
+ * `sessions_spawn` was added to `group:sessions` but most admin agents use
+ * individual tool names rather than the group reference. This reconciliation
+ * patches them on gateway startup so sub-agent delegation works.
+ *
+ * Runs unconditionally on gateway startup. Idempotent — skips agents that
+ * already have `sessions_spawn` or `group:sessions`.
+ */
+export function reconcileSessionsSpawnTool(params) {
+    const config = structuredClone(params.config);
+    const changes = [];
+    const agents = config.agents?.list;
+    if (!Array.isArray(agents))
+        return { config, changes };
+    for (const agent of agents) {
+        if (!agent || !isAdminAgent(agent))
+            continue;
+        const allow = agent.tools?.allow;
+        if (!Array.isArray(allow))
+            continue;
+        // Already covered
+        if (allow.includes("sessions_spawn") || allow.includes("group:sessions"))
+            continue;
+        // Only patch agents that have sessions_list (confirms they use individual session tool names)
+        if (!allow.includes("sessions_list"))
+            continue;
+        const idx = allow.indexOf("sessions_list");
+        allow.splice(idx + 1, 0, "sessions_spawn");
+        changes.push(`Added sessions_spawn to agent "${agent.id ?? "<unnamed>"}" tools.allow.`);
+    }
+    return { config, changes };
+}
 /**
  * Individual skill tool names that should be replaced by `group:skills`.
  * Matches the members of TOOL_GROUPS["group:skills"] in tool-policy.ts.