thinkpool-pair 0.7.224 → 0.7.226

package/account.mjs

@@ -778,7 +778,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
     if (!tc || roomPartner.get(target) !== partnerUid) return reply({ error: `Room ${target} is not a room this device shares with you.` })
     const reqId = randomUUID()
     pairPending.set(reqId, { reply: (mm) => reply({ ok: mm.ok, ref: mm.ref, error: mm.error }), askerRoom: null })
-    try { tc.send({ t: 'pair-post-local', reqId, fromRoom: payload.fromRoom, fromHost: payload.fromHost, text: payload.text, terminal: payload.terminal }) }
+    try { tc.send({ t: 'pair-post-local', reqId, fromRoom: payload.fromRoom, fromHost: payload.fromHost, fromTerminalName: payload.fromTerminalName, text: payload.text, terminal: payload.terminal }) }
     catch { pairPending.delete(reqId); reply({ error: `Could not reach room ${target}.` }) }
   }
   // Join the per-pair bus for `partnerUid` (idempotent). The channel is PRIVATE so
@@ -801,7 +801,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   // Forward a local child's cross-room request to the bus (Tier 2 peek / Tier 3 post)
   // when the target room is NOT served on this machine. Used inside the child handler.
   const busPeek = (targetRoom, terminal, lines) => busRequestFirst('peer-peek-req', { targetRoom, terminal, lines }, CROSSROOM_BUS.busTimeoutMs)
-  const busPost = (targetRoom, terminal, text, fromRoom) => busRequestFirst('peer-post-req', { targetRoom, terminal, text, fromRoom, fromHost: machine }, 180_000)
+  const busPost = (targetRoom, terminal, text, fromRoom, fromTerminalName) => busRequestFirst('peer-post-req', { targetRoom, terminal, text, fromRoom, fromHost: machine, fromTerminalName }, 180_000)
 
   // Re-entrancy guard: bind-room fires tick() AND a 15s interval fires tick(); tick
   // awaits a code_sessions query before children.set(), so two overlapping runs can
@@ -953,13 +953,13 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
             if (tc) {   // LOCAL target — the target child raises its own receipt card
               const reqId = randomUUID()
               pairPending.set(reqId, { reply: (mm) => reply({ ok: mm.ok, ref: mm.ref, error: mm.error }), askerRoom: room })
-              try { tc.send({ t: 'pair-post-local', reqId, fromRoom: room, fromHost: machine, text: m.text, terminal: m.terminal }) }
+              try { tc.send({ t: 'pair-post-local', reqId, fromRoom: room, fromHost: machine, fromTerminalName: m.fromTerminalName, text: m.text, terminal: m.terminal }) }
               catch { pairPending.delete(reqId); reply({ error: `Could not reach session ${target}.` }) }
               return
             }
             // REMOTE target — over the pair bus.
             if (!pairChannels.size) return reply({ error: `Room ${target} is not on this machine, and no pair bus is open to reach it.` })
-            const res = await busPost(target, m.terminal, m.text, room)
+            const res = await busPost(target, m.terminal, m.text, room, m.fromTerminalName)
             if (!res) return reply({ error: `Room ${target} did not respond to the hand-off in time.` })
             reply({ ok: res.ok, ref: res.ref, error: res.error })
           })()

package/bridge.mjs

