@spikedpunch/align-core 0.1.0

package/dist/build/schema.d.ts.map

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

package/dist/build/schema.js

@@ -0,0 +1,128 @@
+/**
+ * Wire shapes for `align build` (ADR 011): the tier-1/MCP "rule fragment" input format, the
+ * `.align/generated-rules.json` file, and the `.align/rules.lock.json` file. Zod-validated per
+ * ADR 002's parse-don't-validate discipline — every fragment and every on-disk build artifact is
+ * `.parse()`d once, at its boundary.
+ */
+import { z } from 'zod';
+import { ruleIRSchema, rulesetIRSchema } from '../types/ir.js';
+const componentRefText = z.string().min(1);
+// ---------------------------------------------------------------------------------------------
+// Rule fragment: the tier-1 ```align block JSON shape (and the MCP `align_propose_rules` proposal
+// input shape) — a RuleIR variant's structural fields, minus `id` and `provenance`. Both of those
+// are always assigned by align's build pipeline, never authored: `id` is a deterministic slug
+// derived from the fragment's own content (ADR 011's rule-level diff minimization depends on ids
+// being content-addressed, not author-assigned) and `provenance` is populated from where the
+// fragment was found in the doc (or, for MCP, from what the client agent reports). A fragment MAY
+// carry an optional `because` override — sourceQuote is auto-populated into the final rule's
+// `because` field either way (ADR 011), but an author can prepend their own rationale text.
+// ---------------------------------------------------------------------------------------------
+const noDependencyFragmentSchema = z.object({
+    kind: z.literal('arch.no-dependency'),
+    from: componentRefText,
+    to: componentRefText,
+    because: z.string().optional(),
+});
+const noCyclesFragmentSchema = z.object({
+    kind: z.literal('arch.no-cycles'),
+    scope: z.union([z.literal('repo'), componentRefText]).optional(),
+    includeTypeOnly: z.boolean().optional(),
+    because: z.string().optional(),
+});
+const layersFragmentSchema = z.object({
+    kind: z.literal('arch.layers'),
+    // Exactly one layer entry per fragment (mirrors the DSL's `.layer(x).canOnlyDependOn(...)`,
+    // which always produces a single-entry `layers` array) — keeps rule ids content-addressed
+    // one-layer-per-id (`arch.layers:<layer>`), the same scheme `dsl/index.ts` uses. A doc
+    // expressing constraints for two layers writes two bullets/blocks, not one fragment with two
+    // entries.
+    layers: z.array(z.object({ layer: componentRefText, canDependOn: z.array(componentRefText) })).length(1),
+    because: z.string().optional(),
+});
+const customHostFragmentSchema = z.object({
+    kind: z.literal('custom.host'),
+    hostRuleName: z.string(),
+    because: z.string().optional(),
+});
+// `arch.metric` (max-LOC only, promoted 2026-07-12 on kluster ruleset evidence,
+// IMPLEMENTATION_PLAN.md's Promotion log) — mirrors the DSL's `.maxLinesPerFile(max)` (dsl/index.ts).
+const metricFragmentSchema = z.object({
+    kind: z.literal('arch.metric'),
+    target: componentRefText,
+    metric: z.literal('loc'),
+    max: z.number().int().positive(),
+    because: z.string().optional(),
+});
+// `security.manifest.*` (ADR 013, promoted 2026-07-12 on spike/MANIFEST_PROBE_REPORT.md probe
+// evidence) — mirrors the DSL's `.sourceHygiene()`/`.newDependencyGate()` (dsl/index.ts). Neither
+// verb takes a target/selector, so the fragment carries only `because`, same shape as
+// `customHostFragmentSchema` minus `hostRuleName`.
+const securityManifestSourceHygieneFragmentSchema = z.object({
+    kind: z.literal('security.manifest.source-hygiene'),
+    because: z.string().optional(),
+});
+const securityManifestNewDependencyFragmentSchema = z.object({
+    kind: z.literal('security.manifest.new-dependency'),
+    because: z.string().optional(),
+});
+export const ruleFragmentSchema = z.discriminatedUnion('kind', [
+    noDependencyFragmentSchema,
+    noCyclesFragmentSchema,
+    layersFragmentSchema,
+    customHostFragmentSchema,
+    metricFragmentSchema,
+    securityManifestSourceHygieneFragmentSchema,
+    securityManifestNewDependencyFragmentSchema,
+]);
+// ---------------------------------------------------------------------------------------------
+// `.align/generated-rules.json` — a RuleIR array with full provenance, imported by the config
+// loader (packages/cli/src/config.ts). Deliberately NOT a full RulesetIR: `components` stays
+// authored once in align.config.ts, never duplicated into the generated artifact.
+// ---------------------------------------------------------------------------------------------
+export const generatedRulesFileSchema = z.object({
+    irVersion: z.literal('1'),
+    docPath: z.string(),
+    generatedAt: z.number(),
+    rules: z.array(ruleIRSchema),
+});
+// ---------------------------------------------------------------------------------------------
+// `.align/rules.lock.json` — section hashes <-> rule ids, plus the generated-rules.json content
+// hash (divergence detection: a hand-edit to the generated artifact changes this hash without a
+// matching lockfile update).
+// ---------------------------------------------------------------------------------------------
+const lockSectionSchema = z.object({
+    anchor: z.string(),
+    headingText: z.string(),
+    startLine: z.number().int(),
+    endLine: z.number().int(),
+    contentHash: z.string(),
+    tier: z.enum(['verbatim', 'bullet', 'prose', 'empty']),
+    ruleIds: z.array(z.string()),
+});
+export const rulesLockSchema = z.object({
+    irVersion: z.literal('1'),
+    docPath: z.string(),
+    docContentHash: z.string(),
+    builtAt: z.number(),
+    sections: z.array(lockSectionSchema),
+    generatedRulesContentHash: z.string(),
+});
+// ---------------------------------------------------------------------------------------------
+// `.align/ruleset-ir.json` (ADR 014) — the untrusted-mode data source. Written once in a trusted
+// context by `align export-ir` and read by `align check --untrusted`/`--ir-only`, which never
+// imports align.config.ts. `ruleset` is exactly a `RulesetIR` (ADR 002: components + rules, both
+// already portable JSON with zero function-valued fields — `defineProject` zod-parses it before
+// this schema ever sees it) — this wrapper adds only what an untrusted scan additionally needs
+// beyond the ruleset itself: the scan-time `excludes` list (plain string data, config.ts's
+// documented `excludes`-is-not-part-of-RulesetIR deviation, ADR 002) and export provenance.
+// Deliberately does NOT carry `hostRules` — predicate functions cannot survive a JSON boundary
+// (ADR 002 amendment) and are categorically unavailable under --untrusted regardless
+// (`assertNoCustomHostRules`, `rules/host-rules.ts`).
+// ---------------------------------------------------------------------------------------------
+export const exportedRulesetSchema = z.object({
+    irVersion: z.literal('1'),
+    exportedAt: z.number(),
+    excludes: z.array(z.string()),
+    ruleset: rulesetIRSchema,
+});
+//# sourceMappingURL=schema.js.map

