sela-core 0.1.0-alpha.1

package/dist/services/safety/rules/DangerousSinkRule.js

@@ -0,0 +1,53 @@
+"use strict";
+// src/services/safety/rules/DangerousSinkRule.ts
+//
+// Step 5.5 - Dangerous-Sink escalation (context-mutator, returns null).
+//
+// Closes the headline blind spot from the incident: a heal that transitions
+// INTO a destructive or auth role (e.g. "Update System"(UNKNOWN) →
+// "delete System"(DELETE)) sailed through as SAFE because:
+//   - the cross-role swap rule (step 5) only fires when BOTH roles are known,
+//   - the auditor gate (step 6) only fired for zero-trust / assertion /
+//     both-UNKNOWN, none of which matched.
+//
+// Per design decision #2, this rule does NOT decide on its own; it FORCES
+// the Intent Auditor to run (ctx.forceAudit = true) whenever the new role is
+// a dangerous sink and differs from the old role.  The auditor's existing
+// verdict mapping then applies: INCONSISTENT → FAIL_HARD, SUSPICIOUS →
+// BLOCKED/REQUIRES_REVIEW, CONSISTENT → continue.
+//
+// Note on coverage: a swap between two KNOWN roles (e.g. SUBMIT → DELETE)
+// is already short-circuited by FunctionalRoleRule before reaching here, so
+// in practice this rule fires for the UNKNOWN→sink case it was built for.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DangerousSinkRule = exports.DANGEROUS_SINK_ROLES = void 0;
+exports.isDangerousSinkTransition = isDangerousSinkTransition;
+const roleClassifier_1 = require("../roleClassifier");
+const logger_1 = require("../../../utils/logger");
+/**
+ * Roles whose ARRIVAL is treated as high-risk: a control that did not
+ * obviously mean "delete" or "authenticate" before, but now does.
+ */
+exports.DANGEROUS_SINK_ROLES = new Set([
+    "DELETE",
+    "AUTH",
+]);
+function isDangerousSinkTransition(oldRole, newRole) {
+    return exports.DANGEROUS_SINK_ROLES.has(newRole) && newRole !== oldRole;
+}
+exports.DangerousSinkRule = {
+    id: "dangerous-sink-escalation",
+    run(ctx) {
+        // Roles are set by FunctionalRoleRule; fall back to a fresh
+        // classification defensively if a future reorder runs this first.
+        const oldRole = ctx.oldRole ?? (0, roleClassifier_1.classifyFunctionalRole)(ctx.oldText ?? "");
+        const newRole = ctx.newRole ?? (0, roleClassifier_1.classifyFunctionalRole)(ctx.newText ?? "");
+        if (isDangerousSinkTransition(oldRole, newRole)) {
+            logger_1.logger.warn(`SafetyGuard dangerous-sink transition: ` +
+                `"${ctx.oldText}" (${oldRole}) → "${ctx.newText}" (${newRole}) - ` +
+                `forcing Intent Auditor`);
+            ctx.forceAudit = true;
+        }
+        return null;
+    },
+};

package/dist/services/safety/rules/FunctionalRoleRule.d.ts

@@ -0,0 +1,3 @@
+import type { SafetyRule } from "../PipelineContext";
+export declare const FunctionalRoleRule: SafetyRule;
+//# sourceMappingURL=FunctionalRoleRule.d.ts.map

package/dist/services/safety/rules/FunctionalRoleRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionalRoleRule.d.ts","sourceRoot":"","sources":["../../../../src/services/safety/rules/FunctionalRoleRule.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAqC,MAAM,oBAAoB,CAAC;AAExF,eAAO,MAAM,kBAAkB,EAAE,UA6DhC,CAAC"}

package/dist/services/safety/rules/FunctionalRoleRule.js

