thinkpool-pair 0.7.330 → 0.7.332

package/codex-session.mjs

@@ -34,6 +34,7 @@ import { CODEX_THINKPOOL_FIRST_TURN_PREAMBLE, buildThinkPoolTurnGuidance, create
 import { questionAnswerResponse } from './question-response.mjs'
 import { codexReviewTarget, isCodexCompactCommand } from './codex-commands.mjs'
 import { createCumulativeEventRelay } from './cumulative-event-relay.mjs'
+import { stallDecision, stallEvent } from './turn-stall.mjs'
 
 const DEFAULT_SANDBOX = 'workspace-write'
 const SAFE_SANDBOXES = new Set(['read-only', 'workspace-write', 'danger-full-access'])
@@ -362,7 +363,7 @@ function appServerItemForMapper(item) {
  * @param {string} [o.providerConfig] optional -c overrides / provider block (M2: from the provider registry)
  * @returns {{ sendTurn(text, options?), abort(), end(), readonly sessionId }}
  */
-export function startCodexSession({ cwd, model, effort: initialEffort = 'high', resume, env, sandbox, mode = 'default', onEvent, providerConfig, terminalRolePrompt, rolePrompt, roomContext, mcpServers, prepareCwd = null, requestPermission, appServerGate = codexAppServerGate, appServerFactory = createCodexAppServer, mcpHttpFactory = startCodexMcpHttp, spawnImpl = spawn, admitStart = null }) {
+export function startCodexSession({ cwd, model, effort: initialEffort = 'high', resume, env, sandbox, mode = 'default', onEvent, providerConfig, terminalRolePrompt, rolePrompt, roomContext, mcpServers, prepareCwd = null, requestPermission, appServerGate = codexAppServerGate, appServerFactory = createCodexAppServer, mcpHttpFactory = startCodexMcpHttp, spawnImpl = spawn, admitStart = null, stallOptions = {} }) {
   let activeMode = CODEX_MODE_CONFIG[mode] ? mode : 'default'
   let modeConfig = codexConfigForMode(activeMode)
   sandbox = normalizeCodexSandbox(sandbox || modeConfig.sandbox)
@@ -381,6 +382,30 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   let aborted = false
   let ended = false
   let turnActive = false
+  // Codex can accept a room turn and then emit nothing while App Server is
+  // booting or an upstream model call is retrying. The room's generic roster
+  // clock can label that lane "stalled", but only the owning transport can
+  // surface an honest in-pane status and safely interrupt/replay the exact
+  // logical prompt. Keep this lifecycle parallel to Claude's shared watchdog.
+  const stallNow = typeof stallOptions.now === 'function' ? stallOptions.now : Date.now
+  const stallSetInterval = typeof stallOptions.setInterval === 'function' ? stallOptions.setInterval : setInterval
+  const stallClearInterval = typeof stallOptions.clearInterval === 'function' ? stallOptions.clearInterval : clearInterval
+  const STALL_MS = Number.isFinite(stallOptions.stallMs)
+    ? Math.max(1, Number(stallOptions.stallMs))
+    : Math.max(30000, parseInt(childEnv.TP_STALL_MS, 10) || 90000)
+  const FORCE_STOP_MS = Number.isFinite(stallOptions.forceStopMs)
+    ? Math.max(STALL_MS, Number(stallOptions.forceStopMs))
+    : Math.max(STALL_MS * 3, parseInt(childEnv.TP_FORCE_STOP_MS, 10) || 300000)
+  const STALL_INTERVAL_MS = Number.isFinite(stallOptions.intervalMs)
+    ? Math.max(1, Number(stallOptions.intervalMs))
+    : 5000
+  let lastEvtTs = stallNow()
+  let stalledSent = false
+  let stallRetried = false
+  let stallRetryRequested = false
+  let stallGiveupRequested = false
+  let awaitingUser = 0
+  let stallTimer = null
   let activeModel = model || null
   let activeEffort = EFFORT_LEVELS.has(initialEffort) ? initialEffort : 'high'
   let latestUsageSnapshot = sessionId ? readCodexThreadUsage(sessionId) : null
@@ -403,7 +428,14 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   let chain = Promise.resolve()
   const queue = []
 
-  const relayEvent = createCumulativeEventRelay((event) => { try { onEvent?.(event) } catch { /* consumer isolation */ } })
+  // Synthetic watchdog chrome must not count as provider activity, otherwise
+  // its 90s status would reset the silence clock and postpone the 5m recovery.
+  // Everything on the normal relay path is real transport/session activity and
+  // immediately clears the one-shot stalled banner.
+  const emitRaw = createCumulativeEventRelay((event) => { try { onEvent?.(event) } catch { /* consumer isolation */ } })
+  const touchActivity = () => { lastEvtTs = stallNow(); stalledSent = false }
+  const relayEvent = (event) => { touchActivity(); emitRaw(event) }
+  relayEvent.cancel = () => emitRaw.cancel()
   const mapper = new CodexEventMapper({
     onEvent: relayEvent,
     model: model || null,
@@ -430,6 +462,15 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     relayEvent(event)
   }
 
+  const armTurnLiveness = ({ retry = false } = {}) => {
+    turnActive = true
+    lastEvtTs = stallNow()
+    stalledSent = false
+    stallRetryRequested = false
+    stallGiveupRequested = false
+    if (!retry) stallRetried = false
+  }
+
   const note = (text) => relayEvent({ kind: 'note', text })
 
   const closeAppServerTurn = (turnId = activeTurnId) => {
@@ -462,12 +503,14 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       const turnId = String(params.turn.id)
       if (ended || aborted) { closeAppServerTurn(turnId); return }
       if (!activeTurnId) activeTurnId = turnId
+      touchActivity()
       return
     }
     // Every mapped App Server notification below is turn-scoped in the tested
     // protocol and carries turnId. Fail closed on missing, stale, completed, or
     // interrupted ids so a provider's buffered stdout cannot reopen a closed turn.
     if ((method === 'turn/plan/updated' || method === 'item/agentMessage/delta' || method === 'item/started' || method === 'item/completed' || method === 'error') && !appServerTurnIsCurrent(params)) return
+    touchActivity()
     if (method === 'turn/plan/updated') {
       const todos = (Array.isArray(params.plan) ? params.plan : []).map(({ step, status }) => ({
         content: step || '',
@@ -524,7 +567,14 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     // Missing/broken room permission plumbing denies safely. App Server expects
     // an ordinary response even for denial; an RPC error can strand the turn.
     let decision = 'deny'
+    awaitingUser++
     try { decision = await requestPermission?.(card) } catch { /* deny */ }
+    finally {
+      awaitingUser = Math.max(0, awaitingUser - 1)
+      // Give the resumed model call a fresh watchdog window. Human think time
+      // is intentionally excluded and must not force-stop the turn next tick.
+      touchActivity()
+    }
     if (method === 'item/tool/requestUserInput') return codexUserInputResponse(decision, card.questions)
     return codexApprovalResponse(decision)
   }
@@ -556,6 +606,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
           },
         })
         await appServer.start()
+        touchActivity()
       }
       sessionId = await appServer.startThread({
         threadId: turnNo > 0 ? sessionId : null,
@@ -568,12 +619,16 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         // independent ThinkPool sandbox / approval posture above.
         config: { 'features.default_mode_request_user_input': true },
       })
+      touchActivity()
       // App Server reports thread/start before its per-thread MCP clients finish
       // initializing. Starting the first turn in that gap snapshots a toolset
       // without ThinkPool even though the server becomes ready milliseconds later.
       // Hold the turn boundary until the room MCP is actually ready; a timeout or
       // startup failure drops into the required-MCP codex exec fallback below.
-      if (peer?.url) await appServer.waitForMcpServer({ threadId: sessionId, name: 'thinkpool' })
+      if (peer?.url) {
+        await appServer.waitForMcpServer({ threadId: sessionId, name: 'thinkpool' })
+        touchActivity()
+      }
       appServerThreadReady = true
       pushMappedEvent({ type: 'thread.started', thread_id: sessionId })
       return true
@@ -588,15 +643,101 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     }
   }
 
+  function stopStalledTransport({ force = false } = {}) {
+    const server = appServer
+    const turnId = activeTurnId
+
+    if (server && force) {
+      // A second stall is terminal. End the resident process, not merely its
+      // turn: an interrupt whose completion notification is itself wedged would
+      // otherwise leave `chain` unresolved and silently queue every later send.
+      closeAppServerTurn(turnId)
+      appServerDisabled = true
+      appServerThreadReady = false
+      try { server.end() } catch { /* noop */ }
+      if (appServer === server) appServer = null
+    } else if (server && turnId) {
+      // Fence the old native id before interrupting so buffered deltas/tool rows
+      // cannot cross into the retried logical turn.
+      closeAppServerTurn(turnId)
+      Promise.resolve(server.interrupt({ threadId: sessionId, turnId })).catch(() => {
+        // An interrupt rejected before delivery: tear down the uncertain control
+        // channel. The current pump will use the exec fallback for its one retry.
+        appServerDisabled = true
+        appServerThreadReady = false
+        try { server.end() } catch { /* noop */ }
+        if (appServer === server) appServer = null
+      })
+    } else if (server) {
+      // The stall happened during cold App Server / MCP bootstrap, before a
+      // native turn id existed. Closing that process makes the pending startup
+      // reject; ensureAppServer then returns false and the same prompt gets its
+      // bounded retry through codex exec.
+      appServerDisabled = true
+      appServerThreadReady = false
+      try { server.end() } catch { /* noop */ }
+      if (appServer === server) appServer = null
+    }
+
+    if (child) {
+      const stalledChild = child
+      try { stalledChild.kill('SIGTERM') } catch { /* noop */ }
+      setTimeout(() => {
+        if (child === stalledChild) { try { stalledChild.kill('SIGKILL') } catch { /* noop */ } }
+      }, 1500)
+    }
+  }
+
+  stallTimer = stallSetInterval(() => {
+    const quietMs = stallNow() - lastEvtTs
+    const action = stallDecision({
+      turnActive,
+      awaitingUser,
+      quietMs,
+      stallMs: STALL_MS,
+      forceStopMs: FORCE_STOP_MS,
+      stalledSent,
+      stallRetried,
+    })
+    if (action === 'none') return
+
+    const event = stallEvent(action, quietMs)
+    if (event) emitRaw(event)
+    if (action === 'status') {
+      stalledSent = true
+      return
+    }
+    if (action === 'retry') {
+      // Preserve the prompt and retry budget in pump(); do not use the public
+      // abort flag because that intentionally discards queued work and emits a
+      // terminal aborted boundary.
+      stallRetried = true
+      stallRetryRequested = true
+      lastEvtTs = stallNow()
+      stalledSent = false
+      stopStalledTransport()
+      return
+    }
+
+    // The retry also went silent. Surface the durable terminal boundary now so
+    // the lane cannot remain busy if the native interrupt itself is wedged.
+    stallGiveupRequested = true
+    stallRetryRequested = false
+    queue.length = 0
+    emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: undefined, denials: 0, resultText: null })
+    stopStalledTransport({ force: true })
+  }, STALL_INTERVAL_MS)
+  stallTimer.unref?.()
+
   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 (ended || aborted || stallGiveupRequested) 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
     // after bootstrap finally resolves.
