thinkpool-pair 0.7.357 → 0.7.358

package/bridge.mjs

@@ -1755,6 +1755,11 @@ const designArtifacts = new Map() // previewId → trusted source record
 const designQueues = new Map()    // producer term → validated requests
 const designActive = new Map()    // producer term → request awaiting result + proof
 const designRestore = new Map()   // current previewId → immediately previous verified record/edit
+// Realtime can carry the settled DOM for ordinary authored mockups. Including
+// that already-uploaded snapshot in the correlated verified-live event lets an
+// open Design lane advance revisions without a second auth/sign/download round
+// trip. Large artifacts keep the normal signed-storage path.
+const MAX_INLINE_DESIGN_REVISION_BYTES = 128 * 1024
 const designStatus = (payload) => designChannel.send({
   type: 'broadcast', event: 'design-status', payload: { ts: Date.now(), ...payload },
 })
@@ -1777,7 +1782,12 @@ const finishDesign = (term, state, extra = {}) => {
 const maybeVerifyDesign = (term) => {
   const active = designActive.get(term)
   if (!active?.resultOk || !active.proof) return
-  finishDesign(term, 'verified-live', { message: 'Verified at desktop and mobile.', artifact: active.proof, canRestore: active.record.sourceKind !== 'preview' })
+  finishDesign(term, 'verified-live', {
+    message: 'Verified at desktop and mobile.',
+    artifact: active.proof.artifact,
+    ...(active.proof.artifactHtml ? { artifactHtml: active.proof.artifactHtml } : {}),
+    canRestore: active.record.sourceKind !== 'preview',
+  })
 }
 
 function pumpDesign(term) {
@@ -1949,7 +1959,10 @@ const handleManifest = async ({ box, term, trustedDesignSource = false, slug, m
         : designRecord.sourcePath === active?.record?.sourcePath
       if (correlated && dual && sameTarget && revisionProvesChange) {
         if (active.record.sourceKind !== 'preview') designRestore.set(designRecord.previewId, { priorRecord: active.record, request: active.request })
-        active.proof = artifact
+        const artifactHtml = Buffer.byteLength(displaySource, 'utf8') <= MAX_INLINE_DESIGN_REVISION_BYTES
+          ? displaySource
+          : null
+        active.proof = { artifact, artifactHtml }
         maybeVerifyDesign(term)
       }
     }
@@ -2238,6 +2251,80 @@ function restoredTurnOpen(log) {
   return false
 }
 
+function emitCodexCompactionControl(entry, text, by = null) {
+  const evt = { kind: 'control', text, by }
+  pushLog(entry, evt)
+  bcast('code-event', { term: entry.id, evt })
+}
+
+async function runCodexCompaction(entry, request = {}) {
+  const recap = buildRecapFromLog(entry.log, RECAP_CAP, { reason: 'compact' })
+  if (!recap) {
+    emitCodexCompactionControl(entry, 'nothing to compact — context unchanged', request.by)
+    return
+  }
+  const preTokens = entry.lastUsage?.ctx?.used || null
+  bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'start', ts: Date.now() } })
+  let nativeCompacted = false
+  try {
+    nativeCompacted = await entry.session.compactContext?.()
+  } catch {
+    // compactContext classifies delivery certainty. A truly unexpected throw
+    // remains non-replayable here; resetting after an unknown native request can
+    // execute compaction twice against two different threads.
+    nativeCompacted = null
+  } finally {
+    // Native compaction emits usage while compactActive=true, so onEvent
+    // legitimately announces a busy edge. It has no ordinary result event;
+    // close that borrowed edge after compactContext clears compactActive.
+    if (!entry.session.turnActive && settleLaneControl(entry)) announce()
+  }
+  if (nativeCompacted === true) {
+    const evt = { kind: 'compaction', trigger: 'manual', preTokens, by: request.by, native: true }
+    pushLog(entry, evt)
+    bcast('code-event', { term: entry.id, evt })
+    bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+    entry.flush?.()
+    return
+  }
+  if (nativeCompacted == null) {
+    bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+    emitCodexCompactionControl(entry, 'Native compaction is still settling; existing context was preserved.', request.by)
+    entry.flush?.()
+    return
+  }
+  if (entry.session.clearContext?.() === false) {
+    bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+    emitCodexCompactionControl(entry, 'Codex context compaction unavailable right now', request.by)
+    return
+  }
+  entry.pendingRecap = recap
+  const evt = { kind: 'compaction', trigger: 'manual', preTokens, by: request.by }
+  pushLog(entry, evt)
+  bcast('code-event', { term: entry.id, evt })
+  // The new native thread has only the bounded recap queued for the next human
+  // turn. Reset the visible meter to that conservative text estimate.
+  if (entry.lastUsage?.ctx?.max) {
+    const used = Math.ceil(recap.length / 4)
+    const max = entry.lastUsage.ctx.max
+    const usage = { kind: 'usage', ctx: { ...entry.lastUsage.ctx, used, max, pct: Math.min(100, Math.round((used / max) * 100)), over: used > max } }
+    entry.lastUsage = usage
+    bcast('code-event', { term: entry.id, evt: usage })
+  }
+  bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+  entry.flush?.()
+}
+
+function startCodexCompaction(entry, request = {}) {
+  if (!entry || entry.runtime !== 'codex' || entry.codexCompactionPromise) return false
+  const job = runCodexCompaction(entry, request)
+  entry.codexCompactionPromise = job
+  void job.finally(() => {
+    if (entry.codexCompactionPromise === job) entry.codexCompactionPromise = null
+  }).catch(() => { /* runCodexCompaction already surfaced classified failures */ })
+  return true
+}
+
 // Active-worktree snapshot for the per-turn ROOM NOW tail. Cached ~60s per cwd —
 // a subprocess on every turn of every lane would be waste, and worktrees change on
 // minutes-scale. Plain `git worktree list` output (path · sha · [branch]) is the