package/dist/build/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/build/schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAE/D,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAE3C,gGAAgG;AAChG,kGAAkG;AAClG,kGAAkG;AAClG,8FAA8F;AAC9F,iGAAiG;AACjG,6FAA6F;AAC7F,kGAAkG;AAClG,6FAA6F;AAC7F,4FAA4F;AAC5F,gGAAgG;AAEhG,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC;IACrC,IAAI,EAAE,gBAAgB;IACtB,EAAE,EAAE,gBAAgB;IACpB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC;IACjC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,QAAQ,EAAE;IAChE,eAAe,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACvC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAC9B,4FAA4F;IAC5F,0FAA0F;IAC1F,uFAAuF;IACvF,6FAA6F;IAC7F,WAAW;IACX,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACxG,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAC9B,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;IACxB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,gFAAgF;AAChF,sGAAsG;AACtG,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAC9B,MAAM,EAAE,gBAAgB;IACxB,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;IACxB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IAChC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,8FAA8F;AAC9F,kGAAkG;AAClG,sFAAsF;AACtF,mDAAmD;AACnD,MAAM,2CAA2C,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3D,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,kCAAkC,CAAC;IACnD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,2CAA2C,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3D,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,kCAAkC,CAAC;IACnD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAC7D,0BAA0B;IAC1B,sBAAsB;IACtB,oBAAoB;IACpB,wBAAwB;IACxB,oBAAoB;IACpB,2CAA2C;IAC3C,2CAA2C;CAC5C,CAAC,CAAC;AAIH,gGAAgG;AAChG,8FAA8F;AAC9F,6FAA6F;AAC7F,kFAAkF;AAClF,gGAAgG;AAEhG,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;IACzB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC;CAC7B,CAAC,CAAC;AAIH,gGAAgG;AAChG,gGAAgG;AAChG,gGAAgG;AAChG,6BAA6B;AAC7B,gGAAgG;AAEhG,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IAC3B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACzB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACtD,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;IACzB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;IAC1B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC;IACpC,yBAAyB,EAAE,CAAC,CAAC,MAAM,EAAE;CACtC,CAAC,CAAC;AAIH,gGAAgG;AAChG,iGAAiG;AACjG,8FAA8F;AAC9F,iGAAiG;AACjG,gGAAgG;AAChG,+FAA+F;AAC/F,2FAA2F;AAC3F,4FAA4F;AAC5F,+FAA+F;AAC/F,qFAAqF;AACrF,sDAAsD;AACtD,gGAAgG;AAEhG,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;IACzB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC7B,OAAO,EAAE,eAAe;CACzB,CAAC,CAAC"}

