codictator 0.0.0 → 0.1.3

package/dist/features/records/history-parse.js

@@ -0,0 +1,101 @@
+// SPEC §7.7: history entry grammar and parser. Pure over caller-supplied
+// text: the base revision comes from the Git port at the enforcer layer,
+// never from here.
+import { normalizeText } from "../../kernel/index.js";
+const ENTRY_HEADING = /^## (\d{4}-\d{2}-\d{2}) · (.+?)\s*$/;
+const FIELD_LINE = /^- \*\*([A-Za-z -]+):\*\* (.*)$/;
+export const FILE_TITLE = /^# History — \d{4}-\d{2}-\d{2}(-\d+)?\s*$/;
+function emptyEntry(date, subject) {
+    return {
+        date,
+        subject,
+        kind: undefined,
+        task: undefined,
+        bug: undefined,
+        fields: new Map(),
+        depsLines: [],
+    };
+}
+function toKind(value) {
+    if (value === "code" ||
+        value === "docs" ||
+        value === "deps" ||
+        value === "guardrail") {
+        return value;
+    }
+    return undefined;
+}
+function newParseState() {
+    return {
+        current: undefined,
+        fields: new Map(),
+        depsLines: [],
+        entries: [],
+        errors: [],
+    };
+}
+function flushEntry(state) {
+    if (state.current !== undefined) {
+        state.entries.push({
+            ...state.current,
+            kind: toKind(state.fields.get("Kind")),
+            task: state.fields.get("Task"),
+            bug: state.fields.get("Bug"),
+            fields: new Map(state.fields),
+            depsLines: [...state.depsLines],
+        });
+    }
+    state.current = undefined;
+    state.fields = new Map();
+    state.depsLines = [];
+}
+function applyHeading(state, raw) {
+    const heading = ENTRY_HEADING.exec(raw);
+    if (heading === null) {
+        return false;
+    }
+    flushEntry(state);
+    state.current = emptyEntry(heading[1] ?? "", heading[2] ?? "");
+    return true;
+}
+function applyOutsideEntry(state, raw) {
+    if (raw.trim() !== "" && FILE_TITLE.exec(raw.trim()) === null) {
+        state.errors.push(`history text outside any entry: "${raw.trim()}"`);
+    }
+}
+function applyFieldLine(state, raw) {
+    const field = FIELD_LINE.exec(raw);
+    if (field === null) {
+        state.errors.push(`history line outside the field grammar: "${raw.trim()}"`);
+        return;
+    }
+    const name = field[1] ?? "";
+    const value = field[2] ?? "";
+    if (name === "Deps") {
+        state.depsLines.push(value);
+        return;
+    }
+    if (state.fields.has(name)) {
+        state.errors.push(`history field repeated in one entry: ${name}`);
+        return;
+    }
+    state.fields.set(name, value);
+}
+export function parseHistoryEntries(text) {
+    const state = newParseState();
+    for (const raw of normalizeText(text).split("\n")) {
+        if (applyHeading(state, raw)) {
+            continue;
+        }
+        if (state.current === undefined) {
+            applyOutsideEntry(state, raw);
+            continue;
+        }
+        if (raw.trim() === "") {
+            continue;
+        }
+        applyFieldLine(state, raw);
+    }
+    flushEntry(state);
+    return { entries: state.entries, errors: state.errors };
+}

package/dist/features/records/history-scope.d.ts

@@ -0,0 +1,5 @@
+import type { CheckContext, Finding } from "../engine/index.ts";
+import type { HistoryKind } from "./history-parse.ts";
+export declare function deriveHistoryKind(changedPaths: ReadonlyArray<string>, manifestPaths?: ReadonlySet<string>): HistoryKind;
+export declare function checkHistory(ctx: CheckContext, text: string, baseText?: string, commitSubject?: string): Promise<Array<Finding>>;
+export declare function checkHistoryFiles(files: ReadonlyArray<string>, text: string, baseText?: string, commitSubject?: string): Array<Finding>;

package/dist/features/records/history-scope.js

