synabun 2.0.0 → 2.0.5

package/neural-interface/public/shared/blob-store.js

@@ -10,6 +10,38 @@
 const _putTimers = new Map();   // `${ns}/${id}` -> timeout id
 const _pendingPuts = new Map(); // `${ns}/${id}` -> { ns, id, value, opts }
 const DEFAULT_DEBOUNCE_MS = 500;
+// One request per entry at a time, in the order they were asked for: a delete
+// (or a newer write) that overtook a write still on its way would be undone by it.
+const _inFlight = new Map();       // `${ns}/${id}` -> the request under way (a write or a delete); never rejects
+const _waitingDeletes = new Map(); // `${ns}/${id}` -> sends the delete that waits behind that request
+const _asked = new Map();          // `${ns}/${id}` -> counts the puts and deletes asked for
+
+// Every put and delete of this page is numbered when it is asked for, and says which page it is of. Of two
+// requests of one page for an entry the server keeps the one with the higher number, whichever arrives first
+// (lib/ui-blob-store.js): what is sent while the page is being left (flushBlobs) cannot be put in an order here.
+// A server from before this ignores the two fields; the order kept above is then all there is, as it was.
+const _writer = (() => {
+  try { return Array.from(crypto.getRandomValues(new Uint8Array(12)), (byte) => byte.toString(16).padStart(2, '0')).join(''); }
+  catch { return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`; }
+})();
+let _revision = 0;
+
+/** The address of one entry, for the request numbered `rev` (and what a write asks to be evicted). */
+const _url = (ns, id, rev, opts = {}) => {
+  const params = new URLSearchParams();
+  if (opts.maxEntries) params.set('maxEntries', String(opts.maxEntries));
+  if (opts.maxChars) params.set('maxChars', String(opts.maxChars));
+  params.set('rev', String(rev));
+  params.set('writer', _writer);
+  return `/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}?${params.toString()}`;
+};
+const _ask = (key) => { const n = (_asked.get(key) || 0) + 1; _asked.set(key, n); return n; };
+
+function _track(key, request) {
+  const tracked = Promise.resolve(request).then(() => {}, () => {}).then(() => { if (_inFlight.get(key) === tracked) _inFlight.delete(key); });
+  _inFlight.set(key, tracked);
+  return tracked;
+}
 
 export async function fetchBlobNamespace(ns) {
   try {
@@ -22,68 +54,125 @@ export async function fetchBlobNamespace(ns) {
   }
 }
 
+// One entry, or null: there is none, or the server has no such namespace.
+export async function fetchBlob(ns, id) {
+  try {
+    const res = await fetch(`/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}`);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
 async function _sendPut(key) {
   const pending = _pendingPuts.get(key);
   if (!pending) return;
-  _pendingPuts.delete(key);
   _putTimers.delete(key);
-  const { ns, id, value, opts } = pending;
-  const params = new URLSearchParams();
-  if (opts.maxEntries) params.set('maxEntries', String(opts.maxEntries));
-  if (opts.maxChars) params.set('maxChars', String(opts.maxChars));
-  const qs = params.toString();
-  try {
-    const res = await fetch(`/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}${qs ? '?' + qs : ''}`, {
+  // Something of this entry is on its way: this write goes when that is settled (still pending until then).
+  const busy = _inFlight.get(key);
+  if (busy) { busy.then(() => _sendPut(key)); return; }
+  _pendingPuts.delete(key);
+  const { ns, id, value, opts, rev } = pending;
+  const asked = _asked.get(key);
+  const request = (async () => {
+    const res = await fetch(_url(ns, id, rev, opts), {
       method: 'PUT',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(value),
     });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  })();
+  _track(key, request);
+  try {
+    await request;
+    _answer(pending.waiters, true);
   } catch (err) {
-    console.warn(`[blob-store] PUT ${ns}/${id} failed:`, err.message, '— will retry');
-    // Re-queue unless a newer value superseded this one while in flight.
-    if (!_pendingPuts.has(key)) {
+    // Re-queue only if nothing was asked for this entry meanwhile: a newer value superseded this one, or the
+    // entry was deleted (a retry would bring back what was removed).
+    const retry = _asked.get(key) === asked && !_pendingPuts.has(key);
+    console.warn(`[blob-store] PUT ${ns}/${id} failed:`, err.message, retry ? '— will retry' : '— superseded');
+    if (retry) {
       _pendingPuts.set(key, pending);
       _putTimers.set(key, setTimeout(() => _sendPut(key), 2000));
+    } else {
+      // Whoever waits for this write waits for the newer one that took its place; without one (the entry was
+      // deleted) it was given up.
+      const newer = _pendingPuts.get(key);
+      if (newer) newer.waiters.push(...pending.waiters.splice(0));
+      else _answer(pending.waiters, false);
     }
   }
 }
 
-// Debounced per-(ns,id), latest value wins.
+// What the callers of putBlob that wait for it are told: `true`, the server has the value (or a newer one of the
+// entry); `false`, the write was given up.
+const _answer = (waiters, stored) => { for (const done of waiters.splice(0)) done(stored); };
+
+// Debounced per-(ns,id), latest value wins. Answers a promise, for a caller that must not go on before the value
+// is in the store: `true` once the server has stored it (or a newer value of the entry, when one was asked for
+// meanwhile), `false` when the write was given up (the entry was deleted, or the page is going and the write was
+// handed to a beacon, which says nothing back). It never rejects; a write that fails is tried again as before, and
+// the promise waits with it.
 export function putBlob(ns, id, value, opts = {}) {
   const key = `${ns}/${id}`;
   const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
-  _pendingPuts.set(key, { ns, id, value, opts });
+  _ask(key);
+  const waiters = _pendingPuts.get(key)?.waiters || [];
+  const stored = new Promise((done) => { waiters.push(done); });
+  _pendingPuts.set(key, { ns, id, value, opts, rev: ++_revision, waiters });
   if (_putTimers.has(key)) clearTimeout(_putTimers.get(key));
   _putTimers.set(key, setTimeout(() => _sendPut(key), debounceMs));
+  return stored;
 }
 
+// A delete is tried once: one that failed (the server could not make it, refused it, or was not reached) is not
+// sent again. This page cannot know what another page has written to the entry since, and a delete that arrived
+// late would remove that.
 export function deleteBlob(ns, id) {
   const key = `${ns}/${id}`;
   if (_putTimers.has(key)) { clearTimeout(_putTimers.get(key)); _putTimers.delete(key); }
+  const dropped = _pendingPuts.get(key);
   _pendingPuts.delete(key);
-  fetch(`/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}`, { method: 'DELETE' })
-    .catch(() => {});
+  if (dropped) _answer(dropped.waiters, false);
+  _ask(key);
+  const rev = ++_revision;
+  const send = (init = {}) => fetch(_url(ns, id, rev), { method: 'DELETE', ...init }).catch(() => {});
+  const busy = _inFlight.get(key);
+  if (!busy) { _track(key, send()); return; }
+  // After the request of this entry that is on its way (sent once, also when the page goes first: flushBlobs).
+  // Its turn sends it only while it is still the one that waits: a later delete has taken its place, or the
+  // page that was about to be left has sent it already.
+  _waitingDeletes.set(key, send);
+  _track(key, busy.then(() => {
+    if (_waitingDeletes.get(key) !== send) return undefined;
+    _waitingDeletes.delete(key);
+    return send();
+  }));
 }
 
 // Flush all pending puts immediately. With useBeacon (pagehide path), bodies
 // under ~60KB go via sendBeacon (survives unload); larger ones use a best-
 // effort fetch — the last debounced PUT was at most a debounce window ago, so
-// little is lost if it doesn't complete.
+// little is lost if it doesn't complete. What goes out here goes out at once,
+// beside a request that may still be on its way: each carries its number, and
+// the server keeps what was asked for last.
 export function flushBlobs({ useBeacon = false } = {}) {
+  // The page is going: a delete that waits behind a request cannot wait any longer.
+  if (useBeacon) {
+    for (const [key, send] of [..._waitingDeletes.entries()]) { _waitingDeletes.delete(key); send({ keepalive: true }); }
+  }
   for (const [key, pending] of [..._pendingPuts.entries()]) {
     if (_putTimers.has(key)) { clearTimeout(_putTimers.get(key)); _putTimers.delete(key); }
     if (useBeacon) {
-      const { ns, id, value } = pending;
+      const { ns, id, value, rev } = pending;
       const body = JSON.stringify(value);
       _pendingPuts.delete(key);
+      _answer(pending.waiters, false);   // a beacon says nothing back: nobody is told it arrived
       if (body.length < 60_000) {
-        navigator.sendBeacon(
-          `/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}`,
-          new Blob([body], { type: 'application/json' })
-        );
+        navigator.sendBeacon(_url(ns, id, rev), new Blob([body], { type: 'application/json' }));
       } else {
-        fetch(`/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}`, {
+        fetch(_url(ns, id, rev), {
           method: 'PUT',
           headers: { 'Content-Type': 'application/json' },
           body,

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

@@ -7,6 +7,9 @@ import { registerSidepanel, setSidepanelVisible, sidepanelAcceptsKeyboard, openA
 import { subscribeCliStatus, recheckCliStatus, getCliDocUrl, getCliInstallCommand, getCliLabel } from '../cli-status.js';
 import { nativeLoopWindowId } from '../ui-native-window-id.js';
 import { createStickyScrollController, getStickyScrollController } from '../ui-scroll-follow.js';
+import { wireFileLinks } from '../ui-file-links.js';
+import { trackWorkerEnd } from '../ui-worker-end.js';
+import { isDispatchedRun } from '../worker-end.js';
 import { injectStyles } from './cdx-styles.js';
 import { mountContextMenu } from './cdx-context-menu.js';
 import { teardownMcpApps } from './cdx-mcp-app-host.js';
@@ -39,6 +42,7 @@ import {
   handleNotify,
   appendLocalUserMessage, hydrateCodexAutomationHistory,
   clearPlanHandoffState,
+  placeWorkerEnd,
   withTab,
   ensureProjectsLoaded,
   setActiveProject,
@@ -107,7 +111,6 @@ let _contextMenu = null;
  * monolith and are referenced by wireEvents / ensurePanel.
  *
  * Expected shape:
- *   maybeOpenProjectFileLink(href, event) -> bool
  *   flushCardBody(itemState)
  *   resetThreadState(opts)
  *   appendSystem(text, tone)
@@ -785,14 +788,18 @@ async function saveRecallProfile(profile) {
 // ═══════════════════════════════════════════
 
 function wireEvents() {
-  // Project links retain their existing handling; card heads bind in cdx-render.
-  const msgContainer = panelEl('#cxp-messages-container');
-  if (msgContainer) {
-    msgContainer.addEventListener('click', (e) => {
-      const link = e.target.closest('a[href]');
-      if (link && msgContainer.contains(link) && _host.maybeOpenProjectFileLink?.(link.getAttribute('href'), e)) return;
-    });
-  }
+  // File links open in the code editor (../ui-file-links.js, shared with the other panels): one listener for
+  // every tab's transcript, so stored and streaming messages behave alike. Card heads bind in cdx-render.
+  wireFileLinks(panelEl('#cxp-messages-container'), {
+    // A relative path is a path in the project of the tab on screen (a worker run's tab has the run's folder).
+    cwd: (link) => (allTabs().find((tab) => tab.messagesEl?.contains(link)) || activeTab())?.project || '',
+    textLinks: 'a.cxp-file-link',
+    // A path the editor does not open keeps what a click on it did: it is copied.
+    copyPath: (link, path) => navigator.clipboard.writeText(path).then(() => {
+      link.classList.add('cxp-file-link-copied');
+      setTimeout(() => link.classList.remove('cxp-file-link-copied'), 1500);
+    }),
+  });
 
   const input = panelEl('#cxp-input');
   const send = panelEl('#cxp-send');
@@ -1274,6 +1281,19 @@ export async function attachCodexAutomation(run, {
   ensurePanel();
   await ensureProjectsLoaded();
   if (isCancelled()) return { ok: false, reason: 'dismissed' };
+  const running = run.status === 'starting' || run.status === 'running';
+  // The user continued this run's thread by hand after the run ended: the tab stays theirs. The
+  // dock's Focus raises it; the run is let go again, and nothing in the tab changes.
+  const own = allTabs().find((entry) => !entry.automationRunId && entry.releasedRunId === run.runId && entry.threadId === threadId);
+  if (own && !running) {
+    window.dispatchEvent(new CustomEvent('native-loop:dismissed', { detail: { runId: run.runId } }));
+    if (focus) {
+      if (!_visible) await toggleCodexPanel();
+      const ownIdx = allTabs().indexOf(own);
+      if (ownIdx >= 0) switchTab(ownIdx);
+    }
+    return { ok: true, tabId: own.id, released: true };
+  }
   let tab = allTabs().find((entry) => entry.automationRunId === run.runId);
   if (!tab) {
     tab = createTab({
@@ -1291,7 +1311,6 @@ export async function attachCodexAutomation(run, {
     }, { autoSwitch: false });
   }
   if (!tab) return { ok: false, reason: 'tab_limit' };
-  const running = run.status === 'starting' || run.status === 'running';
   // A task-mode worker between turns (waiting for a follow-up) is alive, not working.
   const working = running && run.turnState !== 'idle' && run.turnState !== 'terminal';
   tab.automationRunId = run.runId;
@@ -1315,10 +1334,12 @@ export async function attachCodexAutomation(run, {
       return { ok: false, reason: 'dismissed' };
     }
   }
-  if (run.status === 'failed' && run.error && tab._automationLifecycleError !== run.error) {
+  // (A dispatched worker's failure, with its reason, is on its end card.)
+  if (run.status === 'failed' && run.error && !isDispatchedRun(run) && tab._automationLifecycleError !== run.error) {
     tab._automationLifecycleError = run.error;
     withTab(tab, () => appendSystem(run.error, 'error'));
   }
+  trackWorkerEnd(run, { apply: (view) => { tab._workerEnd = view; placeWorkerEnd(tab); } });
   saveTabs();
   renderPills();
   if (focus) {

package/neural-interface/public/shared/cdx/cdx-render.js

@@ -16,6 +16,7 @@ import { bindExpandableCard, setCardExpanded } from './cdx-cards.js';
 import { mountMcpAppCard } from './cdx-mcp-app-host.js';
 import { OUTPUT_LIMITS, boundedText, jsonAnswer, prettyJsonFences, readableStructuredValue, fileChangeDiffs, parseUnifiedDiff, deduplicateTurnDiff } from './cdx-output-model.js';
 import { renderReadableOutput, renderReadableBlock, cleanOutputBlocks, hydrateOutputControls, observeOutputBlocks, renderDiffView, restoreDiffViews } from './cdx-output.js';
+import { fileLinkTitle, fillFileLinkCopy, isInsideRoots, parseFileLinkTarget } from '../file-links.js';
 export { setCardExpanded } from './cdx-cards.js';
 
 // ── Shared context (set by cdx-tabs via setRenderContext) ──
@@ -375,101 +376,45 @@ export function postProcessRenderedHtml(container) {
 // ═══════════════════════════════════════════
 // File Path Linking
 // ═══════════════════════════════════════════
+// What a target means is decided in ../file-links.js, shared with the other panels; a click is taken by the
+// one listener cdx-panel.js puts on the transcript (../ui-file-links.js), so links in a stored transcript
+// work like fresh ones.
 
 export function normalizePathForCompare(path) {
   return String(path || '').replace(/\\/g, '/').replace(/\/+$/, '');
 }
 
-export function isProjectFilePath(path) {
-  const normalized = normalizePathForCompare(path);
-  if (!normalized.startsWith('/')) return false;
-  const roots = new Set([
-    normalizePathForCompare(_ctx.project),
-    ...(_ctx.projects || []).map((entry) => normalizePathForCompare(entry?.path)).filter(Boolean),
-  ]);
-  for (const root of roots) {
-    if (!root) continue;
-    if (normalized === root || normalized.startsWith(`${root}/`)) return true;
-  }
-  return false;
+// The folder a relative link is read from: the project of the tab the transcript belongs to.
+function fileLinkWhere() {
+  return {
+    cwd: _ctx.boundTab?.project || _ctx.project || '',
+    origin: globalThis.location?.origin || '',
+  };
 }
 
-export function parseProjectFileTarget(rawTarget) {
-  if (!rawTarget) return null;
-  let raw = String(rawTarget).trim();
-  if (!raw || raw === '#') return null;
-  if (raw.startsWith('file://')) {
-    try { raw = decodeURIComponent(new URL(raw).pathname || ''); }
-    catch { raw = raw.replace(/^file:\/\//, ''); }
-  }
-
-  let pathPart = raw;
-  let hash = '';
-  if (/^[a-z]+:\/\//i.test(raw)) {
-    try {
-      const parsed = new URL(raw, window.location.origin);
-      if (parsed.origin !== window.location.origin) return null;
-      pathPart = parsed.pathname || '';
-      hash = parsed.hash || '';
-    } catch {
-      return null;
-    }
-  } else {
-    const hashIndex = raw.indexOf('#');
-    if (hashIndex >= 0) {
-      pathPart = raw.slice(0, hashIndex);
-      hash = raw.slice(hashIndex);
-    }
-  }
-
-  try { pathPart = decodeURIComponent(pathPart); } catch {}
-  pathPart = normalizePathForCompare(pathPart);
-
-  let line = null;
-  let column = null;
-  const suffixMatch = pathPart.match(/:(\d+)(?::(\d+))?$/);
-  if (suffixMatch) {
-    line = Number(suffixMatch[1]) || null;
-    column = Number(suffixMatch[2]) || null;
-    pathPart = normalizePathForCompare(pathPart.slice(0, suffixMatch.index));
-  }
-  if (!isProjectFilePath(pathPart)) return null;
-  const hashMatch = hash.match(/^#L(\d+)(?:C(\d+))?$/i);
-  if (hashMatch) {
-    line = Number(hashMatch[1]) || line;
-    column = Number(hashMatch[2]) || column;
-  }
-
-  return { filePath: pathPart, line, column };
+export function isProjectFilePath(path) {
+  return isInsideRoots(path, [_ctx.boundTab?.project, _ctx.project, ...(_ctx.projects || []).map((entry) => entry?.path)]);
 }
 
-export function openProjectFileTarget(target) {
-  if (!target?.filePath) return false;
-  _ctx.emit('open-file-editor', {
-    filePath: target.filePath,
-    line: target.line || undefined,
-    column: target.column || undefined,
-  });
-  return true;
+// A link target that is a file of this tab's project or of a registered one, or null.
+function projectFileTarget(rawTarget) {
+  const target = parseFileLinkTarget(rawTarget, fileLinkWhere());
+  return target?.path && isProjectFilePath(target.path) ? target : null;
 }
 
-export function maybeOpenProjectFileLink(rawTarget, event) {
-  const target = parseProjectFileTarget(rawTarget);
-  if (!target) return false;
-  event?.preventDefault?.();
-  return openProjectFileTarget(target);
+function openInEditorTitle(target) {
+  const { key, params } = fileLinkTitle(target);
+  return _ctx.fileLinkText?.(key, params) || fillFileLinkCopy(key, params);
 }
 
 export function markProjectFileAnchors(container) {
   if (!container) return;
   container.querySelectorAll('a[href]').forEach((link) => {
-    const target = parseProjectFileTarget(link.getAttribute('href'));
+    const target = projectFileTarget(link.getAttribute('href'));
     if (!target) return;
     link.classList.add('cxp-file-link');
-    link.dataset.projectFilePath = target.filePath;
-    link.title = target.line
-      ? `Open in editor${target.column ? ` at line ${target.line}, column ${target.column}` : ` at line ${target.line}`}`
-      : 'Open in editor';
+    link.dataset.projectFilePath = target.path;
+    link.title = openInEditorTitle(target);
   });
 }
 
@@ -497,19 +442,10 @@ export function linkifyFilePaths(container) {
       const link = document.createElement('a');
       link.className = 'cxp-file-link';
       link.textContent = pathStr;
-      const target = parseProjectFileTarget(pathStr);
-      link.title = target?.line
-        ? `Open in editor${target.column ? ` at line ${target.line}, column ${target.column}` : ` at line ${target.line}`}`
-        : target ? 'Open in editor' : 'Click to copy path';
+      const target = projectFileTarget(pathStr);
+      link.title = target ? openInEditorTitle(target) : 'Click to copy path';
       link.href = '#';
-      link.addEventListener('click', (e) => {
-        if (maybeOpenProjectFileLink(pathStr, e)) return;
-        e.preventDefault();
-        const cleanPath = pathStr.replace(/:\d+(:\d+)?$/, '');
-        navigator.clipboard.writeText(cleanPath).catch(() => {});
-        link.classList.add('cxp-file-link-copied');
-        setTimeout(() => link.classList.remove('cxp-file-link-copied'), 1500);
-      });
+      // The click is taken on the transcript (cdx-panel.js): the editor when it can open the path, else a copy.
       frag.appendChild(link);
       lastIndex = match.index + match[0].length;
     }

package/neural-interface/public/shared/cdx/cdx-styles.js

@@ -2442,6 +2442,42 @@ export function injectStyles() {
       .cxp-post-plan-utilities .cxp-request-btn { flex: 1; justify-content: center; }
     }
 
+    /* ── A dispatched worker's end (ui-worker-end.js): the post-plan header and note in the
+       compaction card's hairline frame, in the transcript column. The title says the state in words. ── */
+    .cxp-worker-end {
+      display: grid;
+      gap: var(--cxp-space-2);
+      min-width: 0;
+      margin: var(--cxp-space-2) var(--cxp-space-2) var(--cxp-space-3) calc(var(--cxp-space-2) + 24px + var(--cxp-space-2));
+      padding: var(--cxp-space-3) var(--cxp-space-4);
+      border: 1px solid var(--cxp-border-strong);
+      border-radius: var(--cxp-radius-md);
+      font-family: var(--cxp-font);
+    }
+    .cxp-worker-end[data-tone="ok"] .cxp-post-plan-header { color: var(--cxp-success); }
+    .cxp-worker-end[data-tone="warn"] .cxp-post-plan-header { color: var(--cxp-warning); }
+    .cxp-worker-end[data-tone="err"] .cxp-post-plan-header { color: var(--cxp-danger); }
+    .cxp-worker-end .cxp-post-plan-note { overflow-wrap: anywhere; }
+    .cxp-worker-end .worker-end-meta {
+      font-family: var(--cxp-mono);
+      font-size: var(--cxp-fs-xs);
+      color: var(--cxp-text-3);
+    }
+    .cxp-worker-end .worker-end-note {
+      font-size: var(--cxp-fs-sm);
+      line-height: var(--cxp-lh-tight);
+      color: var(--cxp-text-3);
+    }
+    .cxp-worker-end .worker-end-actions { display: flex; margin-top: var(--cxp-space-1); }
+    .cxp-worker-end .cxp-request-btn:focus-visible {
+      outline: 2px solid var(--cxp-focus);
+      outline-offset: 2px;
+    }
+    @media (max-width: 390px) {
+      .cxp-worker-end { margin-left: var(--cxp-space-2); padding: var(--cxp-space-3); }
+      .cxp-worker-end .cxp-request-btn { flex: 1; justify-content: center; }
+    }
+
     /* ── Composer ── */
     .cxp-bottom {
       flex-shrink: 0;