@@ -0,0 +1,64 @@
+"use strict";
+// src/services/safety/rules/FunctionalRoleRule.ts
+//
+// Step 5 - Functional role analysis.  Classifies old/new text into the
+// functional taxonomy and pins the roles onto the context for the
+// auditor gate.  STATUS_POSITIVE ↔ STATUS_NEGATIVE is always a logic
+// inversion (FAIL_HARD).  A cross-role swap between two known roles is
+// BLOCKED in assertion mode and REQUIRES_REVIEW in action mode.
+//
+// Extracted verbatim - identical classification log, reasons, codes,
+// and the action-mode warning.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionalRoleRule = void 0;
+const SelaError_1 = require("../../../errors/SelaError");
+const roleClassifier_1 = require("../roleClassifier");
+const logger_1 = require("../../../utils/logger");
+exports.FunctionalRoleRule = {
+    id: "functional-role-analysis",
+    run(ctx) {
+        const oldText = ctx.oldText;
+        const newText = ctx.newText;
+        const oldRole = (0, roleClassifier_1.classifyFunctionalRole)(oldText);
+        const newRole = (0, roleClassifier_1.classifyFunctionalRole)(newText);
+        ctx.oldRole = oldRole;
+        ctx.newRole = newRole;
+        logger_1.logger.debug(`SafetyGuard role classification: "${oldText}"→${oldRole}, "${newText}"→${newRole}`);
+        // STATUS_POSITIVE ↔ STATUS_NEGATIVE is always a logic inversion
+        const isStatusInversion = (oldRole === "STATUS_POSITIVE" && newRole === "STATUS_NEGATIVE") ||
+            (oldRole === "STATUS_NEGATIVE" && newRole === "STATUS_POSITIVE");
+        if (isStatusInversion) {
+            return {
+                level: "FAIL_HARD",
+                code: SelaError_1.SAFETY_GUARD_CODES.FAIL_HARD_STATUS_INVERSION,
+                reason: `Status inversion: "${oldText}" (${oldRole}) → "${newText}" (${newRole}) - ` +
+                    `masking a logic failure is not permitted`,
+                canProceed: false,
+            };
+        }
+        // Cross-role swap (e.g. DELETE → CANCEL, SUBMIT → NAVIGATE)
+        if (oldRole !== "UNKNOWN" && newRole !== "UNKNOWN" && oldRole !== newRole) {
+            if (ctx.mode === "assertion") {
+                // Assertion explicitly checked the old functional text; a different
+                // function being found is almost certainly a wrong element fix.
+                return {
+                    level: "BLOCKED",
+                    code: SelaError_1.SAFETY_GUARD_CODES.BLOCKED_ROLE_SWAP_ASSERTION,
+                    reason: `Functional role swap in assertion: "${oldText}" (${oldRole}) → "${newText}" (${newRole}) - ` +
+                        `the assertion was verifying a specific functional state`,
+                    canProceed: false,
+                };
+            }
+            // Action mode: allow with warning - a UI refactor may rename a control
+            // (e.g. "Delete" button renamed "Remove" or merged into a menu)
+            logger_1.logger.warn(`SafetyGuard functional role change in action: ` +
+                `"${oldText}" (${oldRole}) → "${newText}" (${newRole}) - review recommended`);
+            return {
+                level: "REQUIRES_REVIEW",
+                reason: `Functional role change in action: "${oldText}" (${oldRole}) → "${newText}" (${newRole})`,
+                canProceed: true,
+            };
+        }
+        return null;
+    },
+};

package/dist/services/safety/rules/HardConfidenceRule.d.ts

@@ -0,0 +1,3 @@
+import type { SafetyRule } from "../PipelineContext";
+export declare const HardConfidenceRule: SafetyRule;
+//# sourceMappingURL=HardConfidenceRule.d.ts.map

package/dist/services/safety/rules/HardConfidenceRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HardConfidenceRule.d.ts","sourceRoot":"","sources":["../../../../src/services/safety/rules/HardConfidenceRule.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAqC,MAAM,oBAAoB,CAAC;AAExF,eAAO,MAAM,kBAAkB,EAAE,UAahC,CAAC"}

package/dist/services/safety/rules/HardConfidenceRule.js

@@ -0,0 +1,22 @@
+"use strict";
+// src/services/safety/rules/HardConfidenceRule.ts
+//
+// Step 1 - Hard confidence stop.  Heals below confidenceHardStop are
+// always BLOCKED, before any content reasoning.  Extracted verbatim.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HardConfidenceRule = void 0;
+const SelaError_1 = require("../../../errors/SelaError");
+exports.HardConfidenceRule = {
+    id: "hard-confidence-stop",
+    run(ctx) {
+        if (ctx.confidence < ctx.thresholds.confidenceHardStop) {
+            return {
+                level: "BLOCKED",
+                code: SelaError_1.SAFETY_GUARD_CODES.BLOCKED_LOW_CONFIDENCE,
+                reason: `Confidence too low (${ctx.confidence}/100 < ${ctx.thresholds.confidenceHardStop}) - refusing to heal`,
+                canProceed: false,
+            };
+        }
+        return null;
+    },
+};

