@nooticr/mcp 1.26.29 → 1.26.31

package/dist/shared/brand-watch.js

@@ -13,6 +13,7 @@
  * rather than a build.
  */
 import { z } from "zod";
+import { withEvidence } from "./evidence-digest.js";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
 import { viewMeta } from "./view-meta.js";
 import { BACKEND_CALL_CREDITS, confirmSpend, declinedResult, searchMentionsCost } from "./spend.js";
@@ -268,9 +269,17 @@ function trendGuidance(sc, runs) {
 }
 function toResult(proxy) {
     const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
+    const structured = proxy.structured;
+    // The backend's text block is a one-line summary — "1 active brand watch."
+    // — and the watches themselves are in `structuredContent`, which a host
+    // rendering the view keeps for the widget. A model asked which watch to stop
+    // could see the count and not the terms (#59).
+    const text = String(textBlock?.text ?? "");
     return {
-        content: textBlock ? [{ type: "text", text: String(textBlock.text ?? "") }] : [],
-        structuredContent: proxy.structured,
+        content: [
+            { type: "text", text: structured ? withEvidence(text, structured) : text },
+        ],
+        structuredContent: structured,
     };
 }
 function failed(prefix, err) {
@@ -468,10 +477,17 @@ export function registerBrandWatch(server, makeClient) {
             // model reading two points as a trend, and reading the start of the
             // retention window as the moment a conversation began.
             const guidance = trendGuidance(sc, runs);
+            const payload = { guidance, ...sc };
             return {
                 ...result,
-                content: [{ type: "text", text: guidance }],
-                structuredContent: { guidance, ...sc },
+                // "8 runs of X, newest first" with the runs in the other channel is
+                // the same deictic failure as everywhere else (#59): a host that
+                // renders the view keeps `structuredContent` for the widget, and the
+                // model is left counting runs it cannot read.
+                content: [
+                    { type: "text", text: withEvidence(guidance, payload) },
+                ],
+                structuredContent: payload,
             };
         }
         catch (err) {

package/dist/shared/evidence-digest.js

@@ -0,0 +1,269 @@
+/**
+ * A compact rendering of a payload's evidence, for the channel that gets the
+ * text blocks.
+ *
+ * ## Why this exists
+ *
+ * There are two channels out of a tool call and no host delivers both to the
+ * model:
+ *
+ * | | `content` text blocks | `structuredContent` |
+ * |---|---|---|
+ * | Claude Code | dropped when `structuredContent` is present | delivered, serialised |
+ * | Claude.ai, tool with a UI view | delivered | routed to the widget |
+ *
+ * #44 found the first column and #51 fixed it, by writing the guidance into
+ * both channels. The evidence never got the same treatment, so it survived
+ * Claude Code and vanished on Claude.ai — where a real session received
+ * "3 posts that might be someone describing ...", instructions to quote lines
+ * from them and report their permalinks, and not one post (#59).
+ *
+ * The tools most affected were the composed ones, which replace the backend's
+ * text block with their own guidance. That guidance is deictic — "Here are 4
+ * comments", "2 creators", "8 runs" — so it counts and describes material that
+ * is somewhere else. "Here are 4 comments" is a false sentence in the channel
+ * it is written in.
+ *
+ * So: each channel has to be self-sufficient. This renders the evidence for
+ * the text one.
+ *
+ * ## What it is not
+ *
+ * Not the serialised payload. A model asked to judge posts needs the caption,
+ * the handle and the link; it does not need `engagementRate` to four decimal
+ * places, and 14 KB of JSON in a text block crowds out the guidance that says
+ * what to do with it. Each shape below renders the fields its guidance
+ * actually names.
+ */
+/** Per-item text budget. Long enough for a real Reddit complaint, short enough that twenty fit. */
+const ITEM_CHARS = 600;
+/**
+ * Whole-digest budget.
+ *
+ * `answer_my_audience` can carry 14 KB of payload. The cap is what keeps a
+ * text block readable rather than a second serialisation of it — and when it
+ * bites, the digest says so, because a model reasoning over 20 of 60 comments
+ * has to know it has 20.
+ */
+const DIGEST_CHARS = 6000;
+/** How many items of one kind are worth rendering before the count matters more than the detail. */
+const MAX_ITEMS = 25;
+const str = (v) => (typeof v === "string" ? v : "");
+const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+function clamp(text, max = ITEM_CHARS) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+/** `12.3k`, because a raw 12345 beside four other numbers is harder to read than it looks. */
+function compactCount(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}k`;
+    return String(n);
+}
+function stats(row) {
+    const parts = [];
+    const views = num(row.views);
+    const likes = num(row.likes);
+    const comments = num(row.comments);
+    if (views)
+        parts.push(`${compactCount(views)} views`);
+    if (likes)
+        parts.push(`${compactCount(likes)} likes`);
+    if (comments)
+        parts.push(`${compactCount(comments)} comments`);
+    return parts.join(", ");
+}
+/**
+ * One post, as a line a model can cite.
+ *
+ * `externalUrl` is not decoration: `find_people_with_problem`'s guidance asks
+ * for qualifying posts to be reported "with their permalink, so they can
+ * actually be replied to". A digest without links cannot answer that.
+ */
+function postLine(row) {
+    const head = [
+        str(row.platform) || null,
+        str(row.creatorHandle) ? `@${str(row.creatorHandle)}` : null,
+        str(row.subreddit) || null,
+        str(row.foundBy) ? `found by: ${str(row.foundBy)}` : null,
+        stats(row) || null,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    const text = clamp(str(row.caption) || str(row.title) || str(row.text));
+    const url = str(row.externalUrl) || str(row.url);
+    return [head && `[${head}]`, text, url].filter(Boolean).join("\n  ");
+}
+/**
+ * One comment, with its id.
+ *
+ * The id is the load-bearing field: `analyze_comments` asks for a
+ * classification per comment and `show_comment_review` takes those ids back.
+ * A digest that renders the text and drops the id breaks the next call.
+ */
+function commentLine(row) {
+    const id = str(row.id);
+    const who = str(row.author) || str(row.username);
+    const likes = num(row.likes);
+    const head = [id || null, who ? `@${who}` : null, likes ? `${compactCount(likes)} likes` : null]
+        .filter(Boolean)
+        .join(" · ");
+    return [head && `[${head}]`, clamp(str(row.text) || str(row.comment))].filter(Boolean).join("\n  ");
+}
+function creatorLine(row) {
+    const head = [
+        str(row.username) ? `@${str(row.username)}` : str(row.handle) ? `@${str(row.handle)}` : null,
+        str(row.platform) || null,
+        num(row.followers) ? `${compactCount(num(row.followers))} followers` : null,
+        str(row.foundBy) ? `found by: ${str(row.foundBy)}` : null,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    const why = clamp(str(row.why) || str(row.bio) || str(row.verdict));
+    const links = Array.isArray(row.links)
+        ? row.links
+            .map((l) => str(l.url))
+            .filter(Boolean)
+            .slice(0, 3)
+            .join(" ")
+        : "";
+    return [head && `[${head}]`, why, links].filter(Boolean).join("\n  ");
+}
+function runLine(row) {
+    const when = str(row.ranAt).slice(0, 10);
+    const found = num(row.found);
+    const reported = num(row.reported);
+    return `${when || "(undated)"} · found ${found ?? "?"} · reported ${reported ?? "?"}`;
+}
+/** Everything with no shape of its own: the short scalar fields, in order. */
+function genericLine(row) {
+    const pairs = Object.entries(row)
+        .filter(([, v]) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+        .map(([k, v]) => `${k}: ${clamp(String(v), 160)}`)
+        .slice(0, 8);
+    return pairs.join(" · ");
+}
+/**
+ * The evidence keys worth rendering, and how.
+ *
+ * Ordered: when a payload carries several, the first is the one the guidance
+ * is most likely to be about.
+ */
+const SHAPES = [
+    { key: "posts", label: "post", line: postLine },
+    // The baseline a post is scored against, and the asks a niche sweep found.
+    // Both are posts in all but name, and both are the material their tool's
+    // guidance reasons over — `why_did_this_underperform` cannot say "this is an
+    // ordinary result" without the distribution it is ordinary against.
+    { key: "window", label: "post in the baseline window", line: postLine },
+    { key: "demand", label: "thing the audience asked for", line: postLine },
+    { key: "supply", label: "post already serving it", line: postLine },
+    { key: "comments", label: "comment", line: commentLine },
+    { key: "replies", label: "reply", line: commentLine },
+    { key: "mentions", label: "mention", line: commentLine },
+    { key: "creators", label: "creator", line: creatorLine },
+    { key: "candidates", label: "candidate", line: creatorLine },
+    { key: "runs", label: "run", line: runLine },
+    { key: "cues", label: "line", line: genericLine },
+    { key: "segments", label: "segment", line: genericLine },
+    { key: "hashtags", label: "hashtag", line: genericLine },
+    { key: "sounds", label: "sound", line: genericLine },
+    { key: "watches", label: "watch", line: genericLine },
+    { key: "apps", label: "app", line: genericLine },
+    { key: "connections", label: "connection", line: genericLine },
+    { key: "unavailable", label: "network that could not be searched", line: genericLine },
+];
+/**
+ * Render whatever evidence a payload carries, or "" when it carries none.
+ *
+ * Returning "" rather than a placeholder matters: a tool whose result is a
+ * verdict rather than material (`show_*`, a state mutation) should get its
+ * guidance and nothing appended.
+ */
+/** Fields that identify a row — the ones a caller would cite it by. */
+const IDENTIFYING = [
+    "id",
+    "externalUrl",
+    "url",
+    "permalink",
+    "caption",
+    "text",
+    "title",
+    "username",
+    "handle",
+    "creatorHandle",
+    "name",
+    "term",
+    "appId",
+    "ranAt",
+    "tag",
+];
+/**
+ * Any array of objects the named shapes did not claim.
+ *
+ * A hand-maintained list of keys is exactly the artefact that drifts — a tool
+ * adds `window` or `demand`, nobody updates the list, and the material goes
+ * missing again with every test still green. So anything that looks like a row
+ * with an identity gets rendered, well or plainly, rather than dropped.
+ */
+function unclaimedShapes(payload) {
+    const named = new Set(SHAPES.map((s) => s.key));
+    return Object.entries(payload)
+        .filter(([key, rows]) => {
+        if (named.has(key) || !Array.isArray(rows) || rows.length === 0)
+            return false;
+        const first = rows.find((r) => r && typeof r === "object");
+        if (!first)
+            return false;
+        return IDENTIFYING.some((f) => {
+            const v = first[f];
+            return typeof v === "string" || typeof v === "number";
+        });
+    })
+        .map(([key]) => ({ key, label: key.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase(), line: genericLine }));
+}
+export function evidenceDigest(payload) {
+    const blocks = [];
+    let spent = 0;
+    for (const shape of [...SHAPES, ...unclaimedShapes(payload)]) {
+        const rows = payload[shape.key];
+        if (!Array.isArray(rows) || rows.length === 0)
+            continue;
+        if (spent >= DIGEST_CHARS)
+            break;
+        const shown = [];
+        for (const row of rows.slice(0, MAX_ITEMS)) {
+            if (spent >= DIGEST_CHARS)
+                break;
+            const line = shape.line((row ?? {}));
+            if (!line.trim())
+                continue;
+            shown.push(line);
+            spent += line.length;
+        }
+        if (!shown.length)
+            continue;
+        // Say what was left out. A model reasoning over 20 of 60 has to know it
+        // has 20 — a digest that silently truncates turns "here is everything" into
+        // a claim the caller cannot check.
+        const total = rows.length;
+        const plural = total === 1 || shape.label.endsWith("s") ? shape.label : `${shape.label}s`;
+        const header = shown.length < total
+            ? `${shown.length} of ${total} ${plural} (the rest are in the structured payload and in the view):`
+            : `${total} ${plural}:`;
+        blocks.push([header, ...shown.map((l, i) => `${i + 1}. ${l}`)].join("\n"));
+    }
+    return blocks.join("\n\n");
+}
+/**
+ * Guidance and evidence in one text block, in the order a reader needs them.
+ *
+ * Guidance first: it is the instruction, and a model that reads the material
+ * before knowing what it is for reads it twice.
+ */
+export function withEvidence(guidance, payload) {
+    const digest = evidenceDigest(payload);
+    return digest ? `${guidance}\n\n---\n\n${digest}` : guidance;
+}

package/dist/shared/evidence.js

@@ -563,3 +563,56 @@ export function fetchBillingNote(tool) {
         "not charge again: the idempotency key is namespaced per tool, so a retry replays the " +
         "same debits.");
 }
+/**
+ * The searchable core of a complaint, with the speaker stripped out.
+ *
+ * `find_people_with_problem` widens a problem into the shapes a complaint
+ * takes. Those shapes were templated onto the raw argument, and the argument
+ * the schema asks for is a full sentence with a subject ("I waste an hour a
+ * day checking what competitors posted") — so "is there a way to " + that
+ * produced a string nobody has ever written, and sent it to a keyword search
+ * (#60).
+ *
+ * Two things happen here, and neither is intent matching — the backend is a
+ * keyword search and this does not pretend otherwise:
+ *
+ *  - The first-person subject and its auxiliary come off the front of each
+ *    clause. "I'm out of content ideas" is a sentence about a speaker;
+ *    "out of content ideas" is what the post being looked for actually says.
+ *  - The result is capped, because a long sentence matches on its commonest
+ *    words. That is the tool's own advice to its caller, and it was not
+ *    taking it.
+ *
+ * A caller who can do better should: `queries` overrides all of this.
+ */
+export function complaintCore(problem) {
+    const MAX_WORDS = 12;
+    // The pronoun always goes. The verb after it goes ONLY if it is an
+    // auxiliary — "I have no idea" is about a speaker, but "I waste an hour a
+    // day" carries "waste", and stripping it leaves "an hour a day checking",
+    // which is a worse search than the one being fixed. That distinction is the
+    // whole of this function; getting it wrong trades one bad query for another.
+    const SUBJECT = /^\s*(?:i|we)\b['’]?(?:m\b)?[\s,]*/i;
+    const AUXILIARY = /^\s*(?:am|are|is|was|were|have|has|had|do|does|did|don['’]?t|can['’]?t|cannot|been)\b[\s,]*/i;
+    // Never end on a word that was pointing at the one the cap removed.
+    const DANGLING = /(?:\s+(?:for|my|our|the|a|an|of|to|and|or|with|in|on|at|by|that|this))+$/i;
+    const cleaned = problem
+        .split(/[,;]+/)
+        .map((clause) => {
+        const withoutSubject = clause.trim().replace(SUBJECT, "");
+        // Only strip an auxiliary that actually followed a subject, so a clause
+        // opening with a real verb keeps it.
+        return (withoutSubject === clause.trim()
+            ? withoutSubject
+            : withoutSubject.replace(AUXILIARY, "")).trim();
+    })
+        .filter(Boolean)
+        .join(", ");
+    const words = (cleaned || problem.trim()).split(/\s+/).filter(Boolean);
+    return words
+        .slice(0, MAX_WORDS)
+        .join(" ")
+        .replace(/[,;]+$/, "")
+        .replace(DANGLING, "")
+        .trim();
+}

package/dist/shared/jobs.js

@@ -56,7 +56,8 @@
 import { z } from "zod";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
 import { platformFromUrl, postSlug } from "./comment-review.js";
-import { clamp, handleMissGuidance, ownIt, PLATFORM_ARG } from "./evidence.js";
+import { clamp, complaintCore, handleMissGuidance, ownIt, PLATFORM_ARG } from "./evidence.js";
+import { withEvidence } from "./evidence-digest.js";
 import { confirmSpend, costOf, declinedResult, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, SPOKEN_PLATFORMS, CREDITS_PER_CREATOR, } from "./spend.js";
 import { distributionOf, excluding, numberOf, standing, } from "./performance.js";
 import { normaliseHandle, watchEntryId, watchlistOwner } from "./watchlist.js";
@@ -596,14 +597,21 @@ const metricArg = z
     .optional()
     .describe("Which stat to rank on (default views).");
 export function registerJobTools(server, makeClient, store) {
-    /** Guidance in the text block, evidence in the structured one — as every tool here does. */
-    // Both channels, because only one of them arrives. A host that renders
-    // `structuredContent` replaces the content text blocks with the serialised
-    // JSON, so guidance kept only in a text block reaches no model — measured at
-    // 0 phrases across 175 tool results. See tools.ts's runEvidence for the full
-    // note, and docs/testing/tool-chaining-quests.md for the measurement.
+    /** Guidance AND evidence in both channels, because no host delivers both. */
+    // Neither channel is safe on its own, and which one is dropped depends on
+    // the host: Claude Code discards every `content` text block when a result
+    // carries `structuredContent` (#44, measured at 0 guidance phrases across
+    // 175 tool results), while Claude.ai routes `structuredContent` to the
+    // widget and hands the model only the text blocks (#59).
+    //
+    // #51 made the guidance survive both. The evidence did not, so a real
+    // session got "3 posts that might be someone describing ...", instructions
+    // to quote lines from them, and no posts. The guidance these tools write is
+    // deictic — it counts and describes material that used to be somewhere
+    // else — so `withEvidence` puts a rendering of that material in the same
+    // block as the sentence describing it.
     const evidence = (guidance, payload) => ({
-        content: [{ type: "text", text: guidance }],
+        content: [{ type: "text", text: withEvidence(guidance, payload) }],
         structuredContent: { guidance, ...payload },
     });
     const failed = (prefix, err) => ({
@@ -2104,6 +2112,14 @@ export function registerJobTools(server, makeClient, store) {
                 .optional()
                 .describe("Where to look (default reddit). Each one is a separate paid search."),
             limit: z.number().int().optional().describe("Posts per query shape (default 6, max 15)."),
+            queries: z
+                .array(z.string())
+                .optional()
+                .describe("Search these exact phrasings instead of the ones derived from `problem` (max 4). " +
+                "You are better at this than a string template is: write how a person would " +
+                "actually word the complaint on the network being searched — a Reddit title, " +
+                "an X post — and keep each one short, because this is a keyword search and a " +
+                "long sentence matches on its commonest words."),
         })
             .strict(),
     }, async (args, extra) => {
@@ -2115,11 +2131,27 @@ export function registerJobTools(server, makeClient, store) {
         // The shapes a complaint takes, rather than the topic it is about. Kept
         // to three: each is a paid call per platform, and past three they start
         // returning the same posts as each other.
-        const shapes = [
-            { shape: "plain", query: problem },
-            { shape: "shared", query: `anyone else ${problem}` },
-            { shape: "asking", query: `is there a way to ${problem}` },
-        ];
+        //
+        // Built from a stripped core rather than the raw sentence, and the two
+        // non-plain shapes no longer prefix a template onto whatever arrived.
+        // The old `is there a way to ${problem}` assumed a bare verb phrase
+        // while the schema's own example is a full sentence with a subject, so
+        // the documented input produced "is there a way to I have no idea what
+        // to post next, I'm out of content ideas for my page" — a string nobody
+        // has ever written, sent to a keyword search, three times, having been
+        // lengthened twice (#60).
+        const core = complaintCore(problem);
+        const shapes = args.queries?.length
+            ? args.queries.slice(0, 4).map((q, i) => ({ shape: `given:${i + 1}`, query: q.trim() }))
+            : [
+                { shape: "plain", query: core },
+                // Reddit's own idiom, and it reads as a sentence now that `core`
+                // has had its leading subject removed.
+                { shape: "shared", query: `anyone else ${core}` },
+                // A SUFFIX, not a prefix: appended keywords cannot be made
+                // ungrammatical by whatever shape the core turned out to be.
+                { shape: "asking", query: `${core} any recommendations` },
+            ];
         const seen = new Set();
         const posts = [];
         const unavailable = [];
@@ -2191,9 +2223,20 @@ export function registerJobTools(server, makeClient, store) {
                 "and say how many you rejected and why — a shortlist with no reject count reads as if " +
                 "the search was precise.",
             "",
-            "`foundBy` says which phrasing surfaced each post: `plain` the problem itself, `shared` " +
-                "the does-anyone-else form, `asking` the is-there-a-tool form. The last two skew " +
-                "towards genuine complaints and the first towards content about the topic.",
+            args.queries?.length
+                ? "`foundBy` says which of your own phrasings surfaced each post, in the order you " +
+                    "gave them."
+                : "`foundBy` says which phrasing surfaced each post: `plain` the problem itself, " +
+                    "`shared` the does-anyone-else form, `asking` the looking-for-a-tool form. The " +
+                    "last two skew towards genuine complaints and the first towards content about " +
+                    "the topic.",
+            "",
+            args.queries?.length
+                ? ""
+                : `These were searched as: ${shapes.map((sh) => `"${sh.query}"`).join(", ")}. That ` +
+                    "is a keyword search, not intent matching. If those read wrong for where you are " +
+                    "looking — a Reddit title is worded differently from an X post — call this again " +
+                    "with `queries` set to phrasings you write yourself, and keep each one short.",
             "",
             unavailable.length
                 ? `Note that ${unavailable.length} searches errored — tell the user which networks ` +

package/dist/shared/own-account.js

@@ -51,13 +51,23 @@
  * `get_content_plan` above); this file is what makes them reachable here.
  */
 import { z } from "zod";
+import { withEvidence } from "./evidence-digest.js";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
 import { viewMeta } from "./view-meta.js";
 function toResult(proxy) {
     const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
+    const structured = proxy.structured;
+    // The backend's summary line, plus the rows it summarises. `list_own_apps`
+    // said "You have 2 app(s) in this workspace" and kept the appIds in
+    // `structuredContent` — which a host rendering the view gives to the widget,
+    // leaving a model that needs an appId for draft_post with the count alone
+    // (#59).
+    const text = String(textBlock?.text ?? "");
     return {
-        content: textBlock ? [{ type: "text", text: String(textBlock.text ?? "") }] : [],
-        structuredContent: proxy.structured,
+        content: [
+            { type: "text", text: structured ? withEvidence(text, structured) : text },
+        ],
+        structuredContent: structured,
     };
 }
 function failed(prefix, err) {

package/dist/shared/tools-def.js

@@ -394,7 +394,7 @@ export const TOOL_DEFINITIONS = [
         name: "find_people_with_problem",
         title: "Find People With A Problem",
         description: "Find people describing a problem in their own words — prospects, early users, anyone whose complaint your product answers. Say the problem the way a person would say it (\"I spend hours checking competitors by hand\") and this searches for posts shaped like that complaint, not for the topic it is about. That difference is the point: searching the TOPIC finds marketing about it, which is what discover_social_posts is for. Widens the query into the forms a complaint takes — the plain phrasing, the does-anyone-else question, the is-there-a-tool ask — and merges what each returns. It is a wide cheap net and NOT a filter: the posts come back for you to judge, and many will be off-target. Consumes 2 nooticr credits per platform searched. Defaults to reddit, where people describe workflow pain in sentences; add twitter for volume.",
-        inputSchema: z.object({ problem: z.string().describe("The problem in a person's own words, not a topic. \"I waste an hour a day checking what competitors posted\" finds people; \"competitor analysis\" finds marketing about competitor analysis."), platforms: z.array(z.enum(["reddit", "twitter", "youtube", "tiktok", "instagram", "linkedin"])).optional().describe("Where to look (default reddit). Each one is a separate paid search."), limit: z.number().int().optional().describe("Posts per query shape (default 6, max 15).") }).strict(),
+        inputSchema: z.object({ problem: z.string().describe("The problem in a person's own words, not a topic. \"I waste an hour a day checking what competitors posted\" finds people; \"competitor analysis\" finds marketing about competitor analysis."), platforms: z.array(z.enum(["reddit", "twitter", "youtube", "tiktok", "instagram", "linkedin"])).optional().describe("Where to look (default reddit). Each one is a separate paid search."), limit: z.number().int().optional().describe("Posts per query shape (default 6, max 15)."), queries: z.array(z.string()).optional().describe("Search these exact phrasings instead of the ones derived from `problem` (max 4). You are better at this than a string template is: write how a person would actually word the complaint on the network being searched \u2014 a Reddit title, an X post \u2014 and keep each one short, because this is a keyword search and a long sentence matches on its commonest words.") }).strict(),
     },
     {
         name: "search_spoken_mentions",

package/dist/shared/tools.js

@@ -15,6 +15,7 @@ import { deriveHashtags, derivedNote } from "./hashtags.js";
 import { createTaskStore, registerSlowTool } from "./tasks.js";
 import { COMMENT_CATEGORIES, COMMENT_SENTIMENTS, platformFromUrl, reviewGuidance, toEvidence, } from "./comment-review.js";
 import { costSentence, EVIDENCE_PLANS, fetchBillingNote, frameIndex, framesToBlocks, planCalls, scoreDraftGuidance, KNOWN_PLATFORMS, platformFailureGuidance, } from "./evidence.js";
+import { evidenceDigest } from "./evidence-digest.js";
 import { confirmSpend, declinedResult, searchMentionsCost, SEARCH_PLATFORMS, DISCOVERABLE_PLATFORMS, } from "./spend.js";
 import { BackendWatchStore, MemoryWatchStore, registerWatchlist, } from "./watchlist.js";
 import { registerJobTools } from "./jobs.js";
@@ -25,7 +26,7 @@ import { loadingPlansJson } from "./loading-plans.js";
 import { registerHandoff } from "./handoff.js";
 import { registerCollabTools } from "./collab.js";
 /** Current MCP server version — bumped on every deploy for traceability. */
-export const MCP_SERVER_VERSION = "1.26.29";
+export const MCP_SERVER_VERSION = "1.26.31";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -444,6 +445,19 @@ async function runEvidence(tool, args, client) {
     // rather than "no fetch was made".
     if (plan.also && !nothingToFetch)
         out[plan.also.via] = extra;
+    // The evidence has to ride in the text block too, and it is written last
+    // because `out` is what it renders — the fetched payload, plus whatever the
+    // `also` call added, minus the frames that became image blocks.
+    //
+    // Same reason the guidance is in both channels (#44/#51), pointed the other
+    // way: Claude Code drops these text blocks and reads `structuredContent`,
+    // while a host rendering a UI view hands the model the text blocks and gives
+    // `structuredContent` to the widget. A transcript that exists only in the
+    // second one is a transcript the model was told to read and never saw (#59).
+    const digest = evidenceDigest(out);
+    if (digest) {
+        content[0] = { type: "text", text: `${guidance}\n\n---\n\n${digest}` };
+    }
     return { content, structuredContent: out };
 }
 export function createMcpServer(rawMakeClient, opts) {
@@ -1202,23 +1216,31 @@ export function createMcpServer(rawMakeClient, opts) {
             const structured = (res.structured ?? {});
             const comments = toEvidence(args.url, structured.comments);
             const guidance = reviewGuidance(args.url, comments.length);
+            // "Here are 4 comments ... Read them and classify each one" was a false
+            // sentence in the channel it was written in: the comments were only ever
+            // in `structuredContent`, which a host rendering the view keeps for the
+            // widget. The model was asked to classify comments it could not see, and
+            // to return the `id` of each — so the digest renders ids too (#59).
+            const payload = {
+                // See runEvidence: a text block alone reaches no host that renders
+                // structuredContent, and this is the tool show_comment_review's whole
+                // chain hangs off.
+                guidance,
+                mode: "evidence",
+                url: args.url,
+                platform: structured.platform ?? null,
+                commentCount: comments.length,
+                comments,
+                // Passed through rather than re-derived: the platform's own clustering
+                // is evidence too, and it is already paid for.
+                themes: structured.themes ?? [],
+                mcpCredits: structured.mcpCredits ?? null,
+            };
             return {
-                content: [{ type: "text", text: guidance }],
-                structuredContent: {
-                    // See runEvidence: a text block alone reaches no host that renders
-                    // structuredContent, and this is the tool show_comment_review's whole
-                    // chain hangs off.
-                    guidance,
-                    mode: "evidence",
-                    url: args.url,
-                    platform: structured.platform ?? null,
-                    commentCount: comments.length,
-                    comments,
-                    // Passed through rather than re-derived: the platform's own clustering
-                    // is evidence too, and it is already paid for.
-                    themes: structured.themes ?? [],
-                    mcpCredits: structured.mcpCredits ?? null,
-                },
+                content: [
+                    { type: "text", text: `${guidance}\n\n---\n\n${evidenceDigest(payload)}` },
+                ],
+                structuredContent: payload,
             };
         }
         catch (err) {

package/package.json

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