kibi-cli 0.1.6 → 0.2.0

package/dist/commands/sync.js

@@ -42,16 +42,20 @@
       fi
     done
 */
+import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import * as fs from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import * as path from "node:path";
 import fg from "fast-glob";
 import { dump as dumpYAML, load as parseYAML } from "js-yaml";
 import { extractFromManifest } from "../extractors/manifest.js";
-import { extractFromMarkdown, } from "../extractors/markdown.js";
+import { FrontmatterError, extractFromMarkdown, } from "../extractors/markdown.js";
+import { copyFileSync } from "node:fs";
+import { branchErrorToDiagnostic, createDocsNotIndexedDiagnostic, createInvalidAuthoringDiagnostic, createKbMissingDiagnostic, formatSyncSummary, } from "../diagnostics.js";
 import { enrichSymbolCoordinates, } from "../extractors/symbols-coordinator.js";
 import { PrologProcess } from "../prolog.js";
+import { copyCleanSnapshot, getBranchDiagnostic, resolveActiveBranch, resolveDefaultBranch, } from "../utils/branch-resolver.js";
+import { loadSyncConfig } from "../utils/config.js";
 export class SyncError extends Error {
     constructor(message) {
         super(message);
@@ -130,24 +134,117 @@ function writeSyncCache(cachePath, cache) {
     writeFileSync(cachePath, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
+function copySyncCache(livePath, stagingPath) {
+    const liveCachePath = path.join(livePath, "sync-cache.json");
+    const stagingCachePath = path.join(stagingPath, "sync-cache.json");
+    if (existsSync(liveCachePath)) {
+        const cacheContent = readFileSync(liveCachePath, "utf8");
+        writeFileSync(stagingCachePath, cacheContent, "utf8");
+    }
+}
+async function copySchemaToStaging(stagingPath) {
+    const possibleSchemaPaths = [
+        path.resolve(process.cwd(), "node_modules", "kibi-cli", "schema"),
+        path.resolve(process.cwd(), "..", "..", "schema"),
+        path.resolve(import.meta.dirname || __dirname, "..", "..", "schema"),
+        path.resolve(process.cwd(), "packages", "cli", "schema"),
+    ];
+    let schemaSourceDir = null;
+    for (const p of possibleSchemaPaths) {
+        if (existsSync(p)) {
+            schemaSourceDir = p;
+            break;
+        }
+    }
+    if (!schemaSourceDir) {
+        return;
+    }
+    const schemaFiles = await fg("*.pl", {
+        cwd: schemaSourceDir,
+        absolute: false,
+    });
+    const schemaDestDir = path.join(stagingPath, "schema");
+    if (!existsSync(schemaDestDir)) {
+        mkdirSync(schemaDestDir, { recursive: true });
+    }
+    for (const file of schemaFiles) {
+        const sourcePath = path.join(schemaSourceDir, file);
+        const destPath = path.join(schemaDestDir, file);
+        copyFileSync(sourcePath, destPath);
+    }
+}
+async function validateStagingKB(stagingPath) {
+    const prolog = new PrologProcess({ timeout: 60000 });
+    await prolog.start();
+    try {
+        const attachResult = await prolog.query(`kb_attach('${stagingPath}')`);
+        if (!attachResult.success) {
+            console.error(`Failed to attach to staging KB: ${attachResult.error}`);
+            return false;
+        }
+        await prolog.query("kb_detach");
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Validation error: ${message}`);
+        return false;
+    }
+    finally {
+        await prolog.terminate();
+    }
+}
+function atomicPublish(stagingPath, livePath) {
+    const liveParent = path.dirname(livePath);
+    if (!existsSync(liveParent)) {
+        mkdirSync(liveParent, { recursive: true });
+    }
+    if (existsSync(livePath)) {
+        const tempPath = `${livePath}.old.${Date.now()}`;
+        renameSync(livePath, tempPath);
+        renameSync(stagingPath, livePath);
+        rmSync(tempPath, { recursive: true, force: true });
+    }
+    else {
+        renameSync(stagingPath, livePath);
+    }
+}
+function cleanupStaging(stagingPath) {
+    if (existsSync(stagingPath)) {
+        rmSync(stagingPath, { recursive: true, force: true });
+    }
+}
 export async function syncCommand(options = {}) {
     const validateOnly = options.validateOnly ?? false;
-    try {
-        // Detect current branch early (needed for cache and KB paths)
-        let currentBranch = "main";
+    const rebuild = options.rebuild ?? false;
+    const startTime = Date.now();
+    const diagnostics = [];
+    const entityCounts = {};
+    const relationshipCount = 0;
+    let published = false;
+    let currentBranch;
+    const getCurrentCommit = () => {
         try {
-            const { execSync } = await import("node:child_process");
-            const branch = execSync("git branch --show-current", {
+            return execSync("git rev-parse HEAD", {
                 cwd: process.cwd(),
                 encoding: "utf8",
+                timeout: 5000,
+                stdio: ["pipe", "pipe", "pipe"],
             }).trim();
-            if (branch && branch !== "master") {
-                currentBranch = branch;
-            }
         }
         catch {
-            currentBranch = "main";
+            return undefined;
+        }
+    };
+    try {
+        const branchResult = resolveActiveBranch(process.cwd());
+        if ("error" in branchResult) {
+            const diagnostic = branchErrorToDiagnostic(branchResult.code, branchResult.error);
+            diagnostics.push(diagnostic);
+            console.error(getBranchDiagnostic(undefined, branchResult.error));
+            throw new SyncError(`Failed to resolve active branch: ${branchResult.error}`);
         }
+        currentBranch = branchResult.branch;
         if (process.env.KIBI_DEBUG) {
             try {
                 // eslint-disable-next-line no-console
@@ -155,33 +252,8 @@ export async function syncCommand(options = {}) {
             }
             catch { }
         }
-        // Load config (fall back to defaults if missing)
-        const DEFAULT_CONFIG = {
-            paths: {
-                requirements: "requirements/**/*.md",
-                scenarios: "scenarios/**/*.md",
-                tests: "tests/**/*.md",
-                adr: "adr/**/*.md",
-                flags: "flags/**/*.md",
-                events: "events/**/*.md",
-                facts: "facts/**/*.md",
-                symbols: "symbols.yaml",
-            },
-        };
-        const configPath = path.join(process.cwd(), ".kb/config.json");
-        let config;
-        try {
-            const parsed = JSON.parse(readFileSync(configPath, "utf8"));
-            config = {
-                paths: {
-                    ...DEFAULT_CONFIG.paths,
-                    ...(parsed.paths ?? {}),
-                },
-            };
-        }
-        catch {
-            config = DEFAULT_CONFIG;
-        }
+        // Load config using shared loader
+        const config = loadSyncConfig(process.cwd());
         const paths = config.paths;
         // Discover files - construct glob patterns from directory paths
         const normalizeMarkdownPath = (pattern) => {
@@ -213,10 +285,12 @@ export async function syncCommand(options = {}) {
             }
             catch { }
         }
-        const manifestFiles = await fg(paths.symbols, {
-            cwd: process.cwd(),
-            absolute: true,
-        });
+        const manifestFiles = paths.symbols
+            ? await fg(paths.symbols, {
+                cwd: process.cwd(),
+                absolute: true,
+            })
+            : [];
         const sourceFiles = [...markdownFiles, ...manifestFiles].sort();
         // Use branch-specific cache to handle branch isolation correctly
         const cachePath = path.join(process.cwd(), `.kb/branches/${currentBranch}/sync-cache.json`);
@@ -227,6 +301,12 @@ export async function syncCommand(options = {}) {
         const nextSeenAt = {};
         const changedMarkdownFiles = [];
         const changedManifestFiles = [];
+        if (process.env.KIBI_DEBUG) {
+            // eslint-disable-next-line no-console
+            console.log("[kibi-debug] sourceFiles:", sourceFiles);
+            // eslint-disable-next-line no-console
+            console.log("[kibi-debug] syncCache.hashes:", syncCache.hashes);
+        }
         for (const file of sourceFiles) {
             try {
                 const key = toCacheKey(file);
@@ -238,7 +318,12 @@ export async function syncCommand(options = {}) {
                     : nowMs - lastSeenMs > SYNC_CACHE_TTL_MS;
                 nextHashes[key] = hash;
                 nextSeenAt[key] = nowIso;
-                if (expired || syncCache.hashes[key] !== hash || validateOnly) {
+                const isChanged = expired || syncCache.hashes[key] !== hash || validateOnly;
+                if (process.env.KIBI_DEBUG) {
+                    // eslint-disable-next-line no-console
+                    console.log(`[kibi-debug] ${key}: cached=${syncCache.hashes[key]}, current=${hash}, changed=${isChanged}`);
+                }
+                if (isChanged) {
                     if (markdownFiles.includes(file)) {
                         changedMarkdownFiles.push(file);
                     }
@@ -252,6 +337,10 @@ export async function syncCommand(options = {}) {
                 console.warn(`Warning: Failed to hash ${file}: ${message}`);
             }
         }
+        if (process.env.KIBI_DEBUG) {
+            // eslint-disable-next-line no-console
+            console.log("[kibi-debug] changedMarkdownFiles:", changedMarkdownFiles);
+        }
         const results = [];
         const failedCacheKeys = new Set();
         const errors = [];
@@ -261,6 +350,18 @@ export async function syncCommand(options = {}) {
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
+                // Handle INVALID_AUTHORING diagnostics for embedded entities
+                if (error instanceof FrontmatterError &&
+                    error.classification === "Embedded Entity Violation") {
+                    const embeddedTypes = message.includes("scenario") && message.includes("test")
+                        ? ["scenario", "test"]
+                        : message.includes("scenario")
+                            ? ["scenario"]
+                            : message.includes("test")
+                                ? ["test"]
+                                : ["entity"];
+                    diagnostics.push(createInvalidAuthoringDiagnostic(file, embeddedTypes));
+                }
                 if (validateOnly) {
                     errors.push({ file, message });
                 }
@@ -308,7 +409,7 @@ export async function syncCommand(options = {}) {
                 console.warn(`Warning: Failed to refresh symbol coordinates in ${file}: ${message}`);
             }
         }
-        if (results.length === 0) {
+        if (results.length === 0 && !rebuild) {
             const evictedHashes = {};
             const evictedSeenAt = {};
             for (const [key, hash] of Object.entries(nextHashes)) {
@@ -323,193 +424,237 @@ export async function syncCommand(options = {}) {
                 hashes: evictedHashes,
                 seenAt: evictedSeenAt,
             });
-            console.log("✓ Imported 0 entities, 0 relationships");
+            console.log("✓ Imported 0 entities, 0 relationships (no changes)");
             process.exit(0);
         }
-        // Connect to KB
-        const prolog = new PrologProcess({ timeout: 120000 });
-        await prolog.start();
-        const kbPath = path.join(process.cwd(), `.kb/branches/${currentBranch}`);
-        const mainPath = path.join(process.cwd(), ".kb/branches/main");
-        // If branch KB doesn't exist but main does, copy from main (copy-on-write)
-        // Skip for orphan branches (branches with no commits yet)
-        if (!existsSync(kbPath) && existsSync(mainPath)) {
-            const hasCommits = (() => {
-                try {
-                    const { execSync } = require("node:child_process");
-                    execSync("git rev-parse HEAD", { cwd: process.cwd(), stdio: "pipe" });
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            })();
-            if (hasCommits) {
-                fs.cpSync(mainPath, kbPath, { recursive: true });
-                // Remove copied sync cache to avoid cross-branch cache pollution
-                try {
-                    const copiedCache = path.join(kbPath, "sync-cache.json");
-                    if (existsSync(copiedCache)) {
-                        fs.rmSync(copiedCache);
-                    }
-                }
-                catch {
-                    // ignore errors cleaning up cache
-                }
-            }
+        const livePath = path.join(process.cwd(), `.kb/branches/${currentBranch}`);
+        // Check if KB exists (for diagnostic purposes)
+        const kbExists = existsSync(livePath);
+        if (!kbExists && !rebuild) {
+            diagnostics.push(createKbMissingDiagnostic(currentBranch, livePath));
         }
-        const attachResult = await prolog.query(`kb_attach('${kbPath}')`);
-        if (!attachResult.success) {
-            await prolog.terminate();
-            throw new SyncError(`Failed to attach KB: ${attachResult.error || "Unknown error"}`);
-        }
-        // Upsert entities
-        let entityCount = 0;
-        let kbModified = false;
-        const simplePrologAtom = /^[a-z][a-zA-Z0-9_]*$/;
-        const prologAtom = (value) => simplePrologAtom.test(value) ? value : `'${value.replace(/'/g, "''")}'`;
-        for (const { entity } of results) {
-            try {
-                const props = [
-                    `id='${entity.id}'`,
-                    `title="${entity.title.replace(/"/g, '\\"')}"`,
-                    `status=${prologAtom(entity.status)}`,
-                    `created_at="${entity.created_at}"`,
-                    `updated_at="${entity.updated_at}"`,
-                    `source="${entity.source.replace(/"/g, '\\"')}"`,
-                ];
-                if (entity.tags && entity.tags.length > 0) {
-                    const tagsList = entity.tags.map(prologAtom).join(",");
-                    props.push(`tags=[${tagsList}]`);
+        const stagingPath = path.join(process.cwd(), `.kb/branches/${currentBranch}.staging`);
+        cleanupStaging(stagingPath);
+        mkdirSync(stagingPath, { recursive: true });
+        try {
+            if (!rebuild) {
+                const config = loadSyncConfig(process.cwd());
+                const defaultBranchResult = resolveDefaultBranch(process.cwd(), config);
+                const defaultBranch = "branch" in defaultBranchResult ? defaultBranchResult.branch : "main";
+                const defaultBranchPath = path.join(process.cwd(), `.kb/branches/${defaultBranch}`);
+                const sourcePath = existsSync(livePath)
+                    ? livePath
+                    : existsSync(defaultBranchPath) && currentBranch !== defaultBranch
+                        ? defaultBranchPath
+                        : null;
+                if (sourcePath) {
+                    copyCleanSnapshot(sourcePath, stagingPath);
+                    copySyncCache(sourcePath, stagingPath);
                 }
-                if (entity.owner)
-                    props.push(`owner=${prologAtom(entity.owner)}`);
-                if (entity.priority)
-                    props.push(`priority=${prologAtom(entity.priority)}`);
-                if (entity.severity)
-                    props.push(`severity=${prologAtom(entity.severity)}`);
-                if (entity.text_ref)
-                    props.push(`text_ref="${entity.text_ref}"`);
-                const propsList = `[${props.join(", ")}]`;
-                const goal = `kb_assert_entity(${entity.type}, ${propsList})`;
-                const result = await prolog.query(goal);
-                if (result.success) {
-                    entityCount++;
-                    kbModified = true;
+                else {
+                    await copySchemaToStaging(stagingPath);
                 }
             }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.warn(`Warning: Failed to upsert entity ${entity.id}: ${message}`);
+            else {
+                await copySchemaToStaging(stagingPath);
             }
-        }
-        // Build ID lookup map: filename -> entity ID
-        const idLookup = new Map();
-        for (const { entity } of results) {
-            const filename = path.basename(entity.source, ".md");
-            idLookup.set(filename, entity.id);
-            idLookup.set(entity.id, entity.id);
-        }
-        // Assert relationships - two-pass approach to handle targets that don't exist yet
-        let relCount = 0;
-        const failedRelationships = [];
-        // First pass: try all relationships
-        for (const { relationships } of results) {
-            for (const rel of relationships) {
+            const prolog = new PrologProcess({ timeout: 120000 });
+            await prolog.start();
+            const attachResult = await prolog.query(`kb_attach('${stagingPath}')`);
+            if (!attachResult.success) {
+                await prolog.terminate();
+                throw new SyncError(`Failed to attach to staging KB: ${attachResult.error || "Unknown error"}`);
+            }
+            let entityCount = 0;
+            let kbModified = false;
+            // Track entity counts by type
+            for (const { entity } of results) {
+                entityCounts[entity.type] = (entityCounts[entity.type] || 0) + 1;
+            }
+            const simplePrologAtom = /^[a-z][a-zA-Z0-9_]*$/;
+            const prologAtom = (value) => simplePrologAtom.test(value) ? value : `'${value.replace(/'/g, "''")}'`;
+            for (const { entity } of results) {
                 try {
-                    const fromId = idLookup.get(rel.from) || rel.from;
-                    const toId = idLookup.get(rel.to) || rel.to;
-                    const goal = `kb_assert_relationship(${rel.type}, '${fromId}', '${toId}', [])`;
+                    const props = [
+                        `id='${entity.id}'`,
+                        `title="${entity.title.replace(/"/g, '\\"')}"`,
+                        `status=${prologAtom(entity.status)}`,
+                        `created_at="${entity.created_at}"`,
+                        `updated_at="${entity.updated_at}"`,
+                        `source="${entity.source.replace(/"/g, '\\"')}"`,
+                    ];
+                    if (entity.tags && entity.tags.length > 0) {
+                        const tagsList = entity.tags.map(prologAtom).join(",");
+                        props.push(`tags=[${tagsList}]`);
+                    }
+                    if (entity.owner)
+                        props.push(`owner=${prologAtom(entity.owner)}`);
+                    if (entity.priority)
+                        props.push(`priority=${prologAtom(entity.priority)}`);
+                    if (entity.severity)
+                        props.push(`severity=${prologAtom(entity.severity)}`);
+                    if (entity.text_ref)
+                        props.push(`text_ref="${entity.text_ref}"`);
+                    const propsList = `[${props.join(", ")}]`;
+                    const goal = `kb_assert_entity(${entity.type}, ${propsList})`;
                     const result = await prolog.query(goal);
                     if (result.success) {
-                        relCount++;
+                        entityCount++;
                         kbModified = true;
                     }
-                    else {
-                        failedRelationships.push({ rel, fromId, toId, error: result.error || "Unknown error" });
-                    }
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
-                    const fromId = idLookup.get(rel.from) || rel.from;
-                    const toId = idLookup.get(rel.to) || rel.to;
-                    failedRelationships.push({ rel, fromId, toId, error: message });
+                    console.warn(`Warning: Failed to upsert entity ${entity.id}: ${message}`);
                 }
             }
-        }
-        // Second pass: retry failed relationships (targets may have been created in first pass)
-        const retryCount = 3;
-        for (let pass = 0; pass < retryCount && failedRelationships.length > 0; pass++) {
-            const remainingFailed = [];
-            for (const { rel, fromId, toId, error } of failedRelationships) {
-                try {
-                    const goal = `kb_assert_relationship(${rel.type}, '${fromId}', '${toId}', [])`;
-                    const result = await prolog.query(goal);
-                    if (result.success) {
-                        relCount++;
-                        kbModified = true;
+            const idLookup = new Map();
+            for (const { entity } of results) {
+                const filename = path.basename(entity.source, ".md");
+                idLookup.set(filename, entity.id);
+                idLookup.set(entity.id, entity.id);
+            }
+            let relCount = 0;
+            const failedRelationships = [];
+            for (const { relationships } of results) {
+                for (const rel of relationships) {
+                    try {
+                        const fromId = idLookup.get(rel.from) || rel.from;
+                        const toId = idLookup.get(rel.to) || rel.to;
+                        const goal = `kb_assert_relationship(${rel.type}, '${fromId}', '${toId}', [])`;
+                        const result = await prolog.query(goal);
+                        if (result.success) {
+                            relCount++;
+                            kbModified = true;
+                        }
+                        else {
+                            failedRelationships.push({
+                                rel,
+                                fromId,
+                                toId,
+                                error: result.error || "Unknown error",
+                            });
+                        }
                     }
-                    else {
-                        remainingFailed.push({ rel, fromId, toId, error: result.error || "Unknown error" });
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        const fromId = idLookup.get(rel.from) || rel.from;
+                        const toId = idLookup.get(rel.to) || rel.to;
+                        failedRelationships.push({ rel, fromId, toId, error: message });
                     }
                 }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    remainingFailed.push({ rel, fromId, toId, error: message });
+            }
+            const retryCount = 3;
+            for (let pass = 0; pass < retryCount && failedRelationships.length > 0; pass++) {
+                const remainingFailed = [];
+                for (const { rel, fromId, toId } of failedRelationships) {
+                    try {
+                        const goal = `kb_assert_relationship(${rel.type}, '${fromId}', '${toId}', [])`;
+                        const result = await prolog.query(goal);
+                        if (result.success) {
+                            relCount++;
+                            kbModified = true;
+                        }
+                        else {
+                            remainingFailed.push({
+                                rel,
+                                fromId,
+                                toId,
+                                error: result.error || "Unknown error",
+                            });
+                        }
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        remainingFailed.push({ rel, fromId, toId, error: message });
+                    }
                 }
+                failedRelationships.length = 0;
+                failedRelationships.push(...remainingFailed);
             }
-            failedRelationships.length = 0;
-            failedRelationships.push(...remainingFailed);
-        }
-        // Report remaining failed relationships after all passes
-        if (failedRelationships.length > 0) {
-            console.warn(`\nWarning: ${failedRelationships.length} relationship(s) failed to sync:`);
-            const seen = new Set();
-            for (const { rel, fromId, toId, error } of failedRelationships) {
-                const key = `${rel.type}:${fromId}->${toId}`;
-                if (!seen.has(key)) {
-                    seen.add(key);
-                    console.warn(`  - ${rel.type}: ${fromId} -> ${toId}`);
-                    console.warn(`    Error: ${error}`);
+            if (failedRelationships.length > 0) {
+                console.warn(`\nWarning: ${failedRelationships.length} relationship(s) failed to sync:`);
+                const seen = new Set();
+                for (const { rel, fromId, toId, error } of failedRelationships) {
+                    const key = `${rel.type}:${fromId}->${toId}`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        console.warn(`  - ${rel.type}: ${fromId} -> ${toId}`);
+                        console.warn(`    Error: ${error}`);
+                    }
                 }
+                console.warn("\nTip: Ensure target entities exist before creating relationships.");
             }
-            console.warn("\nTip: Ensure target entities exist before creating relationships.");
-        }
-        if (kbModified) {
-            prolog.invalidateCache();
-        }
-        // Save KB and detach
-        await prolog.query("kb_save");
-        await prolog.query("kb_detach");
-        await prolog.terminate();
-        const evictedHashes = {};
-        const evictedSeenAt = {};
-        for (const [key, hash] of Object.entries(nextHashes)) {
-            if (failedCacheKeys.has(key)) {
-                continue;
+            if (kbModified) {
+                prolog.invalidateCache();
+            }
+            await prolog.query("kb_save");
+            await prolog.query("kb_detach");
+            await prolog.terminate();
+            atomicPublish(stagingPath, livePath);
+            const evictedHashes = {};
+            const evictedSeenAt = {};
+            for (const [key, hash] of Object.entries(nextHashes)) {
+                if (failedCacheKeys.has(key)) {
+                    continue;
+                }
+                evictedHashes[key] = hash;
+                evictedSeenAt[key] = nextSeenAt[key] ?? nowIso;
             }
-            evictedHashes[key] = hash;
-            evictedSeenAt[key] = nextSeenAt[key] ?? nowIso;
+            const liveCachePath = path.join(livePath, "sync-cache.json");
+            writeSyncCache(liveCachePath, {
+                version: SYNC_CACHE_VERSION,
+                hashes: evictedHashes,
+                seenAt: evictedSeenAt,
+            });
+            published = true;
+            if (markdownFiles.length > 0 && entityCount < markdownFiles.length) {
+                diagnostics.push(createDocsNotIndexedDiagnostic(markdownFiles.length, entityCount));
+            }
+            console.log(`✓ Imported ${entityCount} entities, ${relCount} relationships`);
+            const commit = getCurrentCommit();
+            const summary = {
+                branch: currentBranch,
+                commit,
+                timestamp: new Date().toISOString(),
+                entityCounts,
+                relationshipCount: relCount,
+                success: true,
+                published,
+                failures: diagnostics,
+                durationMs: Date.now() - startTime,
+            };
+            console.log(formatSyncSummary(summary));
+            return summary;
+        }
+        catch (error) {
+            cleanupStaging(stagingPath);
+            throw error;
         }
-        writeSyncCache(cachePath, {
-            version: SYNC_CACHE_VERSION,
-            hashes: evictedHashes,
-            seenAt: evictedSeenAt,
-        });
-        console.log(`✓ Imported ${entityCount} entities, ${relCount} relationships`);
-        process.exit(0);
     }
     catch (error) {
-        if (error instanceof SyncError) {
-            console.error(`Error: ${error.message}`);
-        }
-        else if (error instanceof Error) {
-            console.error(`Error: ${error.message}`);
-        }
-        else {
-            console.error(`Error: ${String(error)}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${errorMessage}`);
+        // Return failure summary
+        const commit = getCurrentCommit();
+        const summary = {
+            branch: currentBranch || "unknown",
+            commit,
+            timestamp: new Date().toISOString(),
+            entityCounts,
+            relationshipCount,
+            success: false,
+            published: false,
+            failures: diagnostics,
+            durationMs: Date.now() - startTime,
+        };
+        if (diagnostics.length > 0) {
+            console.log("\nDiagnostics:");
+            for (const d of diagnostics) {
+                console.log(`  [${d.category}] ${d.severity}: ${d.message}`);
+            }
         }
-        process.exit(1);
+        throw error;
     }
 }
 async function refreshManifestCoordinates(manifestPath, workspaceRoot) {