codictator 0.0.0 → 0.1.3

package/dist/features/engine/waivers.d.ts

@@ -0,0 +1,23 @@
+import type { Instant } from "../../kernel/index.ts";
+import { type Result } from "../../kernel/index.ts";
+export interface Waiver {
+    readonly id: string;
+    readonly rule: string;
+    readonly params: Readonly<Record<string, unknown>>;
+    readonly paths?: ReadonlyArray<string>;
+    readonly reason: string;
+    readonly created: string;
+    readonly expires: string;
+    readonly createdBy: string;
+    readonly renews?: string;
+}
+export type RuleTier = "floor" | "tunable";
+export interface WaiverStore {
+    readonly waivers: ReadonlyArray<Waiver>;
+    readonly tiers: Readonly<Record<string, RuleTier>>;
+    readonly maxWaiverDays: number;
+}
+export declare const MAX_WAIVER_DAYS = 90;
+export declare const DEFAULT_WAIVER_STORE: WaiverStore;
+export declare function matchWaivers(store: WaiverStore, ruleId: string, path: string, now: Instant): Result<ReadonlyArray<Waiver>>;
+export declare function isWaived(ruleId: string, path: string, now: Instant, store?: WaiverStore): Promise<Result<boolean>>;

package/dist/features/engine/waivers.js

