sela-core 1.0.0

package/dist/services/DnaEditorService.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnaEditorService = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+function jsonPath(dir, key) {
+    return path_1.default.join(dir, `${key}.json`);
+}
+function tmpPath(dir, key) {
+    return path_1.default.join(dir, `${key}.json.tmp`);
+}
+function bakPath(dir, key) {
+    return path_1.default.join(dir, `${key}.json.bak`);
+}
+// Derive a best-effort selector from engine snapshot fields when none is stored.
+function deriveSelector(snap) {
+    const id = snap['id'];
+    const classes = snap['classes'];
+    const tagName = snap['tagName'];
+    if (typeof id === 'string' && id)
+        return `#${id}`;
+    if (Array.isArray(classes) && classes.length > 0)
+        return `.${classes.join('.')}`;
+    return typeof tagName === 'string' ? tagName : 'unknown';
+}
+function dnaError(message, code) {
+    const err = new Error(message);
+    err.code = code;
+    return err;
+}
+class DnaEditorService {
+    snapshotDir;
+    constructor(snapshotDir) {
+        this.snapshotDir = snapshotDir;
+    }
+    async read(key) {
+        const target = jsonPath(this.snapshotDir, key);
+        let raw;
+        try {
+            raw = await promises_1.default.readFile(target, 'utf-8');
+        }
+        catch {
+            throw dnaError(`DNA not found: ${key}`, 'DNA_NOT_FOUND');
+        }
+        const parsed = JSON.parse(raw);
+        // Promote to extended format if selector not stored
+        if (!parsed['selector']) {
+            parsed['selector'] = deriveSelector(parsed);
+        }
+        return parsed;
+    }
+    async write(key, patch) {
+        const target = jsonPath(this.snapshotDir, key);
+        const bak = bakPath(this.snapshotDir, key);
+        const tmp = tmpPath(this.snapshotDir, key);
+        // 1. Read existing snapshot
+        const original = await this.read(key);
+        // 2. Shallow-merge patch (arrays and objects replaced, not deep-merged)
+        const merged = { ...original, ...patch };
+        // Any CLI write = human has reviewed the DNA → clear auto-heal status flag.
+        delete merged['status'];
+        // 3. Derive selector only when absent — never override an explicit (possibly invalid) value
+        if (merged['selector'] == null) {
+            merged['selector'] = deriveSelector(merged);
+        }
+        // 4. Validate before touching disk
+        const validation = this.validate(merged);
+        if (!validation.valid) {
+            throw dnaError(`Validation failed for ${key}: ${validation.errors.join('; ')}`, 'VALIDATION_FAILED');
+        }
+        // 5. Backup current file (overwrite previous bak)
+        await promises_1.default.writeFile(bak, JSON.stringify(original, null, 2), 'utf-8');
+        // 6. Write to tmp
+        await promises_1.default.writeFile(tmp, JSON.stringify(merged, null, 2), 'utf-8');
+        // 7. Atomic rename tmp → json
+        await promises_1.default.rename(tmp, target);
+        return bak;
+    }
+    async rollback(key) {
+        const target = jsonPath(this.snapshotDir, key);
+        const bak = bakPath(this.snapshotDir, key);
+        try {
+            await promises_1.default.access(bak);
+        }
+        catch {
+            throw dnaError(`No backup found for: ${key}`, 'DNA_NOT_FOUND');
+        }
+        await promises_1.default.rename(bak, target);
+    }
+    validate(candidate) {
+        const errors = [];
+        if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) {
+            return { valid: false, errors: ['candidate must be a plain object'] };
+        }
+        const snap = candidate;
+        // ── Required top-level fields ─────────────────────────────────────────────
+        for (const field of ['tagName', 'selector', 'schemaVersion', 'timestamp']) {
+            if (!(field in snap) || snap[field] === undefined) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        if (snap['schemaVersion'] !== 2) {
+            errors.push(`schemaVersion must be 2, got ${String(snap['schemaVersion'])}`);
+        }
+        // ── selector ─────────────────────────────────────────────────────────────
+        const sel = snap['selector'];
+        if (typeof sel === 'string') {
+            if (sel.trim() === '')
+                errors.push('selector must not be empty');
+            if (sel === 'undefined')
+                errors.push('selector must not be the string "undefined"');
+            if (/[\r\n]/.test(sel))
+                errors.push('selector must not contain raw newlines');
+        }
+        else if ('selector' in snap) {
+            errors.push('selector must be a string');
+        }
+        // ── tagName ───────────────────────────────────────────────────────────────
+        const tag = snap['tagName'];
+        if (typeof tag === 'string') {
+            if (!/^[a-z][a-z0-9-]*$/.test(tag)) {
+                errors.push('tagName must match /^[a-z][a-z0-9-]*$/');
+            }
+        }
+        else if ('tagName' in snap) {
+            errors.push('tagName must be a string');
+        }
+        // ── text ─────────────────────────────────────────────────────────────────
+        const text = snap['text'];
+        if (text !== null && text !== undefined) {
+            if (typeof text !== 'string') {
+                errors.push('text must be a string or null');
+            }
+            else if (text.length >= 2000) {
+                errors.push('text must be fewer than 2000 characters');
+            }
+        }
+        // ── attributes ───────────────────────────────────────────────────────────
+        const attrs = snap['attributes'];
+        if (attrs !== undefined) {
+            if (typeof attrs !== 'object' || attrs === null || Array.isArray(attrs)) {
+                errors.push('attributes must be a plain object');
+            }
+            else {
+                for (const [k, v] of Object.entries(attrs)) {
+                    if (!k)
+                        errors.push('attributes keys must not be empty');
+                    if (typeof v !== 'string')
+                        errors.push(`attributes["${k}"] must be a string`);
+                }
+            }
+        }
+        // ── visibility (all 4 keys required) ─────────────────────────────────────
+        const vis = snap['visibility'];
+        if (typeof vis === 'object' && vis !== null && !Array.isArray(vis)) {
+            const visObj = vis;
+            for (const key of ['isGhost', 'ghostReason', 'isOccluded', 'opacity']) {
+                if (!(key in visObj))
+                    errors.push(`visibility.${key} is required`);
+            }
+        }
+        else {
+            errors.push('visibility block is required and must be an object');
+        }
+        // ── anchors (all 3 keys required) ────────────────────────────────────────
+        const anch = snap['anchors'];
+        if (typeof anch === 'object' && anch !== null && !Array.isArray(anch)) {
+            const anchObj = anch;
+            for (const key of ['closestLabel', 'rowAnchor', 'neighborTexts']) {
+                if (!(key in anchObj))
+                    errors.push(`anchors.${key} is required`);
+            }
+            const cl = anchObj['closestLabel'];
+            if (cl !== null && typeof cl !== 'string') {
+                errors.push('anchors.closestLabel must be a string or null');
+            }
+            const nt = anchObj['neighborTexts'];
+            if (!Array.isArray(nt)) {
+                errors.push('anchors.neighborTexts must be an array');
+            }
+            else {
+                if (nt.length > 10)
+                    errors.push('anchors.neighborTexts must have at most 10 elements');
+                if (!nt.every((x) => typeof x === 'string')) {
+                    errors.push('anchors.neighborTexts elements must all be strings');
+                }
+            }
+        }
+        else {
+            errors.push('anchors block is required and must be an object');
+        }
+        return { valid: errors.length === 0, errors };
+    }
+}
+exports.DnaEditorService = DnaEditorService;