@@ -0,0 +1,86 @@
+import { checkHistoryAppendOnly, checkHistoryEntryComplete, checkHistoryEntryCount, entryFinding, } from "./history-checks.js";
+import { parseHistoryEntries } from "./history-parse.js";
+const TOOLCHAIN_FILES = new Set([
+    "package.json",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    ".nvmrc",
+    ".node-version",
+    ".editorconfig",
+    ".gitattributes",
+    ".gitignore",
+]);
+function isMetadata(path) {
+    const base = path.split("/").pop() ?? path;
+    return (base.startsWith("LICENSE") ||
+        base.startsWith("NOTICE") ||
+        TOOLCHAIN_FILES.has(base));
+}
+function isDocPath(path) {
+    return path.endsWith(".md") || isMetadata(path);
+}
+// SPEC §4.9.3: the kind follows the commit's paths after dropping record
+// files. manifestPaths names the guardrail-manifest entries (§4.14.1); lock
+// and toolchain files are the §4.8.1 set.
+export function deriveHistoryKind(changedPaths, manifestPaths = new Set()) {
+    const remaining = changedPaths.filter((path) => !path.startsWith("docs/HISTORY/") && !path.startsWith("docs/BUGS/"));
+    if (remaining.length === 0) {
+        return "docs";
+    }
+    const kinds = new Set();
+    for (const path of remaining) {
+        if (manifestPaths.has(path)) {
+            kinds.add("guardrail");
+        }
+        else if (path.endsWith(".lock") ||
+            TOOLCHAIN_FILES.has(path.split("/").pop() ?? path)) {
+            kinds.add("deps");
+        }
+        else if (isDocPath(path)) {
+            kinds.add("docs");
+        }
+        else {
+            kinds.add("code");
+        }
+    }
+    if (kinds.size === 1) {
+        const only = [...kinds][0];
+        return only ?? "code";
+    }
+    return "code";
+}
+function historyFileOf(files) {
+    return [...files]
+        .filter((file) => file.startsWith("docs/HISTORY/"))
+        .sort()[0];
+}
+// The evaluation-path entry: the staged files come from the check context;
+// count, subject, completeness and, when the base text is supplied,
+// append-only.
+export function checkHistory(ctx, text, baseText, commitSubject) {
+    return Promise.resolve(checkHistoryFiles(ctx.scope.files, text, baseText, commitSubject));
+}
+export function checkHistoryFiles(files, text, baseText, commitSubject) {
+    const historyPath = historyFileOf(files);
+    if (historyPath === undefined) {
+        return [
+            entryFinding("core/history-entry", "commit stages no history entry", "docs/HISTORY/"),
+        ];
+    }
+    const findings = checkHistoryEntryCount(text, historyPath, commitSubject);
+    if (findings.length > 0) {
+        return findings;
+    }
+    const parsed = parseHistoryEntries(text);
+    const entry = parsed.entries[0];
+    if (entry === undefined) {
+        return findings;
+    }
+    findings.push(...checkHistoryEntryComplete(entry, historyPath));
+    if (baseText !== undefined) {
+        findings.push(...checkHistoryAppendOnly(baseText, text, historyPath));
+    }
+    return findings;
+}

package/dist/features/records/history.d.ts

@@ -0,0 +1,3 @@
+export { checkHistoryAppendOnly, checkHistoryEntryComplete, checkHistoryEntryCount, } from "./history-checks.ts";
+export { type HistoryEntry, type HistoryKind, type HistoryParse, parseHistoryEntries, } from "./history-parse.ts";
+export { checkHistory, checkHistoryFiles, deriveHistoryKind, } from "./history-scope.ts";

package/dist/features/records/history.js

@@ -0,0 +1,5 @@
+// SPEC §4.9.3: history barrel path; parsing lives in history-parse.ts,
+// entry checks in history-checks.ts, kind and scope in history-scope.ts.
+export { checkHistoryAppendOnly, checkHistoryEntryComplete, checkHistoryEntryCount, } from "./history-checks.js";
+export { parseHistoryEntries, } from "./history-parse.js";
+export { checkHistory, checkHistoryFiles, deriveHistoryKind, } from "./history-scope.js";

package/dist/features/records/index.d.ts