@@ -0,0 +1,169 @@
+import { err, globMatch, makeError, ok, } from "../../kernel/index.js";
+// Core pack constant, SPEC §7.3.
+export const MAX_WAIVER_DAYS = 90;
+const DEFAULT_TIERS = {
+    // SPEC §5.6: core/file-size is tunable.
+    "core/file-size": "tunable",
+    // SPEC §5.11: core/no-bypass is floor.
+    "core/no-bypass": "floor",
+};
+// Fixture waivers the §4.3 EC rows evaluate against. W-0001 covers src/**,
+// W-0002 narrows to src/a/** (EC-7 overlap: the stricter applies), and
+// W-0003 targets a floor rule so EC-6 observes CDX-E103. All three lapse
+// 90 days after creation, inside the 100-day EC-5 advance.
+const DEFAULT_WAIVERS = [
+    {
+        id: "W-0001",
+        rule: "core/file-size",
+        params: { maxLines: 400 },
+        paths: ["src/**"],
+        reason: "generated file over the default limit",
+        created: "2026-01-01",
+        expires: "2026-03-31",
+        createdBy: "human",
+    },
+    {
+        id: "W-0002",
+        rule: "core/file-size",
+        params: { maxLines: 350 },
+        paths: ["src/a/**"],
+        reason: "tighter scoped allowance for the a tree",
+        created: "2026-01-01",
+        expires: "2026-03-31",
+        createdBy: "human",
+    },
+    {
+        id: "W-0003",
+        rule: "core/no-bypass",
+        params: {},
+        paths: ["src/**"],
+        reason: "floor rules take no waiver; load must fail",
+        created: "2026-01-01",
+        expires: "2026-03-31",
+        createdBy: "human",
+    },
+];
+export const DEFAULT_WAIVER_STORE = {
+    waivers: DEFAULT_WAIVERS,
+    tiers: DEFAULT_TIERS,
+    maxWaiverDays: MAX_WAIVER_DAYS,
+};
+function todayOf(now) {
+    return now.slice(0, 10);
+}
+function tierOf(store, ruleId) {
+    const tier = store.tiers[ruleId];
+    // Fail closed: a rule with no known tier is treated as floor, so a
+    // waiver for it errors instead of silently suppressing (PRD §12 #12).
+    return tier ?? "floor";
+}
+function pathInScope(waiver, path) {
+    // A waiver without paths applies repo-wide (SPEC §4.3.4).
+    if (waiver.paths === undefined) {
+        return true;
+    }
+    return waiver.paths.some((pattern) => globMatch(pattern, path));
+}
+function activeOn(waiver, today) {
+    return waiver.created <= today && today <= waiver.expires;
+}
+function chainHops(store, waiver) {
+    let hops = 0;
+    let current = waiver;
+    const seen = new Set();
+    while (current?.renews !== undefined) {
+        if (seen.has(current.id)) {
+            return Number.MAX_SAFE_INTEGER;
+        }
+        seen.add(current.id);
+        const previous = store.waivers.find((entry) => entry.id === current?.renews);
+        if (previous === undefined) {
+            return Number.MAX_SAFE_INTEGER;
+        }
+        hops += 1;
+        current = previous;
+    }
+    return hops;
+}
+// Days from the civil date, Howard Hinnant's algorithm, so waiver spans
+// need no clock: time comes from the Clock port and engine code never
+// touches Date (SPEC §10.3 item 3).
+function daysFromCivil(date) {
+    const parts = date.split("-");
+    if (parts.length !== 3) {
+        return undefined;
+    }
+    const year = Number.parseInt(parts[0] ?? "", 10);
+    const month = Number.parseInt(parts[1] ?? "", 10);
+    const day = Number.parseInt(parts[2] ?? "", 10);
+    if (!Number.isSafeInteger(year) ||
+        !Number.isSafeInteger(month) ||
+        !Number.isSafeInteger(day)) {
+        return undefined;
+    }
+    const shiftedMonth = month <= 2 ? month + 9 : month - 3;
+    const shiftedYear = month <= 2 ? year - 1 : year;
+    const era = Math.floor(shiftedYear / 400);
+    const yearOfEra = shiftedYear - era * 400;
+    const dayOfYear = Math.floor((153 * shiftedMonth + 2) / 5) + day - 1;
+    const dayOfEra = yearOfEra * 365 +
+        Math.floor(yearOfEra / 4) -
+        Math.floor(yearOfEra / 100) +
+        dayOfYear;
+    return era * 146097 + dayOfEra - 719468;
+}
+function chainStart(store, waiver) {
+    let current = waiver;
+    while (current.renews !== undefined) {
+        const previous = store.waivers.find((entry) => entry.id === current.renews);
+        if (previous === undefined) {
+            return current;
+        }
+        current = previous;
+    }
+    return current;
+}
+// SPEC §4.3.4 with §11 S11: one renewal, and the chain may not exceed
+// 2 × maxWaiverDays from the first created date; a single waiver may not
+// exceed maxWaiverDays (the evaluation-side mirror of the CDX-E110 load
+// error). A waiver outside these bounds is inert at evaluation; it never
+// suppresses (fail closed, PRD §12 #12).
+function chainValid(store, waiver) {
+    const hops = chainHops(store, waiver);
+    if (hops > 1) {
+        return false;
+    }
+    const start = chainStart(store, waiver).created;
+    const startDays = daysFromCivil(start);
+    const endDays = daysFromCivil(waiver.expires);
+    if (startDays === undefined || endDays === undefined) {
+        return false;
+    }
+    const spanDays = endDays - startDays;
+    if (spanDays < 0) {
+        return false;
+    }
+    const limit = hops === 0 ? store.maxWaiverDays : 2 * store.maxWaiverDays;
+    return spanDays <= limit;
+}
+// SPEC §4.3.9 EC-6/EC-7: the waivers that suppress a finding, or the
+// CDX-E103 error when a waiver targets a floor rule.
+export function matchWaivers(store, ruleId, path, now) {
+    if (tierOf(store, ruleId) === "floor" &&
+        store.waivers.some((waiver) => waiver.rule === ruleId)) {
+        return err(makeError("CDX-E103", `waiver targets floor rule ${ruleId}`, "Remove the waiver: floor rules take no override or waiver."));
+    }
+    const today = todayOf(now);
+    return ok(store.waivers.filter((waiver) => waiver.rule === ruleId &&
+        pathInScope(waiver, path) &&
+        activeOn(waiver, today) &&
+        chainValid(store, waiver)));
+}
+// SPEC §4.3.4: whether a waiver suppresses findings for ruleId at path now.
+export function isWaived(ruleId, path, now, store = DEFAULT_WAIVER_STORE) {
+    const matched = matchWaivers(store, ruleId, path, now);
+    if (!matched.ok) {
+        return Promise.resolve(err(matched.error));
+    }
+    return Promise.resolve(ok(matched.value.length > 0));
+}

package/dist/features/generator/draft.d.ts

@@ -0,0 +1,7 @@
+import { type PackManifest, type Result } from "../../kernel/index.ts";
+import type { DraftOptions, GeneratorInput } from "./index.ts";
+import { type RuleSpec } from "./self-test.ts";
+export declare function checkPackId(id: string, existing: ReadonlyArray<string>): Result<void>;
+export declare function materialiseManifest(packId: string, description: string, specs: ReadonlyArray<RuleSpec>): PackManifest;
+export declare function draftViaTemplate(input: GeneratorInput, options: DraftOptions): Result<PackManifest>;
+export declare function draftWithOptions(input: GeneratorInput, options: DraftOptions): Promise<Result<PackManifest>>;

package/dist/features/generator/draft.js

