@nooticr/mcp 1.26.67 → 1.26.69

package/README.md

@@ -52,7 +52,7 @@ npx @nooticr/mcp login   # one-time sign-in (Google)
 
 ## Tools
 
-114 tools, grouped by what you are trying to do. Prices are in nooticr credits and
+117 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
@@ -127,8 +127,11 @@ them caps that fan-out with an argument.
 
 | Tool | Credits | What it is for |
 |------|---------|----------------|
-| `answer_my_audience` | 2 + 2 per post opened (14 by default) | **The mirror of `search_mentions`.** The questions waiting under your *own* posts: recent posts fetched, comments read on each, grouped under the post they were left on, every comment with a stable id, and the ones that read like questions or requests flagged and sorted to the top. It finds and drafts — it cannot post a reply. This tool never sends anything; a reply is posted only if you then ask for it, on your connected account, after you confirm the exact text. `limit` caps how many posts are opened, which is the price. |
+| `answer_my_audience` | 2 + 2 per post opened (14 by default) | **The mirror of `search_mentions`.** The questions waiting under your *own* posts: recent posts fetched, comments read on each, grouped under the post they were left on, every comment with a stable id, and the ones that read like questions or requests flagged and sorted to the top. It finds and drafts — it cannot post a reply itself: the drafts are for a person to paste in, or to send through `draft_comment_reply` and `post_comment_reply` once the text is confirmed. `limit` caps how many posts are opened, which is the price. |
 | `prepare_handoff` | free | **The hand-off to your tracker.** Turns items you classified — a bug report in a comment, a complaint said out loud in a video — into the exact `title`, `body` and `labels` to file through whichever GitHub, Jira or Linear MCP server the host also has connected. nooticr files nothing and holds no tracker credential. The body carries the quote fenced and framed as a third-party report rather than as instructions, because the issue is read next by a coding agent; contact details are redacted, `@handles` and `#numbers` are defanged so filing notifies nobody by accident, and a `searchFirst` string dedupes a second sweep against the first. Makes no requests. |
+| `list_comments_to_answer` | free | Recent comments on your *own* connected account that nobody has answered yet, newest first (YouTube once connected with `capabilities: ["manage_comments"]`; other networks come back under `unsupported` with the reason). Read-only. |
+| `draft_comment_reply` | free with `text`, 1 when nooticr writes it | Stores a reply to one comment; nothing is posted. Returns a `draftId` and a `confirmationToken` to show the user first. |
+| `post_comment_reply` | free | Posts a stored draft as your own account. Needs the `draftId`, `confirm: true` and the `confirmationToken`, and only after the user has agreed to the exact text. Each comment is answered at most once. |
 | `show_audience_replies` | free | Lays your drafts out for a person to work through, grouped under the post, each with what you decided to do about it. Sends nothing; fetches nothing. |
 | `show_standings` | free | Draws the standings your model read out of `compare_creators` or `watchlist_standings` — one row per creator, with the window and the median it was scored against. `ranking` records which axis you ordered on, and `tooThin` draws a creator with too short a window as unranked rather than last: missing from a comparison is not the same as losing it. Makes no requests. |
 | `show_trend` | free | Draws the trend your model read out of `mention_trend`. `tooShort` marks a series with too few points to call a direction, and `edgeIsRecordStart` marks a left edge that is where the record begins rather than where the conversation did — a chart hiding either is the mistake this view could otherwise make on your behalf. Makes no requests. |
@@ -194,7 +197,7 @@ a `scanId` for the rest.
 | `get_tool_run` | free | One run from that history by id, with its full error. |
 | `get_usage_report` | free | The run ledger added up over a window: total calls, failures and credits actually taken, per tool, per day and the most recent failures. `scope: "workspace"` adds one row per seat, for the workspace's owners and admins. |
 | `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. |
+| `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; this tool posts nothing; a reply goes out only through `post_comment_reply`, on a draft the user confirmed. 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. |

package/dist/shared/connections.js

