synabun 2026.5.2-beta → 2026.5.3-beta

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## THIS IS A NEW CHANGELOG START FRESH ##
 
+## 2026-05-03
+
+### Fixed — OpenCode Sidepanel: Auto-Recovery for Kimi/OpenCode `question` Tool Deadlock
+
+- **Symptom** — In the OpenCode sidepanel with `kimi-for-coding/k2p6` (and likely other non-Anthropic providers via OpenCode 1.14.30), answering an interactive question card (e.g. `/synabun changelog`'s Save/Edit/Cancel prompt, or any skill that calls the OpenCode `question` tool) hung the session indefinitely. Diagnostic from `~/.local/share/opencode/log/2026-05-01T235721.log` (session `ses_2144a6db9ffenIy1ILBw42mMeg` / question `que_debd75e030018zoXNsm4WhqaPC`): `service=question … asking` + `bus type=question.asked publishing` at 03:17:33 → user-answer `POST /question/<id>` returned **200 in 24 ms** at 03:21:16 → **12 minutes of total log silence** (no `service=llm providerID=kimi-for-coding modelID=k2p6 … stream` follow-up, no `tool.registry status=completed`, no bus events, no session.processor activity) → user clicked Stop at 03:33:23 (`session.prompt cancel` / `error=Aborted process`). OpenCode-side stall: HTTP layer accepted the answer but `session.processor` never resumed the LLM stream.
+- **Fix — sidepanel-side watchdog + auto-recovery** in `neural-interface/public/shared/ocp/ocp-tabs.js`. Single-file change.
+  - **`QUESTION_REPLY_WATCHDOG_MS = 75000`** — generous enough for slow tool-follow-up TTFT (typically 1–3 s) but recovers fast enough that the user isn't burned (previous behavior: 12-min stall before manual Stop).
+  - **`buildAnswerSyntheticMessage(questions, answers)`** — converts the question card's `pendingAnswers` object into a human-readable string. Single answer → bare value; multi-answer → `Here are my answers:\n- Q: A\n…`; multi-select arrays joined with `, `.
+  - **`scheduleQuestionReplyWatchdog(tab, syntheticMessage)`** — sets `tab._questionReplyWatchdogId` setTimeout + caches the synthetic on `tab._questionReplyAnswerSnapshot`. Both transient (NOT in `saveTabs` serialization list — auto-discarded on reload). Idempotent: re-scheduling clears the prior timer.
+  - **`clearQuestionReplyWatchdog(tab)`** — idempotent timer-clear + snapshot reset. Wired into 4 sites: `closeTab`, `sendMessage` start (after `clearPlanFinalizationWatchdog`), `abortTab` (after `clearPlanFinalizationWatchdog`), and `handleSSEEvent` immediately after `tab._lastEventAt = Date.now()` — that single insertion catches every "LLM is alive" signal (`message.part.delta`, `message.updated`, `message.completed`, `session.idle`, `session.error`, `tool.start`, `tool.result`, etc.) without per-handler hooks.
+  - **`executeQuestionReplyRecovery(tab, syntheticMessage)`** async — switches back to the originating tab if the user navigated away (`_tabs.indexOf(tab)` + `switchTab(idx)` since `sendMessage` operates on `activeTab()`). Renders banner ("Model didn't resume after answering. Auto-recovering — resending your answer as a regular message…"), rejects pending send request, resets `running`/`turnStartedAt`/turn state, then `await requestWs('message:abort', { sessionId }, 5000)` to settle the abort server-side BEFORE `await sendMessage(syntheticMessage)` — prevents a late `session.idle` from the abort racing into the new turn and flipping `tab.running` back to false.
+  - **Wired into `renderOpencodeQuestion`'s `question:reply` `.then(resp)`** success branch — schedules watchdog only when `resp.status < 400` (don't watchdog a failed reply). Anthropic / Qwen flows emit `message.part.delta` within ~1 s of `question:reply`, clearing the watchdog before it ever fires; only the Kimi-style stall reaches the recovery path.
+
+### Fixed — OpenCode Sidepanel MCP Profile Dropdown Label Sync
+
+- **`populateProfileDropdown()` missing label update** — `neural-interface/public/shared/ocp/ocp-panel.js:1405`. When the `mcp:profile-changed` event fired (e.g., from MCP profile action='set'), the dropdown menu items were rebuilt with correct selection state, but the visible label itself was never updated. This left the OpenCode sidepanel showing a stale profile name while the MCP profile had changed.
+- **Fix** — Added 4 lines inside `populateProfileDropdown(dd)` immediately before the `for (const p of _mcpProfiles)` rebuild loop: `const matched = _mcpProfiles.find(p => p.id === _currentProfile); lbl.textContent = matched ? matched.label : _currentProfile; dd.classList.add('has-value'); dd._value = _currentProfile;`. The dropdown label now stays in sync with profile changes via the MCP tool, sidepanel API, or file reload.
+
 ## 2026-05-02
 
 ### Fixed — OpenCode Sidepanel: Read-Only Tools After Plan→Build / Plan→Chat Transition (Qwen + non-Anthropic models)

