synabun 2.0.0 → 2.0.7

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

@@ -1,4 +1,5 @@
 import { capabilityAvailability, flattenNativeCatalog, reviewTarget } from './cdx-commands.js';
+import { t } from '../i18n.js';
 import { knownCodexCapabilities } from './cdx-capabilities.js';
 import { codexReadableValue, parseCodexAttachmentPayload, codexGatewayState, codexVerificationState, codexHttpsHandoff } from './cdx-protocol.js';
 
@@ -333,23 +334,27 @@ export function updateCodexGateway(tab, value) {
   accountSecurityViews.get(tab)?.();
 }
 
-export async function mountCodexAccountSecurity({ host, request, tab, capabilities }) {
+export async function mountCodexAccountSecurity({ host, experimentalHost = host, request, tab, capabilities }) {
+  const tr = (key, params) => t(`codexSettings.${key}`, params);
   const view = { error: message => { error.textContent = message; } };
   const error = element('div', 'cxp-settings-hint'); error.setAttribute('role', 'alert');
   const gateway = element('div', 'cxp-settings-section');
   const verification = element('div', 'cxp-settings-section');
-  host.append(gateway, verification, error);
+  host.append(gateway, error);
+  experimentalHost.append(verification);
   const available = name => capabilityAvailability(knownCodexCapabilities(tab) || capabilities, name);
   const renderGateway = () => {
     if (!host.isConnected || tab.closed) { accountSecurityViews.delete(tab); return; }
     gateway.replaceChildren();
     if (!available('gateway_oauth_read').supported) return;
     const value = tab.gatewayOAuth || {};
+    gateway.hidden = !value.required;
+    if (!value.required) return;
     const state = codexGatewayState(value);
-    gateway.append(element('div', 'cxp-settings-section-title', 'Gateway OAuth'));
-    gateway.append(element('div', 'cxp-settings-hint', `${value.providerName || value.providerId || 'Provider'} · ${state.label}`));
+    gateway.append(element('div', 'cxp-settings-section-title', tr('gateway')));
+    gateway.append(element('div', 'cxp-settings-hint', `${value.providerName || value.providerId || tr('provider')} · ${tr(`gatewayStates.${value.status || 'notReady'}`)}`));
     const action = state.pending ? 'gateway_oauth_cancel' : 'gateway_oauth_login';
-    gateway.append(button(state.pending ? 'Cancel' : 'Sign in', async () => {
+    gateway.append(button(tr(state.pending ? 'cancel' : 'signIn'), async () => {
       if (!available(action).supported) throw new Error(available(action).reason);
       await request(action, {});
       // Notification is authoritative; do not overwrite a completed login with a stale optimistic state.
@@ -360,10 +365,10 @@ export async function mountCodexAccountSecurity({ host, request, tab, capabiliti
     }, view, available(action)));
     if (!available(action).supported) gateway.append(element('div', 'cxp-settings-hint', available(action).reason));
     const handoff = codexHttpsHandoff(value.authUrl);
-    if (value.authUrl && !handoff) gateway.append(element('div', 'cxp-settings-hint', 'Authorization URL is unavailable: HTTPS is required.'));
+    if (value.authUrl && !handoff) gateway.append(element('div', 'cxp-settings-hint', tr('httpsRequired')));
     if (handoff && state.pending) {
-      gateway.append(element('div', 'cxp-settings-hint', `Continue sign-in at ${handoff.host}`));
-      gateway.append(button(`Open ${handoff.host}`, () => {
+      gateway.append(element('div', 'cxp-settings-hint', tr('continueAt', { host: handoff.host })));
+      gateway.append(button(tr('openHost', { host: handoff.host }), () => {
         window.open(handoff.url, '_blank', 'noopener,noreferrer');
       }, view));
     }
@@ -386,12 +391,15 @@ export async function mountCodexAccountSecurity({ host, request, tab, capabiliti
       const response = await request('verification_status', {});
       if (!host.isConnected || tab.closed) return;
       const state = codexVerificationState(response.verification);
-      verification.append(element('div', 'cxp-settings-section-title', 'User verification · Experimental'));
-      verification.append(element('div', 'cxp-settings-hint', state.label));
-      verification.append(element('div', 'cxp-settings-hint', 'Local device credential only; backend registration is managed by the verifier.'));
+      const reason = response.verification?.unavailableReason;
+      verification.hidden = !!reason && reason !== 'credentialMissing';
+      if (verification.hidden) return;
+      verification.append(element('div', 'cxp-settings-section-title', tr('verification')));
+      verification.append(element('div', 'cxp-settings-hint', tr(state.enrolled ? 'credentialReady' : 'credentialMissing')));
+      verification.append(element('div', 'cxp-settings-hint', tr('localCredential')));
       const action = state.enrolled ? 'verification_delete' : 'verification_enroll';
-      const control = button(state.enrolled ? 'Remove' : 'Enroll', async () => {
-        if (state.enrolled && !window.confirm('Remove the local user verification credential?')) return;
+      const control = button(tr(state.enrolled ? 'remove' : 'enroll'), async () => {
+        if (state.enrolled && !window.confirm(tr('removeCredential'))) return;
         await request(action, {}); await readVerification();
       }, view, available(action));
       if (state.enrolled) control.style.color = 'var(--cxp-danger)';
@@ -399,7 +407,7 @@ export async function mountCodexAccountSecurity({ host, request, tab, capabiliti
       if (!available(action).supported) verification.append(element('div', 'cxp-settings-hint', available(action).reason));
     } catch (failure) {
       if (available('verification_status').supported) {
-        verification.append(element('div', 'cxp-settings-hint', `User verification unavailable: ${failure.message}`));
+        verification.append(element('div', 'cxp-settings-hint', tr('error', { message: failure.message })));
       }
     }
   }

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

@@ -41,6 +41,8 @@ export let windowId = hostedSidepanelId || sessionStorage.getItem('cxp-window-id
 // ── Storage Keys ──
 export const STOR = {
   threadId: 'synabun-codex-panel-thread',
+  // The account that thread belongs to (its rollout lives in that account's CODEX_HOME).
+  threadAccount: 'synabun-codex-panel-thread-account',
   title: 'synabun-codex-panel-title',
   project: 'synabun-codex-panel-project',
   projectThreads: 'synabun-codex-panel-project-threads',

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

@@ -4,9 +4,12 @@
 import { storage } from '../storage.js';
 import { state, emit, on } from '../state.js';
 import { registerSidepanel, setSidepanelVisible, sidepanelAcceptsKeyboard, openAnotherSidepanelSession } from '../ui-sidepanel-windows.js';
-import { subscribeCliStatus, recheckCliStatus, getCliDocUrl, getCliInstallCommand, getCliLabel } from '../cli-status.js';
+import { mountCliBanner } from '../ui-cli-banner.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';
@@ -27,6 +30,7 @@ import {
   requestModelList, populateModelDropdown,
   setSessionLabel, renameActiveSession, promptNameNewSession, openSettingsPanel, renderSessionMenu,
   toggleAccountMenu,
+  mountCodexAccountMenu,
   contextMenuData, contextMenuReading, refreshContextMenuDetails,
   addImageFromFile, removeImage, renderImageStrip,
   addPathChip, removePathChip, renderPathStrip,
@@ -39,6 +43,7 @@ import {
   handleNotify,
   appendLocalUserMessage, hydrateCodexAutomationHistory,
   clearPlanHandoffState,
+  placeWorkerEnd,
   withTab,
   ensureProjectsLoaded,
   setActiveProject,
@@ -58,8 +63,7 @@ document.addEventListener('visibilitychange', () => {
 let _panel = null;
 let _visible = false;
 let _resizeBound = false;
-let _cliInstalled = null;
-let _cliUnsub = null;
+let _cliBanner = null; // the CLI banner and send-block (ui-cli-banner.js)
 
 // ═══════════════════════════════════════════
 //  Bound State (mirrors active tab — managed by cdx-tabs)
@@ -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)
@@ -272,7 +275,6 @@ function buildPanel() {
         <button class="cxp-btn" id="cxp-slide" title="Slide panel"><svg viewBox="0 0 24 24"><polyline points="9 18 15 12 9 6"/></svg></button>
       </div>
       <div class="cxp-session-menu" id="cxp-session-menu"></div>
-      <div class="cxp-account-menu" id="cxp-account-menu"></div>
     </div>
     <div class="cxp-messages-container" id="cxp-messages-container"></div>
     <div class="cxp-bottom">
@@ -403,122 +405,66 @@ function startupEmptyText() {
 }
 
 // ── CLI installation status (banner + send-block) ──
-let _cliInstallFailureForced = false;
-let _cliFailureReason = null;
-
-function ensureCliBannerEl() {
-  if (!_panel) return null;
-  const container = panelEl('#cxp-messages-container');
-  if (!container || !container.parentNode) return null;
-  let banner = container.parentNode.querySelector(':scope > .cxp-cli-banner');
-  if (banner) { renderCliBannerContent(banner); return banner; }
-  const url = getCliDocUrl('codex');
-  banner = document.createElement('div');
-  banner.className = 'cxp-cli-banner';
-  banner.innerHTML = `
-    <div class="cxp-cli-banner-icon">!</div>
-    <div class="cxp-cli-banner-text">
-      <div class="cxp-cli-banner-title"></div>
-      <div class="cxp-cli-banner-body"></div>
-    </div>
-    <div class="cxp-cli-banner-actions">
-      <a class="cxp-cli-banner-link" href="${url}" target="_blank" rel="noopener noreferrer">Install guide</a>
-      <button class="cxp-cli-banner-recheck" type="button">Re-check</button>
-    </div>
-  `;
-  container.parentNode.insertBefore(banner, container);
-  const btn = banner.querySelector('.cxp-cli-banner-recheck');
-  btn?.addEventListener('click', async () => {
-    btn.disabled = true;
-    btn.textContent = 'Checking…';
-    try { await recheckCliStatus('codex'); }
-    finally {
-      if (btn.isConnected) {
-        btn.disabled = false;
-        btn.textContent = 'Re-check';
-      }
-    }
-  });
-  renderCliBannerContent(banner);
-  return banner;
-}
-
-// Two very different situations reach this banner, and telling the user the
-// CLI is "not installed" when it is installed sends them off to reinstall
-// something that is already there. Distinguish them.
-function renderCliBannerContent(banner) {
-  const titleEl = banner.querySelector('.cxp-cli-banner-title');
-  const bodyEl = banner.querySelector('.cxp-cli-banner-body');
-  if (!titleEl || !bodyEl) return;
-  const label = getCliLabel('codex');
-  bodyEl.replaceChildren();
-
-  if (_cliInstalled === null) {
-    titleEl.textContent = `${label} CLI not installed`;
-    const cmd = getCliInstallCommand('codex');
-    bodyEl.append('Run ');
-    const code = document.createElement('code');
-    code.textContent = cmd;
-    bodyEl.append(code, ' or follow the install guide.');
-    return;
-  }
-
-  titleEl.textContent = `${label} CLI failed to start`;
-  bodyEl.append(`${label} v${_cliInstalled} is installed, but it could not be launched. `);
-  if (_cliFailureReason) {
-    const code = document.createElement('code');
-    code.textContent = _cliFailureReason;
-    bodyEl.append(code);
-  } else {
-    bodyEl.append('Check the CLI path in Settings, then re-check.');
+// One controller (ui-cli-banner.js) draws the banner above the transcript while
+// Codex is not usable: not installed (with Install, which runs OpenAI's own
+// installer on the server), being installed, failed to install, or found but
+// failed to start (with the error it gave). It toggles `cxp-cli-blocked` on the
+// panel, which syncInputEnabled (cdx-tabs.js) reads to keep Send off. What it
+// says is cli-install-view.js (`cliInstall.*` strings).
+let _cliWasBlocked = false;
+
+function cliBanner() {
+  if (!_cliBanner) {
+    _cliBanner = mountCliBanner({
+      toolKey: 'codex',
+      prefix: 'cxp',
+      panel: () => _panel,
+      anchor: () => panelEl('#cxp-messages-container'),
+      onBlockedChange: (blocked) => {
+        try { syncInputEnabled(); } catch {}
+        const usableAgain = _cliWasBlocked && !blocked;
+        _cliWasBlocked = blocked;
+        if (usableAgain) reconnectAfterCli();
+      },
+    });
   }
+  return _cliBanner;
 }
 
-function removeCliBannerEl() {
-  if (!_panel) return;
-  const container = panelEl('#cxp-messages-container');
-  const banner = container?.parentNode?.querySelector(':scope > .cxp-cli-banner');
-  banner?.remove();
+// Codex was installed (or found again) after this tab's session could not start it: the tab connects again, so
+// Send works without reopening the panel. A tab that is running, or one an automation owns, is left alone.
+function reconnectAfterCli() {
+  const tab = activeTab();
+  if (!tab || tab.closed || tab.automationActive || tab.running) return;
+  if (tab.connected && tab.bootstrapped) return;
+  try {
+    if (tab.ws && tab.ws.readyState === WebSocket.OPEN) disconnectTab(tab);
+    connectTab(tab);
+  } catch (error) {
+    console.warn('[cdx-panel] reconnect after Codex became usable failed', error);
+  }
 }
 
 function refreshCliBanner() {
   if (!_panel) return;
-  const missing = _cliInstalled === null || _cliInstallFailureForced;
-  _panel.classList.toggle('cxp-cli-blocked', missing);
-  if (missing) ensureCliBannerEl();
-  else removeCliBannerEl();
+  cliBanner().refresh();
   try { syncInputEnabled(); } catch {}
 }
 
 export function isCdxCliInstalled() {
-  return _cliInstalled !== null && !_cliInstallFailureForced;
+  return !cliBanner().blocked();
 }
 
+// A session could not start Codex: "failed to start" with its words at once,
+// then the server is asked again and its answer decides what stays. (The
+// answer is read from the re-check itself: a spawn failure does not change
+// the version, so a change-only notification would never clear the banner.)
 export function flagCdxCliInstallFailure(reason = null) {
-  _cliInstallFailureForced = true;
-  _cliFailureReason = reason ? String(reason).slice(0, 300) : null;
-  refreshCliBanner();
-  // Clear the latch from the value recheckCliStatus RETURNS. Relying on the
-  // subscriber callback alone deadlocked: the callback only fired when the
-  // version string changed, and a spawn failure does not change the version,
-  // so the banner could never be dismissed — the Re-check button included.
-  recheckCliStatus('codex')
-    .then((info) => {
-      if (!info?.installed) return;
-      _cliInstallFailureForced = false;
-      _cliFailureReason = null;
-      refreshCliBanner();
-    })
-    .catch(() => {});
+  cliBanner().flagFailure(reason);
 }
 
 function ensureCliSubscription() {
-  if (_cliUnsub) return;
-  _cliUnsub = subscribeCliStatus('codex', (info) => {
-    _cliInstalled = info?.installed || null;
-    if (_cliInstalled) { _cliInstallFailureForced = false; _cliFailureReason = null; }
-    refreshCliBanner();
-  });
+  cliBanner();
 }
 
 // ═══════════════════════════════════════════
@@ -785,14 +731,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');
@@ -899,7 +849,6 @@ function wireEvents() {
     },
     onOpen: () => {
       sessionMenu?.classList.remove('open');
-      panelEl('#cxp-account-menu')?.classList.remove('open');
       panelEl('#cxp-effort-menu')?.classList.remove('open');
       refreshContextMenuDetails();
     },
@@ -909,8 +858,8 @@ function wireEvents() {
     // After this click has reached the document, whose handler closes the menu.
     onAccount: () => setTimeout(() => toggleAccountMenu(), 0),
   });
-  // The account menu hangs under the header, which a floating window is moved by.
-  panelEl('#cxp-account-menu')?.addEventListener('pointerdown', (event) => event.stopPropagation());
+  // The header account menu (account-menu.js, shared with the Claude panel): before the cog.
+  mountCodexAccountMenu(panelEl('.cxp-actions'), _panel);
   const slideBtn = panelEl('#cxp-slide');
   slideBtn?.addEventListener('click', () => setVisible(false));
   const changelogBtn = panelEl('#cxp-action-changelog');
@@ -1028,7 +977,6 @@ function wireEvents() {
   });
   document.addEventListener('click', (event) => {
     if (!event.target.closest('.cxp-header')) sessionMenu?.classList.remove('open');
-    if (!event.target.closest('#cxp-account-menu')) panelEl('#cxp-account-menu')?.classList.remove('open');
     if (!event.target.closest('.cxp-dropdown')) {
       _panel?.querySelectorAll('.cxp-dropdown.open').forEach((node) => node.classList.remove('open'));
     }
@@ -1274,6 +1222,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 +1252,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 +1275,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;
     }