codictator 0.0.0 → 0.1.3

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

@@ -0,0 +1,131 @@
+import { ok } from "../../../kernel/index.js";
+import { bindRule, findingFor, selectFiles } from "./binding.js";
+import { baseEnforcer, isMarkerFile, loadScopeText, parseMarkers, scopeMarkerTexts, } from "./health-measures.js";
+// SPEC §4.15.2 core/ci-present: no committed workflow flags; a named one
+// stays quiet.
+export function resolveCiPresent(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const { file, markers } of await scopeMarkerTexts(ports, binding, ctx, findings)) {
+            const workflow = markers.get("workflow") ?? "";
+            if (workflow === "" || workflow === "missing") {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: "no CI workflow committed",
+                    vars: { path: file, detail: "the CI workflow" },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §4.15.2 core/ci-actions-pinned: every uses: in every workflow is a
+// 40-hex SHA (EC-5). A ref without @, or with anything but a full SHA,
+// flags; containers and images stay with the ci module's read.
+export function resolveCiActionsPinned(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 || !isMarkerFile(file)) {
+                continue;
+            }
+            for (const line of text.split("\n")) {
+                const colon = line.indexOf(":");
+                if (colon < 0) {
+                    continue;
+                }
+                if (line.slice(0, colon).trim().toLowerCase() !== "uses") {
+                    continue;
+                }
+                const uses = line.slice(colon + 1).trim();
+                const at = uses.indexOf("@");
+                const ref = at >= 0 ? uses.slice(at + 1) : "";
+                if (/^[0-9a-f]{40}$/.test(ref) !== true) {
+                    findings.push(findingFor(binding, {
+                        path: file,
+                        message: `${uses} pins no full commit SHA`,
+                        vars: { path: file, value: uses },
+                    }));
+                }
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §4.15.2 core/branch-protection: a direct push to the default branch
+// flags; a push via PR with checks stays quiet. The live force-push,
+// deletion and squash reads stay in ci/evaluateProtection; the marker
+// mirror answers the same question from the case report.
+export function resolveBranchProtection(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const { file, markers } of await scopeMarkerTexts(ports, binding, ctx, findings)) {
+            if ((markers.get("direct") ?? "") === "true") {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: "direct push to the default branch bypasses review",
+                    vars: { path: file, detail: markers.get("push") ?? "main" },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §4.15.2 + EC-7 core/ci-required-check: the default branch must
+// require the verify check; a required set without it blocks. Mirrors the
+// live ci/evaluateProtection block; a missing list also blocks (verify not
+// reported required), while unreadable advise stays with the live read.
+export function resolveCiRequiredCheck(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const { file, markers } of await scopeMarkerTexts(ports, binding, ctx, findings)) {
+            const required = (markers.get("required") ?? "")
+                .split(",")
+                .map((entry) => entry.trim().toLowerCase())
+                .filter((entry) => entry !== "");
+            if (!required.includes("verify")) {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: "the verify check is not a required check",
+                    vars: { path: file, detail: "verify" },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §5.11 core/conventional-commit: the subject matches the
+// type(scope)!: detail form. A subject with no type prefix flags. Body and
+// module-name scope reads stay in the owning commit path; the marker
+// mirror judges the subject shape from the case report.
+const SUBJECT_PATTERN = /^(feat|fix|docs|refactor|test|chore|perf|ci|build|revert)(\([a-z0-9-]+\))?!?: \S.{0,71}$/;
+export function resolveConventionalCommit(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);
+            // Commit subjects arrive as marker reports (SPEC §4.4.1
+            // sample.txt fixtures); source files carry `subject:` lines
+            // of their own (parameters, YAML keys), which are not commits.
+            if (text === undefined || !isMarkerFile(file)) {
+                continue;
+            }
+            const subject = parseMarkers(text).get("subject") ?? "";
+            if (subject === "" || SUBJECT_PATTERN.test(subject)) {
+                continue;
+            }
+            findings.push(findingFor(binding, {
+                path: file,
+                message: "commit subject does not match the conventional form",
+                vars: { path: file, detail: subject },
+            }));
+        }
+        return findings;
+    }));
+}

package/dist/features/packs/enforcers/code-health.d.ts

@@ -0,0 +1,9 @@
+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 resolveFunctionSize(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveComplexity(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveNoGuardRemoval(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveRatchetTouchedImproves(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;

package/dist/features/packs/enforcers/code-health.js

@@ -0,0 +1,180 @@
+import { ok } from "../../../kernel/index.js";
+import { bindRule, findingFor, isTestPath, selectFiles, } from "./binding.js";
+import { blankCode } from "./health-lex.js";
+import { baseEnforcer, countCyclomatic, isMarkerFile, isTsFile, limitOf, loadScopeText, measureFunctionSpans, parseMarkerInt, parseMarkers, } from "./health-measures.js";
+// SPEC §5.6 core/function-size: functions stay under maxLines lines.
+export function resolveFunctionSize(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const maxLines = limitOf(binding, "maxLines", 40);
+    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 (isMarkerFile(file)) {
+                const lines = parseMarkerInt(parseMarkers(text), "function-lines");
+                if (lines !== undefined && lines > maxLines) {
+                    findings.push(findingFor(binding, {
+                        path: file,
+                        line: 1,
+                        message: `function over the size limit in ${file}`,
+                        vars: {
+                            path: file,
+                            line: "1",
+                            limit: String(maxLines),
+                            value: String(lines),
+                        },
+                    }));
+                }
+                continue;
+            }
+            if (!isTsFile(file) || isTestPath(file)) {
+                continue;
+            }
+            findings.push(...oversizedSpans(binding, file, text, maxLines));
+        }
+        return findings;
+    }));
+}
+function oversizedSpans(binding, file, text, maxLines) {
+    const findings = [];
+    for (const span of measureFunctionSpans(text)) {
+        if (span.lines > maxLines) {
+            findings.push(findingFor(binding, {
+                path: file,
+                line: span.line,
+                message: `function over the size limit at ${file}:${String(span.line)}`,
+                vars: {
+                    path: file,
+                    line: String(span.line),
+                    limit: String(maxLines),
+                    value: String(span.lines),
+                },
+            }));
+        }
+    }
+    return findings;
+}
+// SPEC §5.6 core/complexity: cyclomatic complexity stays under
+// maxCyclomatic per function body. Whole-file counting flags every module
+// with more than a couple of branches, so the measure runs over each
+// function span the §6.1 brace matcher finds.
+export function resolveComplexity(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const maxCyclomatic = limitOf(binding, "maxCyclomatic", 10);
+    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 (isMarkerFile(file)) {
+                const value = parseMarkerInt(parseMarkers(text), "cyclomatic");
+                if (value !== undefined && value > maxCyclomatic) {
+                    findings.push(findingFor(binding, {
+                        path: file,
+                        line: 1,
+                        message: `complexity over the limit in ${file}`,
+                        vars: {
+                            path: file,
+                            line: "1",
+                            limit: String(maxCyclomatic),
+                            value: String(value),
+                        },
+                    }));
+                }
+                continue;
+            }
+            if (!isTsFile(file) || isTestPath(file)) {
+                continue;
+            }
+            const lines = text.split("\n");
+            findings.push(...overComplexSpans(binding, file, text, lines, maxCyclomatic));
+        }
+        return findings;
+    }));
+}
+function overComplexSpans(binding, file, text, lines, maxCyclomatic) {
+    const findings = [];
+    for (const span of measureFunctionSpans(text)) {
+        const body = blankCode(lines.slice(span.line - 1, span.line - 1 + span.lines).join("\n"));
+        const value = countCyclomatic(body);
+        if (value > maxCyclomatic) {
+            findings.push(findingFor(binding, {
+                path: file,
+                line: span.line,
+                message: `complexity over the limit at ${file}:${String(span.line)}`,
+                vars: {
+                    path: file,
+                    line: String(span.line),
+                    limit: String(maxCyclomatic),
+                    value: String(value),
+                },
+            }));
+        }
+    }
+    return findings;
+}
+// SPEC §5.6 core/no-guard-removal: no deleted validation, throw or assert
+// in a living function. The enforcer sees current file content only, so
+// the fixture measure report carries the removal; without a base diff
+// there is nothing to judge and the rule stays quiet.
+export function resolveNoGuardRemoval(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 || !isMarkerFile(file)) {
+                continue;
+            }
+            const removed = parseMarkers(text).get("removed") ?? "";
+            const isGuardRemoval = removed.length > 0 &&
+                removed !== "none" &&
+                /throw|assert|\.parse\(|valid|guard|check|require/i.test(removed);
+            if (isGuardRemoval) {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    line: 1,
+                    message: `guard removed in ${file}: ${removed}`,
+                    vars: { path: file, line: "1", value: removed },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §5.6 core/ratchet-touched-improves: touching a file lowers at
+// least one ratchet metric by minDecrement. The delta rides the fixture
+// measure report; without baseline data there is nothing to compare.
+export function resolveRatchetTouchedImproves(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const minDecrement = limitOf(binding, "minDecrement", 1);
+    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 || !isMarkerFile(file)) {
+                continue;
+            }
+            const delta = parseMarkerInt(parseMarkers(text), "touched-delta");
+            if (delta !== undefined && delta + minDecrement > 0) {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    line: 1,
+                    message: `touched file ${file} improves no ratchet metric`,
+                    vars: {
+                        path: file,
+                        line: "1",
+                        limit: String(minDecrement),
+                        value: String(delta),
+                    },
+                }));
+            }
+        }
+        return findings;
+    }));
+}

