@askdkc/kiokuko 0.1.17 → 0.1.19

package/dist/web/ui.js

@@ -10,6 +10,93 @@ const WEB_I18N_CONFIG = JSON.stringify({
     .replaceAll('>', '\\u003e')
     .replaceAll('\u2028', '\\u2028')
     .replaceAll('\u2029', '\\u2029');
+/** Strict client-boundary decoder for the bounded external-skill list shape. */
+export function externalSkillListItemIsValid(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const skill = value;
+    const fields = new Set([
+        'skillId', 'provider', 'sourceType', 'sourceLocator', 'slug', 'name', 'installUrl',
+        'officialStatus', 'duplicate', 'installs', 'state', 'sourceWorkspace', 'sourceCommit',
+        'snapshotHash', 'metadata', 'auditStatus', 'generation', 'firstSeenAt', 'lastSeenAt',
+        'lastCheckedAt', 'disabledAt',
+    ]);
+    const text = (item, maximum) => typeof item === 'string'
+        && item.length >= 1 && item.length <= maximum && item === item.trim() && !/[\u0000-\u001f\u007f]/u.test(item);
+    const timestamp = (item) => {
+        if (typeof item !== 'string')
+            return false;
+        const parsed = Date.parse(item);
+        return Number.isFinite(parsed) && new Date(parsed).toISOString() === item;
+    };
+    const metadata = skill.metadata;
+    const sourceLocator = skill.sourceLocator;
+    const slug = skill.slug;
+    const sourceCommit = skill.sourceCommit;
+    const snapshotHash = skill.snapshotHash;
+    const disabledAt = skill.disabledAt;
+    const officialStatus = skill.officialStatus;
+    const state = skill.state;
+    const auditStatus = skill.auditStatus;
+    if (Object.keys(skill).length !== fields.size || Object.keys(skill).some((field) => !fields.has(field))
+        || !text(skill.skillId, 500) || !text(skill.provider, 50) || !/^[A-Za-z0-9_.-]+$/u.test(skill.provider)
+        || skill.sourceType !== 'github'
+        || typeof sourceLocator !== 'string' || !/^[a-z0-9_.-]{1,100}\/[a-z0-9_.-]{1,100}$/u.test(sourceLocator)
+        || typeof slug !== 'string' || !/^[A-Za-z0-9_.\-/]{1,240}$/u.test(slug)
+        || slug.split('/').some((part) => part === '' || part === '.' || part === '..')
+        || skill.skillId !== `github:${sourceLocator}:${slug}`
+        || !text(skill.name, 500)
+        || skill.installUrl !== null && skill.installUrl !== `https://github.com/${sourceLocator}`
+        || typeof officialStatus !== 'string'
+        || !['curated', 'catalog-verified', 'owner-verified', 'registry-only', 'unknown'].includes(officialStatus)
+        || typeof skill.duplicate !== 'boolean'
+        || typeof skill.installs !== 'number' || !Number.isSafeInteger(skill.installs) || skill.installs < 0
+        || typeof state !== 'string'
+        || !['discovered', 'imported', 'blocked', 'stale', 'disabled'].includes(state)
+        || !text(skill.sourceWorkspace, 240)
+        || sourceCommit !== null && (typeof sourceCommit !== 'string' || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(sourceCommit))
+        || snapshotHash !== null && (typeof snapshotHash !== 'string' || !/^[0-9a-f]{64}$/u.test(snapshotHash))
+        || (sourceCommit === null) !== (snapshotHash === null)
+        || typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)
+        || Object.keys(metadata).length !== 2 || !Object.hasOwn(metadata, 'documents') || !Object.hasOwn(metadata, 'technology')
+        || typeof metadata.documents !== 'number'
+        || !Number.isSafeInteger(metadata.documents)
+        || metadata.documents < 0
+        || metadata.documents > 64
+        || metadata.technology !== null && !text(metadata.technology, 500)
+        || typeof auditStatus !== 'string'
+        || !['not-required', 'passed', 'failed', 'unavailable'].includes(auditStatus)
+        || typeof skill.generation !== 'number' || !Number.isSafeInteger(skill.generation) || skill.generation < 1
+        || !timestamp(skill.firstSeenAt) || !timestamp(skill.lastSeenAt) || !timestamp(skill.lastCheckedAt)
+        || disabledAt !== null && !timestamp(disabledAt)
+        || skill.firstSeenAt > skill.lastSeenAt
+        || skill.firstSeenAt > skill.lastCheckedAt
+        || disabledAt !== null && disabledAt < skill.firstSeenAt
+        || sourceCommit === null && (['imported', 'disabled'].includes(state) || disabledAt !== null)
+        || sourceCommit !== null && !['imported', 'disabled', 'stale', 'blocked'].includes(state)
+        || state === 'imported' && disabledAt !== null
+        || state === 'disabled' && disabledAt === null
+        || sourceCommit === null && (metadata.documents !== 0 || metadata.technology !== null)
+        || sourceCommit !== null && (metadata.documents === 0 || !text(metadata.technology, 500)))
+        return false;
+    return true;
+}
+/** Strict client-boundary decoder for one external-skill mapping summary. */
+export function externalSkillEntrySummaryIsValid(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const entry = value;
+    const fields = new Set(['entryId', 'revision', 'sourcePath', 'chunkIndex', 'primary', 'active']);
+    return Object.keys(entry).length === fields.size
+        && Object.keys(entry).every((field) => fields.has(field))
+        && typeof entry.entryId === 'string' && entry.entryId.length >= 1 && entry.entryId.length <= 500 && entry.entryId === entry.entryId.trim()
+        && typeof entry.revision === 'number' && Number.isSafeInteger(entry.revision) && entry.revision >= 1
+        && typeof entry.sourcePath === 'string' && entry.sourcePath.length >= 1 && entry.sourcePath.length <= 2_000
+        && /^[A-Za-z0-9_.\-/]+$/u.test(entry.sourcePath) && !entry.sourcePath.startsWith('/')
+        && !entry.sourcePath.split('/').some((part) => part === '' || part === '.' || part === '..')
+        && typeof entry.chunkIndex === 'number' && Number.isSafeInteger(entry.chunkIndex) && entry.chunkIndex >= 0
+        && typeof entry.primary === 'boolean' && typeof entry.active === 'boolean';
+}
 export const WEB_HTML = String.raw `<!doctype html>
 <html lang="en">
 <head>
@@ -140,6 +227,17 @@ export const WEB_HTML = String.raw `<!doctype html>
     .curator-confirm-field dd { margin:0; overflow-wrap:anywhere; white-space:pre-wrap; }
     .curator-confirm-draft { max-height:280px; overflow:auto; margin:0; padding:12px; border:1px solid var(--line); border-radius:12px; background:var(--surface); white-space:pre-wrap; overflow-wrap:anywhere; font:inherit; font-size:13px; line-height:1.5; }
     .curator-confirm-actions { display:flex; justify-content:flex-end; gap:8px; margin-top:14px; }
+    .skill-dialog { width:min(1040px,calc(100vw - 32px)); max-height:min(860px,calc(100vh - 48px)); display:flex; flex-direction:column; min-height:0; background:rgba(255,255,255,.96); box-shadow:0 28px 90px rgba(15,23,42,.28); }
+    .skill-dialog .panel-body { min-height:0; overflow-y:auto; }
+    .skill-list { display:grid; gap:12px; }
+    .skill-card { border:1px solid var(--line); border-radius:14px; padding:16px; background:var(--panel); }
+    .skill-card h3 { margin:8px 0; font-size:17px; overflow-wrap:anywhere; }
+    .skill-card-grid { display:grid; grid-template-columns:repeat(auto-fit,minmax(180px,1fr)); gap:8px; margin-top:12px; }
+    .skill-field { min-width:0; padding:10px 11px; border:1px solid var(--line); border-radius:10px; background:var(--surface); }
+    .skill-field dt { margin:0 0 4px; color:var(--muted); font-size:11px; font-weight:800; }
+    .skill-field dd { margin:0; overflow-wrap:anywhere; white-space:pre-wrap; font-size:13px; }
+    .skill-card-actions { display:flex; flex-wrap:wrap; gap:8px; margin-top:12px; }
+    .skill-source-link { color:var(--accent); overflow-wrap:anywhere; }
     @keyframes curator-backdrop-in { from { opacity:0; } to { opacity:1; } }
     @keyframes curator-backdrop-out { from { opacity:1; } to { opacity:0; } }
     @keyframes curator-dialog-in { from { opacity:0; transform:translateY(10px) scale(.98); } to { opacity:1; transform:translateY(0) scale(1); } }
@@ -171,6 +269,7 @@ export const WEB_HTML = String.raw `<!doctype html>
           <select id="workspace" class="control" aria-label="Workspace" data-i18n-aria-label="workspaceLabel"></select>
           <input id="search" class="search" type="search" placeholder="Search memory…" aria-label="Search memory…" data-i18n-placeholder="searchPlaceholder" data-i18n-aria-label="searchPlaceholder">
           <button id="curator-button" class="button" type="button" data-i18n="curator">Curator</button>
+          <button id="external-skills-button" class="button" type="button" data-i18n="openExternalSkills">External Skills</button>
           <button id="refresh" class="button" type="button" data-i18n="refresh">Refresh</button>
         </div>
       </div>
@@ -238,8 +337,23 @@ export const WEB_HTML = String.raw `<!doctype html>
       </section>
     </div>
   </div>
+  <div id="external-skills-modal" class="curator-modal" hidden>
+    <section id="external-skills-panel" class="panel skill-dialog" role="dialog" aria-modal="true" aria-labelledby="external-skills-title" aria-describedby="external-skills-description">
+      <div class="panel-head curator-dialog-head">
+        <div class="curator-heading"><h2 id="external-skills-title" data-i18n="externalSkills">External Skills</h2><span class="badge" data-i18n="trustBadge">stored data is untrusted / non-actionable</span></div>
+        <div class="curator-header-actions"><button id="external-skills-refresh" class="button" type="button" data-i18n="externalSkillsRefresh">Refresh</button><button id="external-skills-close" class="curator-close" type="button" aria-label="Close External Skills" data-i18n-aria-label="externalSkillsClose"><span aria-hidden="true">×</span></button></div>
+      </div>
+      <div class="panel-body">
+        <p id="external-skills-description" class="subtitle" data-i18n="externalSkillsDescription">Review fetched skills as untrusted reference data. Nothing here installs software or runs scripts.</p>
+        <div id="external-skills-status" class="status" role="status" aria-live="polite"></div>
+        <div id="external-skills-list" class="skill-list"></div>
+      </div>
+    </section>
+  </div>
   <script>
     const i18n = ${WEB_I18N_CONFIG};
+    const validExternalSkillListItem = (${externalSkillListItemIsValid.toString()});
+    const validExternalSkillEntrySummary = (${externalSkillEntrySummaryIsValid.toString()});
     const localeStorageKey = 'kiokuko.web.locale';
     const normalizeLocale = (value) => {
       if (typeof value !== 'string') return null;
@@ -251,7 +365,14 @@ export const WEB_HTML = String.raw `<!doctype html>
       if (language === 'zh' && (parts.length === 1 || parts.includes('hans') || parts.includes('cn') || parts.includes('sg'))) return 'zh-CN';
       return null;
     };
-    const readStoredLocale = () => { try { return localStorage.getItem(localeStorageKey); } catch { return null; } };
+    const isStorageAccessError = (error) => typeof DOMException !== 'undefined' && error instanceof DOMException;
+    const readStoredLocale = () => {
+      try { return localStorage.getItem(localeStorageKey); }
+      catch (error) {
+        if (!isStorageAccessError(error)) throw error;
+        return null;
+      }
+    };
     const browserLocales = Array.isArray(navigator.languages) ? navigator.languages : [navigator.language];
     const localeCandidates = [new URLSearchParams(location.search).get('lang'), readStoredLocale(), ...browserLocales];
     const initialLocale = localeCandidates.map(normalizeLocale).find(Boolean) || i18n.defaultLocale;
@@ -262,7 +383,7 @@ export const WEB_HTML = String.raw `<!doctype html>
       ['bot:common', 'bot.common'], ['bot:researcher', 'bot.researcher'], ['bot:builder', 'bot.builder'], ['bot:reviewer', 'bot.reviewer'], ['bot:devops', 'bot.devops'], ['bot:writer', 'bot.writer'], ['bot:analyst', 'bot.analyst']
     ];
     const curatorUrl = new URLSearchParams(location.search);
-    const state = { locale: initialLocale, workspace: '', kind: 'all', tag: '', query: '', entries: [], recallItems: [], tags: [], selected: null, selectedRecall: null, runs: [], selectedRun: null, curatorCandidates: [], curatorGlobalized: new Set(), curatorNextCursor: null, curatorTotalApproximate: 0, curatorOpen: false, curatorPreviousFocus: null, curatorPendingCandidate: null, curatorConfirmationTrigger: null, curatorGlobalizeBusy: false, localizedStatus: null, curatorSearch: curatorUrl.get('search') || '', curatorProject: curatorUrl.get('project') || '', curatorTags: new Set(curatorUrl.getAll('tag')), curatorFramework: curatorUrl.get('framework') || '', curatorLanguage: curatorUrl.get('language') || '', curatorMemoryClass: curatorUrl.get('memoryClass') || '', curatorTier: curatorUrl.get('tier') || '', curatorReady: curatorUrl.get('ready') === 'true', curatorIncludeGlobalized: curatorUrl.get('includeGlobalized') === 'true', curatorFacets: null };
+    const state = { locale: initialLocale, workspace: '', kind: 'all', tag: '', query: '', entries: [], recallItems: [], tags: [], selected: null, selectedRecall: null, runs: [], selectedRun: null, curatorCandidates: [], curatorGlobalized: new Set(), curatorNextCursor: null, curatorTotalApproximate: 0, curatorOpen: false, curatorPreviousFocus: null, curatorPendingCandidate: null, curatorConfirmationTrigger: null, curatorGlobalizeBusy: false, externalSkills: [], externalSkillsOpen: false, externalSkillsPreviousFocus: null, externalSkillsBusy: false, externalSkillsPendingDisable: null, localizedStatus: null, curatorSearch: curatorUrl.get('search') || '', curatorProject: curatorUrl.get('project') || '', curatorTags: new Set(curatorUrl.getAll('tag')), curatorFramework: curatorUrl.get('framework') || '', curatorLanguage: curatorUrl.get('language') || '', curatorMemoryClass: curatorUrl.get('memoryClass') || '', curatorTier: curatorUrl.get('tier') || '', curatorReady: curatorUrl.get('ready') === 'true', curatorIncludeGlobalized: curatorUrl.get('includeGlobalized') === 'true', curatorFacets: null };
     const $ = (id) => document.getElementById(id);
     const t = (key, parameters = {}) => {
       const template = i18n.messages[state.locale]?.[key] ?? i18n.messages[i18n.defaultLocale]?.[key] ?? key;
@@ -310,9 +431,10 @@ export const WEB_HTML = String.raw `<!doctype html>
     };
     const selectLocale = (value) => {
       state.locale = normalizeLocale(value) || i18n.defaultLocale;
-      try { localStorage.setItem(localeStorageKey, state.locale); } catch {}
+      try { localStorage.setItem(localeStorageKey, state.locale); }
+      catch (error) { if (!isStorageAccessError(error)) throw error; }
       setLanguageMenuOpen(false, true);
-      applyTranslations(); renderFilters(); renderEntries(); renderRuns(); renderRunDetail(); renderCurator(); updateEditorState();
+      applyTranslations(); renderFilters(); renderEntries(); renderRuns(); renderRunDetail(); renderCurator(); renderExternalSkills(); updateEditorState();
     };
     const applyTranslations = () => {
       document.documentElement.lang = state.locale;
@@ -326,10 +448,24 @@ export const WEB_HTML = String.raw `<!doctype html>
       renderLanguageMenu();
       if (state.localizedStatus) showStatus(state.localizedStatus.plural ? tp(state.localizedStatus.key, state.localizedStatus.count) : t(state.localizedStatus.key, state.localizedStatus.parameters), state.localizedStatus.error);
     };
+    const apiError = (value) => {
+      const rawCode = value?.error?.code;
+      const rawMessage = value?.error?.message;
+      const code = typeof rawCode === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/.test(rawCode) ? rawCode : 'REQUEST_FAILED';
+      const normalizedMessage = typeof rawMessage === 'string' ? rawMessage.replace(/[\u0000-\u001f\u007f]+/g, ' ').trim().slice(0, 300) : '';
+      const error = new Error(normalizedMessage || t('requestFailed'));
+      error.code = code;
+      return error;
+    };
+    const apiErrorText = (error) => {
+      const code = error instanceof Error && typeof error.code === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/.test(error.code) ? error.code : 'REQUEST_FAILED';
+      const normalizedMessage = error instanceof Error ? error.message.replace(/[\u0000-\u001f\u007f]+/g, ' ').trim().slice(0, 300) : '';
+      return '[' + code + '] ' + (normalizedMessage || t('requestFailed'));
+    };
     const api = async (path, options) => {
       const response = await fetch(path, options);
       const value = await response.json();
-      if (!response.ok) throw new Error(value.error?.message || t('requestFailed'));
+      if (!response.ok) throw apiError(value);
       return value;
     };
     const escapeTags = (value) => value.split(',').map((item) => item.trim()).filter(Boolean);
@@ -437,6 +573,242 @@ export const WEB_HTML = String.raw `<!doctype html>
       else if (!event.shiftKey && document.activeElement === last) { event.preventDefault(); first.focus(); }
     }
 
+    const setExternalSkillsStatus = (message, error = false) => {
+      const element = $('external-skills-status');
+      element.textContent = message;
+      element.className = error ? 'status notice error curator-status' : 'status curator-status';
+    };
+    function openExternalSkills() {
+      if (state.externalSkillsOpen) { $('external-skills-close')?.focus(); return; }
+      state.externalSkillsPreviousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+      state.externalSkillsOpen = true;
+      const modal = $('external-skills-modal');
+      modal.classList.remove('is-closing');
+      setCuratorBackgroundBlocked(true);
+      modal.hidden = false;
+      requestAnimationFrame(() => $('external-skills-close')?.focus());
+    }
+    function closeExternalSkills() {
+      if (state.externalSkillsBusy) return;
+      const modal = $('external-skills-modal');
+      if (modal.hidden) return;
+      state.externalSkillsOpen = false;
+      state.externalSkillsPendingDisable = null;
+      modal.classList.add('is-closing');
+      let finished = false;
+      const finish = () => {
+        if (finished) return;
+        finished = true;
+        modal.hidden = true;
+        modal.classList.remove('is-closing');
+        setCuratorBackgroundBlocked(false);
+        const previousFocus = state.externalSkillsPreviousFocus;
+        state.externalSkillsPreviousFocus = null;
+        if (previousFocus?.isConnected) previousFocus.focus(); else $('external-skills-button')?.focus();
+      };
+      modal.addEventListener('animationend', (event) => { if (event.target === modal) finish(); }, { once: true });
+      window.setTimeout(finish, 220);
+    }
+    function handleExternalSkillsKeydown(event) {
+      if (event.key === 'Escape') { event.preventDefault(); closeExternalSkills(); return; }
+      if (event.key !== 'Tab') return;
+      const modal = $('external-skills-modal');
+      const focusable = [...modal.querySelectorAll('button:not([disabled]), a[href], [tabindex]:not([tabindex="-1"])')];
+      if (!focusable.length) { event.preventDefault(); return; }
+      const first = focusable[0]; const last = focusable.at(-1);
+      if (event.shiftKey && document.activeElement === first) { event.preventDefault(); last.focus(); }
+      else if (!event.shiftKey && document.activeElement === last) { event.preventDefault(); first.focus(); }
+    }
+    function skillField(labelKey, value) {
+      const field = document.createElement('div'); field.className = 'skill-field';
+      const label = document.createElement('dt'); setI18nText(label, labelKey);
+      const content = document.createElement('dd'); content.textContent = value || t('unknown');
+      field.append(label, content); return field;
+    }
+    function externalSkillButton(attribute, skillId) {
+      return [...document.querySelectorAll('[' + attribute + ']')].find((element) => element.getAttribute(attribute) === skillId);
+    }
+    function externalSkillSourceUrl(skill) {
+      return /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/.test(skill.sourceLocator) ? 'https://github.com/' + skill.sourceLocator : null;
+    }
+    function renderExternalSkills() {
+      if (!state.externalSkillsOpen) return;
+      const root = $('external-skills-list');
+      if (!state.externalSkills.length) { const empty = document.createElement('div'); empty.className = 'editor-empty'; setI18nText(empty, 'externalSkillsEmpty'); root.replaceChildren(empty); return; }
+      root.replaceChildren(...state.externalSkills.map((skill) => {
+        const card = document.createElement('article'); card.className = 'skill-card';
+        const meta = document.createElement('div'); meta.className = 'entry-meta';
+        const stateBadge = document.createElement('span'); stateBadge.className = 'badge ' + (skill.state === 'disabled' ? 'superseded' : skill.state === 'imported' ? 'verified' : 'candidate'); stateBadge.textContent = skill.state;
+        const official = document.createElement('span'); official.className = 'badge'; official.textContent = skill.officialStatus;
+        meta.append(stateBadge, official);
+        const heading = document.createElement('h3'); heading.textContent = skill.name;
+        const fields = document.createElement('dl'); fields.className = 'skill-card-grid';
+        fields.append(
+          skillField('externalSkillsSource', skill.sourceLocator + '/' + skill.slug),
+          skillField('externalSkillsCommit', skill.sourceCommit ? skill.sourceCommit.slice(0, 12) : null),
+          skillField('externalSkillsSnapshot', skill.snapshotHash ? skill.snapshotHash.slice(0, 12) : null),
+          skillField('externalSkillsDocuments', String(skill.metadata?.documents ?? 0)),
+          skillField('externalSkillsFirstSeen', skill.firstSeenAt),
+          skillField('externalSkillsLastChecked', skill.lastCheckedAt),
+          skillField('externalSkillsTechnology', skill.metadata?.technology ?? skill.name),
+          skillField('externalSkillsAudit', skill.auditStatus),
+          skillField('externalSkillsState', skill.state),
+        );
+        const notice = document.createElement('div'); notice.className = 'notice'; setI18nText(notice, 'externalSkillsUntrusted');
+        const actions = document.createElement('div'); actions.className = 'skill-card-actions';
+        const sourceUrl = externalSkillSourceUrl(skill);
+        if (sourceUrl) { const source = document.createElement('a'); source.className = 'button'; source.href = sourceUrl; source.target = '_blank'; source.rel = 'noopener noreferrer'; setI18nText(source, 'externalSkillsSourceUrl'); actions.append(source); }
+        const refresh = document.createElement('button'); refresh.type = 'button'; refresh.className = 'button'; refresh.setAttribute('data-external-skill-refresh', skill.skillId); setI18nText(refresh, 'externalSkillsRefresh'); refresh.disabled = state.externalSkillsBusy; refresh.addEventListener('click', () => externalSkillAction(skill.skillId, 'refresh')); actions.append(refresh);
+        const action = skill.state === 'disabled' ? 'enable' : skill.state === 'imported' ? 'disable' : null;
+        if (action === 'disable' && state.externalSkillsPendingDisable === skill.skillId) {
+          const confirmation = document.createElement('div'); confirmation.className = 'notice'; confirmation.textContent = t('externalSkillsDisableConfirm');
+          const confirm = document.createElement('button'); confirm.type = 'button'; confirm.className = 'button primary'; confirm.setAttribute('data-external-skill-confirm', skill.skillId); setI18nText(confirm, 'externalSkillsDisable'); confirm.disabled = state.externalSkillsBusy; confirm.addEventListener('click', () => externalSkillAction(skill.skillId, action, true));
+          const cancel = document.createElement('button'); cancel.type = 'button'; cancel.className = 'button'; setI18nText(cancel, 'curatorCancel'); cancel.disabled = state.externalSkillsBusy; cancel.addEventListener('click', () => { state.externalSkillsPendingDisable = null; renderExternalSkills(); requestAnimationFrame(() => externalSkillButton('data-external-skill-toggle', skill.skillId)?.focus()); });
+          actions.append(confirmation, confirm, cancel);
+        } else if (action !== null) {
+          const toggle = document.createElement('button'); toggle.type = 'button'; toggle.className = 'button primary'; toggle.setAttribute('data-external-skill-toggle', skill.skillId); setI18nText(toggle, action === 'enable' ? 'externalSkillsEnable' : 'externalSkillsDisable'); toggle.disabled = state.externalSkillsBusy; toggle.addEventListener('click', () => externalSkillAction(skill.skillId, action)); actions.append(toggle);
+        }
+        const mapping = document.createElement('div'); mapping.className = 'detail-text'; mapping.hidden = true;
+        const viewEntries = document.createElement('button'); viewEntries.type = 'button'; viewEntries.className = 'button'; viewEntries.setAttribute('aria-expanded', 'false'); setI18nText(viewEntries, 'externalSkillsViewEntries'); viewEntries.disabled = state.externalSkillsBusy; viewEntries.addEventListener('click', async () => {
+          viewEntries.disabled = true;
+          try {
+            const detail = externalSkillDetail(await api('/api/skills/' + encodeURIComponent(skill.skillId)), skill.skillId);
+            if (detail === null) throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+            const entries = detail.entries;
+            mapping.textContent = entries.length ? entries.map((entry) => entry.sourcePath + '#' + entry.chunkIndex + ' → ' + entry.entryId + '@' + entry.revision + (entry.active ? '' : ' (inactive)')).join('\n') : t('externalSkillsNoEntries');
+            mapping.hidden = false;
+            viewEntries.setAttribute('aria-expanded', 'true');
+          } catch {
+            mapping.textContent = '';
+            mapping.hidden = true;
+            viewEntries.setAttribute('aria-expanded', 'false');
+            setExternalSkillsStatus(t('externalSkillsFailure'), true);
+          }
+          finally { viewEntries.disabled = state.externalSkillsBusy; }
+        });
+        actions.append(viewEntries);
+        card.append(meta, heading, fields, notice, actions, mapping); return card;
+      }));
+    }
+    async function reloadExternalSkills() {
+      const skills = [];
+      const skillIds = new Set();
+      const cursors = new Set();
+      let cursor = null;
+      for (let page = 0; page < 100; page += 1) {
+        const result = await api('/api/skills?limit=200' + (cursor === null ? '' : '&cursor=' + encodeURIComponent(cursor)));
+        if (!result || typeof result !== 'object' || Array.isArray(result)
+          || Object.keys(result).length !== 5
+          || result.untrusted !== true
+          || !Array.isArray(result.skills) || result.skills.length > 200
+          || !Number.isSafeInteger(result.count) || result.count !== result.skills.length
+          || typeof result.truncated !== 'boolean'
+          || result.nextCursor !== null && typeof result.nextCursor !== 'string') throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+        if (skills.length + result.skills.length > 20_000) throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+        for (const skill of result.skills) {
+          if (!validExternalSkillListItem(skill) || skillIds.has(skill.skillId)) throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+          skillIds.add(skill.skillId); skills.push(skill);
+        }
+        if (!result.truncated) {
+          if (result.nextCursor !== null) throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+          state.externalSkills = skills;
+          renderExternalSkills();
+          return;
+        }
+        if (result.skills.length === 0 || typeof result.nextCursor !== 'string' || result.nextCursor.length === 0 || cursors.has(result.nextCursor)) throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+        cursors.add(result.nextCursor); cursor = result.nextCursor;
+      }
+      throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+    }
+    function externalSkillDetail(result, expectedSkillId) {
+      if (!result || typeof result !== 'object' || Array.isArray(result)
+        || Object.keys(result).length !== 4 || result.untrusted !== true
+        || !validExternalSkillListItem(result.skill) || result.skill.skillId !== expectedSkillId
+        || !Array.isArray(result.entries) || result.entries.length > 200
+        || typeof result.entriesTruncated !== 'boolean'
+        || result.entriesTruncated && result.entries.length !== 200
+        || result.skill.sourceCommit === null && result.entries.length !== 0) return null;
+      const entryIds = new Set(); const mappingIds = new Set();
+      for (const entry of result.entries) {
+        const mappingId = validExternalSkillEntrySummary(entry) ? entry.sourcePath + '\u0000' + entry.chunkIndex : null;
+        if (mappingId === null || entryIds.has(entry.entryId) || mappingIds.has(mappingId)) return null;
+        entryIds.add(entry.entryId); mappingIds.add(mappingId);
+      }
+      return { skill: result.skill, entries: result.entries, entriesTruncated: result.entriesTruncated };
+    }
+    async function reloadExternalSkill(skillId) {
+      const detail = externalSkillDetail(await api('/api/skills/' + encodeURIComponent(skillId)), skillId);
+      if (detail === null) throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+      const index = state.externalSkills.findIndex((skill) => skill.skillId === skillId);
+      if (index < 0) throw apiError({ error: { code: 'INVALID_RESPONSE', message: t('requestFailed') } });
+      state.externalSkills[index] = detail.skill;
+      renderExternalSkills();
+    }
+    async function externalSkillAction(skillId, action, confirmed = false) {
+      if (state.externalSkillsBusy) return;
+      if (action === 'disable' && !confirmed) { state.externalSkillsPendingDisable = skillId; renderExternalSkills(); requestAnimationFrame(() => externalSkillButton('data-external-skill-confirm', skillId)?.focus()); return; }
+      state.externalSkillsPendingDisable = null;
+      state.externalSkillsBusy = true;
+      $('external-skills-refresh').disabled = true;
+      $('external-skills-panel').setAttribute('aria-busy', 'true');
+      setExternalSkillsStatus(action === 'refresh' ? t('externalSkillsRefreshing') : t('externalSkillsLoading'));
+      renderExternalSkills();
+      try {
+        let actionError = null;
+        try {
+          await api('/api/skills/' + encodeURIComponent(skillId) + '/' + action, { method: 'POST' });
+        } catch (error) {
+          actionError = error;
+        }
+        let reloadError = null;
+        try {
+          await reloadExternalSkill(skillId);
+        } catch (error) {
+          reloadError = error;
+        }
+        if (reloadError) {
+          state.externalSkills = [];
+          state.externalSkillsPendingDisable = null;
+        }
+        if (actionError) {
+          const reloadFailure = reloadError ? ' / ' + apiErrorText(reloadError) : '';
+          setExternalSkillsStatus(apiErrorText(actionError) + reloadFailure, true);
+        } else if (reloadError) {
+          setExternalSkillsStatus(apiErrorText(reloadError), true);
+        } else {
+          setExternalSkillsStatus(t(action === 'disable' ? 'externalSkillsDisabled' : action === 'enable' ? 'externalSkillsEnabled' : 'externalSkillsRefreshed'));
+        }
+      } finally {
+        state.externalSkillsBusy = false;
+        $('external-skills-refresh').disabled = false;
+        $('external-skills-panel').removeAttribute('aria-busy');
+        renderExternalSkills();
+        requestAnimationFrame(() => externalSkillButton(action === 'refresh' ? 'data-external-skill-refresh' : 'data-external-skill-toggle', skillId)?.focus());
+      }
+    }
+    async function loadExternalSkills(open = true) {
+      if (state.externalSkillsBusy) return;
+      if (open) openExternalSkills();
+      state.externalSkills = [];
+      state.externalSkillsPendingDisable = null;
+      state.externalSkillsBusy = true;
+      $('external-skills-refresh').disabled = true;
+      renderExternalSkills();
+      setExternalSkillsStatus(t('externalSkillsLoading'));
+      $('external-skills-panel').setAttribute('aria-busy', 'true');
+      try {
+        await reloadExternalSkills();
+        setExternalSkillsStatus('');
+      } catch (error) {
+        setExternalSkillsStatus(t('externalSkillsOffline') + ' ' + apiErrorText(error), true);
+      } finally {
+        $('external-skills-panel').removeAttribute('aria-busy');
+        state.externalSkillsBusy = false;
+        $('external-skills-refresh').disabled = false;
+        renderExternalSkills();
+      }
+    }
+
     function filterButton(key, label, count, active, onClick) {
         const button = document.createElement('button');
         button.type = 'button';
@@ -862,13 +1234,17 @@ export const WEB_HTML = String.raw `<!doctype html>
     });
     document.addEventListener('click', (event) => { if (!$('language-picker')?.contains(event.target)) setLanguageMenuOpen(false); });
     document.addEventListener('focusin', (event) => { if (!$('language-picker')?.contains(event.target)) setLanguageMenuOpen(false); });