package/dist/services/safety/rules/IntentAuditorRule.d.ts

@@ -0,0 +1,3 @@
+import type { SafetyRule } from "../PipelineContext";
+export declare const IntentAuditorRule: SafetyRule;
+//# sourceMappingURL=IntentAuditorRule.d.ts.map

package/dist/services/safety/rules/IntentAuditorRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntentAuditorRule.d.ts","sourceRoot":"","sources":["../../../../src/services/safety/rules/IntentAuditorRule.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,UAAU,EAAqC,MAAM,oBAAoB,CAAC;AAExF,eAAO,MAAM,iBAAiB,EAAE,UAyF/B,CAAC"}

package/dist/services/safety/rules/IntentAuditorRule.js

@@ -0,0 +1,97 @@
+"use strict";
+// src/services/safety/rules/IntentAuditorRule.ts
+//
+// Step 6/7 - Intent Auditor gate + verdict mapping.  Calls the secondary
+// LLM auditor when:
+//   a) zero-trust synthesized the contentChange (AI silent → extra scrutiny), OR
+//   b) we are in assertion mode (the test explicitly checked the text), OR
+//   c) both roles are UNKNOWN (no functional category to fall back on).
+//
+// INCONSISTENT → FAIL_HARD.  SUSPICIOUS → BLOCKED in assertion (unless
+// allowSuspicious) else REQUIRES_REVIEW.  CONSISTENT → fall through,
+// stashing the auditor score breakdown on the context for the final tier.
+//
+// Extracted verbatim - identical trigger condition, reasons, codes,
+// logs, and meta shape.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentAuditorRule = void 0;
+const SelaError_1 = require("../../../errors/SelaError");
+const logger_1 = require("../../../utils/logger");
+exports.IntentAuditorRule = {
+    id: "intent-auditor-gate",
+    async run(ctx) {
+        const oldText = ctx.oldText;
+        const newText = ctx.newText;
+        const oldRole = ctx.oldRole;
+        const newRole = ctx.newRole;
+        const shouldAudit = ctx.forceAudit === true ||
+            ctx.source === "zero-trust" ||
+            ctx.mode === "assertion" ||
+            (oldRole === "UNKNOWN" && newRole === "UNKNOWN");
+        if (!shouldAudit)
+            return null;
+        const auditVerdict = await ctx.auditor.auditIntent({
+            dnaText: oldText,
+            dnaRole: ctx.aiFix.dnaRole,
+            liveText: newText,
+            healMode: ctx.mode,
+            // v2 structural context forwarded for scoring
+            dnaAncestry: ctx.aiFix.dnaAncestry,
+            liveAncestry: ctx.aiFix.liveAncestry,
+            dnaAnchors: ctx.aiFix.dnaAnchors,
+            liveAnchors: ctx.aiFix.liveAnchors,
+        });
+        if (auditVerdict.verdict === "INCONSISTENT") {
+            return {
+                level: "FAIL_HARD",
+                code: SelaError_1.SAFETY_GUARD_CODES.FAIL_HARD_AUDITOR_INCONSISTENT,
+                reason: `Intent Auditor - INCONSISTENT: ${auditVerdict.reason}` +
+                    (auditVerdict.inversionType
+                        ? ` [inversion: ${auditVerdict.inversionType}]`
+                        : ""),
+                canProceed: false,
+            };
+        }
+        if (auditVerdict.verdict === "SUSPICIOUS") {
+            const meta = {
+                auditorVerdict: "SUSPICIOUS",
+                auditorConfidence: auditVerdict.confidence,
+            };
+            // Block by default in assertion mode; allowSuspicious (loose policy) downgrades to REQUIRES_REVIEW
+            if (!ctx.thresholds.allowSuspicious && ctx.mode === "assertion") {
+                return {
+                    level: "BLOCKED",
+                    code: SelaError_1.SAFETY_GUARD_CODES.BLOCKED_AUDITOR_SUSPICIOUS,
+                    reason: `Intent Auditor - SUSPICIOUS in assertion mode: ${auditVerdict.reason}`,
+                    canProceed: false,
+                    meta,
+                };
+            }
+            if (ctx.thresholds.allowSuspicious && ctx.mode === "assertion") {
+                logger_1.logger.debug("SafetyGuard allowSuspicious=true - SUSPICIOUS in assertion mode escalated to REQUIRES_REVIEW");
+            }
+            return {
+                level: "REQUIRES_REVIEW",
+                reason: `Intent Auditor - SUSPICIOUS in ${ctx.mode} mode: ${auditVerdict.reason}`,
+                canProceed: true,
+                meta,
+            };
+        }
+        // CONSISTENT - fall through to confidence tiers
+        logger_1.logger.debug(`SafetyGuard Intent Auditor - CONSISTENT (${auditVerdict.confidence}%): ${auditVerdict.reason}`);
+        if (auditVerdict.scoreBreakdown) {
+            const { rawConfidence, penalty, bonus } = auditVerdict.scoreBreakdown;
+            if (penalty !== 0 || bonus !== 0) {
+                ctx.localAuditMeta = {
+                    auditScoreBreakdown: {
+                        rawConfidence,
+                        penalty,
+                        bonus,
+                        adjustedConfidence: auditVerdict.confidence,
+                    },
+                };
+            }
+        }
+        return null;
+    },
+};