package/dist/build/sections.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Markdown section model (ADR 011): a doc is parsed into heading-anchored sections with stable
+ * content hashes. Every markdown heading (any level, `#`-`######`) starts a new section that runs
+ * until the next heading or end of file — a flat model, not a nested tree; `align build`'s
+ * change-detection unit is "the section under one heading," which is what ADR 011's acceptance
+ * criteria ("one-section reword re-proposes only that section") operates on.
+ */
+export interface DocSection {
+    /** Stable slug derived from the heading text (github-style), deduped against earlier headings
+     * in the same doc so two identically-worded headings don't collide. */
+    readonly anchor: string;
+    readonly headingText: string;
+    readonly level: number;
+    /** 1-based, inclusive — the heading line itself. */
+    readonly startLine: number;
+    /** 1-based, inclusive — the last line of the section's body (before the next heading, or EOF). */
+    readonly endLine: number;
+    /** Raw body text (excludes the heading line) — the classification/hashing input. */
+    readonly bodyText: string;
+    /** Content hash of `headingText` + `bodyText` — changes iff the section's own text changes,
+     * independent of line-number shifts caused by edits elsewhere in the doc. */
+    readonly contentHash: string;
+}
+export interface ParsedDoc {
+    readonly lines: readonly string[];
+    readonly sections: readonly DocSection[];
+}
+/** Parses a markdown document into heading-anchored sections (ADR 011). Pure — no I/O. */
+export declare function parseMarkdownDoc(doc: string): ParsedDoc;
+//# sourceMappingURL=sections.d.ts.map

package/dist/build/sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sections.d.ts","sourceRoot":"","sources":["../../src/build/sections.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB;2EACuE;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kGAAkG;IAClG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;iFAC6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;CAC1C;AAqBD,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CA0CvD"}

package/dist/build/sections.js

@@ -0,0 +1,58 @@
+import { sha256Hex } from './hash.js';
+const HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+function slugify(headingText) {
+    const base = headingText
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    return base.length > 0 ? base : 'section';
+}
+function dedupeAnchor(base, seen) {
+    const count = seen.get(base) ?? 0;
+    seen.set(base, count + 1);
+    return count === 0 ? base : `${base}-${count + 1}`;
+}
+/** Parses a markdown document into heading-anchored sections (ADR 011). Pure — no I/O. */
+export function parseMarkdownDoc(doc) {
+    const lines = doc.split('\n');
+    const seenAnchors = new Map();
+    const headings = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        const match = HEADING_RE.exec(line);
+        if (match === null)
+            continue;
+        const hashes = match[1];
+        const headingText = match[2];
+        if (hashes === undefined || headingText === undefined)
+            continue;
+        headings.push({ level: hashes.length, headingText, startLine: i + 1 });
+    }
+    const sections = [];
+    for (let i = 0; i < headings.length; i += 1) {
+        const h = headings[i];
+        if (h === undefined)
+            continue;
+        const next = headings[i + 1];
+        const endLine = next === undefined ? lines.length : next.startLine - 1;
+        const bodyLines = lines.slice(h.startLine, endLine); // excludes the heading line itself
+        const bodyText = bodyLines.join('\n');
+        const anchor = dedupeAnchor(slugify(h.headingText), seenAnchors);
+        sections.push({
+            anchor,
+            headingText: h.headingText,
+            level: h.level,
+            startLine: h.startLine,
+            endLine,
+            bodyText,
+            contentHash: sha256Hex(`${h.headingText}\n${bodyText}`),
+        });
+    }
+    return { lines, sections };
+}
+//# sourceMappingURL=sections.js.map

