@rubytech/taskmaster 1.20.2 → 1.21.1

package/dist/agents/skills/agent-scope.js

@@ -0,0 +1,14 @@
+import { PRELOADED_SKILL_AGENTS } from "./types.js";
+const DEFAULT_AGENTS = ["admin", "public"];
+/**
+ * Resolve which agents can access a skill.
+ * Preloaded skills use the hardcoded map (not overridable).
+ * User/licensed skills use config, defaulting to all agents.
+ */
+export function resolveSkillAgents(skillName, isPreloaded, config) {
+    if (isPreloaded) {
+        return PRELOADED_SKILL_AGENTS[skillName] ?? DEFAULT_AGENTS;
+    }
+    const entry = config?.skills?.entries?.[skillName];
+    return entry?.agents ?? DEFAULT_AGENTS;
+}

package/dist/agents/tools/skill-pack-install-tool.js

@@ -1,5 +1,5 @@
-import fsp from "node:fs/promises";
 import path from "node:path";
+import fsp from "node:fs/promises";
 import { Type } from "@sinclair/typebox";
 import { jsonResult, readStringParam } from "./common.js";
 import { verifySkillPack, hasMarker, readMarker, writeMarker, } from "../../license/skill-pack.js";
@@ -16,6 +16,7 @@ export function createSkillPackInstallTool(opts) {
         name: "skill_pack_install",
         description: "Install a signed skill pack (.skillpack.json) onto this device. " +
             "Verifies the cryptographic signature and device binding before installing. " +
+            "Supports single skills and bundles (multiple skills in one pack). " +
             "Use this when a customer forwards a skill pack file to you.",
         parameters: SkillPackInstallSchema,
         execute: async (_toolCallId, args) => {
@@ -43,48 +44,65 @@ export function createSkillPackInstallTool(opts) {
                 throw new Error("This skill pack is licensed for a different device. " +
                     "It cannot be installed on this device.");
             }
-            // Check for existing marketplace skill
-            const skillDir = path.join(opts.workspaceDir, "skills", payload.pack.id);
-            if (hasMarker(skillDir)) {
-                const existing = await readMarker(skillDir);
-                if (existing && existing.version === payload.pack.version) {
-                    return jsonResult({
-                        ok: true,
-                        alreadyInstalled: true,
-                        packId: payload.pack.id,
-                        version: payload.pack.version,
-                        message: `${payload.pack.name} v${payload.pack.version} is already installed.`,
-                    });
-                }
+            // Check if all skills in this pack version are already installed
+            const allAlreadyInstalled = await allSkillsInstalled(opts.workspaceDir, payload.content.skills.map((s) => s.id), payload.pack.id, payload.pack.version);
+            if (allAlreadyInstalled) {
+                return jsonResult({
+                    ok: true,
+                    alreadyInstalled: true,
+                    packId: payload.pack.id,
+                    version: payload.pack.version,
+                    message: `${payload.pack.name} v${payload.pack.version} is already installed.`,
+                });
+            }
+            // Install each skill via skills.create gateway RPC
+            const installed = [];
+            for (const entry of payload.content.skills) {
+                const references = entry.references.map((r) => ({
+                    name: r.name,
+                    content: r.content,
+                }));
+                await callGatewayTool("skills.create", {}, {
+                    name: entry.id,
+                    skillContent: entry.skill,
+                    ...(references.length > 0 ? { references } : {}),
+                });
+                // Write marker file for each skill
+                const skillDir = path.join(opts.workspaceDir, "skills", entry.id);
+                const marker = {
+                    packId: payload.pack.id,
+                    version: payload.pack.version,
+                    author: payload.pack.author,
+                    installedAt: new Date().toISOString(),
+                    deviceId: payload.device.did,
+                    customerId: payload.device.cid,
+                };
+                await writeMarker(skillDir, marker);
+                installed.push(entry.id);
             }
-            // Install via skills.create gateway RPC
-            const references = payload.content.references.map((r) => ({
-                name: r.name,
-                content: r.content,
-            }));
-            await callGatewayTool("skills.create", {}, {
-                name: payload.pack.id,
-                skillContent: payload.content.skill,
-                ...(references.length > 0 ? { references } : {}),
-            });
-            // Write marker file
-            const marker = {
-                packId: payload.pack.id,
-                version: payload.pack.version,
-                author: payload.pack.author,
-                installedAt: new Date().toISOString(),
-                deviceId: payload.device.did,
-                customerId: payload.device.cid,
-            };
-            await writeMarker(skillDir, marker);
             return jsonResult({
                 ok: true,
                 packId: payload.pack.id,
                 version: payload.pack.version,
                 name: payload.pack.name,
-                message: `Successfully installed ${payload.pack.name} v${payload.pack.version}. ` +
-                    `This skill is now available for use.`,
+                skillCount: installed.length,
+                skills: installed,
+                message: `Successfully installed ${payload.pack.name} v${payload.pack.version} ` +
+                    `with ${installed.length} skill(s): ${installed.join(", ")}. ` +
+                    `${installed.length === 1 ? "This skill is" : "These skills are"} now available for use.`,
             });
         },
     };
 }
