@omnitype-code/cli 0.1.0

package/dist/core/FileProvenance.js

@@ -0,0 +1,483 @@
+"use strict";
+/**
+ * FileProvenance — character-level origin tracking for a single file.
+ *
+ * Every character belongs to one of four origins:
+ *   'ai'       — inserted by an AI tool
+ *   'user'     — typed manually
+ *   'paste'    — pasted from clipboard
+ *   'existing' — present before tracking began (unknown origin)
+ *
+ * Internally the file is an ordered array of contiguous Spans covering
+ * [start, end) character offsets. Adjacent spans with the same origin
+ * are coalesced automatically.
+ *
+ * For external disk writes we accept a LineHashBaseline (hashes + char lengths)
+ * instead of raw text — no source code is ever stored or reconstructed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileProvenance = void 0;
+/** Compact origin encoding: 0=existing, 1=user, 2=ai, 3=paste */
+const ORIGIN_ENCODE = { existing: 0, user: 1, ai: 2, paste: 3 };
+const ORIGIN_DECODE = ['existing', 'user', 'ai', 'paste'];
+class FileProvenance {
+    constructor(existingLength) {
+        this.aiEditedByManual = 0;
+        this.manualEditedByAi = 0;
+        /** File-local model dictionary for string interning. */
+        this._modelDict = [];
+        this.spans = existingLength > 0
+            ? [{ start: 0, end: existingLength, origin: 'existing', timestamp: 0 }]
+            : [];
+    }
+    /**
+     * Intern a model name and return its numeric ID.
+     * Returns undefined for falsy/unknown model names.
+     */
+    internModel(model) {
+        if (!model || model === 'unknown')
+            return undefined;
+        let idx = this._modelDict.indexOf(model);
+        if (idx === -1) {
+            idx = this._modelDict.length;
+            this._modelDict.push(model);
+        }
+        return idx;
+    }
+    /** Resolve a modelId back to its string name. */
+    resolveModel(modelId) {
+        if (modelId === undefined || modelId < 0 || modelId >= this._modelDict.length)
+            return undefined;
+        return this._modelDict[modelId];
+    }
+    /** Get the full model dictionary (for serialization). */
+    getModelDictionary() {
+        return this._modelDict;
+    }
+    /**
+     * Adjust the length of the span(s) at `offset` without changing origin attribution.
+     * Used for "silent" updates like indentation/formatting where the line identity
+     * (hash) remains the same but the number of whitespace characters changed.
+     */
+    adjustLength(offset, oldLen, newLen) {
+        if (oldLen === newLen)
+            return;
+        const delta = newLen - oldLen;
+        const idx = this._spanAt(offset);
+        if (idx === -1)
+            return;
+        // We extend/shrink the span that contains the offset.
+        // Usually this is the start of a line.
+        this.spans[idx].end += delta;
+        this._shiftFrom(idx + 1, delta);
+        this._coalesce();
+    }
+    // ── Core operations ──────────────────────────────────────────────────────────
+    /**
+     * Insert `length` characters at `offset` with the given origin.
+     * timestamp defaults to Date.now() for tracked origins, 0 for 'existing'.
+     */
+    insert(offset, length, origin, timestamp, modelId) {
+        if (length <= 0)
+            return;
+        const ts = timestamp ?? (origin === 'existing' ? 0 : Date.now());
+        const idx = this._spanAt(offset);
+        if (idx === -1) {
+            const last = this.spans[this.spans.length - 1];
+            const start = last ? last.end : 0;
+            this.spans.push({ start, end: start + length, origin, modelId, timestamp: ts });
+            this._coalesce();
+            return;
+        }
+        const span = this.spans[idx];
+        if (span.start === offset) {
+            this.spans.splice(idx, 0, { start: offset, end: offset + length, origin, modelId, timestamp: ts });
+            this._shiftFrom(idx + 1, length);
+        }
+        else if (span.end === offset) {
+            this.spans.splice(idx + 1, 0, { start: offset, end: offset + length, origin, modelId, timestamp: ts });
+            this._shiftFrom(idx + 2, length);
+        }
+        else {
+            // Split span — right half inherits the original span's timestamp and modelId
+            const right = { start: offset + length, end: span.end + length, origin: span.origin, modelId: span.modelId, timestamp: span.timestamp };
+            span.end = offset;
+            this.spans.splice(idx + 1, 0, { start: offset, end: offset + length, origin, modelId, timestamp: ts }, right);
+            this._shiftFrom(idx + 3, length);
+        }
+        this._coalesce();
+    }
+    /**
+     * Delete `length` characters starting at `offset`.
+     * Returns the composition of the deleted segment.
+     */
+    delete(offset, length) {
+        const deleted = { ai: 0, user: 0, paste: 0, existing: 0 };
+        if (length <= 0)
+            return deleted;
+        const end = offset + length;
+        let i = 0;
+        while (i < this.spans.length) {
+            const s = this.spans[i];
+            if (s.end <= offset) {
+                i++;
+                continue;
+            }
+            if (s.start >= end)
+                break;
+            const overlapLen = Math.min(s.end, end) - Math.max(s.start, offset);
+            deleted[s.origin] += overlapLen;
+            s.end -= overlapLen;
+            if (s.start >= s.end) {
+                this.spans.splice(i, 1);
+            }
+            else {
+                i++;
+            }
+        }
+        for (let j = i; j < this.spans.length; j++) {
+            this.spans[j].start -= length;
+            this.spans[j].end -= length;
+        }
+        this._coalesce();
+        return deleted;
+    }
+    /**
+     * Replace [offset, offset+deleteLen) with insertLen chars of origin.
+     * Returns a delta indicating what was added and what was deleted.
+     */
+    replace(offset, deleteLen, insertLen, origin, modelId) {
+        const res = {
+            added: insertLen,
+            deleted: { ai: 0, user: 0, paste: 0, existing: 0 },
+            aiEditedByManual: 0,
+            manualEditedByAi: 0
+        };
+        if (deleteLen > 0) {
+            const del = this.delete(offset, deleteLen);
+            Object.assign(res.deleted, del);
+            // Attribution: if a user edit replaces AI work, track that "edit"
+            if (origin === 'user' && res.deleted.ai > 0) {
+                const amt = Math.min(res.deleted.ai, insertLen);
+                this.aiEditedByManual += amt;
+                res.aiEditedByManual += amt;
+            }
+            if (origin === 'ai' && res.deleted.user > 0) {
+                const amt = Math.min(res.deleted.user, insertLen);
+                this.manualEditedByAi += amt;
+                res.manualEditedByAi += amt;
+            }
+        }
+        if (insertLen > 0)
+            this.insert(offset, insertLen, origin, undefined, modelId);
+        return res;
+    }
+    /**
+     * Apply a diff between an old baseline and a new baseline, attributing
+     * all added/changed lines to `origin`.
+     */
+    applyLineDiff(oldBaseline, newBaseline, origin, modelId) {
+        const res = {
+            added: 0,
+            deleted: { ai: 0, user: 0, paste: 0, existing: 0 },
+            aiEditedByManual: 0,
+            manualEditedByAi: 0
+        };
+        const m = oldBaseline.length;
+        const n = newBaseline.length;
+        const t = this._lcsTable(oldBaseline, newBaseline);
+        const ops = [];
+        let i = m, j = n;
+        while (i > 0 || j > 0) {
+            if (i > 0 && j > 0 && oldBaseline[i - 1].hash === newBaseline[j - 1].hash && t[i][j] === t[i - 1][j - 1] + 1) {
+                ops.push({ type: 'match', oi: i - 1, ni: j - 1 });
+                i--;
+                j--;
+            }
+            else if (i > 0 && (j === 0 || t[i - 1][j] >= t[i][j - 1])) {
+                ops.push({ type: 'delete', oi: i - 1, ni: -1 });
+                i--;
+            }
+            else {
+                ops.push({ type: 'add', oi: -1, ni: j - 1 });
+                j--;
+            }
+        }
+        ops.reverse();
+        // 2. Apply operations forward to maintain correct character offsets
+        let offset = 0;
+        let lastDeleted = null;
+        for (const op of ops) {
+            if (op.type === 'match') {
+                const olen = oldBaseline[op.oi].charLen;
+                const nlen = newBaseline[op.ni].charLen;
+                if (olen !== nlen)
+                    this.adjustLength(offset, olen, nlen);
+                offset += nlen;
+                lastDeleted = null;
+            }
+            else if (op.type === 'add') {
+                const len = newBaseline[op.ni].charLen;
+                this.insert(offset, len, origin, undefined, modelId);
+                res.added += len;
+                // Tracking transitions for consecutive replacements
+                if (lastDeleted) {
+                    if (origin === 'user' && lastDeleted.ai > 0) {
+                        const amt = Math.min(lastDeleted.ai, len);
+                        this.aiEditedByManual += amt;
+                        res.aiEditedByManual += amt;
+                    }
+                    else if (origin === 'ai' && lastDeleted.user > 0) {
+                        const amt = Math.min(lastDeleted.user, len);
+                        this.manualEditedByAi += amt;
+                        res.manualEditedByAi += amt;
+                    }
+                }
+                offset += len;
+            }
+            else {
+                const len = oldBaseline[op.oi].charLen;
+                const del = this.delete(offset, len);
+                for (const k in del)
+                    res.deleted[k] += del[k];
+                lastDeleted = del;
+            }
+        }
+        return res;
+    }
+    getComposition() {
+        const c = {
+            ai: 0, user: 0, paste: 0, existing: 0, total: 0,
+            aiEditedByManual: this.aiEditedByManual,
+            manualEditedByAi: this.manualEditedByAi
+        };
+        for (const s of this.spans) {
+            const len = s.end - s.start;
+            c[s.origin] += len;
+            c.total += len;
+        }
+        return c;
+    }
+    // ── Persistence ──────────────────────────────────────────────────────────────
+    /**
+     * Returns the dominant origin for each line.
+     * A line's origin is whichever origin covers the most characters in that line.
+     */
+    getLineOrigins(baseline) {
+        return this._getLineData(baseline).map(d => d.origin);
+    }
+    /** Get per-line model names (resolved from dictionary). */
+    getLineModels(baseline) {
+        return this._getLineData(baseline).map(d => this.resolveModel(d.modelId));
+    }
+    /** Returns per-model char counts for AI-attributed content in this file. */
+    getModelBreakdown(baseline) {
+        const result = {};
+        for (const span of this.spans) {
+            if (span.origin !== 'ai')
+                continue;
+            const model = this.resolveModel(span.modelId);
+            if (!model || model === 'unknown')
+                continue;
+            // Count chars covered by this span that overlap with the baseline
+            const totalChars = span.end - span.start;
+            result[model] = (result[model] ?? 0) + totalChars;
+        }
+        return result;
+    }
+    _getLineData(baseline) {
+        const result = [];
+        let offset = 0;
+        for (const line of baseline) {
+            const lineEnd = offset + line.charLen;
+            const counts = { ai: 0, user: 0, paste: 0, existing: 0 };
+            const timestamps = { ai: 0, user: 0, paste: 0, existing: 0 };
+            const modelCounts = new Map();
+            for (const span of this.spans) {
+                if (span.end <= offset || span.start >= lineEnd)
+                    continue;
+                const lo = Math.max(span.start, offset);
+                const hi = Math.min(span.end, lineEnd);
+                const covered = hi - lo;
+                counts[span.origin] += covered;
+                if (span.timestamp > timestamps[span.origin])
+                    timestamps[span.origin] = span.timestamp;
+                modelCounts.set(span.modelId, (modelCounts.get(span.modelId) ?? 0) + covered);
+            }
+            let dominant = 'existing';
+            let max = 0;
+            for (const k of ['ai', 'user', 'paste', 'existing']) {
+                if (counts[k] > max) {
+                    max = counts[k];
+                    dominant = k;
+                }
+            }
+            // Pick the model with the most coverage on this line
+            let dominantModel;
+            let maxModelCov = 0;
+            for (const [mid, cov] of modelCounts) {
+                if (mid !== undefined && cov > maxModelCov) {
+                    maxModelCov = cov;
+                    dominantModel = mid;
+                }
+            }
+            result.push({ origin: dominant, timestamp: timestamps[dominant], modelId: dominantModel });
+            offset = lineEnd;
+        }
+        return result;
+    }
+    /** Serialize to a compact, storable format. */
+    toStored(baseline) {
+        const lineData = this._getLineData(baseline);
+        const hasModels = this._modelDict.length > 0;
+        const stored = {
+            hashes: baseline.map(l => l.hash),
+            origins: lineData.map(d => ORIGIN_ENCODE[d.origin]),
+            charLens: baseline.map(l => l.charLen),
+            timestamps: lineData.map(d => d.timestamp),
+            aiEditedByManual: this.aiEditedByManual,
+            manualEditedByAi: this.manualEditedByAi,
+        };
+        if (hasModels) {
+            stored.modelDictionary = [...this._modelDict];
+            stored.modelIds = lineData.map(d => d.modelId ?? -1);
+        }
+        return stored;
+    }
+    /**
+     * Reconstruct FileProvenance from a previous session's stored data,
+     * reconciling against the current file baseline via LCS on hashes.
+     *
+     * Lines that match (same hash) keep their stored origin.
+     * New or changed lines (no hash match) are marked 'existing'.
+     */
+    static fromStored(stored, currentBaseline) {
+        const m = stored.hashes.length;
+        const n = currentBaseline.length;
+        // LCS table on line hashes
+        const t = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                t[i][j] = stored.hashes[i - 1] === currentBaseline[j - 1].hash
+                    ? t[i - 1][j - 1] + 1
+                    : Math.max(t[i - 1][j], t[i][j - 1]);
+            }
+        }
+        // Backtrack to assign origins and timestamps to current lines
+        const lineOrigins = new Array(n).fill('existing');
+        const lineTimestamps = new Array(n).fill(0);
+        let i = m, j = n;
+        while (i > 0 && j > 0) {
+            if (stored.hashes[i - 1] === currentBaseline[j - 1].hash && t[i][j] === t[i - 1][j - 1] + 1) {
+                lineOrigins[j - 1] = ORIGIN_DECODE[stored.origins[i - 1]] ?? 'existing';
+                lineTimestamps[j - 1] = stored.timestamps?.[i - 1] ?? 0;
+                i--;
+                j--;
+            }
+            else if (t[i - 1][j] >= t[i][j - 1]) {
+                i--;
+            }
+            else {
+                j--;
+            }
+        }
+        // Restore model dictionary
+        const fp = new FileProvenance(0);
+        if (stored.modelDictionary) {
+            fp._modelDict = [...stored.modelDictionary];
+        }
+        fp.aiEditedByManual = stored.aiEditedByManual || 0;
+        fp.manualEditedByAi = stored.manualEditedByAi || 0;
+        // Build per-line modelId array from stored data (reconciled via LCS)
+        const lineModelIds = new Array(n).fill(undefined);
+        // Re-walk the LCS backtrack to map stored modelIds to current lines
+        let ii = m, jj = n;
+        while (ii > 0 && jj > 0) {
+            if (stored.hashes[ii - 1] === currentBaseline[jj - 1].hash && t[ii][jj] === t[ii - 1][jj - 1] + 1) {
+                const mid = stored.modelIds?.[ii - 1];
+                lineModelIds[jj - 1] = (mid !== undefined && mid >= 0) ? mid : undefined;
+                ii--;
+                jj--;
+            }
+            else if (t[ii - 1][jj] >= t[ii][jj - 1]) {
+                ii--;
+            }
+            else {
+                jj--;
+            }
+        }
+        let offset = 0;
+        for (let k = 0; k < n; k++) {
+            const len = currentBaseline[k].charLen;
+            if (len > 0) {
+                fp.insert(offset, len, lineOrigins[k], lineTimestamps[k], lineModelIds[k]);
+                offset += len;
+            }
+        }
+        return fp;
+    }
+    // ── Private helpers ──────────────────────────────────────────────────────────
+    /** Index of the span that contains `offset`, or -1 if past end. Binary search O(log n). */
+    _spanAt(offset) {
+        let lo = 0, hi = this.spans.length - 1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >>> 1;
+            const s = this.spans[mid];
+            if (offset < s.start) {
+                hi = mid - 1;
+            }
+            else if (offset > s.end) {
+                lo = mid + 1;
+            }
+            else {
+                return mid;
+            }
+        }
+        return -1;
+    }
+    _shiftFrom(idx, delta) {
+        for (let i = idx; i < this.spans.length; i++) {
+            this.spans[i].start += delta;
+            this.spans[i].end += delta;
+        }
+    }
+    _coalesce() {
+        this.spans = this.spans.filter(s => s.end > s.start);
+        let i = 0;
+        while (i < this.spans.length - 1) {
+            const a = this.spans[i], b = this.spans[i + 1];
+            if (a.origin === b.origin && a.modelId === b.modelId && a.end === b.start) {
+                a.end = b.end;
+                a.timestamp = Math.max(a.timestamp, b.timestamp);
+                this.spans.splice(i + 1, 1);
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    _lcsTable(a, b) {
+        const m = a.length, n = b.length;
+        if (m > FileProvenance.MAX_LCS_SIDE || n > FileProvenance.MAX_LCS_SIDE) {
+            return Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+        }
+        const t = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                t[i][j] = a[i - 1].hash === b[j - 1].hash
+                    ? t[i - 1][j - 1] + 1
+                    : Math.max(t[i - 1][j], t[i][j - 1]);
+            }
+        }
+        return t;
+    }
+}
+exports.FileProvenance = FileProvenance;
+/**
+ * O(m×n) LCS table over hash values.
+ * Guard: if either side exceeds MAX_LCS_SIDE lines the table would exceed ~36 MB.
+ * In that case return an all-zeros table — the diff algorithm will treat every
+ * line as deleted+added, which is conservative (no lines get wrongly matched)
+ * but loses attribution for unchanged lines on those huge files.
+ */
+FileProvenance.MAX_LCS_SIDE = 3000;