@@ -45,8 +45,9 @@ export function registerConnectionTools(server, makeClient) {
             "no, or unknown; unknown means the grant predates scope recording, so treat it as \"try " +
             "it\", not as a refusal. Also returns which platforms can be connected at all, which is a " +
             "smaller set than the networks nooticr can read. \"Manage comments\" reports what the " +
-            "platform granted, not something nooticr does: no nooticr tool posts, replies to or " +
-            "moderates a comment, so a yes there never means a drafted reply will be sent. Call this " +
+            "platform granted, not something this tool does: this tool posts nothing, and a yes there " +
+            "never means a drafted reply will be sent by itself. A reply goes out only through " +
+            "post_comment_reply, on a draft the user confirmed. Call this " +
             "before promising that something can be posted or replied to. No cost to call.",
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         inputSchema: z.object({}).strict(),

package/dist/shared/jobs.js

@@ -799,8 +799,8 @@ export function registerJobTools(server, makeClient, store) {
             postsChecked: threads.length,
             // Stated in the payload as well as the prose, because a model that
             // believes it can send will promise the user something that cannot
-            // happen. Some grants do allow managing comments (#29); nooticr has no
-            // send path whatever the grant says.
+            // happen. This payload comes from the drafting tools, which never post;
+            // only post_comment_reply sends, and only a confirmed draft.
             repliesCanBeSent: false,
             totalMentions: totalComments,
             totalThreads: threads.length,

package/dist/shared/loading-plans.js

@@ -537,6 +537,15 @@ export const LOADING_PLANS = {
     list_watchlist: { label: "Reading your watchlist", kind: "text", n: 1, steps: [], free: true },
     list_social_connections: { label: "Reading your connections", kind: "list", n: 3, steps: [], free: true },
     connect_social_account: { label: "Minting a fresh link", kind: "text", n: 1, steps: [], free: true },
+    list_comments_to_answer: { label: "Reading the comments waiting for a reply", kind: "list", n: 5, steps: [], free: true },
+    // Free when the caller passes `text`; 1 credit when the server writes the reply.
+    draft_comment_reply: {
+        label: "Drafting the reply",
+        kind: "text",
+        n: 1,
+        steps: [{ via: "draft_comment_reply", label: "Writing the reply", detail: "Free when you pass the text yourself", credits: 1 }],
+    },
+    post_comment_reply: { label: "Posting the reply", kind: "text", n: 1, steps: [], free: true },
     create_product: { label: "Writing the row", kind: "text", n: 1, steps: [], free: true },
     update_product: { label: "Patching the row", kind: "text", n: 1, steps: [], free: true },
 };

package/dist/shared/output-schemas.js

@@ -640,8 +640,9 @@ export const OUTPUT_SCHEMAS = {
         since: scalar().describe("The date window asked for, if any."),
         sinceApplied: scalar().describe("False when the platform returned no dates, so the window could not be honoured."),
         postsChecked: scalar().describe("Posts whose comments were actually read."),
-        repliesCanBeSent: scalar().describe("Always false. This tool only drafts and never sends; a reply is posted only by a separate step, " +
-            "on the user's connected account, after the user confirms the exact text."),
+        repliesCanBeSent: scalar().describe("Always false: answer_my_audience posts nothing, so the drafts this produces are for a person to " +
+            "paste in themselves, or to send through draft_comment_reply and post_comment_reply after " +
+            "confirming the text."),
         totalMentions: scalar().describe("Comments returned across every group."),
         totalThreads: scalar(),
         wantsReplyCount: scalar().describe("How many carry a reply signal. A sort, not a verdict."),
@@ -1696,6 +1697,39 @@ export const OUTPUT_SCHEMAS = {
         connections: listOf(anyObject()),
         message: scalar(),
     }),
+    list_comments_to_answer: open({
+        account: open({
+            platform: scalar(),
+            username: scalar(),
+            influencerId: scalar(),
+            canManageComments: scalar(),
+            manageCommentsStatus: scalar(),
+        }).nullish(),
+        comments: listOf(open({})),
+        unsupported: listOf(open({ platform: scalar(), reason: scalar() })),
+        note: scalar(),
+        message: scalar(),
+    }),
+    draft_comment_reply: open({
+        draftId: scalar(),
+        reply: scalar().describe("The stored reply text. Show it to the user before posting."),
+        comment: open({ author: scalar(), snippet: scalar() }).nullish(),
+        postUrl: scalar(),
+        status: scalar(),
+        expiresInSeconds: scalar(),
+        confirmationToken: scalar().describe("Pass to post_comment_reply with confirm: true after the user agrees."),
+        rejected: scalar(),
+        instructions: scalar(),
+        mcpCredits: open({ cost: scalar(), balance: scalar() }).nullish(),
+    }),
+    post_comment_reply: open({
+        posted: scalar(),
+        alreadyPosted: scalar(),
+        draftId: scalar(),
+        platformReplyId: scalar(),
+        url: scalar(),
+        postedAt: scalar(),
+    }),
     // Marketplace. One shape for all three collection tools: a status poll
     // returns exactly what the scan that started it returns, and a single
     // product is a scan of one — describing them differently would be three

package/dist/shared/replies.js

@@ -0,0 +1,113 @@
+/**
+ * Replying to comments on the user's own posts (nooticr-server R1).
+ *
+ * Three tools, in the order a reply travels: list what is waiting, draft one
+ * reply (stored, nothing sent), post it. The first two never write to a
+ * network. `post_comment_reply` does, as the user's own account, so it needs
+ * the exact draft the user saw: the draftId, `confirm: true` and the
+ * confirmationToken that `draft_comment_reply` returned. The server enforces
+ * that; the schema here requires all three so a model cannot omit one.
+ *
+ * Thin passthroughs, like connections.ts: the server owns the rules.
+ */
+import { z } from "zod";
+import { OUTPUT_SCHEMAS } from "./output-schemas.js";
+function toResult(proxy) {
+    const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
+    return {
+        content: textBlock ? [{ type: "text", text: String(textBlock.text ?? "") }] : [],
+        structuredContent: proxy.structured,
+    };
+}
+function failed(prefix, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+        content: [{ type: "text", text: `${prefix}: ${msg}` }],
+        isError: true,
+    };
+}
+const platform = z.enum(["youtube", "instagram"]);
+export function registerReplyTools(server, makeClient) {
+    server.registerTool("list_comments_to_answer", {
+        title: "List Comments To Answer",
+        description: "List recent comments on the user's own connected account that nobody has answered yet, " +
+            "newest first. Only the user's own posts, through their own connection: YouTube works once " +
+            "connected with capabilities: [\"manage_comments\"] (see connect_social_account); networks " +
+            "that cannot be answered come back under `unsupported` with the reason. Optional platform, " +
+            "influencerId, postId, sinceDays (1-30, default 7), limit (1-100, default 30), " +
+            "includeAnswered. Read-only: it sends nothing. No cost to call.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        outputSchema: OUTPUT_SCHEMAS.list_comments_to_answer,
+        inputSchema: z
+            .object({
+            platform: platform.optional().describe("Only this network."),
+            influencerId: z.number().int().optional().describe("Creator profile id when more than one account is connected."),
+            postId: z.string().optional().describe("Only comments on this video/media id."),
+            sinceDays: z.number().int().min(1).max(30).optional().describe("How far back to look (default 7)."),
+            limit: z.number().int().min(1).max(100).optional().describe("Most comments to return (default 30)."),
+            includeAnswered: z.boolean().optional().describe("Also list comments that already have a reply."),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        try {
+            return toResult(await client.callTool("list_comments_to_answer", args));
+        }
+        catch (err) {
+            return failed("list_comments_to_answer failed", err);
+        }
+    });
+    server.registerTool("draft_comment_reply", {
+        title: "Draft Comment Reply",
+        description: "Draft a reply to one comment from list_comments_to_answer and store it; nothing is " +
+            "posted. Pass `text` to use the user's own wording (no cost), or omit it and nooticr " +
+            "writes one (costs 1 nooticr credit); `guidance` steers the writing. Replies may not contain links, " +
+            "emails, phone numbers or @-mentions of anyone but the commenter. Returns a draftId and a " +
+            "confirmationToken: show the reply to the user first, then post it with post_comment_reply.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        outputSchema: OUTPUT_SCHEMAS.draft_comment_reply,
+        inputSchema: z
+            .object({
+            platform: platform.describe("The network the comment is on."),
+            commentId: z.string().describe("Comment id from list_comments_to_answer."),
+            postId: z.string().describe("Post id the comment is on."),
+            text: z.string().optional().describe("The reply to store, in the user's words. Omit to have one written (1 credit)."),
+            influencerId: z.number().int().optional().describe("Creator profile id when more than one account is connected."),
+            guidance: z.string().optional().describe("What the reply should say or avoid; a URL here is the only URL the reply may contain."),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        try {
+            return toResult(await client.callTool("draft_comment_reply", args));
+        }
+        catch (err) {
+            return failed("draft_comment_reply failed", err);
+        }
+    });
+    server.registerTool("post_comment_reply", {
+        title: "Post Comment Reply",
+        description: "Post a stored reply draft to the comment, as the user's own account. Only after the user " +
+            "has seen and agreed to the exact text: pass the draftId, confirm: true and the " +
+            "confirmationToken from draft_comment_reply. Each comment is answered at most once and " +
+            "daily limits apply. It writes to a third-party network and cannot be undone from here. " +
+            "No cost to call.",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+        outputSchema: OUTPUT_SCHEMAS.post_comment_reply,
+        inputSchema: z
+            .object({
+            draftId: z.string().describe("Draft id from draft_comment_reply."),
+            confirm: z.boolean().describe("true only once the user has agreed to the exact text."),
+            confirmationToken: z.string().describe("Token returned with the draft."),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        try {
+            return toResult(await client.callTool("post_comment_reply", args));
+        }
+        catch (err) {
+            return failed("post_comment_reply failed", err);
+        }
+    });
+}

package/dist/shared/sheets.js

@@ -68,7 +68,11 @@ export function registerSheetsTools(server, makeClient) {
     server.registerTool("sheets_read", {
         title: "Read Spreadsheet Range",
         description: 'Read a range (A1 notation, e.g. "Ledger!A1:F200") of a spreadsheet. ' +
-            "Numbers come back as numbers and dates as formatted text; at most 10000 cells. Free.",
+            "Numbers come back as numbers and dates as formatted text; at most 10000 cells, " +
+            'and a range open at the bottom ("A:F", "Ledger!$A:$F") or longer than the cap is cut to the rows that fit, ' +
+            "with truncated=true when more may remain: read further down with a range that starts after the last row. " +
+            'A bare name without quotes ("Expenses") is passed to Google as written, since it may be a named range, ' +
+            'so name a tab as "Ledger!A:F" or "\'My Tab\'" to have it bounded. Free.',
         annotations: READ,
         inputSchema: z.object({ appId, id: spreadsheetId, range: z.string() }).strict(),
         outputSchema: OUTPUT_SCHEMAS.sheets_read,

package/dist/shared/tools-def.js

@@ -327,7 +327,7 @@ export const TOOL_DEFINITIONS = [
     {
         name: "sheets_read",
         title: "Read Spreadsheet Range",
-        description: "Read a range (A1 notation, e.g. \"Ledger!A1:F200\") of a spreadsheet. Numbers come back as numbers and dates as formatted text; at most 10000 cells. Free.",
+        description: "Read a range (A1 notation, e.g. \"Ledger!A1:F200\") of a spreadsheet. Numbers come back as numbers and dates as formatted text; at most 10000 cells, and a range open at the bottom (\"A:F\", \"Ledger!$A:$F\") or longer than the cap is cut to the rows that fit, with truncated=true when more may remain: read further down with a range that starts after the last row. A bare name without quotes (\"Expenses\") is passed to Google as written, since it may be a named range, so name a tab as \"Ledger!A:F\" or \"'My Tab'\" to have it bounded. Free.",
         inputSchema: z.object({ appId: z.number().int().optional().describe("Product id; optional when the workspace has one product."), id: z.string().describe("Spreadsheet id from sheets_create or sheets_list."), range: z.string() }).strict(),
     },
     {
@@ -477,7 +477,7 @@ export const TOOL_DEFINITIONS = [
     {
         name: "list_social_connections",
         title: "List Social Connections",
-        description: "List the social accounts your workspace has connected and what each connection is allowed to do — read the account, publish a post, manage comments. Manage comments reports the grant; no nooticr tool posts or replies to a comment. Also returns which platforms can be connected at all. No cost to call.",
+        description: "List the social accounts your workspace has connected and what each connection is allowed to do — read the account, publish a post, manage comments. Manage comments reports the grant; this tool posts nothing, and a reply goes out only through post_comment_reply on a draft the user confirmed. Also returns which platforms can be connected at all. No cost to call.",
         inputSchema: z.object({}).strict(),
     },
     {
@@ -486,6 +486,24 @@ export const TOOL_DEFINITIONS = [
         description: "Get a link to open so you can connect one social account. The user approves at the provider; nothing is connected until they do, and no credential ever passes through this tool. For YouTube, pass capabilities [\"manage_comments\"] to also ask for the comment-management grant. No cost to call.",
         inputSchema: z.object({ platform: z.string().describe("Which network to connect."), influencerId: z.number().int().optional(), appId: z.number().int().optional(), capabilities: z.array(z.enum(["manage_comments"])).optional().describe("YouTube only: [\"manage_comments\"] asks for the comment-management grant.") }).strict(),
     },
+    {
+        name: "list_comments_to_answer",
+        title: "List Comments To Answer",
+        description: "List recent comments on the user's own connected account that nobody has answered yet, newest first. Only the user's own posts, through their own connection: YouTube works once connected with capabilities: [\"manage_comments\"] (see connect_social_account); networks that cannot be answered come back under `unsupported` with the reason. Optional platform, influencerId, postId, sinceDays (1-30, default 7), limit (1-100, default 30), includeAnswered. Read-only: it sends nothing. No cost to call.",
+        inputSchema: z.object({ platform: z.enum(["youtube", "instagram"]).optional().describe("Only this network."), influencerId: z.number().int().optional().describe("Creator profile id when more than one account is connected."), postId: z.string().optional().describe("Only comments on this video/media id."), sinceDays: z.number().int().min(1).max(30).optional().describe("How far back to look (default 7)."), limit: z.number().int().min(1).max(100).optional().describe("Most comments to return (default 30)."), includeAnswered: z.boolean().optional().describe("Also list comments that already have a reply.") }).strict(),
+    },
+    {
+        name: "draft_comment_reply",
+        title: "Draft Comment Reply",
+        description: "Draft a reply to one comment from list_comments_to_answer and store it; nothing is posted. Pass `text` to use the user's own wording (no cost), or omit it and nooticr writes one (costs 1 nooticr credit); `guidance` steers the writing. Replies may not contain links, emails, phone numbers or @-mentions of anyone but the commenter. Returns a draftId and a confirmationToken: show the reply to the user first, then post it with post_comment_reply.",
+        inputSchema: z.object({ platform: z.enum(["youtube", "instagram"]).describe("The network the comment is on."), commentId: z.string().describe("Comment id from list_comments_to_answer."), postId: z.string().describe("Post id the comment is on."), text: z.string().optional().describe("The reply to store, in the user's words. Omit to have one written (1 credit)."), influencerId: z.number().int().optional().describe("Creator profile id when more than one account is connected."), guidance: z.string().optional().describe("What the reply should say or avoid; a URL here is the only URL the reply may contain.") }).strict(),
+    },
+    {
+        name: "post_comment_reply",
+        title: "Post Comment Reply",
+        description: "Post a stored reply draft to the comment, as the user's own account. Only after the user has seen and agreed to the exact text: pass the draftId, confirm: true and the confirmationToken from draft_comment_reply. Each comment is answered at most once and daily limits apply. It writes to a third-party network and cannot be undone from here. No cost to call.",
+        inputSchema: z.object({ draftId: z.string().describe("Draft id from draft_comment_reply."), confirm: z.boolean().describe("true only once the user has agreed to the exact text."), confirmationToken: z.string().describe("Token returned with the draft.") }).strict(),
+    },
     {
         name: "connect_store",
         title: "Connect Store",
@@ -501,7 +519,7 @@ export const TOOL_DEFINITIONS = [
     {
         name: "answer_my_audience",
         title: "Answer My Audience",
-        description: "The questions waiting for you under your own posts. Fetches a creator's recent posts, reads the comments on each, and returns them grouped under the post they were left on \u2014 every comment with a stable id, and the ones that read like questions or requests flagged and sorted to the top. Finds and drafts; this tool cannot post a reply \u2014 a reply is posted only after the user confirms its exact text. Use when the job is to answer your own audience rather than to read about strangers. Consumes 2 nooticr credits for the post list plus 2 per post opened \u2014 14 credits at the default of 6 posts.",
+        description: "The questions waiting for you under your own posts. Fetches a creator's recent posts, reads the comments on each, and returns them grouped under the post they were left on \u2014 every comment with a stable id, and the ones that read like questions or requests flagged and sorted to the top. Finds and drafts; it cannot post a reply \u2014 the drafts are for a person to paste in themselves, or to send through draft_comment_reply and post_comment_reply once the user has confirmed the text. Use when the job is to answer your own audience rather than to read about strangers. Consumes 2 nooticr credits for the post list plus 2 per post opened \u2014 14 credits at the default of 6 posts.",
         inputSchema: z.object({ username: z.string().describe("Your handle, with or without @."), platform: z.string().optional().describe("Platform (default tiktok)."), limit: z.number().int().optional().describe("Posts to open (default 6, max 12). Each one is a comment fetch, so this is the price."), commentsPerPost: z.number().int().optional().describe("Comments to read per post (default 20, max 50)."), since: z.string().optional().describe("Only posts published on or after this date, as YYYY-MM-DD. Windows the posts, not the comments.") }).strict(),
     },
     {

package/dist/shared/tools.js

@@ -25,6 +25,7 @@ import { registerCreativeTools } from "./creative.js";
 import { registerSheetsTools } from "./sheets.js";
 import { registerOwnAccountTools } from "./own-account.js";
 import { registerConnectionTools } from "./connections.js";
+import { registerReplyTools } from "./replies.js";
 import { registerEmployeeTools } from "./employees.js";
 import { registerStoreReadTools } from "./store-read.js";
 import { registerGettingStarted, SERVER_INSTRUCTIONS } from "./getting-started.js";
@@ -35,7 +36,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.67";
+export const MCP_SERVER_VERSION = "1.26.69";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -2894,6 +2895,7 @@ export function createMcpServer(rawMakeClient, opts) {
     // Google Sheets (sheets.ts): the sheets_* family of nooticr-server BK2.
     registerSheetsTools(server, makeClient);
     registerConnectionTools(server, makeClient);
+    registerReplyTools(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.

package/dist/shared/ui-template.js

@@ -4411,7 +4411,7 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
           +'<div class="nt-commerce-chiprow">'+readOnly.map(function(k){
             return '<span class="nt-tag nt-commerce-nettag tag">'+glyph(k,12)+esc(pTitle(k))+"</span>";}).join("")+"</div>"
           +'<p class="nt-commerce-conn-sub" style="margin-top:8px">So "monitor my brand on Weibo" works and "reply to that Weibo comment" cannot — '
-          +"replies are never sent on their own: one is posted only after you confirm its exact text.</p></div>":""),
+          +"replies go out only through post_comment_reply, on a draft you confirmed, and only where a connection allows managing comments.</p></div>":""),
       footer:'<span class="ai-note">Each press mints a fresh link — an old one does not work twice. Approve in your own browser; nothing is connected until you do.</span>'});
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nooticr/mcp",
   "mcpName": "com.nooticr/mcp",
-  "version": "1.26.67",
+  "version": "1.26.69",
   "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": {