+/** Check whether all skills from a pack are already installed at the given version. */
+async function allSkillsInstalled(workspaceDir, skillIds, packId, version) {
+    for (const id of skillIds) {
+        const skillDir = path.join(workspaceDir, "skills", id);
+        if (!hasMarker(skillDir))
+            return false;
+        const existing = await readMarker(skillDir);
+        if (!existing || existing.packId !== packId || existing.version !== version)
+            return false;
+    }
+    return true;
+}

package/dist/agents/tools/skill-pack-sign-tool.js

@@ -2,79 +2,178 @@ import fsp from "node:fs/promises";
 import path from "node:path";
 import { Type } from "@sinclair/typebox";
 import { jsonResult, readStringParam } from "./common.js";
-import { signSkillPack } from "../../license/skill-pack.js";
+import { signSkillPack, } from "../../license/skill-pack.js";
 import { parseFrontmatter } from "../skills/frontmatter.js";
 const SkillPackSignSchema = Type.Object({
-    packId: Type.String({
-        description: "Skill pack ID — must match a directory name in the skill-packs/ folder of this workspace.",
-    }),
-    deviceId: Type.String({
+    packId: Type.Optional(Type.String({
+        description: "Skill pack ID — must match a directory name in the skill-packs/ folder. " +
+            "Omit to list available packs.",
+    })),
+    deviceId: Type.Optional(Type.String({
         description: "Target device ID (tm_dev_...) from the customer's contact record.",
-    }),
-    customerId: Type.String({
+    })),
+    customerId: Type.Optional(Type.String({
         description: "Customer identifier from the contact record.",
-    }),
+    })),
     version: Type.Optional(Type.String({ description: 'Skill pack version (e.g. "1.0.0"). Defaults to "1.0.0".' })),
 });