-    $('workspace').addEventListener('change', (event) => { if (state.curatorOpen) closeCurator(); state.workspace = event.target.value; state.selected = null; state.selectedRecall = null; state.selectedRun = null; state.runs = []; state.tag = ''; state.curatorCandidates = []; state.curatorGlobalized = new Set(); state.curatorNextCursor = null; state.curatorTotalApproximate = 0; state.curatorOpen = false; loadTags().then(loadEntries).then(loadRuns); });
+    $('workspace').addEventListener('change', (event) => { if (state.curatorOpen) closeCurator(); if (state.externalSkillsOpen) closeExternalSkills(); state.workspace = event.target.value; state.selected = null; state.selectedRecall = null; state.selectedRun = null; state.runs = []; state.tag = ''; state.curatorCandidates = []; state.curatorGlobalized = new Set(); state.curatorNextCursor = null; state.curatorTotalApproximate = 0; state.curatorOpen = false; loadTags().then(loadEntries).then(loadRuns); });
     $('curator-button').addEventListener('click', () => loadCurator());
     $('curator-close').addEventListener('click', () => closeCurator());
+    $('external-skills-button').addEventListener('click', () => loadExternalSkills());
+    $('external-skills-close').addEventListener('click', () => closeExternalSkills());
+    $('external-skills-refresh').addEventListener('click', () => loadExternalSkills(false));
     $('curator-confirm-cancel').addEventListener('click', () => closeCuratorConfirmation());
     $('curator-confirm-submit').addEventListener('click', () => globalizePendingCurator());
     $('curator-confirm-modal').addEventListener('keydown', handleCuratorConfirmationKeydown);
     $('curator-modal').addEventListener('keydown', handleCuratorKeydown);
