autokap 1.0.7 → 1.0.8

package/dist/session-profile.js

@@ -29,6 +29,10 @@ const LANGUAGE_ALIASES = {
     tr: ['tr', 'turkish', 'turkce', 'türkçe'],
     zh: ['zh', 'chinese', '中文'],
 };
+const THEME_ALIASES = {
+    light: ['light', 'clair', 'claro', 'chiaro'],
+    dark: ['dark', 'sombre', 'oscuro', 'scuro'],
+};
 function makeDiagnostic(outcome, confidence, reasons) {
     return {
         outcome,
@@ -965,6 +969,44 @@ function languageTerms(requestedLang) {
         return [];
     return LANGUAGE_ALIASES[normalized] ?? [normalized];
 }
+function themeTerms(requestedTheme) {
+    const normalized = requestedTheme.toLowerCase();
+    if (normalized === 'light' || normalized === 'dark') {
+        return THEME_ALIASES[normalized];
+    }
+    return [requestedTheme];
+}
+function variantTerms(kind, target) {
+    return kind === 'locale' ? languageTerms(target) : themeTerms(target);
+}
+function normalizeSearchToken(value) {
+    return value
+        .normalize('NFKD')
+        .replace(/\p{Diacritic}/gu, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function buildVariantSearchQueries(kind, target) {
+    const seen = new Set();
+    return variantTerms(kind, target)
+        .map((term) => term.trim())
+        .filter(Boolean)
+        .sort((left, right) => {
+        const leftShort = normalizeSearchToken(left).length <= 2 ? 1 : 0;
+        const rightShort = normalizeSearchToken(right).length <= 2 ? 1 : 0;
+        if (leftShort !== rightShort)
+            return leftShort - rightShort;
+        return right.length - left.length;
+    })
+        .filter((term) => {
+        const normalized = normalizeSearchToken(term);
+        if (!normalized || seen.has(normalized))
+            return false;
+        seen.add(normalized);
+        return true;
+    });
+}
 function controlMatchesVariant(control, kind, target) {
     if (control.kind !== kind)
         return false;
@@ -983,6 +1025,17 @@ async function applyVariantSelector(browser, selector, params) {
     const probe = await probeSelector(browser, selector);
     if (!probe)
         return false;
+    const probeControl = {
+        kind: params.kind,
+        mechanism: 'button',
+        selector,
+        label: probe.label,
+        value: null,
+        href: probe.href,
+        tag: probe.tag,
+        role: probe.role,
+    };
+    const isDirectTarget = controlMatchesVariant(probeControl, params.kind, params.target);
     if (probe.tag === 'select') {
         const optionLabel = params.kind === 'locale'
             ? languageTerms(params.target)[0] ?? params.target
@@ -1010,7 +1063,8 @@ async function applyVariantSelector(browser, selector, params) {
         await browser.clickBySelector(selector);
         return true;
     }
-    if (LANG_CONTROL_RE.test(`${probe.label} ${selector}`) || THEME_CONTROL_RE.test(`${probe.label} ${selector}`)) {
+    if (!isDirectTarget
+        && (LANG_CONTROL_RE.test(`${probe.label} ${selector}`) || THEME_CONTROL_RE.test(`${probe.label} ${selector}`))) {
         await browser.safeExpand({ selector });
         return true;
     }
@@ -1057,6 +1111,87 @@ async function trySelectorSet(browser, selectors, action, params) {
     }
     return { success: false, validation, updates };
 }
+function scoreVariantSearchResult(result, kind, query) {
+    const normalizedQuery = normalizeSearchToken(query);
+    const normalizedText = normalizeSearchToken(result.text || '');
+    const selector = (result.selector || '').toLowerCase();
+    const tag = (result.tag || '').toLowerCase();
+    const role = (result.role || '').toLowerCase();
+    let score = 0;
+    if (normalizedText === normalizedQuery)
+        score += 10;
+    else if (normalizedText.includes(normalizedQuery))
+        score += 7;
+    else
+        score += 3;
+    if (result.clickable)
+        score += 5;
+    if (result.visibilityState === 'full')
+        score += 4;
+    else if (result.visibilityState === 'partial')
+        score += 3;
+    else if (result.visibilityState === 'offscreen')
+        score += 2;
+    if (['label', 'button', 'input', 'a', 'option'].includes(tag))
+        score += 4;
+    if (['button', 'radio', 'switch', 'link', 'menuitem', 'option'].includes(role))
+        score += 3;
+    if (kind === 'locale' && /\b(lang|locale|language|hreflang)\b/.test(selector))
+        score += 2;
+    if (kind === 'theme' && /\b(theme|appearance|color-scheme|mode)\b/.test(selector))
+        score += 2;
+    return score;
+}
+async function trySearchBasedVariantSet(browser, params) {
+    let validation = await revalidate(browser, params.validationParams);
+    const updates = [];
+    const attemptedSelectors = new Set();
+    for (const query of buildVariantSearchQueries(params.kind, params.target).slice(0, 6)) {
+        let results = [];
+        try {
+            results = await browser.searchText(query);
+        }
+        catch {
+            continue;
+        }
+        const candidates = results
+            .map((result) => ({ result, score: scoreVariantSearchResult(result, params.kind, query) }))
+            .sort((left, right) => right.score - left.score)
+            .slice(0, 5);
+        for (const candidate of candidates) {
+            const selector = candidate.result.selector;
+            if (!selector || attemptedSelectors.has(selector))
+                continue;
+            attemptedSelectors.add(selector);
+            try {
+                await applyVariantSelector(browser, selector, {
+                    kind: params.kind,
+                    target: params.target,
+                });
+                await browser.wait(350);
+                validation = await revalidate(browser, params.validationParams);
+                updates.push({
+                    stepSignature: params.signature,
+                    selector,
+                    source: 'deterministic',
+                    success: validation.validationStatus !== 'invalid',
+                });
+                if (validation.validationStatus === 'valid') {
+                    return { success: true, validation, updates };
+                }
+            }
+            catch {
+                updates.push({
+                    stepSignature: params.signature,
+                    selector,
+                    source: 'deterministic',
+                    success: false,
+                });
+            }
+        }
+    }
+    return { success: false, validation, updates };
+}
 function needsHardLangRepair(validation) {
     return validation.langDiagnostic.outcome === 'mismatch';
 }
@@ -1166,6 +1301,20 @@ export async function performDeterministicSessionRepair(browser, params) {
                 }
             }
         }
+        const langSearchAttempt = await trySearchBasedVariantSet(browser, {
+            kind: 'locale',
+            target: params.requestedLang,
+            signature: `lang:option:${requestedLang}`,
+            validationParams: params,
+        });
+        remember(langSearchAttempt.updates);
+        validation = langSearchAttempt.validation;
+        if (langSearchAttempt.updates.length > 0) {
+            signals = await refreshSignals(signals);
+        }
+        if (validation.validationStatus === 'valid') {
+            return { repaired: true, validation, pathUsed: 'lang_search', updates };
+        }
     }
     // Recapture signals before theme repair — lang repair may have changed the DOM structure,
     // opened/closed menus, or navigated to different settings. Theme variant controls detected
@@ -1222,6 +1371,20 @@ export async function performDeterministicSessionRepair(browser, params) {
                 }
             }
         }
+        const themeSearchAttempt = await trySearchBasedVariantSet(browser, {
+            kind: 'theme',
+            target: params.requestedTheme,
+            signature: `theme:option:${params.requestedTheme}`,
+            validationParams: params,
+        });
+        remember(themeSearchAttempt.updates);
+        validation = themeSearchAttempt.validation;
+        if (themeSearchAttempt.updates.length > 0) {
+            signals = await refreshSignals(signals);
+        }
+        if (validation.validationStatus === 'valid') {
+            return { repaired: true, validation, pathUsed: 'theme_search', updates };
+        }
     }
     if (signals
         && ((params.requestedLang && validation.langMatches !== true)

package/dist/sf-pro-symbols.d.ts

@@ -0,0 +1 @@
+export declare const SF_PRO_SYMBOLS: string;

package/dist/sf-pro-symbols.js

@@ -0,0 +1,55 @@
+// Auto-generated — SF Pro symbol subset as base64 data URI
+// Source: /Library/Fonts/SF-Pro.ttf (subset to required macOS menu bar glyphs)
+export const SF_PRO_SYMBOLS = 'data:font/woff2;base64,d09GMgABAAAAAA8MABIAAAAAJ0gAAA6gAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGyAcNj9IVkFSg' +
+    'Q4/TVZBUoYNBmA/U1RBVIZMJzoAfC+FVAqHCIY0MI1WATYCJAMcCxAABCAFn0QHIBuqJRPueNg4YFjjHTcaGTVZLUKK/yohGzKkN' +
+    '19DhKi7ucMVMRiKiSEKTVQqjzlLvmzbB/eVf93jHBohySwPD+ue79w7M2++6ARxhfQF901qP+0muUEJCnH9/off5t8HVmAj8yjy/' +
+    'QyjsBYGRjUomMgUMZpYVri1i8SKfPAN7vF1VVcg/OHLbAAyhBVAAMXkVqmeYYRfgNf/t9Yq/xaNHxpJ7ez14ULakgnpr8wd6mkRl' +
+    'SEd8UKxEmmD+WDRIkRSxaqhs7mJQmJcqUL/uSiq8umb6qEL2xVqr9Ca8UgQJkJiJBaMQij4h//7fjxdsrZ/wK/YML1P4/KyKMtmO' +
+    '+rN3Aoso+B/M9GnpT0sjAxnXPjkPFPLxuSgj68SomAZs2SLVlYo9cWHBVrpgy7I/IV+YSCjhGYTUOVPwhqJ/0B4irhsMHi5rEww+' +
+    'DB4HDCwhazH0AVwVgV7IAGzYeEVa4GnYKV9LXnb29bNRgPhdWYiXtsNEQq/0CyrAIyQArfvok5tqKkbGCkJCNBCZcqXx90AiCiQO' +
+    '5T7dzCL9bAwfujlVN5g/6MDGLIfyBdh9f35YQdoWO+N789Vqm97U6iKTDa9CO0WoAFQBgCAQFNZ/ba3AQCAFc4ANgCAU7hR8jTWh' +
+    'NwF4MZR5sSpAwKXYeXUgannQIqobr8ZA0uCFBmy5ChSogxHhSo16rTgaSNYRafQkCLTlgdX0PnlroXhlRFkGSuPkQAsLHUYUnBAw' +
+    'JIkTYY8Bc/m5Z4Gzcsfas+++cFKXqpuGUuSpnyfWRhBA7MCQRCE3nVTkv65JGEsS30xOd+/gsGswE47m7x8guLtBSkvhRBqvNQ3W' +
+    'bsoKbFEoiUn9qrIKxkFLMtmxJMKk23s53cClKyYszrID2h/osfq0/+rgvHtMYKAskN1AQOQEFILJbpgAJgC5uDzvDQkB+zclVuMc' +
+    'CEHX0rjIbkw/0/79QgP1mJxsm30yBve9qU//IvgwiDWhF/Qgxdb42TcjQ9RF0MJ2SUpaZ9ByczC3Jln82F+yaYcKySglMR+GP3+X' +
+    'yigIgfWHnpsVTm4TiiFyqG1x6kcrpU6cqS0XY6W5irHahUpcrzUd9+JxrWT2inttHZGO6ud085rF7SLcmntjjePy+W1qqsvypXS3' +
+    'v5VSiv9a5QC5HrppdwoxWk3tVv33V5s7Y52V7un3dceaA/5qfno+ACF4jWooSrt+eyVj3/+eGsqvnaIkvu8t0QfsALbYbVCHxR2A' +
+    'Fbq+hM9KSd0UFZ5UOigG+UpdbDc7TSUBgBKpeBNwZbEGgPxDtpYvA00qL4F3Aq6gOeBB4ggvx2sAhVAn5MBMfytYQgQwmEtxE4xI' +
+    'gyB8Upz9eLCKIzLJuOahClMxjULc5iMiwlhCZPxMSmsAFf0U8IG/iycFnYAoXhRPyPWwh84K+ZeH65NtO/AQsdOLKR1ZqFLVxa6d' +
+    'WehR08WevVmoU9fFvr1Zx8DBnKYPRs3aDBMxg0ZCpPxEzYcsFIYMRK0Afqo0fCyMGYs6OL0ceOhDxMmhtcm0jPCW0hMmsyGzCw2T' +
+    'JnKhmnT2TBjJhuyZ7Eh4o7YwJ7DXQDq+2iHtkQvEO8UeV+pkLKJSqkad4KaKk5ffbpUZSU7qqvDD34Xi8G37IfGQXGYWCy3vaYmW' +
+    'dmmiJoGRFBbK6+Sk7dHvvzVr3n48OYMp/c9DwFxifjxpDtatTtvp706nLsyju3rPiDWugSN9fr67vQw1qFb4O4Xue3PjVLsKzpqG' +
+    'iL51c8yUosIal5Ajrhoe0cPuasXujfUdbVF7OisbaSvoabjvblNXAfqq9sLsNpsVhmyTa642k+XIYczR9cSqUxVbCksp6r1JClaU' +
+    'xR+yEl9l2a6YjnNyodk7eRhzvaNsO8hKAjyasdhLTbZBVt4ZBcE2rjqeuo6rA/Q89Cz8M7KXRvkkphw/e0jOd/vp9GtookB+kS94' +
+    'P9YJEw5J8/RRn4fRk/W3ipbYl+F8z4TVXvTbIjnO8ZETZXNuyQxFlymy6KjjPFeT3YRY588JcY+3oX3vtqcCMefjbkGGcCMvXKCS' +
+    'acfLyqszJgbJ5JA6bndl0qIjY3EkkuXEkHN+y9ti5j2S+4bRFvi9T86kvBncYNDDPfBQKFKdv2ikN5x80YHQygM58YNRkcQzo2bH' +
+    'XSItps3BTn4jBv9yzmtpXU6598/HC18zqkgCF6s0xKu+3vtrpWov19kdfeuyLq/r2m4m7BPZF1ntSUkUDMhqs4p/7F1a6ISIXr/k' +
+    'Mze4sj7yN1+YVtjY538SGSSRbi6cdY7Z3h6OqcT4fYfJOpTNwrepnCflpQk8oiCVUmqf5TqW0jzyPX39+DR50v1IcmzLiARHwXMM' +
+    'JAEapgQAdIBgMf/18jckPoJCPiOlzWEdPYEwH8Tko+RxnCwoT8AeBv4CQp8ABEBYPCP7XL48a/iRXRJWmZxrLu+oWtsbHJmdnZ6Y' +
+    'mxksH9KhsagTaCvoSKNsZJyaho4WVlcjoyUorpapipOuQ2nuv1ODZEL6oQaoWFyB89cH9QE7Eidf2dc0UyUhGqi9rgzJ48dOXr0+' +
+    'Kkz5y9dwbl0AWgnCwT6izLGHpQ0llnU1l7plq1oE758/vrzx/dff+2eX99//Pz+RQT8vsgEYL5paEKgnQ4aNpLGUQiVADiIsVNAg' +
+    '5wrVraCkANDaJWBKkMbESGI0CrFb1KiY2gjIoQQbFX47IZaZ/toszUps0M1WxeacOvbuTabD8fRSps8PxwGDhEhiA1rlYEqQzURI' +
+    'YhIq3RVtp7f38DH1MOB03zAnOXT4FqK2r7Tm2AHHsrhyNmnq5mOquc39rmj5SjvbmEqGq/64sF1v/5FXf+Msk7l+9fPqzpmwBktY' +
+    'yNuy9Hbzz81jcyiNNL06fnto1toaBkfrp+2JshPtIjtmpYJeQJeHf/ifdMg2tfUcsiEQjbdLcLVkKA819vs1junTCDb+0e9wt+eL' +
+    'BJIKP3vEc32gJ0uuo+FtTAr4xSTg5rr9MeLzmgS6suXUrSP9vhfCVzhBzJ44USbnCia5mwXirOatKgcFzjhhR98yBEoto6rGtmZi' +
+    'pHqeOsSxcoFhuEvHKhzXWe/mnv7vDPqijJUN7sduPG9dVafFnoWTX+29dNJN7QUzcB0KXLyk2iZIAZSrys+EffNCgmzfeKq19dPH' +
+    'nC3k9dfV9VPy2qcIjtdX/Xs9DYXtDwpSGw7/QwOnF5tZ2emJw/T7X+rUPjbPg3y/c3sHj2qrB4D3Gian11LM8bBWHXlIxHWa62ev' +
+    'FBS2r7WK4rrBpvtSxs3t+VGeVnK9NX6mX0yll50D9jmquegMrQt6LDystVPn76vHQflkQ5eoeBgqAzjte+fcrl0Zzz0vzm723acf' +
+    'dMP+Dl07pTgO4zflh/WTwolJ+s/PbmwzQUtu3MMt114suz70Doeba0fat+z0ztpO/2sbzu2ibpjwxlcwJuwAL8wWCUePq80LK56c' +
+    'G3PRqU91x4cvfXoczVTnx/dOrpnNhuz74iFe4CGlgmczhcZ4GCsSTzdmsYAN8TE5HX9n9o+3oUbzFVg9M/r589/DKGdqO42QVWD4' +
+    'R/tBltbE3UYElexULtKPATqY151fyjVMgUKA82U9OXRqZY/IoyfibxQS97EjxrKqzA3XijVj0qcaz66nCPWReK8Ls4dDlkWicttu' +
+    'cssL9uVjyuqHgzPr0BvUqCtmhCvZhto4c2usBm2t4WvLQk7dosl2fom2H5RlCdAhUASQdRt/FnusMXxu9e2VCx/G3UEcYUzZ6vtr' +
+    'dsVbjEmnP69G2x3xl57CVon+9loy3GjbevPdI/j2qrJ/MyUyZ9/+GkQi70e/PTw/L89TkvpuXmv//uj03xXlLv5E0n+qYff++dEg' +
+    'AAB6k0M/0Rl+2kZrAwAftWXbsw+ObV9yXlhetUu+ZIPwVPbyV8nyz5fK4fPIcfll/uf1S0yW/B8td9TjSj8lgketOToyf4vBypQx' +
+    'yJKLKE4/K6UOFK9VohSFtgICkIbG6V2nlWYQXZLpcoArh409OLLHYRMzk+wGp4hFAohwZBR4BixjnWM6QaHCUrsZIoYDyezGGLmD' +
+    'GKFBTORWCIpCJWJuKyQdZo1C31gQ1dTbFFSlR1irrOGUcZYi5gbp3XbcXFaz/jJHjVnONApCkfkcuNEtzLQUGorZ6S6y4VJ/eWKW' +
+    'CvcGLUudwbtxYNZs3nS6eO8kPsxb7rdxAelF/jSHRI/lKHxpz5pAhCnVCCZxskpSBwXBZNrPBVCc94JpeTZhgVHOIVGnQj46RIJN' +
+    '0ui6FhBNJmaIoa6LcSSq93E0XTAFB+DuZMwOBKRvRGdha9jILhBEgNPSaazeEzktcZC3BgpjLZYKt29KA1l30lH2gEZTE5BJsKtw' +
+    'WZwIbLoXD4O8u3f2TCe7mQPcXM6cZ47n4tHoeVC87qy+WhB97Ww41rUZS3urJZ0U0s7qGVd0/JOaUV3lN8RFXRBhcGvKOzdGPBuC' +
+    'nU3B7lbwtutge22kHZ7MLsjjN0ZwO4KXXcHrXvC1b2B6r4QdX9weiAsPRiQHgpFDwehR1a/2PDoik9+1QCoWGCJDaa5UL9GxFm2b' +
+    'GwsRLxxJDOr1XthT+JKlyoNT26pzyrC+v98LExmhPJAJAjXBiFYUuVhY+DWh+sb2LbELE3BFNZ4fVNVqlg2W9uzJmKQnVzpxwqn6' +
+    'd65vMt02K9FSsfEkyZQNp50yRhTkdB+cRxFYk3qoqsNsmRPbJiLy0TCsfFwzR09Detb+TI+xEeFSZOO4wt1wOtp/Np7jF9TvIg5T' +
+    '7ZE0tA/66erj8pyJUOEEipZ/SSlz/aMr2mKeD+Fi+fDXbz6XryPIV+RQB+RaRfsrSXLBFr4XBxMLJwAwxgntClCmL4PmBHQkRxh8' +
+    'QlVnjD4hCZPmKKELk6owaAPmBHQFzADMBVFV+WGDJVAfCChtSQJr5KpcJcfFX9hbyD+kt0A590VysZYwHTnki1EUgZJQvQ8wLiAJ' +
+    'CmSwSFr4iS9SVIkSRaXrALjXqDvAcYF9AQMgtn3vtuXf5QMC/z/FQ7ZAwAA';
+//# sourceMappingURL=sf-pro-symbols.js.map

package/dist/skill-packaging.d.ts

@@ -0,0 +1,28 @@
+export type SkillType = 'preset' | 'studio';
+export type SkillAgent = 'claude' | 'codex' | 'cursor' | 'windsurf' | 'copilot';
+export interface SkillPlaceholderOptions {
+    projectUrl?: string;
+    projectId?: string;
+    apiBaseUrl?: string;
+}
+export interface SkillExportResult {
+    mode: 'single-file' | 'bundle';
+    writtenPaths: string[];
+}
+export declare function resolveSkillAssetDir(): Promise<string>;
+export declare function shouldInstallSkillBundle(params: {
+    agent?: string;
+    outputPath?: string;
+    type: SkillType;
+}): boolean;
+export declare function renderSkillSingleFile(params: {
+    type: SkillType;
+    agent?: string;
+    placeholders: SkillPlaceholderOptions;
+}): Promise<string>;
+export declare function writeSkillExport(params: {
+    type: SkillType;
+    agent?: string;
+    outputPath: string;
+    placeholders: SkillPlaceholderOptions;
+}): Promise<SkillExportResult>;

package/dist/skill-packaging.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+function replaceSkillPlaceholders(content, opts) {
+    let result = content;
+    if (opts.projectUrl) {
+        result = result.replace(/\[AUTOKAP_PROJECT_URL\]/g, opts.projectUrl);
+    }
+    if (opts.projectId) {
+        result = result.replace(/\[AUTOKAP_PROJECT_ID\]/g, opts.projectId);
+    }
+    if (opts.apiBaseUrl) {
+        result = result.replace(/https:\/\/autokap\.app/g, opts.apiBaseUrl);
+    }
+    return result;
+}
+const PRESET_SKILL_SOURCE = {
+    coreFile: 'SKILL.md',
+    references: [
+        { relativePath: 'OPCODE-REFERENCE.md', title: 'Opcode Reference', anchor: 'reference-opcode-reference' },
+        { relativePath: 'references/interactive-demo.md', title: 'Interactive Demo Workflow', anchor: 'reference-interactive-demo-workflow' },
+        { relativePath: 'references/mock-data.md', title: 'Mock Data Injection', anchor: 'reference-mock-data-injection' },
+        { relativePath: 'references/examples.md', title: 'Complete Examples', anchor: 'reference-complete-examples' },
+    ],
+};
+const STUDIO_SKILL_SOURCE = {
+    coreFile: 'STUDIO-SKILL.md',
+    references: [],
+};
+function getSkillSourceSpec(type) {
+    return type === 'studio' ? STUDIO_SKILL_SOURCE : PRESET_SKILL_SOURCE;
+}
+async function pathExists(candidate) {
+    try {
+        await fs.access(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getModuleAssetCandidates() {
+    const url = new URL(import.meta.url);
+    const dir = process.platform === 'win32'
+        ? path.dirname(url.pathname.replace(/^\/([A-Za-z]:)/, '$1'))
+        : path.dirname(url.pathname);
+    return [
+        path.resolve(dir, '..', 'assets', 'skill'),
+        path.resolve(dir, '..', '..', 'assets', 'skill'),
+    ];
+}
+export async function resolveSkillAssetDir() {
+    const candidates = [
+        ...getModuleAssetCandidates(),
+        path.join(process.cwd(), 'assets', 'skill'),
+        path.join(process.cwd(), '..', 'assets', 'skill'),
+        path.join(process.cwd(), '..', '..', 'assets', 'skill'),
+    ];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error('Could not find assets/skill. Make sure the autokap package is installed correctly.');
+}
+function inferBundleInstall(outputPath) {
+    if (!outputPath)
+        return false;
+    const normalized = path.normalize(outputPath);
+    const parts = normalized.split(path.sep).filter(Boolean);
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        if (parts[index] === '.agents' && parts[index + 1] === 'skills') {
+            return path.basename(normalized) === 'SKILL.md';
+        }
+    }
+    return false;
+}
+export function shouldInstallSkillBundle(params) {
+    if (params.type === 'studio')
+        return false;
+    if (params.agent?.toLowerCase() === 'codex')
+        return true;
+    return inferBundleInstall(params.outputPath);
+}
+async function readSkillFile(rootDir, relativePath, placeholders) {
+    const absolutePath = path.join(rootDir, relativePath);
+    const raw = await fs.readFile(absolutePath, 'utf-8');
+    return replaceSkillPlaceholders(raw, placeholders);
+}
+function insertAfterFrontmatter(content, inserted) {
+    if (!content.startsWith('---\n')) {
+        return `${inserted.trim()}\n\n${content}`;
+    }
+    const secondFence = content.indexOf('\n---\n', 4);
+    if (secondFence === -1) {
+        return `${inserted.trim()}\n\n${content}`;
+    }
+    const frontmatter = content.slice(0, secondFence + 5);
+    const rest = content.slice(secondFence + 5).replace(/^\n+/, '');
+    return `${frontmatter}\n${inserted.trim()}\n\n${rest}`;
+}
+function stripLeadingTitle(content) {
+    return content.replace(/^# .*\n+/, '').trim();
+}
+function rewriteLinksForSingleFile(content, spec) {
+    let rewritten = content.replace(/\(SKILL\.md\)/g, '(#autokap-preset-creation-skill)');
+    for (const reference of spec.references) {
+        const escapedPath = reference.relativePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        rewritten = rewritten.replace(new RegExp(`\\(${escapedPath}\\)`, 'g'), `(#${reference.anchor})`);
+    }
+    return rewritten;
+}
+export async function renderSkillSingleFile(params) {
+    const rootDir = await resolveSkillAssetDir();
+    const spec = getSkillSourceSpec(params.type);
+    let core = await readSkillFile(rootDir, spec.coreFile, params.placeholders);
+    if (params.type === 'studio') {
+        return core;
+    }
+    core = rewriteLinksForSingleFile(core, spec);
+    core = insertAfterFrontmatter(core, '> Packaging note: the canonical AutoKap preset skill is a modular bundle for Codex (`SKILL.md` + companion reference files). This single-file export is generated from that same source so all agents stay in parity.');
+    const bundledReferences = [];
+    for (const reference of spec.references) {
+        const content = await readSkillFile(rootDir, reference.relativePath, params.placeholders);
+        bundledReferences.push([
+            '---',
+            '',
+            `## Reference: ${reference.title}`,
+            `Source path in the Codex bundle: \`${reference.relativePath}\``,
+            '',
+            rewriteLinksForSingleFile(stripLeadingTitle(content), spec),
+        ].join('\n'));
+    }
+    return [core, ...bundledReferences].join('\n\n');
+}
+export async function writeSkillExport(params) {
+    const rootDir = await resolveSkillAssetDir();
+    const spec = getSkillSourceSpec(params.type);
+    if (shouldInstallSkillBundle({
+        agent: params.agent,
+        outputPath: params.outputPath,
+        type: params.type,
+    })) {
+        const destinationDir = path.dirname(params.outputPath);
+        const writtenPaths = [];
+        for (const relativePath of [spec.coreFile, ...spec.references.map((reference) => reference.relativePath)]) {
+            const absolutePath = path.join(destinationDir, relativePath);
+            const content = await readSkillFile(rootDir, relativePath, params.placeholders);
+            await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+            await fs.writeFile(absolutePath, content, 'utf-8');
+            writtenPaths.push(absolutePath);
+        }
+        return {
+            mode: 'bundle',
+            writtenPaths,
+        };
+    }
+    const content = await renderSkillSingleFile({
+        type: params.type,
+        agent: params.agent,
+        placeholders: params.placeholders,
+    });
+    await fs.mkdir(path.dirname(params.outputPath), { recursive: true });
+    await fs.writeFile(params.outputPath, content, 'utf-8');
+    return {
+        mode: 'single-file',
+        writtenPaths: [params.outputPath],
+    };
+}
+//# sourceMappingURL=skill-packaging.js.map

package/dist/smart-wait.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Capture Agent — Smart Wait
+ *
+ * Detects if the page is still loading before capture.
+ * Uses Playwright-native checks (no LLM) to wait for:
+ * - Network idle
+ * - No visible spinners/skeletons
+ * - DOM stability
+ */
+import type { RuntimeAdapter } from './execution-types.js';
+export interface SmartWaitResult {
+    /** Whether the page appears stable */
+    stable: boolean;
+    /** What we waited for */
+    waitedFor: string[];
+    /** Total time spent waiting (ms) */
+    waitedMs: number;
+}
+/**
+ * Waits for the page to be visually stable before capture.
+ * Checks for common loading patterns and waits for them to resolve.
+ *
+ * This runs BEFORE CAPTURE_SCREENSHOT — deterministic, no LLM.
+ */
+export declare function smartWaitForStability(adapter: RuntimeAdapter, options?: {
+    maxWaitMs?: number;
+}): Promise<SmartWaitResult>;

package/dist/smart-wait.js

@@ -0,0 +1,81 @@
+/**
+ * Capture Agent — Smart Wait
+ *
+ * Detects if the page is still loading before capture.
+ * Uses Playwright-native checks (no LLM) to wait for:
+ * - Network idle
+ * - No visible spinners/skeletons
+ * - DOM stability
+ */
+/**
+ * Waits for the page to be visually stable before capture.
+ * Checks for common loading patterns and waits for them to resolve.
+ *
+ * This runs BEFORE CAPTURE_SCREENSHOT — deterministic, no LLM.
+ */
+export async function smartWaitForStability(adapter, options) {
+    const maxWait = options?.maxWaitMs ?? 10000;
+    const startTime = Date.now();
+    const waitedFor = [];
+    // 1. Wait for no visible spinners/skeletons
+    const spinnerSelectors = [
+        '[class*="spinner"]',
+        '[class*="loading"]',
+        '[class*="skeleton"]',
+        '[class*="shimmer"]',
+        '[role="progressbar"]',
+        '[aria-busy="true"]',
+        '.animate-spin',
+        '.animate-pulse',
+    ];
+    for (const selector of spinnerSelectors) {
+        const elapsed = Date.now() - startTime;
+        if (elapsed >= maxWait)
+            break;
+        try {
+            // Check if spinner exists and is visible
+            const visible = await adapter.waitFor({
+                selector,
+                state: 'visible',
+                timeoutMs: 200, // Quick check
+            });
+            if (visible) {
+                // Spinner found — wait for it to disappear
+                waitedFor.push(selector);
+                const remaining = maxWait - (Date.now() - startTime);
+                if (remaining > 0) {
+                    // Poll until spinner disappears
+                    const deadline = Date.now() + Math.min(remaining, 5000);
+                    while (Date.now() < deadline) {
+                        const stillVisible = await adapter.waitFor({
+                            selector,
+                            state: 'visible',
+                            timeoutMs: 300,
+                        });
+                        if (!stillVisible)
+                            break;
+                        await sleep(300);
+                    }
+                }
+            }
+        }
+        catch {
+            // Selector check failed — skip
+        }
+    }
+    // 2. Brief stability pause (let animations settle)
+    const elapsed = Date.now() - startTime;
+    if (elapsed < maxWait) {
+        await sleep(Math.min(500, maxWait - elapsed));
+        waitedFor.push('stability-pause');
+    }
+    return {
+        stable: true,
+        waitedFor,
+        waitedMs: Date.now() - startTime,
+    };
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=smart-wait.js.map

package/dist/status-bar-render.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Status bar PNG renderer — uses satori (CSS flexbox engine) + resvg for
+ * pixel-perfect parity with the HTML status bar used on the client.
+ *
+ * The layout code mirrors generateStatusBarHtml() from status-bar.ts exactly:
+ * same flex containers, gaps, font sizes, and icon dimensions. satori measures
+ * text widths using the actual SF Pro font metrics (via opentype.js), so
+ * spacing is identical to what a browser produces.
+ *
+ * Fonts are decompressed from woff2 → TTF on first use (wawoff2) and cached.
+ */
+import type { StatusBarRenderOptions } from './status-bar.js';
+/**
+ * Render the status bar to a PNG buffer using satori (CSS flexbox) + resvg.
+ * Produces pixel-perfect output matching the HTML status bar on the client.
+ *
+ * @param options  Same options as generateStatusBarHtml()
+ * @param targetWidth  Physical pixel width for the output PNG (e.g. logical × outputScale)
+ */
+export declare function renderStatusBarBuffer(options: StatusBarRenderOptions, targetWidth: number): Promise<Buffer>;