sela-core 0.1.0-alpha.1

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;AAiB3D,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;CAwD5B"}

package/dist/services/InitializerUpdater.js

@@ -0,0 +1,73 @@
+"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");
+const DryRunGuard_1 = require("../config/DryRunGuard");
+const PathScopeGuard_1 = require("../config/PathScopeGuard");
+const WorkspaceSnapshotService_1 = require("./WorkspaceSnapshotService");
+const SelectorSanitizer_1 = require("./SelectorSanitizer");
+const logger_1 = require("../utils/logger");
+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) {
+        // ABSOLUTE GUARD: never serialise a Playwright internal engine selector
+        // into a string-literal definition. `.locator()` strings cannot express
+        // a semantic locator (getByRole/…), so writing `internal:role=…` here is
+        // the bug that leaks engine internals into user source. Refuse → the
+        // caller escalates to a semantic-guard (no regex fallback corruption).
+        if ((0, SelectorSanitizer_1.isInternalEngineSelector)(newValue)) {
+            logger_1.logger.warn(`Refusing to write internal engine selector into source: "${newValue.slice(0, 64)}"`);
+            return null;
+        }
+        // Safe path scoping (T1): block (and skip the in-memory AST mutation for)
+        // files outside allowedPaths before touching the node.
+        if (!PathScopeGuard_1.PathScopeGuard.enforce(sourceFile.getFilePath())) {
+            return null;
+        }
+        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;
+            }
+            // Centralised write gate - mirrors ASTSourceUpdater._persistChanges.
+            // InitializerUpdater is the canonical write-head for definition-site
+            // mutations (SemanticDispatch → tracer-resolved identifier / property
+            // access / cross-file paths all converge here), so the Clean-Room
+            // snapshot ledger and DryRunGuard MUST be enforced here too.
+            // Without this, an upstream-traced fix (e.g. global StringLiteral at
+            // top of file) writes to disk but `WorkspaceSnapshotService` never
+            // sees it - `getMutatedSnapshots()` returns empty and PR automation
+            // skips the heal entirely.
+            const fp = sourceFile.getFilePath();
+            if (DryRunGuard_1.DryRunGuard.active()) {
+                DryRunGuard_1.DryRunGuard.logSkippedWrite("saveSync", fp);
+            }
+            else {
+                WorkspaceSnapshotService_1.sharedWorkspaceSnapshot.preWrite(fp);
+                sourceFile.saveSync();
+                WorkspaceSnapshotService_1.sharedWorkspaceSnapshot.postWrite(fp);
+            }
+            return {
+                lineUpdated: valueNode.getStartLineNumber() - 1,
+                healedLocatorString: newValue,
+            };
+        }
+        catch (e) {
+            logger_1.logger.warn(`InitializerUpdater apply failed: ${e.message}`);
+            return null;
+        }
+    }
+}
+exports.InitializerUpdater = InitializerUpdater;

package/dist/services/IntentAuditor.d.ts

@@ -0,0 +1,56 @@
+import Anthropic from "@anthropic-ai/sdk";
+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;
+    };
+}
+/**
+ * Constructor options for IntentAuditor.
+ *
+ * - `anthropic`: pre-built Anthropic client to use. Pass `null` explicitly
+ *   to force the auditor into its disabled state (useful in tests that
+ *   want to assert the SUSPICIOUS fallback path without touching env vars).
+ *   Pass `undefined` (default) to fall back to env-based construction.
+ * - `apiKey`: override the ANTHROPIC_API_KEY env var (DI-friendly).
+ * - `model`: override the Haiku model id (lets tests pin the SDK call).
+ */
+export interface IntentAuditorOptions {
+    anthropic?: Anthropic | null;
+    apiKey?: string;
+    model?: string;
+}
+export declare class IntentAuditor {
+    private anthropic;
+    private readonly disabled;
+    private readonly model;
+    constructor(opts?: IntentAuditorOptions);
+    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":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAE1C,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AASpD,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;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAID,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,IAAI,GAAE,oBAAyB;IAiCrC,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAyH3D,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"}

