@agfpd/iapeer 0.2.51 → 0.2.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.51",
+  "version": "0.2.53",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "type": "module",
   "bin": {

package/src/cli/cli.test.ts

@@ -11,7 +11,7 @@ import { addRuntime, compactPeer, defaultRuntime, formatListTable, listPeers, ne
 import { findPeer, readPeersIndex, upsertPeer } from '../registry/index.ts'
 import { hasIdleReaped, isStopped, loadLifecycleConfig, setIdleReaped, setStopped } from '../lifecycle/index.ts'
 import { launchdPlistPath } from '../launch/launchd.ts'
-import { ok } from '../core/errors.ts'
+import { err, ok } from '../core/errors.ts'
 
 let root: string
 let laDir: string
@@ -463,6 +463,7 @@ describe('compact (resume sleeping dialogue)', () => {
     setIdleReaped(cfg, 'codex-sleepy')
     const wakeCalls: unknown[] = []
     const controlCalls: unknown[] = []
+    const doneCalls: unknown[] = []
     const o = await compactPeer('sleepy', 'codex', {
       env: e,
       wakeFn: async args => {
@@ -473,13 +474,34 @@ describe('compact (resume sleeping dialogue)', () => {
         controlCalls.push({ personality, runtime, command })
         return ok({ ok: true, controlled: { personality, runtime: runtime! }, command: command.name, ts: 't' })
       },
+      compactDoneFn: (target, cwd, baseline) => {
+        doneCalls.push({ target, cwd, runtime: baseline.runtime })
+        return ok({ ok: true, ms: 42, signal: 'transcript+ready' })
+      },
     })
     expect(o).toMatchObject({ action: 'compacted', runtime: 'codex', woke: true })
     expect(wakeCalls).toEqual([{ personality: 'sleepy', runtime: 'codex', task: '', resume: true }])
     expect(controlCalls).toEqual([{ personality: 'sleepy', runtime: 'codex', command: { name: 'compact' } }])
+    expect(doneCalls).toHaveLength(1)
+    expect(doneCalls[0]).toMatchObject({ cwd: '/tmp/sleepy', runtime: 'codex', target: { runtime: 'codex', personality: 'sleepy' } })
     expect(hasIdleReaped(cfg, 'codex-sleepy')).toBe(false)
   })
 
+  test('compact done gate failure surfaces as failed (no false success)', async () => {
+    await register('slow', 'codex')
+    const e = env()
+    const cfg = loadLifecycleConfig(e)
+    setIdleReaped(cfg, 'codex-slow')
+    const o = await compactPeer('slow', 'codex', {
+      env: e,
+      wakeFn: async args => ({ status: 'READY', woke: true, runtime: args.runtime, process_address: `${args.runtime}-${args.personality}`, taskDelivered: true }),
+      controlFn: (personality, runtime, command) => ok({ ok: true, controlled: { personality, runtime: runtime! }, command: command.name, ts: 't' }),
+      compactDoneFn: () => err('compact did not complete within test'),
+    })
+    expect(o.action).toBe('failed')
+    expect(o.reason).toContain('did not complete')
+  })
+
   test('crashed / first-wake asleep peer (no clean idle marker) → nothing-to-compact, no fresh wake', async () => {
     await register('freshy', 'codex')
     let woke = false

package/src/cli/index.ts

@@ -24,7 +24,7 @@ import { recycleFoundationOwnedInfraJobs, updateIapeer, waitForDaemonHealthy } f
 import { buildProcessAddress, buildSocketPath, parseSessionName } from '../core/socket.ts'
 import { ensureGlobalIapScaffold } from '../storage/index.ts'
 import { findPeer, readPeersIndex, removePeer, type PeerRecord } from '../registry/index.ts'
-import { isPeerLive, routeControl, routeSend, type WakeFn } from '../transport/index.ts'
+import { compactDoneBaseline, isPeerLive, routeControl, routeSend, waitForCompactDone, type WakeFn } from '../transport/index.ts'
 import {
   attachPeer,
   clearIdleReaped,
@@ -515,9 +515,11 @@ export interface CompactPeerOutcome {
 
 /**
  * compact <peer> [runtime] — compact the DIALOGUE, not merely the currently-live
- * session. A live target receives the in-session `/compact` control as before. A
- * cleanly idle-reaped target is first resumed into the same dialogue, then compacted.
- * A crashed / never-run / non-resumable target returns an honest "nothing to compact"
+ * session. A live target receives the in-session `/compact` control; a cleanly
+ * idle-reaped target is first resumed into the same dialogue, then controlled.
+ * SUCCESS is gated on actual compaction completion (structured transcript marker
+ * after the command + input surface ready), not on keystrokes being accepted. A
+ * crashed / never-run / non-resumable target returns an honest "nothing to compact"
  * instead of starting a fresh empty session and compacting that.
  */
 export async function compactPeer(
@@ -526,6 +528,7 @@ export async function compactPeer(
   opts: CliEnvOptions & {
     wakeFn?: (args: { personality: string; runtime: Runtime; task: string; resume: true }) => Promise<WakeResult>
     controlFn?: typeof routeControl
+    compactDoneFn?: typeof waitForCompactDone
   } = {},
 ): Promise<CompactPeerOutcome> {
   const env = opts.env ?? process.env
@@ -551,10 +554,39 @@ export async function compactPeer(
   }
 
   const control = opts.controlFn ?? routeControl
+  const compactDone = opts.compactDoneFn ?? waitForCompactDone
+  const waitDone = (rt: Runtime, baseline: ReturnType<typeof compactDoneBaseline>, woke: boolean): CompactPeerOutcome | null => {
+    const done = compactDone(
+      {
+        personality,
+        runtime: rt,
+        address: buildProcessAddress(rt, personality),
+        socketPath: buildSocketPath(rt, personality, cfg.sockDir),
+      },
+      peer.cwd,
+      baseline,
+      { env },
+    )
+    if (!done.ok) return { personality, runtime: rt, action: 'failed', woke, reason: done.error.message }
+    return null
+  }
   const liveRuntimes = peer.runtimes.filter(rt => isPeerLive(rt, personality, cfg.sockDir))
   if (runtime ? liveRuntimes.includes(runtime as Runtime) : liveRuntimes.length > 0) {
-    const r = control(personality, runtime, { name: 'compact' })
-    if (!r.ok) return { personality, runtime: runtime ?? peer.runtime, action: 'failed', reason: r.error.message }
+    const rt = (runtime as Runtime | undefined)
+      ?? (liveRuntimes.includes(peer.runtime) ? peer.runtime : liveRuntimes.length === 1 ? liveRuntimes[0] : undefined)
+    if (!rt) {
+      return {
+        personality,
+        runtime: peer.runtime,
+        action: 'failed',
+        reason: `${personality} is online in multiple runtimes (${liveRuntimes.join(', ')}) — specify runtime`,
+      }
+    }
+    const baseline = compactDoneBaseline(rt, peer.cwd, { env })
+    const r = control(personality, rt, { name: 'compact' })
+    if (!r.ok) return { personality, runtime: rt, action: 'failed', reason: r.error.message }
+    const waited = waitDone(r.value.controlled.runtime as Runtime, baseline, false)
+    if (waited) return waited
     return { personality, runtime: r.value.controlled.runtime, action: 'compacted', woke: false }
   }
 
@@ -589,8 +621,11 @@ export async function compactPeer(
     return { personality, runtime: rt, action: 'failed', reason }
   }
   clearIdleReaped(cfg, identity)
+  const baseline = compactDoneBaseline(rt, peer.cwd, { env })
   const r = control(personality, rt, { name: 'compact' })
   if (!r.ok) return { personality, runtime: rt, action: 'failed', woke: true, reason: r.error.message }
+  const waited = waitDone(rt, baseline, true)
+  if (waited) return waited
   return { personality, runtime: rt, action: 'compacted', woke: true }
 }
 
@@ -803,6 +838,7 @@ export async function sendMessage(
     via: result.ok ? `${result.value.delivered_to.runtime}-${result.value.delivered_to.personality}` : undefined,
     woke: result.ok ? String(result.value.woke) : undefined,
     queued: result.ok && result.value.queued ? 'true' : undefined,
+    qkind: result.ok ? result.value.queuedBy : undefined,
     qd: result.ok ? result.value.queueDepth : undefined,
     ms: Date.now() - t0,
     len: opts.message.length,

package/src/daemon/daemon.test.ts

@@ -197,6 +197,7 @@ describe('ephemeral serial-queue seam (M3)', () => {
                 delivered_to: { personality: peer.personality, runtime: 'claude' },
                 woke: false,
                 queued: true,
+                queuedBy: 'ephemeral',
                 queueDepth: 2,
                 ts: 'now',
               },
@@ -209,6 +210,7 @@ describe('ephemeral serial-queue seam (M3)', () => {
     expect(delivered).toEqual(['checked:/tmp/offlinepeer', 'deliver:offlinepeer:job-1'])
     const line = readFileSync(join(logDir, 'delivery.log'), 'utf8').trim()
     expect(line).toContain('queued=true')
+    expect(line).toContain('qkind=ephemeral')
     expect(line).toContain('qd=2')
     expect(line).toContain('ok=true')
   })

package/src/daemon/index.ts

@@ -43,7 +43,7 @@ import { IapError } from '../core/errors.ts'
 import { pluginStateDir, writeFileAtomic, type StorageOptions } from '../storage/index.ts'
 import { publicPeerSummary, readPeersIndex, type PeersIndex } from '../registry/index.ts'
 import { resolveCallerIdentity, type CallerIdentity, type ResolvedCaller } from '../identity/index.ts'
-import { routeSend, type EphemeralRouteDeps, type SendToPeerInput, type WakeFn } from '../transport/index.ts'
+import { routeSend, type ComposerQueueRouteDeps, type EphemeralRouteDeps, type SendToPeerInput, type WakeFn } from '../transport/index.ts'
 import { appendDeliveryEvent } from './deliverylog.ts'
 
 export const CALLER_HEADER = 'x-iapeer-identity'
@@ -192,6 +192,8 @@ export interface CallToolDeps {
    *  see transport.RouteDeps.noteLiveTopic. Injected so the daemon never imports
    *  lifecycle; the production main wires makeNoteLiveTopic. */
   noteLiveTopic?: (identity: string, topic: string) => void
+  /** Busy-human-composer queue — see transport.createComposerDeliveryQueue. */
+  composerQueue?: ComposerQueueRouteDeps
 }
 
 export async function callTool(
@@ -209,7 +211,12 @@ export async function callTool(
       attachments: Array.isArray(args.attachments) ? (args.attachments as string[]) : undefined,
     }
     const t0 = Date.now()
-    const sent = await routeSend(caller, input, { wake: deps.wake, ephemeral: deps.ephemeral, noteLiveTopic: deps.noteLiveTopic })
+    const sent = await routeSend(caller, input, {
+      wake: deps.wake,
+      ephemeral: deps.ephemeral,
+      noteLiveTopic: deps.noteLiveTopic,
+      composerQueue: deps.composerQueue,
+    })
     // Ф-#8a: ONE durable outcome line per delivery attempt (delivery.log, sibling
     // to lifecycle.log) — metadata only, never the body. Both branches of the
     // routeSend result are recorded, so a suspected loss is reconstructable from
@@ -226,6 +233,7 @@ export async function callTool(
       // M3 queue observability (boris acceptance (a)): a queued accept is marked
       // and carries the queue depth at accept time — a stuck queue is visible.
       queued: sent.ok && sent.value.queued ? 'true' : undefined,
+      qkind: sent.ok ? sent.value.queuedBy : undefined,
       qd: sent.ok ? sent.value.queueDepth : undefined,
       ms: Date.now() - t0,
       len: input.message.length,
@@ -237,7 +245,7 @@ export async function callTool(
     // reply is NOT out, and arming then could quiet-reap a worker mid-retry (the
     // ordinary idle bound covers that case instead). Fail-safe: hook errors are
     // swallowed, the delivery result stands.
-    if (sent.ok) {
+    if (sent.ok && sent.value.queuedBy !== 'composer') {
       try {
         deps.onDelivered?.(caller)
       } catch {
@@ -377,6 +385,13 @@ export interface StartDaemonOptions extends StorageOptions {
    * main wires the lifecycle marker write (makeNoteLiveTopic).
    */
   noteLiveTopic?: (identity: string, topic: string) => void
+  /**
+   * Busy-human-composer queue — async acceptance for live local TUI delivery when
+   * an attached operator has non-dim text in the target composer. OFF by default
+   * for library/tests; production main wires an in-memory queue that fail-notifies
+   * senders on shutdown/restart.
+   */
+  composerQueue?: ComposerQueueRouteDeps
   /**
    * Write the discovery file (router.json) at <root>/state/iapeer/router.json with
    * the active addresses `{sock, tcp}` — atomically on listen, removed on close.
@@ -410,6 +425,7 @@ export async function startDaemon(opts: StartDaemonOptions = {}): Promise<Daemon
       onDelivered: opts.onDelivered,
       ephemeral: opts.ephemeral,
       noteLiveTopic: opts.noteLiveTopic,
+      composerQueue: opts.composerQueue,
     })
     const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined })
     res.on('close', () => {
@@ -507,8 +523,9 @@ export async function startDaemon(opts: StartDaemonOptions = {}): Promise<Daemon
     host: tcpEnabled ? host : undefined,
     port,
     url,
-    close: () =>
-      new Promise<void>(resolve => {
+    close: async () => {
+      await opts.composerQueue?.failAll?.('daemon shutting down/restarting before queued delivery completed')
+      await new Promise<void>(resolve => {
         if (supervisor) clearInterval(supervisor)
         for (const s of servers) s.closeAllConnections?.() // drop lingering keep-alive/SSE conns
         let pending = servers.length
@@ -525,6 +542,7 @@ export async function startDaemon(opts: StartDaemonOptions = {}): Promise<Daemon
             }
           })
         }
-      }),
+      })
+    },
   }
 }

package/src/daemon/main.test.ts

@@ -232,6 +232,24 @@ describe('dual-listen + router.json discovery', () => {
   })
 })
 
+describe('startDaemon composerQueue shutdown seam', () => {
+  test('close() fails pending busy-composer queue before tearing listeners down', async () => {
+    const reasons: string[] = []
+    const h = await startDaemon({
+      port: 0,
+      host: '127.0.0.1',
+      composerQueue: {
+        tryEnqueue: async () => null,
+        failAll: async reason => {
+          reasons.push(reason)
+        },
+      },
+    })
+    await h.close()
+    expect(reasons).toEqual(['daemon shutting down/restarting before queued delivery completed'])
+  })
+})
+
 // ─────────────────────────────────────────────────────────────────────────────
 // wake_policy:ephemeral M2 — makeArmEphemeralOnDelivered (the arm-on-outbound
 // composition: ephemeral caller's ok send ⇒ .ephemeral-armed for its identity)
@@ -307,6 +325,7 @@ describe('makeEphemeralRouteDeps (M3 serial-queue composition)', () => {
     const r2 = await deps.deliver({ peer: workerPeer, envelope: '<iap>task two</iap>' })
 
     expect(r1.ok && r1.value.queued).toBe(true)
+    expect(r1.ok && r1.value.queuedBy).toBe('ephemeral')
     expect(r1.ok && r1.value.queueDepth).toBe(1)
     expect(r1.ok && r1.value.woke).toBe(false)
     expect(r2.ok && r2.value.queueDepth).toBe(2)

package/src/daemon/main.ts

@@ -46,9 +46,21 @@ import {
 import { appendLifecycleEvent } from '../lifecycle/eventlog.ts'
 import { buildProcessAddress } from '../core/socket.ts'
 import { err, ok } from '../core/errors.ts'
+import { resolveCallerIdentity } from '../identity/index.ts'
 import type { ResolvedCaller } from '../identity/index.ts'
-import type { EphemeralRouteDeps, WakeFn, WakeOutcome, WakeRequest } from '../transport/index.ts'
+import { findPeer, readPeersIndex } from '../registry/index.ts'
+import {
+  createComposerDeliveryQueue,
+  routeSend,
+  type ComposerQueueRouteDeps,
+  type ComposerQueuedDelivery,
+  type EphemeralRouteDeps,
+  type WakeFn,
+  type WakeOutcome,
+  type WakeRequest,
+} from '../transport/index.ts'
 import { iapeerBinPath } from '../install/index.ts'
+import { appendDeliveryEvent } from './deliverylog.ts'
 import { defaultDaemonSocketPath, startDaemon, type DaemonHandle } from './index.ts'
 
 /** Default TCP loopback port for the always-on router. Real http MCP clients
@@ -168,6 +180,7 @@ export function makeEphemeralRouteDeps(
         delivered_to: { personality: peer.personality, runtime: rt.value },
         woke: false,
         queued: true,
+        queuedBy: 'ephemeral',
         queueDepth: depth,
         ts: new Date().toISOString(),
       })
@@ -175,6 +188,80 @@ export function makeEphemeralRouteDeps(
   }
 }
 
+function queuedFailureMessage(job: ComposerQueuedDelivery, reason: string): string {
+  const topic = job.topic ? ` topic="${job.topic}"` : ''
+  return (
+    `delivery failed: queued message to ${job.target.personality} (${job.target.runtime})${topic} was not delivered.\n` +
+    `reason: ${reason}\n` +
+    'The original send was accepted as queued because a human operator was typing in the target composer; retry if still needed.'
+  )
+}
+
+/**
+ * Busy-human-composer queue composition. This is deliberately daemon-owned and
+ * in-memory: it exists only to bridge a short operator-editing window. Because a
+ * queued ack is not a delivery fact, the queue has two extra responsibilities:
+ *   1) after actual drain success, run the same post-delivery hooks as the
+ *      synchronous path (topic marker + ephemeral caller arm);
+ *   2) before daemon shutdown/restart, fail every pending queued envelope back
+ *      to its sender, so `queued` never becomes silent loss.
+ */
+export function makeComposerQueueRouteDeps(cfg: LifecycleConfig, env: NodeJS.ProcessEnv): ComposerQueueRouteDeps {
+  const noteLiveTopic = makeNoteLiveTopic(cfg, env)
+  const onDelivered = makeArmEphemeralOnDelivered(cfg)
+  const wake = makeWakeFn(cfg, env)
+  const ephemeral = makeEphemeralRouteDeps(cfg, env)
+
+  return createComposerDeliveryQueue({
+    env,
+    noteLiveTopic,
+    onDelivered,
+    notifyFailed: async (job, reason) => {
+      const index = readPeersIndex({ env })
+      const self = findPeer(index, 'iapeer')
+      if (!self) {
+        appendDeliveryEvent(cfg.eventLogDir, {
+          ev: 'composer-queue-failed-notify',
+          caller: 'iapeer',
+          to: job.caller.personality,
+          rt: job.caller.runtime,
+          ok: 'false',
+          err: 'foundation peer "iapeer" is not registered; cannot notify queued sender',
+        })
+        return
+      }
+      const sender = resolveCallerIdentity({ personality: 'iapeer', runtime: self.runtime }, index)
+      const result = await routeSend(
+        sender,
+        {
+          personality: job.caller.personality,
+          runtime: job.caller.runtime,
+          message: queuedFailureMessage(job, reason),
+          topic: job.topic ?? 'delivery-failed',
+        },
+        // Do not pass composerQueue here: this path is the queue's failure outlet
+        // (including SIGTERM/update). Recursively queueing a failure notification
+        // could turn shutdown re-fail into another queued item.
+        { wake, ephemeral, noteLiveTopic },
+      )
+      appendDeliveryEvent(cfg.eventLogDir, {
+        ev: 'composer-queue-failed-notify',
+        caller: sender.address,
+        to: job.caller.personality,
+        rt: job.caller.runtime,
+        ok: String(result.ok),
+        via: result.ok ? `${result.value.delivered_to.runtime}-${result.value.delivered_to.personality}` : undefined,
+        woke: result.ok ? String(result.value.woke) : undefined,
+        queued: result.ok && result.value.queued ? 'true' : undefined,
+        qkind: result.ok ? result.value.queuedBy : undefined,
+        qd: result.ok ? result.value.queueDepth : undefined,
+        topic: job.topic ?? 'delivery-failed',
+        err: result.ok ? undefined : result.error.message,
+      })
+    },
+  })
+}
+
 export interface ConfiguredDaemonOptions {
   /** TCP loopback port (default DEFAULT_DAEMON_PORT). */
   port?: number
@@ -202,18 +289,25 @@ export async function startConfiguredDaemon(opts: ConfiguredDaemonOptions = {}):
   const env = opts.env ?? process.env
   const cfg = loadLifecycleConfig(env)
   const bearerToken = opts.bearerToken ?? (env.IAPEER_BEARER_TOKEN?.trim() || undefined)
+  const noteLiveTopic = makeNoteLiveTopic(cfg, env)
+  const armEphemeralOnDelivered = makeArmEphemeralOnDelivered(cfg)
+  const ephemeral = makeEphemeralRouteDeps(cfg, env)
+  const composerQueue = makeComposerQueueRouteDeps(cfg, env)
   return startDaemon({
     wake: makeWakeFn(cfg, env),
     // M2 arm-on-outbound (see makeArmEphemeralOnDelivered): ephemeral caller's ok
     // send ⇒ armed for the supervise quiet-reap. No-op for every other caller.
-    onDelivered: makeArmEphemeralOnDelivered(cfg),
+    onDelivered: armEphemeralOnDelivered,
     // M3 serial queue (see makeEphemeralRouteDeps): ephemeral TARGET ⇒ enqueue +
     // async drain. No-op for every other target.
-    ephemeral: makeEphemeralRouteDeps(cfg, env),
+    ephemeral,
     // Live-delivered topic → the target's .topic marker (see makeNoteLiveTopic):
     // the wake resolver's executor discriminator then compares against the topic
     // the session last WORKED ON, not the one it woke with (defect 11.06).
-    noteLiveTopic: makeNoteLiveTopic(cfg, env),
+    noteLiveTopic,
+    // Busy-human-composer queue: fast queued ack, async drain, fail all pending
+    // on daemon close/update so a queued envelope is never silently lost.
+    composerQueue,
     supervise: {
       intervalMs: opts.superviseIntervalMs ?? DEFAULT_SUPERVISE_INTERVAL_MS,
       // idle-reap / zombie-sweep, THEN the eager fresh re-launch for any peer whose

package/src/launch/adapters/claude.ts

@@ -103,6 +103,7 @@ export const claudeAdapter: RuntimeAdapter = {
   deliveryMarkers: {
     promptGlyphs: ['❯'],
     pastePatterns: [/\[Pasted text/, /\[Image #/],
+    ghostTextSgr: ['2', '38;5;246'],
   },
 
   /**

package/src/launch/adapters/codex.ts

@@ -167,6 +167,7 @@ export const codexAdapter: RuntimeAdapter = {
   deliveryMarkers: {
     promptGlyphs: ['›'],
     pastePatterns: [/\[Pasted text/, /\[Image #/],
+    ghostTextSgr: ['2', '38;5;246'],
   },
 
   /**

package/src/launch/launch.test.ts

@@ -304,10 +304,12 @@ describe('deliveryMarkers (adapter-owned, was transport PROMPT_GLYPHS)', () => {
   test('claude: ❯ glyph + paste patterns', () => {
     expect(claudeAdapter.deliveryMarkers.promptGlyphs).toEqual(['❯'])
     expect(claudeAdapter.deliveryMarkers.pastePatterns?.some(re => re.test('[Pasted text +5 lines]'))).toBe(true)
+    expect(claudeAdapter.deliveryMarkers.ghostTextSgr).toEqual(['2', '38;5;246'])
   })
   test('codex: › glyph (not ❯) — per-runtime, no false cross-match', () => {
     expect(codexAdapter.deliveryMarkers.promptGlyphs).toEqual(['›'])
     expect(codexAdapter.deliveryMarkers.promptGlyphs).not.toContain('❯')
+    expect(codexAdapter.deliveryMarkers.ghostTextSgr).toEqual(['2', '38;5;246'])
   })
   test('routers have no submit surface → empty glyphs', () => {
     expect(telegramAdapter.deliveryMarkers.promptGlyphs).toEqual([])

package/src/launch/types.ts

@@ -180,6 +180,14 @@ export interface DeliveryMarkers {
    *  (claude '[Pasted text' / '[Image #'). Optional — when absent the tail-marker is
    *  the sole landed-signal. */
   pastePatterns?: RegExp[]
+  /** SGR parameter sequences that the runtime uses for composer ghost/placeholder
+   *  text (non-human input). The busy-composer delivery queue captures the pane
+   *  with ANSI escapes and treats visible text after the prompt glyph as HUMAN only
+   *  when at least one non-whitespace character is NOT under these dim/grey SGR
+   *  attributes. Runtime-owned for the same reason as promptGlyphs: color is TUI
+   *  surface, not transport policy. Examples observed on live panes:
+   *  `2` (faint/dim) and `38;5;246` (xterm 256-color grey). */
+  ghostTextSgr?: string[]
 }
 
 // ─────────────────────────────────────────────────────────────────────────────

package/src/transport/compactDone.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync, appendFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { compactDoneBaseline, compactTranscriptHasDone } from './index.ts'
+
+function withHome(fn: (home: string, env: NodeJS.ProcessEnv) => void): void {
+  const home = mkdtempSync(join(tmpdir(), 'iapeer-compact-gate-home-'))
+  try {
+    fn(home, { ...process.env, HOME: home })
+  } finally {
+    rmSync(home, { recursive: true, force: true })
+  }
+}
+
+function claudeSlug(cwd: string): string {
+  return realpathSync(cwd).replace(/[^a-zA-Z0-9]/g, '-')
+}
+
+describe('compact done transcript gate', () => {
+  test('codex: ignores old markers and detects a new context_compacted event', () => withHome((home, env) => {
+    const cwd = mkdtempSync(join(tmpdir(), 'iapeer-compact-codex-cwd-'))
+    try {
+      const dir = join(home, '.codex', 'sessions', '2026', '06', '13')
+      mkdirSync(dir, { recursive: true })
+      const file = join(dir, 'rollout-test.jsonl')
+      writeFileSync(file,
+        JSON.stringify({ type: 'session_meta', payload: { cwd } }) + '\n' +
+        JSON.stringify({ type: 'event_msg', payload: { type: 'context_compacted' } }) + '\n',
+      )
+      const baseline = compactDoneBaseline('codex', cwd, { env })
+      expect(compactTranscriptHasDone(baseline, { env })).toBe(false)
+      appendFileSync(file, JSON.stringify({ type: 'event_msg', payload: { type: 'context_compacted' } }) + '\n')
+      expect(compactTranscriptHasDone(baseline, { env })).toBe(true)
+    } finally {
+      rmSync(cwd, { recursive: true, force: true })
+    }
+  }))
+
+  test('claude: detects a new compact_boundary and ignores raw text mentions', () => withHome((home, env) => {
+    const cwd = mkdtempSync(join(tmpdir(), 'iapeer-compact-claude-cwd-'))
+    try {
+      const dir = join(home, '.claude', 'projects', claudeSlug(cwd))
+      mkdirSync(dir, { recursive: true })
+      const file = join(dir, 'session.jsonl')
+      writeFileSync(file,
+        JSON.stringify({ type: 'user', message: { role: 'user', content: 'context_compacted is only text' } }) + '\n' +
+        JSON.stringify({ type: 'system', subtype: 'compact_boundary', content: 'Conversation compacted' }) + '\n',
+      )
+      const baseline = compactDoneBaseline('claude', cwd, { env })
+      expect(compactTranscriptHasDone(baseline, { env })).toBe(false)
+      appendFileSync(file, JSON.stringify({ type: 'user', message: { role: 'user', content: 'Conversation compacted text only' } }) + '\n')
+      expect(compactTranscriptHasDone(baseline, { env })).toBe(false)
+      appendFileSync(file, JSON.stringify({ type: 'system', subtype: 'compact_boundary', content: 'Conversation compacted', compactMetadata: { durationMs: 12 } }) + '\n')
+      expect(compactTranscriptHasDone(baseline, { env })).toBe(true)
+    } finally {
+      rmSync(cwd, { recursive: true, force: true })
+    }
+  }))
+})