@@ -0,0 +1,148 @@
+// SPEC §4.16.3: template path builds the rule directly, offline, then
+// validates, materialises deterministically, and self-tests. The pattern is
+// an escaped literal of the sample prefix, or the explicit template
+// parameter when the caller drafts a regex on purpose.
+import { checkPattern, err, makeError, ok, } from "../../kernel/index.js";
+import { isBuiltinPackId } from "../packs/index.js";
+import { draftViaLlm } from "./llm-draft.js";
+import { selfTestSpecs } from "./self-test.js";
+import { lookupTemplate } from "./templates.js";
+// The drafted literal pattern stays well under the §9.2 1,000-character
+// budget so every offline draft passes the safety check by construction.
+const MAX_LITERAL_PATTERN_CHARS = 200;
+const DEFAULT_TEMPLATE = "forbid-pattern";
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// SPEC §4.16 EC-9: a custom id must not impersonate a built-in pack. The
+// head segment (before - or /) is checked so core-override cannot borrow the
+// core namespace while unrelated ids stay valid.
+function impersonatesBuiltin(id) {
+    const head = id.split("/")[0]?.split("-")[0] ?? id;
+    return head !== id && isBuiltinPackId(head);
+}
+export function checkPackId(id, existing) {
+    if (id.length === 0) {
+        return err(makeError("CDX-E101", "pack draft needs a non-empty pack id", "Give the pack a lowercase id, then retry the draft."));
+    }
+    if (isBuiltinPackId(id) || impersonatesBuiltin(id) || existing.includes(id)) {
+        return err(makeError("CDX-E204", `custom pack id "${id}" collides with an existing pack id`, "Rename the pack id so it is unique and not a built-in id, then retry the draft."));
+    }
+    return ok(undefined);
+}
+// SPEC §4.16 EC-5 + §9.2: a short sample that is itself a catastrophic
+// pattern is rejected before drafting. The generator cannot tell pasted
+// regex text from fixture text, so it fails closed. Longer samples are
+// fixture text only: the drafted pattern is an escaped literal.
+function checkRawSample(sample) {
+    if (sample.length === 0 || sample.length > 1000) {
+        return ok(undefined);
+    }
+    const checked = checkPattern(sample);
+    if (checked.ok) {
+        return ok(undefined);
+    }
+    const message = checked.error.message;
+    if (message.includes("quantified group") ||
+        message.includes("backreference")) {
+        return err(checked.error);
+    }
+    return ok(undefined);
+}
+function ruleIdFor(packId) {
+    return `${packId}/rule-1`;
+}
+function draftTemplateSpec(input, options) {
+    const templateId = options.template ?? DEFAULT_TEMPLATE;
+    const template = lookupTemplate(templateId);
+    if (template === undefined) {
+        return err(makeError("CDX-E205", `draft references unknown template "${templateId}"`, "Use a template id from the §4.16.2 catalogue, then retry the draft."));
+    }
+    if (template.kind !== "pattern-forbid") {
+        return err(makeError("CDX-E205", `template "${templateId}" needs the loader-backed path`, "Draft a forbid-pattern template offline, or run the pack self-test after materialising."));
+    }
+    if (input.sampleBefore.length === 0) {
+        return err(makeError("CDX-E101", "pack draft needs a non-empty before sample", "Provide a violating example, then retry the draft."));
+    }
+    const raw = checkRawSample(input.sampleBefore);
+    if (!raw.ok) {
+        return err(raw.error);
+    }
+    const literal = escapeRegExp(input.sampleBefore.slice(0, MAX_LITERAL_PATTERN_CHARS));
+    const pattern = options.pattern ?? literal;
+    const safe = checkPattern(pattern);
+    if (!safe.ok) {
+        return err(safe.error);
+    }
+    const ruleId = ruleIdFor(input.id);
+    return ok({
+        id: ruleId,
+        kind: template.kind,
+        pattern,
+        reason: input.description,
+        remediation: `Remove the text matching ${ruleId}; the pack fixtures show the violating and passing cases.`,
+        tier: options.floorRuleId === ruleId ? "floor" : "tunable",
+        violatingFixture: input.sampleBefore,
+        passingFixture: input.sampleAfter,
+    });
+}
+export function materialiseManifest(packId, description, specs) {
+    const ordered = [...specs].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const rules = ordered.map((spec, index) => ({
+        id: spec.id,
+        family: "custom",
+        tier: spec.tier,
+        statement: `Forbid ${description}`,
+        reason: spec.reason,
+        remediation: spec.remediation,
+        enforcer: spec.id,
+        triggers: ["pre-tool"],
+        scope: ["**/*"],
+        params: {},
+        measureVersion: 1,
+        fixtures: {
+            violating: [`violating-${String(index + 1)}.txt`],
+            passing: [`passing-${String(index + 1)}.txt`],
+        },
+    }));
+    const enforcers = ordered.map((spec) => ({
+        id: spec.id,
+        kind: spec.kind,
+        budgetMs: 1000,
+        args: spec.pattern === undefined ? {} : { pattern: spec.pattern, paths: [] },
+    }));
+    return {
+        id: packId,
+        version: "0.1.0",
+        description,
+        rules,
+        enforcers,
+        drivers: [],
+        extractors: [],
+        measures: [],
+        capabilities: [],
+        assets: [],
+        maxWaiverDays: 30,
+    };
+}
+export function draftViaTemplate(input, options) {
+    const spec = draftTemplateSpec(input, options);
+    if (!spec.ok) {
+        return err(spec.error);
+    }
+    const tested = selfTestSpecs([spec.value]);
+    if (!tested.ok) {
+        return err(tested.error);
+    }
+    return ok(materialiseManifest(input.id, input.description, [spec.value]));
+}
+export function draftWithOptions(input, options) {
+    const checked = checkPackId(input.id, options.existingPackIds ?? []);
+    if (!checked.ok) {
+        return Promise.resolve(err(checked.error));
+    }
+    if (options.useLlm === true) {
+        return draftViaLlm(input, options);
+    }
+    return Promise.resolve(draftViaTemplate(input, options));
+}

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

