synabun 2.1.0 → 2.2.0

package/neural-interface/public/shared/skills/ss-profiles.js

@@ -11,14 +11,15 @@
 //
 // Invocation is kept as intent, apart from any one runtime's spelling of it: who may start the skill (the user
 // by name, the model on its own), read from every dialect a folder carries (Claude Code fields, Codex's
-// agents/openai.yaml, OpenCode's metadata) and compared with what a target would read from the exported bytes,
-// so an install never lets a model start a skill its author kept explicit-only (invocationPlan).
+// agents/openai.yaml, OpenCode's metadata, Antigravity's disable-slash-command) and compared with what a target
+// would read from the exported bytes, so an install never lets a model start a skill its author kept
+// explicit-only (invocationPlan).
 //
 // No DOM, no I/O: the page and the server load it; YAML is parsed by the caller.
 
 import { findHiddenChars } from './ss-unicode.js';
 
-export const PROFILE_SET_VERSION = '2026-10-22';
+export const PROFILE_SET_VERSION = '2026-10-30';
 
 const RETRIEVED = '2026-10-21';
 const SOURCES = Object.freeze({
@@ -29,6 +30,7 @@ const SOURCES = Object.freeze({
   codexPrompts: { title: 'Codex custom prompts (deprecated)', url: 'https://learn.chatgpt.com/docs/custom-prompts', retrieved: RETRIEVED },
   opencode: { title: 'OpenCode skills', url: 'https://opencode.ai/docs/skills/', retrieved: RETRIEVED },
   opencodeCommands: { title: 'OpenCode commands', url: 'https://opencode.ai/docs/commands/', retrieved: RETRIEVED },
+  antigravity: { title: 'Antigravity CLI reference', url: 'https://antigravity.google/docs/cli/reference', retrieved: '2026-10-30' },
 });
 
 export const PORTABLE_FIELDS = Object.freeze(['name', 'description', 'license', 'compatibility', 'metadata', 'allowed-tools']);
@@ -39,6 +41,9 @@ export const CLAUDE_FIELDS = Object.freeze([
 ]);
 const OPENCODE_FIELDS = Object.freeze(['name', 'description', 'license', 'compatibility', 'metadata', 'disable-model-invocation']);
 const CODEX_FIELDS = Object.freeze(['name', 'description', 'metadata']);
+const ANTIGRAVITY_FIELDS = Object.freeze(['name', 'description', 'disable-slash-command']);
+/** The most of a SKILL.md body Antigravity reads (UTF-8 bytes after the frontmatter). */
+export const ANTIGRAVITY_BODY_BYTES = 24 * 1024;
 
 export const PORTABLE_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 export const CODEX_SIDECAR = 'agents/openai.yaml';
@@ -121,6 +126,19 @@ export const PROFILES = Object.freeze({
     ],
     reload: { file: 'new-session', newRoot: 'new-session', note: 'A running OpenCode may not see a new skill; start a new session (or restart the server) to be sure.' },
   }),
+  'antigravity-native': Object.freeze({
+    id: 'antigravity-native', version: '2026-10-30', title: 'Antigravity', runtime: 'antigravity', status: 'current',
+    sources: [SOURCES.antigravity], verified: null,
+    fields: { recognized: ANTIGRAVITY_FIELDS, required: ['name', 'description'], strictTopLevel: false },
+    limits: { nameChars: 64, descriptionChars: 1024, bodyBytes: ANTIGRAVITY_BODY_BYTES },
+    invocation: { model: 'chosen by its description; no field keeps the model from starting it', user: '/name; `disable-slash-command: true` hides it' },
+    substitutions: null,
+    roots: [
+      { scope: 'user', path: '~/.gemini/config/skills', note: 'where SynaBun installs' },
+      { scope: 'project', path: '<project>/.agents/skills', note: 'the Codex project folder, which Antigravity reads too' },
+    ],
+    reload: { file: 'automatic', newRoot: 'automatic', note: 'Antigravity reads its skill folders again by itself; there is no command to run.' },
+  }),
   'codex-prompt': Object.freeze({
     id: 'codex-prompt', version: '2026-10-21', title: 'Codex custom prompt (deprecated)', runtime: 'codex', status: 'legacy',
     sources: [SOURCES.codexPrompts], verified: null,
@@ -144,7 +162,7 @@ export const PROFILES = Object.freeze({
 });
 
 /** The profile an install into a runtime is checked against. */
-export const TARGET_PROFILE = Object.freeze({ claude: 'claude-code', codex: 'codex-native', opencode: 'opencode-native', agents: 'portable-six-field' });
+export const TARGET_PROFILE = Object.freeze({ claude: 'claude-code', codex: 'codex-native', opencode: 'opencode-native', antigravity: 'antigravity-native', agents: 'portable-six-field' });
 
 export function getProfile(id) {
   return Object.prototype.hasOwnProperty.call(PROFILES, id) ? PROFILES[id] : null;
@@ -162,6 +180,11 @@ export function profileList() {
 
 const has = (data, key) => !!data && Object.prototype.hasOwnProperty.call(data, key);
 const isMap = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const ENCODER = new TextEncoder();
+/** A text's length in UTF-8 bytes (0 for anything else). */
+const utf8Length = (text) => (typeof text === 'string' ? ENCODER.encode(text).length : 0);
+/** "24 KB", "25.3 KB", "812 bytes". */
+const kb = (bytes) => (bytes < 1024 ? `${bytes} bytes` : `${Math.round((bytes / 1024) * 10) / 10} KB`);
 const kindOf = (value) => {
   if (value === undefined) return 'absent';
   if (value === null) return 'empty';
@@ -202,9 +225,11 @@ export function readInvocationIntent({ data, sidecar = null }) {
   const meta = isMap(data?.metadata) ? data.metadata : null;
   if (meta && has(meta, 'opencode/autoinvoke')) said.opencodeModel = openSwitch(meta['opencode/autoinvoke']);
   if (meta && has(meta, 'opencode/slash')) said.opencodeSlash = openSwitch(meta['opencode/slash']);
+  // Antigravity's `disable-slash-command: true` keeps /name from the person, as Claude Code's user-invocable: false does.
+  if (has(data, 'disable-slash-command')) said.antigravityUser = claudeBoolean(data['disable-slash-command']) === true ? false : (claudeBoolean(data['disable-slash-command']) === false ? true : null);
   const modelSays = [said.claudeModel, said.codexModel, said.opencodeModel].filter((v) => v === true || v === false);
   const model = !modelSays.includes(false);
-  const user = said.claudeUser !== false;
+  const user = said.claudeUser !== false && said.antigravityUser !== false;
   const conflicts = [];
   if (modelSays.includes(false) && modelSays.includes(true)) conflicts.push('model');
   return { user, model, slash: said.opencodeSlash ?? null, said, conflicts };
@@ -228,6 +253,10 @@ export function effectiveInvocation(profileId, { data, sidecar = null }) {
     const claudeOff = claudeBoolean(data?.['disable-model-invocation']) === true;
     return { model: !(openSwitch(meta?.['opencode/autoinvoke']) === false || claudeOff), user: true, slash: openSwitch(meta?.['opencode/slash']) === true };
   }
+  if (runtime === 'antigravity') {
+    // Only a YAML true is taken as hiding /name (anything else is not counted on); nothing keeps its model from starting a skill.
+    return { model: true, user: data?.['disable-slash-command'] !== true };
+  }
   return { model: true, user: true };
 }
 
@@ -254,6 +283,7 @@ export function invocationPlan(profileId, { intent, data, sidecar = null }) {
   }
   if (!intent.user && now.user) {
     if (runtime === 'claude') transforms.push({ file: 'SKILL.md', op: 'frontmatter', key: 'user-invocable', value: false, reason: 'Keeps /name hidden in Claude Code, as the skill\'s other settings say.' });
+    else if (runtime === 'antigravity') transforms.push({ file: 'SKILL.md', op: 'frontmatter', key: 'disable-slash-command', value: true, reason: 'Keeps /name hidden in Antigravity, as the skill\'s other settings say.' });
     else diagnostics.push({ ruleId: 'L-08-user-invocation-broader', severity: 'warning', message: `${profile.title} has no setting that hides a skill from the person: there it can still be started by name.`, file: 'SKILL.md', line: null });
   }
   return { transforms, diagnostics };
@@ -306,7 +336,7 @@ export function lintForProfile(profileId, { parsed, folderName = '', headPath =
       if (hidden.length || /[<>]/.test(name)) add('L-03-name-chars', 'error', `"name" holds characters ${profile.title} refuses (${hidden.length ? hidden.map((h) => h.label).join(', ') : 'an angle bracket'}).`, lineOf('name'));
       const portableName = PORTABLE_NAME_RE.test(name);
       if (!portableName) {
-        if (strictPortable || runtime === 'opencode') add('L-03-name-format', 'error', `"name" must be lowercase letters, digits and single hyphens for ${profile.title}.`, lineOf('name'));
+        if (strictPortable || runtime === 'opencode' || runtime === 'antigravity') add('L-03-name-format', 'error', `"name" must be lowercase letters, digits and single hyphens for ${profile.title}.`, lineOf('name'));
         else add('L-03-name-format', 'warning', `"name" is not lowercase letters, digits and single hyphens: other runtimes may refuse it.`, lineOf('name'));
       }
       if (folderName && name !== folderName) {
@@ -398,6 +428,14 @@ export function lintForProfile(profileId, { parsed, folderName = '', headPath =
     if (has(data, 'hooks') && !isMap(data.hooks)) add('L-04-hooks-type', 'error', `"hooks" must be a mapping of events; it is ${kindOf(data.hooks)}.`, lineOf('hooks'));
   }
 
+  // Antigravity's own field and limit
+  if (runtime === 'antigravity') {
+    if (has(data, 'disable-slash-command') && typeof data['disable-slash-command'] !== 'boolean') add('L-04-disable-slash-command-type', 'error', `"disable-slash-command" must be true or false; it is ${kindOf(data['disable-slash-command'])}.`, lineOf('disable-slash-command'));
+    const bytes = utf8Length(parsed?.body);
+    const max = profile.limits.bodyBytes || ANTIGRAVITY_BODY_BYTES;
+    if (bytes > max) add('L-03-body-size', 'error', `The body is ${kb(bytes)}; ${profile.title} reads ${kb(max)} at most. Move detail into files the skill points to.`, parsed?.bodyLine || null);
+  }
+
   // Keys the profile does not read
   for (const key of Object.keys(data)) {
     if (profile.fields.recognized.includes(key)) continue;

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

@@ -20,7 +20,7 @@ export const REVIEW_STATE_LABEL = Object.freeze({
   withdrawn: 'Withdrawn',
 });
 
-export const RUNTIME_LABEL = Object.freeze({ claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', agents: 'Shared (~/.agents/skills)' });
+export const RUNTIME_LABEL = Object.freeze({ claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', antigravity: 'Antigravity', agents: 'Shared (~/.agents/skills)' });
 
 /** A target as a person reads it: the runtime, and the project or the account when it is not the default one. */
 export function targetLabel(t) {
@@ -123,7 +123,7 @@ export function targetChoices({ sharedAgentsRoot = false } = {}, suggested = [])
     choices.push({ key, runtime: target.runtime, target, label: targetLabel(target), on: true });
   }
   const plainAsked = new Set(asked.filter(plainTarget).map((t) => t.runtime));
-  for (const runtime of ['claude', 'codex', 'opencode', ...(sharedAgentsRoot ? ['agents'] : [])]) {
+  for (const runtime of ['claude', 'codex', 'opencode', 'antigravity', ...(sharedAgentsRoot ? ['agents'] : [])]) {
     if (plainAsked.has(runtime)) continue;
     const target = { runtime };
     choices.push({ key: JSON.stringify(target), runtime, target, label: targetLabel(target), on: !asked.length && runtime === 'claude' });

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

@@ -165,7 +165,7 @@ export async function deleteFromLibrary(ctx, ws) {
   if (!ctx.alive(gen)) return;
   const installs = skill.installations || [];
   if (installs.length) {
-    const where = installs.slice(0, 6).map((i) => `• ${t(`skillsStudio.runtime.${['claude', 'codex', 'opencode', 'agents'].includes(i.runtime) ? i.runtime : 'claude'}`)} · ${i.destination || ''}`);
+    const where = installs.slice(0, 6).map((i) => `• ${t(`skillsStudio.runtime.${['claude', 'codex', 'opencode', 'antigravity', 'agents'].includes(i.runtime) ? i.runtime : 'claude'}`)} · ${i.destination || ''}`);
     const answer = await ctx.ask({
       title: t('skillsStudio.ws.libraryDeleteInstalledTitle', { name: ws.label }),
       lines: [tp('skillsStudio.ws.libraryDeleteInstalled', installs.length), ...where],

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

@@ -25,7 +25,7 @@ import {
 
 const PROMPT_KEY = 'skills-studio-create-prompt';
 const SCAN_COUNTED = ['blocked', 'incomplete', 'review', 'findings'];
-const PROVIDER_RUNTIME = new Map([['claude-code', 'claude'], ['codex', 'codex'], ['opencode', 'opencode']]);
+const PROVIDER_RUNTIME = new Map([['claude-code', 'claude'], ['codex', 'codex'], ['opencode', 'opencode'], ['antigravity', 'antigravity']]);
 
 // What the box keeps between drawings of the place (the form itself is kept in storage).
 const AI = {

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

@@ -13,7 +13,8 @@ import { CREATION_LIMITS, DRAFT_PROVIDERS, isActiveCreation, normalizeCreationRe
 export const AI_FORM_KEY = 'skills-studio-create-ai';
 /** The places a source is added from (describe is the prompt itself). */
 export const AI_SOURCE_KINDS = Object.freeze(['conversation', 'url', 'repo', 'memory', 'import']);
-export const DRAFT_RUNTIMES = Object.freeze(['claude', 'codex', 'opencode']);
+/** The runtimes a drafted skill is meant for (its install targets, ss-creation.js CREATION_TARGET_RUNTIMES), not who drafts it. */
+export const DRAFT_RUNTIMES = Object.freeze(['claude', 'codex', 'opencode', 'antigravity']);
 export const WORK_MINUTES = Object.freeze([20, 30, 45, 60, 90]);
 /** The steps a creation shows, in order. */
 export const CREATION_STEPS = Object.freeze(['sources', 'drafting', 'checking', 'review']);

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

@@ -97,7 +97,8 @@ export function healthIcon(code) {
     case 'invalid': case 'not-text': return ICONS.err;
     case 'warnings': return ICONS.warn;
     case 'update': return ICONS.update;
-    case 'shadowed': case 'twice': case 'same-description': return ICONS.flag;
+    case 'shadowed': case 'twice': case 'same-description': case 'duplicate-record': return ICONS.flag;
+    case 'stale-install': return ICONS.update;
     case 'bridge': return ICONS.bridge;
     case 'readonly': return ICONS.lock;
     case 'draft': return ICONS.draft;

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

@@ -0,0 +1,359 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Skills Studio 2.0: the fix panel and "Fix safe issues"
+// ═══════════════════════════════════════════
+//
+// A health pill of the Library (or of a workspace's head) opens the fix panel of its row: every problem in plain
+// words, what each fix does, and its buttons (sx-fixes.js says which). The Library's attention notice offers
+// "Fix safe issues…": every one-press repair is read first and listed (what will be added, which record archived),
+// nothing is written until the owner applies that list, and what was done or not is said item by item.
+// Every write is a Studio API call (X-SynaBun-UI): a library skill's text goes to its draft (PATCH /v2/drafts), an
+// agent's file is saved over the revision it was read at, a second library record is archived (Restore brings it
+// back). Install locations change only through Publish and the existing remove flows.
+
+import { studioErrorText } from './sx-errors.js';
+import { subjectOf } from './sx-subject.js';
+import { issuesOf, planTextFix, safeFixCandidates, issueCounts, fingerprintOf } from './sx-fixes.js';
+import { healthWords } from './sx-library-view.js';
+import { HEAD } from './sx-docs.js';
+import { createFrontmatter } from '../ss-frontmatter.js';
+import { lintArtifact } from '../ss-lint.js';
+import { html, setHTML, ICONS, healthIcon } from './sx-dom.js';
+
+const YAML_MODULE = '/vendor/yaml/yaml-2.9.1.min.js';
+let _fm = null;
+const frontmatter = async () => (_fm ||= createFrontmatter(await import(YAML_MODULE)));
+
+/** The most text repairs "Fix safe issues" reads in one go (each is one or two reads). */
+export const MAX_TEXT_READS = 40;
+
+/** What a row allows the fix panel to do. */
+export function canOf(ctx, deleteKind) {
+  return (row) => {
+    const s = subjectOf(row, { guest: ctx.guest, caps: ctx.caps });
+    const library = s.mode === 'library' && !!row.skill?.skillId;
+    return {
+      edit: !ctx.guest && !row.binary && (library || (s.mode === 'inplace' && !!s.v1Id && row.kind === 'agent')),
+      open: true,
+      delete: !!deleteKind?.(ctx, row, s),
+      archive: !ctx.guest && (!ctx.capsKnown || ctx.caps.has('library-delete')),
+      dismiss: !ctx.guest,
+    };
+  };
+}
+
+/**
+ * Read a row's head file and the safe repair of it, without writing anything.
+ * @returns {Promise<{ changes: object[], apply: () => Promise<void> } | null>} null: nothing safe to do
+ */
+export async function readTextFix(ctx, row) {
+  const { api } = ctx;
+  const s = subjectOf(row, { guest: ctx.guest, caps: ctx.caps });
+  if (s.mode === 'inplace' && s.v1Id && row.kind === 'agent') {
+    const got = await api.fetchSkillsArtifact(s.v1Id);
+    if (got.binary || got.readOnly) return null;
+    const plan = planTextFix({ raw: got.rawContent, diagnostics: got.diagnostics, type: 'agent', folderName: row.folderName });
+    if (!plan) return null;
+    return { changes: plan.changes, apply: () => api.saveSkillsArtifact(s.v1Id, plan.text, { expectedRevision: got.revision }) };
+  }
+  if (s.mode !== 'library' || !row.skill?.skillId) return null;
+  const skill = (await api.fetchSkill(row.skill.skillId)).skill;
+  let draft = null;
+  if (skill.pointers?.draft) {
+    try { draft = (await api.fetchSkillsDraft(skill.pointers.draft)).draft; } catch (err) { if (err?.status !== 404) throw err; }
+  }
+  const latest = skill.pointers?.latest || null;
+  const file = draft ? await api.fetchSkillsDraftFile(draft.draftId, HEAD) : latest ? await api.fetchSkillsRevisionFile(latest, HEAD) : null;
+  if (!file || typeof file.content !== 'string') return null;
+  const fm = await frontmatter();
+  const folderName = String(skill.name || row.folderName || '');
+  const lint = lintArtifact({ type: 'skill', parsed: fm.parse(file.content), folderName });
+  const plan = planTextFix({ raw: file.content, diagnostics: lint.all, type: 'skill', folderName });
+  if (!plan) return null;
+  return {
+    changes: plan.changes,
+    apply: async () => {
+      const target = draft || (await api.createSkillsDraft({ skillId: skill.skillId, baseRevisionId: latest }, { idempotencyKey: ctx.key('fix-draft') })).draft;
+      await api.patchSkillsDraft(target.draftId, { expectedEtag: target.etag, ops: [{ op: 'put', path: HEAD, content: plan.text }] });
+    },
+  };
+}
+
+/** Archive the second library record of a skill (Restore in the Archived view brings it back). */
+const archiveRecord = (ctx, row) => ctx.api.deleteLibrarySkill(row.skill.skillId, row.skill.etag ? { expectedEtag: row.skill.etag } : {});
+
+/** The words of a step of the preview. */
+function stepWords(ctx, step) {
+  const { t } = ctx;
+  if (step.kind === 'archive') return t('skillsStudio.fix.step.archive', { name: step.row.label, original: step.issue.health.name || '' });
+  return t('skillsStudio.fix.step.text', { name: step.row.label, added: step.changes.map((c) => c.added).join(' · ') });
+}
+
+/** Say what was done (a notice kept above the list until OK, a toast, the live region). */
+function report(ctx, done, failed) {
+  const { t, tp } = ctx;
+  const line = failed.length ? t('skillsStudio.fix.resultPartial', { done: done.length, failed: failed.length, first: failed[0] }) : tp('skillsStudio.fix.resultDone', done.length);
+  ctx.lib.fixNotice = { kind: failed.length ? 'warn' : 'info', line, lines: [...done, ...failed] };
+  ctx.toast(line, failed.length ? 'error' : 'info');
+  ctx.announce(line);
+}
+
+/**
+ * "Fix safe issues…": read every candidate, list exactly what would change, apply only that list on the owner's word.
+ * @param {object} ctx @param {object[]} rows the Library's rows @param {Function} deleteKind
+ */
+export async function fixAllSafe(ctx, rows, deleteKind) {
+  const { t, tp } = ctx;
+  const { steps } = safeFixCandidates(rows, canOf(ctx, deleteKind));
+  const gen = ctx.gen();
+  ctx.toast(t('skillsStudio.fix.reading'));
+  const ready = []; const unreadable = [];
+  let reads = 0;
+  for (const step of steps) {
+    if (step.kind !== 'text') { ready.push(step); continue; }
+    if (reads++ >= MAX_TEXT_READS) break;
+    try {
+      const fix = await readTextFix(ctx, step.row);
+      if (fix) ready.push({ ...step, changes: fix.changes, apply: fix.apply });
+    } catch (err) { unreadable.push(`${step.row.label}: ${studioErrorText(t, err)}`); }
+    if (!ctx.alive(gen)) return;
+  }
+  if (!ctx.alive(gen)) return;
+  const list = document.createElement('ul');
+  list.className = 'sx-fix-preview';
+  for (const step of ready) {
+    const li = document.createElement('li');
+    li.className = 'sx-fix-preview-row';
+    li.textContent = stepWords(ctx, step);
+    list.append(li);
+  }
+  if (!ready.length) {
+    await ctx.ask({ title: t('skillsStudio.fix.previewTitle'), lines: [t('skillsStudio.fix.previewNothing'), ...unreadable], buttons: [{ id: 'ok', label: t('skillsStudio.dialog.close'), kind: 'primary' }], cancelId: 'ok' });
+    return;
+  }
+  const answer = await ctx.ask({
+    title: t('skillsStudio.fix.previewTitle'),
+    lines: [t('skillsStudio.fix.previewIntro'), ...unreadable],
+    extra: list,
+    wide: true,
+    buttons: [{ id: 'cancel', label: t('skillsStudio.dialog.cancel') }, { id: 'apply', label: tp('skillsStudio.fix.apply', ready.length), kind: 'primary' }],
+    focus: 'apply',
+  });
+  if (answer !== 'apply' || !ctx.alive(gen)) return;
+  const done = []; const failed = [];
+  for (const step of ready) {
+    try {
+      if (step.kind === 'archive') await archiveRecord(ctx, step.row); else await step.apply();
+      done.push(stepWords(ctx, step));
+    } catch (err) { failed.push(`${step.row.label}: ${studioErrorText(t, err)}`); }
+  }
+  if (!ctx.alive(gen)) return;
+  report(ctx, done, failed);
+  await ctx.reload();
+}
+
+/** One issue as a card of the panel: its word, what it means, how it is fixed, and its buttons. */
+function issueCard(ctx, row, issue, index) {
+  const { t } = ctx;
+  const card = document.createElement('section');
+  card.className = `sx-fix-card sx-fix-card--${issue.sev}`;
+  card.setAttribute('aria-labelledby', `sx-fix-${index}-title`);
+  const head = document.createElement('div');
+  head.className = 'sx-fix-card-head';
+  setHTML(head, html`${healthIcon(issue.code)}<strong id="sx-fix-${index}-title">${healthWords(issue.health, t)}</strong><span class="sx-fix-mode sx-fix-mode--${issue.mode}">${issue.mode === 'auto' ? t('skillsStudio.fix.mode.auto') : t('skillsStudio.fix.mode.guided')}</span>`);
+  const explain = document.createElement('p');
+  explain.className = 'sx-fix-explain';
+  explain.textContent = explainOf(ctx, row, issue);
+  card.append(head, explain);
+  const bar = document.createElement('div');
+  bar.className = 'sx-fix-actions';
+  for (const action of issue.actions) {
+    const b = document.createElement('button');
+    b.type = 'button';
+    b.className = `sx-btn sx-btn--sm${action === 'dismiss' ? ' sx-btn--ghost' : action === 'delete' ? ' sx-btn--danger' : (action === 'auto-text' || action === 'archive-duplicate') ? ' sx-btn--primary' : ''}`;
+    b.dataset.fix = `${index}:${action}`;
+    b.textContent = t(`skillsStudio.fix.action.${action}`);
+    bar.append(b);
+  }
+  if (!issue.actions.length) {
+    const p = document.createElement('p');
+    p.className = 'sx-dim';
+    p.textContent = t('skillsStudio.fix.nothingHere');
+    bar.append(p);
+  }
+  card.append(bar);
+  return card;
+}
+
+/** What a problem means for this row, in plain words. */
+export function explainOf(ctx, row, issue) {
+  const { t } = ctx;
+  const h = issue.health;
+  const runtime = h.runtime ? t(`skillsStudio.runtime.${h.runtime}`) : '';
+  switch (issue.code) {
+    case 'shadowed': return t('skillsStudio.fix.explain.shadowed', { runtime: runtime || '—' });
+    case 'twice': return t('skillsStudio.fix.explain.twice', { runtime: runtime || '—' });
+    case 'same-description': return t('skillsStudio.fix.explain.same-description', { names: (h.names || []).join(', ') });
+    case 'duplicate-record': return `${t('skillsStudio.fix.explain.duplicate-record', { original: h.name || '' })}${h.why ? ` ${t(`skillsStudio.fix.duplicateWhy.${h.why}`)}` : ''}`;
+    default: return t(`skillsStudio.fix.explain.${issue.code}`);
+  }
+}
+
+/**
+ * The fix panel of one row. Resolves when the owner is done (a fix applied, a place opened, or closed).
+ * @param {object} ctx @param {object} row @param {{ deleteKind: Function, bulkDelete: Function }} hooks
+ */
+export async function openFixPanel(ctx, row, { deleteKind, bulkDelete } = {}) {
+  const { t } = ctx;
+  const issues = issuesOf(row, canOf(ctx, deleteKind)(row));
+  const box = document.createElement('div');
+  box.className = 'sx-fix-panel';
+  if (!issues.length) {
+    const p = document.createElement('p');
+    p.textContent = t('skillsStudio.fix.none');
+    box.append(p);
+  }
+  issues.forEach((issue, i) => box.append(issueCard(ctx, row, issue, i)));
+  const answer = await ctx.ask({
+    title: t('skillsStudio.fix.title', { name: row.label }),
+    lines: issues.length ? [t('skillsStudio.fix.intro')] : [],
+    extra: box,
+    wide: true,
+    buttons: [{ id: 'close', label: t('skillsStudio.dialog.close') }],
+    cancelId: 'close',
+    onOpen: (ui) => box.addEventListener('click', (e) => { const b = e.target.closest?.('[data-fix]'); if (b) ui.done(b.dataset.fix); }),
+  });
+  if (!answer || answer === 'close') return;
+  const [index, action] = [Number(answer.split(':')[0]), answer.split(':').slice(1).join(':')];
+  const issue = issues[index];
+  if (!issue) return;
+  await runAction(ctx, row, issue, action, { bulkDelete });
+}
+
+async function runAction(ctx, row, issue, action, { bulkDelete }) {
+  const { t, tp } = ctx;
+  const gen = ctx.gen();
+  try {
+    switch (action) {
+      case 'dismiss':
+        ctx.dismissIssues([issue.fingerprint]);
+        ctx.toast(t('skillsStudio.fix.dismissed'));
+        return;
+      case 'open-edit': ctx.openRow(row.key, { tab: 'edit' }); return;
+      case 'open-publish': ctx.openRow(row.key, { tab: 'publish' }); return;
+      case 'open-update': ctx.openRow(row.key); return;
+      case 'keep-mine':
+        ctx.keepUpdate(row.folderName, row.update?.upstreamRevisionId);
+        ctx.toast(t('skillsStudio.toast.keptMine', { name: row.folderName }));
+        ctx.render();
+        return;
+      case 'move-bridges': await ctx.openSkillFolders(); return;
+      case 'delete':
+        ctx.lib.selected = new Set([row.key]);
+        await bulkDelete?.(ctx);
+        return;
+      case 'auto-text': {
+        const fix = await readTextFix(ctx, row);
+        if (!ctx.alive(gen)) return;
+        if (!fix) {
+          const go = await ctx.ask({ title: t('skillsStudio.fix.title', { name: row.label }), lines: [t('skillsStudio.fix.textNothing')], buttons: [{ id: 'cancel', label: t('skillsStudio.dialog.close') }, { id: 'open', label: t('skillsStudio.fix.action.open-edit'), kind: 'primary' }], focus: 'open' });
+          if (go === 'open') ctx.openRow(row.key, { tab: 'edit' });
+          return;
+        }
+        const step = { kind: 'text', row, issue, changes: fix.changes };
+        const ok = await ctx.ask({ title: t('skillsStudio.fix.previewTitle'), lines: [t('skillsStudio.fix.previewIntro'), stepWords(ctx, step), row.skill ? t('skillsStudio.fix.textToDraft') : t('skillsStudio.fix.textInPlace')], buttons: [{ id: 'cancel', label: t('skillsStudio.dialog.cancel') }, { id: 'apply', label: tp('skillsStudio.fix.apply', 1), kind: 'primary' }], focus: 'apply' });
+        if (ok !== 'apply' || !ctx.alive(gen)) return;
+        await fix.apply();
+        report(ctx, [stepWords(ctx, step)], []);
+        await ctx.reload();
+        return;
+      }
+      case 'archive-duplicate': {
+        const step = { kind: 'archive', row, issue };
+        const ok = await ctx.ask({ title: t('skillsStudio.fix.previewTitle'), lines: [stepWords(ctx, step)], buttons: [{ id: 'cancel', label: t('skillsStudio.dialog.cancel') }, { id: 'apply', label: tp('skillsStudio.fix.apply', 1), kind: 'primary' }], focus: 'apply' });
+        if (ok !== 'apply' || !ctx.alive(gen)) return;
+        await archiveRecord(ctx, row);
+        report(ctx, [stepWords(ctx, step)], []);
+        await ctx.reload();
+        return;
+      }
+      case 'choose-copy': await chooseCopy(ctx, row, issue); return;
+      default: return;
+    }
+  } catch (err) {
+    if (ctx.alive(gen)) ctx.toast(t('skillsStudio.fix.failed', { error: studioErrorText(t, err) }), 'error');
+  }
+}
+
+/** Two records of one skill that differ: the owner picks the one that keeps the name; the other is archived. */
+async function chooseCopy(ctx, row, issue) {
+  const { t, tp } = ctx;
+  const original = ctx.rows.find((r) => r.key === issue.health.of);
+  const pair = [original, row].filter(Boolean);
+  const archivable = (r) => !(r.skill?.installations || []).length && !r.review;
+  const box = document.createElement('div');
+  box.className = 'sx-fix-choose';
+  box.setAttribute('role', 'radiogroup');
+  box.setAttribute('aria-label', t('skillsStudio.fix.chooseTitle'));
+  let picked = null;
+  for (const r of pair) {
+    const label = document.createElement('label');
+    label.className = 'sx-fix-choice';
+    const input = document.createElement('input');
+    input.type = 'radio';
+    input.name = 'sx-fix-keep';
+    input.value = r.key;
+    // Keeping one archives the other: only a record that can be archived (not installed, not in review) may go.
+    const other = pair.find((x) => x !== r);
+    input.disabled = !other || !archivable(other);
+    input.addEventListener('change', () => { picked = r.key; });
+    const text = document.createElement('span');
+    const versions = Number(r.skill?.revisions) || 0;
+    const installs = (r.skill?.installations || []).length;
+    text.textContent = t('skillsStudio.fix.keepThis', { name: r.label, versions: tp('skillsStudio.fix.versions', versions), installs: tp('skillsStudio.fix.installs', installs) });
+    label.append(input, text);
+    box.append(label);
+  }
+  if (!pair.some((r) => archivable(r))) {
+    await ctx.ask({ title: t('skillsStudio.fix.chooseTitle'), lines: [t('skillsStudio.fix.chooseNone')], buttons: [{ id: 'ok', label: t('skillsStudio.dialog.close'), kind: 'primary' }], cancelId: 'ok' });
+    return;
+  }
+  const answer = await ctx.ask({
+    title: t('skillsStudio.fix.chooseTitle'),
+    lines: [t('skillsStudio.fix.chooseIntro')],
+    extra: box,
+    buttons: [{ id: 'cancel', label: t('skillsStudio.dialog.cancel') }, { id: 'keep', label: t('skillsStudio.fix.keepConfirm'), kind: 'primary' }],
+    accept: () => !!picked,
+  });
+  if (answer !== 'keep' || !picked) return;
+  const gone = pair.find((r) => r.key !== picked);
+  await archiveRecord(ctx, gone);
+  report(ctx, [t('skillsStudio.fix.step.archive', { name: gone.label, original: pair.find((r) => r.key === picked)?.label || '' })], []);
+  await ctx.reload();
+}
+
+/** The Library's attention notice: how many problems, and "Fix safe issues…" / "Show them". */
+export function fixNoticeHTML(ctx, deleteKind) {
+  if (ctx.guest || ctx.lib.view === 'archived' || ctx.loading) return '';
+  const { t, tp } = ctx;
+  const out = [];
+  const n = ctx.lib.fixNotice;
+  if (n) {
+    out.push(html`<div class="sx-notice sx-notice--${n.kind === 'info' ? 'info' : 'warn'}" role="status" data-notice-box="fix">
+      ${n.kind === 'info' ? ICONS.ok : ICONS.warn}<span class="sx-notice-text">${n.line}${n.lines.slice(0, 8).map((l) => html`<span class="sx-block">${l}</span>`)}</span>
+      <button type="button" class="sx-btn sx-btn--ghost" data-lib="fix-notice-ok">${t('skillsStudio.notice.ok')}</button>
+    </div>`);
+  }
+  const counts = issueCounts(ctx.rows, canOf(ctx, deleteKind));
+  if (counts.total) {
+    const { steps } = safeFixCandidates(ctx.rows, canOf(ctx, deleteKind));
+    out.push(html`<div class="sx-notice sx-notice--warn sx-fix-notice" role="note" data-notice-box="attention">
+      ${ICONS.warn}<span class="sx-notice-text">${tp('skillsStudio.fix.notice', counts.total)}${steps.length ? ` ${tp('skillsStudio.fix.noticeSafe', steps.length)}` : ''}</span>
+      ${steps.length ? html`<button type="button" class="sx-btn sx-btn--primary" data-lib="fix-all">${t('skillsStudio.fix.fixAll')}</button>` : ''}
+      ${ctx.lib.health === 'attention' ? '' : html`<button type="button" class="sx-btn" data-lib="fix-show">${t('skillsStudio.fix.showIssues')}</button>`}
+    </div>`);
+  }
+  return html`${out}`;
+}
+
+/** The unreadable folders of the catalog, said with what can be done: read again, or leave them (dismissed). */
+export const unreadableFingerprint = (count) => fingerprintOf('library', { code: 'unreadable', count });