package/dist/services/DnaIndexService.d.ts

@@ -0,0 +1,24 @@
+import type { DnaRecord, DnaIndex } from './types.js';
+export interface IDnaIndexService {
+    buildIndex(snapshotDir: string): Promise<DnaIndex>;
+    findBySelector(pattern: string): DnaRecord[];
+    findByText(pattern: string): DnaRecord[];
+    findBySourceFile(filePath: string): DnaRecord[];
+    findByTestTitle(pattern: string): DnaRecord[];
+    getByKey(key: string): DnaRecord | null;
+    getIndex(): DnaIndex;
+    refresh(): void;
+}
+export declare class DnaIndexService implements IDnaIndexService {
+    private cachedIndex;
+    buildIndex(snapshotDir: string): Promise<DnaIndex>;
+    findBySelector(pattern: string): DnaRecord[];
+    findByText(pattern: string): DnaRecord[];
+    findBySourceFile(filePath: string): DnaRecord[];
+    findByTestTitle(pattern: string): DnaRecord[];
+    getByKey(key: string): DnaRecord | null;
+    getIndex(): DnaIndex;
+    refresh(): void;
+    private requireIndex;
+}
+//# sourceMappingURL=DnaIndexService.d.ts.map

package/dist/services/DnaIndexService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DnaIndexService.d.ts","sourceRoot":"","sources":["../../src/services/DnaIndexService.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAatD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnD,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IAC7C,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IACzC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IAChD,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACxC,QAAQ,IAAI,QAAQ,CAAC;IACrB,OAAO,IAAI,IAAI,CAAC;CACjB;AAkED,qBAAa,eAAgB,YAAW,gBAAgB;IACtD,OAAO,CAAC,WAAW,CAAyB;IAEtC,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAkCxD,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE;IAK5C,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE;IAKxC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE;IAO/C,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE;IAK7C,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAIvC,QAAQ,IAAI,QAAQ;IAIpB,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,YAAY;CAQrB"}