@@ -1123,7 +1123,7 @@ function raiseCard(entry, req) {
 // the target agent lane, raise the receipt card, and on approval inject the turn one
 // room-hop deep (so the reached agent can read/peek but cannot post onward to a third
 // room — crossRoomPostDecision blocks roomHop≥1). Returns { ok, ref } or { error }.
-async function receiveCrossRoomPost({ fromRoom, fromHost, text, terminal }) {
+async function receiveCrossRoomPost({ fromRoom, fromHost, fromTerminalName, text, terminal }) {
   if (process.env.TP_PAIRBUS_OFF === '1') return { error: 'Cross-room posting is turned off in this room.' }
   const body = String(text || '').trim()
   if (!body) return { error: 'Empty cross-room post ignored.' }
@@ -1145,13 +1145,13 @@ async function receiveCrossRoomPost({ fromRoom, fromHost, text, terminal }) {
   if (!te?.session) return { error: `That terminal in room ${room} is no longer live.` }
   const fromLabel = `${fromRoom}${fromHost ? ` on ${fromHost}` : ''}`
   let decision = 'deny'
-  try { decision = await raiseCard(te, { id: randomUUID(), toolName: 'mcp__thinkpool__post_to_session', input: { session: fromRoom, host: fromHost, text: body, incoming: true }, risk: 'high' }) } catch { decision = 'deny' }
+  try { decision = await raiseCard(te, { id: randomUUID(), toolName: 'mcp__thinkpool__post_to_session', input: { session: fromRoom, host: fromHost, terminalName: fromTerminalName, text: body, incoming: true }, risk: 'high' }) } catch { decision = 'deny' }
   if (decision !== 'allow') return { error: `The people in room ${room} declined the incoming task from ${fromLabel}.` }
   // Injected turn: one room-hop deep, fresh in-room budgets (the loop-breaker reset
   // point is code-turn — a real human turn — which this is NOT, so the deeper hop sticks).
   te.roomHop = 1; te.hop = (te.hop || 0) + 1; te.peekCount = 0; te.postCount = 0; te.pairPeekCount = 0; te.crossRoomPostCount = 0
   const msg = `[From: room ${fromLabel} — relayed via the ThinkPool cross-room Ensemble, approved by a person in this room]\n${body}`
-  const evt = { kind: 'you', text: msg, by: `room ${fromRoom}`, crosspost: true }
+  const evt = { kind: 'you', text: msg, by: `room ${fromRoom}`, crosspost: true, relaySourceName: String(fromTerminalName || '').trim().slice(0, 80) || undefined }
   stampEvent(evt); pushLog(te, evt); bcast('code-event', { term: targetId, evt })
   try { te.session.sendTurn(msg) } catch { return { error: `Could not deliver to room ${room} — the lane may have just closed.` } }
   return { ok: true, ref: String(targetId).slice(0, 8) }
@@ -1671,8 +1671,11 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
   // `claude-fable-5` → 400 [1211][Unknown Model]. One value, one truth.
   // undefined → omit the SDK option entirely and let the provider env/endpoint default.
   const codexModels = runtime === 'codex' ? readCodexModels() : []
+  const codexRequestedModel = runtime === 'codex' ? (model || readCodexDefaultModel() || undefined) : undefined
   const laneModel = runtime === 'codex'
-    ? resolveCodexModel(model || readCodexDefaultModel() || undefined, codexModels)
+    ? (codexRequestedModel
+      ? resolveCodexModel(codexRequestedModel, codexModels)
+      : flowLaneModelFor({ sliceType: 'feature', runtime: 'codex', catalog: codexModels }))
     : effectiveLaneModel({ provider, model, configuredModel: resolveProviderEnv(provider)?.ANTHROPIC_MODEL })
   // spawnedBy: set when this lane was Dispatched (spawn_terminal). Restored from the
   // session store so the Ensemble flag survives a bridge restart (else a respin
@@ -2044,7 +2047,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
           entry.crossRoomPostCount = (entry.crossRoomPostCount || 0) + 1
           // Generous timeout: the TARGET room's person must approve a receipt card,
           // which can take a while. Fails soft (never hangs the turn) past the window.
-          const res = await pairRequest('pair-post-req', { targetRoom: target, terminal: args?.terminal, text, fromRoom: room }, 180_000)
+          const res = await pairRequest('pair-post-req', { targetRoom: target, terminal: args?.terminal, text, fromRoom: room, fromTerminalName: termNames[id] || undefined }, 180_000)
           if (res?.error) return okText(res.error)
           return okText(res?.ok ? `Delivered to room ${target}${res.ref ? ` (lane ${res.ref})` : ''} — it will respond in its own room; check back with read_session.` : `Room ${target} did not accept the message.`)
         },
@@ -2084,7 +2087,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
           te.postCount = 0
           // Echo the injected prompt into the TARGET lane so both people see what
           // arrived (rides the existing code-event 'you' path — no new topic).
-          const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true }
+          const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true, relaySourceName: termNames[id] || undefined }
           stampEvent(evt)
           pushLog(te, evt)
           bcast('code-event', { term: target.id, evt })
@@ -2174,7 +2177,7 @@ function openStructured({ id, runtime = 'claude', model, effort, resume, log, co
             // to any lane still resets it to hop 0 (code-turn). Mirrors Tier C injection.
             ne.hop = (entry.hop || 0) + 1; ne.peekCount = 0; ne.postCount = 0; ne.spawnTimes = []
             const msg = `[Task from terminal ${fromRef}'s agent — relayed via ThinkPool cross-terminal; you are a fresh lane it opened for you]\n${args.task}`
-            const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true }
+            const evt = { kind: 'you', text: msg, by: `terminal ${fromRef} (agent)`, crosspost: true, relaySourceName: termNames[id] || undefined }
             stampEvent(evt); pushLog(ne, evt); bcast('code-event', { term: newId, evt })
             try { ne.session.sendTurn(msg) } catch { return okText(`Opened lane ${newRef}${args?.name ? ` ("${args.name}")` : ''}, but it may still be starting — could not hand off the task. Try post_to_terminal shortly.`) }
             return okText(`Opened agent lane ${newRef}${args?.name ? ` ("${args.name}")` : ''} and handed it the task. It runs in its own lane — check back with read_terminal, then close_terminal when done.`)

package/event-bounds.mjs

@@ -83,7 +83,7 @@ export function boundStructuredEvent(event, cap = STRUCTURED_EVENT_CAP) {
 
   // Hard fallback: retain ordering/dedup identity and recognisable tool blocks.
   const identity = {}
-  for (const key of ['kind', 'seq', 'cid', 'ts', 'term', 'toolUseId', 'isError']) {
+  for (const key of ['kind', 'seq', 'cid', 'ts', 'term', 'toolUseId', 'isError', 'by', 'crosspost', 'relaySourceName']) {
     if (out[key] != null) identity[key] = out[key]
   }
   if (Array.isArray(out.blocks)) identity.blocks = out.blocks.slice(0, 4).map(block => compactBlock(block, 6000))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.224",
+  "version": "0.7.226",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {