sela-core 0.1.0-alpha.1

package/dist/config/DryRunGuard.js

@@ -0,0 +1,80 @@
+"use strict";
+// src/config/DryRunGuard.ts
+//
+// Single source of truth for the "dry run" runtime gate.
+//
+// The flag is sourced from the `SELA_DRY_RUN` environment variable using the
+// strict parser in SelaConfig.parseEnvBoolean (no silent coercion - bad
+// values throw). The variable is re-read on every call so tests and
+// long-running processes can toggle it without restarting the engine.
+//
+// Two writer paths route through this guard:
+//
+//   1. SourceUpdater._coreUpdate - every `fs.writeFileSync` to a spec/source
+//      file. When dry-run is active the write is skipped and a console
+//      breadcrumb is emitted with the absolute path that *would have* been
+//      written.
+//
+//   2. ASTSourceUpdater._persistChanges - wraps ts-morph `SourceFile.saveSync`.
+//      When dry-run is active the in-memory AST mutation stays, but the
+//      `saveSync` call (which forwards to fs.writeFileSync inside ts-morph)
+//      is skipped so the spec on disk is identical pre/post heal.
+//
+// Git auto-commit operations consult `DryRunGuard.active()` directly so
+// `git add` / `git commit` never fire during a dry run.
+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.DryRunGuard = void 0;
+const path = __importStar(require("path"));
+const SelaConfig_1 = require("./SelaConfig");
+const logger_1 = require("../utils/logger");
+exports.DryRunGuard = {
+    /**
+     * Returns true when `SELA_DRY_RUN` is set to a truthy value in the current
+     * process environment. Throws via `parseEnvBoolean` when the value is not
+     * one of the accepted tokens - fail-fast keeps misconfigured CI loud.
+     */
+    active(env = process.env) {
+        return (0, SelaConfig_1.parseEnvBoolean)("SELA_DRY_RUN", env.SELA_DRY_RUN);
+    },
+    /**
+     * Centralised log line for skipped writes so the diff between a dry run
+     * and a real run is auditable in test output and CI logs.
+     */
+    logSkippedWrite(label, target) {
+        const display = target ? path.basename(target) : "<no-path>";
+        logger_1.logger.debug(`Dry Run - skip ${label} → ${display}`);
+    },
+};

package/dist/config/PathScopeGuard.d.ts

@@ -0,0 +1,42 @@
+export interface PathScopeDecision {
+    /** True when the write is permitted. */
+    allowed: boolean;
+    /** Absolute, normalized (symlink-resolved when possible) path evaluated. */
+    resolved: string;
+    /** cwd-relative POSIX form actually matched against the globs. */
+    relative: string;
+    /** The allowedPaths entry that authorized the write, or null. */
+    matchedPattern: string | null;
+    /** Human-readable explanation (surfaced in the security warning / tests). */
+    reason: string;
+}
+export interface PathScopeOptions {
+    /** Override the allowlist. Defaults to `ConfigLoader.getInstance().allowedPaths`. */
+    allowedPaths?: string[];
+    /** Override the working directory. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /** Override platform for case-sensitivity. Defaults to `process.platform`. */
+    platform?: NodeJS.Platform;
+    /** Resolve symlinks before the escape check (escape hardening). Default: true. */
+    followSymlinks?: boolean;
+}
+export declare const PathScopeGuard: {
+    /**
+     * Pure decision function — no logging, no config I/O. Given a raw path and
+     * an explicit allowlist, returns whether the write is permitted.
+     *
+     * `allowedPaths` undefined or `[]` => allow all (backward-compatible).
+     */
+    evaluate(rawPath: string, opts?: PathScopeOptions): PathScopeDecision;
+    /**
+     * Production gate used by the write heads. Reads `allowedPaths` from the
+     * resolved config (unless injected), evaluates, and logs a security warning
+     * on block. Returns true when the write may proceed.
+     *
+     * If config resolution itself fails, fail OPEN (allow) rather than break
+     * every heal — path scoping is a guardrail, not a kill switch.
+     */
+    enforce(rawPath: string, opts?: PathScopeOptions): boolean;
+    logBlocked(decision: PathScopeDecision, allowedPaths: string[]): void;
+};
+//# sourceMappingURL=PathScopeGuard.d.ts.map