package/dist/services/DnaIndexService.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnaIndexService = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+// Supports /regex/flags syntax or plain substring (case-insensitive).
+function toRegExp(pattern) {
+    const m = pattern.match(/^\/(.+)\/([gimsuy]*)$/);
+    if (m)
+        return new RegExp(m[1], m[2]);
+    return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+}
+function deriveSelector(snap) {
+    if (snap.selector)
+        return snap.selector;
+    if (snap.id)
+        return `#${snap.id}`;
+    if (snap.classes.length > 0)
+        return `.${snap.classes.join('.')}`;
+    return snap.tagName;
+}
+function isWithin7Days(iso) {
+    return new Date(iso).getTime() >= Date.now() - 7 * 24 * 60 * 60 * 1000;
+}
+function toRecord(filePath, raw) {
+    const key = path_1.default.basename(filePath, '.json');
+    const sourceFile = raw.sourceFile ?? '';
+    return {
+        key,
+        filePath,
+        testTitle: raw.testTitle ?? '',
+        sourceFile,
+        sourceLine: raw.sourceLine ?? 0,
+        selector: deriveSelector(raw),
+        tagName: raw.tagName,
+        text: raw.text ?? null,
+        lastHealed: raw.lastHealed ?? null,
+        schemaVersion: raw.schemaVersion ?? 1,
+        // Only flag orphaned when sourceFile is known — engine snapshots have no sourceFile
+        isOrphaned: sourceFile !== '' && !(0, fs_1.existsSync)(sourceFile),
+        status: raw.status,
+    };
+}
+async function collectJsonFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    await Promise.all(entries.map(async (entry) => {
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...(await collectJsonFiles(full)));
+        }
+        else if (entry.isFile() &&
+            entry.name.endsWith('.json') &&
+            !entry.name.endsWith('.bak') &&
+            !entry.name.endsWith('.tmp')) {
+            results.push(full);
+        }
+    }));
+    return results;
+}
+class DnaIndexService {
+    cachedIndex = null;
+    async buildIndex(snapshotDir) {
+        const files = await collectJsonFiles(snapshotDir);
+        const settled = await Promise.allSettled(files.map(async (filePath) => {
+            const content = await promises_1.default.readFile(filePath, 'utf-8');
+            return toRecord(filePath, JSON.parse(content));
+        }));
+        const records = settled
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+        const healedAllTime = records.filter((r) => r.lastHealed !== null).length;
+        const healedLast7Days = records.filter((r) => r.lastHealed !== null && isWithin7Days(r.lastHealed)).length;
+        this.cachedIndex = {
+            generatedAt: new Date().toISOString(),
+            snapshotDir,
+            records,
+            stats: {
+                total: records.length,
+                orphaned: records.filter((r) => r.isOrphaned).length,
+                healedLast7Days,
+                healedAllTime,
+            },
+        };
+        return this.cachedIndex;
+    }
+    findBySelector(pattern) {
+        const re = toRegExp(pattern);
+        return this.requireIndex().records.filter((r) => re.test(r.selector));
+    }
+    findByText(pattern) {
+        const re = toRegExp(pattern);
+        return this.requireIndex().records.filter((r) => r.text !== null && re.test(r.text));
+    }
+    findBySourceFile(filePath) {
+        const needle = path_1.default.normalize(filePath).toLowerCase();
+        return this.requireIndex().records.filter((r) => path_1.default.normalize(r.sourceFile).toLowerCase().includes(needle));
+    }
+    findByTestTitle(pattern) {
+        const re = toRegExp(pattern);
+        return this.requireIndex().records.filter((r) => re.test(r.testTitle));
+    }
+    getByKey(key) {
+        return this.requireIndex().records.find((r) => r.key === key) ?? null;
+    }
+    getIndex() {
+        return this.requireIndex();
+    }
+    refresh() {
+        this.cachedIndex = null;
+    }
+    requireIndex() {
+        if (!this.cachedIndex) {
+            const err = new Error('Index not built — call buildIndex() first');
+            err.code = 'SNAPSHOT_DIR_MISSING';
+            throw err;
+        }
+        return this.cachedIndex;
+    }
+}
+exports.DnaIndexService = DnaIndexService;