package/dist/build/sections.js.map

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

package/dist/build/tier1.d.ts

@@ -0,0 +1,24 @@
+import type { RepoRelativePath } from '../types/branded.js';
+import type { SourceRange } from '../types/violation.js';
+import type { DocSection } from './sections.js';
+import { type RuleFragment } from './schema.js';
+import type { FlaggedProposal } from './types.js';
+export interface ExtractedFragment {
+    readonly fragment: RuleFragment;
+    readonly sourceLineRange: SourceRange;
+    /** Tier-1 sourceQuote is the fenced block's own JSON content (trimmed) — there is no separate
+     * prose to quote for a verbatim block; the block itself IS the doc's declared intent (an
+     * explicit ADR 011 resolution — see the Stage 3 final report's "ambiguities resolved" list). */
+    readonly sourceQuote: string;
+}
+/**
+ * Tier 1 of the precision ladder (ADR 011): fenced ` ```align ` code blocks compile verbatim,
+ * zero LLM involved. Each block's content is a **JSON RuleFragment** (`schema.ts`) — the
+ * structural fields of one `RuleIR` variant, minus `id`/`provenance` (both are always assigned by
+ * the build pipeline, never authored — see `ground.ts`). Pure — no I/O.
+ */
+export declare function extractFencedAlignBlocks(lines: readonly string[], section: DocSection, docPath: RepoRelativePath): {
+    readonly fragments: readonly ExtractedFragment[];
+    readonly errors: readonly FlaggedProposal[];
+};
+//# sourceMappingURL=tier1.d.ts.map

package/dist/build/tier1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier1.d.ts","sourceRoot":"","sources":["../../src/build/tier1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC;IACtC;;oGAEgG;IAChG,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAKD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,gBAAgB,GACxB;IAAE,QAAQ,CAAC,SAAS,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,CA+DnG"}

package/dist/build/tier1.js