@@ -0,0 +1,8 @@
+export { type BugFile, type BugRow, type BugStatus, parseBugFile, } from "./bug-grammar.ts";
+export { checkBugRegistry, checkDiagnoseBeforeFix, type TaskRef, } from "./bug-registry.ts";
+export { checkBugRowsImmutable } from "./bug-rows-immutable.ts";
+export { checkBugs } from "./bugs.ts";
+export { checkDocNoInlineChangelog, checkDocOneLevel, checkDocPlacement, checkDocSingleOwner, checkDocs, classifyDoc, type DocClass, } from "./docs.ts";
+export { checkDocDensity, checkDocLinksValid, checkDocNoCorpusCounts, githubSlug, splitSentences, } from "./docs-prose.ts";
+export { checkDocBreadth, checkDocRouterLeaf, checkDocSize, DEFAULT_DOC_LIMITS, type DocFile, type DocLimits, type RouterLeaf, type RouterTree, } from "./docs-structure.ts";
+export { checkHistory, checkHistoryAppendOnly, checkHistoryEntryComplete, checkHistoryEntryCount, checkHistoryFiles, deriveHistoryKind, type HistoryEntry, type HistoryKind, type HistoryParse, parseHistoryEntries, } from "./history.ts";

package/dist/features/records/index.js

@@ -0,0 +1,11 @@
+// SPEC §4.9: doc checks, history, bug registry. Owns the §7.7 record
+// grammars. The checks are pure over caller-supplied trees; ports stay at
+// the enforcer layer (SPEC §3.3).
+export { parseBugFile, } from "./bug-grammar.js";
+export { checkBugRegistry, checkDiagnoseBeforeFix, } from "./bug-registry.js";
+export { checkBugRowsImmutable } from "./bug-rows-immutable.js";
+export { checkBugs } from "./bugs.js";
+export { checkDocNoInlineChangelog, checkDocOneLevel, checkDocPlacement, checkDocSingleOwner, checkDocs, classifyDoc, } from "./docs.js";
+export { checkDocDensity, checkDocLinksValid, checkDocNoCorpusCounts, githubSlug, splitSentences, } from "./docs-prose.js";
+export { checkDocBreadth, checkDocRouterLeaf, checkDocSize, DEFAULT_DOC_LIMITS, } from "./docs-structure.js";
+export { checkHistory, checkHistoryAppendOnly, checkHistoryEntryComplete, checkHistoryEntryCount, checkHistoryFiles, deriveHistoryKind, parseHistoryEntries, } from "./history.js";

package/dist/features/remediation/adoption.d.ts

@@ -0,0 +1,32 @@
+import type { Result } from "../../kernel/index.ts";
+import { type UpgradeBot } from "../deps/index.ts";
+import type { Finding } from "../engine/index.ts";
+import type { Baseline } from "./types.ts";
+export interface BrownfieldManifest {
+    readonly path: string;
+    readonly text: string;
+}
+export interface BrownfieldInput {
+    readonly files: ReadonlyArray<string>;
+    readonly manifests: ReadonlyArray<BrownfieldManifest>;
+    readonly lockfiles: Readonly<Record<string, string | null>>;
+    readonly now: string;
+}
+export interface LoosePin {
+    readonly path: string;
+    readonly name: string;
+    readonly range: string;
+}
+export interface BrownfieldDetection {
+    readonly bot: UpgradeBot;
+    readonly loosePins: ReadonlyArray<LoosePin>;
+    readonly missingLockfiles: ReadonlyArray<string>;
+    readonly findings: ReadonlyArray<Finding>;
+}
+export declare function detectBrownfield(input: BrownfieldInput): BrownfieldDetection;
+export declare function baselineFromFindings(findings: ReadonlyArray<Finding>): Baseline;
+export interface FloorPinResult {
+    readonly text: string;
+    readonly pinned: ReadonlyArray<string>;
+}
+export declare function applyFloorPins(manifestText: string, resolved: Readonly<Record<string, string>>): Result<FloorPinResult>;

package/dist/features/remediation/adoption.js

