@voybio/ace-swarm 0.1.0

package/dist/semantic-cache.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Semantic cache — snapshot, persist, and diff agent-state documents
+ * using MinHash signatures for approximate similarity.
+ *
+ * Flow:
+ *   1. takeSnapshot() — hash + sign every tracked file, persist to .tmp/cache/
+ *   2. computeSemanticDelta() — compare two snapshots, emit per-file + per-section deltas
+ *   3. checkDriftBudget() — gate: is the delta within acceptable bounds?
+ *
+ * Integration points:
+ *   • scan_workspace_delta (coarse gate) runs first, flags changed files
+ *   • semantic cache runs only on files flagged changed
+ *   • drift report feeds skeptic/ops via status events
+ */
+export interface MinHashParams {
+    num_permutations: number;
+    shingle_size: number;
+    seed: number;
+}
+export interface FileSignature {
+    content_hash: string;
+    size: number;
+    signature: number[];
+    sections: SectionSignature[];
+}
+export interface SectionSignature {
+    heading: string;
+    line_start: number;
+    line_end: number;
+    content_hash: string;
+    signature: number[];
+}
+export interface SemanticSnapshot {
+    version: 1;
+    snapshot_id: string;
+    timestamp: string;
+    minhash_params: MinHashParams;
+    tracked_dirs: string[];
+    file_count: number;
+    total_size: number;
+    files: Record<string, FileSignature>;
+}
+export type FileChangeStatus = "unchanged" | "modified" | "added" | "deleted";
+export interface SectionChange {
+    heading: string;
+    status: FileChangeStatus;
+    similarity: number;
+    diff_summary?: string;
+}
+export interface FileDelta {
+    status: FileChangeStatus;
+    file_similarity: number;
+    size_before: number;
+    size_after: number;
+    growth_pct: number;
+    section_changes: SectionChange[];
+}
+export interface DriftBudgetConfig {
+    max_growth_pct: number;
+    max_churn_pct: number;
+    max_new_files: number;
+    max_deleted_files: number;
+}
+export interface DriftBudgetResult {
+    passed: boolean;
+    actual_growth_pct: number;
+    actual_churn_pct: number;
+    new_files: number;
+    deleted_files: number;
+    violations: string[];
+}
+export interface SemanticDelta {
+    version: 1;
+    before_snapshot: string;
+    after_snapshot: string;
+    timestamp: string;
+    summary: {
+        unchanged_files: number;
+        modified_files: number;
+        added_files: number;
+        deleted_files: number;
+        total_section_changes: number;
+    };
+    drift_budget?: DriftBudgetResult;
+    files: Record<string, FileDelta>;
+}
+export interface TakeSnapshotInput {
+    snapshot_id: string;
+    tracked_dirs?: string[];
+    shingle_size?: number;
+    num_permutations?: number;
+    seed?: number;
+    /** Only snapshot these specific files (overrides tracked_dirs scan). */
+    files?: string[];
+}
+/**
+ * Snapshot current state of all tracked files into semantic cache.
+ * Computes content hashes + MinHash signatures at file and section level.
+ */
+export declare function takeSnapshot(input: TakeSnapshotInput): SemanticSnapshot;
+export declare function loadSnapshot(snapshotId: string): SemanticSnapshot | undefined;
+export declare function listSnapshots(): string[];
+export interface ComputeDeltaInput {
+    before: string | SemanticSnapshot;
+    after: string | SemanticSnapshot;
+    /** Include surgical token diff for modified sections (more expensive). */
+    include_diffs?: boolean;
+    /** Drift budget config. */
+    drift_budget?: DriftBudgetConfig;
+}
+/**
+ * Compare two snapshots and produce a semantic delta.
+ * For markdown files: section-level alignment via DP.
+ * For all files: file-level MinHash similarity.
+ */
+export declare function computeSemanticDelta(input: ComputeDeltaInput): SemanticDelta;
+/**
+ * Pre-cycle: take a "before" snapshot.
+ * Returns the snapshot ID for use in post-cycle comparison.
+ */
+export declare function preCycleSnapshot(cycleId: string, trackedDirs?: string[]): SemanticSnapshot;
+/**
+ * Post-cycle: take an "after" snapshot and compute the delta.
+ */
+export declare function postCycleSnapshot(cycleId: string, trackedDirs?: string[], driftBudget?: DriftBudgetConfig, includeDiffs?: boolean): {
+    snapshot: SemanticSnapshot;
+    delta: SemanticDelta;
+};
+export interface RewriteTarget {
+    file: string;
+    type: "full" | "section";
+    /** For section targets: heading text for ast-grep/heading search. */
+    heading?: string;
+    /** Line range (0-based) of the affected section. */
+    line_start?: number;
+    line_end?: number;
+    /** Similarity to old version. */
+    similarity: number;
+}
+/**
+ * Extract rewrite targets from a semantic delta.
+ * Returns only modified or added targets — nothing for unchanged/deleted.
+ * For code files: full-file target (use ast-grep node targeting externally).
+ * For markdown: section-level targets with heading/line ranges.
+ */
+export declare function extractRewriteTargets(delta: SemanticDelta): RewriteTarget[];
+//# sourceMappingURL=semantic-cache.d.ts.map

