diff --git a/.changeset/publish-multi-search-id.md b/.changeset/publish-multi-search-id.md
new file mode 100644
index 0000000..a8577d5
--- /dev/null
+++ b/.changeset/publish-multi-search-id.md
@@ -0,0 +1,25 @@
+---
+'tenjin-cli': patch
+---
+
+One piece can now claim every search it answered.
+
+`tenjin publish --search-id` repeats, up to ten searches per piece. A research
+thread fans out into many searchIds — one investigation last month logged ten
+MISSes for what was a single question — and until now the piece published back
+against one of them while the other nine were closed one at a time as
+`regenerated`. That was false twice over: they were not re-derived, they were
+answered by the same piece, and MISS-to-publish conversion counted every sibling
+of the thread as a failure.
+
+Every named id closes its own local loop with publish attribution, re-linking one
+an `outcome` already closed exactly as a single id does today, and the JSON
+envelope reports each id separately (`searches`), so an id this machine has never
+recorded warns for itself instead of taking the rest down with it. A lone id
+keeps the flat `search` field callers already read. Repeats collapse. A `--draft`
+still answers nobody and sends no attribution at all.
+
+On the wire, one id ships as the bare string it has always been, so a
+single-search publish is byte-identical against a server that predates this;
+several ship as an array, which needs the array-accepting post-create deployed
+first.
diff --git a/docs/command-reference.md b/docs/command-reference.md
index 70c32fd..e909748 100644
--- a/docs/command-reference.md
+++ b/docs/command-reference.md
@@ -164,25 +164,25 @@ Reports how a search ended.
 
 Publishes Markdown with optional metadata and a local safety scan. Hard blocks cannot be bypassed.
 
-| Flag                       | Effect                                              |
-| -------------------------- | --------------------------------------------------- |
-| `--search-id <uuid>`       | Link the piece to the search it answers.            |
-| `--draft`                  | Save privately instead of publishing.               |
-| `--price <usd>`            | Set the post price.                                 |
-| `--excerpt <text>`         | Public preview.                                     |
-| `--mode <mode>`            | `review`, `auto`, or `full-auto` for this run.      |
-| `--yes`                    | Clear warning findings and the review confirmation. |
-| `--question <text>`        | Question this piece answers. Repeatable.            |
-| `--task <text>`            | Task this piece supports. Repeatable.               |
-| `--scope <text>`           | What the piece covers.                              |
-| `--exclusions <text>`      | What it does not cover.                             |
-| `--applies-to <key=v1,v2>` | Applicability metadata. Repeatable.                 |
-| `--as-of <time>`           | When evidence was gathered.                         |
-| `--valid-until <time>`     | When the answer expires.                            |
-| `--artifact-type <type>`   | `document`, `skill`, or `dataset`.                  |
-| `--temporal-mode <mode>`   | `snapshot`, `maintained`, or `evergreen`.           |
-| `--provenance <text>`      | How evidence was obtained.                          |
-| `--methodology <text>`     | How it was established.                             |
+| Flag                       | Effect                                                                   |
+| -------------------------- | ------------------------------------------------------------------------ |
+| `--search-id <uuid>`       | Link the piece to the search it answers. Repeatable, up to 10 per piece. |
+| `--draft`                  | Save privately instead of publishing.                                    |
+| `--price <usd>`            | Set the post price.                                                      |
+| `--excerpt <text>`         | Public preview.                                                          |
+| `--mode <mode>`            | `review`, `auto`, or `full-auto` for this run.                           |
+| `--yes`                    | Clear warning findings and the review confirmation.                      |
+| `--question <text>`        | Question this piece answers. Repeatable.                                 |
+| `--task <text>`            | Task this piece supports. Repeatable.                                    |
+| `--scope <text>`           | What the piece covers.                                                   |
+| `--exclusions <text>`      | What it does not cover.                                                  |
+| `--applies-to <key=v1,v2>` | Applicability metadata. Repeatable.                                      |
+| `--as-of <time>`           | When evidence was gathered.                                              |
+| `--valid-until <time>`     | When the answer expires.                                                 |
+| `--artifact-type <type>`   | `document`, `skill`, or `dataset`.                                       |
+| `--temporal-mode <mode>`   | `snapshot`, `maintained`, or `evergreen`.                                |
+| `--provenance <text>`      | How evidence was obtained.                                               |
+| `--methodology <text>`     | How it was established.                                                  |
 
 ### `tenjin edit <post-id>`
 
diff --git a/skills/tenjin-publish/SKILL.md b/skills/tenjin-publish/SKILL.md
index 0bbf61d..82980b8 100644
--- a/skills/tenjin-publish/SKILL.md
+++ b/skills/tenjin-publish/SKILL.md
@@ -179,8 +179,10 @@ tenjin publish <file.md> --json [--search-id <id>] [--draft]
 Pass `--search-id <id>` when the piece answers a search that MISSed: it closes
 that loop, prefills the searched question into `questionsAnswered` when the draft
 names none, and travels to the server as this piece's attribution. It re-links a
-loop an `outcome` already closed, so a premature close is recoverable. `--draft`
-saves a private draft, leaves the loop open, and sends no attribution.
+loop an `outcome` already closed, so a premature close is recoverable. Repeat it
+(up to 10) when one thread fanned out into several searches this one piece
+answers, rather than closing the siblings as `regenerated`. `--draft` saves a
+private draft, leaves the loop open, and sends no attribution.
 
 **On any exit 3, render THAT payload's findings and price as one yes/no, then
 re-run with `--yes` on an explicit yes.** Never ask a generic "shall I publish?"
diff --git a/src/cli.test.ts b/src/cli.test.ts
index 88069b5..c8cf154 100644
--- a/src/cli.test.ts
+++ b/src/cli.test.ts
@@ -331,6 +331,28 @@ describe('edit flag forwarding (the dispatcher mapping)', () => {
   });
 });
 
+/**
+ * An option that did not collect would keep the LAST id and drop the rest. Read
+ * back through the cap refusal, which only eleven surviving ids can trip.
+ */
+describe('publish --search-id collects (the dispatcher mapping)', () => {
+  it('repeats rather than replacing, and the cap counts every id given', async () => {
+    const ids = Array.from(
+      { length: 11 },
+      (_, i) => `0197bbbb-cccc-7ddd-8eee-0000000000${String(i).padStart(2, '0')}`,
+    );
+    const cap = captureIo();
+    const code = await main(
+      ['publish', 'nope.md', ...ids.flatMap((id) => ['--search-id', id]), '--json'],
+      cap.io,
+    );
+    expect(code).toBe(2);
+    const parsed = JSON.parse(cap.stdout());
+    expect(parsed.command).toBe('publish');
+    expect(parsed.error.message).toContain('at most 10 searches (got 11)');
+  });
+});
+
 /**
  * The `session` group. Dispatcher-level only: `session start` reaches a wallet,
  * so the cases here are the ones that resolve BEFORE it — the group exists, the
diff --git a/src/cli.ts b/src/cli.ts
index 852716d..f21cb02 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -472,7 +472,9 @@ export function buildProgram(io: Io, setExit: (code: number) => void): Command {
     )
     .option(
       '--search-id <id>',
-      'the search this file answers (closes its open loop, and prefills its question)',
+      'the search this file answers (closes its open loop, and prefills its question); repeatable, up to 10, when one piece answers a whole research thread',
+      collect,
+      [],
     )
     .option('--draft', 'save as a private draft instead of publishing')
     .option('--yes', 'clear soft findings and the review confirm (never a hard block)')
@@ -500,7 +502,9 @@ export function buildProgram(io: Io, setExit: (code: number) => void): Command {
         return runPublish(
           {
             ...(typeof file === 'string' ? { file } : {}),
-            ...(typeof o.searchId === 'string' ? { searchId: o.searchId } : {}),
+            ...(Array.isArray(o.searchId) && o.searchId.length > 0
+              ? { searchId: o.searchId as string[] }
+              : {}),
             ...(o.draft === true ? { draft: true } : {}),
             ...(o.yes === true ? { yes: true } : {}),
             ...(typeof o.mode === 'string' ? { mode: o.mode } : {}),
diff --git a/src/commands/publish.test.ts b/src/commands/publish.test.ts
index 31c7541..09a1122 100644
--- a/src/commands/publish.test.ts
+++ b/src/commands/publish.test.ts
@@ -119,6 +119,23 @@ function stubServer(post: Record<string, unknown> = CREATED): {
   return { fetch: fetchFn, calls };
 }
 
+/** A stub server that also captures the parsed request body. */
+function bodyServer(): { fetch: typeof fetch; body: () => Record<string, unknown> | undefined } {
+  let captured: Record<string, unknown> | undefined;
+  const fetchFn = (async (_url: string | URL, init?: RequestInit) => {
+    captured = typeof init?.body === 'string' ? JSON.parse(init.body) : undefined;
+    return new Response(JSON.stringify(CREATED), {
+      status: 201,
+      headers: { 'content-type': 'application/json' },
+    });
+  }) as unknown as typeof fetch;
+  return { fetch: fetchFn, body: () => captured };
+}
+
+function questionsIn(body: Record<string, unknown> | undefined): string[] | undefined {
+  return (body?.resource as { questionsAnswered?: string[] } | undefined)?.questionsAnswered;
+}
+
 async function writeDoc(content: string): Promise<string> {
   const path = join(dir, 'post.md');
   await writeFile(path, content, 'utf8');
@@ -588,23 +605,6 @@ describe('runPublish — publish <file> --search-id', () => {
     });
   }
 
-  /** A stub server that also captures the parsed request body. */
-  function bodyServer(): { fetch: typeof fetch; body: () => Record<string, unknown> | undefined } {
-    let captured: Record<string, unknown> | undefined;
-    const fetchFn = (async (_url: string | URL, init?: RequestInit) => {
-      captured = typeof init?.body === 'string' ? JSON.parse(init.body) : undefined;
-      return new Response(JSON.stringify(CREATED), {
-        status: 201,
-        headers: { 'content-type': 'application/json' },
-      });
-    }) as unknown as typeof fetch;
-    return { fetch: fetchFn, body: () => captured };
-  }
-
-  function questionsIn(body: Record<string, unknown> | undefined): string[] | undefined {
-    return (body?.resource as { questionsAnswered?: string[] } | undefined)?.questionsAnswered;
-  }
-
   // The gap this flag closes: the path the Stop hook and the auto-mode skill
   // prescribe is a bare file publish, which left the loop open.
   it('resolves the named search on a successful file publish', async () => {
@@ -886,6 +886,146 @@ describe('runPublish — publish <file> --search-id', () => {
   });
 });
 
+/**
+ * One research thread fans out into many searchIds and a piece answers the
+ * thread, not one query of it (#167). The siblings used to be closed as
+ * `regenerated`, which reads as failures of a loop that actually converted.
+ */
+describe('runPublish — a piece that answers a whole thread', () => {
+  const A = '0197bbbb-cccc-7ddd-8eee-aaaaaaaaaaaa';
+  const B = '0197bbbb-cccc-7ddd-8eee-bbbbbbbbbbbb';
+  const C = '0197bbbb-cccc-7ddd-8eee-cccccccccccc';
+  const D = '0197bbbb-cccc-7ddd-8eee-dddddddddddd';
+
+  async function seed(searchId: string, question: string): Promise<void> {
+    await recordSearch(dir, {
+      searchId,
+      at: new Date().toISOString(),
+      question,
+      decision: 'MISS',
+      candidates: [],
+    });
+  }
+
+  function searchesIn(res: { data: unknown }): unknown[] | undefined {
+    return (res.data as { searches?: unknown[] }).searches;
+  }
+
+  async function publishWith(ids: string[], over: Partial<PublishArgs> = {}) {
+    const { fetch, body } = bodyServer();
+    const { ctx, stderr } = makeCtxCapturingStderr();
+    const res = await runPublish(
+      baseArgs(await writeDoc(CLEAN), { searchId: ids, mode: 'auto', ...over }),
+      ctx,
+      hermetic({ fetchImpl: fetch, provider: spyProvider().provider }),
+    );
+    return { res, body, stderr };
+  }
+
+  // The wire rule the server rollout depends on: a CLI that never names two
+  // keeps working against a post-create that only takes a scalar.
+  it('sends a bare string for one id and an array for several', async () => {
+    await seed(A, 'first');
+    const one = await publishWith([A]);
+    expect(one.body()?.searchId).toBe(A);
+
+    await seed(B, 'second');
+    const many = await publishWith([A, B]);
+    expect(many.body()?.searchId).toEqual([A, B]);
+  });
+
+  // A repeat collapses in the ledger too, not only on the wire.
+  it('collapses a repeated id on the wire and in the receipt', async () => {
+    await seed(A, 'first');
+    await seed(B, 'second');
+    const { res, body } = await publishWith([A, B, A]);
+    expect(body()?.searchId).toEqual([A, B]);
+    expect(searchesIn(res)).toHaveLength(2);
+  });
+
+  it('refuses more than ten searches before any wallet touch', async () => {
+    const ids = Array.from(
+      { length: 11 },
+      (_, i) => `0197bbbb-cccc-7ddd-8eee-0000000000${String(i).padStart(2, '0')}`,
+    );
+    const { fetch, calls } = stubServer();
+    const { provider, getSignerCount } = spyProvider();
+    await expect(
+      runPublish(
+        baseArgs(await writeDoc(CLEAN), { searchId: ids, mode: 'auto' }),
+        makeCtx(),
+        hermetic({ fetchImpl: fetch, provider }),
+      ),
+    ).rejects.toMatchObject({ code: 'USAGE' });
+    expect(calls).toHaveLength(0);
+    expect(getSignerCount()).toBe(0);
+  });
+
+  // Four local states, differing in who holds the attribution. The id this
+  // machine never heard of must not take the rest down with it.
+  it('closes each named search on its own terms, absent ones included', async () => {
+    await seed(A, 'closeable');
+    await seed(B, 'closed by an outcome report');
+    await seed(C, 'closed by an earlier publish');
+    await markSearchResolved(dir, B, 'outcome');
+    await markSearchResolved(dir, C, 'publish');
+
+    const { res, stderr } = await publishWith([A, B, C, D]);
+
+    expect(searchesIn(res)).toEqual([
+      { id: A, closed: true, prefill: 'applied' },
+      { id: B, closed: true, relinked: true, prefill: 'none' },
+      { id: C, closed: true, alreadyAnswered: true, prefill: 'none' },
+      { id: D, closed: false, prefill: 'none' },
+    ]);
+    const stored = await loadSearches(dir);
+    for (const id of [A, B, C]) {
+      expect(stored.find((s) => s.searchId === id)?.resolved?.by, id).toBe('publish');
+    }
+    expect(stderr()).toContain(`search ${D} is not in the local store`);
+    expect(res.humanLines).toContain(`Closed the loop on search ${A}.`);
+    expect(res.humanLines).toContain(
+      `Re-linked search ${B} to this piece; it had been closed without one.`,
+    );
+    expect(res.humanLines).toContain(`Search ${C} was already answered by an earlier publish.`);
+  });
+
+  // One card, so one prefill: only the first recorded search lends its phrasing.
+  it('prefills the card from the first stored search and says which one', async () => {
+    await seed(B, 'the phrasing that ships');
+    const { res, body } = await publishWith([A, B, C]);
+    expect(questionsIn(body())).toEqual(['the phrasing that ships']);
+    expect(searchesIn(res)).toEqual([
+      { id: A, closed: false, prefill: 'none' },
+      { id: B, closed: true, prefill: 'applied' },
+      { id: C, closed: false, prefill: 'none' },
+    ]);
+  });
+
+  it('sends no searchId on a multi-id draft and leaves every loop open', async () => {
+    await seed(A, 'first');
+    await seed(B, 'second');
+    const { res, body } = await publishWith([A, B], { draft: true });
+    expect(body()).not.toHaveProperty('searchId');
+    expect((await loadSearches(dir)).every((s) => s.resolved === undefined)).toBe(true);
+    expect(searchesIn(res)?.every((s) => (s as { closed: boolean }).closed === false)).toBe(true);
+  });
+
+  // `search` is what callers have read since #161: it survives for a lone id.
+  it('keeps the flat search field for one id and drops it for several', async () => {
+    await seed(A, 'first');
+    const one = await publishWith([A]);
+    expect((one.res.data as { search?: unknown }).search).toEqual({
+      id: A,
+      closed: true,
+      prefill: 'applied',
+    });
+    await seed(B, 'second');
+    const many = await publishWith([A, B]);
+    expect(many.res.data).not.toHaveProperty('search');
+  });
+});
+
 describe('runPublish — the public preview (--excerpt)', () => {
   /** A stub server that also captures the parsed request body. */
   function bodyServer(): { fetch: typeof fetch; body: () => Record<string, unknown> | undefined } {
diff --git a/src/commands/publish.ts b/src/commands/publish.ts
index dd48eb1..d0a9339 100644
--- a/src/commands/publish.ts
+++ b/src/commands/publish.ts
@@ -22,9 +22,9 @@ import {
 } from '../lib/card';
 import {
   publishPost,
+  normalizeSearchIds,
   EXCERPT_MAX_LENGTH,
   PUBLISH_STATUSES,
-  SEARCH_ID_WIRE_RE,
   type PublishInput,
   type PublishStatus,
 } from '../lib/posts-api';
@@ -55,8 +55,8 @@ import type { CommandContext, CommandResult } from '../context';
 export interface PublishArgs {
   /** The Markdown file to publish. */
   file?: string;
-  /** The search this publish answers; closes its open loop. */
-  searchId?: string;
+  /** The search(es) this publish answers; closes each open loop. */
+  searchId?: string | string[];
   draft?: boolean;
   yes?: boolean;
   /** Raw `--mode` (review|auto|full-auto); validated at the edge (USAGE on a bad value). */
@@ -101,16 +101,13 @@ export async function runPublish(
   // typo like `--mode Review` must never be silently dropped onto a looser mode
   // and publish unconfirmed. Mirrors install's --publish-mode edge check.
   if (args.mode !== undefined) parsePublishModeFlag(args.mode, '--mode');
-  validateSearchId(args);
+  const searchIds = normalizeSearchIds(args.searchId, '--search-id');
 
   const raw = await readSource(args);
-  // Read the named search ONCE, here: it prefills the card's question below, and
-  // whether it was found decides what the post-publish close reports. Local read,
-  // and a missing store reads as no entry rather than failing the publish.
-  const storedSearch =
-    args.searchId !== undefined
-      ? ((await loadSearches(ctx.dataDir)).find((s) => s.searchId === args.searchId) ?? null)
-      : null;
+  // Read the named searches ONCE, here: one prefills the card's question below,
+  // and each id's presence decides what its close reports. A missing store reads
+  // as no entries rather than failing the publish.
+  const stored = await loadNamedSearches(ctx, searchIds);
   const { frontmatter, body } = parseFrontmatter(raw);
 
   const status = resolveStatus(args, frontmatter);
@@ -122,7 +119,9 @@ export async function runPublish(
   // fallback: an explicit --question OR a frontmatter questionsAnswered still
   // wins. That phrasing is what the next searcher will send.
   const cardFlags = cardFlagsFrom(args);
-  const wanted = storedSearch?.question;
+  // One card, so one prefill: the first recorded id. The rest are attribution.
+  const prefillFrom = searchIds.find((id) => stored.get(id)?.question !== undefined);
+  const wanted = prefillFrom === undefined ? undefined : stored.get(prefillFrom)?.question;
   const prefillQuestion = wanted === undefined ? undefined : cardQuestion(wanted);
   const roomForPrefill =
     cardFlags.question === undefined && frontmatter.questionsAnswered === undefined;
@@ -246,7 +245,7 @@ export async function runPublish(
     // demand either. Sending it on a draft put one demand signal on two posts —
     // no command promotes a draft, so reaching a public piece means a second
     // publish carrying the same id — with one of them possibly never shipping.
-    ...(args.searchId !== undefined && status !== 'draft' ? { searchId: args.searchId } : {}),
+    ...(searchIds.length > 0 && status !== 'draft' ? { searchId: searchIds } : {}),
   };
 
   const result = await publishPost(input, auth, {
@@ -260,11 +259,31 @@ export async function runPublish(
   // what resolves it.
   const parksPrivately = status === 'draft';
 
-  let searchInfo: SearchReceipt | undefined;
-  if (args.searchId !== undefined) {
-    searchInfo = await closeNamedSearch(ctx, args.searchId, storedSearch, parksPrivately, prefill);
+  // One close per id, each reporting for itself: the piece is published and the
+  // server has every id, so an unrecorded search warns without costing the rest.
+  const searches: SearchReceipt[] = [];
+  for (const id of searchIds) {
+    searches.push(
+      await closeNamedSearch(
+        ctx,
+        id,
+        stored.get(id) ?? null,
+        parksPrivately,
+        id === prefillFrom ? prefill : 'none',
+      ),
+    );
   }
-  return receipt(result, runtime.baseUrl, searchInfo);
+  return receipt(result, runtime.baseUrl, searches);
+}
+
+async function loadNamedSearches(
+  ctx: CommandContext,
+  searchIds: string[],
+): Promise<Map<string, StoredSearch>> {
+  if (searchIds.length === 0) return new Map();
+  const searches = await loadSearches(ctx.dataDir);
+  const wanted = new Set(searchIds);
+  return new Map(searches.filter((s) => wanted.has(s.searchId)).map((s) => [s.searchId, s]));
 }
 
 /**
@@ -298,24 +317,6 @@ interface SearchReceipt {
  */
 type PrefillOutcome = 'applied' | 'dropped-too-long' | 'none';
 
-/**
- * `--search-id` at the edge: a uuid, refused before any wallet touch so a typo
- * costs a message rather than a signing prompt.
- *
- * Checked against the shape the SERVER declares, not the looser local UUID_RE,
- * because this value is now sent on the publish body: an id that satisfied only
- * the local shape would be refused by the server as a 400, and that refusal
- * would arrive after the wallet signature rather than here.
- */
-function validateSearchId(args: PublishArgs): void {
-  if (args.searchId === undefined) return;
-  if (!SEARCH_ID_WIRE_RE.test(args.searchId)) {
-    throw new CliError('USAGE', `Invalid --search-id: ${JSON.stringify(args.searchId)}.`, {
-      fix: 'Pass the searchId from a prior `tenjin search` (a uuid).',
-    });
-  }
-}
-
 /**
  * Close the loop a `--search-id` file publish named, and say what happened in
  * both registers: a stderr line for a human, the returned receipt for `--json`.
@@ -392,7 +393,7 @@ async function readSource(args: PublishArgs): Promise<string> {
 function receipt(
   result: Awaited<ReturnType<typeof publishPost>>,
   baseUrl: string,
-  searchInfo?: SearchReceipt,
+  searches: SearchReceipt[],
 ): CommandResult {
   const price = toMoney(result.priceAtomic);
   const missing = missingSentences(result.cacheEligibleMissing).map(sanitizeForTerminal);
@@ -409,15 +410,7 @@ function receipt(
       : missing.length > 0
         ? `Answer card not search-eligible yet: ${missing.join(' ')}`
         : 'Published as a browse-only document (no answer card).',
-    ...(searchInfo?.closed === true
-      ? [
-          searchInfo.relinked === true
-            ? `Re-linked search ${searchInfo.id} to this piece; it had been closed without one.`
-            : searchInfo.alreadyAnswered === true
-              ? `Search ${searchInfo.id} was already answered by an earlier publish.`
-              : `Closed the loop on search ${searchInfo.id}.`,
-        ]
-      : []),
+    ...searches.filter((s) => s.closed).map(closeLine),
     ...result.warnings.map((w) => `warning: ${sanitizeForTerminal(w)}`),
   ];
   return {
@@ -429,13 +422,26 @@ function receipt(
       cacheEligible,
       missing,
       deskUrl,
-      ...(searchInfo !== undefined ? { search: searchInfo } : {}),
+      // `search` repeats a lone result for callers that already read it; a
+      // batch has no single one to repeat.
+      ...(searches.length === 1 ? { search: searches[0] } : {}),
+      ...(searches.length > 0 ? { searches } : {}),
       ...(result.warnings.length > 0 ? { warnings: result.warnings } : {}),
     },
     humanLines: human,
   };
 }
 
+function closeLine(search: SearchReceipt): string {
+  if (search.relinked === true) {
+    return `Re-linked search ${search.id} to this piece; it had been closed without one.`;
+  }
+  if (search.alreadyAnswered === true) {
+    return `Search ${search.id} was already answered by an earlier publish.`;
+  }
+  return `Closed the loop on search ${search.id}.`;
+}
+
 // ---------------------------------------------------------------------------
 // Field resolution.
 // ---------------------------------------------------------------------------
diff --git a/src/lib/posts-api.test.ts b/src/lib/posts-api.test.ts
index 6386435..ec84310 100644
--- a/src/lib/posts-api.test.ts
+++ b/src/lib/posts-api.test.ts
@@ -11,6 +11,9 @@ import type { SignableRequest, WriteAuth } from './session-key';
 
 const OPTS = { baseUrl: 'https://tenjin.blog', timeoutMs: 5000 };
 
+const SEARCH_A = '0197aaaa-bbbb-7ccc-8ddd-eeeeeeeeeeee';
+const SEARCH_B = '0197aaaa-bbbb-7ccc-8ddd-ffffffffffff';
+
 interface CapturedCall {
   url: string;
   method: string;
@@ -130,6 +133,33 @@ describe('buildPostCreateBody — bounds', () => {
     expect(() => buildPostCreateBody({ status: 'draft', handle: 'A!' })).toThrow();
   });
 
+  // The wire rule the server rollout turns on: one search stays the bare string
+  // a post-create that predates the array still takes.
+  it('ships one searchId as a bare string and several as an array', () => {
+    const base = { status: 'published', title: 'T', bodyMd: 'B' } as const;
+    expect(buildPostCreateBody({ ...base, searchId: SEARCH_A }).searchId).toBe(SEARCH_A);
+    expect(buildPostCreateBody({ ...base, searchId: [SEARCH_A] }).searchId).toBe(SEARCH_A);
+    expect(buildPostCreateBody({ ...base, searchId: [SEARCH_A, SEARCH_B] }).searchId).toEqual([
+      SEARCH_A,
+      SEARCH_B,
+    ]);
+    expect(buildPostCreateBody({ ...base, searchId: [SEARCH_A, SEARCH_A] }).searchId).toBe(
+      SEARCH_A,
+    );
+  });
+
+  it('refuses a bad searchId anywhere in the list, and more than ten of them', () => {
+    const base = { status: 'published', title: 'T', bodyMd: 'B' } as const;
+    expect(() => buildPostCreateBody({ ...base, searchId: [SEARCH_A, 'nope'] })).toThrow(
+      /Invalid searchId/,
+    );
+    const eleven = Array.from(
+      { length: 11 },
+      (_, i) => `0197aaaa-bbbb-7ccc-8ddd-0000000000${String(i).padStart(2, '0')}`,
+    );
+    expect(() => buildPostCreateBody({ ...base, searchId: eleven })).toThrow(/at most 10 searches/);
+  });
+
   it('emits only defined keys (strictObject-safe), status last', () => {
     const body = buildPostCreateBody({
       status: 'published',
diff --git a/src/lib/posts-api.ts b/src/lib/posts-api.ts
index 137b656..70f9734 100644
--- a/src/lib/posts-api.ts
+++ b/src/lib/posts-api.ts
@@ -38,11 +38,12 @@ export interface PublishInput {
   status: PublishStatus;
   resource?: ResourceCardInput;
   /**
-   * The search whose MISS motivated this piece, so the marketplace can attribute
-   * supply to the demand that asked for it (tenjin-agent #161). Stored
-   * server-side only and never echoed back, so nothing downstream reads it.
+   * The search(es) whose MISS motivated this piece, so the marketplace can
+   * attribute supply to the demand that asked for it (tenjin-agent #161, #167).
+   * Several because one thread fans out into many searchIds and a piece answers
+   * the thread. Stored server-side only and never echoed back.
    */
-  searchId?: string;
+  searchId?: string | string[];
 }
 
 /** The exact strictObject body sent to POST /api/posts (defined keys only). */
@@ -55,7 +56,7 @@ export interface PostCreateBody {
   handle?: string;
   status?: PublishStatus;
   resource?: ResourceCardInput;
-  searchId?: string;
+  searchId?: string | string[];
 }
 
 const PRICE_RE = /^(0|[1-9]\d{0,12})$/;
@@ -71,6 +72,49 @@ const HANDLE_RE = /^[a-z0-9-]{2,32}$/;
  */
 export const SEARCH_ID_WIRE_RE =
   /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
+/** How many searches one piece may claim, mirroring the server's cap. */
+export const SEARCH_ID_MAX = 10;
+
+/**
+ * The searchIds a publish claims: deduped (naming one twice says it once, not
+ * twice), each checked against the shape the SERVER declares, and capped. Run
+ * by the command edge before the wallet touch, so a typo costs a message rather
+ * than a signature, and again by the builder, the last gate before a signed body.
+ */
+export function normalizeSearchIds(
+  searchId: string | string[] | undefined,
+  label: string,
+): string[] {
+  if (searchId === undefined) return [];
+  const ids = [...new Set(typeof searchId === 'string' ? [searchId] : searchId)];
+  for (const id of ids) {
+    if (!SEARCH_ID_WIRE_RE.test(id)) {
+      throw new CliError('USAGE', `Invalid ${label}: ${JSON.stringify(id)}`, {
+        fix: 'Pass the searchId from a prior `tenjin search` (a uuid).',
+      });
+    }
+  }
+  if (ids.length > SEARCH_ID_MAX) {
+    throw new CliError(
+      'USAGE',
+      `One piece claims at most ${SEARCH_ID_MAX} searches (got ${ids.length}).`,
+      {
+        fix: `Name the ${SEARCH_ID_MAX} this piece actually answers, then close the rest with \`tenjin outcome --search-id <id> --status regenerated\`.`,
+      },
+    );
+  }
+  return ids;
+}
+
+/**
+ * A lone id ships as the bare string it has always been, byte-identical against
+ * a server that predates the array; several need that server deployed.
+ */
+function toWireSearchId(ids: string[]): string | string[] | undefined {
+  if (ids.length === 0) return undefined;
+  return ids.length === 1 ? ids[0] : ids;
+}
+
 /**
  * The server's `excerpt` bound (pinned against the OpenAPI fixture in
  * contract.test.ts). Exported so `publish` can refuse an over-long one at its own
@@ -205,11 +249,7 @@ export function buildPostCreateBody(input: PublishInput): PostCreateBody {
     }
   }
 
-  if (input.searchId !== undefined && !SEARCH_ID_WIRE_RE.test(input.searchId)) {
-    throw new CliError('USAGE', `Invalid searchId: ${JSON.stringify(input.searchId)}`, {
-      fix: 'Pass the searchId from a prior `tenjin search` (a uuid).',
-    });
-  }
+  const searchId = toWireSearchId(normalizeSearchIds(input.searchId, 'searchId'));
 
   return {
     ...(title !== undefined && title.length > 0 ? { title } : {}),
@@ -223,7 +263,7 @@ export function buildPostCreateBody(input: PublishInput): PostCreateBody {
     // Sent whatever the LOCAL loop says, including on a relink and on a draft:
     // the server stores it against this post, and whether some earlier `outcome`
     // already reported on the search is not a fact about who answered it.
-    ...(input.searchId !== undefined ? { searchId: input.searchId } : {}),
+    ...(searchId !== undefined ? { searchId } : {}),
   };
 }
 
diff --git a/src/mcp/server.ts b/src/mcp/server.ts
index ad9e8b2..29a512d 100644
--- a/src/mcp/server.ts
+++ b/src/mcp/server.ts
@@ -131,11 +131,12 @@ const outcomeInput = {
 
 const publishInput = {
   file: z.string().optional().describe('Path to the Markdown file to publish'),
+  // A lone string stays valid: agents already send one, and the batch is additive.
   searchId: z
-    .string()
+    .union([z.string(), z.array(z.string())])
     .optional()
     .describe(
-      'The search this file answers; closes its open loop and prefills its question when the draft names none',
+      'The search this file answers, or every search of one thread it answers (max 10); closes each open loop and prefills the first question when the draft names none',
     ),
   draft: z.boolean().optional().describe('Save as a private draft instead of publishing'),
   yes: z