package/dist/features/packs/enforcers/code.d.ts

@@ -0,0 +1,5 @@
+import type { Ports, 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 resolveCodeEnforcer(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer | undefined>;

package/dist/features/packs/enforcers/code.js

@@ -0,0 +1,129 @@
+import { ok } from "../../../kernel/index.js";
+import { resolveArchBoundaries, resolveArchModuleMapped, resolveArchModuleSize, resolveArchNoCycles, resolveArchProfileDeclared, resolveArchPublicEntry, resolveCompilerStrict, } from "./arch-guards.js";
+import { resolveBranchProtection, resolveCiActionsPinned, resolveCiPresent, resolveCiRequiredCheck, resolveConventionalCommit, } from "./ci-guards.js";
+import { resolveComplexity, resolveFunctionSize, resolveNoGuardRemoval, resolveRatchetTouchedImproves, } from "./code-health.js";
+import { resolveDepExactPin, resolveDepLatestStable, resolveDepLockfile, resolveDepNewNeedsReason, } from "./deps-guards.js";
+import { resolveDepLicense, resolveDepNoDeprecated, resolveDepNoVulnerable, resolveDepOnePerCapability, } from "./deps-policy-guards.js";
+import { resolveDocNoCorpusCounts, resolveDocOneLevel, resolveDocPlacement, resolveDocRouterLeaf, resolveDocSingleOwner, } from "./docs-guards.js";
+import { resolveDocBreadth, resolveDocDensity, resolveDocLinksValid, resolveDocNoInlineChangelog, } from "./docs-guards-measures.js";
+import { resolveEngineVersionMatch } from "./engine-version-guards.js";
+import { resolveAgentAssetsPresent, resolveCustomPackSelftest, resolveGuardrailManifest, resolveHooksActive, resolvePerfBudgets, resolveWaiversValid, } from "./gate-guards.js";
+import { resolveNoSpeculativeAbstraction } from "./health-abstraction.js";
+import { resolveDuplication } from "./health-duplication.js";
+import { resolveDeadCode } from "./health-refs.js";
+import { resolveNoAssertionLoss, resolveNoBaselineRaise, resolveNoFixtureShrink, resolveNoNewSuppressions, resolveNoSkippedTests, resolveNoThresholdLowering, resolveTestCommandIntact, } from "./integrity-guards.js";
+import { resolveNoBypass, resolveRepoHygiene, } from "./integrity-guards-repo.js";
+import { resolvePythonLint, resolvePythonTypecheck } from "./py-checks.js";
+import { resolvePythonNoPhantomImport } from "./py-phantom.js";
+import { resolvePythonSecurityPatterns } from "./py-security-patterns.js";
+import { resolveBugRegistry, resolveBugRowsImmutable, resolveDiagnoseBeforeFix, resolveFileNaming, resolveHistoryAppendOnly, resolveHistoryEntry, resolveHistoryEntryComplete, } from "./records-guards.js";
+import { resolveRemediationStepSize } from "./remediation-guards.js";
+import { resolveNoSecretReads, resolveNoSecrets } from "./secret-scan.js";
+import { resolveDangerousShell } from "./shell-analyse.js";
+import { resolveContextHardBand, resolveContextSoftBand, resolveGraphBeforeScan, resolveMcpDeclared, resolveReadDedupe, resolveSessionToolCallLimit, } from "./steering-guards.js";
+import { resolveCoverageFloor, resolveRedBeforeGreen, resolveRegressionTestForFix, resolveSpecTrace, resolveTestKindsByScenario, } from "./testing-guards.js";
+import { resolveTsLint, resolveTsTypecheck } from "./ts-checks.js";
+import { resolveTsNoPhantomImport } from "./ts-phantom.js";
+import { resolveTsSecurityPatterns } from "./ts-security-patterns.js";
+import { resolveLoopBreaker, resolveReviewGate, resolveReviewRoundCap, resolveWorkflowGates, resolveWritesWithinPlan, } from "./workflow-guards.js";
+import { resolveWriteConfinement } from "./write-confine.js";
+const CODE_RESOLVERS = {
+    "core/no-secrets": resolveNoSecrets,
+    "core/no-secret-reads": resolveNoSecretReads,
+    "core/dangerous-shell": resolveDangerousShell,
+    "core/write-confinement": resolveWriteConfinement,
+    "ts/security-patterns": resolveTsSecurityPatterns,
+    "core/function-size": resolveFunctionSize,
+    "core/complexity": resolveComplexity,
+    "core/dead-code": resolveDeadCode,
+    "core/duplication": resolveDuplication,
+    "core/no-speculative-abstraction": resolveNoSpeculativeAbstraction,
+    "core/no-guard-removal": resolveNoGuardRemoval,
+    "core/ratchet-touched-improves": resolveRatchetTouchedImproves,
+    "ts/typecheck": resolveTsTypecheck,
+    "ts/lint": resolveTsLint,
+    "ts/no-phantom-import": resolveTsNoPhantomImport,
+    "python/typecheck": resolvePythonTypecheck,
+    "python/lint": resolvePythonLint,
+    "python/no-phantom-import": resolvePythonNoPhantomImport,
+    "python/security-patterns": resolvePythonSecurityPatterns,
+    "core/no-skipped-tests": resolveNoSkippedTests,
+    "core/no-new-suppressions": resolveNoNewSuppressions,
+    "core/no-fixture-shrink": resolveNoFixtureShrink,
+    "core/no-threshold-lowering": resolveNoThresholdLowering,
+    "core/test-command-intact": resolveTestCommandIntact,
+    "core/no-baseline-raise": resolveNoBaselineRaise,
+    "core/no-assertion-loss": resolveNoAssertionLoss,
+    "core/spec-trace": resolveSpecTrace,
+    "core/red-before-green": resolveRedBeforeGreen,
+    "core/test-kinds-by-scenario": resolveTestKindsByScenario,
+    "core/regression-test-for-fix": resolveRegressionTestForFix,
+    "core/coverage-floor": resolveCoverageFloor,
+    "core/arch-profile-declared": resolveArchProfileDeclared,
+    "core/arch-module-mapped": resolveArchModuleMapped,
+    "core/arch-boundaries": resolveArchBoundaries,
+    "core/arch-public-entry": resolveArchPublicEntry,
+    "core/arch-no-cycles": resolveArchNoCycles,
+    "core/arch-module-size": resolveArchModuleSize,
+    "core/compiler-strict": resolveCompilerStrict,
+    "core/history-entry": resolveHistoryEntry,
+    "core/history-append-only": resolveHistoryAppendOnly,
+    "core/history-entry-complete": resolveHistoryEntryComplete,
+    "core/bug-registry": resolveBugRegistry,
+    "core/bug-rows-immutable": resolveBugRowsImmutable,
+    "core/diagnose-before-fix": resolveDiagnoseBeforeFix,
+    "core/workflow-gates": resolveWorkflowGates,
+    "core/writes-within-plan": resolveWritesWithinPlan,
+    "core/no-bypass": resolveNoBypass,
+    "core/repo-hygiene": resolveRepoHygiene,
+    "core/file-naming": resolveFileNaming,
+    "core/loop-breaker": resolveLoopBreaker,
+    "core/review-gate": resolveReviewGate,
+    "core/review-round-cap": resolveReviewRoundCap,
+    "core/doc-placement": resolveDocPlacement,
+    "core/doc-one-level": resolveDocOneLevel,
+    "core/doc-router-leaf": resolveDocRouterLeaf,
+    "core/doc-breadth": resolveDocBreadth,
+    "core/doc-density": resolveDocDensity,
+    "core/doc-links-valid": resolveDocLinksValid,
+    "core/doc-no-inline-changelog": resolveDocNoInlineChangelog,
+    "core/doc-no-corpus-counts": resolveDocNoCorpusCounts,
+    "core/doc-single-owner": resolveDocSingleOwner,
+    "core/dep-exact-pin": resolveDepExactPin,
+    "core/dep-lockfile": resolveDepLockfile,
+    "core/dep-no-vulnerable": resolveDepNoVulnerable,
+    "core/dep-no-deprecated": resolveDepNoDeprecated,
+    "core/dep-latest-stable": resolveDepLatestStable,
+    "core/dep-new-needs-reason": resolveDepNewNeedsReason,
+    "core/dep-one-per-capability": resolveDepOnePerCapability,
+    "core/dep-license": resolveDepLicense,
+    "core/remediation-step-size": resolveRemediationStepSize,
+    "core/context-soft-band": resolveContextSoftBand,
+    "core/context-hard-band": resolveContextHardBand,
+    "core/session-tool-call-limit": resolveSessionToolCallLimit,
+    "core/read-dedupe": resolveReadDedupe,
+    "core/graph-before-scan": resolveGraphBeforeScan,
+    "core/mcp-declared": resolveMcpDeclared,
+    "core/agent-assets-present": resolveAgentAssetsPresent,
+    "core/ci-present": resolveCiPresent,
+    "core/ci-actions-pinned": resolveCiActionsPinned,
+    "core/ci-required-check": resolveCiRequiredCheck,
+    "core/branch-protection": resolveBranchProtection,
+    "core/conventional-commit": resolveConventionalCommit,
+    "core/perf-budgets": resolvePerfBudgets,
+    "core/guardrail-manifest": resolveGuardrailManifest,
+    "core/hooks-active": resolveHooksActive,
+    "core/engine-version-match": resolveEngineVersionMatch,
+    "core/waivers-valid": resolveWaiversValid,
+    "core/custom-pack-selftest": resolveCustomPackSelftest,
+};
+// SPEC §4.4.3 step 4: one enforcer per referencing rule. An unknown rule
+// id resolves undefined and the registry defers it; a resolver failure
+// fails the load like any other parametric narrowing error.
+export function resolveCodeEnforcer(decl, rule, ports) {
+    const resolver = CODE_RESOLVERS[rule.id];
+    if (resolver === undefined) {
+        return ok(undefined);
+    }
+    return resolver(decl, rule, ports);
+}

package/dist/features/packs/enforcers/command-forbid.d.ts

@@ -0,0 +1,8 @@
+import { type Ports, type Result } from "../../../kernel/index.ts";
+import type { CheckContext, Finding } from "../../engine/index.ts";
+import { type RuleBinding } from "./binding.ts";
+export interface CommandForbidConfig {
+    readonly commands: ReadonlyArray<string>;
+}
+export declare function narrowCommandForbidArgs(declId: string, args: unknown): Result<CommandForbidConfig>;
+export declare function checkCommandForbid(ports: Ports, binding: RuleBinding, config: CommandForbidConfig, ctx: CheckContext): Promise<Array<Finding>>;

package/dist/features/packs/enforcers/command-forbid.js

@@ -0,0 +1,61 @@
+// SPEC §4.4.6 command-forbid: denied commands matched through the §4.7.2
+// shell analyser. Shell text arrives as `run:` lines of the scanned files
+// (shared with dangerous-shell); a whole shell script counts as one
+// source. An unparseable source fails closed with CDX-E306.
+import { analyseShell, err, ok, } from "../../../kernel/index.js";
+import { field } from "../manifest.js";
+import { argsRecord, bindingError, findingFor, readErrorFinding, readLossyText, selectFiles, stringList, } from "./binding.js";
+import { extractShellSources } from "./shell-analyse.js";
+// SPEC §4.4.6: the deny list arrives in decl args as non-empty command
+// names; matching is case-insensitive, like the analyser's own names.
+export function narrowCommandForbidArgs(declId, args) {
+    const record = argsRecord(declId, args);
+    if (!record.ok) {
+        return err(record.error);
+    }
+    const commands = (stringList(field(record.value, "commands")) ?? []).filter((entry) => entry.length > 0);
+    if (commands.length === 0) {
+        return bindingError(declId, "needs a non-empty commands list in args");
+    }
+    return ok({ commands });
+}
+export async function checkCommandForbid(ports, binding, config, ctx) {
+    const denied = new Set(config.commands.map((entry) => entry.toLowerCase()));
+    const findings = [];
+    for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+        const loaded = await readLossyText(ports.fs, file);
+        if (!loaded.ok) {
+            findings.push(readErrorFinding(binding, file, loaded.error, "read"));
+            continue;
+        }
+        for (const source of extractShellSources(loaded.value.text, file)) {
+            const parsed = analyseShell(source);
+            if (!parsed.ok) {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    code: parsed.error.code,
+                    message: `shell command in ${file} is unparseable`,
+                    vars: { path: file },
+                }));
+                continue;
+            }
+            for (const pipeline of parsed.value.pipelines) {
+                for (const command of pipeline.commands) {
+                    const name = command.name
+                        .replace(/\\/g, "/")
+                        .split("/")
+                        .pop()
+                        ?.toLowerCase();
+                    if (name !== undefined && denied.has(name)) {
+                        findings.push(findingFor(binding, {
+                            path: file,
+                            message: `forbidden command ${command.name} in ${file}`,
+                            vars: { path: file },
+                        }));
+                    }
+                }
+            }
+        }
+    }
+    return findings;
+}

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

@@ -0,0 +1,15 @@
+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 const CAPABILITIES: Readonly<Record<string, string>>;
+export declare const LICENSE_ALLOW: ReadonlyArray<string>;
+export declare function collectPinRanges(text: string): Array<{
+    name: string;
+    range: string;
+}>;
+export declare function resolveDepExactPin(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveDepLockfile(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveDepLatestStable(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveDepNewNeedsReason(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;