package/dist/services/IntentAuditor.js

@@ -0,0 +1,326 @@
+"use strict";
+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.IntentAuditor = void 0;
+const dotenv = __importStar(require("dotenv"));
+const SanitizingAnthropic_1 = require("./SanitizingAnthropic");
+const logger_1 = require("../utils/logger");
+dotenv.config();
+// ═══════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════
+const FALLBACK_VERDICT = {
+    verdict: "SUSPICIOUS",
+    confidence: 0,
+    reason: "Auditor unavailable - defaulting to cautious SUSPICIOUS verdict",
+    inversionType: null,
+};
+// Ancestry drift penalties (spec §2.1).
+// Applied as negative adjustments to the LLM's confidence score.
+// Maximum combined penalty: −30 pts.
+const DRIFT_PENALTIES = [
+    { full: -20, partial: -10 }, // depth 1 - direct parent
+    { full: -10, partial: -5 }, // depth 2 - grandparent
+];
+// Anchor bonuses: positive-only (spec §3.3).
+// closestLabel exact match:  +10 pts
+// rowAnchor exact match:      +5 pts
+// Maximum combined bonus:    +15 pts
+const ANCHOR_BONUS_LABEL = 10;
+const ANCHOR_BONUS_ROW = 5;
+const SYSTEM_PROMPT = `You are a semantic intent auditor for a self-healing test automation system.
+
+Your job: given a BEFORE text (DNA baseline) and an AFTER text (live element), decide whether the element's semantic intent is consistent, inconsistent, or suspicious.
+
+You must respond with ONLY a JSON object. No prose, no markdown, no explanation outside the JSON.
+
+VERDICT DEFINITIONS:
+- CONSISTENT: The semantic intent is preserved. The element represents the same concept, state, or action. Minor wording, phrasing, or language differences are acceptable (e.g. "Submit" → "Send", "Username" → "Email address", "Connexion" → "Login"). Small quantitative changes that are not inversions are acceptable (e.g. "3 items" → "4 items").
+- INCONSISTENT: The semantic intent has inverted or fundamentally changed. The element now represents an opposite or unrelated concept. Examples: "Success" → "Error", "Enabled" → "Disabled", "Login" → "Logout", "Confirm" → "Cancel", "Add" → "Remove".
+- SUSPICIOUS: Cannot determine with confidence. The change is ambiguous, the texts are too short to judge, or the relationship is unclear. Err toward SUSPICIOUS when unsure.
+
+INVERSION TYPES (populate when INCONSISTENT, null otherwise):
+- "polarity": Boolean/state opposites (enabled/disabled, on/off, true/false, success/failure)
+- "state": Workflow or lifecycle state inversions (login/logout, open/closed, connected/disconnected)
+- "quantitative": Numeric inversions that suggest logic change (not just count changes)
+- "identity": Fundamentally different concept (e.g. "Delete" button became "Save" button)
+
+RULES:
+1. Language is irrelevant. "Connexion" and "Login" are CONSISTENT.
+2. Casing is irrelevant. "SUBMIT" and "submit" are CONSISTENT.
+3. Minor reformatting is irrelevant. "Save Changes" and "Save" are CONSISTENT.
+4. Role/aria context matters. A button that was "Submit" becoming "Cancel" is INCONSISTENT (identity inversion).
+5. When both texts are very short (3 chars or less) and differ, prefer SUSPICIOUS unless an obvious opposite pair.
+6. In "assertion" mode, be stricter - lean toward SUSPICIOUS or INCONSISTENT when the change is ambiguous.
+7. In "action" mode, be more lenient - lean toward CONSISTENT when the change looks like a UI refactor.
+
+RESPONSE FORMAT (strict JSON, no other text):
+{
+  "verdict": "CONSISTENT" | "INCONSISTENT" | "SUSPICIOUS",
+  "confidence": <integer 0-100>,
+  "reason": "<one sentence explaining the verdict>",
+  "inversionType": "polarity" | "quantitative" | "state" | "identity" | null
+}`;
+const DEFAULT_AUDITOR_MODEL = "claude-haiku-4-5-20251001";
+class IntentAuditor {
+    anthropic;
+    disabled;
+    model;
+    constructor(opts = {}) {
+        this.model = opts.model ?? DEFAULT_AUDITOR_MODEL;
+        // Explicit `null` from the caller forces disabled mode - used by tests.
+        if (opts.anthropic === null) {
+            this.anthropic = null;
+            this.disabled = true;
+            return;
+        }
+        // Caller supplied a ready-to-use client → use it as-is.
+        if (opts.anthropic !== undefined) {
+            this.anthropic = opts.anthropic;
+            this.disabled = false;
+            return;
+        }
+        // Otherwise fall back to env-based construction (legacy default).
+        const apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            logger_1.logger.warn("ANTHROPIC_API_KEY not set - auditor disabled, will return SUSPICIOUS for all audited heals");
+            this.anthropic = null;
+            this.disabled = true;
+        }
+        else {
+            // Route through the PII/secrets sanitizer (T3): the auditor prompt
+            // embeds live element text, so it must be scrubbed before leaving too.
+            this.anthropic = (0, SanitizingAnthropic_1.createSanitizingAnthropic)({ apiKey });
+            this.disabled = false;
+        }
+    }
+    async auditIntent(req) {
+        if (this.disabled || !this.anthropic) {
+            return { ...FALLBACK_VERDICT };
+        }
+        const userMessage = [
+            `BEFORE (DNA baseline): "${req.dnaText}"`,
+            req.dnaRole ? `BEFORE role: ${req.dnaRole}` : null,
+            `AFTER (live text):     "${req.liveText}"`,
+            req.liveRole ? `AFTER role:  ${req.liveRole}` : null,
+            `Heal mode: ${req.healMode}`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        try {
+            const response = await this.anthropic.messages.create({
+                model: this.model,
+                max_tokens: 256,
+                temperature: 0.1,
+                system: SYSTEM_PROMPT,
+                messages: [{ role: "user", content: userMessage }],
+            });
+            const raw = response.content[0].type === "text" ? response.content[0].text : "";
+            // parseVerdict returns the raw LLM verdict without the low-confidence
+            // downgrade so that scoring adjustments below are applied first.
+            const rawVerdict = this.parseVerdict(raw);
+            // ── Structural scoring ────────────────────────────────────────
+            // Apply ancestry drift penalty and anchor bonus to the LLM's raw
+            // confidence.  The semantic verdict category (CONSISTENT / SUSPICIOUS /
+            // INCONSISTENT) is never changed by scoring - only the confidence value.
+            // The low-confidence CONSISTENT→SUSPICIOUS downgrade is re-evaluated
+            // after scoring so the adjusted value is used for the threshold.
+            const penalty = this.computeAncestryPenalty(req.dnaAncestry ?? [], req.liveAncestry ?? []);
+            const bonus = this.computeAnchorBonus(req.dnaAnchors, req.liveAnchors);
+            const scoreAdjustment = penalty + bonus;
+            let finalVerdict;
+            if (scoreAdjustment !== 0) {
+                const adjConf = Math.max(0, Math.min(100, rawVerdict.confidence + scoreAdjustment));
+                const parts = [];
+                if (penalty !== 0)
+                    parts.push(`drift ${penalty}`);
+                if (bonus !== 0)
+                    parts.push(`anchor +${bonus}`);
+                logger_1.logger.debug(`Confidence: ${rawVerdict.confidence}% → ${adjConf}% (${parts.join(", ")})`);
+                // Re-apply low-confidence CONSISTENT downgrade with the adjusted value.
+                // The raw check in parseVerdict used the pre-adjustment confidence; a
+                // penalty may push a borderline CONSISTENT below the 50% threshold.
+                const scoring = {
+                    rawConfidence: rawVerdict.confidence,
+                    penalty,
+                    bonus,
+                };
+                if (rawVerdict.verdict === "CONSISTENT" && adjConf < 50) {
+                    finalVerdict = {
+                        verdict: "SUSPICIOUS",
+                        confidence: adjConf,
+                        reason: `Low-confidence CONSISTENT downgraded after drift/anchor scoring: ${rawVerdict.reason}`,
+                        inversionType: null,
+                        scoreBreakdown: scoring,
+                    };
+                    logger_1.logger.debug(`CONSISTENT→SUSPICIOUS after scoring (${rawVerdict.confidence}%→${adjConf}%)`);
+                }
+                else {
+                    finalVerdict = {
+                        ...rawVerdict,
+                        confidence: adjConf,
+                        scoreBreakdown: scoring,
+                    };
+                }
+            }
+            else {
+                finalVerdict = rawVerdict;
+            }
+            logger_1.logger.debug(`verdict=${finalVerdict.verdict} (${finalVerdict.confidence}%) - ${finalVerdict.reason}`);
+            return finalVerdict;
+        }
+        catch (err) {
+            logger_1.logger.warn(`Auditor call failed: ${err.message} - returning SUSPICIOUS`);
+            return {
+                ...FALLBACK_VERDICT,
+                reason: `Auditor call failed: ${err.message}`,
+            };
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // computeAncestryPenalty - DNA v2 Ancestry Drift  (spec §2)
+    //
+    // Compares at most 2 ancestor depths between the DNA baseline and
+    // the live candidate.  Returns a value in [−30, 0]; 0 = no drift.
+    //
+    // Empty dnaPath → 0 penalty (v1 migrated snapshot has no data).
+    // livePath shorter than dnaPath → compare up to min length (§2.5).
+    //
+    // Penalty table (§2.1):
+    //   depth 1  full mismatch  −20 pts  partial mismatch  −10 pts
+    //   depth 2  full mismatch  −10 pts  partial mismatch  −5 pts
+    //
+    // Full mismatch  = tags differ
+    // Partial mismatch = same tag, fingerprint differs (id or classes)
+    // ─────────────────────────────────────────────────────────────
+    computeAncestryPenalty(dnaPath, livePath) {
+        if (dnaPath.length === 0)
+            return 0; // v1 migrated snapshot - skip
+        let totalPenalty = 0;
+        const maxDepth = Math.min(dnaPath.length, livePath.length, 2);
+        for (let i = 0; i < maxDepth; i++) {
+            const dna = dnaPath[i];
+            const live = livePath[i];
+            const { full, partial } = DRIFT_PENALTIES[i];
+            if (dna.fingerprint === live.fingerprint) {
+                continue; // exact match, no penalty
+            }
+            const depthLabel = i === 0 ? "depth-1 (parent)" : "depth-2 (grandparent)";
+            if (dna.tag !== live.tag) {
+                totalPenalty += full;
+                logger_1.logger.debug(`Ancestry drift ${full} pts - ${depthLabel}: ` +
+                    `tag mismatch (${dna.fingerprint} → ${live.fingerprint})`);
+            }
+            else {
+                totalPenalty += partial;
+                logger_1.logger.debug(`Ancestry drift ${partial} pts - ${depthLabel}: ` +
+                    `same tag, id/class changed (${dna.fingerprint} → ${live.fingerprint})`);
+            }
+        }
+        return totalPenalty;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // computeAnchorBonus - DNA v2 Anchor Confirmation  (spec §3.3)
+    //
+    // Anchors only provide positive confirmation - no penalty for
+    // mismatch.  Returns a value in [0, +15].
+    //
+    // closestLabel exact match (case-insensitive):  +10 pts
+    // rowAnchor exact match (case-insensitive):      +5 pts
+    // ─────────────────────────────────────────────────────────────
+    computeAnchorBonus(dnaAnchors, liveAnchors) {
+        if (!dnaAnchors || !liveAnchors)
+            return 0;
+        let bonus = 0;
+        const dnaLabel = dnaAnchors.closestLabel?.toLowerCase().trim();
+        const liveLabel = liveAnchors.closestLabel?.toLowerCase().trim();
+        if (dnaLabel && liveLabel && dnaLabel === liveLabel) {
+            bonus += ANCHOR_BONUS_LABEL;
+            logger_1.logger.debug(`Anchor +${ANCHOR_BONUS_LABEL} pts - closestLabel match: "${dnaAnchors.closestLabel}"`);
+        }
+        const dnaRow = dnaAnchors.rowAnchor?.toLowerCase().trim();
+        const liveRow = liveAnchors.rowAnchor?.toLowerCase().trim();
+        if (dnaRow && liveRow && dnaRow === liveRow) {
+            bonus += ANCHOR_BONUS_ROW;
+            logger_1.logger.debug(`Anchor +${ANCHOR_BONUS_ROW} pts - rowAnchor match: "${dnaAnchors.rowAnchor}"`);
+        }
+        return bonus;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // PRIVATE: parse and validate raw LLM JSON response.
+    //
+    // Returns the verdict as-is from the LLM.  The low-confidence
+    // CONSISTENT downgrade is intentionally NOT performed here so
+    // that auditIntent() can apply structural scoring first and then
+    // run the downgrade once against the adjusted confidence.
+    // ─────────────────────────────────────────────────────────────
+    parseVerdict(raw) {
+        try {
+            const jsonMatch = raw.match(/\{[\s\S]*\}/);
+            if (!jsonMatch)
+                throw new Error("No JSON object found in response");
+            const parsed = JSON.parse(jsonMatch[0]);
+            const verdict = parsed.verdict === "CONSISTENT" ||
+                parsed.verdict === "INCONSISTENT" ||
+                parsed.verdict === "SUSPICIOUS"
+                ? parsed.verdict
+                : "SUSPICIOUS";
+            const confidence = typeof parsed.confidence === "number"
+                ? Math.max(0, Math.min(100, Math.round(parsed.confidence)))
+                : 0;
+            const reason = typeof parsed.reason === "string" && parsed.reason.length > 0
+                ? parsed.reason
+                : "No reason provided";
+            const validInversionTypes = new Set([
+                "polarity",
+                "quantitative",
+                "state",
+                "identity",
+            ]);
+            const inversionType = validInversionTypes.has(parsed.inversionType)
+                ? parsed.inversionType
+                : null;
+            return { verdict, confidence, reason, inversionType };
+        }
+        catch (err) {
+            logger_1.logger.warn(`Failed to parse Auditor response: ${err.message}`);
+            return {
+                ...FALLBACK_VERDICT,
+                reason: `Parse failure: ${err.message}`,
+            };
+        }
+    }
+}
+exports.IntentAuditor = IntentAuditor;

package/dist/services/InteractiveReview.d.ts

@@ -0,0 +1,15 @@
+import type { PendingPromptEntry } from "./PendingPromptLedger";
+export interface PrintReviewDeps {
+    entries: PendingPromptEntry[];
+    /** Override the console sink - tests capture output for assertions. */
+    log?: (msg: string) => void;
+    /** Absolute path of the rendered Sela Insights HTML report, when present. */
+    reportHtmlPath?: string | null;
+}
+/**
+ * Print the post-run review summary. Returns immediately - never blocks
+ * on stdin. Safe to call from the reporter's onEnd() in any environment
+ * (TTY, piped CI, IDE-integrated runner).
+ */
+export declare function printHealReview(deps: PrintReviewDeps): void;
+//# sourceMappingURL=InteractiveReview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InteractiveReview.d.ts","sourceRoot":"","sources":["../../src/services/InteractiveReview.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,uEAAuE;IACvE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,6EAA6E;IAC7E,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CA6B3D"}