skillex 0.2.4 → 0.3.0

package/dist/install.js

@@ -36,9 +36,6 @@ export async function initProject(options = {}) {
             lockfile.sources = [toLockfileSource(source)];
         }
         lockfile.settings.autoSync = options.autoSync ?? lockfile.settings.autoSync;
-        if (lockfile.settings.autoSync && !lockfile.adapters.active) {
-            throw new InstallError("Auto-sync requires an active adapter. Use --adapter <id> or run in a detectable workspace.", "AUTO_SYNC_REQUIRES_ADAPTER");
-        }
         lockfile.updatedAt = now();
         await writeJson(statePaths.lockfilePath, lockfile);
         // Create .gitignore for the local state directory on first init.
@@ -129,7 +126,8 @@ export async function installSkills(requestedSkillIds, options = {}) {
         const autoSync = await maybeAutoSync(withAgentSkillsDir({
             cwd,
             scope: options.scope,
-            adapter: lockfile.adapters.active,
+            adapters: lockfile.adapters,
+            adapterOverride: options.adapter,
             enabled: lockfile.settings.autoSync,
             now,
             changed: installedSkills.length > 0,
@@ -217,7 +215,8 @@ export async function updateInstalledSkills(requestedSkillIds, options = {}) {
         const autoSync = await maybeAutoSync(withAgentSkillsDir({
             cwd,
             scope: options.scope,
-            adapter: lockfile.adapters.active,
+            adapters: lockfile.adapters,
+            adapterOverride: options.adapter,
             enabled: lockfile.settings.autoSync,
             now,
             changed: updatedSkills.length > 0,
@@ -272,10 +271,13 @@ export async function removeSkills(requestedSkillIds, options = {}) {
         }
         lockfile.updatedAt = now();
         await writeJson(statePaths.lockfilePath, lockfile);
-        const autoSync = await maybeAutoSync(withAgentSkillsDir({
+        const autoSync = await maybeSyncAfterRemove(withAgentSkillsDir({
             cwd,
             scope: options.scope,
-            adapter: lockfile.adapters.active,
+            adapters: lockfile.adapters,
+            adapterOverride: options.adapter,
+            syncHistory: lockfile.syncHistory,
+            legacySync: lockfile.sync,
             enabled: lockfile.settings.autoSync,
             now,
             changed: removedSkills.length > 0,
@@ -312,55 +314,93 @@ export async function syncInstalledSkills(options = {}) {
         }
         const defaultSource = resolveSource(toCatalogSourceInput(options, resolvePrimarySourceOverride(options, existing)));
         const lockfile = normalizeLockfile(existing, defaultSource, now);
-        const adapterId = options.adapter || lockfile.adapters.active;
-        if (!adapterId) {
+        const adapterIds = resolveSyncAdapterIds(lockfile.adapters, options.adapter);
+        if (adapterIds.length === 0) {
             throw new InstallError("No active adapter configured. Run: skillex init --adapter <id> or use --adapter.", "ACTIVE_ADAPTER_MISSING");
         }
         const skills = await loadInstalledSkillDocuments({
             cwd,
             lockfile,
         });
-        const syncResult = await syncAdapterFiles({
-            cwd,
-            scope: statePaths.scope,
-            adapterId,
-            statePaths,
-            skills,
-            previousSkillIds: lockfile.sync?.skillIds || [],
-            ...(options.mode ? { mode: options.mode } : {}),
-            ...(options.dryRun !== undefined ? { dryRun: options.dryRun } : {}),
-        });
+        const syncResults = [];
+        const diffParts = [];
+        for (const adapterId of adapterIds) {
+            const syncResult = await syncAdapterFiles({
+                cwd,
+                scope: statePaths.scope,
+                adapterId,
+                statePaths,
+                skills,
+                previousSkillIds: lockfile.syncHistory[adapterId]?.skillIds || lockfile.sync?.skillIds || [],
+                ...(options.mode ? { mode: options.mode } : {}),
+                ...(options.dryRun !== undefined ? { dryRun: options.dryRun } : {}),
+            });
+            syncResults.push(syncResult);
+            if (syncResult.diff.trim()) {
+                diffParts.push(syncResult.diff.trimEnd());
+            }
+        }
+        const primarySync = syncResults[0];
+        if (!primarySync) {
+            throw new InstallError("No adapter configured for synchronization. Use --adapter <id> or work in a detectable workspace.", "ACTIVE_ADAPTER_MISSING");
+        }
         if (options.dryRun) {
             return {
                 statePaths,
                 sync: {
-                    adapter: syncResult.adapter,
-                    targetPath: syncResult.targetPath,
+                    adapter: primarySync.adapter,
+                    targetPath: primarySync.targetPath,
                 },
+                syncs: syncResults.map((result) => ({
+                    adapter: result.adapter,
+                    targetPath: result.targetPath,
+                    syncMode: result.syncMode,
+                    changed: result.changed,
+                })),
                 skillCount: skills.length,
-                changed: syncResult.changed,
-                diff: syncResult.diff,
+                changed: syncResults.some((result) => result.changed),
+                diff: diffParts.length > 0 ? `${diffParts.join("\n\n")}\n` : "",
                 dryRun: true,
-                syncMode: syncResult.syncMode,
+                syncMode: primarySync.syncMode,
             };
         }
-        lockfile.sync = {
-            adapter: syncResult.adapter,
-            targetPath: syncResult.targetPath,
+        const primaryMetadata = {
+            adapter: primarySync.adapter,
+            targetPath: primarySync.targetPath,
             syncedAt: now(),
             skillIds: skills.map((skill) => skill.id),
         };
-        lockfile.syncMode = syncResult.syncMode;
+        const nextSyncHistory = {
+            ...lockfile.syncHistory,
+            [primarySync.adapter]: primaryMetadata,
+        };
+        for (const syncResult of syncResults.slice(1)) {
+            nextSyncHistory[syncResult.adapter] = {
+                adapter: syncResult.adapter,
+                targetPath: syncResult.targetPath,
+                syncedAt: now(),
+                skillIds: skills.map((skill) => skill.id),
+            };
+        }
+        lockfile.sync = primaryMetadata;
+        lockfile.syncHistory = nextSyncHistory;
+        lockfile.syncMode = primarySync.syncMode;
         lockfile.updatedAt = now();
         await writeJson(statePaths.lockfilePath, lockfile);
         return {
             statePaths,
-            sync: lockfile.sync,
+            sync: primaryMetadata,
+            syncs: syncResults.map((result) => ({
+                adapter: result.adapter,
+                targetPath: result.targetPath,
+                syncMode: result.syncMode,
+                changed: result.changed,
+            })),
             skillCount: skills.length,
-            changed: syncResult.changed,
-            diff: syncResult.diff,
+            changed: syncResults.some((result) => result.changed),
+            diff: diffParts.length > 0 ? `${diffParts.join("\n\n")}\n` : "",
             dryRun: false,
-            syncMode: syncResult.syncMode,
+            syncMode: primarySync.syncMode,
         };
     }
     catch (error) {
@@ -541,9 +581,10 @@ function createBaseLockfile(source, now) {
             detected: [],
         },
         settings: {
-            autoSync: false,
+            autoSync: true,
         },
         sync: null,
+        syncHistory: {},
         syncMode: null,
         installed: {},
     };
@@ -666,13 +707,35 @@ function normalizeLockfile(existing, source, now) {
             detected: [...new Set(detectedAdapters.filter(Boolean))],
         },
         settings: {
-            autoSync: Boolean(existing.settings?.autoSync),
+            autoSync: existing.settings?.autoSync ?? true,
         },
         sync: existing.sync || null,
+        syncHistory: normalizeSyncHistory(existing),
         syncMode: existing.syncMode || null,
         installed: existing.installed || {},
     };
 }
+function normalizeSyncHistory(existing) {
+    const history = {};
+    const candidate = existing && "syncHistory" in existing && existing.syncHistory && typeof existing.syncHistory === "object"
+        ? existing.syncHistory
+        : null;
+    if (candidate) {
+        for (const [adapterId, metadata] of Object.entries(candidate)) {
+            if (!metadata || typeof metadata !== "object") {
+                continue;
+            }
+            if (!("adapter" in metadata) || !("targetPath" in metadata) || !("syncedAt" in metadata)) {
+                continue;
+            }
+            history[adapterId] = metadata;
+        }
+    }
+    if (existing?.sync?.adapter && !history[existing.sync.adapter]) {
+        history[existing.sync.adapter] = existing.sync;
+    }
+    return history;
+}
 /** Repos that are known placeholder values written by older versions and must be ignored. */
 const PLACEHOLDER_REPOS = new Set(["owner/repo"]);
 function getLockfileSources(existing, fallbackSource) {
@@ -835,15 +898,65 @@ async function maybeAutoSync(options) {
     if (!options.enabled || !options.changed) {
         return null;
     }
+    if (resolveSyncAdapterIds(options.adapters, options.adapterOverride).length === 0) {
+        return null;
+    }
     return syncInstalledSkills({
         cwd: options.cwd,
         scope: options.scope || DEFAULT_INSTALL_SCOPE,
         ...(options.agentSkillsDir ? { agentSkillsDir: options.agentSkillsDir } : {}),
-        ...(options.adapter ? { adapter: options.adapter } : {}),
+        ...(options.adapterOverride ? { adapter: options.adapterOverride } : {}),
         ...(options.mode ? { mode: options.mode } : {}),
         now: options.now,
     });
 }
+async function maybeSyncAfterRemove(options) {
+    if (!options.changed) {
+        return null;
+    }
+    const adapters = new Set();
+    for (const adapterId of Object.keys(options.syncHistory || {})) {
+        adapters.add(adapterId);
+    }
+    if (options.legacySync?.adapter) {
+        adapters.add(options.legacySync.adapter);
+    }
+    if (options.adapterOverride) {
+        adapters.add(options.adapterOverride);
+    }
+    else if (options.enabled) {
+        for (const adapterId of resolveSyncAdapterIds(options.adapters)) {
+            adapters.add(adapterId);
+        }
+    }
+    let result = null;
+    for (const adapterId of adapters) {
+        result = await syncInstalledSkills({
+            cwd: options.cwd,
+            scope: options.scope || DEFAULT_INSTALL_SCOPE,
+            ...(options.agentSkillsDir ? { agentSkillsDir: options.agentSkillsDir } : {}),
+            adapter: adapterId,
+            ...(options.mode ? { mode: options.mode } : {}),
+            now: options.now,
+        });
+    }
+    return result;
+}
+function resolveSyncAdapterIds(adapters, adapterOverride) {
+    if (adapterOverride) {
+        return [adapterOverride];
+    }
+    const adapterIds = [];
+    if (adapters.active) {
+        adapterIds.push(adapters.active);
+    }
+    for (const adapterId of adapters.detected || []) {
+        if (!adapterIds.includes(adapterId)) {
+            adapterIds.push(adapterId);
+        }
+    }
+    return adapterIds;
+}
 function toCatalogSourceInput(options, overrides = {}) {
     const input = {};
     if (options.owner) {

package/dist/markdown.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Renders a safe HTML representation for common Markdown constructs used by skills.
+ *
+ * @param markdown - Raw markdown source.
+ * @returns Sanitized HTML string.
+ */
+export declare function renderMarkdownToHtml(markdown: string): string;

package/dist/markdown.js

@@ -0,0 +1,193 @@
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function renderInlineMarkdown(value) {
+    let html = escapeHtml(value);
+    html = html.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, (_match, label, url) => {
+        const safeLabel = escapeHtml(label);
+        const safeUrl = escapeHtml(url);
+        return `<a href="${safeUrl}" target="_blank" rel="noreferrer noopener">${safeLabel}</a>`;
+    });
+    html = html.replace(/`([^`]+)`/g, (_match, code) => `<code>${escapeHtml(code)}</code>`);
+    html = html.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+    html = html.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+    return html;
+}
+function flushParagraph(paragraph, html) {
+    if (paragraph.length === 0) {
+        return;
+    }
+    html.push(`<p>${paragraph.map((line) => renderInlineMarkdown(line)).join("<br>")}</p>`);
+    paragraph.length = 0;
+}
+function closeList(currentList, html) {
+    if (currentList.type) {
+        html.push(`</${currentList.type}>`);
+        currentList.type = null;
+    }
+}
+function isTableSeparator(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || !trimmed.endsWith("|")) {
+        return false;
+    }
+    return trimmed
+        .slice(1, -1)
+        .split("|")
+        .every((cell) => /^:?-{3,}:?$/.test(cell.trim()));
+}
+function splitTableRow(line) {
+    return line
+        .trim()
+        .slice(1, -1)
+        .split("|")
+        .map((cell) => renderInlineMarkdown(cell.trim()));
+}
+function consumeTable(lines, startIndex) {
+    const headerLine = lines[startIndex]?.trim();
+    const separatorLine = lines[startIndex + 1]?.trim();
+    if (!headerLine || !separatorLine || !headerLine.startsWith("|") || !headerLine.endsWith("|") || !isTableSeparator(separatorLine)) {
+        return null;
+    }
+    const headers = splitTableRow(headerLine);
+    const rows = [];
+    let index = startIndex + 2;
+    while (index < lines.length) {
+        const candidate = lines[index]?.trim();
+        if (!candidate || !candidate.startsWith("|") || !candidate.endsWith("|")) {
+            break;
+        }
+        rows.push(splitTableRow(candidate));
+        index += 1;
+    }
+    const html = [
+        "<div class=\"markdown-table-wrap\">",
+        "<table>",
+        "<thead>",
+        "<tr>",
+        ...headers.map((header) => `<th>${header}</th>`),
+        "</tr>",
+        "</thead>",
+        "<tbody>",
+        ...rows.map((row) => `<tr>${row.map((cell) => `<td>${cell}</td>`).join("")}</tr>`),
+        "</tbody>",
+        "</table>",
+        "</div>",
+    ].join("");
+    return {
+        html,
+        nextIndex: index - 1,
+    };
+}
+/**
+ * Renders a safe HTML representation for common Markdown constructs used by skills.
+ *
+ * @param markdown - Raw markdown source.
+ * @returns Sanitized HTML string.
+ */
+export function renderMarkdownToHtml(markdown) {
+    const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+    const html = [];
+    const paragraph = [];
+    const currentList = { type: null };
+    let inCodeFence = false;
+    let codeFenceLanguage = "";
+    const codeFenceLines = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const trimmed = line.trim();
+        if (trimmed.startsWith("```")) {
+            flushParagraph(paragraph, html);
+            closeList(currentList, html);
+            if (inCodeFence) {
+                const languageClass = codeFenceLanguage ? ` class="language-${escapeHtml(codeFenceLanguage)}"` : "";
+                html.push(`<pre><code${languageClass}>${escapeHtml(codeFenceLines.join("\n"))}</code></pre>`);
+                codeFenceLines.length = 0;
+                codeFenceLanguage = "";
+                inCodeFence = false;
+            }
+            else {
+                inCodeFence = true;
+                codeFenceLanguage = trimmed.slice(3).trim();
+            }
+            continue;
+        }
+        if (inCodeFence) {
+            codeFenceLines.push(line);
+            continue;
+        }
+        const table = consumeTable(lines, index);
+        if (table) {
+            flushParagraph(paragraph, html);
+            closeList(currentList, html);
+            html.push(table.html);
+            index = table.nextIndex;
+            continue;
+        }
+        if (!trimmed) {
+            flushParagraph(paragraph, html);
+            closeList(currentList, html);
+            continue;
+        }
+        const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            flushParagraph(paragraph, html);
+            closeList(currentList, html);
+            const level = headingMatch[1]?.length ?? 1;
+            html.push(`<h${level}>${renderInlineMarkdown(headingMatch[2] ?? "")}</h${level}>`);
+            continue;
+        }
+        const unorderedMatch = trimmed.match(/^[-*+]\s+(.+)$/);
+        if (unorderedMatch) {
+            flushParagraph(paragraph, html);
+            if (currentList.type !== "ul") {
+                closeList(currentList, html);
+                currentList.type = "ul";
+                html.push("<ul>");
+            }
+            html.push(`<li>${renderInlineMarkdown(unorderedMatch[1] ?? "")}</li>`);
+            continue;
+        }
+        const orderedMatch = trimmed.match(/^\d+\.\s+(.+)$/);
+        if (orderedMatch) {
+            flushParagraph(paragraph, html);
+            if (currentList.type !== "ol") {
+                closeList(currentList, html);
+                currentList.type = "ol";
+                html.push("<ol>");
+            }
+            html.push(`<li>${renderInlineMarkdown(orderedMatch[1] ?? "")}</li>`);
+            continue;
+        }
+        const quoteMatch = trimmed.match(/^>\s?(.*)$/);
+        if (quoteMatch) {
+            flushParagraph(paragraph, html);
+            closeList(currentList, html);
+            const quoteLines = [renderInlineMarkdown(quoteMatch[1] ?? "")];
+            while (index + 1 < lines.length) {
+                const next = lines[index + 1]?.trim() ?? "";
+                const nextQuote = next.match(/^>\s?(.*)$/);
+                if (!nextQuote) {
+                    break;
+                }
+                quoteLines.push(renderInlineMarkdown(nextQuote[1] ?? ""));
+                index += 1;
+            }
+            html.push(`<blockquote><p>${quoteLines.join("<br>")}</p></blockquote>`);
+            continue;
+        }
+        paragraph.push(trimmed);
+    }
+    if (inCodeFence) {
+        const languageClass = codeFenceLanguage ? ` class="language-${escapeHtml(codeFenceLanguage)}"` : "";
+        html.push(`<pre><code${languageClass}>${escapeHtml(codeFenceLines.join("\n"))}</code></pre>`);
+    }
+    flushParagraph(paragraph, html);
+    closeList(currentList, html);
+    return html.join("\n");
+}

package/dist/sync.js

@@ -51,7 +51,16 @@ export async function syncAdapterFiles(options) {
     try {
         const prepared = await prepareSyncAdapterFiles(options);
         if (!options.dryRun) {
-            if (prepared.directoryEntries) {
+            if (prepared.removeTarget) {
+                if (prepared.generatedSourcePath) {
+                    await removePath(prepared.generatedSourcePath);
+                }
+                await removePath(prepared.absoluteTargetPath);
+                for (const cleanupPath of prepared.cleanupPaths) {
+                    await removePath(cleanupPath);
+                }
+            }
+            else if (prepared.directoryEntries) {
                 await ensureDir(prepared.absoluteTargetPath);
                 const createLink = options.linkFactory || createSymlink;
                 let finalMode = prepared.syncMode;
@@ -144,8 +153,28 @@ export async function prepareSyncAdapterFiles(options) {
     const autoInjectBlock = buildAutoInjectBlock(options.skills);
     if (adapter.syncMode === "managed-block") {
         const existing = (await readText(absoluteTargetPath, "")) || "";
-        const nextManaged = upsertManagedBlock(existing, wrapManagedBlock(MANAGED_START, MANAGED_END, body));
-        const nextContent = upsertAutoInjectBlock(nextManaged, autoInjectBlock);
+        const nextManaged = options.skills.length === 0
+            ? upsertManagedBlock(existing, null)
+            : upsertManagedBlock(existing, wrapManagedBlock(MANAGED_START, MANAGED_END, body));
+        const nextContent = upsertAutoInjectBlock(nextManaged, options.skills.length === 0 ? null : autoInjectBlock);
+        if (nextContent === "") {
+            return {
+                adapter: adapter.id,
+                absoluteTargetPath,
+                targetPath,
+                cleanupPaths,
+                removeTarget: true,
+                changed: Boolean(normalizeComparableText(existing)) || cleanupPaths.length > 0,
+                currentContent: existing,
+                nextContent: "",
+                diff: createManagedBlockRemovalDiff({
+                    targetPath,
+                    currentContent: existing,
+                    cleanupPaths: cleanupPaths.map((cleanupPath) => toDisplayPath(options.cwd, cleanupPath, options.statePaths.scope)),
+                }),
+                syncMode: "copy",
+            };
+        }
         return {
             adapter: adapter.id,
             absoluteTargetPath,
@@ -160,6 +189,35 @@ export async function prepareSyncAdapterFiles(options) {
     }
     const nextContent = buildManagedFileContent(adapter.id, body, autoInjectBlock);
     const requestedMode = options.mode || "symlink";
+    const generatedSourcePath = path.join(options.statePaths.generatedDirPath, adapter.id, path.basename(adapter.syncTarget));
+    if (options.skills.length === 0) {
+        const currentDescriptor = await describeTarget(absoluteTargetPath);
+        const currentVisibleContent = (await readText(absoluteTargetPath, "")) || "";
+        const generatedExists = await pathExists(generatedSourcePath);
+        return {
+            adapter: adapter.id,
+            absoluteTargetPath,
+            targetPath,
+            cleanupPaths,
+            removeTarget: true,
+            changed: Boolean(normalizeComparableText(currentDescriptor)) ||
+                Boolean(normalizeComparableText(currentVisibleContent)) ||
+                generatedExists ||
+                cleanupPaths.length > 0,
+            currentContent: currentDescriptor,
+            nextContent: "",
+            diff: createManagedFileRemovalDiff({
+                targetPath,
+                generatedPath: toDisplayPath(options.cwd, generatedSourcePath, options.statePaths.scope),
+                generatedExists,
+                currentDescriptor,
+                currentContent: currentVisibleContent,
+                cleanupPaths: cleanupPaths.map((cleanupPath) => toDisplayPath(options.cwd, cleanupPath, options.statePaths.scope)),
+            }),
+            syncMode: requestedMode,
+            generatedSourcePath,
+        };
+    }
     if (requestedMode === "copy") {
         const existing = (await readText(absoluteTargetPath, "")) || "";
         return {
@@ -174,7 +232,6 @@ export async function prepareSyncAdapterFiles(options) {
             syncMode: "copy",
         };
     }
-    const generatedSourcePath = path.join(options.statePaths.generatedDirPath, adapter.id, path.basename(adapter.syncTarget));
     const currentDescriptor = await describeTarget(absoluteTargetPath);
     const currentVisibleContent = (await readText(absoluteTargetPath, "")) || "";
     const nextDescriptor = `symlink -> ${toPosix(path.relative(path.dirname(absoluteTargetPath), generatedSourcePath))}\n`;
@@ -437,6 +494,35 @@ function createManagedFileDiff(context) {
     }
     return `${parts.join("\n")}\n`;
 }
+function createManagedBlockRemovalDiff(context) {
+    const parts = [];
+    if (normalizeComparableText(context.currentContent) !== "") {
+        parts.push(createTextDiff(context.currentContent, "", context.targetPath).trimEnd());
+    }
+    for (const cleanupPath of context.cleanupPaths) {
+        parts.push(`- remove ${cleanupPath}`);
+    }
+    if (parts.length === 0) {
+        return `Sem alteracoes em ${context.targetPath}.\n`;
+    }
+    return `${parts.join("\n")}\n`;
+}
+function createManagedFileRemovalDiff(context) {
+    const parts = [];
+    if (normalizeComparableText(context.currentDescriptor) !== "") {
+        parts.push(createTextDiff(context.currentDescriptor, "", context.targetPath).trimEnd());
+    }
+    if (normalizeComparableText(context.currentContent) !== "") {
+        parts.push(createTextDiff(context.currentContent, "", context.targetPath).trimEnd());
+    }
+    if (context.generatedExists) {
+        parts.push(`- remove ${context.generatedPath}`);
+    }
+    for (const cleanupPath of context.cleanupPaths) {
+        parts.push(`- remove ${cleanupPath}`);
+    }
+    return `${parts.join("\n")}\n`;
+}
 function createTextDiff(currentContent, nextContent, targetPath) {
     if (normalizeComparableText(currentContent) === normalizeComparableText(nextContent)) {
         return `Sem alteracoes em ${targetPath}.\n`;

package/dist/types.d.ts

@@ -172,6 +172,10 @@ export interface SyncMetadata {
     syncedAt: string;
     skillIds?: string[] | undefined;
 }
+/**
+ * Per-adapter synchronization metadata persisted in the lockfile.
+ */
+export type SyncHistory = Record<string, SyncMetadata>;
 /**
  * Full workspace lockfile structure.
  */
@@ -183,6 +187,7 @@ export interface LockfileState {
     adapters: LockfileAdapters;
     settings: LockfileSettings;
     sync: SyncMetadata | null;
+    syncHistory: SyncHistory;
     syncMode: SyncWriteMode | null;
     installed: Record<string, InstalledSkillMetadata>;
 }
@@ -263,6 +268,7 @@ export interface PreparedSyncResult {
     absoluteTargetPath: string;
     targetPath: string;
     cleanupPaths: string[];
+    removeTarget?: boolean | undefined;
     changed: boolean;
     currentContent: string;
     nextContent: string;
@@ -291,6 +297,15 @@ export interface SyncPreview {
     before: string;
     after: string;
 }
+/**
+ * Per-adapter sync summary returned to callers.
+ */
+export interface SyncExecutionSummary {
+    adapter: string;
+    targetPath: string;
+    syncMode: SyncWriteMode;
+    changed: boolean;
+}
 /**
  * Public sync result returned after writing or dry-run preparation.
  */
@@ -325,6 +340,7 @@ export interface SyncCommandResult {
         adapter: string;
         targetPath: string;
     } | SyncMetadata;
+    syncs: SyncExecutionSummary[];
     skillCount: number;
     changed: boolean;
     diff: string;