thinkpool-pair 0.7.308 → 0.7.310

package/abort-turn-barrier.mjs

@@ -0,0 +1,23 @@
+// Realtime delivers code-abort and the browser's newly-flushed code-turn through
+// independent handlers. Keep that next human turn behind the runtime's real abort
+// completion so a late aborted boundary cannot close the new turn.
+
+export function queueAbortBarrier(entry, runAbort = () => entry?.session?.abort?.()) {
+  if (!entry) return Promise.resolve()
+  const prior = entry._abortBarrier || Promise.resolve()
+  let barrier
+  barrier = Promise.resolve(prior)
+    .catch(() => {})
+    .then(() => runAbort())
+    .catch(() => {})
+    .finally(() => {
+      if (entry._abortBarrier === barrier) entry._abortBarrier = null
+    })
+  entry._abortBarrier = barrier
+  return barrier
+}
+
+export async function waitForAbortBarrier(entry) {
+  const barrier = entry?._abortBarrier
+  if (barrier) await barrier
+}

package/bridge.mjs

@@ -65,6 +65,7 @@ import { commandOnPath } from './agent-detect.mjs'
 import { requiresSdkAdmission, sdkSmokePassed } from './sdk-admission.mjs'
 import { hermesUserInputResponse } from './question-response.mjs'
 import { hostMemoryAdmission } from './host-memory.mjs'
+import { queueAbortBarrier, waitForAbortBarrier } from './abort-turn-barrier.mjs'
 
 const STRUCTURED_MODES = new Set(['default', 'acceptEdits', 'plan', 'review', 'bypassPermissions'])
 import { FLOW_CONDUCTOR_PROMPT, FLOW_LANE_PROMPT, FLOW_CODEX_CONDUCTOR_PROMPT, FLOW_CODEX_LANE_PROMPT, buildConductorEnv, assembleCrossWaveContext, buildLanePrompt } from './flow-conductor.mjs'
@@ -3996,6 +3997,12 @@ channel
   .on('broadcast', { event: 'code-turn' }, async ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)
     if (!s || payload.text == null) return
+    // Stop and the browser's queue flush are separate realtime frames. Codex and
+    // Hermes need their native cancellation to settle before the flushed turn is
+    // accepted; otherwise the old aborted result can land after the new `you` line
+    // and close it. Re-check identity after the await in case the lane was closed.
+    await waitForAbortBarrier(s)
+    if (sessions.get(payload.term) !== s || !s.session) return
     markActivity()
     // B2/C: a real human turn is hop 0 with fresh cross-terminal budgets. This is
     // the loop-breaker reset point — an injected (cross-posted) turn does NOT come
@@ -4290,7 +4297,11 @@ channel
   })
   .on('broadcast', { event: 'code-abort' }, ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)
-    if (s) { drainPending(s); s.session.abort(); announce() }   // settle any open permission card so the hook doesn't hang
+    if (s) {
+      drainPending(s)   // settle any open permission card so the hook doesn't hang
+      queueAbortBarrier(s).finally(() => announce())
+      announce()
+    }
   })
   .on('broadcast', { event: 'code-mode' }, ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)

package/codex-session.mjs

@@ -589,6 +589,9 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   async function runAppServer(prompt, options = {}) {
+    // Stop can win before the queued pump enters native startup. Do not launch a
+    // fresh App Server merely to discover the accepted room turn was cancelled.
+    if (ended || aborted) return true
     if (!await ensureAppServer()) return false
     // Stop can land while the cold App Server / MCP bootstrap is still awaiting.
     // The accepted turn was already closed at the room boundary; never start it
@@ -651,6 +654,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   async function runAppServerReview(commandText) {
+    if (ended || aborted) return true
     if (!await ensureAppServer()) return false
     if (ended || aborted) return true
     mapper.setUsageBaseline(sessionId ? readCodexThreadUsage(sessionId) : null)
@@ -869,11 +873,13 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       return true
     },
     abort() {
+      const activeChain = chain
       const bootstrapOnly = turnActive && !activeTurnId && !child
       aborted = true
       queue.length = 0
       closeAppServerTurn(activeTurnId)
-      if (appServer && activeTurnId) { void appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }).catch(() => {}) ; return }
+      let interrupt = Promise.resolve()
+      if (appServer && activeTurnId) interrupt = appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }).catch(() => {})
       if (child) { try { child.kill('SIGTERM') } catch { /* noop */ } ; setTimeout(() => { try { child?.kill('SIGKILL') } catch { /* noop */ } }, 1500) }
       else if (bootstrapOnly) {
         // No native turn exists to produce a boundary. Close the optimistic
@@ -881,6 +887,10 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         // aborted check discard the delayed startup.
         emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 0, durationMs: undefined, denials: 0, resultText: null })
       }
+      // `code-turn` may already be queued behind Stop in Realtime. Resolve only
+      // after the interrupted native turn's chain has fully unwound; accepting a
+      // new turn earlier lets the old finally/result close the new lifecycle.
+      return interrupt.then(() => activeChain).catch(() => activeChain).then(() => {})
     },
     end() {
       ended = true

package/hermes-session.mjs

@@ -566,7 +566,7 @@ export function startHermesSession({
       })
       return true
     },
