diff --git a/changelog.d/channel-notices-reach-who-can-close.fixed.md b/changelog.d/channel-notices-reach-who-can-close.fixed.md
index 70a1f2bb4..123c3c633 100644
--- a/changelog.d/channel-notices-reach-who-can-close.fixed.md
+++ b/changelog.d/channel-notices-reach-who-can-close.fixed.md
@@ -1,8 +1,9 @@
 - The notice that a channel opened without the agent asking (an open its
   own send or reply caused, or a subscription-policy admission) names
   `channel_close` only to an agent that can call it there for every channel
-  it names, except where several residents share one slot (#291), and in
-  forks spawned from the primary afterwards (#235). A conversation fork can
+  it names, except where several residents share one slot (#291), and where
+  a fork's seed still carries it: in an adaptive template's summary, or in a
+  notice long enough for its template to shard or cut. A conversation fork can
   close only its home channel, and an agent's `allowedTools` can leave
   `channel_close` out. Before, such an agent
   was told to use `channel_close`, and couldn't call it, or its call was
diff --git a/changelog.d/fork-seed-primary-notices.fixed.md b/changelog.d/fork-seed-primary-notices.fixed.md
new file mode 100644
index 000000000..401a0aec5
--- /dev/null
+++ b/changelog.d/fork-seed-primary-notices.fixed.md
@@ -0,0 +1 @@
+- Where conversations are routed to per-channel forks (`FrameworkConfig.conversations`), a fork's seed no longer copies its template's channel notices, or its by-name notices of what another agent's reply did. That's each `[channels]` notice of an open, a failed open or a subscription policy's admission, whichever build stored it, and each notice telling the primary by name of another agent's failed reply or channel. They were copied into the forks spawned after them, so a fork serving one channel held which channels other conversations opened and whose replies failed, with advice judged for the primary, such as "use channel_close", which a fork can follow only for its home channel. The template keeps them. A text block that repeats one word for word is left out too, and the spawn's log line counts what was left out: `[conversation] <fork>: seeded from <template> without N thinking block(s), N channel or by-name notice(s), N unanswered tool call(s) and N orphaned tool result(s)`. A summary an adaptive template wrote while one was in its window can still mention it, a notice long enough for its template to shard or cut compiles to other text and stays, and a fork spawned before this change keeps what its seed copied.
diff --git a/src/framework.ts b/src/framework.ts
index 9bea1fd49..f6e389246 100644
--- a/src/framework.ts
+++ b/src/framework.ts
@@ -1373,27 +1373,70 @@ function releasePairedRawItem(block: ContentBlock): ContentBlock {
   return rest as ContentBlock;
 }
 
+/** The text of each notice in `stored` judged for its agent as the primary:
+ *  a channel notice (a system notice of kind `channel-notice`: an open, a
+ *  failed open or a policy admission), and a by-name notice of another
+ *  agent's reply or channel (a system notice with a `speaker`). A fork is
+ *  seeded from its template, which is the primary where connectome-host
+ *  routes conversations, and a seed that kept these would give the fork what
+ *  other conversations did and which channels were opened, with advice
+ *  judged for the primary: a fork closes only its home channel, and only its
+ *  home's traffic is delivered to it. The template's tool calls that caused
+ *  its own notices stay in the seed. `kind: 'channel-notice'` has marked
+ *  every channel notice since the first (0.7.0), so notices stored by
+ *  earlier builds are recognized too, whatever their wording. */
+function primaryNoticeTexts(stored: readonly StoredMessage[]): Set<string> {
+  const texts = new Set<string>();
+  for (const message of stored) {
+    const meta = message.metadata as { system?: unknown; speaker?: unknown; kind?: unknown } | undefined;
+    if (meta?.system !== true) continue;
+    if (typeof meta.speaker !== 'string' && meta.kind !== 'channel-notice') continue;
+    for (const block of message.content) {
+      if (block.type === 'text') texts.add(block.text);
+    }
+  }
+  return texts;
+}
+
+/** Messages copied into a fork's seed without the text blocks whose text is
+ *  in `texts` (primaryNoticeTexts), wherever such a block is. A message with
+ *  no content left is left out, since a request can't carry an empty
+ *  message. */
+function withoutPrimaryNotices<M extends { content: ContentBlock[] }>(messages: readonly M[], texts: ReadonlySet<string>): M[] {
+  const out: M[] = [];
+  for (const message of messages) {
+    const content = message.content.filter((b) => b.type !== 'text' || !texts.has(b.text));
+    if (content.length > 0) out.push({ ...message, content });
+  }
+  return out;
+}
+
 /** One log line for a fork's seed that left something out, so an operator who
  *  sees a fork answer differently from its template has something to check:
- *  the template's thinking blocks, and the tool blocks the pairing pass
- *  dropped (calls with no result in the seed, results whose call isn't in
- *  it). `withoutReasoning` is the seed before that pass, `seed` after it. */
+ *  the template's thinking blocks, its channel and by-name notices
+ *  (primaryNoticeTexts, counting any text block that repeats one word for
+ *  word), and the tool blocks the pairing pass dropped (calls
+ *  with no result in the seed, results whose call isn't in it).
+ *  `withoutReasoning` is the seed without thinking, `withoutNotices` without
+ *  those notices too, and `seed` after the pairing pass. */
 function logSeedOmissions(
   fork: string,
   template: string,
   compiled: readonly { content: ContentBlock[] }[],
   withoutReasoning: readonly { content: ContentBlock[] }[],
+  withoutNotices: readonly { content: ContentBlock[] }[],
   seed: readonly { content: ContentBlock[] }[],
 ): void {
   const count = (messages: readonly { content: ContentBlock[] }[], test: (b: ContentBlock) => boolean) =>
     messages.reduce((n, m) => n + m.content.filter(test).length, 0);
   const thinking = count(compiled, isThinkingBlock);
-  const calls = count(withoutReasoning, (b) => b.type === 'tool_use') - count(seed, (b) => b.type === 'tool_use');
-  const results = count(withoutReasoning, (b) => b.type === 'tool_result') - count(seed, (b) => b.type === 'tool_result');
-  if (thinking + calls + results === 0) return;
+  const notices = count(withoutReasoning, (b) => b.type === 'text') - count(withoutNotices, (b) => b.type === 'text');
+  const calls = count(withoutNotices, (b) => b.type === 'tool_use') - count(seed, (b) => b.type === 'tool_use');
+  const results = count(withoutNotices, (b) => b.type === 'tool_result') - count(seed, (b) => b.type === 'tool_result');
+  if (thinking + notices + calls + results === 0) return;
   console.log(
     `[conversation] ${fork}: seeded from ${template} without ${thinking} thinking block(s), ` +
-    `${calls} unanswered tool call(s) and ${results} orphaned tool result(s)`,
+    `${notices} channel or by-name notice(s), ${calls} unanswered tool call(s) and ${results} orphaned tool result(s)`,
   );
 }
 
@@ -12485,10 +12528,10 @@ export class AgentFramework {
   /**
    * Spawn a persistent per-channel conversation agent ("fork") from the
    * template agent: own ContextManager under `conversations/{name}`, seeded
-   * with the template's compiled context without its thinking or its unpaired
-   * tool blocks (the SubagentModule wholesale-copy pattern; see the seeding
-   * comment below), registered in the event loop like any agent — but never
-   * primary.
+   * with the template's compiled context without its thinking, its channel
+   * and by-name notices, or its unpaired tool blocks (the SubagentModule
+   * wholesale-copy pattern; see the seeding comment below), registered in the
+   * event loop like any agent — but never primary.
    */
   private async createConversationAgent(name: string, channelId: string): Promise<Agent> {
     const router = this.conversationRouter!;
@@ -12550,6 +12593,15 @@ export class AgentFramework {
       // vouch for the copies. On models that don't bind thinking to its
       // prefix a copy would have been kept, so there the fork loses the
       // template's reasoning.
+      // It leaves out, too, the template's channel notices and its by-name
+      // notices of other agents (primaryNoticeTexts), the channel's own next
+      // fork included. The compile carries no metadata, so each text block
+      // whose text is such a notice's in the template's store goes, wherever
+      // it is, a block of the template's own that repeats one word for word
+      // included. A summary an adaptive template wrote while a notice was in
+      // its window can still mention it, and so can the template's own words.
+      // A notice compiled to other text, as one long enough to be sharded at
+      // ingest or cut by a per-message cap, matches nothing and stays.
       // Then context-manager's stripUnpairedToolBlocks drops each call whose
       // result isn't in the seed and each result whose call isn't, keeping
       // the rest of their messages (a message left with nothing becomes its
@@ -12567,8 +12619,10 @@ export class AgentFramework {
         const { messages: compiled } = await template.toolResultGuard.afterAnnotations(
           () => template.getContextManager().compile(undefined, undefined, { dryRun: true }));
         const withoutReasoning = withoutThinking(compiled);
-        const seed = stripUnpairedToolBlocks(withoutReasoning);
-        logSeedOmissions(name, template.name, compiled, withoutReasoning, seed);
+        const withoutNotices = withoutPrimaryNotices(
+          withoutReasoning, primaryNoticeTexts(template.getContextManager().getAllMessages()));
+        const seed = stripUnpairedToolBlocks(withoutNotices);
+        logSeedOmissions(name, template.name, compiled, withoutReasoning, withoutNotices, seed);
         for (const msg of seed) {
           const participant = msg.participant === template.name ? name : msg.participant;
           contextManager.addMessage(participant, msg.content);
@@ -15390,9 +15444,9 @@ export class AgentFramework {
    * outranks policy) only where the agent it's addressed to can call it for
    * every channel it names (canCloseChannels): a conversation fork may close
    * only its home channel, and an agent's allowedTools can leave
-   * channel_close out. Others can read it too: the other residents, where
-   * several share one slot (#291), and forks spawned from the primary
-   * afterwards, from its window (#235). Where an
+   * channel_close out. The other residents can read it too, where several
+   * share one slot (#291); a fork's seed leaves it out (primaryNoticeTexts).
+   * Where an
    * agent's own send opened a channel it can't close, the primary is told by
    * name too, if it's registered and can close it, and the agent is told
    * that it was. What an open channel delivers is its server's to say (#406),
@@ -15626,9 +15680,8 @@ export class AgentFramework {
    * channel_open as the way to try again only where the agent it's addressed
    * to can call it: a conversation fork's channel_open is refused outright
    * (dispatchChannelToolCall), and an agent's allowedTools can leave it out.
-   * Others can read it too: the other residents, where several share one
-   * slot (#291), and forks spawned from the primary afterwards, from its
-   * window (#235).
+   * The other residents can read it too, where several share one slot
+   * (#291); a fork's seed leaves it out (primaryNoticeTexts).
    * Where the channel is selected for opening, it says so and why, as
    * speech's failure does, and what that means: where the host couldn't
    * record putting the channel's decision back, a later delivery or
diff --git a/test/channel-lifecycle-order.test.ts b/test/channel-lifecycle-order.test.ts
index 6e163214d..4ab697a97 100644
--- a/test/channel-lifecycle-order.test.ts
+++ b/test/channel-lifecycle-order.test.ts
@@ -2541,11 +2541,11 @@ test("where a reply's reader can't close a channel selected for opening, the pri
 
 // The opened notice follows the reply notice's rule: channel_close is named
 // only where the agent it's addressed to can call it for every channel named
-// (other residents of one slot, and forks spawned from the primary later, may
-// read it too: #291, #235), and where an
-// agent's send opened a channel it can't close, the primary is told by name
-// too, if it can close it. The reader's notice carries its inputs only where
-// it was told it can close the channels, so a release passes on only that.
+// (other residents of one slot may read it too, #291; a fork's seed leaves it
+// out), and where an agent's send opened a channel it can't close, the
+// primary is told by name too, if it can close it. The reader's notice
+// carries its inputs only where it was told it can close the channels, so a
+// release passes on only that.
 test('the opened notice names channel_close only where the agent it\'s addressed to can call it, says what the channel delivers only to the agent that holds its traffic, and tells the primary by name where the agent whose send opened it can\'t close it', () => {
   // What the channel delivers: said to the agent whose window holds its
   // traffic. Where conversations are routed (router), that's a fork for its
diff --git a/test/conversation-routing.test.ts b/test/conversation-routing.test.ts
index 928047842..d30c2a752 100644
--- a/test/conversation-routing.test.ts
+++ b/test/conversation-routing.test.ts
@@ -252,9 +252,9 @@ describe('Conversation routing', () => {
   }
 
   /** The line a spawn logs for a seed that left something out. */
-  function seedLine(thinking: number, calls: number, results: number): string {
+  function seedLine(thinking: number, calls: number, results: number, notices = 0): string {
     return `[conversation] ${forkName('slack:D3', 1)}: seeded from trunk without ${thinking} thinking block(s), ` +
-      `${calls} unanswered tool call(s) and ${results} orphaned tool result(s)`;
+      `${notices} channel or by-name notice(s), ${calls} unanswered tool call(s) and ${results} orphaned tool result(s)`;
   }
 
   it('fork inherits the template context, and a seed that leaves nothing out logs nothing', async () => {
@@ -481,6 +481,92 @@ describe('Conversation routing', () => {
     await framework.stop();
   });
 
+  it("a fork's seed leaves out the trunk's channel notices and its by-name notices, whichever build stored them, and keeps the rest", async () => {
+    // A stream takes every response queued when it starts, so each fork's
+    // turn gets its response just before that fork spawns.
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
+    const framework = await makeFramework();
+    const trunk = framework.getAgent('trunk')!.getContextManager();
+    trunk.addMessage('user', [{ type: 'text', text: 'HANDBOOK: always check the logs first.' }]);
+    // Not a system notice, so its keys mark nothing.
+    trunk.addMessage('user', [{ type: 'text', text: 'MODULE NOTE: from the ops board.' }], { speaker: 'board', kind: 'channel-notice' });
+    // A live fork, away from its home in the reply notice below.
+    framework.pushEvent(incomingEvent({ channelId: 'slack:D1', text: 'hi', channelType: 'im' }));
+    await framework.runUntilIdle();
+    const live = forkName('slack:D1', 1);
+    assert.ok(framework.getAgent(live), 'the D1 fork is live');
+    const ended = forkName('slack:D9', 1); // never registered, as an agent that has ended
+    const internals = framework as unknown as {
+      passNoticeToPrimary(speaker: string, metadata: Record<string, unknown>): void;
+      recordChannelAutoOpenNotice(agentName: string | undefined, serverId: string, channels: Array<{ channelId: string; label?: string }>, cause: string): void;
+      recordReplyOpenFailedNotice(agentName: string | undefined, serverId: string, channel: { channelId: string; label?: string }, selected?: string): void;
+    };
+    const quiet = mock.method(console, 'error', () => {});
+    try {
+      internals.passNoticeToPrimary(ended, {
+        system: true, kind: 'discord-send-failed', channelId: 'slack:D9', reason: 'rate limited', textLen: 42, outcome: 'failed',
+      });
+      internals.recordChannelAutoOpenNotice(ended, 'srv', [{ channelId: 'slack:D9', label: '@dora' }], 'opened-by-reply');
+      internals.recordReplyOpenFailedNotice(ended, 'srv', { channelId: 'slack:D8', label: '@erin' }, 'subscription-policy');
+      internals.recordReplyOpenFailedNotice(live, 'srv', { channelId: 'slack:D2', label: '@carol' }, 'subscription-policy');
+      internals.recordChannelAutoOpenNotice(undefined, 'srv', [{ channelId: 'slack:D7', label: '@frank' }], 'subscription-policy');
+      // The trunk's own open: its message into a closed channel opened it.
+      internals.recordChannelAutoOpenNotice('trunk', 'srv', [{ channelId: 'slack:C1', label: '#general' }], 'opened-by-reply');
+      // A policy admission as 0.22.3 and 0.22.4 worded and stored it.
+      trunk.addMessage('user', [{
+        type: 'text', text: "[channels] Now open: @gail (slack:D6) — your subscription policy just admitted it. What an open channel delivers to you depends on its server. If you don't want it, use channel_close — your choice sticks; neither policy nor a later send will silently reopen it.",
+      }], { system: true, kind: 'channel-notice' });
+      // The trunk's own failed reply, which onRouteFailure stores in this shape.
+      trunk.addMessage('user', [{
+        type: 'text', text: '[discord-send-failed] Your previous reply (10 chars) could not be delivered to slack:C1 (rate limited). Nothing was posted; it is saved in your archive.',
+      }], { system: true, kind: 'discord-send-failed', channelId: 'slack:C1', reason: 'rate limited', textLen: 10 });
+    } finally {
+      quiet.mock.restore();
+    }
+    const held: Array<[string, RegExp]> = [
+      ["an ended fork's failed reply", /A reply by conversation-slack-D9-g1-\w+ \(42 chars\) could not be delivered to slack:D9/],
+      ['a channel its reply opened', /Now open: @dora \(slack:D9\): a message from conversation-slack-D9-g1-\w+ into the closed channel opened it/],
+      ["a channel its reply couldn't open", /Not open: @erin \(slack:D8\)\. A reply from conversation-slack-D9-g1-\w+ went out there/],
+      ["a channel a live fork's reply couldn't open, which it can't close", /Not open: @carol \(slack:D2\)\. A reply from your fork in slack:D1, named conversation-slack-D1-g1-\w+, went out there/],
+      ['a policy admission', /Selected for opening by subscription policy: @frank \(slack:D7\)/],
+      ["the trunk's own open", /Now open: #general \(slack:C1\): your own message into the closed channel opened it/],
+      ["a policy admission in 0.22.4's words", /Now open: @gail \(slack:D6\) — your subscription policy just admitted it/],
+    ];
+    const kept = ['HANDBOOK', 'MODULE NOTE', 'Your previous reply (10 chars) could not be delivered to slack:C1', 'MY PLAN'];
+    const trunkTexts = trunk.getAllMessages().map((m) => JSON.stringify(m.content));
+    for (const [row, pattern] of held) {
+      assert.equal(trunkTexts.filter((t) => pattern.test(t)).length, 1, `the trunk holds ${row}`);
+    }
+    // A reply of the trunk's own that repeats a notice word for word loses
+    // that block, and keeps the rest.
+    const admission = trunk.getAllMessages().flatMap((m) => m.content)
+      .find((b) => b.type === 'text' && b.text.includes('Selected for opening by subscription policy: @frank')) as { text: string };
+    trunk.addMessage('trunk', [{ type: 'text', text: admission.text }, { type: 'text', text: 'MY PLAN: answer the ops board first.' }]);
+
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
+    const { seeded, lines } = await seedOf(framework);
+    const seedTexts = seeded.map((m) => JSON.stringify(m.content));
+    for (const [row, pattern] of held) {
+      assert.ok(!seedTexts.some((t) => pattern.test(t)), `the seed leaves out ${row}`);
+    }
+    for (const text of kept) assert.ok(seedTexts.some((t) => t.includes(text)), `the seed keeps ${text}`);
+    assert.ok(seeded.every((m) => m.content.length > 0), 'no message is stored empty');
+    assert.deepEqual(lines, [seedLine(0, 0, 0, held.length + 1)], 'the line counts the notices left out, and the repeat');
+    const after = trunk.getAllMessages().map((m) => JSON.stringify(m.content));
+    for (const [row, pattern] of held) assert.ok(after.some((t) => pattern.test(t)), `the trunk keeps ${row}`);
+
+    // The ended fork's own channel spawns its next generation from the trunk too.
+    framework.getConversationRouter()!.hydrateGenerations({ 'slack:D9': 1 });
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
+    framework.pushEvent(incomingEvent({ channelId: 'slack:D9', text: 'back again', channelType: 'im' }));
+    await framework.runUntilIdle();
+    const next = framework.getAgent(forkName('slack:D9', 2))!.getContextManager().getAllMessages()
+      .map((m) => JSON.stringify(m.content));
+    assert.ok(next.some((t) => t.includes('HANDBOOK')), "the channel's next fork is seeded from the trunk");
+    for (const [row, pattern] of held) assert.ok(!next.some((t) => pattern.test(t)), `the channel's next fork leaves out ${row}`);
+    await framework.stop();
+  });
+
   it("a fork whose namespace already holds history isn't seeded again", async () => {
     membrane.pushResponse(createMockResponse([{ type: 'text', text: 'noted' }]));
     const fw1 = await makeFramework({}, 'reseed.chronicle');