@agfpd/iapeer 0.2.33 → 0.2.35

package/src/launch/composeSystemPrompt.ts

@@ -55,10 +55,33 @@ function jqJson(value: string): string {
     .replace(new RegExp(String.fromCharCode(0x00), 'g'), '\\u0000')
 }
 
+/** A per-file section: a path marker line, then the file content. The marker is an
+ *  HTML comment — inert in rendered markdown yet plainly visible in the raw system-
+ *  prompt the model reads (verified: the model's context surfaces HTML comments) —
+ *  so a reader (human or agent) can tell, per file, exactly which path each chunk of
+ *  the assembled prompt came from. No marker when `path` is absent (a pure-renderer
+ *  caller, or the synthesized Layer-1 YAML / Layer-3 registry which are not files). */
+function markedSection(path: string | undefined, content: string): string {
+  return path ? `<!-- ${path} -->\n${content}` : content
+}
+
+/** Trailing-newline-trimmed length test: a 0-byte or newline-only file is "empty"
+ *  and contributes no section (and so no dangling marker). */
+function hasContent(s: string | undefined): s is string {
+  return s !== undefined && s.replace(/\n+$/, '').length > 0
+}
+
 /**
- * Compose the merged system prompt (YAML identity block + optional global
- * doctrine + per-peer doctrine), GOLDEN byte-for-byte equivalent to the
- * claude-start.sh:264-290 jq pipeline.
+ * Compose the merged system prompt: the YAML identity block (Layer 1) followed by
+ * every file-sourced layer rendered PER FILE — each injected `.md` prefixed by a
+ * path marker (`<!-- <path> -->`). Layers, general → specific:
+ *   1. YAML identity block (synthesized, no marker) — byte-for-byte the jq layout.
+ *   2. IAPEER.md doctrine: global then local, each its own marked section.
+ *   3. Normalized peer registry (generated, no marker).
+ *   4. Other `<DOMAIN>.md` at the .iapeer root — each half (global, local) marked.
+ *   5. fragments/ `*.md` — each half marked. Most-volatile, sits LAST.
+ * Empty files contribute nothing (no section, no marker). Sections are joined by a
+ * single blank line and the output ends with exactly one newline.
  */
 export function composeSystemPrompt(input: ComposePromptInput): string {
   // The eight identity lines, in the bash's exact key order. Keys verbatim:
@@ -77,38 +100,37 @@ export function composeSystemPrompt(input: ComposePromptInput): string {
     // jq's final "" array element → the bare blank line after the closing '---'.
     '\n'
 
-  // Global doctrine sits between the YAML block and the per-peer doctrine so
-  // per-peer rules override global (specific over general). Bash gates on file
-  // EXISTENCE (`[ -f "$GLOBAL_DOCTRINE" ]`), NOT non-emptiness — a present but
-  // EMPTY global file still emits `cat "" + printf "\n"` = "\n". So the contract
-  // is: a present file → globalDoctrine is the string (possibly ""), absent file
-  // → undefined. Guard on `!== undefined` (NOT truthiness) to match bash exactly;
-  // an empty "" then yields "" + "\n" = "\n" (the 1-byte golden divergence the
-  // adversarial verify caught). The trailing "\n" mirrors the unconditional
-  // `printf "\n"` after `cat "$GLOBAL"`.
-  const global = input.globalDoctrine !== undefined ? input.globalDoctrine + '\n' : ''
+  // The YAML identity block is the only Layer-1 section (synthesized, no marker).
+  const sections: string[] = [yaml]
+
+  // Layer 2 — IAPEER.md doctrine, GLOBAL then LOCAL (general → specific), each its
+  // OWN marked file-section. The bash existence-gate (present-but-empty global → a
+  // bare "\n") is dropped deliberately: an empty doctrine file now contributes no
+  // section (and no dangling marker), like every other empty file. IAPEER.md carries
+  // the only FIXED semantics in the assembly (host = general peer rules, local = this
+  // peer's rules — the CLAUDE.md analogue); its meaning is conveyed by the well-known
+  // filename + path, so the marker stays a bare path like every other file's.
+  if (hasContent(input.globalDoctrine)) {
+    sections.push(markedSection(input.globalDoctrinePath, input.globalDoctrine))
+  }
+  if (hasContent(input.peerDoctrine)) {
+    sections.push(markedSection(input.peerDoctrinePath, input.peerDoctrine))
+  }
 
-  // Layers 1+2: YAML block + global doctrine + per-peer doctrine verbatim
-  // (`cat "$DOCTRINE"`), no trailing newline added. BYTE-IDENTICAL to the legacy
-  // jq output — the golden test pins this exactly.
-  const layer12 = yaml + global + input.peerDoctrine
+  // Layer 3 — normalized peer registry (generated from the index, not a file → no
+  // marker). Empty list → nothing.
+  const registry = renderRegistry(input.peers ?? [])
+  if (registry.length > 0) sections.push(registry)
 
-  // Layer 3 (registry), Layer 4 (operator/plugin domains) and Layer 5 (primitive
-  // doctrine fragments) are appended ONLY when they have content. Layer 5 sits LAST
-  // — it is the most volatile (machine-regenerated on every source change), so it
-  // never disturbs the stable prefix (YAML + doctrine + registry + domains) above it.
-  const layer3 = renderRegistry(input.peers ?? [])
-  const layer4 = renderMergedBlocks(input.pluginDomains ?? [])
-  const layer5 = renderMergedBlocks(input.promptFragments ?? [])
-  const sections = [layer12, layer3, layer4, layer5].filter(section => section.length > 0)
+  // Layers 4 (other <DOMAIN>.md) then 5 (fragments/, most-volatile, LAST) — each
+  // file half (global, local) is its own marked section. Empty halves drop out.
+  pushMarkedBlocks(sections, input.pluginDomains ?? [])
+  pushMarkedBlocks(sections, input.promptFragments ?? [])
 
-  // ONE section (no registry, no extra domains) → the legacy bytes, UNTOUCHED —
-  // the golden test pins layer12 exactly (peerDoctrine verbatim, incl. its own
-  // trailing-newline-or-not). MULTIPLE sections → normalize every seam to exactly
-  // one blank line: strip each section's trailing newlines, join with '\n\n', end
-  // with a single '\n'. This makes the output robust to whether the source files
-  // carried trailing newlines (a present-but-newline-only tail never widens a gap).
-  if (sections.length === 1) return sections[0]
+  // Normalize every seam to exactly one blank line: strip each section's trailing
+  // newlines, join with '\n\n', end with a single '\n'. Robust to whether source
+  // files carried trailing newlines. A bare-doctrine peer is now [YAML, local
+  // IAPEER.md] → two sections, so it always carries its doctrine's path marker.
   return sections.map(section => section.replace(/\n+$/, '')).join('\n\n') + '\n'
 }
 
@@ -132,32 +154,23 @@ function renderRegistry(peers: readonly PublicPeerSummary[]): string {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Layers 4 & 5 — merged global/local blocks. Shared renderer:
+// Layers 4 & 5 — per-file marked sections:
 //   • Layer 4: every non-IAPEER `<DOMAIN>.md` pair at the .iapeer/ root (operator /
 //     plugin user-settings; SPAWNER_INSTRUCTIONS.md, … flow in organically).
 //   • Layer 5: every `<STEM>.md` pair in .iapeer/fragments/ (primitive-owned,
 //     machine-regenerated doctrine fragments — iapeer-memory's guide + note index).
-// Both merge general → specific (global then local). The merge is ORGANIC: stems
-// are used only for stable ordering (done by the gatherer), never emitted. An empty
-// file is a presence marker (Канал B) and contributes no text — so a fragment dir
-// that drops to a 0-byte placeholder, or whose file vanishes mid-rotation, yields
-// nothing here rather than a dangling separator.
+// Each block contributes its GLOBAL half then its LOCAL half (general → specific),
+// EACH as its own marked file-section (a 0-byte / newline-only file → no section,
+// no dangling marker). Blocks are appended in the order given (the gatherer sorts
+// by filename for determinism); the stem (`domain`) is used only for that ordering,
+// never emitted.
 // ─────────────────────────────────────────────────────────────────────────────
 
-function renderMergedBlocks(blocks: readonly PromptDomainBlock[]): string {
-  const out: string[] = []
+function pushMarkedBlocks(sections: string[], blocks: readonly PromptDomainBlock[]): void {
   for (const b of blocks) {
-    // Per stem: global then local (general → specific), each trimmed of its
-    // trailing newlines so a 0-byte marker (or a newline-only file) drops out and
-    // the spacing is uniform. Halves of one stem are kept tight (single '\n');
-    // distinct stems are separated by a blank line below.
-    const halves = [b.global, b.local]
-      .filter((s): s is string => s !== undefined)
-      .map(s => s.replace(/\n+$/, ''))
-      .filter(s => s.length > 0)
-    if (halves.length > 0) out.push(halves.join('\n'))
+    if (hasContent(b.global)) sections.push(markedSection(b.globalPath, b.global))
+    if (hasContent(b.local)) sections.push(markedSection(b.localPath, b.local))
   }
-  return out.join('\n\n')
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -218,16 +231,28 @@ function listDomainFiles(root: string): string[] {
   return listMdFiles(root).filter(name => name.toLowerCase() !== doctrineLower)
 }
 
+/** Display path for a marker: an absolute path with a leading HOME abbreviated to
+ *  `~` (the form a human scanning the assembled prompt expects). HOME unset / path
+ *  outside HOME → the absolute path verbatim. */
+function displayPath(absPath: string, env: NodeJS.ProcessEnv): string {
+  const home = env.HOME?.trim()
+  if (home && (absPath === home || absPath.startsWith(home + '/'))) {
+    return '~' + absPath.slice(home.length)
+  }
+  return absPath
+}
+
 /** Build a list of merged global/local blocks (Layer 4 OR Layer 5) from the
  *  union of `*.md` stems present in the global and/or local dir, sorted by
  *  filename (plain codepoint order) for a deterministic prompt. `lister` selects
  *  the candidate `.md` files — Layer 4 excludes the IAPEER.md doctrine, Layer 5
- *  takes every fragment. A read that races a rotation (file removed between listdir
- *  and read) → that half is undefined and drops out; a 0-byte file → '' and is
- *  dropped by the renderer. */
+ *  takes every fragment. Each present half carries its display path for the marker.
+ *  A read that races a rotation (file removed between listdir and read) → that half
+ *  is undefined and drops out; a 0-byte file → '' and is dropped by the renderer. */
 function gatherMergedBlocks(
   globalDir: string,
   localDir: string,
+  env: NodeJS.ProcessEnv,
   lister: (dir: string) => string[] = listMdFiles,
 ): PromptDomainBlock[] {
   const names = new Set<string>([...lister(globalDir), ...lister(localDir)])
@@ -235,8 +260,14 @@ function gatherMergedBlocks(
     const block: PromptDomainBlock = { domain: name.slice(0, -3) } // strip ".md"
     const global = readFileIfPresent(join(globalDir, name))
     const local = readFileIfPresent(join(localDir, name))
-    if (global !== undefined) block.global = global
-    if (local !== undefined) block.local = local
+    if (global !== undefined) {
+      block.global = global
+      block.globalPath = displayPath(join(globalDir, name), env)
+    }
+    if (local !== undefined) {
+      block.local = local
+      block.localPath = displayPath(join(localDir, name), env)
+    }
     return block
   })
 }
@@ -246,16 +277,19 @@ export function gatherPromptInput(opts: GatherPromptOptions): ComposePromptInput
   const globalRoot = opts.globalRoot ?? resolveGlobalRoot(env)
   const localRoot = join(opts.cwd, IAPEER_DIR)
 
-  // Layer 2 — IAPEER.md merge. Global is existence-gated (undefined when absent,
-  // '' when present-but-empty — golden parity). Local defaults to '' when absent.
-  const globalDoctrine = readFileIfPresent(join(globalRoot, IAPEER_DOCTRINE_FILE))
-  const peerDoctrine = readFileIfPresent(join(localRoot, IAPEER_DOCTRINE_FILE)) ?? ''
+  // Layer 2 — IAPEER.md merge. Each half carries its display path for the marker.
+  // Existence-gated: undefined when absent, '' when present-but-empty (an empty
+  // doctrine now contributes no section — no bare-"\n" legacy quirk).
+  const globalDoctrineFile = join(globalRoot, IAPEER_DOCTRINE_FILE)
+  const peerDoctrineFile = join(localRoot, IAPEER_DOCTRINE_FILE)
+  const globalDoctrine = readFileIfPresent(globalDoctrineFile)
+  const peerDoctrine = readFileIfPresent(peerDoctrineFile) ?? ''
 
   // Layer 4 — union of every non-IAPEER domain present globally and/or locally,
   // sorted by filename for a deterministic prompt. Empty (0-byte) files stay as
   // presence markers — readFileIfPresent returns '', and the renderer drops empty
   // halves, so a marker contributes no text/separator.
-  const pluginDomains = gatherMergedBlocks(globalRoot, localRoot, listDomainFiles)
+  const pluginDomains = gatherMergedBlocks(globalRoot, localRoot, env, listDomainFiles)
 
   // Layer 5 — doctrine fragments: every `*.md` in the fragments/ subdir of both
   // roots, merged per stem (global guide → per-peer specifics). Primitive-owned and
@@ -264,6 +298,7 @@ export function gatherPromptInput(opts: GatherPromptOptions): ComposePromptInput
   const promptFragments = gatherMergedBlocks(
     join(globalRoot, FRAGMENTS_DIR),
     join(localRoot, FRAGMENTS_DIR),
+    env,
   )
 
   // Layer 3 — peers projected through the shared normalizer, sorted by personality
@@ -285,7 +320,10 @@ export function gatherPromptInput(opts: GatherPromptOptions): ComposePromptInput
     hostname: opts.hostname,
     today: opts.today,
     peerDoctrine,
-    ...(globalDoctrine !== undefined ? { globalDoctrine } : {}),
+    peerDoctrinePath: displayPath(peerDoctrineFile, env),
+    ...(globalDoctrine !== undefined
+      ? { globalDoctrine, globalDoctrinePath: displayPath(globalDoctrineFile, env) }
+      : {}),
     peers,
     pluginDomains,
     promptFragments,

package/src/launch/types.ts

@@ -42,14 +42,21 @@ export type { PublicPeerSummary } from '../registry/index.ts'
 /** One merged block: the global + local halves of a single stem (either may be
  *  absent), used for BOTH Layer 4 (`<DOMAIN>.md` at the .iapeer/ root) and Layer 5
  *  (`<STEM>.md` in .iapeer/fragments/). `domain` is the filename stem, used only
- *  for stable ordering — it is NOT emitted (the merge is organic). Within a block
- *  global precedes local (general → specific). */
+ *  for stable ordering — it is NOT emitted. Within a block global precedes local
+ *  (general → specific), and each half is rendered as its OWN per-file section
+ *  prefixed by a path marker (`globalPath` / `localPath`) — the assembly is now
+ *  per-file, not an organic stem-merge. */
 export interface PromptDomainBlock {
   domain: string
   /** Global half content (general): ~/.iapeer/<DOMAIN>.md or ~/.iapeer/fragments/<STEM>.md. */
   global?: string
   /** Local half content (specific — overrides global): <cwd>/.iapeer/… counterpart. */
   local?: string
+  /** Display path for the global half's marker (HOME abbreviated to ~). Absent →
+   *  no marker (pure-renderer callers). */
+  globalPath?: string
+  /** Display path for the local half's marker. */
+  localPath?: string
 }
 
 export interface ComposePromptInput {
@@ -64,10 +71,14 @@ export interface ComposePromptInput {
   today: string
   /** Layer 2 local: <cwd>/.iapeer/IAPEER.md content. '' when absent. */
   peerDoctrine: string
+  /** Display path for the local IAPEER.md marker (HOME abbreviated to ~). */
+  peerDoctrinePath?: string
   /** Layer 2 global, OPTIONAL: ~/.iapeer/IAPEER.md content (sits between the YAML
    *  block and the per-peer doctrine so per-peer overrides global). Existence-
    *  gated: a present-but-empty file → '', an absent file → undefined. */
   globalDoctrine?: string
+  /** Display path for the global IAPEER.md marker. */
+  globalDoctrinePath?: string
   /** Layer 3: the normalized peer registry. Empty/omitted → the layer emits
    *  nothing (and the output stays byte-identical to the legacy YAML+doctrine). */
   peers?: PublicPeerSummary[]

package/src/lifecycle/index.ts

@@ -223,8 +223,12 @@ export function clearStopped(cfg: LifecycleConfig, identity: string): void {
 //     Presence on a dead session = the daemon EAGERLY relaunches FRESH (does NOT
 //     wait for a message) and injects initial_prompt. Consumed on the relaunch.
 //   .deaths      : crash-loop guard — a small JSON ring of recent death epoch-ms.
-//   .topic       : the topic tag of the current/last session (executor fresh-vs-
-//     resume discriminator).
+//   .topic       : the topic the current/last session last WORKED ON (executor
+//     fresh-vs-resume discriminator). Written at wake (the boot topic) AND on
+//     every live delivery carrying a different non-empty topic (the daemon/CLI
+//     compositions wire transport's noteLiveTopic seam to writeTopic — defect
+//     11.06: a wake-only marker goes stale over a long session and false-freshes
+//     the stop→start resume the clean park promised).
 //   .ephemeral-armed : wake_policy:ephemeral M2 — set by the DAEMON when it routes
 //     an OUTBOUND send from an ephemeral worker (its single final reply, ADR-006:
 //     workers send no intermediate messages, so outbound ⇒ the task is answered).
@@ -381,7 +385,9 @@ export function readTopic(cfg: LifecycleConfig, identity: string): string {
   }
 }
 
-/** Store the incoming topic for the established session (raw string, best-effort). */
+/** Store the session's working topic (raw string, best-effort). Two writers: the
+ *  wake (boot topic, wakeOrSpawn) and live deliveries via the noteLiveTopic seam
+ *  (makeNoteLiveTopic) — so the marker follows the work, not just the boot. */
 export function writeTopic(cfg: LifecycleConfig, identity: string, topic: string): void {
   mkdirSync(cfg.stateDir, { recursive: true, mode: 0o700 })
   try {

package/src/registry/index.ts

@@ -158,14 +158,17 @@ function normalizePeer(raw: unknown): PeerRecord {
       )}"`,
     )
   }
-  if (!isRuntime(obj.runtime)) {
+  // default_runtime is the contract field; `runtime` is legacy. Dual-read accepts
+  // both during the staged migration (write still emits `runtime` until Phase 2).
+  const defaultRuntime = obj.default_runtime ?? obj.runtime
+  if (!isRuntime(defaultRuntime)) {
     throw new IapError(
-      `peers-profiles.json corrupted: peer "${obj.personality}" runtime must match /^[a-z][a-z0-9]{0,31}$/`,
+      `peers-profiles.json corrupted: peer "${obj.personality}" default_runtime must match /^[a-z][a-z0-9]{0,31}$/`,
     )
   }
   const runtimes = Array.isArray(obj.runtimes)
-    ? ensureRuntimes(obj.runtimes.filter(item => typeof item === 'string') as string[], obj.runtime)
-    : [obj.runtime]
+    ? ensureRuntimes(obj.runtimes.filter(item => typeof item === 'string') as string[], defaultRuntime)
+    : [defaultRuntime]
   const { description } = clampDescription(typeof obj.description === 'string' ? obj.description : '')
   if (typeof obj.cwd !== 'string' || !obj.cwd.trim()) {
     throw new IapError(`peers-profiles.json corrupted: peer "${obj.personality}" cwd is required`)
@@ -177,7 +180,7 @@ function normalizePeer(raw: unknown): PeerRecord {
   let intelligence: Intelligence
   let intelligenceRaw: string | undefined
   if (obj.intelligence === undefined || obj.intelligence === null || obj.intelligence === '') {
-    intelligence = defaultIntelligenceForRuntime(obj.runtime)
+    intelligence = defaultIntelligenceForRuntime(defaultRuntime)
     // no raw on disk → a healed default will be persisted
   } else {
     const normalized = normalizeIntelligenceValue(obj.intelligence)
@@ -192,7 +195,7 @@ function normalizePeer(raw: unknown): PeerRecord {
   const interfaces = normalizeInterfaces(obj.interfaces, obj.personality)
   return {
     personality: obj.personality,
-    runtime: obj.runtime,
+    runtime: defaultRuntime,
     runtimes,
     description,
     intelligence,

package/src/transport/index.ts

@@ -440,6 +440,29 @@ export interface RouteDeps {
   wake?: WakeFn
   /** Ephemeral-target serial-queue delivery (M3); absent → normal routing. */
   ephemeral?: EphemeralRouteDeps
+  /** Fired after a successful LIVE delivery whose envelope carried a non-empty
+   *  topic — the hit path AND the post-wake fast-path redelivery, NOT the boot
+   *  first-message (the wake itself records its topic). The fresh-vs-resume seam:
+   *  lifecycle keeps a per-identity `.topic` marker the wake resolver compares
+   *  the incoming topic against; before this hook the marker was written ONLY at
+   *  wake, so it held «the topic the session woke with», while the resolver's
+   *  semantics want «the topic the session last worked on». A long-lived executor
+   *  that took live-delivered messages of topic B all day then false-FRESHED on
+   *  stop→start→wake with topic B (live incident 11.06, claude-iapeer: a day of
+   *  context lost to cause=idle-reaped-new-topic). Injected so transport never
+   *  imports lifecycle (layering — main.ts is where the two meet); call sites
+   *  swallow hook errors (a hook must never fail a delivered message). */
+  noteLiveTopic?: (identity: string, topic: string) => void
+}
+
+/** Best-effort noteLiveTopic invocation — only on a non-empty topic, never throws. */
+function noteTopic(deps: RouteDeps, identity: string, topic: string | undefined): void {
+  if (!topic) return
+  try {
+    deps.noteLiveTopic?.(identity, topic)
+  } catch {
+    /* a post-delivery hook must never fail the delivery */
+  }
 }
 
 function truncateTopic(raw: string | undefined): string | undefined {
@@ -534,6 +557,7 @@ export async function routeSend(
     // peer.cwd enables the Ф-B transcript-mtime liveness probe (busy-session case).
     const delivered = deliverViaTmux(target.value, envelope, peer.cwd)
     if (!delivered.ok) return delivered
+    noteTopic(deps, target.value.address, topic)
     return ok({
       ok: true,
       delivered_to: { personality: target.value.personality, runtime: target.value.runtime },
@@ -567,6 +591,7 @@ export async function routeSend(
   if (woke.taskDelivered === false) {
     const delivered = deliverViaTmux(live.value, envelope, peer.cwd)
     if (!delivered.ok) return delivered
+    noteTopic(deps, live.value.address, topic)
     return ok({
       ok: true,
       delivered_to: { personality: live.value.personality, runtime: live.value.runtime },

package/src/transport/routesend-wake.test.ts

@@ -137,3 +137,72 @@ describe('routeSend wake fast-path (concurrent-sender envelope loss)', () => {
     expect(r.error.message).toMatch(/verify-before-act|not live/)
   })
 })
+
+// ─────────────────────────────────────────────────────────────────────────────
+// noteLiveTopic seam — a LIVE delivery carrying a topic must surface it to the
+// injected hook (lifecycle's .topic marker write), so the fresh-vs-resume
+// discriminator compares against the topic the session last WORKED ON, not the
+// one it woke with (defect 11.06: stale wake-time marker → false fresh).
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('routeSend noteLiveTopic seam (live-delivered topic)', () => {
+  test('live hit with a topic → hook fired ONCE with the TARGET identity + topic', async () => {
+    startTargetSession()
+    const notes: Array<[string, string]> = []
+    const r = await routeSend(
+      caller,
+      { personality: TARGET, message: 'm', topic: 'fix-resume' },
+      { noteLiveTopic: (id, t) => notes.push([id, t]) },
+    )
+    expect(r.ok).toBe(true)
+    expect(notes).toEqual([[`telegram-${TARGET}`, 'fix-resume']])
+    killTargetSession()
+  })
+
+  test('no topic → hook NOT fired; a throwing hook never fails the delivered message', async () => {
+    startTargetSession()
+    const notes: string[] = []
+    const r1 = await routeSend(caller, { personality: TARGET, message: 'm1' }, { noteLiveTopic: () => { notes.push('x') } })
+    expect(r1.ok).toBe(true)
+    expect(notes).toEqual([])
+    const r2 = await routeSend(
+      caller,
+      { personality: TARGET, message: 'm2', topic: 't' },
+      { noteLiveTopic: () => { throw new Error('boom') } },
+    )
+    expect(r2.ok).toBe(true)
+    killTargetSession()
+  })
+
+  test('post-wake fast-path redelivery (taskDelivered:false) also notes the topic — it is a LIVE delivery', async () => {
+    const notes: Array<[string, string]> = []
+    const wake: WakeFn = async () => {
+      startTargetSession()
+      return { status: 'READY', woke: false, runtime: 'telegram', taskDelivered: false }
+    }
+    const r = await routeSend(
+      caller,
+      { personality: TARGET, message: 'm', topic: 'tt' },
+      { wake, noteLiveTopic: (id, t) => notes.push([id, t]) },
+    )
+    expect(r.ok).toBe(true)
+    expect(notes).toEqual([[`telegram-${TARGET}`, 'tt']])
+    killTargetSession()
+  })
+
+  test('boot first-message delivery (woke:true) does NOT fire the hook — the wake records its own topic', async () => {
+    const notes: string[] = []
+    const wake: WakeFn = async () => {
+      startTargetSession()
+      return { status: 'READY', woke: true, runtime: 'telegram', taskDelivered: true }
+    }
+    const r = await routeSend(
+      caller,
+      { personality: TARGET, message: 'm', topic: 'tb' },
+      { wake, noteLiveTopic: () => { notes.push('x') } },
+    )
+    expect(r.ok).toBe(true)
+    expect(notes).toEqual([])
+    killTargetSession()
+  })
+})