-    abort() {
+    async abort() {
       if (!turnActive) return
       queuedTurns.length = 0
       queueDrainPending = false
@@ -582,14 +582,16 @@ export function startHermesSession({
         retireClient()
         client?.end()
         finishAbortedTurn()
+        await promptChain.catch(() => {})
         return
       }
       if (!sessionId || !client?.alive) {
         finishAbortedTurn()
+        await promptChain.catch(() => {})
         return
       }
       finishAbortedTurn()
-      void client.notify('session/cancel', { sessionId }).catch((error) => {
+      await client.notify('session/cancel', { sessionId }).catch((error) => {
         // Never display a stopped lane while the un-cancelled Hermes process
         // might still be executing. A transport failure tears down the ACP
         // process and makes the lane honestly non-resumable until restart.
@@ -597,6 +599,10 @@ export function startHermesSession({
         client?.end()
         emit({ kind: 'error', message: `Hermes cancellation delivery failed; ACP process stopped: ${error?.message || error}`, recoverable: true })
       })
+      // The ACP cancellation notification is not itself the completion edge.
+      // Wait for the active prompt promise to unwind (including the 0.18.2
+      // cancelled-response recovery) before a bridge queue flush starts anew.
+      await promptChain.catch(() => {})
     },
     end() {
       ended = true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.308",
+  "version": "0.7.310",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "bridge.mjs",
+    "abort-turn-barrier.mjs",
     "host-memory.mjs",
     "sdk-smoke.mjs",
     "sdk-admission.mjs",

package/reap-terminal.mjs

@@ -36,21 +36,28 @@ export async function reapTerminalRow ({ id, token, supabaseUrl, anonKey, shutti
   if (!token)       return { reaped: false, reason: 'anon' }
   if (!id)          return { reaped: false, reason: 'no-id' }
   try {
-    // Mirror of the client reap: DELETE code_terminals WHERE id = <terminal id>. The
-    // terminal id IS the code_terminals PK (client/bridge-minted uuid). RLS scopes the
-    // delete to this bridge's sessions, so id alone is sufficient + idempotent (a fast
-    // client tab may have reaped first — 204 / 0 rows is fine).
-    const response = await fetchImpl(`${supabaseUrl}/rest/v1/code_terminals?id=eq.${encodeURIComponent(id)}`, {
-      method: 'DELETE',
-      headers: { apikey: anonKey, Authorization: `Bearer ${token}` },
+    // A terminal at the 50k transcript cap cannot archive + cascade-delete inside
+    // the authenticated role's ordinary 8s statement timeout. The member-authorized
+    // RPC scopes a longer timeout to this one cleanup operation; a raw REST DELETE
+    // timed out and left the row as a cross-device dormant ghost (8TMX546Q).
+    const response = await fetchImpl(`${supabaseUrl}/rest/v1/rpc/delete_code_terminal`, {
+      method: 'POST',
+      headers: {
+        apikey: anonKey,
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ p_terminal: id }),
     })
     // fetch resolves for HTTP failures. A 401/500 did not reap the row and must
     // stay visible to the fire-and-forget caller as a failed best-effort cleanup.
     if (!response?.ok) {
+      let detail = ''
+      try { detail = String(await response.text()).slice(0, 240) } catch { /* no body */ }
       return fail({
         reaped: false,
         reason: 'error',
-        error: `HTTP ${response?.status ?? 'unknown'}${response?.statusText ? ` ${response.statusText}` : ''}`,
+        error: `HTTP ${response?.status ?? 'unknown'}${response?.statusText ? ` ${response.statusText}` : ''}${detail ? `: ${detail}` : ''}`,
         status: response?.status,
       })
     }

package/terminal-row-reconcile.mjs

@@ -1,3 +1,5 @@
+import { reapTerminalRow } from './reap-terminal.mjs'
+
 /* Reconcile durable terminal rows after a bridge has restored its on-disk roster.
 
    A clean close is reaped by reap-terminal.mjs. This module closes the other
@@ -48,13 +50,16 @@ export async function reconcileTerminalRows ({
 
     const reaped = []
     for (const id of stale) {
-      const del = await fetchImpl(
-        `${supabaseUrl}/rest/v1/code_terminals?id=eq.${encodeURIComponent(id)}` +
-        `&host_id=eq.${encodeURIComponent(hostId)}`,
-        { method: 'DELETE', headers: { apikey: anonKey, Authorization: `Bearer ${token}` } },
-      )
-      if (!del?.ok) {
-        return fail({ reason: 'error', error: `delete HTTP ${del?.status ?? 'unknown'}`, status: del?.status, reaped })
+      const deletion = await reapTerminalRow({
+        id, token, supabaseUrl, anonKey, fetchImpl,
+      })
+      if (!deletion.reaped) {
+        return fail({
+          reason: 'error',
+          error: `delete ${deletion.error || deletion.reason}`,
+          status: deletion.status,
+          reaped,
+        })
       }
       reaped.push(id)
     }