@nooticr/mcp 1.26.58 → 1.26.60

package/README.md

@@ -52,7 +52,7 @@ npx @nooticr/mcp login   # one-time sign-in (Google)
 
 ## Tools
 
-92 tools, grouped by what you are trying to do. Prices are in nooticr credits and
+100 tools, grouped by what you are trying to do. Prices are in nooticr credits and
 match what the server actually charges.
 
 The job tools under **Answer a question you actually have** are not
@@ -151,6 +151,7 @@ a `scanId` for the rest.
 | `get_amazon_product` | 3 | One listing by ASIN or URL: price, rating, the full star histogram, features, specs, Amazon's review digest and aspect breakdown, and the reviews. |
 | `scan_marketplace_category` | 3 per product collected (30 by default) | The same category read on eleven more sites — AliExpress, Cdiscount, Flipkart, Mercado Libre, Lazada, Otto, Rakuten, Trendyol, Jumia, Vinted and Temu. Vinted is resale rather than retail, so its `rating` describes the seller and the scan says so in `ratingScope` — do not read it as a product's reviews. `marketplace` picks the site; `market` picks the storefront for the sites that have several, and the argument names the real set per site so a model cannot send Otto a Lazada region. Same rollup, same confirmation before spending. |
 | `marketplace_scan_status` | free | Picks a running marketplace collection back up by `scanId` and the same `marketplace`. Free, for the same reason `amazon_scan_status` is. |
+| `marketplace_changes` | free | What moved in a category since the previous scan of the same `marketplace` and `query`: products that entered or left the results and ones whose price or place changed. Read from the two latest stored scans, so it fetches nothing; a category scanned once says it has no earlier run. |
 | `get_marketplace_product` | 3 | One product from any of the twelve sites, by id or URL: price, rating, the full star histogram, specs and the reviews. |
 | `show_amazon_category_insights` | free | Draws the read **your model** wrote — purchase drivers, barriers, what each brand does well, the gaps, the positioning angles — beside the listings and their reviews, so a person can click a product and check any claim against the text it came from. The conclusions are attributed to your model, never presented as a nooticr rating of anyone's product. Given the `scanId`, it re-reads the listings from the scan itself (free) instead of drawing whatever the model re-sends, and flags any ASIN the read cites that the scan does not contain; without one, the card says its listings were not checked. |
 | `show_marketplace_category_insights` | free | The same card for the other eleven marketplaces: your read beside that site's listings and reviews, labelled with the right site, re-read from the scan by `scanId` and `marketplace` so nothing is re-typed. |
@@ -181,6 +182,13 @@ a `scanId` for the rest.
 | `nooticr_login` | free | Re-link the account when a call fails with an authentication error. |
 | `list_social_connections` | free | What you have connected and what each connection is actually allowed to do — read the account, publish a post, manage comments — as yes, no or **unknown**. "Manage comments" reports the platform's grant; no nooticr tool posts or replies to a comment. Unknown means the grant predates scope recording: treat it as "try it", not as a refusal. Also says which platforms can be linked at all, which is a smaller set than the networks nooticr reads. |
 | `connect_social_account` | free | A link the user opens to connect one account. They approve at the provider in their own browser; nothing is connected until they do, and no credential passes through the tool or the model's context. Each call mints a fresh link — an old one does not work twice. |
+| `hire_employee` | free to call | Hire an AI employee (for example a Social Media Manager) that works on a schedule inside your workspace. Two calls by design: the first creates nothing and returns a quote and a `confirmationToken`; call again with `confirm: true` and that token only after you say yes. Public actions wait for your approval unless autopilot is on. Its runs bill the hiring user, up to the monthly budget. |
+| `list_employees` | free | Your AI employees with status, schedule, next run and budget left; `includeFired: true` adds the ones let go. |
+| `pause_employee` | free | Pause an AI employee (it keeps its memory and thread) or resume it with `resume: true`. Only the person who hired it or a workspace admin can. |
+| `fire_employee` | free | Let an AI employee go for good: runs stop and actions awaiting approval are discarded. The first call only describes what will happen; confirm with `confirm: true`. |
+| `list_pending_actions` | free | What your AI employees are waiting to do until you approve, each with a preview of what will be published, sent or changed. Optionally one `employeeId`. |
+| `approve_action` | free | Approve one pending action by `actionId`. The first call returns the preview and a `confirmationToken` and runs nothing; after you confirm, the stored action runs exactly once. |
+| `reject_action` | free | Reject one pending action, with an optional note the employee can learn from. |
 | `connect_store` | free | A link a workspace owner or admin opens to connect an Amazon seller account or a Shopify shop. They approve at the store; nothing is connected until they do, and no credential passes through the tool. |
 | `list_store_products` | free | Read the connected store's own catalogue: title, description, status, price, and Amazon listing issues. Read-only. |
 | `create_product` | free | Create a product in your own workspace — the row every other own-account tool needs before it has anything to work with. Always creates in the calling session's workspace, never one you could name. `name` and `slug` are required; every other field is snake_case and read by exact key, so a camelCase `websiteUrl` lands nowhere. Writes no brand playbook. |