@@ -0,0 +1,142 @@
+// SPEC §4.13.1: the adoption sequence. Detection is pure over
+// caller-supplied file lists and manifest text; the caller reads the repo
+// through its ports, so this module never touches the OS (SPEC §3.3).
+import { makeError } from "../../kernel/index.js";
+import { detectUpgradeBots, evaluateDepVerdicts, isExactNpmPin, manifestToEval, parsePackageJson, } from "../deps/index.js";
+function collectManifestLoosePins(manifest, loosePins) {
+    const parsed = parsePackageJson(manifest.text);
+    if (!parsed.ok) {
+        return;
+    }
+    for (const dep of parsed.value.dependencies) {
+        if (dep.kind !== "peer" && !isExactNpmPin(dep.range)) {
+            loosePins.push({
+                path: manifest.path,
+                name: dep.name,
+                range: dep.range,
+            });
+        }
+    }
+}
+function compareLoosePins(left, right) {
+    if (left.path !== right.path) {
+        return left.path < right.path ? -1 : 1;
+    }
+    if (left.name !== right.name) {
+        return left.name < right.name ? -1 : 1;
+    }
+    return 0;
+}
+function collectLoosePins(manifests) {
+    const loosePins = [];
+    for (const manifest of manifests) {
+        collectManifestLoosePins(manifest, loosePins);
+    }
+    loosePins.sort(compareLoosePins);
+    return loosePins;
+}
+function missingManifestLockfiles(manifests, lockfiles) {
+    return manifests
+        .filter((manifest) => lockfiles[manifest.path] === null)
+        .map((manifest) => manifest.path)
+        .sort();
+}
+// SPEC §4.13.1 steps 1–2: brownfield signals are loose pins (floor) and
+// manifests without a committed lockfile. Bot detection follows §4.8.6.
+export function detectBrownfield(input) {
+    const bot = detectUpgradeBots(input.files);
+    const loosePins = collectLoosePins(input.manifests);
+    const missingLockfiles = missingManifestLockfiles(input.manifests, input.lockfiles);
+    const evaluated = evaluateDepVerdicts({
+        manifests: input.manifests.map((manifest) => {
+            const parsed = parsePackageJson(manifest.text);
+            if (!parsed.ok) {
+                return { path: manifest.path, dependencies: [] };
+            }
+            return manifestToEval({
+                path: manifest.path,
+                dependencies: parsed.value.dependencies.map((dep) => ({
+                    name: dep.name,
+                    range: dep.range,
+                    kind: dep.kind,
+                })),
+            });
+        }),
+        now: input.now,
+        lockfiles: input.lockfiles,
+    });
+    return {
+        bot,
+        loosePins,
+        missingLockfiles,
+        findings: [...evaluated.findings],
+    };
+}
+// SPEC §4.13.1 step 3 and §7.6: record current findings as the baseline.
+// Keys are "<ruleId>@<measureVersion>" with per-path counts; zero counts are
+// removed and keys sort, so regeneration is byte-identical.
+export function baselineFromFindings(findings) {
+    const counts = new Map();
+    for (const finding of findings) {
+        const key = `${finding.ruleId}@1`;
+        let byPath = counts.get(key);
+        if (byPath === undefined) {
+            byPath = new Map();
+            counts.set(key, byPath);
+        }
+        const metric = finding.path ?? "repo";
+        byPath.set(metric, (byPath.get(metric) ?? 0) + 1);
+    }
+    const entries = {};
+    for (const key of [...counts.keys()].sort()) {
+        const byPath = counts.get(key);
+        if (byPath === undefined) {
+            continue;
+        }
+        const metrics = {};
+        for (const metric of [...byPath.keys()].sort()) {
+            const count = byPath.get(metric) ?? 0;
+            if (count > 0) {
+                metrics[metric] = count;
+            }
+        }
+        if (Object.keys(metrics).length > 0) {
+            entries[key] = metrics;
+        }
+    }
+    return { version: 1, entries };
+}
+// SPEC §4.13.1 step 4: range → exact pin at the lockfile-resolved version, a
+// mechanical step needing no human decision. The resolved versions come from
+// the caller (the lockfile); a loose pin without one fails closed with
+// CDX-E903 instead of guessing a version.
+export function applyFloorPins(manifestText, resolved) {
+    const parsed = parsePackageJson(manifestText);
+    if (!parsed.ok) {
+        return { ok: false, error: parsed.error };
+    }
+    const missing = parsed.value.dependencies
+        .filter((dep) => dep.kind !== "peer" &&
+        !isExactNpmPin(dep.range) &&
+        resolved[dep.name] === undefined)
+        .map((dep) => dep.name)
+        .sort();
+    if (missing.length > 0) {
+        return {
+            ok: false,
+            error: makeError("CDX-E903", `no lockfile-resolved version for ${missing.join(", ")}`, `Supply the lockfile-resolved version of ${missing.join(", ")} before pinning.`),
+        };
+    }
+    let text = manifestText;
+    const pinned = [];
+    for (const dep of parsed.value.dependencies) {
+        if (dep.kind === "peer" || isExactNpmPin(dep.range)) {
+            continue;
+        }
+        const exact = resolved[dep.name] ?? dep.range;
+        text = text.replace(`"${dep.name}": "${dep.range}"`, `"${dep.name}": "${exact}"`);
+        pinned.push(dep.name);
+    }
+    pinned.sort();
+    return { ok: true, value: { text, pinned } };
+}