package/dist/services/safety/rules/SemanticOppositeRule.d.ts

@@ -0,0 +1,3 @@
+import type { SafetyRule } from "../PipelineContext";
+export declare const SemanticOppositeRule: SafetyRule;
+//# sourceMappingURL=SemanticOppositeRule.d.ts.map

package/dist/services/safety/rules/SemanticOppositeRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SemanticOppositeRule.d.ts","sourceRoot":"","sources":["../../../../src/services/safety/rules/SemanticOppositeRule.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAqC,MAAM,oBAAoB,CAAC;AAExF,eAAO,MAAM,oBAAoB,EAAE,UAqBlC,CAAC"}

package/dist/services/safety/rules/SemanticOppositeRule.js

@@ -0,0 +1,30 @@
+"use strict";
+// src/services/safety/rules/SemanticOppositeRule.ts
+//
+// Step 4 - Binary semantic-opposite guard.  Applies in ALL modes:
+// "Enabled"→"Disabled", "Success"→"Error", etc. always indicate a state
+// inversion and are never safe to auto-heal.  Extracted verbatim.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticOppositeRule = void 0;
+const SelaError_1 = require("../../../errors/SelaError");
+const roleClassifier_1 = require("../roleClassifier");
+exports.SemanticOppositeRule = {
+    id: "semantic-opposite-guard",
+    run(ctx) {
+        // oldText/newText are guaranteed set: StructuralOnlyRule populates
+        // them whenever an effective content change exists, and returns a
+        // decision (short-circuit) otherwise.
+        const oldText = ctx.oldText;
+        const newText = ctx.newText;
+        if ((0, roleClassifier_1.isSemanticOpposite)(oldText, newText)) {
+            return {
+                level: "FAIL_HARD",
+                code: SelaError_1.SAFETY_GUARD_CODES.FAIL_HARD_SEMANTIC_INVERSION,
+                reason: `Semantic inversion detected: "${oldText}" ↔ "${newText}" - ` +
+                    `state inversions mask logical regressions`,
+                canProceed: false,
+            };
+        }
+        return null;
+    },
+};

package/dist/services/safety/rules/StructuralOnlyRule.d.ts

@@ -0,0 +1,3 @@
+import type { SafetyRule } from "../PipelineContext";
+export declare const StructuralOnlyRule: SafetyRule;
+//# sourceMappingURL=StructuralOnlyRule.d.ts.map

package/dist/services/safety/rules/StructuralOnlyRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructuralOnlyRule.d.ts","sourceRoot":"","sources":["../../../../src/services/safety/rules/StructuralOnlyRule.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,UAAU,EAAqC,MAAM,oBAAoB,CAAC;AAExF,eAAO,MAAM,kBAAkB,EAAE,UAyBhC,CAAC"}

package/dist/services/safety/rules/StructuralOnlyRule.js

