@nooticr/mcp 1.26.29 → 1.26.30

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/jobs.js

@@ -57,6 +57,7 @@ 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 { 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) => ({

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.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.30";
 /** 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.30",
   "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": {