@@ -0,0 +1,68 @@
+import { ruleFragmentSchema } from './schema.js';
+const FENCE_OPEN_RE = /^```align\s*$/;
+const FENCE_CLOSE_RE = /^```\s*$/;
+/**
+ * Tier 1 of the precision ladder (ADR 011): fenced ` ```align ` code blocks compile verbatim,
+ * zero LLM involved. Each block's content is a **JSON RuleFragment** (`schema.ts`) — the
+ * structural fields of one `RuleIR` variant, minus `id`/`provenance` (both are always assigned by
+ * the build pipeline, never authored — see `ground.ts`). Pure — no I/O.
+ */
+export function extractFencedAlignBlocks(lines, section, docPath) {
+    const fragments = [];
+    const errors = [];
+    const bodyStart = section.startLine; // 0-indexed first body line (section.startLine is the
+    // 1-based heading line; the body's first line is index === that 1-based number)
+    const bodyEndExclusive = section.endLine; // 0-indexed exclusive end (section.endLine is 1-based inclusive)
+    let i = bodyStart;
+    while (i < bodyEndExclusive) {
+        const line = lines[i];
+        if (line === undefined || !FENCE_OPEN_RE.test(line.trim())) {
+            i += 1;
+            continue;
+        }
+        const contentStart = i + 1; // 0-indexed
+        let j = contentStart;
+        while (j < bodyEndExclusive && !FENCE_CLOSE_RE.test((lines[j] ?? '').trim()))
+            j += 1;
+        const contentEndExclusive = j;
+        const contentLines = lines.slice(contentStart, contentEndExclusive);
+        const raw = contentLines.join('\n').trim();
+        const range = {
+            startLine: contentStart + 1,
+            endLine: Math.max(contentStart + 1, contentEndExclusive),
+        };
+        let parsedJson;
+        try {
+            parsedJson = JSON.parse(raw);
+        }
+        catch (err) {
+            errors.push({
+                section: section.anchor,
+                sourceFile: docPath,
+                sourceLineRange: range,
+                sourceQuote: raw,
+                reason: 'invalid-fragment',
+                detail: `JSON parse error in \`\`\`align block: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            i = j + 1;
+            continue;
+        }
+        const result = ruleFragmentSchema.safeParse(parsedJson);
+        if (!result.success) {
+            errors.push({
+                section: section.anchor,
+                sourceFile: docPath,
+                sourceLineRange: range,
+                sourceQuote: raw,
+                reason: 'invalid-fragment',
+                detail: `Schema validation error: ${result.error.issues.map((iss) => iss.message).join('; ')}`,
+            });
+            i = j + 1;
+            continue;
+        }
+        fragments.push({ fragment: result.data, sourceLineRange: range, sourceQuote: raw });
+        i = j + 1;
+    }
+    return { fragments, errors };
+}
+//# sourceMappingURL=tier1.js.map

package/dist/build/tier1.js.map

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

package/dist/build/tier2.d.ts

@@ -0,0 +1,42 @@
+import type { RepoRelativePath } from '../types/branded.js';
+import type { SourceRange } from '../types/violation.js';
+import type { DocSection } from './sections.js';
+import type { RuleFragment } from './schema.js';
+import type { FlaggedProposal } from './types.js';
+export interface ExtractedBullet {
+    readonly fragment: RuleFragment;
+    readonly sourceLineRange: SourceRange;
+    readonly sourceQuote: string;
+}
+/**
+ * Parses one bullet's sentence into a `RuleFragment` per ADR 011's constrained grammar: component
+ * names, "must not depend on", "no cycles", "layers," "must stay under N lines" (`arch.metric`,
+ * max-LOC only). Returns `undefined` for a sentence that
+ * doesn't match any known pattern — the caller flags it as `unparsed-bullet` rather than guessing.
+ * Deterministic regex matching only — no LLM, no fuzzy matching (this stage's CLI build path is
+ * zero-LLM by design; see the Stage 3 report's ADR-011-ambiguity resolutions).
+ */
+export declare function parseBulletSentence(sentence: string): RuleFragment | undefined;
+/**
+ * Human-readable grammar-form catalog (Stage 5, IMPLEMENTATION_PLAN.md) — the single source
+ * `align skill`'s generated bullet-grammar section reads (`packages/cli/src/skill/bullet-
+ * grammar.ts`). Each `example` is asserted against the real `parseBulletSentence` in
+ * `test/build-tier2-grammar-catalog.test.ts`: if a regex above changes shape and an example stops
+ * matching (or starts producing a different rule kind), that test fails — the catalog cannot
+ * silently drift from the parser it describes.
+ */
+export interface BulletGrammarForm {
+    readonly ruleKind: RuleFragment['kind'];
+    readonly pattern: string;
+    readonly example: string;
+}
+export declare const BULLET_GRAMMAR_FORMS: readonly BulletGrammarForm[];
+/**
+ * Tier 2 of the precision ladder (ADR 011): structured `- **Rule**: ...` bullets parse
+ * deterministically. Pure — no I/O.
+ */
+export declare function extractStructuredBullets(lines: readonly string[], section: DocSection, docPath: RepoRelativePath): {
+    readonly bullets: readonly ExtractedBullet[];
+    readonly errors: readonly FlaggedProposal[];
+};
+//# sourceMappingURL=tier2.d.ts.map

package/dist/build/tier2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier2.d.ts","sourceRoot":"","sources":["../../src/build/tier2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AA0DD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAsD9E;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAOD,eAAO,MAAM,oBAAoB,EAAE,SAAS,iBAAiB,EA+B5D,CAAC;AAEF;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,gBAAgB,GACxB;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,CAmC/F"}

package/dist/build/tier2.js

@@ -0,0 +1,187 @@
+const BULLET_RE = /^\s*-\s+\*\*Rule\*\*:\s*(.+?)\s*$/i;
+const NO_CYCLES_SCOPED_RE = /^no\s+cycles?(?:\s+(?:allowed|permitted))?\s+(?:within|in|for)\s+(.+?)\.?$/i;
+const NO_CYCLES_BARE_RE = /^no\s+cycles?\.?$/i;
+const NO_CYCLES_SUBJECT_RE = /^(.+?)\s+must\s+have\s+no\s+cycles?\.?$/i;
+const NO_DEPENDENCY_RE = /^(.+?)\s+must\s+not\s+depend\s+on\s+(.+?)\.?$/i;
+const LAYERS_RE = /^(.+?)\s+(?:may|can)\s+only\s+depend\s+on\s+(.+?)\.?$/i;
+// `arch.metric` (max-LOC only, promoted 2026-07-12 on kluster ruleset evidence,
+// IMPLEMENTATION_PLAN.md's Promotion log). Mirrors the DSL's `.maxLinesPerFile(max)`
+// (dsl/index.ts) — only the `loc` metric has a tier-2 grammar; fan-in/fan-out/instability stay
+// reserved pending their own evidence and gain their own bullet grammar when promoted.
+const MAX_LOC_RE = /^files\s+in\s+(.+?)\s+must\s+stay\s+under\s+(\d+)\s+lines?\.?$/i;
+// `security.manifest.*` (ADR 013, promoted 2026-07-12 on probe evidence). Bare-sentence forms,
+// same shape as `NO_CYCLES_BARE_RE` — neither rule takes a component target, so there is nothing
+// to capture.
+const SOURCE_HYGIENE_RE = /^dependenc(?:y|ies)\s+(?:sources?\s+)?must\s+be\s+(?:sourced\s+from\s+)?(?:the\s+)?registry(?:[- ]only)?\.?$/i;
+const NEW_DEPENDENCY_GATE_RE = /^new\s+dependenc(?:y|ies)\s+(?:requires?|needs?)\s+baseline\s+(?:approval|acceptance)\.?$/i;
+/** Splits a target-list clause ("`core`, `cli` and `pluginTypescript`") into raw tokens.
+ * Backtick/quote stripping happens at grounding time (`ground.ts`), not here — tier 2 stays a
+ * pure sentence splitter. */
+function splitTokens(clause) {
+    return clause
+        .split(/\s*,\s*|\s+and\s+|\s+or\s+/i)
+        .map((t) => t.trim())
+        .filter((t) => t.length > 0);
+}
+/**
+ * R5 (precision-ladder gap, GREENFIELD_TRIAD_REPORT.md §1): tier-2 bullets had no field for an
+ * authored rationale — only fenced-JSON blocks (tier 1) could carry `.because()` text, capping the
+ * greenfield demo's `.because()` coverage at 75% for no reason other than which tier a rule was
+ * authored in. Splits an optional trailing "Because <rationale>." clause off a bullet's rule
+ * sentence: "api may only depend on core. Because the API layer must stay headless." -> sentence
+ * "api may only depend on core", because "the API layer must stay headless". The result flows
+ * straight into `RuleFragment.because` (every fragment variant already has this optional field,
+ * `schema.ts` — the same field a tier-1 fenced block's own `"because"` JSON key populates), so
+ * `groundFragment`/`buildProvenance` (`ground.ts`/`provenance.ts`) need no changes at all: an
+ * authored tier-2 rationale is prepended to the auto-generated "Enforced by <doc>:<line>: '<quote>'"
+ * phrase exactly like a tier-1 fragment's `because` is.
+ *
+ * The literal period-then-"Because" boundary is the deterministic separator — no NLP, and no
+ * ambiguity with a rule sentence that happens to use the word "because" without that boundary
+ * (which simply isn't matched, and flows through unsplit, same as today).
+ */
+const TRAILING_BECAUSE_RE = /^(.*?)\.\s+Because\s+(.+?)\s*\.?$/i;
+function splitBecauseClause(raw) {
+    const trimmed = raw.trim();
+    const match = TRAILING_BECAUSE_RE.exec(trimmed);
+    if (match?.[1] !== undefined && match[2] !== undefined && match[2].length > 0) {
+        return { sentence: match[1].trim(), because: match[2].trim() };
+    }
+    return { sentence: trimmed.replace(/\.$/, '').trim(), because: undefined };
+}
+/**
+ * Parses one bullet's sentence into a `RuleFragment` per ADR 011's constrained grammar: component
+ * names, "must not depend on", "no cycles", "layers," "must stay under N lines" (`arch.metric`,
+ * max-LOC only). Returns `undefined` for a sentence that
+ * doesn't match any known pattern — the caller flags it as `unparsed-bullet` rather than guessing.
+ * Deterministic regex matching only — no LLM, no fuzzy matching (this stage's CLI build path is
+ * zero-LLM by design; see the Stage 3 report's ADR-011-ambiguity resolutions).
+ */
+export function parseBulletSentence(sentence) {
+    const scopedCycles = NO_CYCLES_SCOPED_RE.exec(sentence);
+    if (scopedCycles?.[1] !== undefined) {
+        return { kind: 'arch.no-cycles', scope: scopedCycles[1].trim() };
+    }
+    if (NO_CYCLES_BARE_RE.test(sentence)) {
+        return { kind: 'arch.no-cycles', scope: 'repo' };
+    }
+    const subjectCycles = NO_CYCLES_SUBJECT_RE.exec(sentence);
+    if (subjectCycles?.[1] !== undefined) {
+        return { kind: 'arch.no-cycles', scope: subjectCycles[1].trim() };
+    }
+    const noDependency = NO_DEPENDENCY_RE.exec(sentence);
+    if (noDependency?.[1] !== undefined && noDependency[2] !== undefined) {
+        const from = splitTokens(noDependency[1])[0];
+        const targets = splitTokens(noDependency[2]);
+        const to = targets[0];
+        // Single from -> single to is the only shape a RuleFragment can express (a "from must not
+        // depend on A, B" bullet with multiple targets isn't representable as one fragment — the
+        // caller sees `undefined` here and flags it as unparsed rather than silently dropping targets;
+        // multi-target denylists are `align.layers`'s job, or split into multiple bullets).
+        if (from === undefined || to === undefined || targets.length > 1)
+            return undefined;
+        return { kind: 'arch.no-dependency', from, to };
+    }
+    const layers = LAYERS_RE.exec(sentence);
+    if (layers?.[1] !== undefined && layers[2] !== undefined) {
+        const layerTokens = splitTokens(layers[1]);
+        const layer = layerTokens[0];
+        const canDependOn = splitTokens(layers[2]);
+        if (layer === undefined || layerTokens.length > 1 || canDependOn.length === 0)
+            return undefined;
+        return { kind: 'arch.layers', layers: [{ layer, canDependOn }] };
+    }
+    const maxLoc = MAX_LOC_RE.exec(sentence);
+    if (maxLoc?.[1] !== undefined && maxLoc[2] !== undefined) {
+        const targetTokens = splitTokens(maxLoc[1]);
+        const target = targetTokens[0];
+        const max = Number.parseInt(maxLoc[2], 10);
+        // Single target only — same "a RuleFragment can express one grounded target" discipline as
+        // `NO_DEPENDENCY_RE`/`LAYERS_RE` above.
+        if (target === undefined || targetTokens.length > 1 || !Number.isFinite(max))
+            return undefined;
+        return { kind: 'arch.metric', target, metric: 'loc', max };
+    }
+    if (SOURCE_HYGIENE_RE.test(sentence)) {
+        return { kind: 'security.manifest.source-hygiene' };
+    }
+    if (NEW_DEPENDENCY_GATE_RE.test(sentence)) {
+        return { kind: 'security.manifest.new-dependency' };
+    }
+    return undefined;
+}
+/** Appended to every pattern below (R5): any bullet may carry an optional trailing rationale
+ * clause, parsed into the rule's `.because()` provenance — a period then the literal word
+ * "Because" is the deterministic boundary between the rule sentence and the rationale. */
+const BECAUSE_SUFFIX = ' Optionally followed by " Because <rationale>." to record why (e.g. "... Because the API layer must stay headless.") — parsed into the rule\'s .because() provenance.';
+export const BULLET_GRAMMAR_FORMS = [
+    {
+        ruleKind: 'arch.no-dependency',
+        pattern: `<component> must not depend on <component>.${BECAUSE_SUFFIX}`,
+        example: 'api must not depend on ui.',
+    },
+    {
+        ruleKind: 'arch.layers',
+        pattern: `<component> may|can only depend on <component>[, <component> and/or <component>...].${BECAUSE_SUFFIX}`,
+        example: 'api may only depend on core.',
+    },
+    {
+        ruleKind: 'arch.no-cycles',
+        pattern: `no cycles. | no cycles within|in|for <scope>. | <scope> must have no cycles.${BECAUSE_SUFFIX}`,
+        example: 'no cycles.',
+    },
+    {
+        ruleKind: 'arch.metric',
+        pattern: `files in <component> must stay under <N> lines.${BECAUSE_SUFFIX}`,
+        example: 'files in core must stay under 500 lines.',
+    },
+    {
+        ruleKind: 'security.manifest.source-hygiene',
+        pattern: `dependency|dependencies (sources) must be (sourced from the) registry(-only).${BECAUSE_SUFFIX}`,
+        example: 'dependency sources must be registry-only.',
+    },
+    {
+        ruleKind: 'security.manifest.new-dependency',
+        pattern: `new dependency|dependencies requires|needs baseline approval|acceptance.${BECAUSE_SUFFIX}`,
+        example: 'new dependency requires baseline approval.',
+    },
+];
+/**
+ * Tier 2 of the precision ladder (ADR 011): structured `- **Rule**: ...` bullets parse
+ * deterministically. Pure — no I/O.
+ */
+export function extractStructuredBullets(lines, section, docPath) {
+    const bullets = [];
+    const errors = [];
+    const bodyStart = section.startLine;
+    const bodyEndExclusive = section.endLine;
+    for (let i = bodyStart; i < bodyEndExclusive; i += 1) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        const match = BULLET_RE.exec(line);
+        if (match?.[1] === undefined)
+            continue;
+        const { sentence, because } = splitBecauseClause(match[1]);
+        const range = { startLine: i + 1, endLine: i + 1 };
+        const fragment = parseBulletSentence(sentence);
+        if (fragment === undefined) {
+            errors.push({
+                section: section.anchor,
+                sourceFile: docPath,
+                sourceLineRange: range,
+                sourceQuote: line.trim(),
+                reason: 'unparsed-bullet',
+                detail: `Bullet did not match the tier-2 grammar (component names + "must not depend on" / "no cycles" / "may only depend on" / "must stay under N lines"): "${sentence}"`,
+            });
+            continue;
+        }
+        bullets.push({
+            fragment: because === undefined ? fragment : { ...fragment, because },
+            sourceLineRange: range,
+            sourceQuote: line.trim(),
+        });
+    }
+    return { bullets, errors };
+}
+//# sourceMappingURL=tier2.js.map

package/dist/build/tier2.js.map

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

package/dist/build/types.d.ts

@@ -0,0 +1,42 @@
+import type { RepoRelativePath, RuleId } from '../types/branded.js';
+import type { RuleIR } from '../types/ir.js';
+import type { SourceRange } from '../types/violation.js';
+/** Why a candidate rule was NOT written — ADR 011: "ungroundable -> flagged proposal, never
+ * silently written." Every reason is surfaced to the human/agent, never silently dropped. */
+export type FlaggedReason = 'ungroundable-selector' | 'unparsed-bullet' | 'invalid-fragment' | 'conflicting-rule-id' | 'unregistered-host-rule';
+export interface FlaggedProposal {
+    readonly section: string;
+    readonly sourceFile: RepoRelativePath;
+    readonly sourceLineRange: SourceRange;
+    readonly sourceQuote: string;
+    readonly reason: FlaggedReason;
+    readonly detail: string;
+}
+export type SectionTier = 'verbatim' | 'bullet' | 'prose' | 'empty';
+export interface SectionClassification {
+    readonly anchor: string;
+    readonly headingText: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly contentHash: string;
+    readonly tier: SectionTier;
+    /** Rule ids produced from this section, post-dedup — empty for 'prose'/'empty' sections. */
+    readonly ruleIds: readonly RuleId[];
+}
+/** Pass-1 scaffold for a prose section (ADR 011 two-pass clarification, Stage 3 MCP spec): align
+ * never invents concerns — `concerns` is deliberately empty here, for the connected client agent
+ * to fill in pass 2. */
+export interface ProseSectionScaffold {
+    readonly anchor: string;
+    readonly headingText: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly concerns: readonly string[];
+}
+export interface BuildProposal {
+    readonly sections: readonly SectionClassification[];
+    readonly rules: readonly RuleIR[];
+    readonly flagged: readonly FlaggedProposal[];
+    readonly proseSections: readonly ProseSectionScaffold[];
+}
+//# sourceMappingURL=types.d.ts.map