package/dist/config/PathScopeGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathScopeGuard.d.ts","sourceRoot":"","sources":["../../src/config/PathScopeGuard.ts"],"names":[],"mappings":"AA4BA,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,4EAA4E;IAC5E,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,qFAAqF;IACrF,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,mEAAmE;IACnE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,kFAAkF;IAClF,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA2CD,eAAO,MAAM,cAAc;IACzB;;;;;OAKG;sBACe,MAAM,SAAQ,gBAAgB,GAAQ,iBAAiB;IA6DzE;;;;;;;OAOG;qBACc,MAAM,SAAQ,gBAAgB,GAAQ,OAAO;yBAOzC,iBAAiB,gBAAgB,MAAM,EAAE,GAAG,IAAI;CAOtE,CAAC"}

package/dist/config/PathScopeGuard.js

@@ -0,0 +1,192 @@
+"use strict";
+// src/config/PathScopeGuard.ts
+//
+// Single source of truth for the "safe path scoping" runtime gate (T1).
+//
+// Every disk-mutating write head in the heal pipeline (SourceUpdater,
+// ASTSourceUpdater, InitializerUpdater, MutationApplier) routes through
+// `PathScopeGuard.enforce(filePath)` immediately before its existing
+// `DryRunGuard.active()` check. A heal whose target file falls outside the
+// configured `allowedPaths` is blocked, the file is left untouched, and a
+// security warning is logged.
+//
+// The allowlist comes from `ConfigLoader.getInstance().allowedPaths`, so the
+// write heads need zero extra plumbing (mirrors how DryRunGuard reads the
+// environment directly). Tests inject `allowedPaths` / `cwd` / `platform`
+// for deterministic, filesystem-independent assertions.
+//
+// CI vs Local: both sides are normalized to a cwd-relative POSIX path before
+// glob matching, so a CI absolute checkout path
+// (`/home/runner/work/repo/tests/a.spec.ts`) and a local relative path
+// (`tests/a.spec.ts`) converge to the same `tests/a.spec.ts` matched against
+// the same `tests/**` pattern.
+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.PathScopeGuard = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const minimatch_1 = require("minimatch");
+const ConfigLoader_1 = require("./ConfigLoader");
+const logger_1 = require("../utils/logger");
+/**
+ * Resolve symlinks best-effort. The target file may not exist yet (a fresh
+ * write), so fall back to realpath-ing the nearest existing ancestor and
+ * re-appending the basename. Never throws.
+ */
+function realpathSafe(abs) {
+    try {
+        return fs.realpathSync.native(abs);
+    }
+    catch {
+        try {
+            const dir = path.dirname(abs);
+            const base = path.basename(abs);
+            return path.join(fs.realpathSync.native(dir), base);
+        }
+        catch {
+            return abs;
+        }
+    }
+}
+/**
+ * Normalize an allowedPaths entry: backslashes → POSIX slashes, strip a
+ * leading `./`, and expand a bare folder (`tests` / `tests/`) into a
+ * recursive `tests/**` glob so folder entries match their contents.
+ */
+function normalizePattern(pattern) {
+    let s = pattern.replace(/\\/g, "/").trim().replace(/^\.\//, "");
+    const hasMagic = /[*?[\]{}!]/.test(s);
+    if (!hasMagic) {
+        const last = s.split("/").pop() ?? "";
+        const looksLikeDir = s.endsWith("/") || !last.includes(".");
+        if (looksLikeDir) {
+            s = s.replace(/\/+$/, "") + "/**";
+        }
+    }
+    return s;
+}
+function isAbsolutePattern(norm) {
+    return path.posix.isAbsolute(norm) || /^[A-Za-z]:/.test(norm);
+}
+exports.PathScopeGuard = {
+    /**
+     * Pure decision function — no logging, no config I/O. Given a raw path and
+     * an explicit allowlist, returns whether the write is permitted.
+     *
+     * `allowedPaths` undefined or `[]` => allow all (backward-compatible).
+     */
+    evaluate(rawPath, opts = {}) {
+        const cwd = opts.cwd ?? process.cwd();
+        const allow = opts.allowedPaths;
+        const absRaw = path.isAbsolute(rawPath)
+            ? rawPath
+            : path.resolve(cwd, rawPath);
+        let abs = path.normalize(absRaw);
+        if (opts.followSymlinks !== false) {
+            abs = realpathSafe(abs);
+        }
+        const relative = path.relative(cwd, abs).split(path.sep).join("/");
+        const absPosix = abs.split(path.sep).join("/");
+        // No allowlist configured → allow all (unset and [] are equivalent).
+        if (!allow || allow.length === 0) {
+            return {
+                allowed: true,
+                resolved: abs,
+                relative,
+                matchedPattern: null,
+                reason: "no allowedPaths configured (allow-all)",
+            };
+        }
+        const platform = opts.platform ?? process.platform;
+        const mmOpts = { dot: true, nocase: platform === "win32" };
+        // Out-of-tree resolution (`..` traversal / symlink escape): only an
+        // explicit ABSOLUTE allowedPaths entry may authorize it. Relative
+        // patterns can never reach outside the project root.
+        const escaped = relative === "" || relative.startsWith("..");
+        for (const pattern of allow) {
+            const norm = normalizePattern(pattern);
+            const patIsAbs = isAbsolutePattern(norm);
+            if (escaped && !patIsAbs)
+                continue;
+            const target = patIsAbs ? absPosix : relative;
+            if ((0, minimatch_1.minimatch)(target, norm, mmOpts)) {
+                return {
+                    allowed: true,
+                    resolved: abs,
+                    relative,
+                    matchedPattern: pattern,
+                    reason: `matched allowedPaths entry "${pattern}"`,
+                };
+            }
+        }
+        return {
+            allowed: false,
+            resolved: abs,
+            relative,
+            matchedPattern: null,
+            reason: escaped
+                ? `path resolves outside the project root ("${relative}") and no absolute allowedPaths entry matched`
+                : `path "${relative}" is outside allowedPaths`,
+        };
+    },
+    /**
+     * Production gate used by the write heads. Reads `allowedPaths` from the
+     * resolved config (unless injected), evaluates, and logs a security warning
+     * on block. Returns true when the write may proceed.
+     *
+     * If config resolution itself fails, fail OPEN (allow) rather than break
+     * every heal — path scoping is a guardrail, not a kill switch.
+     */
+    enforce(rawPath, opts = {}) {
+        const allowedPaths = opts.allowedPaths ?? readAllowedPaths();
+        const decision = this.evaluate(rawPath, { ...opts, allowedPaths });
+        if (!decision.allowed)
+            this.logBlocked(decision, allowedPaths);
+        return decision.allowed;
+    },
+    logBlocked(decision, allowedPaths) {
+        logger_1.logger.warn(`SECURITY: blocked mutation outside allowedPaths — ${decision.resolved}\n` +
+            `        ${decision.reason}\n` +
+            `        allowedPaths: ${JSON.stringify(allowedPaths)}`);
+    },
+};
+function readAllowedPaths() {
+    try {
+        return ConfigLoader_1.ConfigLoader.getInstance().allowedPaths;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/config/SelaConfig.d.ts

@@ -0,0 +1,178 @@
+export type PRStrategy = "directCommit" | "pr" | "draftPR" | "readOnly";
+export type BugAction = "failCI" | "createIssue" | "labelOnly";
+export interface SelaPRAutomationConfig {
+    /** Master switch. Default: false (fully backward-compatible). */
+    enabled?: boolean;
+    /** Git-flow strategy. Default: 'readOnly' (safest). */
+    strategy?: PRStrategy;
+    /** Branches on which directCommit is FORBIDDEN - auto-downgraded. */
+    protectedBranches?: string[];
+    /** Trust-aware downgrade thresholds (0–100). 0 = never downgrade by that metric. */
+    reviewThresholds?: {
+        /** Min AI confidence required for directCommit. Below → downgrade. */
+        minConfidenceForDirectCommit?: number;
+        /** Min auditor adjusted confidence required for directCommit. Below → downgrade. */
+        minAuditorScoreForDirectCommit?: number;
+        /** Strategy to downgrade TO. Default: 'draftPR'. */
+        downgradeTo?: Exclude<PRStrategy, "directCommit">;
+    };
+    /** Behavior when SafetyGuard blocks a heal (PROTECTED events). Default: 'failCI'. */
+    onBugDetected?: BugAction;
+    /** New PR branch name. Vars: ${id}, ${timestamp}. Default: 'sela/heal-${id}'. */
+    branchNameTemplate?: string;
+    /** PR/Issue title template. Vars: ${testName}, ${fileName}, ${count}. */
+    titleTemplate?: string;
+    /** PR body template (Markdown). null = engine uses built-in rich template. */
+    bodyTemplate?: string;
+    /** Labels attached to PR/Issue. */
+    labels?: string[];
+    /** Path/URL of report artifact. Default: 'sela-report.html'. */
+    reportArtifactPath?: string;
+}
+export interface SanitizationConfig {
+    /** Master switch. Default: true (secure by default). */
+    enabled?: boolean;
+    /**
+     * Mask the `value=` of `<input>` elements whose type is password/tel/email.
+     * This is structural (type-driven), not text-based, so it never touches a
+     * button label or heading. Default: true.
+     */
+    redactInputValues?: boolean;
+    /**
+     * Extra regex sources (as strings) merged with the built-in pattern table.
+     * Each is compiled with the global flag; invalid patterns are skipped with
+     * a warning rather than throwing.
+     */
+    customPatterns?: string[];
+}
+export interface SelaConfig {
+    /** Shorthand preset that expands to concrete threshold values. */
+    healingPolicy?: "conservative" | "balanced" | "aggressive";
+    /** Fine-grained threshold overrides. Explicit values always win over preset expansion. */
+    thresholds?: {
+        /** Minimum AI confidence to attempt a heal. Default: 85. Maps to CONFIDENCE_HARD_STOP. */
+        minHealerConfidence?: number;
+        /** How strictly the Intent Auditor treats SUSPICIOUS verdicts. Default: 'balanced'. */
+        auditorStrictness?: "strict" | "balanced" | "loose";
+    };
+    agenticDiscovery?: {
+        enabled?: boolean;
+        maxSteps?: number;
+        forbiddenSelectors?: string[];
+    };
+    /** How healed selectors are persisted. Default: 'inPlace'. */
+    updateStrategy?: "inPlace" | "commentOnly" | "branch";
+    /**
+     * @deprecated Use `prAutomation.strategy = 'directCommit'` instead.
+     * When `prAutomation.enabled` is true this flag is forced to false and
+     * git operations are batched at end-of-run inside SelaEngine.commitUpdates().
+     * Legacy mapping: `autoCommit: true` with no `prAutomation` block →
+     * `prAutomation = { enabled: true, strategy: 'directCommit' }`.
+     */
+    autoCommit?: boolean;
+    /** Git-flow automation (PR/draft PR/direct commit/read-only). See SelaPRAutomationConfig. */
+    prAutomation?: SelaPRAutomationConfig;
+    /** Directory for DNA snapshots. Default: 'sela-snapshots'. */
+    dnaStoragePath?: string;
+    /**
+     * Allowlist of globs/folders Sela may MUTATE. A heal whose target file
+     * falls outside this scope is blocked, the file is skipped, and a security
+     * warning is logged. Matched against the cwd-relative posix path so the
+     * same patterns work for local relative paths and CI absolute checkouts.
+     * Unset or `[]` => allow all (backward-compatible). Default: [].
+     */
+    allowedPaths?: string[];
+    /**
+     * Maximum number of LLM-backed heals permitted in a single run. Once
+     * reached, Sela stops triggering the LLM, finalizes already-applied fixes,
+     * and warns the user. Cache replays do NOT count. Unset => unlimited.
+     * Must be a positive integer when provided (0/non-integer throws).
+     */
+    maxHealsPerRun?: number;
+    /**
+     * Pre-flight PII/secrets masking of all outbound LLM payloads. Enabled by
+     * default (this is a security control). Masking is in-memory only and
+     * targets high-precision patterns + sensitive input values, leaving the
+     * structural anchors the healer relies on intact. See SanitizationConfig.
+     */
+    sanitization?: SanitizationConfig;
+    /**
+     * Per-branch config overrides. Keys are exact branch names.
+     * Merge order: expandPreset(base) → base.thresholds → expandPreset(override) → override.thresholds
+     */
+    branchOverrides?: Record<string, Partial<SelaConfig>>;
+}
+export interface ResolvedThresholds {
+    /** Minimum AI confidence (0–100). Heals below this are always BLOCKED. */
+    confidenceHardStop: number;
+    /** Confidence below which a heal is tagged REQUIRES_REVIEW instead of SAFE. */
+    confidenceReviewThreshold: number;
+    /** Minimum auditor confidence to treat a verdict as CONSISTENT. */
+    auditorConfidenceMin: number;
+    /** When true, SUSPICIOUS in assertion mode yields REQUIRES_REVIEW instead of BLOCKED. */
+    allowSuspicious: boolean;
+    /** The resolved strictness name - used for policy-aware log messages. */
+    auditorStrictness: "strict" | "balanced" | "loose";
+}
+export interface ResolvedPRAutomation {
+    enabled: boolean;
+    strategy: PRStrategy;
+    protectedBranches: string[];
+    reviewThresholds: {
+        minConfidenceForDirectCommit: number;
+        minAuditorScoreForDirectCommit: number;
+        downgradeTo: Exclude<PRStrategy, "directCommit">;
+    };
+    onBugDetected: BugAction;
+    branchNameTemplate: string;
+    titleTemplate: string;
+    bodyTemplate: string | null;
+    labels: string[];
+    reportArtifactPath: string;
+}
+export interface ResolvedSanitization {
+    enabled: boolean;
+    redactInputValues: boolean;
+    customPatterns: string[];
+}
+export interface ResolvedConfig {
+    thresholds: ResolvedThresholds;
+    updateStrategy: "inPlace" | "commentOnly" | "branch";
+    autoCommit: boolean;
+    dnaStoragePath: string;
+    prAutomation: ResolvedPRAutomation;
+    agenticDiscovery: {
+        enabled: boolean;
+        maxSteps: number;
+        forbiddenSelectors: string[];
+    };
+    /** Allowlist of globs/folders Sela may mutate. `[]` = allow all. */
+    allowedPaths: string[];
+    /** Max LLM-backed heals per run. `null` = unlimited. */
+    maxHealsPerRun: number | null;
+    /** Resolved PII/secrets masking config (always defaulted). */
+    sanitization: ResolvedSanitization;
+    /**
+     * When true, every disk-mutating side-effect in the heal pipeline is
+     * suppressed: `fs.writeFileSync`, ts-morph `saveSync`, and git auto-commits.
+     * The heal still runs end-to-end (LLM call, SafetyGuard, candidate diff),
+     * but no source files are modified and no commits are produced.
+     * Sourced from `SELA_DRY_RUN` env var (`1`, `true`, `yes`, `on`).
+     */
+    dryRun: boolean;
+    /**
+     * When true, the healing cache layer is bypassed - every heal request
+     * goes straight to the LLM. Sourced from `SELA_NO_CACHE` env var.
+     */
+    noCache: boolean;
+}
+export declare function resolveThresholds(config: SelaConfig): ResolvedThresholds;
+export declare function parseEnvBoolean(varName: string, rawValue: string | undefined): boolean;
+/**
+ * Validates maxHealsPerRun. Fail-fast (mirrors parseEnvBoolean philosophy):
+ * a misconfigured limit should crash loudly, not silently run unbounded.
+ * undefined => null (unlimited). 0 / negative / non-integer => throw.
+ */
+export declare function resolveMaxHealsPerRun(value: number | undefined): number | null;
+export declare function resolveConfig(config: SelaConfig, env?: NodeJS.ProcessEnv): ResolvedConfig;
+//# sourceMappingURL=SelaConfig.d.ts.map

package/dist/config/SelaConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelaConfig.d.ts","sourceRoot":"","sources":["../../src/config/SelaConfig.ts"],"names":[],"mappings":"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"}

package/dist/config/SelaConfig.js

@@ -0,0 +1,141 @@
+"use strict";
+// src/config/SelaConfig.ts
+// Single source of truth for all Sela configuration types and preset expansion logic.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveThresholds = resolveThresholds;
+exports.parseEnvBoolean = parseEnvBoolean;
+exports.resolveMaxHealsPerRun = resolveMaxHealsPerRun;
+exports.resolveConfig = resolveConfig;
+const PRESET_MAP = {
+    conservative: {
+        minHealerConfidence: 92,
+        auditorStrictness: "strict",
+    },
+    balanced: {
+        minHealerConfidence: 85,
+        auditorStrictness: "balanced",
+    },
+    aggressive: {
+        minHealerConfidence: 75,
+        auditorStrictness: "loose",
+    },
+};
+const STRICTNESS_CONFIDENCE = {
+    strict: 90,
+    balanced: 75,
+    loose: 60,
+};
+function expandPreset(policy) {
+    return policy ? { ...PRESET_MAP[policy] } : {};
+}
+// ═══════════════════════════════════════════════════════════════════
+// RESOLUTION HELPERS
+// ═══════════════════════════════════════════════════════════════════
+function resolveThresholds(config) {
+    const fromPreset = expandPreset(config.healingPolicy);
+    // Explicit thresholds always win over preset expansion
+    const merged = { ...fromPreset, ...config.thresholds };
+    const minHealerConfidence = merged.minHealerConfidence ?? 85;
+    const auditorStrictness = merged.auditorStrictness ?? "balanced";
+    return {
+        confidenceHardStop: minHealerConfidence,
+        confidenceReviewThreshold: 95,
+        auditorConfidenceMin: STRICTNESS_CONFIDENCE[auditorStrictness],
+        // allowSuspicious is derived - never independently settable to avoid footguns
+        allowSuspicious: auditorStrictness === "loose",
+        auditorStrictness,
+    };
+}
+function resolvePRAutomation(config) {
+    const pr = config.prAutomation ?? {};
+    // Legacy bridge: autoCommit:true with no explicit prAutomation block
+    // → enable prAutomation in directCommit mode. Explicit prAutomation always wins.
+    const legacyEnabled = config.autoCommit === true && config.prAutomation === undefined;
+    const enabled = pr.enabled ?? legacyEnabled;
+    const strategy = pr.strategy ?? (legacyEnabled ? "directCommit" : "readOnly");
+    return {
+        enabled,
+        strategy,
+        protectedBranches: pr.protectedBranches ?? ["main", "master", "release"],
+        reviewThresholds: {
+            minConfidenceForDirectCommit: pr.reviewThresholds?.minConfidenceForDirectCommit ?? 0,
+            minAuditorScoreForDirectCommit: pr.reviewThresholds?.minAuditorScoreForDirectCommit ?? 0,
+            downgradeTo: pr.reviewThresholds?.downgradeTo ?? "draftPR",
+        },
+        onBugDetected: pr.onBugDetected ?? "failCI",
+        branchNameTemplate: pr.branchNameTemplate ?? "sela/heal-${id}",
+        titleTemplate: pr.titleTemplate ?? "fix(sela): heal selector in ${fileName}",
+        bodyTemplate: pr.bodyTemplate ?? null,
+        labels: pr.labels ?? [],
+        reportArtifactPath: pr.reportArtifactPath ?? "sela-report.html",
+    };
+}
+// ═══════════════════════════════════════════════════════════════════
+// ENV FLAG PARSING - strict, fail-fast
+//
+// Accepted truthy values (case-insensitive): "1", "true", "yes", "on".
+// Accepted falsy  values (case-insensitive): "0", "false", "no", "off", "".
+// Anything else → throws so misconfigured CI environments fail loudly
+// instead of silently running the wrong mode.
+// ═══════════════════════════════════════════════════════════════════
+const ENV_TRUTHY = new Set(["1", "true", "yes", "on"]);
+const ENV_FALSY = new Set(["0", "false", "no", "off", ""]);
+function parseEnvBoolean(varName, rawValue) {
+    if (rawValue === undefined)
+        return false;
+    const normalized = rawValue.trim().toLowerCase();
+    if (ENV_TRUTHY.has(normalized))
+        return true;
+    if (ENV_FALSY.has(normalized))
+        return false;
+    throw new Error(`[Sela] Invalid value for env var "${varName}": "${rawValue}". ` +
+        `Expected one of: 1, 0, true, false, yes, no, on, off.`);
+}
+/**
+ * Validates maxHealsPerRun. Fail-fast (mirrors parseEnvBoolean philosophy):
+ * a misconfigured limit should crash loudly, not silently run unbounded.
+ * undefined => null (unlimited). 0 / negative / non-integer => throw.
+ */
+function resolveMaxHealsPerRun(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`[Sela] Invalid maxHealsPerRun: ${JSON.stringify(value)}. ` +
+            `Expected a positive integer (or omit it for unlimited).`);
+    }
+    return value;
+}
+function resolveConfig(config, env = process.env) {
+    const prAutomation = resolvePRAutomation(config);
+    // When prAutomation owns the git pipeline, suppress per-heal git side-effects
+    // in SourceUpdater (autoCommit + updateStrategy:'branch') to avoid double-commits.
+    const suppressLegacyGit = prAutomation.enabled;
+    const requestedUpdateStrategy = config.updateStrategy ?? "inPlace";
+    const updateStrategy = suppressLegacyGit && requestedUpdateStrategy === "branch"
+        ? "inPlace"
+        : requestedUpdateStrategy;
+    const autoCommit = suppressLegacyGit ? false : (config.autoCommit ?? false);
+    const dryRun = parseEnvBoolean("SELA_DRY_RUN", env.SELA_DRY_RUN);
+    const noCache = parseEnvBoolean("SELA_NO_CACHE", env.SELA_NO_CACHE);
+    return {
+        thresholds: resolveThresholds(config),
+        updateStrategy,
+        autoCommit,
+        dnaStoragePath: config.dnaStoragePath ?? "sela-snapshots",
+        prAutomation,
+        agenticDiscovery: {
+            enabled: config.agenticDiscovery?.enabled ?? false,
+            maxSteps: config.agenticDiscovery?.maxSteps ?? 10,
+            forbiddenSelectors: config.agenticDiscovery?.forbiddenSelectors ?? [],
+        },
+        allowedPaths: config.allowedPaths ?? [],
+        maxHealsPerRun: resolveMaxHealsPerRun(config.maxHealsPerRun),
+        sanitization: {
+            enabled: config.sanitization?.enabled ?? true,
+            redactInputValues: config.sanitization?.redactInputValues ?? true,
+            customPatterns: config.sanitization?.customPatterns ?? [],
+        },
+        dryRun,
+        noCache,
+    };
+}

package/dist/config/defineConfig.d.ts

@@ -0,0 +1,3 @@
+import { SelaConfig } from './SelaConfig';
+export declare function defineConfig(config: SelaConfig): SelaConfig;
+//# sourceMappingURL=defineConfig.d.ts.map

package/dist/config/defineConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig.d.ts","sourceRoot":"","sources":["../../src/config/defineConfig.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAE3D"}

package/dist/config/defineConfig.js

@@ -0,0 +1,9 @@
+"use strict";
+// src/config/defineConfig.ts
+// Identity helper that provides TypeScript inference for sela.config.ts files
+// without requiring users to manually annotate their export.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = defineConfig;
+function defineConfig(config) {
+    return config;
+}