@nooticr/mcp 1.26.21 → 1.26.22

package/README.md

@@ -138,6 +138,10 @@ them caps that fan-out with an argument.
 | `check_nooticr_credits` | free | Balance and billing URL. |
 | `buy_nooticr_credits` | free | A Stripe Checkout URL for a credit pack. Credits land automatically after payment. |
 | `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**. 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. |
+| `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. |
+| `update_product` | free | Patch a product's fields. An omitted argument leaves its column unchanged, so this cannot blank a field by not mentioning it, and the result lists what was actually written — a misspelled field shows up as one that did not change rather than as a silent no-op. |
 
 ### Your own product
 

package/dist/shared/connections.js

@@ -16,6 +16,12 @@
  */
 import { z } from "zod";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
+// Both of these shipped view-less. The grant a connection actually carries —
+// read, publish, manage comments, each yes/no/unknown — is a table, and a
+// table read out as prose is the thing a view is for; the third value
+// especially, since "unknown" means nobody recorded the scope and must never
+// be drawn as the refusal it is not.
+import { viewMeta } from "./view-meta.js";
 function toResult(proxy) {
     const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
     return {
@@ -32,6 +38,7 @@ function failed(prefix, err) {
 }
 export function registerConnectionTools(server, makeClient) {
     server.registerTool("list_social_connections", {
+        _meta: viewMeta("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. Each answer is yes, " +
@@ -52,6 +59,7 @@ export function registerConnectionTools(server, makeClient) {
         }
     });
     server.registerTool("connect_social_account", {
+        _meta: viewMeta("connect_social_account"),
         title: "Connect Social Account",
         description: "Get a link to open so you can connect one social account. Takes the platform, and " +
             "optionally influencerId or appId when your workspace has more than one creator profile " +

package/dist/shared/jobs.js

@@ -57,7 +57,7 @@ import { z } from "zod";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
 import { platformFromUrl, postSlug } from "./comment-review.js";
 import { handleMissGuidance, ownIt, PLATFORM_ARG } from "./evidence.js";
-import { confirmSpend, costOf, declinedResult, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, } from "./spend.js";
+import { confirmSpend, costOf, declinedResult, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, SPOKEN_PLATFORMS, } from "./spend.js";
 import { distributionOf, excluding, numberOf, standing, } from "./performance.js";
 import { normaliseHandle, watchEntryId, watchlistOwner } from "./watchlist.js";
 import { viewMeta } from "./view-meta.js";
@@ -482,6 +482,48 @@ function nextGuidance(a) {
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+/** "4:12", or "1:04:12" once there is an hour to show. */
+export function formatTimecode(ms) {
+    const total = Math.max(0, Math.floor(ms / 1000));
+    const s = total % 60;
+    const m = Math.floor(total / 60) % 60;
+    const h = Math.floor(total / 3600);
+    const pad = (n) => String(n).padStart(2, "0");
+    return h > 0 ? `${h}:${pad(m)}:${pad(s)}` : `${m}:${pad(s)}`;
+}
+/**
+ * The cue a character offset falls in — the line the term was said in.
+ *
+ * The cues are sorted by offset, so this keeps the last one that starts at or
+ * before the match and stops at the first that starts after it. A match
+ * landing in the gap before the first cue has no answer, which is the honest
+ * one.
+ */
+function cueAt(cues, position) {
+    let found = null;
+    for (const cue of cues) {
+        if (cue.offset > position)
+            break;
+        found = cue;
+    }
+    return found;
+}
+/** Attach the moment each excerpt was said, where the track carried one. */
+export function timeExcerpts(excerpts, rawCues) {
+    const cues = (Array.isArray(rawCues) ? rawCues : [])
+        .filter((c) => !!c && typeof c === "object"
+        && typeof c.offset === "number"
+        && typeof c.startMs === "number")
+        .sort((a, b) => a.offset - b.offset);
+    if (!cues.length)
+        return excerpts;
+    return excerpts.map((ex) => {
+        const cue = cueAt(cues, ex.position);
+        if (!cue)
+            return ex;
+        return { ...ex, startMs: cue.startMs, timecode: formatTimecode(cue.startMs) };
+    });
+}
 /**
  * Where a term is actually said, case-insensitively and on whole words —
  * "nike" must not fire inside "nikeisha". `\b` only means anything next to a
@@ -1549,7 +1591,7 @@ export function registerJobTools(server, makeClient, store) {
                 .describe("Brand, product or person to listen for, e.g. 'nooticr'. Matched case-insensitively " +
                 "on whole words, so 'nike' will not match inside 'nikeisha'."),
             platforms: z
-                .array(z.enum(["tiktok", "youtube"]))
+                .array(z.enum(SPOKEN_PLATFORMS))
                 .optional()
                 .describe("Which networks to check (default: both). These are the only two whose posts carry " +
                 "a caption track this tool can read."),
@@ -1594,8 +1636,8 @@ export function registerJobTools(server, makeClient, store) {
             };
         }
         const platforms = [
-            ...new Set((args.platforms && args.platforms.length ? args.platforms : ["tiktok", "youtube"]).map((p) => String(p).toLowerCase())),
-        ].filter((p) => p === "tiktok" || p === "youtube");
+            ...new Set((args.platforms && args.platforms.length ? args.platforms : SPOKEN_PLATFORMS).map((p) => String(p).toLowerCase())),
+        ].filter((p) => SPOKEN_PLATFORMS.includes(p));
         const explicitHandles = [...new Set((args.usernames ?? []).map(normaliseHandle).filter(Boolean))];
         // A watchlist handle already knows its own platform, so it is checked
         // once there rather than once per requested platform — the same
@@ -1780,7 +1822,12 @@ export function registerJobTools(server, makeClient, store) {
                         post: { ...post, postId: id, postedAt: postDate(post) },
                         postId: id,
                         matchCount,
-                        excerpts,
+                        // TikTok and YouTube both publish a timed caption track, and
+                        // those are the only two platforms this tool narrows to — so a
+                        // hit here almost always knows the moment it was said. The
+                        // speech-to-text fallback carries no clock, and an excerpt from
+                        // one simply arrives without a timecode.
+                        excerpts: timeExcerpts(excerpts, structured.cues),
                         wordCount: numberOf(structured.wordCount),
                         language: structured.language ?? null,
                         autoGenerated: !!structured.autoGenerated,

package/dist/shared/loading-plans.js

@@ -0,0 +1,365 @@
+/**
+ * What each tool is about to do, and what it will cost — for the wait.
+ *
+ * ## Why this exists rather than a table in the view
+ *
+ * The view is a static HTML string with no imports, so its first version of
+ * this was a hand-copied price list. It was wrong within the hour: it took its
+ * numbers from `mcp_tool_cost` in nooticr-server, which prices a *direct*
+ * `/mcp` call, while every evidence tool in this server fans out to cheaper
+ * calls instead. `analyze_post` is billed 6 there and 3 here (frames 2 plus
+ * transcript 1); `analyze_creator_profile` 15 there and 2 here. A price on the
+ * face of a loading screen is a promise, and one copied from the wrong table
+ * is worse than none at all.
+ *
+ * So the plans are built here, from the same constants the tools bill against
+ * — `EVIDENCE_PLANS` and `BACKEND_CALL_CREDITS` — and substituted into the
+ * template as JSON. A tool that changes what it fetches changes what the wait
+ * says, with no second place to remember.
+ *
+ * ## What the view may and may not claim
+ *
+ * MCP Apps gives a view four notifications: tool-input, tool-input-partial,
+ * tool-result and tool-cancelled (`@modelcontextprotocol/ext-apps`). There is
+ * no progress notification, so nothing here can honestly say a step has
+ * *finished* — only what the call is going to do and what each line costs.
+ * The design board's ledger ticks green checks through its rows; that is a
+ * canvas loop, and reproducing it would assert completions this server has no
+ * way to know. The rows are drawn, priced, and left un-ticked.
+ */
+import { planCalls } from "./evidence.js";
+import { BACKEND_CALL_CREDITS, CREDITS_PER_CREATOR, CREDITS_PER_NETWORK, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, SEARCH_PLATFORMS, SPOKEN_PLATFORMS, XIAOHONGSHU_CREDITS, } from "./spend.js";
+/** What each backend call is doing, in words a person reads rather than a tool name. */
+const CALL_LABELS = {
+    get_post_frames: { label: "Sampling frames", detail: "one per shot, by scene change" },
+    get_post_transcript: { label: "Reading the caption track", detail: "exact wording, not inferred" },
+    get_social_media: { label: "Fetching the post", detail: "stats, caption and media" },
+    get_user_posts: { label: "Loading their posts", detail: "recent window, with stats" },
+    get_post_comments: { label: "Reading the comments", detail: "top replies and their themes" },
+    discover_social_posts: { label: "Searching posts", detail: "recent, for the niche" },
+    search_creators: { label: "Finding creators", detail: "by keyword" },
+    get_similar_creators: { label: "Finding lookalikes", detail: "from the seed creator" },
+    discover_sounds: { label: "Finding sounds", detail: "trending audio" },
+    discover_hashtags: { label: "Reading the trend board", detail: "with volumes and direction" },
+};
+function step(via) {
+    const said = CALL_LABELS[via] ?? { label: via };
+    return { via, label: said.label, detail: said.detail, credits: BACKEND_CALL_CREDITS[via] ?? 0 };
+}
+/** The fan-out an evidence tool declares, as priced lines. */
+function evidenceSteps(tool) {
+    return planCalls(tool).map(step);
+}
+const CREATOR_UNIT = {
+    via: "get_user_posts",
+    label: "Checking a creator",
+    detail: "since your last catch-up",
+    credits: CREDITS_PER_CREATOR,
+    defaultCount: 1,
+};
+/**
+ * One plan per registered tool.
+ *
+ * Pinned by tests/loading-plans.test.ts against the server's own tool list, so
+ * a tool cannot ship without a wait that says what it is doing — which is how
+ * search_mentions, the slowest and dearest call here, ended up drawing a
+ * generic grey box that said "Working".
+ */
+export const LOADING_PLANS = {
+    // ─── Read a post ───
+    get_social_media: { label: "Fetching the post", kind: "post", n: 1, steps: [step("get_social_media")] },
+    get_post_transcript: {
+        label: "Reading the caption track",
+        kind: "text",
+        n: 1,
+        steps: [step("get_post_transcript")],
+    },
+    get_post_frames: { label: "Sampling frames", kind: "post", n: 1, steps: [step("get_post_frames")] },
+    get_post_comments: { label: "Loading comments", kind: "list", n: 6, steps: [step("get_post_comments")] },
+    // ─── Understand a post ───
+    analyze_post: { label: "Analysing the post", kind: "post", n: 1, steps: evidenceSteps("analyze_post") },
+    understand_social_post: {
+        label: "Watching the video",
+        kind: "post",
+        n: 1,
+        steps: evidenceSteps("understand_social_post"),
+    },
+    analyze_post_fast: {
+        label: "Reading the post",
+        kind: "text",
+        n: 1,
+        steps: evidenceSteps("analyze_post_fast"),
+    },
+    analyze_comments: {
+        label: "Reading the comment section",
+        kind: "text",
+        n: 1,
+        // Not an evidence plan: it proxies one get_post_comments and synthesises.
+        steps: [step("get_post_comments")],
+    },
+    compare_posts: {
+        label: "Fetching the first post",
+        kind: "strip",
+        n: 2,
+        steps: evidenceSteps("compare_posts"),
+        note: "1 credit more for every further post you fetch yourself.",
+    },
+    // ─── Research ───
+    discover_social_posts: {
+        label: "Searching posts",
+        kind: "strip",
+        n: 3,
+        steps: [step("discover_social_posts")],
+    },
+    get_user_posts: { label: "Loading their posts", kind: "strip", n: 3, steps: [step("get_user_posts")] },
+    search_creators: { label: "Finding creators", kind: "list", n: 5, steps: [step("search_creators")] },
+    get_similar_creators: {
+        label: "Finding similar creators",
+        kind: "list",
+        n: 5,
+        steps: [step("get_similar_creators")],
+    },
+    discover_sounds: { label: "Finding trending sounds", kind: "list", n: 4, steps: [step("discover_sounds")] },
+    discover_hashtags: {
+        label: "Reading the trend board",
+        kind: "list",
+        n: 6,
+        steps: [step("discover_hashtags")],
+    },
+    analyze_creator_profile: {
+        label: "Reading the profile",
+        kind: "list",
+        n: 4,
+        steps: evidenceSteps("analyze_creator_profile"),
+    },
+    find_hook_pattern: {
+        label: "Reading their openings",
+        kind: "list",
+        n: 5,
+        steps: evidenceSteps("find_hook_pattern"),
+    },
+    niche_report: { label: "Reading the niche", kind: "text", n: 1, steps: evidenceSteps("niche_report") },
+    // ─── Make something ───
+    write_hooks: { label: "Reading the source post", kind: "text", n: 1, steps: evidenceSteps("write_hooks") },
+    create_variants: {
+        label: "Reading the post that worked",
+        kind: "text",
+        n: 1,
+        steps: evidenceSteps("create_variants"),
+    },
+    repurpose_post: {
+        label: "Reading the source post",
+        kind: "text",
+        n: 1,
+        steps: evidenceSteps("repurpose_post"),
+    },
+    // Fetches nothing: the draft is already the caller's.
+    score_draft: { label: "Scoring the draft", kind: "text", n: 1, steps: [], free: true },
+    // ─── Brand monitoring ───
+    search_mentions: {
+        label: "Sweeping for mentions",
+        kind: "list",
+        n: 6,
+        steps: [],
+        perUnit: [
+            {
+                via: "search_mentions",
+                label: "Sweeping a network",
+                detail: "every comment that names the term",
+                credits: CREDITS_PER_NETWORK,
+                arg: "platforms",
+                defaultCount: SEARCH_PLATFORMS.length,
+                perPlatform: true,
+            },
+        ],
+        note: "Priced per network. Omitting platforms means all of them.",
+    },
+    // The one plan whose arithmetic is not a single argument read straight off:
+    // it mirrors the worst case jobs.ts computes before it asks to spend, line
+    // for line, because the two numbers are shown to the same person minutes
+    // apart and any gap between them reads as one of them lying.
+    search_spoken_mentions: {
+        label: "Listening for mentions",
+        kind: "list",
+        n: 4,
+        steps: [],
+        perUnit: [
+            {
+                via: "discover_social_posts",
+                label: "Sweeping for candidates",
+                detail: "per network, when a niche is given",
+                credits: BACKEND_CALL_CREDITS.discover_social_posts,
+                arg: "platforms",
+                only: SPOKEN_PLATFORMS,
+                defaultCount: SPOKEN_PLATFORMS.length,
+                onlyWith: "niche",
+            },
+            {
+                via: "get_user_posts",
+                label: "Checking a creator",
+                detail: "once per network asked for",
+                credits: BACKEND_CALL_CREDITS.get_user_posts,
+                arg: "usernames",
+                per: { arg: "platforms", only: SPOKEN_PLATFORMS, defaultCount: SPOKEN_PLATFORMS.length },
+                defaultCount: 0,
+                max: MAX_SPOKEN_HANDLE_CALLS,
+                ceilingWith: "useWatchlist",
+            },
+            {
+                via: "get_post_transcript",
+                label: "Transcribing a candidate",
+                detail: "most-viewed first, up to the ceiling",
+                credits: BACKEND_CALL_CREDITS.get_post_transcript,
+                arg: "maxTranscripts",
+                defaultCount: 8,
+                min: 1,
+                max: MAX_SPOKEN_TRANSCRIPTS,
+            },
+        ],
+        note: "The ceiling is the price. Only the survivors are transcribed.",
+    },
+    catch_up_watchlist: {
+        label: "Checking your watchlist",
+        kind: "list",
+        n: 5,
+        steps: [],
+        perUnit: [CREATOR_UNIT],
+        note: "Priced per creator on the watchlist.",
+    },
+    // ─── The goal tools (jobs.ts) ───
+    answer_my_audience: {
+        label: "Reading your own replies",
+        kind: "list",
+        n: 6,
+        steps: [step("get_user_posts")],
+        perUnit: [
+            {
+                via: "get_post_comments",
+                label: "Opening a post",
+                detail: "reading what was asked under it",
+                credits: BACKEND_CALL_CREDITS.get_post_comments,
+                arg: "limit",
+                defaultCount: 6,
+            },
+        ],
+    },
+    track_competitor: {
+        label: "Reading what they shipped",
+        kind: "strip",
+        n: 3,
+        steps: [step("get_user_posts")],
+    },
+    who_should_i_work_with: {
+        label: "Building a shortlist",
+        kind: "list",
+        n: 5,
+        steps: [step("search_creators")],
+        perUnit: [
+            {
+                via: "get_similar_creators",
+                label: "Adding their lookalikes",
+                credits: BACKEND_CALL_CREDITS.get_similar_creators,
+                defaultCount: 1,
+                onlyWith: "seed",
+            },
+        ],
+    },
+    why_did_this_underperform: {
+        label: "Measuring it against their own median",
+        kind: "text",
+        n: 1,
+        steps: [step("get_social_media"), step("get_user_posts")],
+    },
+    what_should_i_make_next: {
+        label: "Reading demand against supply",
+        kind: "list",
+        n: 6,
+        steps: [step("get_user_posts"), step("discover_social_posts")],
+        perUnit: [
+            {
+                via: "get_post_comments",
+                label: "Reading a post's comments",
+                detail: "what the audience asked for",
+                credits: BACKEND_CALL_CREDITS.get_post_comments,
+                arg: "limit",
+                defaultCount: 4,
+            },
+        ],
+    },
+    // ─── Draws what the caller already has: no fetch, no price ───
+    show_comment_review: { label: "Drawing the labels", kind: "list", n: 6, steps: [], free: true },
+    show_audience_replies: { label: "Laying out the drafts", kind: "list", n: 5, steps: [], free: true },
+    // ─── Draws what the caller already produced: no fetch, no price ───
+    // The show_* family renders the model's own output. A wait here is brief
+    // and free, but it still says which, because "nothing is happening" and
+    // "this is free and instant" look identical on a blank screen.
+    show_analysis: { label: "Drawing the reading", kind: "text", n: 1, steps: [], free: true },
+    show_comparison: { label: "Drawing the comparison", kind: "strip", n: 2, steps: [], free: true },
+    show_hooks: { label: "Laying out the hooks", kind: "list", n: 5, steps: [], free: true },
+    show_variants: { label: "Laying out the variants", kind: "list", n: 4, steps: [], free: true },
+    show_repurposed_post: { label: "Laying out the rewrites", kind: "text", n: 1, steps: [], free: true },
+    show_collab_shortlist: { label: "Drawing the shortlist", kind: "list", n: 5, steps: [], free: true },
+    prepare_handoff: { label: "Packaging the handoff", kind: "list", n: 4, steps: [], free: true },
+    // ─── Own-account reads: nooticr's own stored rows ───
+    get_scheduled_posts: { label: "Reading your pipeline", kind: "list", n: 5, steps: [], free: true },
+    get_post_performance: { label: "Reading your numbers", kind: "list", n: 5, steps: [], free: true },
+    get_video_stats: { label: "Reading the last sync", kind: "strip", n: 3, steps: [], free: true },
+    get_brand_playbook: { label: "Reading the playbook", kind: "text", n: 1, steps: [], free: true },
+    // ─── The product analysis: the one own-account tool that spends ───
+    // The only outbound fetch in this family — it reads an excerpt of the
+    // product's own site — and it is billed against the workspace's plan AI
+    // credits, not the personal MCP balance.
+    analyze_product: { label: "Starting the analysis", kind: "text", n: 1, steps: [], planAi: true },
+    // Free to poll: the spend already happened when the job was started.
+    analyze_product_status: {
+        label: "Checking the analysis",
+        kind: "text",
+        n: 1,
+        steps: [],
+        free: true,
+    },
+    // ─── Scheduled monitoring (brand-watch.ts) ───
+    // Managing a schedule is not using it: the sweeps a watch makes are billed
+    // as search_mentions when the worker runs them, later and elsewhere.
+    create_brand_watch: { label: "Setting up the watch", kind: "text", n: 1, steps: [], free: true },
+    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 },
+    // ─── Own-account reads: nooticr's own stored rows, never an upstream call ───
+    list_own_apps: { label: "Reading your products", kind: "list", n: 3, steps: [], free: true },
+    get_content_plan: { label: "Reading the saved plan", kind: "text", n: 1, steps: [], free: true },
+    // Calls AI, but the dashboard's own pre-publish review has never billed for
+    // it, so neither does this.
+    review_post: { label: "Scoring the post", kind: "text", n: 1, steps: [], free: true },
+    // ─── Own-account generation: a different balance ───
+    draft_post: { label: "Drafting the post", kind: "text", n: 1, steps: [], planAi: true },
+    growth_brief: { label: "Writing the brief", kind: "text", n: 1, steps: [], planAi: true },
+    generate_content_plan: {
+        label: "Planning the week",
+        kind: "list",
+        n: 5,
+        steps: [],
+        planAi: true,
+    },
+    generate_captions: { label: "Writing the captions", kind: "text", n: 1, steps: [], planAi: true },
+    // ─── Account and own-account: free, and free at a zero balance ───
+    check_nooticr_credits: { label: "Checking your balance", kind: "text", n: 1, steps: [], free: true },
+    buy_nooticr_credits: { label: "Opening checkout", kind: "text", n: 1, steps: [], free: true },
+    nooticr_login: { label: "Getting a sign-in link", kind: "text", n: 1, steps: [], free: true },
+    watch_creator: { label: "Adding to your watchlist", kind: "text", n: 1, steps: [], free: true },
+    unwatch_creator: { label: "Removing from 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 },
+    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 },
+};
+/** Everything the view needs, as one JSON blob substituted into the template. */
+export function loadingPlansJson() {
+    return JSON.stringify({
+        plans: LOADING_PLANS,
+        platforms: SEARCH_PLATFORMS,
+        perNetwork: CREDITS_PER_NETWORK,
+        xiaohongshu: XIAOHONGSHU_CREDITS,
+    });
+}
+/** Tools that fan out over an argument, for the tests that pin the wait. */
+export const ARGUMENT_PRICED = Object.keys(LOADING_PLANS).filter((t) => !!LOADING_PLANS[t].perUnit);

package/dist/shared/output-schemas.js

@@ -587,6 +587,9 @@ export const OUTPUT_SCHEMAS = {
                 text: scalar().describe("The spoken line, with surrounding context to judge tone from."),
                 position: scalar().describe("Character offset of the match inside the full transcript."),
                 occurrence: scalar().describe("Which match this is, 1-based. Only the first few carry an excerpt."),
+                startMs: scalar().describe("When it was said, from the caption track's own cue timings. Absent, never " +
+                    "estimated, when the platform published no timings."),
+                timecode: scalar().describe('The same instant as "4:12".'),
             })),
             wordCount: scalar(),
             language: scalar(),
@@ -599,6 +602,16 @@ export const OUTPUT_SCHEMAS = {
     }),
     get_post_transcript: open({
         available: scalar().describe("false when the post carries no caption track."),
+        // Deliberately no text: it is already in `transcript`, and a caption
+        // track is long enough that sending it twice would be a real cost in a
+        // payload that ends up in a model's context. `offset` is what makes that
+        // safe — it indexes into the transcript that is there.
+        cues: listOf(open({
+            startMs: scalar().describe("When this line starts, in milliseconds."),
+            endMs: scalar(),
+            offset: scalar().describe("Where this line's words begin in `transcript`, in UTF-16 code units — so a match " +
+                "found at a string index maps back to the moment it was said."),
+        })).describe("Cue timings, where the platform published a timed track. Absent for speech-to-text."),
         transcript: scalar(),
         wordCount: scalar(),
         language: scalar(),

package/dist/shared/own-account.js

@@ -87,6 +87,7 @@ export function registerOwnAccountTools(server, makeClient) {
         }
     });
     server.registerTool("create_product", {
+        _meta: viewMeta("create_product"),
         title: "Create Product",
         description: "Create a new product (\"app\") in your own workspace — the row every other own-account " +
             "tool needs before it has anything to work with; a fresh workspace has none. Takes no " +
@@ -138,6 +139,7 @@ export function registerOwnAccountTools(server, makeClient) {
         }
     });
     server.registerTool("update_product", {
+        _meta: viewMeta("update_product"),
         title: "Update Product",
         description: "Patch your own product's fields — omitted arguments leave their column unchanged. Takes " +
             "appId (optional when your workspace has only one product); every other field is " +

package/dist/shared/spend.js

@@ -10,6 +10,18 @@ export const SEARCH_PLATFORMS = [
     "reddit",
     "weibo",
 ];
+/**
+ * The only two networks `search_spoken_mentions` can reach.
+ *
+ * Both publish a caption track their post detail already carries; everywhere
+ * else the words would have to be inferred from the audio, which is a
+ * different tool at a different price. Named here rather than inline because
+ * three places have to agree on it — the tool's own enum, the filter it puts
+ * every requested platform through, and the wait that prices the sweep. A
+ * platform the filter drops but the price counts is a credit quoted for a
+ * call that never happens.
+ */
+export const SPOKEN_PLATFORMS = ["tiktok", "youtube"];
 /** Two per network, except the one that costs an order of magnitude more upstream. */
 export const CREDITS_PER_NETWORK = 2;
 export const XIAOHONGSHU_CREDITS = 5;

package/dist/shared/tools-def.js

@@ -246,18 +246,6 @@ export const TOOL_DEFINITIONS = [
         description: "List every product (\"app\") in your own workspace — id, name, niche and product type. Call this first when your workspace has more than one product and another own-account tool asks for appId. Reads only your own workspace. No cost to call.",
         inputSchema: z.object({}).strict(),
     },
-    {
-        name: "create_product",
-        title: "Create Product",
-        description: "Create a new product (\"app\") in your own workspace — the row every other own-account tool needs before it has anything to work with. Takes no workspace argument: it always creates in the calling session's own workspace. Subject to your plan's product limit. Does not generate a brand playbook by itself; call analyze_product afterwards for that. name and slug are required; description, website_url, niche, product_type and the store-listing fields are optional and snake_case. Free — no AI call, just a row.",
-        inputSchema: z.object({ name: z.string().describe("Product name."), slug: z.string().describe("URL-safe slug, unique within your workspace."), description: z.string().optional(), website_url: z.string().optional().describe("The product's own site; analyze_product later fetches an excerpt of it."), niche: z.string().optional(), product_type: z.string().optional(), icon_url: z.string().optional(), primary_cta_label: z.string().optional(), primary_cta_url: z.string().optional(), external_listing_id: z.string().optional(), ios_bundle_id: z.string().optional(), android_package: z.string().optional() }).strict(),
-    },
-    {
-        name: "update_product",
-        title: "Update Product",
-        description: "Patch your own product's fields — omitted arguments leave their column unchanged. Takes appId (optional with a single-app workspace); every other field is snake_case, same as create_product. Free — no AI call, just a row.",
-        inputSchema: z.object({ appId: z.number().int().optional().describe("Your product's id. Omit only with a single-app workspace."), name: z.string().optional(), slug: z.string().optional(), description: z.string().optional(), website_url: z.string().optional(), niche: z.string().optional(), product_type: z.string().optional(), icon_url: z.string().optional(), primary_cta_label: z.string().optional(), primary_cta_url: z.string().optional(), external_listing_id: z.string().optional(), ios_bundle_id: z.string().optional(), android_package: z.string().optional() }).strict(),
-    },
     {
         name: "get_brand_playbook",
         title: "Get Brand Playbook",
@@ -384,4 +372,16 @@ export const TOOL_DEFINITIONS = [
         description: "Brand mentions people SAY but never type. search_mentions reads captions, post bodies and comments — text — so a video that names a brand only out loud is invisible to it. This reads the words actually spoken, from the platform's own caption track, and searches them for a term. Narrows to candidate posts first (a niche sweep, named creator handles, and/or your watchlist), transcribes only the most-viewed survivors up to a hard ceiling you set, and returns the matched line with surrounding context. TikTok and YouTube only — the only two networks whose posts carry a caption track this cheaply — and even there a video with no captions is invisible to this tool; the result says how many candidates were found, transcribed and matched. Use when a term might be spoken on camera but not written anywhere. Consumes 2 nooticr credits per platform a niche is searched on, 2 per creator handle checked, and 1 per transcript actually fetched, capped by maxTranscripts.",
         inputSchema: z.object({ term: z.string().describe("Brand, product or person to listen for, e.g. 'nooticr'."), platforms: z.array(z.enum(["tiktok", "youtube"])).optional().describe("Which networks to check (default: both)."), niche: z.string().optional().describe("Niche or keyword for a candidate sweep. Provide this, usernames, useWatchlist, or any combination."), usernames: z.array(z.string()).optional().describe("Specific creator handles to check."), useWatchlist: z.boolean().optional().describe("Also check your watchlisted creators on tiktok or youtube."), candidateLimit: z.number().int().optional().describe("Posts pulled per narrowing call (default 15, max 25)."), maxTranscripts: z.number().int().optional().describe("Hard ceiling on transcripts fetched (default 8, max 20).") }).strict(),
     },
+    {
+        name: "create_product",
+        title: "Create Product",
+        description: "Create a product in your own workspace \u2014 the row every other own-account tool needs before it has anything to work with; a fresh workspace has none. Takes no workspace argument: it always creates in the workspace of the session calling it, never one you could name. name and slug are required; every other field is optional and all of them are snake_case, read by exact key \u2014 a camelCase websiteUrl is not an alias, it is a field that lands nowhere. Subject to your plan's product limit; the error names the limit if you hit it. Does not generate a brand playbook. Free \u2014 no AI call, just a row.",
+        inputSchema: z.object({ name: z.string().describe("Product name."), slug: z.string().describe("URL-safe slug, unique within your workspace."), description: z.string().optional(), website_url: z.string().optional().describe("The product's own site; analyze_product later fetches an excerpt of it."), niche: z.string().optional(), product_type: z.string().optional(), icon_url: z.string().optional(), primary_cta_label: z.string().optional(), primary_cta_url: z.string().optional(), external_listing_id: z.string().optional(), ios_bundle_id: z.string().optional(), android_package: z.string().optional() }).strict(),
+    },
+    {
+        name: "update_product",
+        title: "Update Product",
+        description: "Patch your own product's fields \u2014 omitted arguments leave their column unchanged, so this cannot blank a field by not mentioning it. Takes appId, optional when your workspace has exactly one product; every other field is snake_case, the same names create_product takes and read the same way. The result lists which fields were actually written, so a name you spelled wrong shows up as a field that did not change rather than as a silent no-op. Free \u2014 no AI call, just a row.",
+        inputSchema: z.object({ appId: z.number().int().optional().describe("Your product's id. Omit only with a single-product workspace."), name: z.string().optional(), slug: z.string().optional(), description: z.string().optional(), website_url: z.string().optional(), niche: z.string().optional(), product_type: z.string().optional(), icon_url: z.string().optional(), primary_cta_label: z.string().optional(), primary_cta_url: z.string().optional(), external_listing_id: z.string().optional(), ios_bundle_id: z.string().optional(), android_package: z.string().optional() }).strict(),
+    },
 ];