@rubytech/taskmaster 1.11.0 → 1.11.2

package/dist/agents/taskmaster-tools.js

@@ -32,8 +32,15 @@ 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 { createBrandSettingsTool } from "./tools/brand-settings-tool.js";
+import { createChannelSettingsTool } from "./tools/channel-settings-tool.js";
 import { createImageGenerateTool } from "./tools/image-generate-tool.js";
+import { createLogsReadTool } from "./tools/logs-read-tool.js";
+import { createPublicChatSettingsTool } from "./tools/public-chat-settings-tool.js";
+import { createSkillManageTool } from "./tools/skill-manage-tool.js";
 import { createSoftwareUpdateTool } from "./tools/software-update-tool.js";
+import { createSystemStatusTool } from "./tools/system-status-tool.js";
+import { createUsageReportTool } from "./tools/usage-report-tool.js";
 import { createVerifyContactTool, createVerifyContactCodeTool, } from "./tools/verify-contact-tool.js";
 export function createTaskmasterTools(options) {
     const imageTool = options?.agentDir?.trim()
@@ -152,6 +159,13 @@ export function createTaskmasterTools(options) {
         createVerifyContactCodeTool({ agentSessionKey: options?.agentSessionKey }),
         createRelayMessageTool(),
         createApiKeysTool(),
+        createSystemStatusTool(),
+        createUsageReportTool(),
+        createChannelSettingsTool(),
+        createBrandSettingsTool(),
+        createPublicChatSettingsTool(),
+        createSkillManageTool(),
+        createLogsReadTool(),
         createFileDeleteTool({
             config: options?.config,
             agentSessionKey: options?.agentSessionKey,

package/dist/agents/tool-policy.js

@@ -46,6 +46,16 @@ export const TOOL_GROUPS = {
     ],
     // Admin management tools
     "group:admin": ["authorize_admin", "revoke_admin", "list_admins"],
+    // Control panel tools — expose setup/dashboard functionality to agents
+    "group:control-panel": [
+        "system_status",
+        "usage_report",
+        "channel_settings",
+        "brand_settings",
+        "public_chat_settings",
+        "skill_manage",
+        "logs_read",
+    ],
     // All Taskmaster native tools (excludes provider plugins).
     "group:taskmaster": [
         "browser",
@@ -80,6 +90,13 @@ export const TOOL_GROUPS = {
         "skill_draft_save",
         "verify_contact",
         "verify_contact_code",
+        "system_status",
+        "usage_report",
+        "channel_settings",
+        "brand_settings",
+        "public_chat_settings",
+        "skill_manage",
+        "logs_read",
     ],
 };
 // Tools that are never granted by profiles — must be explicitly added to the
@@ -123,6 +140,7 @@ const TOOL_PROFILES = {
             "license_generate",
             "group:contacts",
             "group:skills",
+            "group:control-panel",
             "relay_message",
             "memory_save_media",
             "image_generate",

package/dist/agents/tools/brand-settings-tool.js

@@ -0,0 +1,101 @@
+/**
+ * Agent tool for managing branding settings.
+ *
+ * Wraps `config.get`/`config.patch` for accent/background color and
+ * `brand.hasLogo`/`brand.removeLogo` for logo management. Logo upload
+ * is excluded — it requires binary data better handled through the UI.
+ */
+import { Type } from "@sinclair/typebox";
+import { stringEnum } from "../schema/typebox.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+const BRAND_ACTIONS = ["get", "set_colors", "remove_logo"];
+const BrandSettingsSchema = Type.Object({
+    action: stringEnum(BRAND_ACTIONS, {
+        description: '"get" returns current branding (accent color, background color, logo status). ' +
+            '"set_colors" updates accent and/or background colors. ' +
+            '"remove_logo" removes the workspace logo.',
+    }),
+    workspace: Type.Optional(Type.String({
+        description: "Workspace name. Required for logo operations. Defaults to the active workspace.",
+    })),
+    accentColor: Type.Optional(Type.String({
+        description: 'Hex color for the accent/primary color (e.g. "#3B82F6"). Used with set_colors.',
+    })),
+    backgroundColor: Type.Optional(Type.String({
+        description: 'Hex color for the background (e.g. "#1A1A2E"). Used with set_colors.',
+    })),
+});
+export function createBrandSettingsTool() {
+    return {
+        label: "Brand Settings",
+        name: "brand_settings",
+        description: "Read and update branding settings. " +
+            '"get" returns current accent color, background color, and logo status. ' +
+            '"set_colors" updates accent and/or background colors (hex values). ' +
+            '"remove_logo" removes the workspace logo. ' +
+            "Logo upload requires the UI due to binary data — suggest the user upload through the Setup page.",
+        parameters: BrandSettingsSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const gatewayOpts = {};
+            if (action === "get") {
+                const config = await callGatewayTool("config.get", gatewayOpts, {});
+                let brand = {};
+                if (config && typeof config === "object" && typeof config.raw === "string") {
+                    try {
+                        const parsed = JSON.parse(config.raw);
+                        brand = parsed?.brand ?? {};
+                    }
+                    catch {
+                        // fallback to empty
+                    }
+                }
+                // Also check logo status
+                const workspace = readStringParam(params, "workspace");
+                let hasLogo;
+                if (workspace) {
+                    try {
+                        const logoResult = await callGatewayTool("brand.hasLogo", gatewayOpts, { workspace });
+                        hasLogo = logoResult?.hasLogo;
+                    }
+                    catch {
+                        // non-critical
+                    }
+                }
+                return jsonResult({
+                    accentColor: brand.accentColor ?? null,
+                    backgroundColor: brand.backgroundColor ?? null,
+                    ...(hasLogo !== undefined ? { hasLogo } : {}),
+                });
+            }
+            if (action === "set_colors") {
+                const accentColor = readStringParam(params, "accentColor");
+                const backgroundColor = readStringParam(params, "backgroundColor");
+                if (!accentColor && !backgroundColor) {
+                    throw new Error("At least one of accentColor or backgroundColor is required.");
+                }
+                const brandPatch = {};
+                if (accentColor)
+                    brandPatch.accentColor = accentColor;
+                if (backgroundColor)
+                    brandPatch.backgroundColor = backgroundColor;
+                const snapshot = await callGatewayTool("config.get", gatewayOpts, {});
+                const baseHash = typeof snapshot?.hash === "string" ? snapshot.hash : undefined;
+                const result = await callGatewayTool("config.patch", gatewayOpts, {
+                    raw: JSON.stringify({ brand: brandPatch }),
+                    baseHash,
+                    note: "agent: update brand colors",
+                });
+                return jsonResult({ ok: true, ...brandPatch, result });
+            }
+            if (action === "remove_logo") {
+                const workspace = readStringParam(params, "workspace", { required: true, label: "workspace" });
+                const result = await callGatewayTool("brand.removeLogo", gatewayOpts, { workspace });
+                return jsonResult(result);
+            }
+            throw new Error(`Unknown action: ${action}`);
+        },
+    };
+}

package/dist/agents/tools/channel-settings-tool.js

@@ -0,0 +1,116 @@
+/**
+ * Agent tool for reading and updating channel settings.
+ *
+ * Wraps `channels.status` for reading and `config.patch` for writing per-account
+ * WhatsApp/iMessage settings: model selection, thinking level, DM policy, and
+ * group chat policy. These are settings users normally adjust through the
+ * WhatsApp Settings modal in the control panel.
+ */
+import { Type } from "@sinclair/typebox";
+import { stringEnum, optionalStringEnum } from "../schema/typebox.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+const CHANNEL_SETTINGS_ACTIONS = ["status", "set_model", "set_thinking", "set_dm_policy", "set_group_policy"];
+const DM_POLICY_VALUES = ["open", "closed"];
+const GROUP_POLICY_VALUES = ["open", "disabled", "allowlist"];
+const ChannelSettingsSchema = Type.Object({
+    action: stringEnum(CHANNEL_SETTINGS_ACTIONS, {
+        description: '"status" returns connection status for all channels. ' +
+            '"set_model" changes the AI model for a WhatsApp account. ' +
+            '"set_thinking" changes the thinking level. ' +
+            '"set_dm_policy" sets whether public DMs are handled (open/closed). ' +
+            '"set_group_policy" sets group chat mode (open/disabled/allowlist).',
+    }),
+    accountId: Type.Optional(Type.String({
+        description: "WhatsApp account ID (required for set_* actions). Use status action to discover account IDs.",
+    })),
+    model: Type.Optional(Type.String({
+        description: 'Model ID to set (e.g. "anthropic/claude-sonnet-4-5"). Required for set_model.',
+    })),
+    thinking: Type.Optional(Type.String({
+        description: 'Thinking level: "none", "low", "medium", "high". Required for set_thinking.',
+    })),
+    dmPolicy: optionalStringEnum(DM_POLICY_VALUES, {
+        description: 'DM policy: "open" (handle public DMs) or "closed" (ignore). Required for set_dm_policy.',
+    }),
+    groupPolicy: optionalStringEnum(GROUP_POLICY_VALUES, {
+        description: 'Group chat policy: "open", "disabled", or "allowlist". Required for set_group_policy.',
+    }),
+});
+export function createChannelSettingsTool() {
+    return {
+        label: "Channel Settings",
+        name: "channel_settings",
+        description: "Read and update channel settings (WhatsApp, iMessage). " +
+            '"status" shows connection state and account list. ' +
+            "set_model/set_thinking/set_dm_policy/set_group_policy update per-account WhatsApp settings. " +
+            "Use status first to discover available account IDs.",
+        parameters: ChannelSettingsSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const gatewayOpts = {};
+            if (action === "status") {
+                const result = await callGatewayTool("channels.status", gatewayOpts, {});
+                return jsonResult(result);
+            }
+            // All set_* actions require accountId and use config.patch
+            const accountId = readStringParam(params, "accountId", { required: true, label: "accountId" });
+            if (action === "set_model") {
+                const model = readStringParam(params, "model", { required: true, label: "model" });
+                // Patch the WhatsApp account's model in config
+                const snapshot = await callGatewayTool("config.get", gatewayOpts, {});
+                const baseHash = typeof snapshot?.hash === "string" ? snapshot.hash : undefined;
+                const result = await callGatewayTool("config.patch", gatewayOpts, {
+                    raw: JSON.stringify({
+                        channels: { whatsapp: { accounts: { [accountId]: { model } } } },
+                    }),
+                    baseHash,
+                    note: `agent: set model to ${model} for account ${accountId}`,
+                });
+                return jsonResult({ ok: true, accountId, model, result });
+            }
+            if (action === "set_thinking") {
+                const thinking = readStringParam(params, "thinking", { required: true, label: "thinking" });
+                const snapshot = await callGatewayTool("config.get", gatewayOpts, {});
+                const baseHash = typeof snapshot?.hash === "string" ? snapshot.hash : undefined;
+                const result = await callGatewayTool("config.patch", gatewayOpts, {
+                    raw: JSON.stringify({
+                        channels: { whatsapp: { accounts: { [accountId]: { thinking } } } },
+                    }),
+                    baseHash,
+                    note: `agent: set thinking to ${thinking} for account ${accountId}`,
+                });
+                return jsonResult({ ok: true, accountId, thinking, result });
+            }
+            if (action === "set_dm_policy") {
+                const dmPolicy = readStringParam(params, "dmPolicy", { required: true, label: "dmPolicy" });
+                const handlePublicDMs = dmPolicy === "open";
+                const snapshot = await callGatewayTool("config.get", gatewayOpts, {});
+                const baseHash = typeof snapshot?.hash === "string" ? snapshot.hash : undefined;
+                const result = await callGatewayTool("config.patch", gatewayOpts, {
+                    raw: JSON.stringify({
+                        channels: { whatsapp: { accounts: { [accountId]: { handlePublicDMs } } } },
+                    }),
+                    baseHash,
+                    note: `agent: set DM policy to ${dmPolicy} for account ${accountId}`,
+                });
+                return jsonResult({ ok: true, accountId, dmPolicy, result });
+            }
+            if (action === "set_group_policy") {
+                const groupPolicy = readStringParam(params, "groupPolicy", { required: true, label: "groupPolicy" });
+                const snapshot = await callGatewayTool("config.get", gatewayOpts, {});
+                const baseHash = typeof snapshot?.hash === "string" ? snapshot.hash : undefined;
+                const result = await callGatewayTool("config.patch", gatewayOpts, {
+                    raw: JSON.stringify({
+                        channels: { whatsapp: { accounts: { [accountId]: { groups: { mode: groupPolicy } } } } },
+                    }),
+                    baseHash,
+                    note: `agent: set group policy to ${groupPolicy} for account ${accountId}`,
+                });
+                return jsonResult({ ok: true, accountId, groupPolicy, result });
+            }
+            throw new Error(`Unknown action: ${action}`);
+        },
+    };
+}

package/dist/agents/tools/logs-read-tool.js

@@ -0,0 +1,67 @@
+/**
+ * Agent tool for reading system and session logs.
+ *
+ * Wraps `logs.tail` for system logs and `sessions.transcript` for session logs,
+ * giving the agent full observability into what the system has been doing —
+ * without the user needing to open the Advanced > Logs tab.
+ */
+import { Type } from "@sinclair/typebox";
+import { stringEnum } from "../schema/typebox.js";
+import { jsonResult, readStringParam, readStringArrayParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+const LOGS_ACTIONS = ["system", "sessions"];
+const LogsReadSchema = Type.Object({
+    action: stringEnum(LOGS_ACTIONS, {
+        description: '"system" returns recent gateway system logs (errors, warnings, info). ' +
+            '"sessions" returns session transcript entries (messages, tool calls) across agents.',
+    }),
+    limit: Type.Optional(Type.Number({
+        description: "Maximum number of log lines/entries to return. Default 200 for system, 100 for sessions.",
+    })),
+    cursor: Type.Optional(Type.Number({
+        description: "Byte cursor for pagination (system logs). Returned in previous response.",
+    })),
+    agents: Type.Optional(Type.Array(Type.String(), {
+        description: 'Filter session logs to specific agent IDs (e.g. ["admin", "public"]). Sessions action only.',
+    })),
+});
+export function createLogsReadTool() {
+    return {
+        label: "Logs",
+        name: "logs_read",
+        description: "Read system and session logs. " +
+            '"system" returns recent gateway logs with cursor-based pagination. ' +
+            '"sessions" returns transcript entries (messages, tool calls, errors) across all agents. ' +
+            "Filter session logs by agent ID. Use the cursor from previous calls for pagination.",
+        parameters: LogsReadSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            if (action === "system") {
+                const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                    ? Math.max(1, Math.floor(params.limit))
+                    : 200;
+                const cursor = typeof params.cursor === "number" && Number.isFinite(params.cursor)
+                    ? Math.max(0, Math.floor(params.cursor))
+                    : undefined;
+                const result = await callGatewayTool("logs.tail", {}, {
+                    limit,
+                    ...(cursor !== undefined ? { cursor } : {}),
+                });
+                return jsonResult(result);
+            }
+            if (action === "sessions") {
+                const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                    ? Math.max(1, Math.floor(params.limit))
+                    : 100;
+                const agents = readStringArrayParam(params, "agents");
+                const result = await callGatewayTool("sessions.transcript", {}, {
+                    limit,
+                    ...(agents ? { agents } : {}),
+                });
+                return jsonResult(result);
+            }
+            throw new Error(`Unknown action: ${action}`);
+        },
+    };
+}

package/dist/agents/tools/public-chat-settings-tool.js

@@ -0,0 +1,128 @@
+/**
+ * Agent tool for managing public chat settings.
+ *
+ * Wraps config operations for the public chat widget: enable/disable, greeting
+ * text, verification mode, and greeting regeneration. These are settings users
+ * normally adjust through the Public Chat Settings modal in the control panel.
+ */
+import { Type } from "@sinclair/typebox";
+import { stringEnum, optionalStringEnum } from "../schema/typebox.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+const PUBLIC_CHAT_ACTIONS = [
+    "status",
+    "enable",
+    "disable",
+    "set_greeting",
+    "regenerate_greeting",
+    "set_access_mode",
+];
+const ACCESS_MODES = ["open", "verified", "visitor-chooses"];
+const PublicChatSettingsSchema = Type.Object({
+    action: stringEnum(PUBLIC_CHAT_ACTIONS, {
+        description: '"status" returns current public chat config (enabled, greeting, access mode). ' +
+            '"enable"/"disable" toggles public chat. ' +
+            '"set_greeting" updates the greeting text. ' +
+            '"regenerate_greeting" generates a new greeting using the agent persona. ' +
+            '"set_access_mode" sets visitor access: open, verified, or visitor-chooses.',
+    }),
+    greeting: Type.Optional(Type.String({
+        description: "Greeting text to display to visitors. Used with set_greeting.",
+    })),
+    greetingEnabled: Type.Optional(Type.Boolean({
+        description: "Whether to show a greeting message. Used with set_greeting.",
+    })),
+    accessMode: optionalStringEnum(ACCESS_MODES, {
+        description: '"open" allows anonymous access, "verified" requires phone/email verification, ' +
+            '"visitor-chooses" lets the visitor decide. Used with set_access_mode.',
+    }),
+    accountId: Type.Optional(Type.String({
+        description: "Account ID for greeting regeneration. Required for regenerate_greeting.",
+    })),
+});
+export function createPublicChatSettingsTool() {
+    return {
+        label: "Public Chat Settings",
+        name: "public_chat_settings",
+        description: "Manage the public chat widget settings. " +
+            '"status" returns current config. ' +
+            '"enable"/"disable" toggles the widget. ' +
+            '"set_greeting" updates greeting text and visibility. ' +
+            '"regenerate_greeting" auto-generates a greeting from the agent persona. ' +
+            '"set_access_mode" controls visitor verification (open/verified/visitor-chooses).',
+        parameters: PublicChatSettingsSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const gatewayOpts = {};
+            if (action === "status") {
+                const config = await callGatewayTool("config.get", gatewayOpts, {});
+                let publicChat = {};
+                if (config && typeof config === "object" && typeof config.raw === "string") {
+                    try {
+                        const parsed = JSON.parse(config.raw);
+                        publicChat = parsed?.publicChat ?? {};
+                    }
+                    catch {
+                        // fallback
+                    }
+                }
+                return jsonResult({
+                    enabled: publicChat.enabled ?? false,
+                    greeting: publicChat.greeting ?? null,
+                    greetingEnabled: publicChat.greetingEnabled ?? true,
+                    accessMode: publicChat.accessMode ?? "open",
+                    verifyMethods: publicChat.verifyMethods ?? ["phone"],
+                });
+            }
+            if (action === "enable" || action === "disable") {
+                const enabled = action === "enable";
+                const snapshot = await callGatewayTool("config.get", gatewayOpts, {});
+                const baseHash = typeof snapshot?.hash === "string" ? snapshot.hash : undefined;
+                const result = await callGatewayTool("config.patch", gatewayOpts, {
+                    raw: JSON.stringify({ publicChat: { enabled } }),
+                    baseHash,
+                    note: `agent: ${action} public chat`,
+                });
+                return jsonResult({ ok: true, enabled, result });
+            }
+            if (action === "set_greeting") {
+                const greeting = readStringParam(params, "greeting");
+                const greetingEnabled = typeof params.greetingEnabled === "boolean" ? params.greetingEnabled : undefined;
+                if (greeting === undefined && greetingEnabled === undefined) {
+                    throw new Error("At least one of greeting or greetingEnabled is required.");
+                }
+                const patch = {};
+                if (greeting !== undefined)
+                    patch.greeting = greeting;
+                if (greetingEnabled !== undefined)
+                    patch.greetingEnabled = greetingEnabled;
+                const snapshot = await callGatewayTool("config.get", gatewayOpts, {});
+                const baseHash = typeof snapshot?.hash === "string" ? snapshot.hash : undefined;
+                const result = await callGatewayTool("config.patch", gatewayOpts, {
+                    raw: JSON.stringify({ publicChat: patch }),
+                    baseHash,
+                    note: "agent: update public chat greeting",
+                });
+                return jsonResult({ ok: true, ...patch, result });
+            }
+            if (action === "regenerate_greeting") {
+                const accountId = readStringParam(params, "accountId", { required: true, label: "accountId" });
+                const result = await callGatewayTool("public.greeting.generate", gatewayOpts, { accountId });
+                return jsonResult(result);
+            }
+            if (action === "set_access_mode") {
+                const accessMode = readStringParam(params, "accessMode", { required: true, label: "accessMode" });
+                const snapshot = await callGatewayTool("config.get", gatewayOpts, {});
+                const baseHash = typeof snapshot?.hash === "string" ? snapshot.hash : undefined;
+                const result = await callGatewayTool("config.patch", gatewayOpts, {
+                    raw: JSON.stringify({ publicChat: { accessMode } }),
+                    baseHash,
+                    note: `agent: set public chat access mode to ${accessMode}`,
+                });
+                return jsonResult({ ok: true, accessMode, result });
+            }
+            throw new Error(`Unknown action: ${action}`);
+        },
+    };
+}

package/dist/agents/tools/skill-manage-tool.js

@@ -0,0 +1,105 @@
+/**
+ * Agent tool for managing skills (create, update, delete, install).
+ *
+ * Complements the existing `skill_read` and `skill_draft_save` tools by adding
+ * write operations. The agent can now manage the full skill lifecycle through
+ * conversation rather than requiring the user to navigate the Advanced > Skills UI.
+ */
+import { Type } from "@sinclair/typebox";
+import { stringEnum } from "../schema/typebox.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+const SKILL_MANAGE_ACTIONS = ["list", "create", "update", "delete", "install"];
+const SkillManageSchema = Type.Object({
+    action: stringEnum(SKILL_MANAGE_ACTIONS, {
+        description: '"list" returns all skills with their status. ' +
+            '"create" creates a new user skill (name + skillContent required). ' +
+            '"update" modifies a skill setting (skillKey required, plus enabled/apiKey/env). ' +
+            '"delete" removes a user skill (name required; preloaded skills cannot be deleted). ' +
+            '"install" installs a skill from a remote source (name + installId required).',
+    }),
+    name: Type.Optional(Type.String({
+        description: "Skill name/key (required for create, delete, install).",
+    })),
+    skillKey: Type.Optional(Type.String({
+        description: "Skill key for update action.",
+    })),
+    skillContent: Type.Optional(Type.String({
+        description: "SKILL.md content (required for create). Must include YAML frontmatter with name and description.",
+    })),
+    references: Type.Optional(Type.Array(Type.Object({
+        name: Type.String({ description: "Reference filename (e.g. details.md)." }),
+        content: Type.String({ description: "Reference file content." }),
+    }))),
+    enabled: Type.Optional(Type.Boolean({
+        description: "Enable or disable a skill (used with update).",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "API key for a skill that requires one (used with update).",
+    })),
+    installId: Type.Optional(Type.String({
+        description: "Install identifier for remote skill installation (used with install).",
+    })),
+});
+export function createSkillManageTool() {
+    return {
+        label: "Skill Management",
+        name: "skill_manage",
+        description: "Manage workspace skills: list, create, update, delete, or install. " +
+            '"list" shows all skills and their status. ' +
+            '"create" makes a new skill (provide name + skillContent with YAML frontmatter). ' +
+            '"update" modifies settings (enabled, apiKey). ' +
+            '"delete" removes a user skill (preloaded skills are protected). ' +
+            '"install" adds a skill from a remote source.',
+        parameters: SkillManageSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            if (action === "list") {
+                const result = await callGatewayTool("skills.status", {}, {});
+                return jsonResult(result);
+            }
+            if (action === "create") {
+                const name = readStringParam(params, "name", { required: true, label: "name" });
+                const skillContent = readStringParam(params, "skillContent", {
+                    required: true,
+                    label: "skillContent",
+                });
+                const references = Array.isArray(params.references) ? params.references : undefined;
+                const result = await callGatewayTool("skills.create", {}, {
+                    name,
+                    skillContent,
+                    ...(references ? { references } : {}),
+                });
+                return jsonResult(result);
+            }
+            if (action === "update") {
+                const skillKey = readStringParam(params, "skillKey") ?? readStringParam(params, "name");
+                if (!skillKey)
+                    throw new Error("skillKey (or name) required for update");
+                const patch = { skillKey };
+                if (typeof params.enabled === "boolean")
+                    patch.enabled = params.enabled;
+                if (typeof params.apiKey === "string")
+                    patch.apiKey = params.apiKey;
+                const result = await callGatewayTool("skills.update", {}, patch);
+                return jsonResult(result);
+            }
+            if (action === "delete") {
+                const name = readStringParam(params, "name", { required: true, label: "name" });
+                const result = await callGatewayTool("skills.delete", {}, { name });
+                return jsonResult(result);
+            }
+            if (action === "install") {
+                const name = readStringParam(params, "name", { required: true, label: "name" });
+                const installId = readStringParam(params, "installId", {
+                    required: true,
+                    label: "installId",
+                });
+                const result = await callGatewayTool("skills.install", {}, { name, installId });
+                return jsonResult(result);
+            }
+            throw new Error(`Unknown action: ${action}`);
+        },
+    };
+}

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

