codictator 0.0.0-stage → 0.1.2

package/dist/features/packs/enforcers/testing-guards.js

@@ -0,0 +1,118 @@
+import { ok } from "../../../kernel/index.js";
+import { bindRule, findingFor, selectFiles } from "./binding.js";
+import { baseEnforcer, loadScopeText, parseMarkerInt, parseMarkers, } from "./health-measures.js";
+// SPEC §5.4 core/spec-trace: a test title without a SPEC reference flags.
+export function resolveSpecTrace(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined || /\[§\d/.test(text)) {
+                continue;
+            }
+            findings.push(findingFor(binding, {
+                path: file,
+                message: `test without a SPEC reference in ${file}`,
+                vars: { path: file },
+            }));
+        }
+        return findings;
+    }));
+}
+// SPEC §5.4 core/red-before-green: a fix with no recorded red proof flags.
+export function resolveRedBeforeGreen(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined) {
+                continue;
+            }
+            if ((parseMarkers(text).get("red-proof") ?? "") === "none") {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `fix with no red proof in ${file}`,
+                    vars: { path: file },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §5.4 core/test-kinds-by-scenario: a hot path covered by unit tests
+// alone flags; the scenario classifier (SPEC §4.10) owns the full mapping.
+export function resolveTestKindsByScenario(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined || !text.includes("unit only")) {
+                continue;
+            }
+            findings.push(findingFor(binding, {
+                path: file,
+                message: `scenario covered by unit tests alone in ${file}`,
+                vars: { path: file },
+            }));
+        }
+        return findings;
+    }));
+}
+// SPEC §5.4 core/regression-test-for-fix: a fix with no regression test
+// flags.
+export function resolveRegressionTestForFix(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined) {
+                continue;
+            }
+            if ((parseMarkers(text).get("regression-test") ?? "") === "none") {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `fix with no regression test in ${file}`,
+                    vars: { path: file },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §5.4 core/coverage-floor: line or branch cover under the tunable
+// floor flags.
+export function resolveCoverageFloor(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const floor = (name, fallback) => {
+        const raw = binding.tunables[name];
+        return typeof raw === "number" && Number.isFinite(raw) ? raw : fallback;
+    };
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined) {
+                continue;
+            }
+            const markers = parseMarkers(text);
+            const lines = parseMarkerInt(markers, "lines");
+            const branches = parseMarkerInt(markers, "branches");
+            if ((lines !== undefined && lines < floor("lines", 90)) ||
+                (branches !== undefined && branches < floor("branches", 80))) {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `coverage under the floor in ${file}`,
+                    vars: {
+                        path: file,
+                        limit: `${String(floor("lines", 90))}/${String(floor("branches", 80))}`,
+                    },
+                }));
+            }
+        }
+        return findings;
+    }));
+}

package/dist/features/packs/enforcers/ts-checks.d.ts