package/dist/core/GitNotes.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * GitNotes — read/write omnitype attribution data as Git Notes.
+ *
+ * Notes live at refs/notes/ai. Each note on a commit is a JSON blob:
+ *
+ *   {
+ *     "v": 1,
+ *     "tool": "omnitype",
+ *     "ts": <unix-ms>,
+ *     "files": {
+ *       "src/foo.ts": [
+ *         { "start": 1, "end": 45, "origin": "ai",   "model": "claude-sonnet-4-5" },
+ *         { "start": 46, "end": 60, "origin": "user" }
+ *       ]
+ *     }
+ *   }
+ *
+ * Line numbers are 1-indexed, inclusive — matching git blame output.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNote = buildNote;
+exports.writeNote = writeNote;
+exports.readNote = readNote;
+exports.mergeNotes = mergeNotes;
+exports.provenanceToNoteFile = provenanceToNoteFile;
+exports.fetchNotes = fetchNotes;
+exports.pushNotes = pushNotes;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const _execFile = (0, util_1.promisify)(child_process_1.execFile);
+const NOTES_REF = 'refs/notes/ai';
+function buildNote(files) {
+    return { v: 1, tool: 'omnitype', ts: Date.now(), files };
+}
+/** Write (or overwrite) a Git Note for the given commit in the repo at repoPath. */
+async function writeNote(repoPath, commitish, note) {
+    const json = JSON.stringify(note);
+    await _execFile('git', ['-C', repoPath, 'notes', '--ref', NOTES_REF, 'add', '-f', '-m', json, commitish]);
+}
+/** Read the omnitype Git Note for a commit. Returns null if none exists. */
+function readNote(repoPath, commitish) {
+    try {
+        const out = (0, child_process_1.execFileSync)('git', ['-C', repoPath, 'notes', '--ref', NOTES_REF, 'show', commitish], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const parsed = JSON.parse(out);
+        if (parsed?.v === 1 && parsed?.tool === 'omnitype')
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Merge two notes — second note's ranges overwrite first for conflicting files. */
+function mergeNotes(base, overlay) {
+    return {
+        ...base,
+        ts: Math.max(base.ts, overlay.ts),
+        files: { ...base.files, ...overlay.files },
+    };
+}
+/**
+ * Build a NoteFile from a StoredProvenance map (as returned by FileProvenance.toStored).
+ * Converts span-level data into 1-indexed line ranges for the note.
+ */
+function provenanceToNoteFile(files) {
+    const DECODE = { 0: 'existing', 1: 'user', 2: 'ai', 3: 'paste' };
+    const result = {};
+    for (const [relPath, sp] of Object.entries(files)) {
+        const ranges = [];
+        let lineNum = 1;
+        let runStart = lineNum;
+        let runOrigin = DECODE[sp.origins[0]] ?? 'existing';
+        let runModel;
+        let runTool;
+        const flush = (end) => {
+            if (end < runStart)
+                return;
+            const r = { start: runStart, end, origin: runOrigin };
+            if (runModel)
+                r.model = runModel;
+            if (runTool)
+                r.tool = runTool;
+            ranges.push(r);
+        };
+        for (let i = 0; i < sp.origins.length; i++) {
+            const origin = DECODE[sp.origins[i]] ?? 'existing';
+            const model = (sp.modelIds && sp.modelDictionary && sp.modelIds[i] >= 0)
+                ? sp.modelDictionary[sp.modelIds[i]] : undefined;
+            const tool = (sp.toolIds && sp.toolDictionary && sp.toolIds[i] >= 0)
+                ? sp.toolDictionary[sp.toolIds[i]] : undefined;
+            if (origin !== runOrigin || model !== runModel || tool !== runTool) {
+                flush(lineNum - 1);
+                runStart = lineNum;
+                runOrigin = origin;
+                runModel = model;
+                runTool = tool;
+            }
+            lineNum++;
+        }
+        flush(lineNum - 1);
+        if (ranges.length > 0)
+            result[relPath] = ranges;
+    }
+    return result;
+}
+/** Fetch git notes from remote so teammates' attributions are visible locally. */
+async function fetchNotes(repoPath, remote = 'origin') {
+    try {
+        await _execFile('git', [
+            '-C', repoPath, 'fetch', remote,
+            `${NOTES_REF}:${NOTES_REF}`,
+        ]);
+    }
+    catch { /* remote may not have notes yet */ }
+}
+/** Push git notes to remote. */
+async function pushNotes(repoPath, remote = 'origin') {
+    await _execFile('git', ['-C', repoPath, 'push', remote, NOTES_REF]);
+}

package/dist/core/Heartbeat.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Heartbeat coordination between the VS Code extension and the CLI daemon.
+ *
+ * The extension writes ~/.omnitype/vscode-heartbeat.json periodically.
+ * The daemon reads it before pushing to decide whether to yield.
+ *
+ * Schema: { pid: number, workspacePaths: string[], ts: number }
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readExtensionHeartbeat = readExtensionHeartbeat;
+exports.extensionIsActiveFor = extensionIsActiveFor;
+exports.writeDaemonHeartbeat = writeDaemonHeartbeat;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const HEARTBEAT_PATH = path.join(os.homedir(), '.omnitype', 'vscode-heartbeat.json');
+const YIELD_WINDOW_MS = 30000; // daemon yields if extension was seen within 30s
+function readExtensionHeartbeat() {
+    try {
+        const raw = fs.readFileSync(HEARTBEAT_PATH, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Returns true if the VS Code extension is actively tracking the given workspace.
+ * When true, the daemon should skip pushing for files in that workspace.
+ */
+function extensionIsActiveFor(workspacePath) {
+    const hb = readExtensionHeartbeat();
+    if (!hb)
+        return false;
+    if (Date.now() - hb.ts > YIELD_WINDOW_MS)
+        return false;
+    return hb.workspacePaths.some(p => workspacePath.startsWith(p) || p.startsWith(workspacePath));
+}
+/** Write our own daemon heartbeat so the extension can also yield to us if needed. */
+function writeDaemonHeartbeat(watchPath) {
+    try {
+        const data = { pid: process.pid, watchPath, ts: Date.now() };
+        fs.mkdirSync(path.dirname(HEARTBEAT_PATH), { recursive: true });
+        fs.writeFileSync(path.join(os.homedir(), '.omnitype', 'daemon-heartbeat.json'), JSON.stringify(data));
+    }
+    catch { /* non-fatal */ }
+}