@@ -0,0 +1,64 @@
+/**
+ * Agent tool for checking system status.
+ *
+ * Gives the agent a unified view of gateway health, auth status, license info,
+ * channel connections, available models, and software update availability —
+ * everything a user would normally check by opening the Setup dashboard.
+ */
+import { Type } from "@sinclair/typebox";
+import { stringEnum } from "../schema/typebox.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+const SYSTEM_STATUS_ACTIONS = ["overview", "health", "auth", "license", "channels", "models", "update"];
+const SystemStatusSchema = Type.Object({
+    action: stringEnum(SYSTEM_STATUS_ACTIONS, {
+        description: '"overview" returns a combined snapshot of all subsystems. Use specific actions for detailed info on one subsystem.',
+    }),
+});
+export function createSystemStatusTool() {
+    return {
+        label: "System Status",
+        name: "system_status",
+        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), ' +
+            '"channels" (WhatsApp/iMessage connections), "models" (available LLM models), ' +
+            '"update" (software version and update availability).',
+        parameters: SystemStatusSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            if (action === "overview") {
+                // Fetch all subsystems in parallel for a unified snapshot
+                const [health, auth, license, channels, update] = await Promise.allSettled([
+                    callGatewayTool("health", {}, {}),
+                    callGatewayTool("auth.status", {}, {}),
+                    callGatewayTool("license.status", {}, {}),
+                    callGatewayTool("channels.status", {}, {}),
+                    callGatewayTool("update.status", {}, {}),
+                ]);
+                return jsonResult({
+                    health: health.status === "fulfilled" ? health.value : { error: String(health.reason) },
+                    auth: auth.status === "fulfilled" ? auth.value : { error: String(auth.reason) },
+                    license: license.status === "fulfilled" ? license.value : { error: String(license.reason) },
+                    channels: channels.status === "fulfilled" ? channels.value : { error: String(channels.reason) },
+                    update: update.status === "fulfilled" ? update.value : { error: String(update.reason) },
+                });
+            }
+            const methodMap = {
+                health: "health",
+                auth: "auth.status",
+                license: "license.status",
+                channels: "channels.status",
+                models: "models.list",
+                update: "update.status",
+            };
+            const method = methodMap[action];
+            if (!method)
+                throw new Error(`Unknown action: ${action}`);
+            const result = await callGatewayTool(method, {}, {});
+            return jsonResult(result);
+        },
+    };
+}