synabun 2.1.0 → 2.2.1

package/neural-interface/public/shared/skills/studio/sx-library-view.js

@@ -18,11 +18,13 @@ import { html, raw, setHTML, ICONS, healthIcon, relativeTime, fullTime, rovingFo
 import { dropKept, dropDraft } from './sx-docs.js';
 import { encodeArtifactId } from '../ss-ids.js';
 import { revealHidden } from '../ss-unicode.js';
+import { issuesOf } from './sx-fixes.js';
+import { openFixPanel, fixAllSafe, fixNoticeHTML, unreadableFingerprint } from './sx-fixes-view.js';
 
 let _life = null;      // the listeners of the drawn header (filters): they end with the next drawing
 let _lastChecked = null;
 
-const RT_LETTER = { claude: 'C', codex: 'X', opencode: 'O' };
+const RT_LETTER = { claude: 'C', codex: 'X', opencode: 'O', antigravity: 'A' };
 const DIAG_REASONS = ['no-skill-md', 'unreadable-head', 'link', 'too-deep', 'unreadable', 'outside-project', 'not-a-folder'];
 
 /** Where a row comes from, in words: a label and a detail. */
@@ -65,11 +67,22 @@ export function healthWhy(h, t) {
   return '';
 }
 
-export function healthCapsule(row, t) {
+/**
+ * `fix`: the capsule opens the row's fix panel (sx-fixes-view.js) when it holds a problem: in the Library a
+ * `data-fix` button, in a workspace a `data-ws="fix-issues"` one. A capsule with nothing to fix stays a label.
+ */
+export function healthCapsule(row, t, { fix = null } = {}) {
   const worst = worstHealth(row);
   const rest = row.health.filter((h) => h !== worst && h.sev !== 'ok');
   const all = row.health.map((h) => { const why = healthWhy(h, t); return why ? `${healthWords(h, t)}: ${why}` : healthWords(h, t); }).join(' · ');
-  return html`<span class="sx-health sx-health--${worst.sev}" title="${all}">${healthIcon(worst.code)}<span>${healthWords(worst, t)}</span>${rest.length ? html`<span class="sx-health-more">+${rest.length}</span>` : ''}</span>`;
+  const inner = html`${healthIcon(worst.code)}<span>${healthWords(worst, t)}</span>${rest.length ? html`<span class="sx-health-more">+${rest.length}</span>` : ''}`;
+  if (fix && issuesOf(row, { open: true }).length) {
+    const label = t('skillsStudio.fix.open', { problems: all });
+    return fix === 'library'
+      ? html`<button type="button" class="sx-health sx-health--${worst.sev} sx-health--fix" data-fix="${row.key}" tabindex="-1" title="${label}" aria-label="${label}">${inner}</button>`
+      : html`<button type="button" class="sx-health sx-health--${worst.sev} sx-health--fix" data-ws="fix-issues" title="${label}" aria-label="${label}">${inner}</button>`;
+  }
+  return html`<span class="sx-health sx-health--${worst.sev}" title="${all}">${inner}</span>`;
 }
 
 /**
@@ -80,12 +93,12 @@ export function healthCapsule(row, t) {
 export function statusPill(status, ctx, { button = null, id = null } = {}) {
   const { t } = ctx;
   const where = status.where.map((w) => {
-    const runtime = t(`skillsStudio.runtime.${['claude', 'codex', 'opencode', 'agents'].includes(w.runtime) ? w.runtime : 'claude'}`);
+    const runtime = t(`skillsStudio.runtime.${['claude', 'codex', 'opencode', 'antigravity', 'agents'].includes(w.runtime) ? w.runtime : 'claude'}`);
     if (w.scope === 'project') return t('skillsStudio.publish.targetProject', { runtime, project: ctx.projects?.find((p) => p.path === w.projectPath)?.label || w.projectPath || '' });
     if (w.accountId && w.accountId !== 'default') return t('skillsStudio.publish.targetAccount', { runtime, account: w.accountId });
     return t('skillsStudio.publish.targetUser', { runtime });
   });
-  const runtimes = [...new Set(status.where.map((w) => t(`skillsStudio.runtime.${['claude', 'codex', 'opencode', 'agents'].includes(w.runtime) ? w.runtime : 'claude'}`)))].join(', ');
+  const runtimes = [...new Set(status.where.map((w) => t(`skillsStudio.runtime.${['claude', 'codex', 'opencode', 'antigravity', 'agents'].includes(w.runtime) ? w.runtime : 'claude'}`)))].join(', ');
   const text = status.code === 'installed' ? t('skillsStudio.status.installed', { where: runtimes }) : status.code === 'outdated' ? t('skillsStudio.status.outdated', { where: runtimes }) : t(`skillsStudio.status.${status.code}`);
   const title = where.length ? where.join(', ') : t(`skillsStudio.status.help.${status.code}`);
   // Not installed is no tick: the dashed circle (healthIcon has no 'off' and would fall through to the tick).
@@ -96,7 +109,21 @@ export function statusPill(status, ctx, { button = null, id = null } = {}) {
     : html`<span class="sx-status sx-status--${status.code}"${id ? html` id="${id}"` : ''} title="${title}">${inner}</span>`;
 }
 
-/** The runtime capsules of a row (C X O), each named in full. */
+/**
+ * The status and health pills of a row, once each, in the Library cell and the workspace head alike: a library skill
+ * shows its status, and its health only when something is wrong (an info item such as "draft" or "in review" is
+ * what the status already says); anything else shows its health.
+ */
+export function statusPills(row, ctx, { status = installStatus({ skill: row.skill, row }), button = null, id = null, fix = null } = {}) {
+  const how = ctx.guest ? null : fix;
+  if (!status) return healthCapsule(row, ctx.t, { fix: how });
+  const sev = worstHealth(row).sev;
+  // An installation older than the latest version is said too: the status reads "installed" for it.
+  const stale = row.health.some((h) => h.code === 'stale-install');
+  return html`${statusPill(status, ctx, { button, id })}${sev === 'err' || sev === 'warn' || stale ? healthCapsule(row, ctx.t, { fix: how }) : ''}`;
+}
+
+/** The runtime capsules of a row (C X O A), each named in full. */
 export function runtimeCapsules(row, t) {
   return html`<span class="sx-rts">${RUNTIMES.map((rt) => {
     const st = row.runtimes[rt]?.state || 'none';
@@ -169,11 +196,10 @@ function rowHTML(row, ctx, selected, first) {
 function healthCellHTML(row, ctx) {
   const { t } = ctx;
   const status = installStatus({ skill: row.skill, row });
-  if (!status) return healthCapsule(row, t);
-  const worst = worstHealth(row);
+  if (!status) return healthCapsule(row, t, { fix: ctx.guest ? null : 'library' });
   // Installed for one assistant and not the others in effect: one press from the row adds them.
   const also = ['installed', 'outdated'].includes(status.code) && !ctx.guest ? alsoInstall(ctx, { skill: row.skill, row }) : { targets: [], words: '' };
-  return html`<span class="sx-health-cell">${statusPill(status, ctx)}${worst.sev === 'err' || worst.sev === 'warn' ? healthCapsule(row, t) : ''}${status.code === 'approved' && !ctx.guest ? html`<button type="button" class="sx-btn sx-btn--sm sx-btn--primary" data-install="${row.key}" tabindex="-1" title="${t('skillsStudio.library.installHelp')}">${t('skillsStudio.library.install')}</button>` : ''}${also.targets.length ? html`<button type="button" class="sx-btn sx-btn--sm" data-also-install="${row.key}" tabindex="-1" title="${t('skillsStudio.library.alsoInstallHelp')}">${t('skillsStudio.library.alsoInstall', { targets: also.words })}</button>` : ''}</span>`;
+  return html`<span class="sx-health-cell">${statusPills(row, ctx, { status, fix: 'library' })}${status.code === 'approved' && !ctx.guest ? html`<button type="button" class="sx-btn sx-btn--sm sx-btn--primary" data-install="${row.key}" tabindex="-1" title="${t('skillsStudio.library.installHelp')}">${t('skillsStudio.library.install')}</button>` : ''}${also.targets.length ? html`<button type="button" class="sx-btn sx-btn--sm" data-also-install="${row.key}" tabindex="-1" title="${t('skillsStudio.library.alsoInstallHelp')}">${t('skillsStudio.library.alsoInstall', { targets: also.words })}</button>` : ''}</span>`;
 }
 
 /**
@@ -269,9 +295,11 @@ function summaryHTML(ctx, shown) {
   const parts = [t('skillsStudio.library.shown', { shown: shown.length, total })];
   if (counts?.views?.attention) parts.push(tp('skillsStudio.library.attentionCount', counts.views.attention));
   const diag = data?.catalog?.diagnostics || [];
+  // Folders the owner said to leave as they are are not said again until their number changes.
+  const diagSaid = diag.length && !ctx.dismissed?.().has(unreadableFingerprint(diag.length));
   // A server older than the page reads no change times: the dashes are said once, with what brings them.
   const restart = knowsUpdated(ctx) ? '' : html` · <span class="sx-note-warn" id="sx-lib-updated-restart">${t('skillsStudio.library.updatedRestart')}</span>`;
-  return html`<p class="sx-summary" role="status">${parts.join(' · ')}${diag.length ? html` · <button type="button" class="sx-link" data-lib="diagnostics">${tp('skillsStudio.library.diagnostics', diag.length)}</button>` : ''}${data?.catalog?.truncated ? html` · <span class="sx-warn-text">${t('skillsStudio.library.truncated')}</span>` : ''}${restart}</p>`;
+  return html`<p class="sx-summary" role="status">${parts.join(' · ')}${diagSaid ? html` · <button type="button" class="sx-link" data-lib="diagnostics">${tp('skillsStudio.library.diagnostics', diag.length)}</button>` : ''}${data?.catalog?.truncated ? html` · <span class="sx-warn-text">${t('skillsStudio.library.truncated')}</span>` : ''}${restart}</p>`;
 }
 
 /**
@@ -394,7 +422,7 @@ export function renderLibraryPlace(host, ctx) {
   const shown = visible(ctx);
   setHTML(host, html`<section class="sx-place sx-place--library" aria-labelledby="sx-lib-title">
     ${filterHeadHTML(ctx)}
-    <div class="sx-place-notices">${installNoticeHTML(ctx)}${migrationNoticeHTML(ctx)}${keptNoticeHTML(ctx)}${updateNoticeHTML(ctx)}</div>
+    <div class="sx-place-notices">${fixNoticeHTML(ctx, deleteKind)}${installNoticeHTML(ctx)}${migrationNoticeHTML(ctx)}${keptNoticeHTML(ctx)}${updateNoticeHTML(ctx)}</div>
     <div class="sx-place-scroll" id="sx-lib-scroll">
       <div id="sx-lib-summary">${summaryHTML(ctx, shown)}</div>
       <div id="sx-lib-table">${tableHTML(ctx, shown)}</div>
@@ -450,6 +478,8 @@ async function onClick(e, host, ctx) {
   if (also && host.contains(also) && !also.disabled) { onAlsoInstall(also, host, ctx); return; }
   const restore = e.target.closest?.('[data-restore]');
   if (restore && host.contains(restore) && !restore.disabled) { onRestore(restore, host, ctx); return; }
+  const fix = e.target.closest?.('[data-fix]');
+  if (fix && host.contains(fix)) { const row = ctx.rows.find((r) => r.key === fix.dataset.fix); ctx.lib.focus = fix.dataset.fix; if (row) openFixPanel(ctx, row, { deleteKind, bulkDelete }); return; }
   const open = e.target.closest?.('[data-open]');
   if (open && host.contains(open)) { ctx.lib.focus = open.dataset.open; ctx.openRow(open.dataset.open); return; }
   const btn = e.target.closest?.('[data-lib]');
@@ -458,6 +488,9 @@ async function onClick(e, host, ctx) {
   if (act === 'new') ctx.goPlace('create');
   else if (act === 'retry') ctx.reload();
   else if (act === 'install-notice-ok') { ctx.lib.installNotice = null; ctx.render(); }
+  else if (act === 'fix-notice-ok') { ctx.lib.fixNotice = null; ctx.render(); }
+  else if (act === 'fix-all') fixAllSafe(ctx, ctx.rows, deleteKind);
+  else if (act === 'fix-show') { Object.assign(ctx.lib, { view: 'all', health: 'attention' }); ctx.saveLibraryView(); ctx.render(); }
   else if (act === 'clear-filters') { Object.assign(ctx.lib, { view: 'all', kind: 'all', source: 'all', runtime: 'all', health: 'any', q: '' }); ctx.saveLibraryView(); ctx.render(); }
   else if (act === 'bulk-clear') { ctx.lib.selected.clear(); redrawRows(host, ctx); }
   else if (act === 'diagnostics') showDiagnostics(ctx);
@@ -515,7 +548,18 @@ async function showDiagnostics(ctx) {
     li.title = d.message || '';
     list.append(li);
   }
-  await ctx.ask({ title: t('skillsStudio.library.diagnosticsTitle'), lines: [t('skillsStudio.library.diagnosticsHelp')], extra: list, buttons: [{ id: 'ok', label: t('skillsStudio.dialog.close'), kind: 'primary' }], cancelId: 'ok', wide: true });
+  const buttons = ctx.guest ? [{ id: 'ok', label: t('skillsStudio.dialog.close'), kind: 'primary' }]
+    : [{ id: 'dismiss', label: t('skillsStudio.fix.action.dismiss') }, { id: 'ok', label: t('skillsStudio.dialog.close') }, { id: 'rescan', label: t('skillsStudio.fix.action.rescan'), kind: 'primary' }];
+  const answer = await ctx.ask({ title: t('skillsStudio.library.diagnosticsTitle'), lines: [t('skillsStudio.library.diagnosticsHelp'), t('skillsStudio.fix.explain.unreadable')], extra: list, buttons, cancelId: 'ok', wide: true });
+  if (answer === 'dismiss') { ctx.dismissIssues([unreadableFingerprint(diag.length)]); ctx.toast(t('skillsStudio.fix.dismissed')); return; }
+  if (answer !== 'rescan') return;
+  const gen = ctx.gen();
+  try {
+    await ctx.api.rescanSkillsCatalog();
+    if (!ctx.alive(gen)) return;
+    ctx.toast(t('skillsStudio.fix.rescanned'));
+  } catch (err) { if (ctx.alive(gen)) ctx.toast(t('skillsStudio.fix.failed', { error: studioErrorText(ctx.t, err) }), 'error'); }
+  if (ctx.alive(gen)) await ctx.reload();
 }
 
 async function reopenKept(ctx) {
@@ -581,7 +625,7 @@ function bulkExport(ctx) {
   ctx.toast(ctx.tp('skillsStudio.library.bulk.exported', n));
 }
 
-async function bulkDelete(ctx) {
+export async function bulkDelete(ctx) {
   const { t, tp, api } = ctx;
   const chosen = ctx.rows.filter((r) => ctx.lib.selected.has(r.key)).map((r) => ({ row: r, s: subjectOf(r, { caps: ctx.caps }) }))
     .map((x) => ({ ...x, kind: deleteKind(ctx, x.row, x.s) })).filter((x) => x.kind);
@@ -590,32 +634,25 @@ async function bulkDelete(ctx) {
   const inLibrary = chosen.filter((x) => x.kind === 'library');
   // Unsaved text in an open workspace of one of them goes with it only when the owner says so.
   const unsaved = chosen.filter((x) => ctx.workspaces.get(x.row.key)?.tabs.some((tab) => tab.dirty));
-  const box = document.createElement('div');
-  box.className = 'sx-dlg-form';
-  const label = document.createElement('label');
-  label.className = 'sx-field-label';
-  label.htmlFor = 'sx-del-confirm';
-  label.textContent = t('skillsStudio.library.bulk.deleteType', { word: t('skillsStudio.library.bulk.deleteWord') });
-  const input = document.createElement('input');
-  input.id = 'sx-del-confirm';
-  input.className = 'sx-input';
-  input.autocomplete = 'off';
-  const err = document.createElement('p');
-  err.className = 'ss-dlg-error';
-  err.setAttribute('role', 'alert');
-  box.append(label, input, err);
+  const word = t('skillsStudio.library.bulk.deleteWord');
+  const { box, input, err } = deleteConfirmBox(ctx, chosen, { onDisk, inLibrary, unsaved, word });
   const answer = await ctx.ask({
     title: tp('skillsStudio.library.bulk.deleteTitle', chosen.length),
-    // Two kinds, said apart: what is removed from where it is, and what only leaves the library.
-    lines: [
-      ...(onDisk.length ? [t('skillsStudio.library.bulk.deleteExplain'), ...onDisk.slice(0, 8).map((x) => `• ${x.row.label} (${x.row.path || ''})`)] : []),
-      ...(inLibrary.length ? [t('skillsStudio.library.bulk.deleteLibraryExplain'), ...inLibrary.slice(0, 8).map((x) => `• ${x.row.label}`)] : []),
-      ...(unsaved.length ? [tp('skillsStudio.library.bulk.deleteUnsaved', unsaved.length)] : []),
-    ],
     extra: box,
-    buttons: [{ id: 'cancel', label: t('skillsStudio.dialog.cancel') }, { id: 'delete', label: t('skillsStudio.library.bulk.deleteConfirm'), kind: 'danger' }],
+    className: 'ss-dlg--confirm',
+    buttons: [{ id: 'cancel', label: t('skillsStudio.dialog.cancel') }, { id: 'delete', label: t('skillsStudio.library.bulk.deleteConfirm'), kind: 'danger', disabled: true }],
     focus: 'cancel',
-    accept: (id) => { if (id === 'delete' && input.value.trim().toLowerCase() !== t('skillsStudio.library.bulk.deleteWord').toLowerCase()) { err.textContent = t('skillsStudio.library.bulk.deleteTypeError'); return false; } return true; },
+    // Delete stays off until the word is typed; Enter in the field answers once it is.
+    onOpen: (ui) => {
+      input.addEventListener('input', () => { ui.setDisabled('delete', !deleteWordMatches(input.value, word)); if (deleteWordMatches(input.value, word)) err.textContent = ''; });
+      input.addEventListener('keydown', (e) => {
+        if (e.key !== 'Enter' || e.isComposing) return;
+        e.preventDefault();
+        if (deleteWordMatches(input.value, word)) ui.done('delete'); else err.textContent = t('skillsStudio.library.bulk.deleteTypeError');
+      });
+      input.focus({ preventScroll: true });
+    },
+    accept: (id) => { if (id === 'delete' && !deleteWordMatches(input.value, word)) { err.textContent = t('skillsStudio.library.bulk.deleteTypeError'); return false; } return true; },
   });
   if (answer !== 'delete') return;
   const gen = ctx.gen();
@@ -635,5 +672,77 @@ async function bulkDelete(ctx) {
   await ctx.reload();
 }
 
+/** Whether what was typed is the confirmation word (case and surrounding spaces aside). */
+export function deleteWordMatches(value, word) {
+  return String(value ?? '').trim().toLocaleLowerCase() === String(word ?? '').trim().toLocaleLowerCase() && !!String(word ?? '').trim();
+}
+
+/**
+ * The body of the delete question: one tidy row per item (its name, its kind, where it is, shortened, with the full
+ * path on hover, and what happens to it), what that means, and the field the word is typed in.
+ */
+export function deleteConfirmBox(ctx, chosen, { onDisk = [], inLibrary = [], unsaved = [], word }) {
+  const { t, tp } = ctx;
+  const el = (tag, cls, text) => { const n = document.createElement(tag); if (cls) n.className = cls; if (text !== undefined) n.textContent = text; return n; };
+  const box = el('div', 'sx-del');
+  const list = el('ul', 'sx-del-list');
+  list.setAttribute('aria-label', t('skillsStudio.library.bulk.deleteListLabel'));
+  const SHOWN = 6;
+  for (const x of chosen.slice(0, SHOWN)) {
+    const li = el('li', 'sx-del-item');
+    const icon = el('span', 'sx-del-icon');
+    icon.setAttribute('aria-hidden', 'true');
+    setHTML(icon, x.row.kind === 'skill' ? ICONS.folder : ICONS.file);
+    const main = el('span', 'sx-del-main');
+    main.append(el('span', 'sx-del-name', x.row.label));
+    const where = x.kind === 'disk' ? shortPath(x.row.path || '') : t('skillsStudio.library.bulk.deleteInLibrary');
+    const path = el('span', 'sx-del-path', where);
+    if (x.kind === 'disk' && x.row.path) path.title = x.row.path;
+    main.append(path);
+    const kind = el('span', 'sx-del-kind', kindLabel(x.row, t));
+    const effect = el('span', `sx-del-effect sx-del-effect--${x.kind}`, x.kind === 'disk' ? t('skillsStudio.library.bulk.deleteEffectDisk') : t('skillsStudio.library.bulk.deleteEffectLibrary'));
+    li.append(icon, main, kind, effect);
+    list.append(li);
+  }
+  if (chosen.length > SHOWN) list.append(el('li', 'sx-del-more', t('skillsStudio.library.bulk.deleteMore', { count: chosen.length - SHOWN })));
+  box.append(list);
+  // Two kinds, said apart: what is removed from where it is (for good), and what only leaves the library.
+  if (onDisk.length) {
+    const note = el('p', 'sx-del-note sx-del-note--danger');
+    setHTML(note, html`${ICONS.warn}<span>${t('skillsStudio.library.bulk.deleteExplain')}</span>`);
+    box.append(note);
+  }
+  if (inLibrary.length) {
+    const note = el('p', 'sx-del-note');
+    setHTML(note, html`${ICONS.info}<span>${t('skillsStudio.library.bulk.deleteLibraryExplain')}</span>`);
+    box.append(note);
+  }
+  if (unsaved.length) {
+    const note = el('p', 'sx-del-note sx-del-note--danger');
+    setHTML(note, html`${ICONS.draft}<span>${tp('skillsStudio.library.bulk.deleteUnsaved', unsaved.length)}</span>`);
+    box.append(note);
+  }
+  const field = el('div', 'sx-del-field');
+  const label = el('label', 'sx-del-label');
+  label.htmlFor = 'sx-del-confirm';
+  // "Type {word} to confirm", with the word set apart as what is to be typed.
+  const sentence = t('skillsStudio.library.bulk.deleteType', { word: '\u0000' });
+  const [before, after = ''] = sentence.split('\u0000');
+  label.append(before, el('code', 'sx-del-word', word), after);
+  const input = el('input', 'sx-del-input');
+  input.id = 'sx-del-confirm';
+  input.type = 'text';
+  input.autocomplete = 'off';
+  input.spellcheck = false;
+  input.setAttribute('autocapitalize', 'off');
+  input.setAttribute('aria-describedby', 'sx-del-error');
+  const err = el('p', 'ss-dlg-error');
+  err.id = 'sx-del-error';
+  err.setAttribute('role', 'alert');
+  field.append(label, input, err);
+  box.append(field);
+  return { box, input, err };
+}
+
 /** The P0 id of a row's entry (exported for the workspace's Export of an agent or a command). */
 export const v1ExportId = (entry) => (entry?.path ? encodeArtifactId(`${entry.kind}:${entry.path}`) : null);

package/neural-interface/public/shared/skills/studio/sx-library.js

@@ -18,7 +18,7 @@
 // Health is a list of codes with a severity (err, warn, info, off, ok), never a colour alone: the view writes the
 // words (i18n `skillsStudio.health.*`). No DOM and no imports.
 
-export const RUNTIMES = Object.freeze(['claude', 'codex', 'opencode']);
+export const RUNTIMES = Object.freeze(['claude', 'codex', 'opencode', 'antigravity']);
 export const SORTS = Object.freeze(['attention', 'name', 'updated', 'kind', 'source']);
 export const KINDS = Object.freeze(['skill', 'agent', 'command']);
 export const SOURCES = Object.freeze(['mine', 'project', 'synabun', 'plugin', 'account', 'system', 'shared', 'library']);
@@ -322,6 +322,10 @@ function finishRow(row) {
   row.label = revealHidden(row.name || row.folderName || '');
   row.shownDescription = revealHidden(row.description || '');
   row.runtimes = runtimeStates(row);
+  // A runtime that lists two copies of this very row (SynaBun installed one library skill into ~/.claude/skills and
+  // ~/.config/opencode/skills, both read by OpenCode) has no other skill to confuse it with: no "duplicate".
+  const own = new Set(row.entries.map((e) => e.id));
+  row.collisions = row.collisions.filter((c) => !(Array.isArray(c.with) && c.with.length && c.with.every((id) => own.has(id))));
   row.health = healthOf(row);
   row.attention = row.health.reduce((n, h) => n + (ATTENTION[h.code] || 0) * (h.code === 'invalid' || h.code === 'warnings' ? Math.max(1, Math.min(9, num(h.count))) : 1), 0);
   row.needsAttention = row.attention > 0;
@@ -338,7 +342,7 @@ export function healthMatches(row, health) {
     case 'invalid': return codes.has('invalid') || codes.has('not-text');
     case 'warnings': return codes.has('warnings');
     case 'update': return codes.has('update');
-    case 'duplicates': return codes.has('shadowed') || codes.has('twice') || codes.has('same-description');
+    case 'duplicates': return codes.has('shadowed') || codes.has('twice') || codes.has('same-description') || codes.has('duplicate-record');
     case 'drafts': return codes.has('draft');
     case 'readonly': return codes.has('readonly');
     case 'ok': return codes.has('ok');

package/neural-interface/public/shared/skills/studio/sx-main.js

@@ -25,6 +25,7 @@ import { askInPanel, dialogOpen, closeDialog } from '../ss-dialog.js';
 import { closeDropdowns } from '../../cc-dropdown.js';
 import * as api from '../../api.js';
 import { readWholeCatalog, buildRows, countRows, projectsOf, keepSelection } from './sx-library.js';
+import { applyFixState, readDismissed, addDismissed, removeDismissed, DISMISSED_KEY } from './sx-fixes.js';
 import { initialRect, parseOpen } from './sx-geometry.js';
 import { frameRect } from '../../app-frame.js';
 import { updateCards, reviewCount } from './sx-review.js';
@@ -134,6 +135,9 @@ function deriveRows() {
   // Review cards and the rail's count all leave a kept update out.
   const kept = readJson(KEPT_UPDATES_KEY, {});
   S.rows = buildRows({ entries: d.catalog.items, skills: d.skills, status: d.status, reviews: d.reviews.filter((r) => ['pending', 'changes_requested', 'approved', 'partial', 'publish_failed'].includes(r.state)), upstream: d.upstream, kept });
+  // The problems only the fix system finds (a second library record, an older installation), and the ones the owner
+  // dismissed taken out (sx-fixes.js), before anything counts them.
+  applyFixState(S.rows, readDismissed(storage.getItem(DISMISSED_KEY)));
   S.counts = countRows(S.rows);
   S.counts.views.archived = Array.isArray(d.archived) ? d.archived.length : 0;
   S.projects = projectsOf(d.catalog.roots, S.rows);
@@ -174,7 +178,7 @@ export async function openStudio(detail = {}) {
   S.opener = document.activeElement instanceof HTMLElement ? document.activeElement : null;
   S.docked = storage.getItem(DOCK_KEY) === 'true';
   S.dim = storage.getItem(DIM_KEY) === 'true' && !S.docked;
-  S.lib = { ...S.lib, ...readJson(LIB_KEY, {}), selected: new Set(), focus: null, installNotice: null };
+  S.lib = { ...S.lib, ...readJson(LIB_KEY, {}), selected: new Set(), focus: null, installNotice: null, fixNotice: null };
   S.backdrop = document.createElement('div');
   S.backdrop.className = `studio-backdrop sx-backdrop${S.dim ? '' : ' backdrop-hidden'}`;
   document.body.appendChild(S.backdrop);
@@ -538,7 +542,7 @@ function runtimeFootHTML() {
     if (own.some((r) => r.status === 'ok')) return 'ready';
     return own.length ? 'empty' : 'unknown';
   };
-  const rows = ['claude', 'codex', 'opencode'].map((rt) => {
+  const rows = ['claude', 'codex', 'opencode', 'antigravity'].map((rt) => {
     const st = state(rt);
     const name = t(`skillsStudio.runtime.${rt}`);
     const label = st === 'bridge' ? t('skillsStudio.rail.runtimeFix', { runtime: name }) : `${name}: ${t(`skillsStudio.rail.runtimeState.${st}`)}`;
@@ -673,6 +677,11 @@ function ctx() {
     keepUpdate: (name, revisionId) => { const kept = readJson(KEPT_UPDATES_KEY, {}); kept[name] = revisionId; storage.setItem(KEPT_UPDATES_KEY, JSON.stringify(kept)); deriveRows(); },
     saveLibraryView: () => storage.setItem(LIB_KEY, JSON.stringify({ view: S.lib.view, kind: S.lib.kind, source: S.lib.source, runtime: S.lib.runtime, health: S.lib.health, sort: S.lib.sort })),
     keptDrafts: () => keptDrafts(),
+    // Problems the owner has seen and leaves as they are (sx-fixes.js fingerprints): kept, and said again when they change.
+    dismissed: () => readDismissed(storage.getItem(DISMISSED_KEY)),
+    dismissIssues: (fingerprints) => { storage.setItem(DISMISSED_KEY, addDismissed(storage.getItem(DISMISSED_KEY), fingerprints)); deriveRows(); render({ keepFocus: true }); },
+    restoreIssues: (fingerprints) => { storage.setItem(DISMISSED_KEY, removeDismissed(storage.getItem(DISMISSED_KEY), fingerprints)); deriveRows(); render({ keepFocus: true }); },
+    openSkillFolders,
     workspaces: S.workspaces,
     closeWorkspace: (ws) => { disposeWorkspace(ws); S.workspaces.delete(ws.key); if (S.ws === ws) { S.ws = null; S.place = 'library'; render(); } },
     key: idempotencyKey,

package/neural-interface/public/shared/skills/studio/sx-review-view.js

@@ -51,7 +51,7 @@ function destinationHTML(ctx, card, dest) {
   // One tile per runtime, as Publish shows them: where this card's install goes (Codex and OpenCode are first-class).
   if (dest.targets.length) {
     const picked = (rt) => [...dest.keys].some((k) => String(k).startsWith(`${rt}:`));
-    lines.push(html`<li class="sx-dest-tiles" role="group" aria-label="${t('skillsStudio.review.destTilesLabel')}">${['claude', 'codex', 'opencode'].map((rt) => html`<span class="sx-dest-tile${picked(rt) ? ' is-on' : ''}" title="${picked(rt) ? t('skillsStudio.review.destTileOn', { runtime: t(`skillsStudio.runtime.${rt}`) }) : t('skillsStudio.review.destTileOff', { runtime: t(`skillsStudio.runtime.${rt}`) })}">${picked(rt) ? ICONS.ok : ''}<span>${t(`skillsStudio.runtime.${rt}`)}</span></span>`)}</li>`);
+    lines.push(html`<li class="sx-dest-tiles" role="group" aria-label="${t('skillsStudio.review.destTilesLabel')}">${['claude', 'codex', 'opencode', 'antigravity'].map((rt) => html`<span class="sx-dest-tile${picked(rt) ? ' is-on' : ''}" title="${picked(rt) ? t('skillsStudio.review.destTileOn', { runtime: t(`skillsStudio.runtime.${rt}`) }) : t('skillsStudio.review.destTileOff', { runtime: t(`skillsStudio.runtime.${rt}`) })}">${picked(rt) ? ICONS.ok : ''}<span>${t(`skillsStudio.runtime.${rt}`)}</span></span>`)}</li>`);
   }
   return html`${lines}`;
 }

package/neural-interface/public/shared/skills/studio/sx-subject.js

@@ -142,7 +142,7 @@ export function sameAsk(a, b) {
   return x.length > 0 && x.length === y.length && x.every((k, i) => k === y[i]);
 }
 
-const RUNTIME_OF_FAMILY = { claude: 'claude', codex: 'codex', opencode: 'opencode', shared: 'agents' };
+const RUNTIME_OF_FAMILY = { claude: 'claude', codex: 'codex', opencode: 'opencode', antigravity: 'antigravity', shared: 'agents' };
 
 /**
  * The targets a skill can be installed into: each runtime's own skills folder for each account, the shared
@@ -175,12 +175,13 @@ export function installTargets({ roots = [], config = {}, projects = [] } = {})
     for (const runtime of ['claude', 'codex', 'opencode']) {
       const target = { runtime, scope: 'project', projectPath: p.path };
       const sub = runtime === 'claude' ? '.claude/skills' : runtime === 'codex' ? '.agents/skills' : '.opencode/skills';
-      // Who reads a project's folders (lib/skills/roots.js): .claude/skills and .agents/skills are read by OpenCode too.
-      const readers = runtime === 'opencode' ? ['opencode'] : [runtime, 'opencode'];
+      // Who reads a project's folders (lib/skills/roots.js): .claude/skills and .agents/skills are read by OpenCode too,
+      // .agents/skills by Antigravity as well (it has no project folder of its own).
+      const readers = runtime === 'opencode' ? ['opencode'] : runtime === 'codex' ? ['codex', 'opencode', 'antigravity'] : [runtime, 'opencode'];
       push({ key: targetKey(target), target, runtime, scope: 'project', accountId: 'default', projectPath: p.path, projectLabel: p.label || p.path, path: `${p.path.replace(/[\\/]+$/, '')}/${sub}`, status: null, policy: null, shared: false, off: false, runtimes: readers });
     }
   }
-  const order = { claude: 0, codex: 1, opencode: 2, agents: 3 };
+  const order = { claude: 0, codex: 1, opencode: 2, antigravity: 3, agents: 4 };
   return out.sort((a, b) => (a.scope === b.scope ? 0 : a.scope === 'user' ? -1 : 1) || (a.projectLabel || '').localeCompare(b.projectLabel || '') || (order[a.runtime] - order[b.runtime]) || a.accountId.localeCompare(b.accountId));
 }
 
@@ -221,11 +222,11 @@ export function defaultTargets(targets, { skill = null, row = null, assistants =
   const there = targets.filter((t) => !t.off && ['installed', 'outdated', 'present'].includes(targetState(t, { skill, row }).state));
   if (there.length) return new Set(there.map((t) => t.key));
   const own = (runtime) => targets.find((t) => t.runtime === runtime && t.scope === 'user' && t.accountId === 'default' && !t.off) || null;
-  const wanted = Array.isArray(assistants) && assistants.length ? assistants.filter((r) => ['claude', 'codex', 'opencode'].includes(r)) : ['claude'];
+  const wanted = Array.isArray(assistants) && assistants.length ? assistants.filter((r) => ['claude', 'codex', 'opencode', 'antigravity'].includes(r)) : ['claude'];
   // Every assistant gets its own folder: a terminal OpenCode reads Claude Code's folder, but SynaBun's own OpenCode
   // serves (the panel, an Assistant brain) start with OPENCODE_DISABLE_CLAUDE_CODE=1 and never see it (checked with
   // opencode 2.1.4), so an OpenCode among the assistants is ticked for a real copy.
-  const picked = ['claude', 'codex', 'opencode'].filter((runtime) => wanted.includes(runtime)).map(own).filter(Boolean);
+  const picked = ['claude', 'codex', 'opencode', 'antigravity'].filter((runtime) => wanted.includes(runtime)).map(own).filter(Boolean);
   if (!picked.length) { const claude = own('claude'); return new Set(claude ? [claude.key] : []); }
   return new Set(picked.map((t) => t.key));
 }

package/neural-interface/public/shared/skills/studio/sx-workspace-view.js

@@ -13,7 +13,8 @@
 import { studioErrorText } from './sx-errors.js';
 import { html, setHTML, ICONS } from './sx-dom.js';
 import { loadWorkspace, dirtyTabs, saveVersion } from './sx-docs.js';
-import { healthCapsule, sourceLabel, statusPill } from './sx-library-view.js';
+import { sourceLabel, statusPills, deleteKind, bulkDelete } from './sx-library-view.js';
+import { openFixPanel } from './sx-fixes-view.js';
 import { installStatus } from './sx-install.js';
 import { reviewTargets, installFlow, flowWords, installBusy, acquireInstall, alsoInstall, alsoInstallNow } from './sx-install-flow.js';
 import { changedFiles } from './sx-diff.js';
@@ -117,7 +118,7 @@ function bannersHTML(ctx, ws) {
     const also = ['installed', 'outdated'].includes(status?.code) ? alsoInstall(ctx, { skill: ws.skill || row.skill, row }) : { targets: [] };
     if (also.targets.length) {
       const busy = installBusy((ws.skill || row.skill)?.skillId);
-      const where = [...new Set(status.where.map((w) => t(`skillsStudio.runtime.${['claude', 'codex', 'opencode', 'agents'].includes(w.runtime) ? w.runtime : 'claude'}`)))].join(' · ');
+      const where = [...new Set(status.where.map((w) => t(`skillsStudio.runtime.${['claude', 'codex', 'opencode', 'antigravity', 'agents'].includes(w.runtime) ? w.runtime : 'claude'}`)))].join(' · ');
       out.push(banner('info', ICONS.publish, t('skillsStudio.ws.banner.alsoInstall', { where, targets: also.words }),
         html`<button type="button" class="sx-btn sx-btn--primary" data-ws="also-install" id="sx-ws-also-install"${busy ? ' disabled' : ''} aria-disabled="${busy ? 'true' : 'false'}">${ICONS.publish}<span>${busy ? t('skillsStudio.review.installing') : t('skillsStudio.ws.alsoInstallFor', { targets: also.words })}</span></button>`));
     }
@@ -163,7 +164,6 @@ function headHTML(ctx, ws) {
   // A library skill shows one status (it opens Publish) and its health only when something is wrong; the rest shows
   // where it comes from and its health.
   const status = installStatus({ skill: ws.skill || row.skill, row });
-  const worst = row.health[0] || { sev: 'ok' };
   return html`<div class="sx-ws-head">
     <nav class="sx-crumb" aria-label="${t('skillsStudio.ws.breadcrumb')}">
       <button type="button" class="sx-link" data-ws="back">${ICONS.back}<span>${t('skillsStudio.rail.library')}</span></button>
@@ -172,8 +172,8 @@ function headHTML(ctx, ws) {
     <div class="sx-ws-title">
       <h3 class="sx-ws-name" id="sx-ws-name" tabindex="-1">${ws.label}</h3>
       <span class="sx-tag">${kind}</span>
-      ${status ? statusPill(status, ctx, { button: s.canPublish ? 'go-publish' : null, id: 'sx-ws-status' }) : html`<span class="sx-tag" title="${src.detail}">${src.label}${src.detail ? html` · ${src.detail}` : ''}</span>`}
-      ${!status || worst.sev === 'err' || worst.sev === 'warn' ? healthCapsule(row, t) : ''}
+      ${status ? '' : html`<span class="sx-tag" title="${src.detail}">${src.label}${src.detail ? html` · ${src.detail}` : ''}</span>`}
+      ${statusPills(row, ctx, { status, button: s.canPublish ? 'go-publish' : null, id: 'sx-ws-status', fix: 'workspace' })}
       <span class="sx-spacer"></span>
       ${s.editable ? html`<button type="button" class="sx-btn" data-ws="save" id="sx-save"${dirty ? '' : ' disabled'} aria-keyshortcuts="${ctx.mac ? 'Meta+S' : 'Control+S'}">${t('skillsStudio.ws.save')} <kbd>${ctx.mac ? '⌘S' : 'Ctrl+S'}</kbd></button>` : ''}
       <button type="button" class="sx-icon-btn" data-ws="more" aria-haspopup="menu" aria-expanded="false" aria-label="${t('skillsStudio.ws.more')}" title="${t('skillsStudio.ws.more')}">${ICONS.more}</button>
@@ -292,6 +292,7 @@ async function onAction(act, btn, ctx, ws) {
     case 'retry': ws.error = null; ws.loaded = false; ctx.render(); return;
     case 'save': saveActive(ctx, ws); return;
     case 'go-publish': switchTab(ctx, ws, 'publish'); return;
+    case 'fix-issues': if (ws.row) openFixPanel(ctx, ws.row, { deleteKind, bulkDelete }); return;
     case 'more': openMore(btn, ctx, ws); return;
     case 'customize': customizeCopy(ctx, ws); return;
     case 'adopt': adoptNow(ctx, ws); return;

package/neural-interface/public/shared/state.js

@@ -46,7 +46,7 @@ export const state = {
   linkedSessionIds: new Set(),  // session IDs currently in an active link
 
   // ── Side panel routing ──
-  lastActivePanel: 'claude',   // 'claude' | 'codex' | 'opencode' | 'assistant' — used by whiteboard "Send to Panel"
+  lastActivePanel: 'claude',   // 'claude' | 'codex' | 'opencode' | 'antigravity' | 'assistant' — used by whiteboard "Send to Panel"
 };
 
 

package/neural-interface/public/shared/storage-retry.js

@@ -0,0 +1,47 @@
+// SynaBun — when storage.js tries a refused flush again. DOM-free (unit-tested under node --test).
+//
+// A failure that may pass by itself (network, 5xx, 408, 429) waits base·2^(attempt-1), capped, with full jitter in
+// the upper half. A 401 / 403 is the server saying this client is not allowed: nothing is retried on a timer until
+// something changes (a new write, the window regaining focus, the network coming back). Unsent values stay queued.
+
+export const RETRY_BASE_MS = 1000;
+export const RETRY_CAP_MS = 60_000;
+
+/** Whether an HTTP status (or null for a network error) is a refusal that a timer will not fix. */
+export function isAuthRefusal(status) {
+  return status === 401 || status === 403;
+}
+
+/** The wait before retry number `attempt` (1-based): between half and all of min(cap, base·2^(attempt-1)). */
+export function retryDelay(attempt, { base = RETRY_BASE_MS, cap = RETRY_CAP_MS, random = Math.random } = {}) {
+  const n = Math.max(1, Math.floor(Number(attempt) || 1));
+  const ceiling = Math.min(cap, base * 2 ** Math.min(n - 1, 30));
+  const r = Math.min(1, Math.max(0, Number(random()) || 0));
+  return Math.round(ceiling / 2 + r * (ceiling / 2));
+}
+
+/**
+ * The retry state of one flusher. `fail(status)` → { blocked, delay } (delay null when blocked);
+ * `ok()` resets; `poke()` (a write or a reconnect) lifts a block and gives the wait the next try still owes.
+ */
+export function createRetryState({ base = RETRY_BASE_MS, cap = RETRY_CAP_MS, random = Math.random, now = () => Date.now() } = {}) {
+  let attempt = 0;
+  let blocked = false;
+  let notBefore = 0;
+  return {
+    get attempt() { return attempt; },
+    get blocked() { return blocked; },
+    fail(status) {
+      attempt++;
+      const delay = retryDelay(attempt, { base, cap, random });
+      notBefore = now() + delay;
+      blocked = isAuthRefusal(status);
+      return { blocked, delay: blocked ? null : delay };
+    },
+    ok() { attempt = 0; blocked = false; notBefore = 0; },
+    /** How long a flush asked for now must still wait (0 when none is owed). Lifts an auth block. */
+    poke() { blocked = false; return Math.max(0, notBefore - now()); },
+    /** How long a flush must still wait, without lifting a block (Infinity while blocked). */
+    wait() { return blocked ? Infinity : Math.max(0, notBefore - now()); },
+  };
+}

package/neural-interface/public/shared/storage.js

@@ -1,4 +1,5 @@
 import { hostedSidepanelId, sidepanelHost } from './ui-sidepanel-runtime.js';
+import { createRetryState } from './storage-retry.js';
 // ═══════════════════════════════════════════
 // STORAGE — Server-synced persistent state
 // ═══════════════════════════════════════════
@@ -19,6 +20,8 @@ let _dirty = {};
 let _flushTimer = null;
 let _hydrated = false;
 const DEBOUNCE_MS = 500;
+// A refused flush is tried again with backoff (storage-retry.js); a 401 / 403 waits for a write or a reconnect.
+const _retry = createRetryState();
 // Keys that migrated to the per-entry blob store (see blob-store.js and the
 // server's FAT_KEY_ROUTES). Excluded from hydration so they can never re-enter
 // the whole-map PATCH cycle.
@@ -129,10 +132,20 @@ export const storage = (hostedSidepanelId && sidepanelHost()?.storageFor(hostedS
 
 // ── Debounced flush to server ────────────────────────
 
-function _scheduleDebouncedFlush() {
+/** `fromWrite`: a new write or a reconnect, which lifts a 401 / 403 block (the backoff still applies). */
+function _scheduleDebouncedFlush(fromWrite = true) {
   if (SHOWCASE_MODE) { _dirty = {}; return; }
+  const owed = fromWrite ? _retry.poke() : _retry.wait();
+  if (!Number.isFinite(owed)) return; // blocked: values stay in _dirty until something changes
   if (_flushTimer) clearTimeout(_flushTimer);
-  _flushTimer = setTimeout(_flushToServer, DEBOUNCE_MS);
+  _flushTimer = setTimeout(_flushToServer, Math.max(DEBOUNCE_MS, owed));
+}
+
+if (!SHOWCASE_MODE) {
+  const _reconnected = () => { if (Object.keys(_dirty).length) _scheduleDebouncedFlush(true); };
+  window.addEventListener('online', _reconnected);
+  window.addEventListener('focus', _reconnected);
+  window.addEventListener('synabun:auth-changed', _reconnected);
 }
 
 async function _flushToServer() {
@@ -150,20 +163,28 @@ async function _flushToServer() {
   _dirty = {};
   _flushTimer = null;
   if (Object.keys(payload).length === 0) return;
+  let status = null;
   try {
     const res = await fetch('/api/ui-state', {
       method: 'PATCH',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(payload),
     });
+    status = res.status;
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    _retry.ok();
   } catch (err) {
-    console.warn('[storage] Flush failed:', err.message, '— will retry');
     // Re-queue failed keys (don't overwrite newer dirty values)
     for (const [k, v] of Object.entries(payload)) {
       if (!(k in _dirty)) _dirty[k] = v;
     }
-    _scheduleDebouncedFlush();
+    const { blocked, delay } = _retry.fail(status);
+    if (blocked) {
+      if (_retry.attempt === 1 || _retry.attempt % 20 === 0) console.warn('[storage] Flush refused:', err.message, '— kept; will try again on the next change or reconnect');
+    } else {
+      if (_retry.attempt <= 3 || _retry.attempt % 20 === 0) console.warn('[storage] Flush failed:', err.message, `— will retry in ${Math.round(delay / 1000)} s`);
+      _scheduleDebouncedFlush(false);
+    }
   }
 }