package/dist/services/HealingAdvisory.d.ts

@@ -0,0 +1,22 @@
+export declare enum AdvisoryCode {
+    BLAST_RADIUS_BLOCKED = "BLAST_RADIUS_BLOCKED",
+    BLAST_RADIUS_WARNING = "BLAST_RADIUS_WARNING",
+    CROSS_FILE_MUTATION = "CROSS_FILE_MUTATION",
+    MANUAL_REVIEW_TEMPLATE_COMPLEX = "MANUAL_REVIEW_TEMPLATE_COMPLEX",
+    MANUAL_REVIEW_CONDITIONAL_RETURN = "MANUAL_REVIEW_CONDITIONAL_RETURN",
+    POST_MUTATION_TYPE_ERROR = "POST_MUTATION_TYPE_ERROR"
+}
+export interface Advisory {
+    code: AdvisoryCode;
+    message: string;
+    affectedFile: string;
+    affectedLine?: number;
+    suggestedAction: string;
+}
+export declare class AdvisoryBuffer {
+    private items;
+    push(advisory: Advisory): void;
+    flush(): void;
+    get length(): number;
+}
+//# sourceMappingURL=HealingAdvisory.d.ts.map

package/dist/services/HealingAdvisory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HealingAdvisory.d.ts","sourceRoot":"","sources":["../../src/services/HealingAdvisory.ts"],"names":[],"mappings":"AAQA,oBAAY,YAAY;IACtB,oBAAoB,yBAAyB;IAC7C,oBAAoB,yBAAyB;IAC7C,mBAAmB,wBAAwB;IAC3C,8BAA8B,mCAAmC;IACjE,gCAAgC,qCAAqC;IACrE,wBAAwB,6BAA6B;CACtD;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAkB;IAE/B,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAI9B,KAAK,IAAI,IAAI;IAab,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}

package/dist/services/HealingAdvisory.js

