@rubytech/taskmaster 1.5.2 → 1.6.0

package/dist/agents/skills/workspace.js

@@ -243,10 +243,26 @@ export async function syncSkillsToWorkspace(params) {
         }
     });
 }
+/**
+ * Bundled skills that must be overwritten in existing workspaces.
+ *
+ * Normally, bundled skill sync preserves existing workspace skills so user
+ * modifications are not lost.  When a bundled skill changes in a way that
+ * affects functionality (e.g. referencing a new tool), add its directory
+ * name here so it is force-copied on the next gateway restart.
+ *
+ * Remove entries after they have shipped in at least one release.
+ */
+const FORCE_RESYNC_SKILLS = new Set([
+    // v1.6: skill-builder updated to use skill_draft_save tool instead of write
+    "skill-builder",
+]);
 /**
  * Copy bundled skills into a workspace's `skills/` directory.
  * Only copies skills whose target directory does not already exist,
- * preserving any user modifications to existing workspace skills.
+ * preserving any user modifications to existing workspace skills —
+ * unless the skill is in {@link FORCE_RESYNC_SKILLS}, in which case
+ * the workspace copy is replaced with the bundled version.
  */
 export async function syncBundledSkillsToWorkspace(workspaceDir, opts) {
     const bundledDir = opts?.bundledSkillsDir ?? resolveBundledSkillsDir();
@@ -266,9 +282,14 @@ export async function syncBundledSkillsToWorkspace(workspaceDir, opts) {
     const synced = [];
     for (const name of entries) {
         const dest = path.join(targetSkillsDir, name);
-        if (fs.existsSync(dest))
+        const exists = fs.existsSync(dest);
+        if (exists && !FORCE_RESYNC_SKILLS.has(name))
             continue;
         try {
+            if (exists) {
+                await fsp.rm(dest, { recursive: true, force: true });
+                skillsLogger.info(`force-resyncing bundled skill "${name}" (updated in this version)`);
+            }
             await fsp.cp(path.join(bundledDir, name), dest, { recursive: true });
             synced.push(name);
         }

package/dist/agents/taskmaster-tools.js

@@ -29,6 +29,7 @@ import { createFileListTool } from "./tools/file-list-tool.js";
 import { createContactLookupTool } from "./tools/contact-lookup-tool.js";
 import { createContactUpdateTool } from "./tools/contact-update-tool.js";
 import { createRelayMessageTool } from "./tools/relay-message-tool.js";
+import { createSkillDraftSaveTool } from "./tools/skill-draft-save-tool.js";
 import { createSkillReadTool } from "./tools/skill-read-tool.js";
 import { createApiKeysTool } from "./tools/apikeys-tool.js";
 import { createImageGenerateTool } from "./tools/image-generate-tool.js";
@@ -162,6 +163,13 @@ export function createTaskmasterTools(options) {
     if (skillDirs.length > 0) {
         tools.push(createSkillReadTool({ allowedSkillDirs: skillDirs }));
     }
+    // Add skill draft save tool
+    const skillDraftSaveTool = createSkillDraftSaveTool({
+        config: options?.config,
+        agentSessionKey: options?.agentSessionKey,
+    });
+    if (skillDraftSaveTool)
+        tools.push(skillDraftSaveTool);
     // Add memory tools (conditionally based on config)
     const memoryToolOptions = {
         config: options?.config,

package/dist/agents/tool-policy.js

@@ -33,6 +33,8 @@ export const TOOL_GROUPS = {
     "group:messaging": ["message"],
     // Nodes + device tools
     "group:nodes": ["nodes"],
+    // Skill management
+    "group:skills": ["skill_read", "skill_draft_save"],
     // Contact record management
     "group:contacts": ["contact_create", "contact_delete", "contact_lookup", "contact_update"],
     // Admin management tools
@@ -68,6 +70,7 @@ export const TOOL_GROUPS = {
         "api_keys",
         "file_delete",
         "file_list",
+        "skill_draft_save",
     ],
 };
 // Tools that are never granted by profiles — must be explicitly added to the
@@ -110,6 +113,7 @@ const TOOL_PROFILES = {
             "tts",
             "license_generate",
             "group:contacts",
+            "group:skills",
             "relay_message",
             "memory_save_media",
             "image_generate",

package/dist/agents/tools/skill-draft-save-tool.js

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Type } from "@sinclair/typebox";
+import { resolveAgentWorkspaceRoot, resolveSessionAgentId } from "../agent-scope.js";
+import { jsonResult, readStringParam } from "./common.js";
+const ReferenceSchema = Type.Object({
+    name: Type.String({ description: "Filename for the reference (e.g. escalation.md)" }),
+    content: Type.String({ description: "Markdown content of the reference file" }),
+});
+const SkillDraftSaveSchema = Type.Object({
+    name: Type.String({
+        description: "Skill name — lowercase, hyphen-separated (e.g. inventory-management). " +
+            "Used as the directory name under .skill-drafts/.",
+    }),
+    skill_content: Type.String({
+        description: "Full content of SKILL.md including YAML frontmatter (name, description) " +
+            "and all behaviour rules.",
+    }),
+    references: Type.Optional(Type.Array(ReferenceSchema, {
+        description: "Optional reference files to save under references/. " +
+            "Each entry needs a name (filename) and content (markdown).",
+    })),
+});
+/**
+ * Create a tool that saves skill drafts to the workspace `.skill-drafts/` directory.
+ *
+ * This is the directory the Control Panel scans when showing available drafts
+ * (via the `skills.drafts` gateway method). Agents that lack `group:fs` can
+ * still create skill drafts through this purpose-built tool.
+ */
+export function createSkillDraftSaveTool(options) {
+    const cfg = options?.config;
+    if (!cfg)
+        return null;
+    const agentId = resolveSessionAgentId({
+        sessionKey: options?.agentSessionKey,
+        config: cfg,
+    });
+    return {
+        label: "Skill Draft Save",
+        name: "skill_draft_save",
+        description: "Save a skill draft so the business owner can review and install it from the Control Panel. " +
+            "Writes SKILL.md and optional reference files to the .skill-drafts/ directory. " +
+            "The draft will appear under Skills → Add Skill in the Control Panel.",
+        parameters: SkillDraftSaveSchema,
+        execute: async (_toolCallId, params) => {
+            const p = params;
+            const name = readStringParam(p, "name", { required: true });
+            const skillContent = readStringParam(p, "skill_content", { required: true });
+            // Validate skill name: lowercase, hyphens, no path traversal
+            if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name)) {
+                return jsonResult({
+                    success: false,
+                    error: "Invalid skill name. Use lowercase letters, numbers, and hyphens " +
+                        "(e.g. inventory-management). Must start and end with a letter or number.",
+                });
+            }
+            const workspaceRoot = resolveAgentWorkspaceRoot(cfg, agentId);
+            const draftDir = path.join(workspaceRoot, ".skill-drafts", name);
+            try {
+                // Create the draft directory
+                fs.mkdirSync(draftDir, { recursive: true });
+                // Write SKILL.md
+                const skillPath = path.join(draftDir, "SKILL.md");
+                fs.writeFileSync(skillPath, skillContent, "utf-8");
+                // Write reference files if provided
+                const refs = p.references;
+                const refsSaved = [];
+                if (Array.isArray(refs) && refs.length > 0) {
+                    const refsDir = path.join(draftDir, "references");
+                    fs.mkdirSync(refsDir, { recursive: true });
+                    for (const ref of refs) {
+                        if (typeof ref !== "object" ||
+                            ref === null ||
+                            typeof ref.name !== "string" ||
+                            typeof ref.content !== "string") {
+                            continue;
+                        }
+                        const refName = ref.name.trim();
+                        const refContent = ref.content;
+                        // Sanitise reference filename — no path traversal
+                        if (!refName || refName.includes("/") || refName.includes("\\") || refName === "..") {
+                            continue;
+                        }
+                        const refPath = path.join(refsDir, refName);
+                        fs.writeFileSync(refPath, refContent, "utf-8");
+                        refsSaved.push(refName);
+                    }
+                }
+                return jsonResult({
+                    success: true,
+                    name,
+                    path: draftDir,
+                    skillFile: "SKILL.md",
+                    references: refsSaved,
+                    message: `Skill draft "${name}" saved. ` +
+                        "The business owner can install it from the Control Panel → Skills → Add Skill.",
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return jsonResult({
+                    success: false,
+                    name,
+                    error: `Failed to save skill draft: ${message}`,
+                });
+            }
+        },
+    };
+}

package/dist/auto-reply/tokens.js

@@ -3,10 +3,33 @@ export const SILENT_REPLY_TOKEN = "NO_REPLY";
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+/**
+ * Maximum text length for prefix/suffix silent-reply matching.
+ * Short texts (under this limit) may be model artifacts like
+ * "NO_REPLY -- I have nothing to add" and are safely suppressed.
+ * Longer texts contain substantive content that must not be silently
+ * dropped just because the token appears at an edge.
+ */
+const MAX_SILENT_ARTIFACT_LENGTH = 200;
 export function isSilentReplyText(text, token = SILENT_REPLY_TOKEN) {
     if (!text)
         return false;
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
     const escaped = escapeRegExp(token);
+    // Exact match: the entire text is just the token (with optional
+    // surrounding whitespace and trailing punctuation). Always silent.
+    if (new RegExp(`^\\s*${escaped}\\W*$`).test(trimmed))
+        return true;
+    // Long text contains real content — never suppress it, even if the
+    // token appears at the edges. This prevents silently dropping
+    // substantive agent output (e.g. a multi-paragraph report ending
+    // with NO_REPLY).
+    if (trimmed.length > MAX_SILENT_ARTIFACT_LENGTH)
+        return false;
+    // Short text: allow prefix/suffix matching to catch model artifacts
+    // like "NO_REPLY -- I have nothing to add" or "interject.NO_REPLY".
     const prefix = new RegExp(`^\\s*${escaped}(?=$|\\W)`);
     if (prefix.test(text))
         return true;

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.2",
-  "commit": "85b33f4472e64618e06f4bd86b77b4da5647767c",
-  "builtAt": "2026-02-25T18:17:01.086Z"
+  "version": "1.6.0",
+  "commit": "20208368bac412787fe3a690f1909f257ab3ac75",
+  "builtAt": "2026-02-26T11:39:19.541Z"
 }

package/dist/cli/provision-seed.js

@@ -144,6 +144,7 @@ export function buildDefaultAgentList(workspaceRoot) {
                 "relay_message",
                 "browser",
                 "skill_read",
+                "skill_draft_save",
             ],
             deny: ["exec", "process", "group:runtime", "canvas"],
         },

package/dist/config/defaults.js

@@ -325,6 +325,38 @@ export function applyContextPruningDefaults(cfg) {
         },
     };
 }
+/**
+ * Default model fallback chain — used when the primary model fails and no
+ * explicit fallbacks are configured.  Candidates that lack an API key are
+ * silently skipped at runtime, so listing them here is always safe.
+ */
+const DEFAULT_MODEL_FALLBACKS = [
+    "google/gemini-3-pro-preview",
+    "openai/gpt-5.2",
+];
+export function applyModelFallbackDefaults(cfg) {
+    const model = cfg.agents?.defaults?.model;
+    // Already has explicit fallbacks — respect the user's choice.
+    // An empty array is treated as "no fallbacks configured" (migration artifact),
+    // not as "user deliberately disabled fallbacks".
+    if (model && Array.isArray(model.fallbacks) && model.fallbacks.length > 0)
+        return cfg;
+    const defaults = cfg.agents?.defaults ?? {};
+    const existing = (model && typeof model === "object" ? model : {});
+    return {
+        ...cfg,
+        agents: {
+            ...cfg.agents,
+            defaults: {
+                ...defaults,
+                model: {
+                    ...existing,
+                    fallbacks: [...DEFAULT_MODEL_FALLBACKS],
+                },
+            },
+        },
+    };
+}
 export function applyCompactionDefaults(cfg) {
     const defaults = cfg.agents?.defaults;
     if (!defaults)

package/dist/config/io.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import JSON5 from "json5";
 import { loadShellEnvFallback, resolveShellEnvFallbackTimeoutMs, shouldDeferShellEnvFallback, shouldEnableShellEnvFallback, } from "../infra/shell-env.js";
 import { DuplicateAgentDirError, findDuplicateAgentDirs } from "./agent-dirs.js";
-import { applyApiKeys, applyCompactionDefaults, applyContextPruningDefaults, applyAgentDefaults, applyLoggingDefaults, applyMessageDefaults, applyModelDefaults, applySessionDefaults, applyTalkApiKey, } from "./defaults.js";
+import { applyApiKeys, applyCompactionDefaults, applyContextPruningDefaults, applyAgentDefaults, applyLoggingDefaults, applyMessageDefaults, applyModelDefaults, applyModelFallbackDefaults, applySessionDefaults, applyTalkApiKey, } from "./defaults.js";
 import { VERSION } from "../version.js";
 import { MissingEnvVarError, resolveConfigEnvVars } from "./env-substitution.js";
 import { collectConfigEnvVars } from "./env-vars.js";
@@ -203,7 +203,7 @@ export function createConfigIO(overrides = {}) {
                 deps.logger.warn(`Config warnings:\\n${details}`);
             }
             warnIfConfigFromFuture(validated.config, deps.logger);
-            const cfg = applyApiKeys(applyModelDefaults(applyCompactionDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyLoggingDefaults(applyMessageDefaults(validated.config))))))));
+            const cfg = applyApiKeys(applyModelFallbackDefaults(applyModelDefaults(applyCompactionDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyLoggingDefaults(applyMessageDefaults(validated.config)))))))));
             normalizeConfigPaths(cfg);
             const duplicates = findDuplicateAgentDirs(cfg, {
                 env: deps.env,
@@ -242,7 +242,7 @@ export function createConfigIO(overrides = {}) {
         const exists = deps.fs.existsSync(configPath);
         if (!exists) {
             const hash = hashConfigRaw(null);
-            const config = applyApiKeys(applyTalkApiKey(applyModelDefaults(applyCompactionDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyMessageDefaults({}))))))));
+            const config = applyApiKeys(applyTalkApiKey(applyModelFallbackDefaults(applyModelDefaults(applyCompactionDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyMessageDefaults({})))))))));
             const legacyIssues = [];
             return {
                 path: configPath,
@@ -350,7 +350,7 @@ export function createConfigIO(overrides = {}) {
                 raw,
                 parsed: parsedRes.parsed,
                 valid: true,
-                config: normalizeConfigPaths(applyApiKeys(applyTalkApiKey(applyModelDefaults(applyAgentDefaults(applySessionDefaults(applyLoggingDefaults(applyMessageDefaults(validated.config)))))))),
+                config: normalizeConfigPaths(applyApiKeys(applyTalkApiKey(applyModelFallbackDefaults(applyModelDefaults(applyAgentDefaults(applySessionDefaults(applyLoggingDefaults(applyMessageDefaults(validated.config))))))))),
                 hash,
                 issues: [],
                 warnings: validated.warnings,

package/dist/config/legacy.migrations.part-3.js

@@ -216,6 +216,57 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_3 = [
             }
         },
     },