package/dist/shared/employees.js

@@ -0,0 +1,153 @@
+/**
+ * AI employees (nooticr-server P1): hire one, see what it is waiting to do,
+ * approve or reject that, pause it, let it go. Every tool here is a passthrough
+ * to the server's `POST /mcp` dispatch; the server owns the quote, the
+ * confirmation token, the permission check (the hiring user or a workspace
+ * admin) and the stored action that approve_action runs exactly once.
+ *
+ * None of these has a view yet: the lists would be drawn as tables and the
+ * quotes as confirmation cards, and the design system has no card for either.
+ */
+import { z } from "zod";
+import { OUTPUT_SCHEMAS } from "./output-schemas.js";
+function toResult(proxy) {
+    const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
+    const structured = proxy.structured;
+    // The backend's text block can be a one-line summary, and the employees,
+    // actions, previews and confirmation tokens are in `structuredContent`, which
+    // a host rendering a view keeps for the widget. Without a view here, the model
+    // must read them from the text, so carry the payload in both.
+    const text = structured ? JSON.stringify(structured) : String(textBlock?.text ?? "");
+    return { content: [{ type: "text", text }], structuredContent: structured };
+}
+function failed(prefix, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+        content: [{ type: "text", text: `${prefix}: ${msg}` }],
+        isError: true,
+    };
+}
+/** The sentence every two-step employee tool carries. A test pins it. */
+export const TWO_STEP_RULE = "The first call changes nothing and returns a preview and a confirmationToken; show it to the " +
+    "user, and call again with confirm: true and the token only after the user explicitly agrees — " +
+    "never confirm on the user's behalf.";
+const confirm = z.boolean().optional();
+export function registerEmployeeTools(server, makeClient) {
+    const passthrough = (name) => async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        try {
+            return toResult(await client.callTool(name, args));
+        }
+        catch (err) {
+            return failed(`${name} failed`, err);
+        }
+    };
+    server.registerTool("hire_employee", {
+        title: "Hire Employee",
+        description: "Hire an AI employee (for example a Social Media Manager) that works on a schedule inside " +
+            "this workspace. Pass `template` and optionally name, instructions, appId, schedule, " +
+            "monthlyBudgetCredits, maxCreditsPerRun, approvalPolicy and notify. " +
+            TWO_STEP_RULE +
+            " Public actions (publish, email, reply, listing or price changes) wait for the user's " +
+            "approval unless autopilot is turned on. The hiring user is billed for runs, up to the " +
+            "monthly budget. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        inputSchema: z
+            .object({
+            template: z.string().describe("Template slug, e.g. social-media-manager."),
+            name: z.string().optional().describe("What to call the employee."),
+            instructions: z.string().optional().describe("Standing instructions from the customer (tone, topics to avoid, ...)."),
+            appId: z.number().int().optional().describe("Focus product id."),
+            schedule: z
+                .object({}).passthrough()
+                .optional()
+                .describe("{kind:'weekly',days:['mon'],times:['09:00'],tz:'Europe/Paris'} | {kind:'interval',minutes:N>=60} | {kind:'manual'}."),
+            monthlyBudgetCredits: z.number().int().min(1).optional(),
+            maxCreditsPerRun: z.number().int().min(1).optional(),
+            approvalPolicy: z.object({}).passthrough().optional().describe("Action type -> 'approval' | 'auto'."),
+            notify: z.object({}).passthrough().optional().describe("{channels:['email'|'slack']}."),
+            model: z.string().optional().describe("Optional model."),
+            effort: z.string().optional().describe("low | medium | high."),
+            confirm,
+            confirmationToken: z.string().optional().describe("Token returned in the quote."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.hire_employee,
+    }, passthrough("hire_employee"));
+    server.registerTool("list_employees", {
+        title: "List Employees",
+        description: "List this workspace's AI employees with status, schedule, next run and budget left. " +
+            "Pass includeFired: true to include ones that were let go. No cost to call.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z.object({ includeFired: z.boolean().optional() }).strict(),
+        outputSchema: OUTPUT_SCHEMAS.list_employees,
+    }, passthrough("list_employees"));
+    server.registerTool("pause_employee", {
+        title: "Pause Employee",
+        description: "Pause an AI employee so it stops running (it keeps its memory and thread), or resume it " +
+            "with resume: true. Only the person who hired it or a workspace admin can. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z
+            .object({
+            employeeId: z.string().describe("Employee id."),
+            resume: z.boolean().optional().describe("Resume instead of pausing."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.pause_employee,
+    }, passthrough("pause_employee"));
+    server.registerTool("fire_employee", {
+        title: "Fire Employee",
+        description: "Let an AI employee go for good: runs stop and actions waiting for approval are discarded; " +
+            "its thread stays readable. The first call only describes what will happen and changes " +
+            "nothing; call again with confirm: true only after the user explicitly agrees — never " +
+            "confirm on the user's behalf. Only the person who hired it or a workspace admin can. " +
+            "No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        inputSchema: z.object({ employeeId: z.string().describe("Employee id."), confirm }).strict(),
+        outputSchema: OUTPUT_SCHEMAS.fire_employee,
+    }, passthrough("fire_employee"));
+    server.registerTool("list_pending_actions", {
+        title: "List Pending Actions",
+        description: "List what AI employees are waiting to do until a human approves: each action has a " +
+            "preview of what will be published, sent or changed. Optionally filter by employeeId. " +
+            "No cost to call.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z
+            .object({
+            employeeId: z.string().optional().describe("Only this employee's actions."),
+            limit: z.number().int().min(1).max(100).optional(),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.list_pending_actions,
+    }, passthrough("list_pending_actions"));
+    server.registerTool("approve_action", {
+        title: "Approve Action",
+        description: "Approve one pending AI-employee action by actionId. " +
+            TWO_STEP_RULE +
+            " The stored action then runs exactly once, and it may publish or send something publicly. " +
+            "Only the hiring user or a workspace admin can. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        inputSchema: z
+            .object({
+            actionId: z.string().describe("Action id from list_pending_actions."),
+            confirm,
+            confirmationToken: z.string().optional().describe("Token from the first call."),
+            note: z.string().optional().describe("Optional note."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.approve_action,
+    }, passthrough("approve_action"));
+    server.registerTool("reject_action", {
+        title: "Reject Action",
+        description: "Reject one pending AI-employee action by actionId, with an optional note the employee " +
+            "can learn from. Only the hiring user or a workspace admin can. No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z
+            .object({
+            actionId: z.string().describe("Action id from list_pending_actions."),
+            note: z.string().optional().describe("Why, so the employee can learn."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.reject_action,
+    }, passthrough("reject_action"));
+}

package/dist/shared/loading-plans.js

@@ -436,6 +436,8 @@ export const LOADING_PLANS = {
         steps: [],
         free: true,
     },
+    // Free: reads two stored scans, fetches nothing.
+    marketplace_changes: { label: "Comparing the two scans", kind: "list", n: 6, steps: [], free: true },
     get_marketplace_product: {
         label: "Reading the product",
         kind: "text",
@@ -477,6 +479,14 @@ export const LOADING_PLANS = {
     list_brand_watches: { label: "Reading your watches", kind: "list", n: 3, steps: [], free: true },
     stop_brand_watch: { label: "Stopping the watch", kind: "text", n: 1, steps: [], free: true },
     update_watch_portfolio: { label: "Updating the portfolio", kind: "text", n: 1, steps: [], free: true },
+    // ─── AI employees (employees.ts): managing one is free; its runs are billed when they happen ───
+    hire_employee: { label: "Preparing the hire", kind: "text", n: 1, steps: [], free: true },
+    list_employees: { label: "Reading your employees", kind: "list", n: 3, steps: [], free: true },
+    pause_employee: { label: "Updating the employee", kind: "text", n: 1, steps: [], free: true },
+    fire_employee: { label: "Letting the employee go", kind: "text", n: 1, steps: [], free: true },
+    list_pending_actions: { label: "Reading what awaits approval", kind: "list", n: 3, steps: [], free: true },
+    approve_action: { label: "Approving the action", kind: "text", n: 1, steps: [], free: true },
+    reject_action: { label: "Rejecting the action", kind: "text", n: 1, steps: [], free: true },
     // ─── Store connections (store-read.ts): a link, and a read of the store's own catalogue ───
     connect_store: { label: "Minting a store link", kind: "text", n: 1, steps: [], free: true },
     list_store_products: { label: "Reading your store's catalogue", kind: "list", n: 3, steps: [], free: true },

package/dist/shared/marketplace.js

@@ -400,6 +400,45 @@ export function registerMarketplaceTools(server, makeClient) {
             return toolError("marketplace_scan_status failed", err);
         }
     });
+    server.registerTool("marketplace_changes", {
+        title: "Marketplace Changes",
+        description: "What moved in a category since the run before: products that entered or left a search's " +
+            "results, and ones whose price or place changed. Compared from the two latest stored scans " +
+            "of the same marketplace and `query`, so it fetches nothing and never re-scans — run " +
+            "scan_marketplace_category first, and again later, to have two runs to compare. `new` and " +
+            "`gone` mean entered or left the results, not listed or delisted. A category scanned only " +
+            "once has no earlier run and says so. Free.",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        outputSchema: OUTPUT_SCHEMAS.marketplace_changes,
+        inputSchema: z
+            .object({
+            marketplace: marketplaceArg,
+            query: z.string().describe("The category search to compare, exactly as it was scanned."),
+            market: z.string().optional().describe("The storefront the scan read, if the site has several."),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const m = marketOf(args.marketplace);
+        if (!m)
+            return toolError("marketplace_changes failed", new Error(`unknown marketplace — one of ${SLUGS}`));
+        try {
+            const res = await client.callTool("marketplace_changes", args);
+            const payload = structured(res);
+            return {
+                content: [{ type: "text", text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (err) {
+            return toolError("marketplace_changes failed", err);
+        }
+    });
     server.registerTool("get_marketplace_product", {
         title: "Get Marketplace Product",
         _meta: viewMeta("get_marketplace_product"),

package/dist/shared/output-schemas.js

@@ -1629,6 +1629,53 @@ export const OUTPUT_SCHEMAS = {
     // the result does not have to know which site it asked.
     scan_marketplace_category: marketplaceScan,
     marketplace_scan_status: marketplaceScan,
+    // AI employees (nooticr-server P1). The quote and employee/action views are
+    // the server's own shapes, so only the stable fields are named.
+    hire_employee: open({
+        created: scalar(),
+        requiresConfirmation: scalar(),
+        confirmationToken: scalar(),
+        message: scalar(),
+        instructions: scalar(),
+        employee: anyObject().nullish(),
+    }),
+    pause_employee: open({ employee: anyObject().nullish() }),
+    fire_employee: open({
+        fired: scalar(),
+        requiresConfirmation: scalar(),
+        pendingActions: scalar(),
+        instructions: scalar(),
+        employee: anyObject().nullish(),
+    }),
+    approve_action: open({
+        executed: scalar(),
+        requiresConfirmation: scalar(),
+        confirmationToken: scalar(),
+        expiresInSeconds: scalar(),
+        instructions: scalar(),
+        action: anyObject().nullish(),
+    }),
+    reject_action: open({ rejected: scalar(), action: anyObject().nullish() }),
+    list_employees: open({ employees: listOf(open({ id: scalar(), name: scalar(), status: scalar() })) }),
+    list_pending_actions: open({ actions: listOf(open({ id: scalar(), employeeId: scalar() })) }),
+    // A diff of two stored scans, drawn by no view: the rows are the answer.
+    marketplace_changes: open({
+        display: scalar(),
+        hasBaseline: scalar(),
+        since: scalar(),
+        takenAt: scalar(),
+        counts: open({ new: scalar(), gone: scalar(), moved: scalar() }).nullish(),
+        totalChanges: scalar(),
+        rows: listOf(open({
+            change: scalar(),
+            id: scalar(),
+            title: scalar(),
+            meta: scalar(),
+            url: scalar(),
+            move: scalar(),
+        })),
+        note: scalar(),
+    }),
     get_marketplace_product: open({
         ...marketplaceScanShape,
         product: amazonProduct.nullish().describe("The single product, also present as products[0]."),

package/dist/shared/tools-def.js

@@ -522,6 +522,54 @@ export const TOOL_DEFINITIONS = [
         description: "Pick up a scan_marketplace_category collection that was still running, by scanId and the same marketplace — the products and reviews collected since, with the same rollup and the same instructions for reading them. Free: it is the poll scan_marketplace_category asked for, and charging for the second half of one answer would bill a wait this server chose. Call it when a scan came back incomplete, and keep calling it until it reports complete: true; only then write your read, from the full set. Do not end your turn between polls.",
         inputSchema: z.object({ marketplace: z.string().describe("The same site the scan ran against."), scanId: z.string().describe("The scanId scan_marketplace_category returned."), waitSeconds: z.number().int().optional().describe("How long to wait for more products before answering (default 30, max 55)."), focus: z.string().optional().describe("Same optional steer as scan_marketplace_category.") }).strict(),
     },
+    {
+        name: "hire_employee",
+        title: "Hire Employee",
+        description: "Hire an AI employee (for example a Social Media Manager) that works on a schedule inside this workspace. Pass `template` and optionally name, instructions, appId, schedule, monthlyBudgetCredits, maxCreditsPerRun, approvalPolicy and notify. The first call changes nothing and returns a preview and a confirmationToken; show it to the user, and call again with confirm: true and the token only after the user explicitly agrees — never confirm on the user's behalf. Public actions (publish, email, reply, listing or price changes) wait for the user's approval unless autopilot is turned on. The hiring user is billed for runs, up to the monthly budget. No cost to call.",
+        inputSchema: z.object({ template: z.string().describe("Template slug, e.g. social-media-manager."), name: z.string().optional().describe("What to call the employee."), instructions: z.string().optional().describe("Standing instructions from the customer (tone, topics to avoid, ...)."), appId: z.number().int().optional().describe("Focus product id."), schedule: z.object({}).passthrough().optional().describe("{kind:'weekly',days:['mon'],times:['09:00'],tz:'Europe/Paris'} | {kind:'interval',minutes:N>=60} | {kind:'manual'}."), monthlyBudgetCredits: z.number().int().min(1).optional(), maxCreditsPerRun: z.number().int().min(1).optional(), approvalPolicy: z.object({}).passthrough().optional().describe("Action type -> 'approval' | 'auto'."), notify: z.object({}).passthrough().optional().describe("{channels:['email'|'slack']}."), model: z.string().optional().describe("Optional model."), effort: z.string().optional().describe("low | medium | high."), confirm: z.boolean().optional(), confirmationToken: z.string().optional().describe("Token returned in the quote.") }).strict(),
+    },
+    {
+        name: "list_employees",
+        title: "List Employees",
+        description: "List this workspace's AI employees with status, schedule, next run and budget left. Pass includeFired: true to include ones that were let go. No cost to call.",
+        inputSchema: z.object({ includeFired: z.boolean().optional() }).strict(),
+    },
+    {
+        name: "pause_employee",
+        title: "Pause Employee",
+        description: "Pause an AI employee so it stops running (it keeps its memory and thread), or resume it with resume: true. Only the person who hired it or a workspace admin can. No cost to call.",
+        inputSchema: z.object({ employeeId: z.string().describe("Employee id."), resume: z.boolean().optional().describe("Resume instead of pausing.") }).strict(),
+    },
+    {
+        name: "fire_employee",
+        title: "Fire Employee",
+        description: "Let an AI employee go for good: runs stop and actions waiting for approval are discarded; its thread stays readable. The first call only describes what will happen and changes nothing; call again with confirm: true only after the user explicitly agrees — never confirm on the user's behalf. Only the person who hired it or a workspace admin can. No cost to call.",
+        inputSchema: z.object({ employeeId: z.string().describe("Employee id."), confirm: z.boolean().optional() }).strict(),
+    },
+    {
+        name: "list_pending_actions",
+        title: "List Pending Actions",
+        description: "List what AI employees are waiting to do until a human approves: each action has a preview of what will be published, sent or changed. Optionally filter by employeeId. No cost to call.",
+        inputSchema: z.object({ employeeId: z.string().optional().describe("Only this employee's actions."), limit: z.number().int().min(1).max(100).optional() }).strict(),
+    },
+    {
+        name: "approve_action",
+        title: "Approve Action",
+        description: "Approve one pending AI-employee action by actionId. The first call changes nothing and returns a preview and a confirmationToken; show it to the user, and call again with confirm: true and the token only after the user explicitly agrees — never confirm on the user's behalf. The stored action then runs exactly once, and it may publish or send something publicly. Only the hiring user or a workspace admin can. No cost to call.",
+        inputSchema: z.object({ actionId: z.string().describe("Action id from list_pending_actions."), confirm: z.boolean().optional(), confirmationToken: z.string().optional().describe("Token from the first call."), note: z.string().optional().describe("Optional note.") }).strict(),
+    },
+    {
+        name: "reject_action",
+        title: "Reject Action",
+        description: "Reject one pending AI-employee action by actionId, with an optional note the employee can learn from. Only the hiring user or a workspace admin can. No cost to call.",
+        inputSchema: z.object({ actionId: z.string().describe("Action id from list_pending_actions."), note: z.string().optional().describe("Why, so the employee can learn.") }).strict(),
+    },
+    {
+        name: "marketplace_changes",
+        title: "Marketplace Changes",
+        description: "What moved in a category since the run before: products that entered or left a search's results, and ones whose price or place changed. Compared from the two latest stored scans of the same marketplace and `query`, so it fetches nothing and never re-scans — run scan_marketplace_category first, and again later, to have two runs to compare. `new` and `gone` mean entered or left the results, not listed or delisted. A category scanned only once has no earlier run and says so. Free.",
+        inputSchema: z.object({ marketplace: z.string().describe("Which site the scan read."), query: z.string().describe("The category search to compare, exactly as it was scanned."), market: z.string().optional().describe("The storefront the scan read, if the site has several.") }).strict(),
+    },
     {
         name: "get_marketplace_product",
         title: "Get Marketplace Product",

package/dist/shared/tools.js

@@ -23,6 +23,7 @@ import { registerJobTools } from "./jobs.js";
 import { registerBrandWatch } from "./brand-watch.js";
 import { registerOwnAccountTools } from "./own-account.js";
 import { registerConnectionTools } from "./connections.js";
+import { registerEmployeeTools } from "./employees.js";
 import { registerStoreReadTools } from "./store-read.js";
 import { registerGettingStarted, SERVER_INSTRUCTIONS } from "./getting-started.js";
 import { loadingPlansJson } from "./loading-plans.js";
@@ -32,7 +33,7 @@ import { registerAmazonTools } from "./amazon.js";
 import { registerMarketplaceTools } from "./marketplace.js";
 import { DEFAULT_NOOTICR_SETTINGS, DEFAULT_SOCIAL_PLATFORMS, MemorySettingsStore, SETTINGS_READ_TOOL, SETTINGS_UPDATE_TOOL, settingsOwnerFromAuth, } from "./settings.js";
 /** Current MCP server version — bumped on every deploy for traceability. */
-export const MCP_SERVER_VERSION = "1.26.58";
+export const MCP_SERVER_VERSION = "1.26.60";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -2887,6 +2888,8 @@ export function createMcpServer(rawMakeClient, opts) {
     registerBrandWatch(server, makeClient);
     registerOwnAccountTools(server, makeClient);
     registerConnectionTools(server, makeClient);
+    // AI employees (employees.ts): hire, list, pause, fire, and approve or reject what they queue.
+    registerEmployeeTools(server, makeClient);
     // Store connections (store-read.ts): the connect link and the catalogue read.
     registerStoreReadTools(server, makeClient);
     registerGettingStarted(server, makeClient, watchStore);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nooticr/mcp",
   "mcpName": "com.nooticr/mcp",
-  "version": "1.26.58",
+  "version": "1.26.60",
   "description": "MCP server for nooticr - fetch, discover and understand TikTok/Instagram/YouTube/X/Reddit/LinkedIn/Weibo posts with AI (media metadata, niche discovery, brand monitoring, hook & viral analysis)",
   "homepage": "https://mcp.nooticr.com",
   "repository": {