@rubytech/taskmaster 1.44.5 → 1.44.7

package/dist/agents/pi-embedded-subscribe.handlers.tools.js

@@ -166,7 +166,10 @@ export function handleToolExecutionEnd(ctx, evt) {
             isError: isToolError,
         },
     });
-    ctx.log.debug(`embedded run tool end: runId=${ctx.params.runId} tool=${toolName} toolCallId=${toolCallId}`);
+    const errorSuffix = isToolError
+        ? ` error=${extractToolErrorMessage(sanitizedResult) ?? "unknown"}`
+        : "";
+    ctx.log.debug(`embedded run tool end: runId=${ctx.params.runId} tool=${toolName} toolCallId=${toolCallId} isError=${isToolError}${errorSuffix}`);
     if (ctx.params.onToolResult && ctx.shouldEmitToolOutput()) {
         const outputText = extractToolResultText(sanitizedResult);
         if (outputText) {

package/dist/agents/pi-tools.js

@@ -11,7 +11,7 @@ import { assertRequiredParams, CLAUDE_PARAM_GROUPS, createTaskmasterReadTool, cr
 import { cleanToolSchemaForGemini, normalizeToolParameters } from "./pi-tools.schema.js";
 import { buildPluginToolGroups, collectExplicitAllowlist, expandPolicyWithPluginGroups, normalizeToolName, resolveToolProfilePolicy, stripPluginOnlyAllowlist, } from "./tool-policy.js";
 import { getPluginToolMeta } from "../plugins/tools.js";
-import { logWarn } from "../logger.js";
+import { logInfo, logWarn } from "../logger.js";
 function isOpenAIProvider(provider) {
     const normalized = provider?.trim().toLowerCase();
     return normalized === "openai" || normalized === "openai-codex";
@@ -254,33 +254,49 @@ export function createTaskmasterCodingTools(options) {
     const groupPolicyExpanded = resolvePolicy(groupPolicy, "group tools.allow");
     const sandboxPolicyExpanded = expandPolicyWithPluginGroups(sandbox?.tools, pluginGroups);
     const subagentPolicyExpanded = expandPolicyWithPluginGroups(subagentPolicy, pluginGroups);
-    const toolsFiltered = profilePolicyExpanded
-        ? filterToolsByPolicy(tools, profilePolicyExpanded)
-        : tools;
-    const providerProfileFiltered = providerProfileExpanded
-        ? filterToolsByPolicy(toolsFiltered, providerProfileExpanded)
-        : toolsFiltered;
-    const globalFiltered = globalPolicyExpanded
-        ? filterToolsByPolicy(providerProfileFiltered, globalPolicyExpanded)
-        : providerProfileFiltered;
-    const globalProviderFiltered = globalProviderExpanded
-        ? filterToolsByPolicy(globalFiltered, globalProviderExpanded)
-        : globalFiltered;
-    const agentFiltered = agentPolicyExpanded
-        ? filterToolsByPolicy(globalProviderFiltered, agentPolicyExpanded)
-        : globalProviderFiltered;
-    const agentProviderFiltered = agentProviderExpanded
-        ? filterToolsByPolicy(agentFiltered, agentProviderExpanded)
-        : agentFiltered;
-    const groupFiltered = groupPolicyExpanded
-        ? filterToolsByPolicy(agentProviderFiltered, groupPolicyExpanded)
-        : agentProviderFiltered;
-    const sandboxed = sandboxPolicyExpanded
-        ? filterToolsByPolicy(groupFiltered, sandboxPolicyExpanded)
-        : groupFiltered;
-    const subagentFiltered = subagentPolicyExpanded
-        ? filterToolsByPolicy(sandboxed, subagentPolicyExpanded)
-        : sandboxed;
+    // ── Cascading tool filter with diagnostic logging ─────────────────────
+    const filterStage = (input, policy, label) => {
+        if (!policy)
+            return input;
+        const output = filterToolsByPolicy(input, policy);
+        const inputNames = new Set(input.map((t) => normalizeToolName(t.name)));
+        const outputNames = new Set(output.map((t) => normalizeToolName(t.name)));
+        const removed = [...inputNames].filter((n) => !outputNames.has(n));
+        if (removed.length > 0) {
+            const sessionLabel = options?.sessionKey ?? "unknown-session";
+            logInfo(`[tool-filter] ${sessionLabel} | ${label} removed ${removed.length} tools: ${removed.join(", ")}`);
+        }
+        return output;
+    };
+    // When the agent has an explicit allow list, merge it with the profile's
+    // allow list so the agent can grant tools beyond the profile baseline.
+    // The profile sets a default scope; the agent config can expand it.
+    // Deny lists and PROFILE_NEVER_GRANT still restrict regardless.
+    const effectiveProfilePolicy = (() => {
+        if (!profilePolicyExpanded || !agentPolicyExpanded?.allow?.length) {
+            return profilePolicyExpanded;
+        }
+        const mergedAllow = [
+            ...(profilePolicyExpanded.allow ?? []),
+            ...(agentPolicyExpanded.allow ?? []),
+        ];
+        return { ...profilePolicyExpanded, allow: mergedAllow };
+    })();
+    const toolsFiltered = filterStage(tools, effectiveProfilePolicy, `profile(${effectiveProfile ?? "none"})+agent`);
+    const providerProfileFiltered = filterStage(toolsFiltered, providerProfileExpanded, "providerProfile");
+    const globalFiltered = filterStage(providerProfileFiltered, globalPolicyExpanded, "global");
+    const globalProviderFiltered = filterStage(globalFiltered, globalProviderExpanded, "globalProvider");
+    const agentFiltered = filterStage(globalProviderFiltered, agentPolicyExpanded, `agent(${agentId ?? "?"})`);
+    const agentProviderFiltered = filterStage(agentFiltered, agentProviderExpanded, "agentProvider");
+    const groupFiltered = filterStage(agentProviderFiltered, groupPolicyExpanded, "group");
+    const sandboxed = filterStage(groupFiltered, sandboxPolicyExpanded, "sandbox");
+    const subagentFiltered = filterStage(sandboxed, subagentPolicyExpanded, "subagent");
+    // Log final tool set for observability.
+    {
+        const sessionLabel = options?.sessionKey ?? "unknown-session";
+        const finalNames = subagentFiltered.map((t) => normalizeToolName(t.name)).sort();
+        logInfo(`[tool-filter] ${sessionLabel} | profile=${effectiveProfile ?? "none"} | final tools (${finalNames.length}): ${finalNames.join(", ")}`);
+    }
     // Always normalize tool JSON Schemas before handing them to pi-agent/pi-ai.
     // Without this, some providers (notably OpenAI) will reject root-level union schemas.
     const normalized = subagentFiltered.map(normalizeToolParameters);

package/dist/agents/system-prompt.js

@@ -338,12 +338,15 @@ export function buildAgentSystemPrompt(params) {
         "",
         "### Spawn Profiles",
         "Use `toolProfile` to give sub-agents only the tools they need. This reduces cost and focuses the sub-agent.",
+        "",
+        "**Profile selection principle:** match the profile to the task's **output**, not its input or subject matter. A task that reads from memory but produces a PDF needs `spawn:documents`, not `spawn:memory`. A task that reads a document but saves findings to memory needs `spawn:memory`, not `spawn:documents`. The deliverable determines the profile.",
+        "",
         "Available profiles:",
-        "- `spawn:memory` — recall and store information: memory search, read, write, file access, skills",
-        "- `spawn:documents` — read and produce documents: PDFs, spreadsheets, QR codes",
+        "- `spawn:memory` — recall, search, and store information in memory. For lookups, saving notes, and organizing knowledge — NOT for producing formatted output files like PDFs.",
+        "- `spawn:documents` — produce formatted output files: draft content, convert to PDF, generate QR codes. Has memory access so it can read source material. Use whenever the deliverable is a file (PDF, document, spreadsheet).",
         "- `spawn:contacts` — manage contacts: lookup, create, update, verify",
         "- `spawn:web` — research online: web search, URL fetch, file access",
-        "- `spawn:admin` — system administration and diagnostics: manage admins, status checks, settings, log review, error triage, performance analysis, automation",
+        "- `spawn:admin` — system administration, licensing, and diagnostics: manage admins, generate licenses, status checks, settings, log review, error triage, performance analysis, automation",
         "- `spawn:automation` — scheduled tasks: cron jobs, gateway management, updates, tunnel",
         "- `spawn:ui` — visual work: browser control, canvas",
         "- `spawn:worker` — general-purpose (files, memory, web, docs, images, skills)",

package/dist/agents/tool-policy.js

@@ -68,6 +68,7 @@ export const TOOL_GROUPS = {
         "account_manage",
         "access_manage",
         "license_manage",
+        "license_generate",
     ],
     // All Taskmaster native tools (excludes provider plugins).
     "group:taskmaster": [
@@ -123,6 +124,7 @@ export const TOOL_GROUPS = {
         "account_manage",
         "access_manage",
         "license_manage",
+        "license_generate",
         "tunnel_status",
         "tunnel_enable",
         "tunnel_disable",
@@ -205,7 +207,15 @@ const TOOL_PROFILES = {
         allow: ["group:memory", "group:fs", "group:runtime", "group:time", "group:skills", "image"],
     },
     "spawn:documents": {
-        allow: ["group:documents", "group:fs", "group:runtime", "group:time", "group:skills", "image"],
+        allow: [
+            "group:documents",
+            "group:memory",
+            "group:fs",
+            "group:runtime",
+            "group:time",
+            "group:skills",
+            "image",
+        ],
     },
     "spawn:contacts": {
         allow: ["group:contacts", "group:fs", "group:time", "group:skills"],

package/dist/agents/tools/document-to-pdf-tool.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { Type } from "@sinclair/typebox";
@@ -7,12 +8,48 @@ import { resolveBrowserExecutableForPlatform } from "../../browser/chrome.execut
 import { resolveAgentWorkspaceDir, resolveSessionAgentId } from "../agent-scope.js";
 import { assertSandboxPath } from "../sandbox-paths.js";
 import { jsonResult, readStringParam } from "./common.js";
+const MARKDOWN_EXTENSIONS = new Set([".md", ".markdown", ".mdown", ".mkd"]);
 const DocumentToPdfSchema = Type.Object({
     path: Type.String({
-        description: "Path to an HTML file. Use a memory path (e.g. memory/users/+447.../documents/invoices/INV-001.html) " +
-            "or an absolute path.",
+        description: "Path to an HTML or Markdown file to convert to PDF. " +
+            "Accepts .html, .md, and .markdown files. Markdown files are automatically rendered to styled HTML before conversion. " +
+            "Use a memory path (e.g. memory/admin/documents/contract.md) or an absolute path.",
     }),
 });
+/**
+ * Wrap markdown-rendered HTML in a styled document shell suitable for PDF output.
+ * Uses system fonts and clean typographic defaults so the PDF looks professional
+ * without requiring external stylesheets.
+ */
+function wrapMarkdownHtml(bodyHtml) {
+    return `<!doctype html>
+<html><head>
+<meta charset="utf-8" />
+<style>
+  html { font-size: 14px; }
+  body {
+    max-width: 720px; margin: 40px auto; padding: 0 24px;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+    line-height: 1.6; color: #1a1a1a;
+  }
+  h1 { font-size: 1.8rem; margin: 1.5em 0 0.5em; border-bottom: 1px solid #ddd; padding-bottom: 0.3em; }
+  h2 { font-size: 1.4rem; margin: 1.3em 0 0.4em; }
+  h3 { font-size: 1.15rem; margin: 1.2em 0 0.4em; }
+  p { margin: 0.6em 0; }
+  ul, ol { padding-left: 1.8em; }
+  li { margin: 0.25em 0; }
+  table { border-collapse: collapse; width: 100%; margin: 1em 0; }
+  th, td { border: 1px solid #ccc; padding: 6px 10px; text-align: left; }
+  th { background: #f5f5f5; font-weight: 600; }
+  blockquote { border-left: 3px solid #ccc; margin: 1em 0; padding: 0.5em 1em; color: #555; }
+  code { background: #f4f4f4; padding: 2px 5px; border-radius: 3px; font-size: 0.9em; }
+  pre { background: #f4f4f4; padding: 12px; border-radius: 6px; overflow-x: auto; }
+  pre code { background: none; padding: 0; }
+  hr { border: none; border-top: 1px solid #ddd; margin: 2em 0; }
+  strong { font-weight: 600; }
+</style>
+</head><body>${bodyHtml}</body></html>`;
+}
 export function createDocumentToPdfTool(options) {
     const cfg = options?.config;
     const agentId = resolveSessionAgentId({
@@ -25,54 +62,55 @@ export function createDocumentToPdfTool(options) {
     return {
         label: "Document to PDF",
         name: "document_to_pdf",
-        description: "Convert an HTML file to PDF using a headless browser. " +
+        description: "Convert an HTML or Markdown file to PDF using a headless browser. " +
+            "Markdown files (.md) are automatically rendered to styled HTML before conversion. " +
             "The PDF is written to the same directory as the source file with a .pdf extension. " +
             "Returns the absolute path to the generated PDF.",
         parameters: DocumentToPdfSchema,
         execute: async (_toolCallId, params) => {
             const inputPath = readStringParam(params, "path", { required: true });
             // ── Resolve the path ──────────────────────────────────────────────
-            let htmlPath;
+            let sourcePath;
             try {
                 if (memoryDir && inputPath.startsWith("memory/")) {
                     const relativePath = inputPath.slice("memory/".length);
-                    htmlPath = path.join(memoryDir, relativePath);
+                    sourcePath = path.join(memoryDir, relativePath);
                 }
                 else if (memoryDir && !path.isAbsolute(inputPath) && !inputPath.startsWith(".")) {
                     // Check if it exists in memory root
                     const candidatePath = path.join(memoryDir, inputPath);
                     try {
                         await fs.stat(candidatePath);
-                        htmlPath = candidatePath;
+                        sourcePath = candidatePath;
                     }
                     catch {
-                        htmlPath = inputPath;
+                        sourcePath = inputPath;
                     }
                 }
                 else {
-                    htmlPath = inputPath;
+                    sourcePath = inputPath;
                 }
-                if (!path.isAbsolute(htmlPath)) {
-                    htmlPath = path.resolve(htmlPath);
+                if (!path.isAbsolute(sourcePath)) {
+                    sourcePath = path.resolve(sourcePath);
                 }
                 // Apply sandbox constraints if configured
                 const sandboxRoot = options?.sandboxRoot?.trim();
                 if (sandboxRoot) {
                     const sandboxed = await assertSandboxPath({
-                        filePath: htmlPath,
+                        filePath: sourcePath,
                         cwd: sandboxRoot,
                         root: sandboxRoot,
                     });
-                    htmlPath = sandboxed.resolved;
+                    sourcePath = sandboxed.resolved;
                 }
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 return jsonResult({ ok: false, error: `Path not accessible: ${message}` });
             }
-            // ── Verify the HTML file exists ───────────────────────────────────
+            // ── Verify the source file exists ─────────────────────────────────
             try {
-                await fs.stat(htmlPath);
+                await fs.stat(sourcePath);
             }
             catch (err) {
                 const anyErr = err;
@@ -83,8 +121,31 @@ export function createDocumentToPdfTool(options) {
                 return jsonResult({ ok: false, error: `Cannot access file: ${message}` });
             }
             // ── Determine output path ─────────────────────────────────────────
-            const parsed = path.parse(htmlPath);
+            const parsed = path.parse(sourcePath);
             const pdfPath = path.join(parsed.dir, `${parsed.name}.pdf`);
+            const isMarkdown = MARKDOWN_EXTENSIONS.has(parsed.ext.toLowerCase());
+            // ── If markdown, render to a temp HTML file ───────────────────────
+            let htmlPath;
+            let tempHtmlPath;
+            if (isMarkdown) {
+                try {
+                    const mdSource = await fs.readFile(sourcePath, "utf-8");
+                    const MarkdownIt = (await import("markdown-it")).default;
+                    const md = new MarkdownIt({ html: true, linkify: true, typographer: true });
+                    const bodyHtml = md.render(mdSource);
+                    const fullHtml = wrapMarkdownHtml(bodyHtml);
+                    tempHtmlPath = path.join(os.tmpdir(), `taskmaster-pdf-${Date.now()}-${parsed.name}.html`);
+                    await fs.writeFile(tempHtmlPath, fullHtml, "utf-8");
+                    htmlPath = tempHtmlPath;
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    return jsonResult({ ok: false, error: `Markdown conversion failed: ${message}` });
+                }
+            }
+            else {
+                htmlPath = sourcePath;
+            }
             // ── Find Chrome executable ────────────────────────────────────────
             const browserConfig = resolveBrowserConfig(cfg?.browser);
             const exe = resolveBrowserExecutableForPlatform(browserConfig, process.platform);
@@ -130,6 +191,10 @@ export function createDocumentToPdfTool(options) {
                         // Ignore close errors
                     }
                 }
+                // Clean up temp HTML file if we created one
+                if (tempHtmlPath) {
+                    fs.unlink(tempHtmlPath).catch(() => { });
+                }
             }
         },
     };

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.44.5",
-  "commit": "414cf5a6f0475e90da9e44c9a38af23eb2662ffa",
-  "builtAt": "2026-03-25T13:57:46.756Z"
+  "version": "1.44.7",
+  "commit": "842965d43dfa6cdab9cb31e489c9a295cf755dfb",
+  "builtAt": "2026-03-28T11:06:01.275Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.44.5",
+  "version": "1.44.7",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"