-    if (ended || aborted) return true
+    if (ended || aborted || stallGiveupRequested) return true
     mapper.setUsageBaseline(sessionId ? readCodexThreadUsage(sessionId) : null)
     turnActive = true
     try {
@@ -609,6 +750,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         approvalPolicy: modeConfig.approvalPolicy,
         collaborationMode: codexDefaultCollaborationMode(activeModel, activeEffort),
       })
+      touchActivity()
       // Stop may land after the RPC was written but before startTurn returns its
       // id. abort() already closed the room boundary; interrupt the now-known
       // native turn before waiting, and never let it continue invisibly.
@@ -620,11 +762,18 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       const completed = await appServer.waitForTurn(activeTurnId)
       closeAppServerTurn(completed?.turn?.id || activeTurnId)
       const status = completed?.turn?.status
-      if (aborted || status === 'interrupted') {
+      if (aborted) {
+        emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
+      } else if (status === 'interrupted' && (stallRetryRequested || stallGiveupRequested)) {
+        // The watchdog owns this lifecycle: retry is re-armed by pump(), while
+        // giveup already emitted the one terminal boundary synchronously.
+      } else if (status === 'interrupted') {
         emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
       } else if (status === 'failed') {
+        stallRetryRequested = false
         pushMappedEvent({ type: 'turn.failed', message: completed?.turn?.error?.message || 'codex turn failed' })
       } else {
+        stallRetryRequested = false
         pushMappedEvent({ type: 'turn.completed' })
       }
     } catch (error) {
@@ -636,7 +785,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       closeAppServerTurn(activeTurnId)
       try { appServer?.end() } catch { /* noop */ }
       appServer = null
-      if (!ended) pushMappedEvent({ type: 'turn.failed', message: `codex app-server turn failed: ${error?.message || error}` })
+      if (!ended && !stallRetryRequested && !stallGiveupRequested) pushMappedEvent({ type: 'turn.failed', message: `codex app-server turn failed: ${error?.message || error}` })
     } finally {
       // A transport failure or interrupt can land after prose deltas but before
       // item/completed. Preserve that partial prose as one durable row rather
@@ -654,15 +803,16 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   async function runAppServerReview(commandText) {
-    if (ended || aborted) return true
+    if (ended || aborted || stallGiveupRequested) return true
     if (!await ensureAppServer()) return false
-    if (ended || aborted) return true
+    if (ended || aborted || stallGiveupRequested) return true
     mapper.setUsageBaseline(sessionId ? readCodexThreadUsage(sessionId) : null)
     turnActive = true
     try {
       const started = await appServer.startReview({ threadId: sessionId, target: codexReviewTarget(commandText) })
       activeTurnId = started?.turn?.id || started?.turnId
       if (!activeTurnId) throw new Error('Codex review/start returned no turn id')
+      touchActivity()
       if (aborted || ended) {
         closeAppServerTurn(activeTurnId)
         try { await appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }) } catch { /* boundary is already closed */ }
@@ -671,11 +821,17 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       const completed = await appServer.waitForTurn(activeTurnId)
       closeAppServerTurn(completed?.turn?.id || activeTurnId)
       const status = completed?.turn?.status
-      if (aborted || status === 'interrupted') {
+      if (aborted) {
+        emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
+      } else if (status === 'interrupted' && (stallRetryRequested || stallGiveupRequested)) {
+        // Watchdog-owned interruption; pump decides retry vs terminal giveup.
+      } else if (status === 'interrupted') {
         emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
       } else if (status === 'failed') {
+        stallRetryRequested = false
         pushMappedEvent({ type: 'turn.failed', message: completed?.turn?.error?.message || 'codex review failed' })
       } else {
+        stallRetryRequested = false
         pushMappedEvent({ type: 'turn.completed' })
       }
     } catch (error) {
@@ -684,7 +840,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       closeAppServerTurn(activeTurnId)
       try { appServer?.end() } catch { /* noop */ }
       appServer = null
-      if (!ended) pushMappedEvent({ type: 'turn.failed', message: `codex review failed: ${error?.message || error}` })
+      if (!ended && !stallRetryRequested && !stallGiveupRequested) pushMappedEvent({ type: 'turn.failed', message: `codex review failed: ${error?.message || error}` })
     } finally {
       for (const state of streamedAgentItems.values()) {
         if (!state.text) continue
@@ -699,7 +855,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
   }
 
   async function runExec(prompt, options = {}) {
-    if (ended || aborted) return
+    if (ended || aborted || stallGiveupRequested) return
     // First turn: fresh exec. Later turns: resume THIS lane's captured thread.
     // `--last` is process-global and can cross-wire two concurrently-active Codex
     // lanes, so it is never safe in a multi-lane bridge.
@@ -741,7 +897,10 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         try { ev = JSON.parse(line) } catch { return /* non-JSON progress line */
         }
         if (ev.type === 'thread.started' && ev.thread_id) sessionId = sessionId || ev.thread_id
-        if (ev.type === 'turn.completed' || ev.type === 'turn.failed') sawTerminalResult = true
+        if (ev.type === 'turn.completed' || ev.type === 'turn.failed') {
+          sawTerminalResult = true
+          stallRetryRequested = false
+        }
         pushMappedEvent(ev)
       })
       // stderr is codex's human progress channel; surface tail on failure only.
@@ -755,7 +914,10 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         settled = true
         child = null
         turnActive = false
-        if (aborted && !sawTerminalResult) {
+        if ((stallRetryRequested || stallGiveupRequested) && !sawTerminalResult && !aborted) {
+          // Watchdog interruption: pump either replays once or has already
+          // published the terminal giveup boundary.
+        } else if (aborted && !sawTerminalResult) {
           emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: undefined, denials: 0, resultText: null })
         } else if (!aborted && !sawTerminalResult && code !== 0 && code != null) {
           emitTurnBoundary({ kind: 'error', message: `codex exec exited ${code}${stderrTail ? ': ' + stderrTail.trim().slice(-300) : ''}`, recoverable: true })
@@ -766,7 +928,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         if (settled) return
         settled = true
         child = null
-        emitTurnBoundary({ kind: 'error', message: `codex failed to start: ${e.message}`, recoverable: true })
+        if (!stallRetryRequested && !stallGiveupRequested) emitTurnBoundary({ kind: 'error', message: `codex failed to start: ${e.message}`, recoverable: true })
         resolve()
       })
       child.on('close', finish)