package/dist/semantic-cache.js

@@ -0,0 +1,552 @@
+/**
+ * Semantic cache — snapshot, persist, and diff agent-state documents
+ * using MinHash signatures for approximate similarity.
+ *
+ * Flow:
+ *   1. takeSnapshot() — hash + sign every tracked file, persist to .tmp/cache/
+ *   2. computeSemanticDelta() — compare two snapshots, emit per-file + per-section deltas
+ *   3. checkDriftBudget() — gate: is the delta within acceptable bounds?
+ *
+ * Integration points:
+ *   • scan_workspace_delta (coarse gate) runs first, flags changed files
+ *   • semantic cache runs only on files flagged changed
+ *   • drift report feeds skeptic/ops via status events
+ */
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { MinHash, getShingles, splitMarkdownSections, surgicalTokenDiff, renderDiffSummary, } from "./semantic-hash.js";
+import { WORKSPACE_ROOT, safeRead } from "./helpers.js";
+import { isReadError, normalizeRelPath } from "./shared.js";
+// ────────────────────────────────────────────────────────────────────
+// Constants
+// ────────────────────────────────────────────────────────────────────
+const CACHE_DIR = ".tmp/cache/semantic";
+const DEFAULT_SHINGLE_SIZE = 3;
+const DEFAULT_NUM_PERMUTATIONS = 128;
+const DEFAULT_SEED = 42;
+const DEFAULT_SIMILARITY_THRESHOLD = 0.4;
+/** Tracked directories (workspace-relative). */
+const DEFAULT_TRACKED_DIRS = ["agent-state", "global-state", "engineering-state", "venture-state"];
+/** File extensions to track for semantic cache. */
+const TRACKED_EXTENSIONS = new Set([".md", ".json", ".yaml", ".yml", ".txt"]);
+/** Max file size for semantic hashing (skip huge files). */
+const MAX_FILE_SIZE = 512 * 1024; // 512 KB
+// ────────────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────────────
+function contentHash(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function cacheDir() {
+    const dir = resolve(WORKSPACE_ROOT, CACHE_DIR);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function snapshotPath(snapshotId) {
+    return resolve(cacheDir(), `${snapshotId}.json`);
+}
+function isMarkdown(path) {
+    return path.endsWith(".md");
+}
+function isTrackedFile(name) {
+    const dot = name.lastIndexOf(".");
+    if (dot <= 0)
+        return false;
+    return TRACKED_EXTENSIONS.has(name.slice(dot).toLowerCase());
+}
+/**
+ * Recursively collect tracked files from given directories.
+ * Returns workspace-relative paths.
+ */
+function collectTrackedFiles(dirs, maxDepth = 4) {
+    const files = [];
+    function walk(absDir, relDir, depth) {
+        if (depth > maxDepth || !existsSync(absDir))
+            return;
+        let entries;
+        try {
+            entries = readdirSync(absDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith("."))
+                continue;
+            const entryAbs = resolve(absDir, entry.name);
+            const entryRel = relDir ? `${relDir}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                // Skip known junk dirs
+                if (["node_modules", "dist", ".git", "HANDOFF_HISTORY"].includes(entry.name))
+                    continue;
+                walk(entryAbs, entryRel, depth + 1);
+            }
+            else if (entry.isFile() && isTrackedFile(entry.name)) {
+                try {
+                    const stat = readFileSync(entryAbs);
+                    if (stat.length <= MAX_FILE_SIZE) {
+                        files.push(entryRel);
+                    }
+                }
+                catch {
+                    // skip unreadable
+                }
+            }
+        }
+    }
+    for (const dir of dirs) {
+        const absDir = resolve(WORKSPACE_ROOT, dir);
+        walk(absDir, dir, 0);
+    }
+    return files.sort();
+}
+/**
+ * Snapshot current state of all tracked files into semantic cache.
+ * Computes content hashes + MinHash signatures at file and section level.
+ */
+export function takeSnapshot(input) {
+    const shingleSize = input.shingle_size ?? DEFAULT_SHINGLE_SIZE;
+    const numPerms = input.num_permutations ?? DEFAULT_NUM_PERMUTATIONS;
+    const seed = input.seed ?? DEFAULT_SEED;
+    const trackedDirs = input.tracked_dirs ?? DEFAULT_TRACKED_DIRS;
+    const mh = new MinHash(numPerms, seed);
+    // Collect files
+    const filePaths = input.files ?? collectTrackedFiles(trackedDirs);
+    const fileSignatures = {};
+    let totalSize = 0;
+    for (const relPath of filePaths) {
+        const raw = safeRead(relPath);
+        if (isReadError(raw))
+            continue;
+        const hash = contentHash(raw);
+        const size = Buffer.byteLength(raw, "utf-8");
+        totalSize += size;
+        // File-level signature
+        const fileShingles = getShingles(raw, shingleSize);
+        const fileSig = mh.computeSignature(fileShingles);
+        // Section-level signatures (markdown only)
+        const sections = [];
+        if (isMarkdown(relPath)) {
+            const mdSections = splitMarkdownSections(raw);
+            for (const sec of mdSections) {
+                const secShingles = getShingles(sec.content, shingleSize);
+                sections.push({
+                    heading: sec.heading,
+                    line_start: sec.lineStart,
+                    line_end: sec.lineEnd,
+                    content_hash: contentHash(sec.content),
+                    signature: mh.computeSignature(secShingles),
+                });
+            }
+        }
+        fileSignatures[normalizeRelPath(relPath)] = {
+            content_hash: hash,
+            size,
+            signature: fileSig,
+            sections,
+        };
+    }
+    const snapshot = {
+        version: 1,
+        snapshot_id: input.snapshot_id,
+        timestamp: new Date().toISOString(),
+        minhash_params: {
+            num_permutations: numPerms,
+            shingle_size: shingleSize,
+            seed,
+        },
+        tracked_dirs: trackedDirs,
+        file_count: Object.keys(fileSignatures).length,
+        total_size: totalSize,
+        files: fileSignatures,
+    };
+    // Persist
+    const outPath = snapshotPath(input.snapshot_id);
+    writeFileSync(outPath, JSON.stringify(snapshot, null, 2), "utf-8");
+    return snapshot;
+}
+// ────────────────────────────────────────────────────────────────────
+// Core: Load Snapshot
+// ────────────────────────────────────────────────────────────────────
+export function loadSnapshot(snapshotId) {
+    const path = snapshotPath(snapshotId);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1)
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function listSnapshots() {
+    const dir = cacheDir();
+    try {
+        return readdirSync(dir)
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => f.replace(/\.json$/, ""))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Compare two snapshots and produce a semantic delta.
+ * For markdown files: section-level alignment via DP.
+ * For all files: file-level MinHash similarity.
+ */
+export function computeSemanticDelta(input) {
+    const before = typeof input.before === "string"
+        ? loadSnapshot(input.before)
+        : input.before;
+    const after = typeof input.after === "string" ? loadSnapshot(input.after) : input.after;
+    if (!before || !after) {
+        throw new Error(`Missing snapshot: before=${typeof input.before === "string" ? input.before : "inline"}, after=${typeof input.after === "string" ? input.after : "inline"}`);
+    }
+    // Verify MinHash params match (otherwise signatures are incomparable)
+    const paramMatch = before.minhash_params.seed === after.minhash_params.seed &&
+        before.minhash_params.num_permutations ===
+            after.minhash_params.num_permutations &&
+        before.minhash_params.shingle_size === after.minhash_params.shingle_size;
+    if (!paramMatch) {
+        throw new Error("MinHash parameters differ between snapshots — signatures are not comparable. " +
+            "Use the same seed/permutations/shingle_size for both.");
+    }
+    const mh = new MinHash(before.minhash_params.num_permutations, before.minhash_params.seed);
+    const allPaths = new Set([
+        ...Object.keys(before.files),
+        ...Object.keys(after.files),
+    ]);
+    const fileDelta = {};
+    let unchangedCount = 0;
+    let modifiedCount = 0;
+    let addedCount = 0;
+    let deletedCount = 0;
+    let totalSectionChanges = 0;
+    for (const path of allPaths) {
+        const beforeFile = before.files[path];
+        const afterFile = after.files[path];
+        if (!beforeFile && afterFile) {
+            // Added
+            addedCount++;
+            fileDelta[path] = {
+                status: "added",
+                file_similarity: 0,
+                size_before: 0,
+                size_after: afterFile.size,
+                growth_pct: 100,
+                section_changes: afterFile.sections.map((s) => ({
+                    heading: s.heading,
+                    status: "added",
+                    similarity: 0,
+                })),
+            };
+            totalSectionChanges += afterFile.sections.length;
+            continue;
+        }
+        if (beforeFile && !afterFile) {
+            // Deleted
+            deletedCount++;
+            fileDelta[path] = {
+                status: "deleted",
+                file_similarity: 0,
+                size_before: beforeFile.size,
+                size_after: 0,
+                growth_pct: -100,
+                section_changes: beforeFile.sections.map((s) => ({
+                    heading: s.heading,
+                    status: "deleted",
+                    similarity: 0,
+                })),
+            };
+            totalSectionChanges += beforeFile.sections.length;
+            continue;
+        }
+        // Both exist — compare
+        if (beforeFile.content_hash === afterFile.content_hash) {
+            // Exact match
+            unchangedCount++;
+            fileDelta[path] = {
+                status: "unchanged",
+                file_similarity: 1.0,
+                size_before: beforeFile.size,
+                size_after: afterFile.size,
+                growth_pct: 0,
+                section_changes: [],
+            };
+            continue;
+        }
+        // Modified — compute similarity
+        modifiedCount++;
+        const fileSim = mh.estimateSimilarity(beforeFile.signature, afterFile.signature);
+        const growthPct = beforeFile.size > 0
+            ? ((afterFile.size - beforeFile.size) / beforeFile.size) * 100
+            : 100;
+        // Section-level alignment for markdown files
+        const sectionChanges = [];
+        if (beforeFile.sections.length > 0 ||
+            afterFile.sections.length > 0) {
+            // Reconstruct MarkdownSection structures from stored signatures
+            // for alignment. We need the content for surgical diff though,
+            // so read the actual files if diffs are requested.
+            const beforeSections = beforeFile.sections.map((s) => ({
+                heading: s.heading,
+                lineStart: s.line_start,
+                lineEnd: s.line_end,
+                content: "", // placeholder — content not stored in cache
+            }));
+            const afterSections = afterFile.sections.map((s) => ({
+                heading: s.heading,
+                lineStart: s.line_start,
+                lineEnd: s.line_end,
+                content: "",
+            }));
+            // Use stored signatures for alignment instead of recomputing
+            // Build a custom alignment from section content hashes
+            const bSigs = beforeFile.sections;
+            const aSigs = afterFile.sections;
+            // Similarity matrix from pre-computed signatures
+            const simMatrix = Array.from({ length: bSigs.length }, () => new Array(aSigs.length).fill(0));
+            for (let i = 0; i < bSigs.length; i++) {
+                for (let j = 0; j < aSigs.length; j++) {
+                    simMatrix[i][j] = mh.estimateSimilarity(bSigs[i].signature, aSigs[j].signature);
+                }
+            }
+            // DP alignment
+            const n = bSigs.length;
+            const m = aSigs.length;
+            const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+            for (let i = 1; i <= n; i++) {
+                for (let j = 1; j <= m; j++) {
+                    if (simMatrix[i - 1][j - 1] > DEFAULT_SIMILARITY_THRESHOLD) {
+                        dp[i][j] = 1 + dp[i - 1][j - 1];
+                    }
+                    else {
+                        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                    }
+                }
+            }
+            // Backtrack
+            let ii = n;
+            let jj = m;
+            const aligned = [];
+            while (ii > 0 || jj > 0) {
+                if (ii > 0 &&
+                    jj > 0 &&
+                    simMatrix[ii - 1][jj - 1] > DEFAULT_SIMILARITY_THRESHOLD) {
+                    const sim = simMatrix[ii - 1][jj - 1];
+                    const isExact = bSigs[ii - 1].content_hash === aSigs[jj - 1].content_hash;
+                    aligned.push({
+                        status: isExact ? "unchanged" : "modified",
+                        leftIdx: ii - 1,
+                        rightIdx: jj - 1,
+                        similarity: sim,
+                    });
+                    ii--;
+                    jj--;
+                }
+                else if (jj > 0 &&
+                    (ii === 0 || dp[ii][jj - 1] >= dp[ii - 1][jj])) {
+                    aligned.push({
+                        status: "added",
+                        leftIdx: -1,
+                        rightIdx: jj - 1,
+                        similarity: 0,
+                    });
+                    jj--;
+                }
+                else if (ii > 0) {
+                    aligned.push({
+                        status: "deleted",
+                        leftIdx: ii - 1,
+                        rightIdx: -1,
+                        similarity: 0,
+                    });
+                    ii--;
+                }
+            }
+            aligned.reverse();
+            // Build section changes
+            for (const entry of aligned) {
+                const heading = entry.rightIdx >= 0
+                    ? aSigs[entry.rightIdx].heading
+                    : bSigs[entry.leftIdx].heading;
+                const change = {
+                    heading,
+                    status: entry.status,
+                    similarity: entry.similarity,
+                };
+                // Surgical diff for modified sections (if requested and content available)
+                if (input.include_diffs && entry.status === "modified") {
+                    // Read actual file content for surgical diff
+                    const beforeContent = safeRead(path);
+                    const afterContent = safeRead(path);
+                    if (!isReadError(beforeContent) && !isReadError(afterContent)) {
+                        const bSections = splitMarkdownSections(beforeContent);
+                        const aSections = splitMarkdownSections(afterContent);
+                        const bSec = bSections[entry.leftIdx];
+                        const aSec = aSections[entry.rightIdx];
+                        if (bSec && aSec) {
+                            const ops = surgicalTokenDiff(bSec.content, aSec.content);
+                            change.diff_summary = renderDiffSummary(ops).slice(0, 2000);
+                        }
+                    }
+                }
+                sectionChanges.push(change);
+                if (entry.status !== "unchanged")
+                    totalSectionChanges++;
+            }
+        }
+        fileDelta[path] = {
+            status: "modified",
+            file_similarity: fileSim,
+            size_before: beforeFile.size,
+            size_after: afterFile.size,
+            growth_pct: Math.round(growthPct * 100) / 100,
+            section_changes: sectionChanges,
+        };
+    }
+    // Drift budget
+    let driftBudget;
+    if (input.drift_budget) {
+        driftBudget = checkDriftBudget({
+            before_total_size: before.total_size,
+            after_total_size: after.total_size,
+            modified_count: modifiedCount,
+            total_file_count: allPaths.size,
+            added_count: addedCount,
+            deleted_count: deletedCount,
+        }, input.drift_budget);
+    }
+    return {
+        version: 1,
+        before_snapshot: before.snapshot_id,
+        after_snapshot: after.snapshot_id,
+        timestamp: new Date().toISOString(),
+        summary: {
+            unchanged_files: unchangedCount,
+            modified_files: modifiedCount,
+            added_files: addedCount,
+            deleted_files: deletedCount,
+            total_section_changes: totalSectionChanges,
+        },
+        drift_budget: driftBudget,
+        files: fileDelta,
+    };
+}
+const DEFAULT_DRIFT_BUDGET = {
+    max_growth_pct: 25,
+    max_churn_pct: 40,
+    max_new_files: 10,
+    max_deleted_files: 5,
+};
+function checkDriftBudget(metrics, config = DEFAULT_DRIFT_BUDGET) {
+    const growthPct = metrics.before_total_size > 0
+        ? ((metrics.after_total_size - metrics.before_total_size) /
+            metrics.before_total_size) *
+            100
+        : metrics.after_total_size > 0
+            ? 100
+            : 0;
+    const churnPct = metrics.total_file_count > 0
+        ? (metrics.modified_count / metrics.total_file_count) * 100
+        : 0;
+    const violations = [];
+    if (Math.abs(growthPct) > config.max_growth_pct) {
+        violations.push(`Size growth ${growthPct.toFixed(1)}% exceeds ±${config.max_growth_pct}% limit`);
+    }
+    if (churnPct > config.max_churn_pct) {
+        violations.push(`Churn ${churnPct.toFixed(1)}% exceeds ${config.max_churn_pct}% limit`);
+    }
+    if (metrics.added_count > config.max_new_files) {
+        violations.push(`${metrics.added_count} new files exceeds limit of ${config.max_new_files}`);
+    }
+    if (metrics.deleted_count > config.max_deleted_files) {
+        violations.push(`${metrics.deleted_count} deleted files exceeds limit of ${config.max_deleted_files}`);
+    }
+    return {
+        passed: violations.length === 0,
+        actual_growth_pct: Math.round(growthPct * 100) / 100,
+        actual_churn_pct: Math.round(churnPct * 100) / 100,
+        new_files: metrics.added_count,
+        deleted_files: metrics.deleted_count,
+        violations,
+    };
+}
+// ────────────────────────────────────────────────────────────────────
+// Convenience: cycle wrapper
+// ────────────────────────────────────────────────────────────────────
+/**
+ * Pre-cycle: take a "before" snapshot.
+ * Returns the snapshot ID for use in post-cycle comparison.
+ */
+export function preCycleSnapshot(cycleId, trackedDirs) {
+    return takeSnapshot({
+        snapshot_id: `${cycleId}_pre`,
+        tracked_dirs: trackedDirs,
+    });
+}
+/**
+ * Post-cycle: take an "after" snapshot and compute the delta.
+ */
+export function postCycleSnapshot(cycleId, trackedDirs, driftBudget, includeDiffs = false) {
+    const afterSnap = takeSnapshot({
+        snapshot_id: `${cycleId}_post`,
+        tracked_dirs: trackedDirs,
+    });
+    const delta = computeSemanticDelta({
+        before: `${cycleId}_pre`,
+        after: afterSnap,
+        include_diffs: includeDiffs,
+        drift_budget: driftBudget ?? DEFAULT_DRIFT_BUDGET,
+    });
+    return { snapshot: afterSnap, delta };
+}
+/**
+ * Extract rewrite targets from a semantic delta.
+ * Returns only modified or added targets — nothing for unchanged/deleted.
+ * For code files: full-file target (use ast-grep node targeting externally).
+ * For markdown: section-level targets with heading/line ranges.
+ */
+export function extractRewriteTargets(delta) {
+    const targets = [];
+    for (const [path, fileDelta] of Object.entries(delta.files)) {
+        if (fileDelta.status === "unchanged" || fileDelta.status === "deleted") {
+            continue;
+        }
+        if (fileDelta.status === "added") {
+            targets.push({ file: path, type: "full", similarity: 0 });
+            continue;
+        }
+        // Modified
+        if (fileDelta.section_changes.length === 0) {
+            // Non-markdown or no section data: full-file target
+            targets.push({
+                file: path,
+                type: "full",
+                similarity: fileDelta.file_similarity,
+            });
+            continue;
+        }
+        // Section-level targets for markdown
+        for (const sec of fileDelta.section_changes) {
+            if (sec.status === "unchanged")
+                continue;
+            targets.push({
+                file: path,
+                type: "section",
+                heading: sec.heading,
+                similarity: sec.similarity,
+            });
+        }
+    }
+    return targets;
+}
+//# sourceMappingURL=semantic-cache.js.map