package/dist/features/remediation/index.d.ts

@@ -0,0 +1,12 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Finding } from "../engine/index.ts";
+import { applyFloorPins, type BrownfieldDetection, type BrownfieldInput, baselineFromFindings, detectBrownfield, type FloorPinResult, type LoosePin } from "./adoption.ts";
+import { applyMergedResults, DEFAULT_SIZE_BUDGET, type DepMajorInput, planDepMajorChain, planStranglerMove, resolveConsolidation, type StranglerInput, type UnnumberedStep } from "./plan.ts";
+import { floorBlocksPr, isStepBranch, refuseRollback, type SplitDetail, type SplitOutcome, type StepGateEvidence, splitRemediationStep } from "./steps.ts";
+import type { Baseline, PlanTarget, RemediationPlan, RemediationStep, SizeBudget } from "./types.ts";
+export { checkRemediationStepSize } from "../deps/index.ts";
+export type { Baseline, BrownfieldDetection, BrownfieldInput, DepMajorInput, FloorPinResult, LoosePin, PlanTarget, RemediationPlan, RemediationStep, SizeBudget, SplitDetail, SplitOutcome, StepGateEvidence, StranglerInput, UnnumberedStep, };
+export { applyFloorPins, applyMergedResults, baselineFromFindings, DEFAULT_SIZE_BUDGET, detectBrownfield, floorBlocksPr, isStepBranch, planDepMajorChain, planStranglerMove, refuseRollback, resolveConsolidation, splitRemediationStep, };
+export declare function captureBaseline(_repoRoot: string, findings?: ReadonlyArray<Finding>): Promise<Result<Baseline>>;
+export declare function planRemediation(baseline: Baseline, findings: ReadonlyArray<string>, prior?: RemediationPlan | undefined): Promise<Result<RemediationPlan>>;
+export declare function runStep(plan: RemediationPlan, stepId: string, evidence?: StepGateEvidence | undefined): Promise<Result<RemediationStep>>;

package/dist/features/remediation/index.js

@@ -0,0 +1,21 @@
+import { applyFloorPins, baselineFromFindings, detectBrownfield, } from "./adoption.js";
+import { applyMergedResults, DEFAULT_SIZE_BUDGET, planDepMajorChain, planRemediation as planRemediationImpl, planStranglerMove, resolveConsolidation, } from "./plan.js";
+import { floorBlocksPr, isStepBranch, refuseRollback, runStep as runStepImpl, splitRemediationStep, } from "./steps.js";
+export { checkRemediationStepSize } from "../deps/index.js";
+export { applyFloorPins, applyMergedResults, baselineFromFindings, DEFAULT_SIZE_BUDGET, detectBrownfield, floorBlocksPr, isStepBranch, planDepMajorChain, planStranglerMove, refuseRollback, resolveConsolidation, splitRemediationStep, };
+// SPEC §4.13.1: adoption sequence entry point. Findings default to none,
+// so a bare capture records the empty baseline instead of guessing.
+export function captureBaseline(_repoRoot, findings = []) {
+    return Promise.resolve({ ok: true, value: baselineFromFindings(findings) });
+}
+// SPEC §4.13.2: plan generation from findings and baseline. The bootstrap
+// red suite drives the planner with scenario markers (§4.13.9); the prior
+// plan, when supplied, keeps finished steps with stable ids.
+export function planRemediation(baseline, findings, prior) {
+    return planRemediationImpl(baseline, findings, prior);
+}
+// SPEC §4.13.4: single step execution behind its gate. Gate evidence comes
+// from the caller; without it the step fails closed with CDX-E608.
+export function runStep(plan, stepId, evidence) {
+    return runStepImpl(plan, stepId, evidence);
+}

package/dist/features/remediation/plan-chains.d.ts

@@ -0,0 +1,3 @@
+import { type DepMajorInput, type StranglerInput, type UnnumberedStep } from "./plan-kinds.ts";
+export declare function planDepMajorChain(input: DepMajorInput): Array<UnnumberedStep>;
+export declare function planStranglerMove(input: StranglerInput): Array<UnnumberedStep>;