package/neural-interface/public/shared/ocp/ocp-panel.js

@@ -1405,6 +1405,10 @@ function populateProfileDropdown(dd) {
   const lbl = dd.querySelector('.ocp-dd-label');
   if (!menu || !lbl) return;
   menu.innerHTML = '';
+  const matched = _mcpProfiles.find(p => p.id === _currentProfile);
+  lbl.textContent = matched ? matched.label : _currentProfile;
+  dd.classList.add('has-value');
+  dd._value = _currentProfile;
   for (const p of _mcpProfiles) {
     const opt = document.createElement('div');
     opt.className = 'ocp-dd-option' + (p.id === _currentProfile ? ' selected' : '');

package/neural-interface/public/shared/ocp/ocp-tabs.js

@@ -669,6 +669,8 @@ export function switchTab(idx) {
 export function closeTab(idx) {
   if (idx < 0 || idx >= _tabs.length) return;
   const tab = _tabs[idx];
+  clearPlanFinalizationWatchdog(tab);
+  clearQuestionReplyWatchdog(tab);
   flushSessionSnapshotSave(tab);
   if (tab.pillEl) tab.pillEl.remove();
   if (tab.trayPillEl) tab.trayPillEl.remove();
@@ -1150,6 +1152,86 @@ function clearPlanFinalizationWatchdog(tab) {
   }
 }
 
+// Watchdog for the kimi-for-coding/k2p6 + OpenCode 1.14.30 deadlock: POST
+// /question/<id> returns 200 but session.processor never resumes — no second
+// LLM stream call, no message.part.delta, no session.idle. Without this, the
+// user sits in "Thinking…" until they manually Stop. After QUESTION_REPLY_WATCHDOG_MS
+// of total SSE silence post-reply, abort the stuck turn and resend the answer
+// as a regular `message:send` (which works fine — the bug is specific to the
+// question-tool resolve path, not normal message turns). Watchdog is cleared
+// in `handleSSEEvent` on any SSE event for this tab, in `abortTab`, and at the
+// start of `sendMessage`.
+const QUESTION_REPLY_WATCHDOG_MS = 75000;
+
+function buildAnswerSyntheticMessage(questions, answers) {
+  const fmt = (v) => Array.isArray(v) ? v.map(x => String(x ?? '').trim()).filter(Boolean).join(', ') : String(v ?? '').trim();
+  if (typeof answers === 'string') return answers.trim();
+  if (!answers || typeof answers !== 'object') return '';
+  const entries = Object.entries(answers).filter(([, v]) => fmt(v));
+  if (entries.length === 0) return '';
+  if (entries.length === 1) return fmt(entries[0][1]);
+  const lines = entries.map(([q, a]) => `- ${q}: ${fmt(a)}`);
+  return `Here are my answers:\n${lines.join('\n')}`;
+}
+
+function scheduleQuestionReplyWatchdog(tab, syntheticMessage) {
+  if (!tab || !syntheticMessage) return;
+  if (tab._questionReplyWatchdogId) clearTimeout(tab._questionReplyWatchdogId);
+  tab._questionReplyAnswerSnapshot = syntheticMessage;
+  tab._questionReplyWatchdogId = setTimeout(() => {
+    const snap = tab._questionReplyAnswerSnapshot;
+    tab._questionReplyWatchdogId = null;
+    tab._questionReplyAnswerSnapshot = null;
+    if (!snap || !tab.running) return;
+    executeQuestionReplyRecovery(tab, snap);
+  }, QUESTION_REPLY_WATCHDOG_MS);
+}
+
+function clearQuestionReplyWatchdog(tab) {
+  if (tab?._questionReplyWatchdogId) {
+    clearTimeout(tab._questionReplyWatchdogId);
+    tab._questionReplyWatchdogId = null;
+  }
+  if (tab) tab._questionReplyAnswerSnapshot = null;
+}
+
+async function executeQuestionReplyRecovery(tab, syntheticMessage) {
+  // sendMessage operates on activeTab(); if the user switched away while
+  // waiting, switch back so the synthetic recovery lands in the right tab.
+  if (tab !== activeTab()) {
+    const idx = _tabs.indexOf(tab);
+    if (idx >= 0) switchTab(idx);
+  }
+  const live = panelEl('#ocp-messages');
+  if (live) {
+    renderErrorMessage(live, "Model didn't resume after answering. Auto-recovering — resending your answer as a regular message…");
+    removeThinking(live);
+    finalizeStreamingMessage(live);
+  }
+  if (tab._activeSendRequestId) {
+    try { rejectPending(tab._activeSendRequestId, 'Question stall recovery'); } catch {}
+    if (_activeSendRequestId === tab._activeSendRequestId) _activeSendRequestId = null;
+    tab._activeSendRequestId = null;
+  }
+  setActiveQuestionToolId(tab, null);
+  tab.running = false;
+  tab.turnStartedAt = 0;
+  endTurn(tab);
+  setTurnStatus(tab);
+  update();
+  // Await the abort so the stuck message is closed server-side before we
+  // start a fresh turn — prevents a late `session.idle` from the abort
+  // racing into the new turn and flipping `tab.running` back to false.
+  if (tab.sessionId) {
+    try { await requestWs('message:abort', { sessionId: tab.sessionId }, 5000); } catch {}
+  }
+  try {
+    await sendMessage(syntheticMessage);
+  } catch (err) {
+    console.error('[ocp-tabs] question stall recovery sendMessage failed:', err);
+  }
+}
+
 export function applySavedPlan(tab, content, filePath = '') {
   if (!tab || !content) return;
   tab.planContent = content;
@@ -1195,6 +1277,7 @@ export async function sendMessage(content, options = {}) {
   tab._exitPlanDetected = false;
   tab._pendingPostPlanCheck = false;
   clearPlanFinalizationWatchdog(tab);
+  clearQuestionReplyWatchdog(tab);
 
   const turnStartedAt = Date.now();
   tab.running = true;
@@ -1406,6 +1489,7 @@ function abortTab(tab, container = null) {
   endTurn(tab);
   setTurnStatus(tab);
   clearPlanFinalizationWatchdog(tab);
+  clearQuestionReplyWatchdog(tab);
   return true;
 }
 
@@ -1896,6 +1980,9 @@ export function handleSSEEvent(eventType, event) {
   // distinguished from a truly dead session (sendMessage uses this to suppress
   // the red error toast when SSE is still streaming).
   tab._lastEventAt = Date.now();
+  // Any SSE event after a question reply means the LLM resumed — clear the
+  // post-reply watchdog so it doesn't fire spurious recovery.
+  clearQuestionReplyWatchdog(tab);
 
   const isActiveTab = tab === activeTab();
   const container = isActiveTab ? panelEl('#ocp-messages') : null;
@@ -2486,6 +2573,13 @@ function renderOpencodeQuestion(tab, container, event, requestID) {
               startedAt: Date.now(),
               waiting: true,
             });
+            // Arm the no-resume watchdog. Auto-recovers from the
+            // kimi-for-coding/k2p6 + OpenCode 1.14.30 deadlock where the POST
+            // is accepted but session.processor never resumes the LLM stream.
+            if (!resp?.status || resp.status < 400) {
+              const synthetic = buildAnswerSyntheticMessage(questions, answers);
+              if (synthetic) scheduleQuestionReplyWatchdog(tab, synthetic);
+            }
             processQuestionQueue(tab, container);
             update();
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synabun",
-  "version": "2026.5.2-beta",
+  "version": "2026.5.3-beta",
   "description": "Persistent vector memory for AI assistants",
   "license": "Apache-2.0",
   "author": "The SynaBun Authors",