@@ -3656,6 +3743,15 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
         pushLog(entry, ce)
         bcast('code-event', { term: id, evt: ce })
       }
+      // A busy Codex lane accepts one deferred /compact intent. Claim the
+      // compaction synchronously at the terminal result boundary so a new human
+      // turn cannot slip into the gap, and coalesce every repeated tap into this
+      // one job.
+      if ((evt.kind === 'result' || evt.kind === 'error') && entry.runtime === 'codex' && entry.pendingCodexCompaction) {
+        const request = entry.pendingCodexCompaction
+        entry.pendingCodexCompaction = null
+        startCodexCompaction(entry, request)
+      }
       // ── Slice 3: the turn settled. Two things happen, in this order.
       //   1. Every outstanding permission card on this lane is now dead (the SDK
       //      won't ask again for a turn that ended) — clearAll retracts any
@@ -4678,6 +4774,7 @@ channel
     }
     if (/^\/clear\s*$/.test(text)) {
       s.pendingRecap = null   // /clear means forget context — drop any un-fired carry recap
+      s.pendingCodexCompaction = null // explicit clear supersedes a deferred compact
       if (s.runtime === 'codex' || s.runtime === 'hermes') s.session.clearContext?.()
       else s.session.sendTurn(text)
       // The seq reset is load-bearing on BOTH ends: the client's clear handler sets
@@ -4698,61 +4795,16 @@ channel
     // No persisted ctl line — the live indicator + the CompactionCard are the record.
     if (/^\/compact\s*$/.test(text)) {
       if (s.runtime === 'codex') {
+        // One lifecycle owns every distinct press. During an ordinary turn the
+        // first request is queued and truthfully runs at its result boundary;
+        // later taps, including taps during native compaction, coalesce silently.
+        if (s.codexCompactionPromise || s.pendingCodexCompaction) return
         if (s.session.turnActive) {
-          ctlLine('Compact after this turn ends.', { tone: 'caution' })
-          return
-        }
-        const recap = buildRecapFromLog(s.log, RECAP_CAP, { reason: 'compact' })
-        if (!recap) {
-          ctlLine('nothing to compact — context unchanged')
-          return
-        }
-        const preTokens = s.lastUsage?.ctx?.used || null
-        bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'start', ts: Date.now() } })
-        let nativeCompacted = false
-        try {
-          nativeCompacted = await s.session.compactContext?.()
-        } catch {
-          // The bounded recap below is the safe fallback for a native transport
-          // failure. The roster edge is still settled in finally.
-        } finally {
-          // Native compaction emits usage while compactActive=true, so onEvent
-          // legitimately announces a busy edge. It has no ordinary result event;
-          // close that borrowed edge here after compactContext's finally clears
-          // compactActive, or "Compacting…" degrades into stale "Thinking…".
-          // A browser turn may have arrived while compactContext awaited App
-          // Server readiness. Never let control cleanup settle that ordinary
-          // turn's busy edge; the normal result boundary owns it.
-          if (!s.session.turnActive && settleLaneControl(s)) announce()
-        }
-        if (nativeCompacted) {
-          const ce = { kind: 'compaction', trigger: 'manual', preTokens, by: payload.by, native: true }
-          pushLog(s, ce)
-          bcast('code-event', { term: payload.term, evt: ce })
-          bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
-          s.flush?.()
+          s.pendingCodexCompaction = { by: payload.by, cid: payload.cid }
+          ctlLine('Compaction queued for after this turn.', { tone: 'caution' })
           return
         }