package/dist/features/remediation/plan-chains.js

@@ -0,0 +1,111 @@
+// SPEC §4.13.5–§4.13.6: dependency-major chains and strangler moves.
+// Each builder returns unnumbered steps whose `after` positions wire the
+// chain; the planner turns them into ids.
+import { numberedBase, } from "./plan-kinds.js";
+function coverageGateStep(packageName) {
+    return {
+        after: [],
+        step: {
+            ...numberedBase("safety-net", [`package:${packageName}`]),
+            target: [{ ruleId: "core/coverage-floor", key: packageName, from: 0 }],
+        },
+    };
+}
+function toolchainGateStep() {
+    return {
+        after: [],
+        step: {
+            ...numberedBase("dep-update", [".nvmrc", "package.json"]),
+            executor: "codictator",
+            target: [{ ruleId: "core/dep-latest-stable", key: "toolchain", from: 1 }],
+        },
+    };
+}
+function upgradeScopeOf(input) {
+    if (input.workspaces === undefined || input.workspaces.length === 0) {
+        return [`package:${input.package}`];
+    }
+    return input.workspaces.map((workspace) => `${workspace}:package:${input.package}`);
+}
+function upgradeStep(scope, packageName) {
+    return {
+        after: [],
+        step: {
+            ...numberedBase("dep-major", scope),
+            target: [
+                {
+                    ruleId: "core/dep-latest-stable",
+                    key: packageName,
+                    from: 1,
+                },
+            ],
+        },
+    };
+}
+function cleanupStep(packageName) {
+    return {
+        after: [],
+        step: {
+            ...numberedBase("dep-major", [`package:${packageName}`]),
+            target: [{ ruleId: "core/dep-no-deprecated", key: packageName, from: 1 }],
+        },
+    };
+}
+// SPEC §4.13.5: a dep-major is a chain of separately gated child steps:
+// coverage, prerequisites, the upgrade itself, then cleanup. Positions in
+// the returned array wire the chain; the planner turns them into ids.
+export function planDepMajorChain(input) {
+    const chain = [];
+    if (input.needsCoverage) {
+        chain.push(coverageGateStep(input.package));
+    }
+    if (input.needsToolchain) {
+        chain.push(toolchainGateStep());
+    }
+    const prereqs = chain.map((_, index) => index);
+    const upgrade = { ...upgradeStep(upgradeScopeOf(input), input.package) };
+    chain.push({ after: prereqs, step: upgrade.step });
+    const cleanup = { ...cleanupStep(input.package) };
+    chain.push({ after: [chain.length - 1], step: cleanup.step });
+    return chain;
+}
+// SPEC §4.13.6: add the needed exports to the target entry, migrate
+// importers in batches of at most batchFiles per step, and close the pair
+// with the step that removes the last deep import.
+export function planStranglerMove(input) {
+    const batchSize = input.batchFiles ?? 10;
+    const sorted = [...input.importers].sort();
+    const steps = [
+        {
+            after: [],
+            step: {
+                ...numberedBase("arch-move", [input.toEntry]),
+                target: [
+                    { ruleId: "core/arch-public-entry", key: input.toEntry, from: 1 },
+                ],
+            },
+        },
+    ];
+    for (let start = 0; start < sorted.length; start += batchSize) {
+        steps.push({
+            after: [steps.length - 1],
+            step: {
+                ...numberedBase("arch-move", sorted.slice(start, start + batchSize)),
+                target: [
+                    { ruleId: "core/arch-boundaries", key: input.fromEntry, from: 1 },
+                ],
+            },
+        });
+    }
+    steps.push({
+        after: [steps.length - 1],
+        step: {
+            ...numberedBase("arch-move", [input.fromEntry]),
+            target: [
+                { ruleId: "core/arch-boundaries", key: input.fromEntry, from: 0 },
+            ],
+            expectedDelta: 0,
+        },
+    });
+    return steps;
+}

package/dist/features/remediation/plan-generate.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Baseline, RemediationPlan } from "./types.ts";
+export declare function planRemediation(baseline: Baseline, findings: ReadonlyArray<string>, prior?: RemediationPlan | undefined): Promise<Result<RemediationPlan>>;