+    $('external-skills-modal').addEventListener('keydown', handleExternalSkillsKeydown);
     window.addEventListener('popstate', () => { restoreCuratorUrl(); if (state.curatorOpen) loadCurator(); });
     $('refresh').addEventListener('click', () => loadWorkspaces());
     let searchTimer; $('search').addEventListener('input', (event) => { clearTimeout(searchTimer); state.query = event.target.value.trim(); searchTimer = setTimeout(() => loadEntries(), 180); });

package/dist/web/ui.js.map

@@ -1 +1 @@
-{"version":3,"file":"ui.js","sourceRoot":"","sources":["../../src/web/ui.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE7F,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC;IACrC,aAAa,EAAE,kBAAkB;IACjC,YAAY,EAAE,iBAAiB;IAC/B,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,YAAY;CACvB,CAAC;KACC,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;KAC1B,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;KAC1B,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;KAC1B,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC;KAC/B,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAEnC,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAqOf,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6nB1B,CAAC"}
+{"version":3,"file":"ui.js","sourceRoot":"","sources":["../../src/web/ui.ts"],"names":[],"mappings":"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"}

package/migrations/009_external_skill_discovery.sql

@@ -0,0 +1,126 @@
+CREATE TABLE external_skill_generation_clock (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    value INTEGER NOT NULL CHECK (typeof(value) = 'integer' AND value BETWEEN 0 AND 9007199254740991)
+);
+
+INSERT INTO external_skill_generation_clock (singleton, value) VALUES (1, 0);
+
+CREATE TABLE external_skill_generation_tokens (
+    generation INTEGER PRIMARY KEY AUTOINCREMENT
+        CHECK (typeof(generation) = 'integer' AND generation BETWEEN 1 AND 9007199254740991)
+);
+
+CREATE TABLE external_skills (
+    skill_id TEXT PRIMARY KEY,
+    generation INTEGER NOT NULL REFERENCES external_skill_generation_tokens(generation)
+        CHECK (typeof(generation) = 'integer' AND generation BETWEEN 1 AND 9007199254740991),
+    provider TEXT NOT NULL,
+    source_type TEXT NOT NULL CHECK (source_type = 'github'),
+    source_locator TEXT NOT NULL,
+    slug TEXT NOT NULL,
+    name TEXT NOT NULL,
+    install_url TEXT,
+    official_status TEXT NOT NULL CHECK (official_status IN ('curated', 'catalog-verified', 'owner-verified', 'registry-only', 'unknown')),
+    duplicate INTEGER NOT NULL DEFAULT 0 CHECK (duplicate IN (0, 1)),
+    installs INTEGER NOT NULL DEFAULT 0 CHECK (installs >= 0),
+    state TEXT NOT NULL CHECK (state IN ('discovered', 'imported', 'blocked', 'stale', 'disabled')),
+    source_workspace TEXT NOT NULL,
+    source_commit TEXT,
+    snapshot_hash TEXT,
+    metadata_json TEXT NOT NULL DEFAULT '{}',
+    first_seen_at TEXT NOT NULL,
+    last_seen_at TEXT NOT NULL,
+    last_checked_at TEXT NOT NULL,
+    disabled_at TEXT,
+    UNIQUE(generation),
+    UNIQUE(source_type, source_locator, slug)
+);
+
+CREATE INDEX idx_external_skills_state_checked ON external_skills(state, last_checked_at DESC);
+CREATE INDEX idx_external_skills_source ON external_skills(source_locator, slug);
+
+CREATE TABLE external_skill_entries (
+    skill_id TEXT NOT NULL REFERENCES external_skills(skill_id) ON DELETE CASCADE,
+    source_path TEXT NOT NULL,
+    chunk_index INTEGER NOT NULL CHECK (chunk_index >= 0),
+    entry_id TEXT NOT NULL REFERENCES entries(id),
+    entry_revision INTEGER NOT NULL CHECK (entry_revision > 0),
+    content_hash TEXT NOT NULL,
+    primary_document INTEGER NOT NULL DEFAULT 0 CHECK (primary_document IN (0, 1)),
+    active INTEGER NOT NULL DEFAULT 1 CHECK (active IN (0, 1)),
+    imported_at TEXT NOT NULL,
+    PRIMARY KEY(skill_id, source_path, chunk_index),
+    FOREIGN KEY(entry_id, entry_revision) REFERENCES entry_revisions(entry_id, revision)
+);
+
+CREATE INDEX idx_external_skill_entries_entry ON external_skill_entries(entry_id, entry_revision);
+
+CREATE TABLE skill_discovery_cache (
+    cache_key TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    query_text TEXT NOT NULL,
+    owner TEXT,
+    mode TEXT NOT NULL CHECK (mode IN ('official', 'community')),
+    outcome TEXT NOT NULL CHECK (outcome IN ('success', 'empty', 'rate_limited', 'unavailable')),
+    response_json TEXT NOT NULL,
+    fetched_at TEXT NOT NULL,
+    expires_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_skill_discovery_cache_expiry ON skill_discovery_cache(expires_at);
+
+CREATE TABLE skill_source_failure_cache (
+    cache_key TEXT PRIMARY KEY,
+    source_type TEXT NOT NULL CHECK (source_type = 'github'),
+    source_locator TEXT NOT NULL,
+    slug TEXT NOT NULL,
+    outcome TEXT NOT NULL CHECK (outcome IN ('source_rate_limited', 'source_unavailable')),
+    fetched_at TEXT NOT NULL,
+    expires_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_skill_source_failure_cache_expiry ON skill_source_failure_cache(expires_at);
+
+CREATE TABLE skill_audit_failure_cache (
+    cache_key TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    source_type TEXT NOT NULL CHECK (source_type = 'github'),
+    source_locator TEXT NOT NULL,
+    slug TEXT NOT NULL,
+    outcome TEXT NOT NULL CHECK (outcome IN ('registry_rate_limited', 'registry_unavailable')),
+    fetched_at TEXT NOT NULL,
+    expires_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_skill_audit_failure_cache_expiry ON skill_audit_failure_cache(expires_at);
+
+CREATE TABLE agent_task_skill_discovery_attempts (
+    run_id TEXT PRIMARY KEY REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    request_digest TEXT NOT NULL CHECK (
+        typeof(request_digest) = 'text'
+        AND length(request_digest) = 64
+        AND request_digest NOT GLOB '*[^0-9a-f]*'
+    ),
+    state TEXT NOT NULL CHECK (state IN ('started', 'completed', 'failed')),
+    summary_json TEXT,
+    failure_json TEXT,
+    started_at TEXT NOT NULL CHECK (typeof(started_at) = 'text' AND length(started_at) > 0),
+    finished_at TEXT,
+    CHECK (
+        finished_at IS NULL
+        OR (typeof(finished_at) = 'text' AND length(finished_at) > 0 AND finished_at >= started_at)
+    ),
+    CHECK (
+        (state = 'started' AND summary_json IS NULL AND failure_json IS NULL AND finished_at IS NULL)
+        OR (state = 'completed' AND typeof(summary_json) = 'text' AND failure_json IS NULL AND finished_at IS NOT NULL)
+        OR (state = 'failed' AND summary_json IS NULL AND typeof(failure_json) = 'text' AND finished_at IS NOT NULL)
+    )
+);
+
+-- The application migration operation rewrites every revision preimage and
+-- hash to the single locale-independent canonical representation before it
+-- inserts this singleton. Leaving the row absent is never a supported state.
+CREATE TABLE entry_revision_hash_format (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    algorithm TEXT NOT NULL CHECK (algorithm = 'canonical-json-utf16-tags-v1')
+);