-        if (s.session.clearContext?.() === false) {
-          bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
-          ctlLine('Codex context compaction unavailable right now')
-          return
-        }
-        s.pendingRecap = recap
-        const ce = { kind: 'compaction', trigger: 'manual', preTokens, by: payload.by }
-        pushLog(s, ce)
-        bcast('code-event', { term: payload.term, evt: ce })
-        // The new native thread has only the bounded recap queued for the next
-        // human turn. Reset the visible meter to that conservative text estimate.
-        if (s.lastUsage?.ctx?.max) {
-          const used = Math.ceil(recap.length / 4)
-          const max = s.lastUsage.ctx.max
-          const usage = { kind: 'usage', ctx: { ...s.lastUsage.ctx, used, max, pct: Math.min(100, Math.round((used / max) * 100)), over: used > max } }
-          s.lastUsage = usage
-          bcast('code-event', { term: payload.term, evt: usage })
-        }
-        bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
-        s.flush?.()
+        startCodexCompaction(s, { by: payload.by, cid: payload.cid })
         return
       }
       s.compacting = true

package/codex-session.mjs

@@ -1153,7 +1153,11 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       // synchronously after sendTurn(), so this is the edge that makes Thinking,
       // Stop, and the tab spinner appear at dispatch time rather than at the
       // first provider event many seconds later.
-      if (!turnActive) {
+      // Native compaction already owns that public busy edge. A human turn
+      // accepted during it stays queued without flipping the ordinary-turn
+      // latch; otherwise compactContext's post-bootstrap recheck mistakes the
+      // queued turn for an active one and abandons a compaction it already owns.
+      if (!turnActive && !compactActive) {
         aborted = false
         armTurnLiveness()
       }
@@ -1229,13 +1233,20 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     },
     async compactContext() {
       if (turnActive || compactActive) return false
-      const readyAppServer = await ensureAppServer()
-      // ensureAppServer may need to boot the transport. Re-check after that
-      // await so a normal turn that began meanwhile owns the lane exclusively.
-      if (!readyAppServer || turnActive || compactActive) return false
+      // A Stop latch belongs to the turn it cancelled. sendTurn clears it when
+      // accepting new work, but /compact enters through this direct control path.
+      // Leaving it set makes appServerNotification discard the real
+      // turn/started event, then the five-second waiter falsely declares failure
+      // while Codex continues compacting the old thread in the background.
+      aborted = false
       compactActive = true
       let startTimer = null
+      let compactAccepted = false
       try {
+        const readyAppServer = await ensureAppServer()
+        // compactActive claims the lane before bootstrap, so sendTurn queues
+        // behind us. An independently active ordinary turn still wins safely.
+        if (!readyAppServer || turnActive) return false
         const compactTurn = new Promise((resolve, reject) => {
           startTimer = setTimeout(() => {
             compactStartWaiter = null
@@ -1244,6 +1255,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
           compactStartWaiter = { resolve, reject }
         })
         await appServer.compact({ threadId: sessionId })
+        compactAccepted = true
         const turnId = await compactTurn
         if (startTimer) clearTimeout(startTimer)
         const completed = await appServer.waitForTurn(turnId)
@@ -1252,6 +1264,14 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         if (status === 'completed') return true
         throw new Error(completed?.turn?.error?.message || `compaction ${status || 'failed'}`)
       } catch (error) {
+        // Once thread/compact/start was accepted, replaying via a bounded-recap
+        // reset is unsafe: the native compaction may still complete (the exact
+        // production failure this guard closes). Preserve the existing thread
+        // and report uncertainty instead of executing a second compaction path.
+        if (compactAccepted || !['rejected', 'not_sent'].includes(error?.delivery)) {
+          note(`Native Codex compaction status is uncertain; existing context was preserved: ${error?.message || error}`)
+          return null
+        }
         note(`Native Codex compaction unavailable; using bounded recap fallback: ${error?.message || error}`)
         return false
       } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.357",
+  "version": "0.7.358",
   "description": "Connect Claude Code, Codex, or Hermes on your computer to a Thinkpool Code room.",
   "type": "module",
   "bin": {