@@ -0,0 +1,38 @@
+"use strict";
+// src/services/safety/rules/StructuralOnlyRule.ts
+//
+// Step 3 - Structural-only heal.  When no effective content change was
+// detected (AI silent AND zero-trust found no live/DNA divergence), the
+// selector moved but the text did not: SAFE at/above the review
+// threshold, REQUIRES_REVIEW below it.
+//
+// When a content change DOES exist this rule is a context-mutator: it
+// pins oldText/newText/source onto the context and emits the
+// "Content change" log, then falls through (returns null) so the
+// downstream inversion rules can reason about the pair.  This keeps the
+// exact ordering of the pre-refactor evaluate() (the log fired right
+// after the structural-only check, before semantic-opposite analysis).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructuralOnlyRule = void 0;
+const logger_1 = require("../../../utils/logger");
+exports.StructuralOnlyRule = {
+    id: "structural-only-heal",
+    run(ctx) {
+        if (!ctx.effectiveContentChange) {
+            const level = ctx.confidence < ctx.thresholds.confidenceReviewThreshold
+                ? "REQUIRES_REVIEW"
+                : "SAFE";
+            return {
+                level,
+                reason: `Structural selector change only (confidence=${ctx.confidence})`,
+                canProceed: true,
+            };
+        }
+        const { oldText, newText } = ctx.effectiveContentChange;
+        ctx.oldText = oldText;
+        ctx.newText = newText;
+        ctx.source = ctx.aiFix.contentChange ? "AI-reported" : "zero-trust";
+        logger_1.logger.debug(`SafetyGuard content change (${ctx.source}): "${oldText}" → "${newText}"`);
+        return null;
+    },
+};

package/dist/services/safety/rules/VisibilityRule.d.ts

@@ -0,0 +1,3 @@
+import type { SafetyRule } from "../PipelineContext";
+export declare const VisibilityRule: SafetyRule;
+//# sourceMappingURL=VisibilityRule.d.ts.map

package/dist/services/safety/rules/VisibilityRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VisibilityRule.d.ts","sourceRoot":"","sources":["../../../../src/services/safety/rules/VisibilityRule.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAqC,MAAM,oBAAoB,CAAC;AAExF,eAAO,MAAM,cAAc,EAAE,UAiD5B,CAAC"}

package/dist/services/safety/rules/VisibilityRule.js

@@ -0,0 +1,53 @@
+"use strict";
+// src/services/safety/rules/VisibilityRule.ts
+//
+// Step 0 - Visibility Gate.  Runs before any confidence or content
+// checks: a ghost element can never be safely acted upon regardless of
+// AI confidence.  Occlusion policy is branch-dependent (hard-fail on
+// main/master, REQUIRES_REVIEW elsewhere).
+//
+// Extracted verbatim from SafetyGuard.evaluate() - identical reasons,
+// codes, and the same warning on the non-main occlusion path.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisibilityRule = void 0;
+const SelaError_1 = require("../../../errors/SelaError");
+const logger_1 = require("../../../utils/logger");
+exports.VisibilityRule = {
+    id: "visibility-gate",
+    run(ctx) {
+        const { liveVisibility } = ctx.aiFix;
+        if (!liveVisibility)
+            return null;
+        const vis = liveVisibility;
+        if (vis.isGhost) {
+            return {
+                level: "FAIL_HARD",
+                code: SelaError_1.SAFETY_GUARD_CODES.FAIL_HARD_VISIBILITY_GHOST,
+                reason: `Visibility Gate: candidate element is a Ghost (${vis.ghostReason}) - ` +
+                    `functionally absent from the user's perspective`,
+                canProceed: false,
+            };
+        }
+        if (vis.isOccluded) {
+            const isMainBranch = ctx.branch === "main" || ctx.branch === "master";
+            if (isMainBranch) {
+                return {
+                    level: "FAIL_HARD",
+                    code: SelaError_1.SAFETY_GUARD_CODES.FAIL_HARD_VISIBILITY_OCCLUDED,
+                    reason: `Visibility Gate: candidate element is occluded by an overlay on branch "${ctx.branch}" - ` +
+                        `hard-fail policy active on main`,
+                    canProceed: false,
+                };
+            }
+            logger_1.logger.warn(`SafetyGuard occlusion detected on branch "${ctx.branch ?? "unknown"}" - ` +
+                `escalating to REQUIRES_REVIEW (not hard-failing on non-main branch)`);
+            return {
+                level: "REQUIRES_REVIEW",
+                reason: `Visibility Gate: candidate element is occluded by an overlay ` +
+                    `(branch: ${ctx.branch ?? "unknown"})`,
+                canProceed: true,
+            };
+        }
+        return null;
+    },
+};