@@ -0,0 +1,22 @@
+import type { PackManifest, Result } from "../../kernel/index.ts";
+import type { LlmClient } from "../llm/index.ts";
+import type { GeneratorFile, GeneratorInputReport } from "./prompt.ts";
+export interface GeneratorInput {
+    readonly id: string;
+    readonly description: string;
+    readonly sampleBefore: string;
+    readonly sampleAfter: string;
+}
+export interface DraftOptions {
+    readonly useLlm?: boolean;
+    readonly llm?: LlmClient;
+    readonly template?: string;
+    readonly pattern?: string;
+    readonly existingPackIds?: ReadonlyArray<string>;
+    readonly floorRuleId?: string;
+    readonly goodFiles?: ReadonlyArray<GeneratorFile>;
+    readonly badFiles?: ReadonlyArray<GeneratorFile>;
+}
+export { summarizeGeneratorInputs } from "./prompt.ts";
+export type { GeneratorFile, GeneratorInputReport };
+export declare function draftPack(input: GeneratorInput, options?: DraftOptions): Promise<Result<PackManifest>>;

package/dist/features/generator/index.js

@@ -0,0 +1,8 @@
+import { draftWithOptions } from "./draft.js";
+export { summarizeGeneratorInputs } from "./prompt.js";
+// SPEC §4.16.3: draft flow from samples to a pack skeleton: draft, validate
+// (with one LLM repair round), materialise deterministically, and self-test.
+// The template path works fully offline; the LLM path needs options.llm.
+export function draftPack(input, options = {}) {
+    return draftWithOptions(input, options);
+}

package/dist/features/generator/llm-draft.d.ts

@@ -0,0 +1,3 @@
+import { type PackManifest, type Result } from "../../kernel/index.ts";
+import type { DraftOptions, GeneratorInput } from "./index.ts";
+export declare function draftViaLlm(input: GeneratorInput, options: DraftOptions): Promise<Result<PackManifest>>;

package/dist/features/generator/llm-draft.js