@@ -778,6 +940,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     const next = queue.shift()
     if (!next) return
     chain = chain.then(async () => {
+      armTurnLiveness()
       // runExec sees turnNo===0 on the FIRST turn (fresh exec); increment only
       // after, so subsequent turns resume this lane's captured thread id.
       // Claude receives these through the Agent SDK's system-reminder path.
@@ -794,13 +957,36 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         forceFullReminder: next.forceFullReminder,
       })
       const review = /^\s*\/review(?:\s|$)/i.test(String(next.text || ''))
-      const usedAppServer = review
-        ? await runAppServerReview(next.text)
-        : await runAppServer(prompt, next.options)
-      if (!usedAppServer) {
-        if (review) {
-          emitTurnBoundary({ kind: 'error', message: 'Codex review is unavailable without the tested App Server runtime.', recoverable: true })
-        } else await runExec(prompt, next.options)
+      let retryAttempt = false
+      while (!ended && !aborted && !stallGiveupRequested) {
+        const usedAppServer = review
+          ? await runAppServerReview(next.text)
+          : await runAppServer(prompt, next.options)
+        if (!usedAppServer) {
+          if (review) {
+            stallRetryRequested = false
+            emitTurnBoundary({ kind: 'error', message: 'Codex review is unavailable without the tested App Server runtime.', recoverable: true })
+          } else {
+            // A watchdog interruption during cold App Server startup has no
+            // native turn to wait on. Treat the exec fallback itself as the one
+            // retry rather than accidentally granting a third attempt.
+            if (stallRetryRequested) {
+              stallRetryRequested = false
+              retryAttempt = true
+              armTurnLiveness({ retry: true })
+              emitRaw({ kind: 'note', text: 'retrying the stalled turn on a fresh connection' })
+            }
+            await runExec(prompt, next.options)
+          }
+        }
+        if (stallRetryRequested && !retryAttempt && !stallGiveupRequested && !ended && !aborted) {
+          stallRetryRequested = false
+          retryAttempt = true
+          armTurnLiveness({ retry: true })
+          emitRaw({ kind: 'note', text: 'retrying the stalled turn on a fresh connection' })
+          continue
+        }
+        break
       }
       turnNo++
       pump()
@@ -833,6 +1019,9 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
         try { cwd = prepareCwd() || cwd } catch { /* keep original cwd */ }
       }
       if (turnActive && appServer && activeTurnId) {
+        // A delivered human steer is new work for the active model call; give it
+        // a fresh quiet window before declaring the transport stalled.
+        touchActivity()
         const fullReminder = usesFullThinkPoolReminder({ promptIndex, forceFull: thisTurnForceFull })
         const prompt = buildCodexPrompt({
           text,
@@ -866,7 +1055,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       // first provider event many seconds later.
       if (!turnActive) {
         aborted = false
-        turnActive = true
+        armTurnLiveness()
       }
       // start the pump if idle
       if (queue.length === 1) pump()
@@ -876,6 +1065,8 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
       const activeChain = chain
       const bootstrapOnly = turnActive && !activeTurnId && !child
       aborted = true
+      stallRetryRequested = false
+      stallGiveupRequested = false
       queue.length = 0
       closeAppServerTurn(activeTurnId)
       let interrupt = Promise.resolve()
@@ -895,6 +1086,7 @@ export function startCodexSession({ cwd, model, effort: initialEffort = 'high',
     end() {
       ended = true
       turnActive = false
+      if (stallTimer) stallClearInterval(stallTimer)
       relayEvent.cancel()
       queue.length = 0
       closeAppServerTurn(activeTurnId)

package/package.json

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

package/terminal-name.mjs

@@ -17,6 +17,7 @@ const ANY_HEADING = /^(?:#{1,6}\s+|(?:context|background|constraints?|inputs?|ou
 const NOISE = /^(?:context|background|for reference|here(?:'s| is)|note|current(?:ly)?|example|environment|room now|constraints?|acceptance|success criteria)\b/i
 const EXPLANATION = /^(?:because|cause|since|so that|this is because)\b/i
 const CONSTRAINT = /^(?:users? can still|keep|must|never|should|without)\b/i
+const DEPENDENT_FRAGMENT = /^(?:after|before|by|during|for|from|in|instead(?: of)?|on|through|until|with|without)\b/i
 const INFORMATION_REQUEST = /^(?:which|what|who|where|when|why|how)\b/i
 const NEGATIVE_PREFERENCE = /^(?:(?:i|we)\s+)?(?:do not|don't|dont|would not|wouldn't|won't|wont)\s+(?:(?:want|wanna|need)(?:\s+to)?|use|include|choose)\b|^(?:(?:i|we)\s+)?(?:want|wanna|need)(?:\s+to)?\s+avoid\b/i
 const ISSUE = /\b(?:broken|buggy|crash(?:es|ed|ing)?|duplicate|error|fail(?:s|ed|ing|ure)?|flash(?:es|ed|ing)?|missing|no animation|not working|out of (?:scrollable )?view|stuck|wrong)\b/i
@@ -29,6 +30,7 @@ const ACTIONS = Object.freeze([
   { title: 'Harden', score: 98, re: /\b(?:harden|hardens|hardened|hardening)\b/i },
   { title: 'Snap', score: 96, re: /\b(?:snap|snaps|snapped|snapping)\b/i },
   { title: 'Improve', score: 94, re: /\b(?:improve|improves|improved|improving|optimi[sz](?:e|es|ed|ing)|\bbetter\b)\b/i },
+  { title: 'Rework', score: 93, re: /\b(?:rework|reworks|reworked|reworking)\b/i },
   { title: 'Implement', score: 92, re: /\b(?:implement|implements|implemented|implementing)\b/i },
   { title: 'Build', score: 90, re: /\b(?:build|builds|built|building|create|creates|created|creating)\b/i },
   { title: 'Add', score: 88, re: /\b(?:add|adds|added|adding|wire|wires|wired|wiring)\b/i },
@@ -136,7 +138,11 @@ const bestIntentClause = (text) => {
     if (EXPLANATION.test(clause)) score -= 34
     if (CONSTRAINT.test(clause)) score -= 45
     if (NEGATIVE_PREFERENCE.test(clause)) score -= 70
-    score += Math.round((i / Math.max(1, clauses.length - 1)) * 4)
+    // A short dependent tail such as "From ground up" or "On mobile" adds
+    // scope to the preceding request; it is not a standalone task. Recency is
+    // deliberately not a signal here: the title should represent the main
+    // theme, not whichever sentence happened to come last.
+    if (!action && !REQUEST.test(clause) && !INFORMATION_REQUEST.test(clause) && DEPENDENT_FRAGMENT.test(clause)) score -= 24
     if (!best || score > best.score) best = { clause, score }
   }
   return best?.clause || clauses[0] || null
@@ -175,13 +181,18 @@ const titleWord = (word) => {
   return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
 }
 
-const contentWords = (value) => {
+const contentWords = (value, excludedFamilies = []) => {
   const words = String(value || '').match(/[\p{L}\p{N}][\p{L}\p{N}+#.'-]*/gu) || []
   const seen = new Set()
   const result = []
   for (let word of words) {
     const lower = word.toLowerCase()
     if (SKIP.has(lower) || /^https?$/i.test(word)) continue
+    // ACTIONS intentionally folds synonyms into one title verb (review/test/verify
+    // all become Audit). Once that verb is chosen, words from the same family are
+    // not objects. Keeping them spent the title budget on "Audit Reviews Audits"
+    // before the extractor reached the actual scope.
+    if (excludedFamilies.some((family) => family.test(word))) continue
     if (lower === 'flashes' || lower === 'flashing') word = 'flash'
     if (lower === 'failing' || lower === 'failed' || lower === 'fails') word = 'failure'
     const key = word.toLowerCase().replace(/(?:s|ed|ing)$/i, '')
@@ -227,12 +238,13 @@ const taskTitle = (value) => {
     const before = body.slice(0, action.index)
     objectText = body.slice(action.index + action.match.length)
     const weakLead = bestAction(before)
-    if (weakLead?.score <= 76) domain = contentWords(before.slice(weakLead.index + weakLead.match.length)).slice(0, 3)
+    if (weakLead?.score <= 76) domain = contentWords(before.slice(weakLead.index + weakLead.match.length), [weakLead.re]).slice(0, 3)
     objectText = objectText.split(/\s*,?\s+(?:and|then)\s+(?:(?:also)\s+)?(?=(?:add|build|create|implement|remove|replace|update|wire)\b)/i, 1)[0]
     objectText = objectText.replace(/\b(?:and|then)\s+(?:audit|check|debug|investigate|review|test|verify)\b/gi, ' ')
   }
-  let object = contentWords(objectText)
-  if (!object.length) object = contentWords(body)
+  const excludedObjectFamilies = action ? [action.re] : []
+  let object = contentWords(objectText, excludedObjectFamilies)
+  if (!object.length) object = contentWords(body, excludedObjectFamilies)
   if (informationRequest) {
     const available = object.findIndex((word) => /^available$/i.test(word))
     if (available > 0) object = [object[available], ...object.slice(0, available), ...object.slice(available + 1)]