@@ -0,0 +1,42 @@
+"use strict";
+// ═══════════════════════════════════════════════════════════════════
+// HealingAdvisory  (T-12)
+//
+// Typed advisory system for definition-site mutations.
+// Advisories are buffered during the AST phase and flushed AFTER
+// Playwright prints its test result — prevents interleaving.
+// ═══════════════════════════════════════════════════════════════════
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdvisoryBuffer = exports.AdvisoryCode = void 0;
+var AdvisoryCode;
+(function (AdvisoryCode) {
+    AdvisoryCode["BLAST_RADIUS_BLOCKED"] = "BLAST_RADIUS_BLOCKED";
+    AdvisoryCode["BLAST_RADIUS_WARNING"] = "BLAST_RADIUS_WARNING";
+    AdvisoryCode["CROSS_FILE_MUTATION"] = "CROSS_FILE_MUTATION";
+    AdvisoryCode["MANUAL_REVIEW_TEMPLATE_COMPLEX"] = "MANUAL_REVIEW_TEMPLATE_COMPLEX";
+    AdvisoryCode["MANUAL_REVIEW_CONDITIONAL_RETURN"] = "MANUAL_REVIEW_CONDITIONAL_RETURN";
+    AdvisoryCode["POST_MUTATION_TYPE_ERROR"] = "POST_MUTATION_TYPE_ERROR";
+})(AdvisoryCode || (exports.AdvisoryCode = AdvisoryCode = {}));
+class AdvisoryBuffer {
+    items = [];
+    push(advisory) {
+        this.items.push(advisory);
+    }
+    flush() {
+        if (this.items.length === 0)
+            return;
+        console.log("\n[Sela Advisories] ══════════════════════════════════════");
+        for (const a of this.items) {
+            const loc = a.affectedLine != null ? `:${a.affectedLine + 1}` : "";
+            console.log(`  [${a.code}] ${a.message}`);
+            console.log(`    File:   ${a.affectedFile}${loc}`);
+            console.log(`    Action: ${a.suggestedAction}`);
+        }
+        console.log("[Sela Advisories] ══════════════════════════════════════\n");
+        this.items = [];
+    }
+    get length() {
+        return this.items.length;
+    }
+}
+exports.AdvisoryBuffer = AdvisoryBuffer;

package/dist/services/HealthReportService.d.ts

@@ -0,0 +1,10 @@
+import type { DnaIndex, HealthReport } from './types.js';
+export interface IHealthReportService {
+    generate(index: DnaIndex): HealthReport;
+    format(report: HealthReport): string;
+}
+export declare class HealthReportService implements IHealthReportService {
+    generate(index: DnaIndex): HealthReport;
+    format(report: HealthReport): string;
+}
+//# sourceMappingURL=HealthReportService.d.ts.map

package/dist/services/HealthReportService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HealthReportService.d.ts","sourceRoot":"","sources":["../../src/services/HealthReportService.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAa,YAAY,EAAE,MAAM,YAAY,CAAC;AAEpE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,YAAY,CAAC;IACxC,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC;CACtC;AAkBD,qBAAa,mBAAoB,YAAW,oBAAoB;IAC9D,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,YAAY;IAgBvC,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM;CA6ErC"}