+    {
+        id: "admin-agent-tools-add-skill_draft_save",
+        describe: "Add skill_draft_save to admin agent tools.allow",
+        apply: (raw, changes) => {
+            const agents = getRecord(raw.agents);
+            const list = getAgentsList(agents);
+            for (const entry of list) {
+                if (!isRecord(entry))
+                    continue;
+                const id = typeof entry.id === "string" ? entry.id.trim() : "";
+                if (!id)
+                    continue;
+                const isAdmin = id === "admin" || id.endsWith("-admin");
+                if (!isAdmin)
+                    continue;
+                const tools = getRecord(entry.tools);
+                if (!tools)
+                    continue;
+                if (!Array.isArray(tools.allow))
+                    continue;
+                const allow = tools.allow;
+                if (!allow.includes("skill_draft_save") && !allow.includes("group:skills")) {
+                    allow.push("skill_draft_save");
+                    changes.push(`Added skill_draft_save to agent "${id}" tools.allow.`);
+                }
+            }
+        },
+    },
+    {
+        id: "agents.defaults.model.fallbacks-defaults",
+        describe: "Set default model fallback chain (Google Gemini Pro, OpenAI GPT-5.2)",
+        apply: (raw, changes) => {
+            const agents = getRecord(raw.agents);
+            const defaults = getRecord(agents?.defaults);
+            if (!defaults)
+                return;
+            const model = getRecord(defaults.model);
+            if (model) {
+                // Already has non-empty fallbacks — respect the user's choice.
+                if (Array.isArray(model.fallbacks) && model.fallbacks.length > 0)
+                    return;
+                model.fallbacks = ["google/gemini-3-pro-preview", "openai/gpt-5.2"];
+            }
+            else {
+                defaults.model = {
+                    fallbacks: ["google/gemini-3-pro-preview", "openai/gpt-5.2"],
+                };
+            }
+            changes.push("Set default model fallbacks: google/gemini-3-pro-preview, openai/gpt-5.2.");
+        },
+    },
     {
         id: "agents-tools-remove-sessions_send",
         describe: "Remove sessions_send from agent tools.allow (tool removed for security)",

package/dist/config/validation.js

@@ -5,7 +5,7 @@ import { normalizePluginsConfig, resolveEnableState, resolveMemorySlotDecision,
 import { loadPluginManifestRegistry } from "../plugins/manifest-registry.js";
 import { validateJsonSchemaValue } from "../plugins/schema-validator.js";
 import { findDuplicateAgentDirs, formatDuplicateAgentDirError } from "./agent-dirs.js";
-import { applyAgentDefaults, applyModelDefaults, applySessionDefaults } from "./defaults.js";
+import { applyAgentDefaults, applyModelDefaults, applyModelFallbackDefaults, applySessionDefaults, } from "./defaults.js";
 import { findLegacyConfigIssues } from "./legacy.js";
 import { TaskmasterSchema } from "./zod-schema.js";
 const AVATAR_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
@@ -102,7 +102,7 @@ export function validateConfigObject(raw) {
     }
     return {
         ok: true,
-        config: applyModelDefaults(applyAgentDefaults(applySessionDefaults(validated.data))),
+        config: applyModelFallbackDefaults(applyModelDefaults(applyAgentDefaults(applySessionDefaults(validated.data)))),
     };
 }
 function isRecord(value) {