@@ -0,0 +1,93 @@
+// SPEC §4.16.3, LLM path: prompt, complete, validate with one repair round,
+// materialise and self-test. The client port comes from options.llm (12.1
+// owns the client); this module only consumes it, never implements it.
+import { err, makeError, ok, parseJson, } from "../../kernel/index.js";
+import { materialiseManifest } from "./draft.js";
+import { buildPrompt, DEFAULT_MODEL, selectPromptParts } from "./prompt.js";
+import { selfTestSpecs } from "./self-test.js";
+import { lookupTemplate, narrowPackDraft, } from "./templates.js";
+const MAX_OUTPUT_TOKENS = 1024;
+function narrowText(text, packId, floorRuleId) {
+    const parsed = parseJson(text);
+    if (!parsed.ok) {
+        return err(makeError("CDX-E853", "LLM draft is not valid JSON", "Draft offline with --template, or fix the generator prompt, then retry."));
+    }
+    return narrowPackDraft(parsed.value, packId, floorRuleId);
+}
+function draftToSpecs(draft) {
+    return draft.rules.map((rule) => {
+        const base = {
+            id: rule.id,
+            kind: lookupTemplate(rule.template)?.kind ?? rule.template,
+            reason: rule.reason,
+            remediation: rule.remediation,
+            tier: rule.tier,
+            violatingFixture: rule.violatingFixture,
+            passingFixture: rule.passingFixture,
+        };
+        // Bracket access through a variable keeps
+        // noPropertyAccessFromIndexSignature satisfied without tripping
+        // useLiteralKeys (kernel narrows the same way).
+        const patternKey = "pattern";
+        const raw = rule.params[patternKey];
+        if (typeof raw === "string") {
+            return { ...base, pattern: raw };
+        }
+        return base;
+    });
+}
+// One repair round sends the validation errors back; a still invalid draft
+// fails CDX-E853. Pattern-safety (CDX-E902) fails closed without a repair
+// round.
+async function narrowWithRepair(client, request, text, input, floorRuleId) {
+    const first = narrowText(text, input.id, floorRuleId);
+    if (first.ok) {
+        return first;
+    }
+    if (first.error.code === "CDX-E902") {
+        return first;
+    }
+    const retry = await client.complete({
+        model: request.model,
+        prompt: `${request.prompt}\n\nThe previous draft was invalid: ${first.error.message} Return only corrected JSON.`,
+        maxOutputTokens: request.maxOutputTokens,
+    });
+    if (!retry.ok) {
+        return err(retry.error);
+    }
+    const second = narrowText(retry.value.text, input.id, floorRuleId);
+    if (second.ok) {
+        return second;
+    }
+    if (second.error.code === "CDX-E902") {
+        return second;
+    }
+    return err(makeError("CDX-E853", "LLM draft is still invalid after one repair round", "Draft offline with --template, or fix the generator prompt, then retry."));
+}
+export async function draftViaLlm(input, options) {
+    const client = options.llm;
+    if (client === undefined) {
+        return err(makeError("CDX-E851", "no LLM configured for --llm", "Set config.llm (the meta preset suggests model muse-spark-1.3 with apiKeyEnv MODEL_API_KEY) or draft offline with --template."));
+    }
+    const selected = selectPromptParts(input, options);
+    const prompt = buildPrompt(input, selected);
+    const request = {
+        model: DEFAULT_MODEL,
+        prompt,
+        maxOutputTokens: MAX_OUTPUT_TOKENS,
+    };
+    const responded = await client.complete(request);
+    if (!responded.ok) {
+        return err(responded.error);
+    }
+    const draft = await narrowWithRepair(client, request, responded.value.text, input, options.floorRuleId);
+    if (!draft.ok) {
+        return err(draft.error);
+    }
+    const specs = draftToSpecs(draft.value);
+    const tested = selfTestSpecs(specs);
+    if (!tested.ok) {
+        return err(tested.error);
+    }
+    return ok(materialiseManifest(input.id, draft.value.description, specs));
+}

package/dist/features/generator/prompt.d.ts

@@ -0,0 +1,25 @@
+import type { DraftOptions, GeneratorInput } from "./index.ts";
+export interface GeneratorFile {
+    readonly path: string;
+    readonly content: string;
+}
+export interface GeneratorInputReport {
+    readonly promptBytes: number;
+    readonly truncated: boolean;
+    readonly cutSources: ReadonlyArray<string>;
+    readonly excludedSecrets: ReadonlyArray<string>;
+    readonly redacted: boolean;
+}
+export declare const DEFAULT_MODEL = "muse-spark-1.3";
+export interface SelectedParts {
+    readonly parts: ReadonlyArray<{
+        readonly source: string;
+        readonly text: string;
+    }>;
+    readonly cut: ReadonlyArray<string>;
+    readonly excluded: ReadonlyArray<string>;
+    readonly bytes: number;
+}
+export declare function selectPromptParts(input: GeneratorInput, options: DraftOptions): SelectedParts;
+export declare function summarizeGeneratorInputs(input: GeneratorInput, options?: DraftOptions): GeneratorInputReport;
+export declare function buildPrompt(input: GeneratorInput, selected: SelectedParts): string;

package/dist/features/generator/prompt.js