package/dist/services/HealthReportService.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthReportService = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+function isWithin7Days(iso) {
+    return new Date(iso).getTime() >= Date.now() - 7 * 24 * 60 * 60 * 1000;
+}
+function topHealedFiles(records) {
+    const counts = new Map();
+    for (const r of records) {
+        if (r.lastHealed !== null && r.sourceFile) {
+            counts.set(r.sourceFile, (counts.get(r.sourceFile) ?? 0) + 1);
+        }
+    }
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .map(([sourceFile, count]) => ({ sourceFile, count }));
+}
+class HealthReportService {
+    generate(index) {
+        const { records, snapshotDir, generatedAt } = index;
+        return {
+            generatedAt,
+            snapshotDir,
+            total: records.length,
+            orphaned: records.filter((r) => r.isOrphaned),
+            unverifiedHeals: records.filter((r) => !r.isOrphaned && r.status === 'healed'),
+            recentlyHealed: records.filter((r) => r.lastHealed !== null && isWithin7Days(r.lastHealed)),
+            neverHealed: records.filter((r) => r.lastHealed === null),
+            topHealedFiles: topHealedFiles(records),
+        };
+    }
+    format(report) {
+        const lines = [''];
+        lines.push(chalk_1.default.bold.cyan('  Sela Health Report') +
+            chalk_1.default.dim(`  (${new Date(report.generatedAt).toISOString()})`));
+        lines.push('');
+        const row = (label, value) => `  ${chalk_1.default.dim(label.padEnd(20))}  ${value}`;
+        lines.push(row('Total DNAs', chalk_1.default.bold(String(report.total))));
+        const orphanCount = report.orphaned.length;
+        lines.push(row('Orphaned', orphanCount > 0
+            ? chalk_1.default.yellow(`${orphanCount}  ⚠`)
+            : chalk_1.default.green('0')));
+        const unverifiedCount = report.unverifiedHeals.length;
+        lines.push(row('Unverified heals', unverifiedCount > 0
+            ? chalk_1.default.yellow(`${unverifiedCount}  ⚠  ${chalk_1.default.dim('(AI-healed, needs review)')}`)
+            : chalk_1.default.green('0')));
+        const brokenTotal = orphanCount + unverifiedCount;
+        const brokenRatio = report.total > 0
+            ? ((brokenTotal / report.total) * 100).toFixed(1)
+            : '0.0';
+        lines.push(row('Broken ratio', (brokenTotal > 0 ? chalk_1.default.yellow : chalk_1.default.green)(`${brokenRatio}%  ${chalk_1.default.dim(`(${brokenTotal}/${report.total})`)}`)));
+        lines.push(row('Healed (7 days)', chalk_1.default.bold(String(report.recentlyHealed.length))));
+        lines.push(row('Healed (all time)', chalk_1.default.bold(String(report.total - report.neverHealed.length))));
+        lines.push(row('Never healed', chalk_1.default.bold(String(report.neverHealed.length))));
+        if (report.topHealedFiles.length > 0) {
+            lines.push('');
+            lines.push(`  ${chalk_1.default.bold('Top healed files:')}`);
+            for (const { sourceFile, count } of report.topHealedFiles.slice(0, 5)) {
+                const rel = path_1.default.relative(process.cwd(), sourceFile);
+                const label = (rel.length < sourceFile.length ? rel : sourceFile).slice(-60).padEnd(62);
+                const noun = count === 1 ? 'heal' : 'heals';
+                lines.push(`    ${chalk_1.default.cyan(label)}  ${chalk_1.default.dim('—')}  ${chalk_1.default.bold(String(count))} ${chalk_1.default.dim(noun)}`);
+            }
+        }
+        if (report.orphaned.length > 0) {
+            lines.push('');
+            lines.push(`  ${chalk_1.default.yellow.bold('Orphaned DNA files:')}`);
+            for (const r of report.orphaned.slice(0, 10)) {
+                lines.push(`    ${chalk_1.default.dim(r.key)}  ${chalk_1.default.yellow(r.sourceFile)}`);
+            }
+            if (report.orphaned.length > 10) {
+                lines.push(chalk_1.default.dim(`    … and ${report.orphaned.length - 10} more`));
+            }
+        }
+        lines.push('');
+        return lines.join('\n');
+    }
+}
+exports.HealthReportService = HealthReportService;

package/dist/services/InitializerUpdater.d.ts

@@ -0,0 +1,16 @@
+import { Node, SourceFile } from "ts-morph";
+export interface InitializerResult {
+    lineUpdated: number;
+    healedLocatorString: string;
+}
+export declare class InitializerUpdater {
+    /**
+     * Mutate a StringLiteral or NoSubstitutionTemplateLiteral node to
+     * hold newValue, then save the containing source file.
+     *
+     * Returns null if the node type is not directly mutable or if the
+     * mutation throws (caller should fall through to existing strategies).
+     */
+    static apply(valueNode: Node, sourceFile: SourceFile, newValue: string): InitializerResult | null;
+}
+//# sourceMappingURL=InitializerUpdater.d.ts.map

package/dist/services/InitializerUpdater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializerUpdater.d.ts","sourceRoot":"","sources":["../../src/services/InitializerUpdater.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAiB,MAAM,UAAU,CAAC;AAY3D,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,qBAAa,kBAAkB;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CACV,SAAS,EAAE,IAAI,EACf,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,GACf,iBAAiB,GAAG,IAAI;CAqB5B"}