@@ -0,0 +1,7 @@
+import type { Ports } from "../../../kernel/index.ts";
+import { type Result } from "../../../kernel/index.ts";
+import type { Enforcer } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+export declare function resolveTsTypecheck(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveTsLint(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;

package/dist/features/packs/enforcers/ts-checks.js

@@ -0,0 +1,101 @@
+import { ok } from "../../../kernel/index.js";
+import { bindRule, findingFor, readErrorFinding, readLossyText, selectFiles, } from "./binding.js";
+import { blankCode } from "./health-lex.js";
+import { baseEnforcer, isTsFile } from "./health-measures.js";
+// SPEC §6.1 ts/typecheck as the L1 static approximation: an annotated
+// literal of the wrong primitive type is a type error the compiler would
+// also reject. The repo tsc --noEmit run stays on the external contract.
+export function resolveTsTypecheck(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const mismatch = /:\s*(number|string|boolean)\s*=\s*("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\b\d+(\.\d+)?\b|\btrue\b|\bfalse\b)/;
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            if (!isTsFile(file)) {
+                continue;
+            }
+            const loaded = await readLossyText(ports.fs, file);
+            if (!loaded.ok) {
+                findings.push(readErrorFinding(binding, file, loaded.error, "read"));
+                continue;
+            }
+            let line = 0;
+            for (const content of loaded.value.text.split("\n")) {
+                line += 1;
+                const hit = mismatch.exec(content);
+                if (hit === null) {
+                    continue;
+                }
+                const annotated = hit[1] ?? "";
+                const literal = hit[2] ?? "";
+                const literalKind = literal.startsWith('"') ||
+                    literal.startsWith("'") ||
+                    literal.startsWith("`")
+                    ? "string"
+                    : literal === "true" || literal === "false"
+                        ? "boolean"
+                        : "number";
+                if (annotated !== literalKind) {
+                    findings.push(findingFor(binding, {
+                        path: file,
+                        line,
+                        message: `type error in ${file}:${String(line)}: ${annotated} assigned ${literal}`,
+                        vars: { path: file, line: String(line), value: literal },
+                    }));
+                }
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §6.1 ts/lint as the L1 static approximation: `var` bindings and
+// never-read `let`/`const` bindings. The repo linter run stays on the
+// external contract.
+export function resolveTsLint(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            if (!isTsFile(file)) {
+                continue;
+            }
+            const loaded = await readLossyText(ports.fs, file);
+            if (!loaded.ok) {
+                findings.push(readErrorFinding(binding, file, loaded.error, "read"));
+                continue;
+            }
+            const blanked = blankCode(loaded.value.text);
+            const lines = blanked.split("\n");
+            const declared = new Map();
+            for (let line = 0; line < lines.length; line += 1) {
+                const content = lines[line] ?? "";
+                const varHit = /\bvar\s+([A-Za-z_$][\w$]*)/.exec(content);
+                if (varHit !== null) {
+                    findings.push(findingFor(binding, {
+                        path: file,
+                        line: line + 1,
+                        message: `var binding ${varHit[1] ?? ""} in ${file}:${String(line + 1)}`,
+                        vars: { path: file, line: String(line + 1) },
+                    }));
+                }
+                const constHit = /\b(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=/.exec(content);
+                if (constHit !== null && (constHit[1] ?? "") !== "") {
+                    declared.set(constHit[1] ?? "", line + 1);
+                }
+            }
+            for (const [name, atLine] of declared) {
+                const word = new RegExp(`\\b${name}\\b`, "g");
+                const uses = blanked.match(word) ?? [];
+                if (uses.length <= 1) {
+                    findings.push(findingFor(binding, {
+                        path: file,
+                        line: atLine,
+                        message: `unused binding ${name} in ${file}:${String(atLine)}`,
+                        vars: { path: file, line: String(atLine) },
+                    }));
+                }
+            }
+        }
+        return findings;
+    }));
+}

package/dist/features/packs/enforcers/ts-phantom-host.d.ts

@@ -0,0 +1,11 @@
+import { type Result } from "../../../kernel/index.ts";
+import type { Finding } from "../../engine/index.ts";
+import { type RuleBinding } from "./binding.ts";
+export interface HostProvidedConfig {
+    readonly grants: ReadonlyArray<{
+        readonly dir: string;
+        readonly specs: ReadonlySet<string>;
+    }>;
+}
+export declare function narrowHostProvidedArgs(declId: string, args: unknown): Result<HostProvidedConfig>;
+export declare function phantomFindings(binding: RuleBinding, file: string, text: string, declared: ReadonlySet<string>, grants: Readonly<HostProvidedConfig["grants"]>): Array<Finding>;

package/dist/features/packs/enforcers/ts-phantom-host.js

@@ -0,0 +1,155 @@
+// SPEC §6.4 EC-11: host-provided module grants for ts/no-phantom-import.
+// Narrowing and matching live here so the enforcer entry stays thin; the
+// pack manifest binds the map (§7.3: args ride along opaquely), keyed by
+// package dir with a specifier list each.
+import { err, ok } from "../../../kernel/index.js";
+import { field, isRecord } from "../manifest.js";
+import { argsRecord, bindingError, findingFor, stringList, } from "./binding.js";
+import { extractLiteralSpecifiers } from "./health-lex-imports.js";
+// SPEC §6.4 EC-4: a built-in, never phantom. Mirrors the §6.1 supply list
+// (builtin-packs/typescript), duplicated here because §3.3 forbids the
+// packs module from importing the pack supplies.
+const NODE_BUILTINS = [
+    "assert",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "module",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "repl",
+    "stream",
+    "string_decoder",
+    "sys",
+    "timers",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib",
+];
+function isBuiltinSpecifier(spec) {
+    if (spec.startsWith("node:")) {
+        return true;
+    }
+    const base = spec.split("/", 1)[0] ?? "";
+    return NODE_BUILTINS.includes(base);
+}
+function isRelativeSpecifier(spec) {
+    return (spec.startsWith("./") ||
+        spec.startsWith("../") ||
+        spec.startsWith("/") ||
+        spec === "." ||
+        spec === "..");
+}
+function narrowHostProvidedEntry(declId, dir, value) {
+    if (dir.length === 0) {
+        return bindingError(declId, "needs non-empty package dirs in args");
+    }
+    const specs = stringList(value);
+    if (specs === undefined ||
+        specs.length === 0 ||
+        specs.some((entry) => entry.length === 0)) {
+        return bindingError(declId, `needs a non-empty specifier list for package dir "${dir}" in args`);
+    }
+    return ok({ dir, specs: new Set(specs) });
+}
+function narrowHostProvidedGrants(declId, raw) {
+    const grants = [];
+    for (const dir of Object.keys(raw).sort()) {
+        const narrowed = narrowHostProvidedEntry(declId, dir, field(raw, dir));
+        if (!narrowed.ok) {
+            return err(narrowed.error);
+        }
+        grants.push(narrowed.value);
+    }
+    return ok(grants);
+}
+// SPEC §6.4 EC-11: host-provided modules arrive in decl args as a package
+// dir to specifier list map. Absent args mean no grant, malformed args fail
+// the load (CDX-E203), so a typo never silently widens the rule.
+export function narrowHostProvidedArgs(declId, args) {
+    if (args === undefined) {
+        return ok({ grants: [] });
+    }
+    const record = argsRecord(declId, args);
+    if (!record.ok) {
+        return err(record.error);
+    }
+    const raw = field(record.value, "hostProvided");
+    if (raw === undefined) {
+        return ok({ grants: [] });
+    }
+    if (!isRecord(raw)) {
+        return bindingError(declId, 'needs a "hostProvided" object in args keyed by package dir');
+    }
+    const grants = narrowHostProvidedGrants(declId, raw);
+    if (!grants.ok) {
+        return err(grants.error);
+    }
+    return ok({ grants: grants.value });
+}
+function specBase(spec) {
+    if (spec.startsWith("@")) {
+        return spec.split("/", 2).join("/");
+    }
+    return spec.split("/", 1)[0] ?? "";
+}
+function isHostProvided(grants, file, spec) {
+    const normalized = file.replaceAll("\\", "/");
+    const base = specBase(spec);
+    return grants.some((grant) => (normalized === grant.dir || normalized.startsWith(`${grant.dir}/`)) &&
+        grant.specs.has(base));
+}
+// The bare-import findings: relative and built-in specifiers never block,
+// host-provided grants count as declared inside their package dir, and the
+// rest must resolve to a declared dependency.
+export function phantomFindings(binding, file, text, declared, grants) {
+    const findings = [];
+    const seen = new Set();
+    for (const { spec, line } of extractLiteralSpecifiers(text)) {
+        if (seen.has(spec)) {
+            continue;
+        }
+        seen.add(spec);
+        if (isRelativeSpecifier(spec) || isBuiltinSpecifier(spec)) {
+            continue;
+        }
+        if (isHostProvided(grants, file, spec)) {
+            continue;
+        }
+        if (!declared.has(specBase(spec))) {
+            findings.push(findingFor(binding, {
+                path: file,
+                line,
+                message: `phantom import ${spec} in ${file}:${String(line)}`,
+                vars: { path: file, line: String(line), value: spec },
+            }));
+        }
+    }
+    return findings;
+}

package/dist/features/packs/enforcers/ts-phantom.d.ts

@@ -0,0 +1,6 @@
+import type { Ports } from "../../../kernel/index.ts";
+import { type Result } from "../../../kernel/index.ts";
+import type { Enforcer } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+export declare function resolveTsNoPhantomImport(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;

package/dist/features/packs/enforcers/ts-phantom.js

@@ -0,0 +1,117 @@
+// SPEC §6.1 ts/no-phantom-import: a bare import resolves to a declared
+// dependency or a Node built-in. Specifier matching lives in the
+// ts-phantom-host sibling; relative and built-in imports never block;
+// SPEC §6.4 EC-5 workspace siblings count as declared; SPEC §6.4 EC-11
+// host-provided modules count as declared inside their package dir.
+import { err, makeError, ok, parseJson, } from "../../../kernel/index.js";
+import { bindRule, readErrorFinding, readLossyText, selectFiles, } from "./binding.js";
+import { baseEnforcer, isTsFile } from "./health-measures.js";
+import { narrowHostProvidedArgs, phantomFindings, } from "./ts-phantom-host.js";
+function parentDir(path) {
+    const slash = path.lastIndexOf("/");
+    return slash < 0 ? "" : path.slice(0, slash);
+}
+function collectDeclaredNames(manifest) {
+    const names = new Set();
+    if (typeof manifest !== "object" ||
+        manifest === null ||
+        Array.isArray(manifest)) {
+        return names;
+    }
+    const record = manifest;
+    for (const section of [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+    ]) {
+        const entries = record[section];
+        if (typeof entries !== "object" ||
+            entries === null ||
+            Array.isArray(entries)) {
+            continue;
+        }
+        for (const name of Object.keys(entries)) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+async function declaredNamesFor(ports, file) {
+    // Nearest package.json walking up from the importing file; no manifest
+    // means no declared dependency, so every bare import is phantom.
+    // A throw reads as missing (the fake port throws for unseeded paths);
+    // only a found-but-unparseable manifest reports CDX-E903.
+    let dir = parentDir(file);
+    for (let depth = 0; depth < 25; depth += 1) {
+        const candidate = dir === "" ? "package.json" : `${dir}/package.json`;
+        let raw;
+        try {
+            const loaded = await ports.fs.read(candidate);
+            if (!loaded.ok) {
+                if (dir === "") {
+                    return { names: new Set(), broken: undefined };
+                }
+                dir = parentDir(dir);
+                continue;
+            }
+            raw = loaded.value;
+        }
+        catch {
+            if (dir === "") {
+                return { names: new Set(), broken: undefined };
+            }
+            dir = parentDir(dir);
+            continue;
+        }
+        const text = new TextDecoder("utf-8", { fatal: false }).decode(raw);
+        const parsed = parseJson(text);
+        if (parsed.ok) {
+            return { names: collectDeclaredNames(parsed.value), broken: undefined };
+        }
+        return { names: new Set(), broken: candidate };
+    }
+    return { names: new Set(), broken: undefined };
+}
+// One TS file judged for phantom imports: unreadable content and an
+// unparseable manifest fail closed; the rest is specifier matching.
+async function findingsForFile(ports, binding, grants, file) {
+    const loaded = await readLossyText(ports.fs, file);
+    if (!loaded.ok) {
+        return [readErrorFinding(binding, file, loaded.error, "read")];
+    }
+    const declared = await declaredNamesFor(ports, file);
+    const findings = [];
+    if (declared.broken !== undefined) {
+        findings.push(readErrorFinding(binding, declared.broken, makeError("CDX-E903", `package.json above ${file} is unparseable`, "Fix the nearest package.json so it parses, then reload."), "read"));
+    }
+    // Import specifiers come from the lexer, never a regex, so
+    // specifiers inside strings, comments and fixture text never
+    // count; non-literal dynamics yield nothing to judge.
+    for (const found of phantomFindings(binding, file, loaded.value.text, declared.names, grants)) {
+        findings.push(found);
+    }
+    return findings;
+}
+// SPEC §6.1 ts/no-phantom-import: a bare import resolves to a declared
+// dependency or a Node built-in. Relative and built-in imports never
+// block; SPEC §6.4 EC-5 workspace siblings count as declared.
+export function resolveTsNoPhantomImport(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const hostProvided = narrowHostProvidedArgs(decl.id, decl.args);
+    if (!hostProvided.ok) {
+        return err(hostProvided.error);
+    }
+    const grants = hostProvided.value.grants;
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            if (!isTsFile(file)) {
+                continue;
+            }
+            for (const found of await findingsForFile(ports, binding, grants, file)) {
+                findings.push(found);
+            }
+        }
+        return findings;
+    }));
+}

package/dist/features/packs/enforcers/ts-security-patterns.d.ts

@@ -0,0 +1,18 @@
+import { type Ports } from "../../../kernel/index.ts";
+import type { CheckContext, Finding } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+export declare function resolveTsSecurityPatterns(decl: EnforcerDecl, rule: PackRule, ports: Ports): {
+    ok: false;
+    error: import("../../../kernel/errors.ts").CdxError;
+    value?: never;
+} | {
+    error?: never;
+    ok: true;
+    value: {
+        id: string;
+        kinds: readonly ("compact" | "post-tool" | "pre-tool" | "prompt" | "review" | "scheduled" | "startup")[];
+        budgetMs: number;
+        check: (ctx: CheckContext) => Promise<Array<Finding>>;
+    };
+};

package/dist/features/packs/enforcers/ts-security-patterns.js

@@ -0,0 +1,93 @@
+// SPEC §6.1 ts/security-patterns: dangerous JS patterns over TypeScript
+// and JavaScript files. eval(, new Function(, child_process exec/execSync
+// with a template or concatenated argument, innerHTML/outerHTML
+// assignment, document.write(, dangerouslySetInnerHTML,
+// rejectUnauthorized: false, NODE_TLS_REJECT_UNAUTHORIZED and template or
+// concatenated SQL passed to .query(, .execute( or .raw( all block. Only
+// language files are scanned, line by line like the parametric patterns.
+import { checkPattern } from "../../../kernel/index.js";
+import { bindRule, findingFor, readErrorFinding, readLossyText, selectFiles, } from "./binding.js";
+const TS_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+];
+const RAW_PATTERNS = [
+    { id: "eval", pattern: "\\beval\\s*\\(" },
+    { id: "Function", pattern: "\\bnew\\s+Function\\s*\\(" },
+    {
+        id: "exec-template",
+        pattern: "\\bexec(Sync)?\\s*\\([^)\\n]*`[^`\\n]*\\$\\{",
+    },
+    { id: "exec-concat", pattern: "\\bexec(Sync)?\\s*\\([^)\\n]*\\+" },
+    { id: "innerHTML", pattern: "\\b(innerHTML|outerHTML)\\s*=\\s*(?![=>])" },
+    { id: "document-write", pattern: "\\bdocument\\.write\\s*\\(" },
+    { id: "dangerouslySetInnerHTML", pattern: "\\bdangerouslySetInnerHTML\\b" },
+    {
+        id: "rejectUnauthorized",
+        pattern: "\\brejectUnauthorized\\s*:\\s*false\\b",
+    },
+    { id: "tls-env", pattern: "\\bNODE_TLS_REJECT_UNAUTHORIZED\\b" },
+    {
+        id: "sql-template",
+        pattern: "\\.(query|execute|raw)\\s*\\([^)\\n]*`[^`\\n]*\\$\\{",
+    },
+    { id: "sql-concat", pattern: "\\.(query|execute|raw)\\s*\\([^)\\n]*\\+" },
+];
+function isTsFile(path) {
+    const lowered = path.toLowerCase();
+    return TS_EXTENSIONS.some((extension) => lowered.endsWith(extension));
+}
+export function resolveTsSecurityPatterns(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const compiled = [];
+    for (const entry of RAW_PATTERNS) {
+        const safe = checkPattern(entry.pattern);
+        if (!safe.ok) {
+            return { ok: false, error: safe.error };
+        }
+        compiled.push({ id: entry.id, pattern: new RegExp(entry.pattern) });
+    }
+    return {
+        ok: true,
+        value: {
+            id: rule.id,
+            kinds: binding.triggers,
+            budgetMs: decl.budgetMs,
+            check: async (ctx) => {
+                const findings = [];
+                for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+                    if (!isTsFile(file)) {
+                        continue;
+                    }
+                    const loaded = await readLossyText(ports.fs, file);
+                    if (!loaded.ok) {
+                        findings.push(readErrorFinding(binding, file, loaded.error, "read"));
+                        continue;
+                    }
+                    let line = 0;
+                    for (const content of loaded.value.text.split("\n")) {
+                        line += 1;
+                        for (const entry of compiled) {
+                            if (entry.pattern.test(content)) {
+                                findings.push(findingFor(binding, {
+                                    path: file,
+                                    line,
+                                    message: `dangerous pattern ${entry.id} in ${file}:${String(line)}`,
+                                    vars: { path: file, line: String(line) },
+                                }));
+                                break;
+                            }
+                        }
+                    }
+                }
+                return findings;
+            },
+        },
+    };
+}

package/dist/features/packs/enforcers/workflow-guards.d.ts

@@ -0,0 +1,10 @@
+import type { Ports } from "../../../kernel/index.ts";
+import { type Result } from "../../../kernel/index.ts";
+import type { Enforcer } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+export declare function resolveWorkflowGates(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveWritesWithinPlan(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveLoopBreaker(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveReviewGate(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveReviewRoundCap(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;