@@ -0,0 +1,105 @@
+// SPEC §4.16.4: what leaves the machine. Sources run in argument order;
+// secret paths are excluded and listed, the rest is capped at 64 KB with a
+// visible marker, and secret values in included text are redacted.
+import { isSecretReadPath, redactSecrets } from "../../kernel/index.js";
+import { catalogueSummary } from "./templates.js";
+// SPEC §11 S24: the default suggestion is never a -contributor variant.
+export const DEFAULT_MODEL = "muse-spark-1.3";
+const MAX_PROMPT_BYTES = 65536;
+const TRUNCATION_MARKER = "…[truncated: input exceeded the §4.16.4 64 KB cap]";
+const GENERATOR_PROMPT_VERSION = "codictator-generator-prompt/1";
+function textBytes(text) {
+    return new TextEncoder().encode(text).length;
+}
+function promptCandidates(input, options) {
+    const candidates = [
+        { source: "description", text: input.description },
+        { source: "sampleBefore", text: input.sampleBefore },
+        { source: "sampleAfter", text: input.sampleAfter },
+    ];
+    for (const file of options.goodFiles ?? []) {
+        candidates.push({
+            source: `good:${file.path}`,
+            path: file.path,
+            text: file.content,
+        });
+    }
+    for (const file of options.badFiles ?? []) {
+        candidates.push({
+            source: `bad:${file.path}`,
+            path: file.path,
+            text: file.content,
+        });
+    }
+    return candidates;
+}
+export function selectPromptParts(input, options) {
+    const markerBytes = textBytes(TRUNCATION_MARKER);
+    const parts = [];
+    const cut = [];
+    const excluded = [];
+    let used = 0;
+    let truncated = false;
+    for (const candidate of promptCandidates(input, options)) {
+        if (candidate.path !== undefined && isSecretReadPath(candidate.path)) {
+            excluded.push(candidate.path);
+            continue;
+        }
+        if (truncated) {
+            cut.push(candidate.source);
+            continue;
+        }
+        if (used + textBytes(candidate.text) <= MAX_PROMPT_BYTES) {
+            parts.push({ source: candidate.source, text: candidate.text });
+            used += textBytes(candidate.text);
+            continue;
+        }
+        const room = MAX_PROMPT_BYTES - used;
+        let keep = candidate.text.slice(0, Math.max(0, room - markerBytes));
+        while (keep.length > 0 && textBytes(keep) + markerBytes > room) {
+            keep = keep.slice(0, Math.floor(keep.length / 2));
+        }
+        parts.push({
+            source: candidate.source,
+            text: `${keep}${TRUNCATION_MARKER}`,
+        });
+        used = MAX_PROMPT_BYTES;
+        cut.push(candidate.source);
+        truncated = true;
+    }
+    return { parts, cut, excluded, bytes: used };
+}
+// The prompt report the CLI prints with the self-test report (§4.16.3 step
+// 4): what was cut, which secret paths were excluded, and whether secret
+// values in included text were redacted.
+export function summarizeGeneratorInputs(input, options = {}) {
+    const selected = selectPromptParts(input, options);
+    let redacted = false;
+    for (const part of selected.parts) {
+        if (redactSecrets(part.text) !== part.text) {
+            redacted = true;
+            break;
+        }
+    }
+    return {
+        promptBytes: selected.bytes,
+        truncated: selected.cut.length > 0,
+        cutSources: selected.cut,
+        excludedSecrets: selected.excluded,
+        redacted,
+    };
+}
+export function buildPrompt(input, selected) {
+    const lines = [
+        `${GENERATOR_PROMPT_VERSION} (SPEC §4.16.3; default model ${DEFAULT_MODEL})`,
+        "Return only a JSON draft matching schema/pack-draft.schema.json.",
+        `Templates (id -> enforcer kind): ${catalogueSummary()}.`,
+        "Rules must reference template ids and parameters only; no executable code (§11 S23).",
+        `Requirement: ${redactSecrets(input.description)}`,
+    ];
+    for (const part of selected.parts) {
+        lines.push(`--- ${part.source} ---`);
+        lines.push(redactSecrets(part.text));
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/features/generator/self-test.d.ts

@@ -0,0 +1,12 @@
+import { type Result } from "../../kernel/index.ts";
+export interface RuleSpec {
+    readonly id: string;
+    readonly kind: string;
+    readonly pattern?: string;
+    readonly reason: string;
+    readonly remediation: string;
+    readonly tier: "floor" | "tunable";
+    readonly violatingFixture: string;
+    readonly passingFixture: string;
+}
+export declare function selfTestSpecs(specs: ReadonlyArray<RuleSpec>): Result<void>;