package/dist/services/InitializerUpdater.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializerUpdater = void 0;
+const ts_morph_1 = require("ts-morph");
+const TemplateDiffService_js_1 = require("./TemplateDiffService.js");
+class InitializerUpdater {
+    /**
+     * Mutate a StringLiteral or NoSubstitutionTemplateLiteral node to
+     * hold newValue, then save the containing source file.
+     *
+     * Returns null if the node type is not directly mutable or if the
+     * mutation throws (caller should fall through to existing strategies).
+     */
+    static apply(valueNode, sourceFile, newValue) {
+        try {
+            if (ts_morph_1.Node.isStringLiteral(valueNode)) {
+                valueNode.setLiteralValue(newValue);
+            }
+            else if (ts_morph_1.Node.isNoSubstitutionTemplateLiteral(valueNode)) {
+                valueNode.replaceWithText("`" + (0, TemplateDiffService_js_1.escapeForTemplate)(newValue) + "`");
+            }
+            else {
+                return null;
+            }
+            sourceFile.saveSync();
+            return {
+                lineUpdated: valueNode.getStartLineNumber() - 1,
+                healedLocatorString: newValue,
+            };
+        }
+        catch (e) {
+            console.warn(`[InitializerUpdater] ⚠️ apply failed: ${e.message}`);
+            return null;
+        }
+    }
+}
+exports.InitializerUpdater = InitializerUpdater;

package/dist/services/IntentAuditor.d.ts

@@ -0,0 +1,39 @@
+import { AncestorNode, AnchorInfo } from "../types";
+export interface AuditRequest {
+    dnaText: string;
+    dnaRole?: string;
+    liveText: string;
+    liveRole?: string;
+    healMode: "assertion" | "action";
+    /** Ancestry chain from the DNA snapshot (empty for migrated v1 snapshots). */
+    dnaAncestry?: AncestorNode[];
+    /** Ancestry chain freshly captured from the candidate element at heal-time. */
+    liveAncestry?: AncestorNode[];
+    /** Label/row anchors from the DNA snapshot. */
+    dnaAnchors?: AnchorInfo;
+    /** Label/row anchors freshly captured from the candidate element. */
+    liveAnchors?: AnchorInfo;
+}
+export type AuditVerdictValue = "CONSISTENT" | "INCONSISTENT" | "SUSPICIOUS";
+export interface AuditVerdict {
+    verdict: AuditVerdictValue;
+    confidence: number;
+    reason: string;
+    inversionType: "polarity" | "quantitative" | "state" | "identity" | null;
+    /** Populated when structural scoring adjusted the raw LLM confidence. */
+    scoreBreakdown?: {
+        rawConfidence: number;
+        penalty: number;
+        bonus: number;
+    };
+}
+export declare class IntentAuditor {
+    private anthropic;
+    private readonly disabled;
+    constructor();
+    auditIntent(req: AuditRequest): Promise<AuditVerdict>;
+    computeAncestryPenalty(dnaPath: AncestorNode[], livePath: AncestorNode[]): number;
+    computeAnchorBonus(dnaAnchors: AnchorInfo | null | undefined, liveAnchors: AnchorInfo | null | undefined): number;
+    private parseVerdict;
+}
+//# sourceMappingURL=IntentAuditor.d.ts.map

package/dist/services/IntentAuditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntentAuditor.d.ts","sourceRoot":"","sources":["../../src/services/IntentAuditor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAOpD,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,WAAW,GAAG,QAAQ,CAAC;IAEjC,8EAA8E;IAC9E,WAAW,CAAC,EAAE,YAAY,EAAE,CAAC;IAC7B,+EAA+E;IAC/E,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC;IAC9B,+CAA+C;IAC/C,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,qEAAqE;IACrE,WAAW,CAAC,EAAE,UAAU,CAAC;CAC1B;AAED,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,cAAc,GAAG,YAAY,CAAC;AAE7E,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,UAAU,GAAG,cAAc,GAAG,OAAO,GAAG,UAAU,GAAG,IAAI,CAAC;IACzE,yEAAyE;IACzE,cAAc,CAAC,EAAE;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5E;AAkED,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;;IAgB7B,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IA4G3D,sBAAsB,CACpB,OAAO,EAAE,YAAY,EAAE,EACvB,QAAQ,EAAE,YAAY,EAAE,GACvB,MAAM;IA4CT,kBAAkB,CAChB,UAAU,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EACzC,WAAW,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GACzC,MAAM;IAmCT,OAAO,CAAC,YAAY;CA8CrB"}