+/** Read a single skill entry from a directory containing SKILL.md and optional references/. */
+async function readSkillEntry(dir, id) {
+    const skillPath = path.join(dir, "SKILL.md");
+    const skillContent = await fsp.readFile(skillPath, "utf-8");
+    const references = [];
+    try {
+        const refsDir = path.join(dir, "references");
+        const refFiles = await fsp.readdir(refsDir);
+        for (const file of refFiles.sort()) {
+            if (file.startsWith("."))
+                continue;
+            const content = await fsp.readFile(path.join(refsDir, file), "utf-8");
+            references.push({ name: file, content });
+        }
+    }
+    catch {
+        // No references directory — that's fine
+    }
+    return { id, skill: skillContent, references };
+}
+/** Check whether a directory is a bundle (subdirectories with SKILL.md) or a single skill. */
+async function detectPackLayout(packDir) {
+    try {
+        await fsp.access(path.join(packDir, "SKILL.md"));
+        return "single";
+    }
+    catch {
+        // No SKILL.md at top level — check for subdirectories
+    }
+    const entries = await fsp.readdir(packDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith("."))
+            continue;
+        try {
+            await fsp.access(path.join(packDir, entry.name, "SKILL.md"));
+            return "bundle";
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`Pack "${path.basename(packDir)}" has no SKILL.md at root and no subdirectories with SKILL.md.`);
+}
 export function createSkillPackSignTool(opts) {
     return {
         label: "Skill Pack Sign",
         name: "skill_pack_sign",
-        description: "Sign a skill pack for a specific customer device. Reads the skill template from " +
-            "skill-packs/<packId>/, signs it with the customer's device ID embedded, and writes " +
-            "the signed .skillpack.json file. Send the resulting file to the customer.",
+        description: "Sign a skill pack for a specific customer device. Supports single skills " +
+            "(skill-packs/<id>/SKILL.md) and bundles (skill-packs/<id>/<skill>/SKILL.md). " +
+            "Call without packId to list available packs.",
         parameters: SkillPackSignSchema,
         execute: async (_toolCallId, args) => {
             const params = args;
-            const packId = readStringParam(params, "packId", { required: true });
-            const deviceId = readStringParam(params, "deviceId", { required: true });
-            const customerId = readStringParam(params, "customerId", { required: true });
+            const packId = readStringParam(params, "packId");
+            const deviceId = readStringParam(params, "deviceId");
+            const customerId = readStringParam(params, "customerId");
             const version = readStringParam(params, "version") ?? "1.0.0";
+            // ── List mode: no packId → return available packs ──
+            const packsDir = path.join(opts.workspaceDir, "skill-packs");
+            if (!packId) {
+                const packs = [];
+                try {
+                    const entries = await fsp.readdir(packsDir, { withFileTypes: true });
+                    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+                        if (!entry.isDirectory() || entry.name === "signed" || entry.name.startsWith("."))
+                            continue;
+                        const dir = path.join(packsDir, entry.name);
+                        try {
+                            const layout = await detectPackLayout(dir);
+                            if (layout === "bundle") {
+                                const subs = await fsp.readdir(dir, { withFileTypes: true });
+                                const skillIds = subs
+                                    .filter((s) => s.isDirectory() && !s.name.startsWith("."))
+                                    .map((s) => s.name)
+                                    .sort();
+                                packs.push({ id: entry.name, type: "bundle", skills: skillIds });
+                            }
+                            else {
+                                packs.push({ id: entry.name, type: "single" });
+                            }
+                        }
+                        catch {
+                            // Skip invalid pack directories
+                        }
+                    }
+                }
+                catch {
+                    // directory doesn't exist
+                }
+                return jsonResult({
+                    ok: true,
+                    packsDir,
+                    packs,
+                    message: packs.length
+                        ? `Found ${packs.length} pack(s)`
+                        : `No skill packs found. Create pack templates in ${packsDir}/<packId>/SKILL.md`,
+                });
+            }
+            if (!deviceId || !customerId) {
+                throw new Error("deviceId and customerId are required when signing a pack.");
+            }
             if (!deviceId.startsWith("tm_dev_")) {
                 throw new Error(`Invalid device ID format: "${deviceId}". Device IDs start with "tm_dev_".`);
             }
-            // Read skill template
-            const packDir = path.join(opts.workspaceDir, "skill-packs", packId);
-            const skillPath = path.join(packDir, "SKILL.md");
-            let skillContent;
+            const packDir = path.join(packsDir, packId);
+            let layout;
             try {
-                skillContent = await fsp.readFile(skillPath, "utf-8");
+                layout = await detectPackLayout(packDir);
             }
             catch {
-                throw new Error(`Skill pack template not found: ${packId}. Expected SKILL.md at ${skillPath}`);
+                throw new Error(`Skill pack not found: ${packId}. Expected at ${packDir}`);
             }
-            // Read references
-            const refsDir = path.join(packDir, "references");
-            const references = [];
-            try {
-                const refFiles = await fsp.readdir(refsDir);
-                for (const file of refFiles.sort()) {
-                    const content = await fsp.readFile(path.join(refsDir, file), "utf-8");
-                    references.push({ name: file, content });
+            // ── Read skill entries ──
+            const skillEntries = [];
+            if (layout === "single") {
+                skillEntries.push(await readSkillEntry(packDir, packId));
+            }
+            else {
+                const subs = await fsp.readdir(packDir, { withFileTypes: true });
+                for (const sub of subs.sort((a, b) => a.name.localeCompare(b.name))) {
+                    if (!sub.isDirectory() || sub.name.startsWith("."))
+                        continue;
+                    const subDir = path.join(packDir, sub.name);
+                    try {
+                        await fsp.access(path.join(subDir, "SKILL.md"));
+                        skillEntries.push(await readSkillEntry(subDir, sub.name));
+                    }
+                    catch {
+                        // subdirectory without SKILL.md — skip
+                    }
                 }
             }
-            catch {
-                // No references directory — that's fine
+            if (skillEntries.length === 0) {
+                throw new Error(`No skills found in pack "${packId}".`);
             }
-            // Parse frontmatter for metadata
-            const frontmatter = parseFrontmatter(skillContent);
-            const name = frontmatter?.name ?? packId;
-            const description = frontmatter?.description ?? "";
+            // Parse frontmatter from first skill for pack-level metadata
+            const firstFm = parseFrontmatter(skillEntries[0].skill);
+            const name = layout === "single" ? (firstFm?.name ?? packId) : packId;
+            const description = layout === "single"
+                ? (firstFm?.description ?? "")
+                : `Bundle of ${skillEntries.length} skills`;
             // Build and sign payload
             const payload = {
                 format: "skillpack-v1",
                 pack: { id: packId, version, name, description, author: "Rubytech LLC" },
                 device: { did: deviceId, cid: customerId },
-                content: { skill: skillContent, references },
+                content: { skills: skillEntries },
                 signedAt: new Date().toISOString(),
             };
             const signed = signSkillPack(payload);
             // Write signed file
             const shortDid = deviceId.slice(0, 20);
-            const signedDir = path.join(opts.workspaceDir, "skill-packs", "signed");
+            const signedDir = path.join(packsDir, "signed");
             await fsp.mkdir(signedDir, { recursive: true });
             const outputPath = path.join(signedDir, `${packId}-${shortDid}.skillpack.json`);
             await fsp.writeFile(outputPath, JSON.stringify(signed, null, 2), "utf-8");
+            const skillNames = skillEntries.map((s) => s.id).join(", ");
             return jsonResult({
                 ok: true,
                 filePath: outputPath,
@@ -82,7 +181,10 @@ export function createSkillPackSignTool(opts) {
                 version,
                 deviceId,
                 customerId,
-                message: `Signed skill pack "${name}" v${version} for device ${deviceId}. ` +
+                skillCount: skillEntries.length,
+                skills: skillEntries.map((s) => s.id),
+                message: `Signed skill pack "${name}" v${version} with ${skillEntries.length} skill(s) ` +
+                    `(${skillNames}) for device ${deviceId}. ` +
                     `File saved to ${outputPath}. Send this file to the customer with instructions ` +
                     `to forward it to their admin agent and ask it to install.`,
             });

package/dist/agents/tools/system-status-tool.js

@@ -32,7 +32,7 @@ export function createSystemStatusTool() {
         description: "Check the status of the Taskmaster system. " +
             '"overview" returns a combined snapshot (health, auth, license, channels, version, update availability). ' +
             "Use specific actions for detail: " +
-            '"health" (gateway health), "auth" (Claude API auth), "license" (license info), ' +
+            '"health" (gateway health), "auth" (Claude API auth), "license" (license info + device ID), ' +
             '"channels" (WhatsApp/iMessage connections), "models" (available LLM models), ' +
             '"update" (software version and update availability), ' +
             '"tailscale" (Tailscale connection + public URL), "network" (hostname + port).',

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.20.2",
-  "commit": "d4b6c29dd73647523ebc7a8e8b7ab3c1e790dd19",
-  "builtAt": "2026-03-06T19:20:00.353Z"
+  "version": "1.21.1",
+  "commit": "a9d05c02ef2f2cf9eb7cfb55ee76266fea595687",
+  "builtAt": "2026-03-06T20:52:13.028Z"
 }

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

@@ -294,3 +294,69 @@ export function reconcileSkillReadTool(params) {
     }
     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.
+ */
+const INDIVIDUAL_SKILL_TOOLS = ["skill_read", "skill_draft_save", "skill_pack_install"];
+/**
+ * Replace individual skill tool entries with `group:skills` on admin agents.
+ *
+ * When `group:skills` gains new tools (e.g. `skill_pack_install`), agents with
+ * explicit allow lists don't see them. This reconciliation upgrades individual
+ * entries to the group reference so future additions are automatic.
+ *
+ * Runs unconditionally on gateway startup. Idempotent — skips agents that
+ * already have `group:skills`.
+ */
+export function reconcileSkillsGroup(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 using the group — just clean up any redundant individual entries
+        if (allow.includes("group:skills")) {
+            const removed = [];
+            for (const tool of INDIVIDUAL_SKILL_TOOLS) {
+                const idx = allow.indexOf(tool);
+                if (idx !== -1) {
+                    allow.splice(idx, 1);
+                    removed.push(tool);
+                }
+            }
+            if (removed.length > 0) {
+                changes.push(`Removed redundant ${removed.join(", ")} from agent "${agent.id}" tools.allow (group:skills covers them).`);
+            }
+            continue;
+        }
+        // Check if any individual skill tools are present
+        const hasAny = INDIVIDUAL_SKILL_TOOLS.some((t) => allow.includes(t));
+        if (!hasAny) {
+            // No skill tools at all — only add group if this looks like a full admin agent
+            if (!allow.includes("message"))
+                continue;
+            allow.push("group:skills");
+            changes.push(`Added group:skills to agent "${agent.id ?? "<unnamed>"}" tools.allow.`);
+            continue;
+        }
+        // Replace individual entries with group
+        const removed = [];
+        for (const tool of INDIVIDUAL_SKILL_TOOLS) {
+            const idx = allow.indexOf(tool);
+            if (idx !== -1) {
+                allow.splice(idx, 1);
+                removed.push(tool);
+            }
+        }
+        allow.push("group:skills");
+        changes.push(`Replaced ${removed.join(", ")} with group:skills in agent "${agent.id}" tools.allow.`);
+    }
+    return { config, changes };
+}