package/dist/services/safety/rules/ZeroTrustRule.d.ts

@@ -0,0 +1,3 @@
+import type { SafetyRule } from "../PipelineContext";
+export declare const ZeroTrustRule: SafetyRule;
+//# sourceMappingURL=ZeroTrustRule.d.ts.map

package/dist/services/safety/rules/ZeroTrustRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZeroTrustRule.d.ts","sourceRoot":"","sources":["../../../../src/services/safety/rules/ZeroTrustRule.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAqC,MAAM,oBAAoB,CAAC;AAExF,eAAO,MAAM,aAAa,EAAE,UA4B3B,CAAC"}

package/dist/services/safety/rules/ZeroTrustRule.js

@@ -0,0 +1,37 @@
+"use strict";
+// src/services/safety/rules/ZeroTrustRule.ts
+//
+// Step 2 - Zero-Trust Verification (context-mutator, always returns null).
+//
+// The AI's contentChange field is self-reported and may be absent even
+// when the element's text actually changed.  When liveText +
+// dnaBaselineText are both available and differ, we synthesize a
+// contentChange pair so the full inversion-check pipeline runs on it
+// regardless of what the AI reported.  If the AI DID report
+// contentChange we keep that (more precise than raw innerText).
+//
+// Extracted verbatim - identical synthesis condition and warning.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZeroTrustRule = void 0;
+const logger_1 = require("../../../utils/logger");
+exports.ZeroTrustRule = {
+    id: "zero-trust-verification",
+    run(ctx) {
+        const { liveText, dnaBaselineText } = ctx.aiFix;
+        let effectiveContentChange = ctx.aiFix.contentChange;
+        if (!effectiveContentChange &&
+            liveText !== undefined &&
+            dnaBaselineText !== undefined) {
+            const normLive = liveText.trim();
+            const normDNA = dnaBaselineText.trim();
+            if (normLive !== normDNA && normLive.length > 0 && normDNA.length > 0) {
+                logger_1.logger.warn(`SafetyGuard Zero-Trust override - AI omitted contentChange but live DOM differs:\n` +
+                    `  DNA baseline : "${normDNA}"\n` +
+                    `  Live text    : "${normLive}"`);
+                effectiveContentChange = { oldText: normDNA, newText: normLive };
+            }
+        }
+        ctx.effectiveContentChange = effectiveContentChange;
+        return null;
+    },
+};

package/dist/services/safety/rules/index.d.ts

@@ -0,0 +1,3 @@
+import type { SafetyRule } from "../PipelineContext";
+export declare const SAFETY_RULES: ReadonlyArray<SafetyRule>;
+//# sourceMappingURL=index.d.ts.map

package/dist/services/safety/rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/safety/rules/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAWrD,eAAO,MAAM,YAAY,EAAE,aAAa,CAAC,UAAU,CAUlD,CAAC"}

package/dist/services/safety/rules/index.js

@@ -0,0 +1,34 @@
+"use strict";
+// src/services/safety/rules/index.ts
+//
+// The ordered SafetyGuard rule pipeline (chain-of-responsibility).
+// Order IS the safety contract - it reproduces the exact priority of the
+// pre-refactor evaluate():
+//
+//   visibility > confidence > zero-trust(mutator) > structural-only >
+//   semantic-opposite > functional-role > intent-auditor > confidence-tier
+//
+// New rules (e.g. a dangerous-sink escalation) plug in as a single array
+// entry at the correct position - no other code changes.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAFETY_RULES = void 0;
+const VisibilityRule_1 = require("./VisibilityRule");
+const HardConfidenceRule_1 = require("./HardConfidenceRule");
+const ZeroTrustRule_1 = require("./ZeroTrustRule");
+const StructuralOnlyRule_1 = require("./StructuralOnlyRule");
+const SemanticOppositeRule_1 = require("./SemanticOppositeRule");
+const FunctionalRoleRule_1 = require("./FunctionalRoleRule");
+const DangerousSinkRule_1 = require("./DangerousSinkRule");
+const IntentAuditorRule_1 = require("./IntentAuditorRule");
+const ConfidenceTierRule_1 = require("./ConfidenceTierRule");
+exports.SAFETY_RULES = [
+    VisibilityRule_1.VisibilityRule, // 0 - ghost / occlusion gate
+    HardConfidenceRule_1.HardConfidenceRule, // 1 - hard confidence stop
+    ZeroTrustRule_1.ZeroTrustRule, // 2 - synthesize contentChange (mutator)
+    StructuralOnlyRule_1.StructuralOnlyRule, // 3 - structural-only decide | pin oldText/newText (mutator)
+    SemanticOppositeRule_1.SemanticOppositeRule, // 4 - hardcoded opposite pairs
+    FunctionalRoleRule_1.FunctionalRoleRule, // 5 - role classification + status/cross-role swap
+    DangerousSinkRule_1.DangerousSinkRule, // 5.5 - force auditor on UNKNOWN→DELETE/AUTH (mutator)
+    IntentAuditorRule_1.IntentAuditorRule, // 6/7 - LLM auditor gate + verdict mapping
+    ConfidenceTierRule_1.ConfidenceTierRule, // 8 - terminal SAFE / REQUIRES_REVIEW tier
+];

package/dist/services/types.d.ts

@@ -0,0 +1,59 @@
+export interface DnaRecord {
+    key: string;
+    filePath: string;
+    testTitle: string;
+    sourceFile: string;
+    sourceLine: number;
+    selector: string;
+    tagName: string;
+    text: string | null;
+    lastHealed: string | null;
+    schemaVersion: number;
+    isOrphaned: boolean;
+    /** 'healed' = AI auto-fixed, pending human verification. 'broken' = AI failed. undefined = healthy/verified. */
+    status?: 'healed' | 'broken';
+}
+export interface DnaIndex {
+    generatedAt: string;
+    snapshotDir: string;
+    records: DnaRecord[];
+    stats: {
+        total: number;
+        orphaned: number;
+        healedLast7Days: number;
+        healedAllTime: number;
+    };
+}
+export interface DnaEditPatch {
+    key: string;
+    field: 'selector' | 'text' | 'tagName' | 'attributes' | 'anchors';
+    oldValue: unknown;
+    newValue: unknown;
+    applySourceUpdate: boolean;
+    locatorIndex: number;
+}
+export interface BulkUpdateJob {
+    oldSelector: string;
+    newSelector: string;
+    dryRun: boolean;
+    targets: DnaRecord[];
+    results: Array<{
+        key: string;
+        success: boolean;
+        reason: string;
+    }>;
+}
+export interface HealthReport {
+    generatedAt: string;
+    snapshotDir: string;
+    total: number;
+    orphaned: DnaRecord[];
+    unverifiedHeals: DnaRecord[];
+    recentlyHealed: DnaRecord[];
+    neverHealed: DnaRecord[];
+    topHealedFiles: Array<{
+        sourceFile: string;
+        count: number;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/services/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,gHAAgH;IAChH,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAC9B;AAED,MAAM,WAAW,QAAQ;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAC;IAClE,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,OAAO,EAAE,KAAK,CAAC;QACb,GAAG,EAAE,MAAM,CAAC;QACZ,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,eAAe,EAAE,SAAS,EAAE,CAAC;IAC7B,cAAc,EAAE,SAAS,EAAE,CAAC;IAC5B,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,cAAc,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9D"}

package/dist/services/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/SnapshotManager.d.ts

@@ -0,0 +1,5 @@
+export declare class SnapshotManager {
+    static save(filePath: string, data: any): Promise<void>;
+    static load(filePath: string): Promise<any>;
+}
+//# sourceMappingURL=SnapshotManager.d.ts.map

package/dist/storage/SnapshotManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnapshotManager.d.ts","sourceRoot":"","sources":["../../src/storage/SnapshotManager.ts"],"names":[],"mappings":"AAKA,qBAAa,eAAe;WACb,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG;WAUhC,IAAI,CAAC,QAAQ,EAAE,MAAM;CAQnC"}

package/dist/storage/SnapshotManager.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotManager = void 0;
+// src/storage/SnapshotManager.ts
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+class SnapshotManager {
+    static async save(filePath, data) {
+        try {
+            const dir = path_1.default.dirname(filePath);
+            await promises_1.default.mkdir(dir, { recursive: true });
+            await promises_1.default.writeFile(filePath, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            logger_1.logger.error("Failed to save snapshot", error);
+        }
+    }
+    static async load(filePath) {
+        try {
+            const content = await promises_1.default.readFile(filePath, "utf-8");
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.SnapshotManager = SnapshotManager;