@spikedpunch/align-cli 0.1.0

package/dist/skill/fix-loop-protocol.js

@@ -0,0 +1,38 @@
+export const FIX_LOOP_PROTOCOL = [
+    {
+        summary: 'check → fix → re-check until green.',
+        detail: 'Run `align check` / `align_check` after every structural change. Fix what it reports, then re-check — ' +
+            'never assume a fix worked without a fresh verdict. Every check is a full fresh scan (ADR 005): there is ' +
+            'no stale cache to distrust, so trust every verdict as current.',
+    },
+    {
+        summary: 'RED IS BLOCKING.',
+        detail: 'A red `align check` / `align_check` means the change is not done. Do not consider a structural change ' +
+            'complete, hand control back, or move on to the next task while red.',
+    },
+    {
+        summary: 'Never edit align.config.ts or .align/** to force green.',
+        detail: 'Removing, weakening, or suppressing a rule in align.config.ts, or hand-editing anything under .align/ ' +
+            '(baseline.json, generated-rules.json, rules.lock.json, cache), is not a fix — it hides the finding ' +
+            'instead of resolving it. Fix the code the rule is pointing at.',
+    },
+    {
+        summary: 'Baseline acceptance is a HUMAN decision.',
+        detail: '`align baseline accept` / `align_baseline_accept` (gated off by default, ADR 006) tolerates a violation ' +
+            'as existing debt — it does not fix it. An agent under pressure to reach green must not self-serve this; ' +
+            'propose it to the human instead of calling it unprompted.',
+    },
+    {
+        summary: 'Explain on demand, not by default.',
+        detail: 'Use `align explain <ruleId>` / `align_explain_rule` to understand WHY a rule fired — its kind, ' +
+            '`.because()` rationale, and constrained components (plus a Mermaid diagram for cycle/dependency ' +
+            'violations) — before proposing a fix, not as a first-pass survey of the whole ruleset.',
+    },
+    {
+        summary: 'Payloads are structured-fields-only — render prose yourself if you need it.',
+        detail: 'Machine payloads (`align_check`, `align_violations`, `align check --json`) carry structured fields only ' +
+            '(file, line, specifier, snippet, fixHint) — no redundant prose `message` field (ADR 007, measured 3.6x ' +
+            'token reduction). Passing gates report counts only, never per-item text.',
+    },
+];
+//# sourceMappingURL=fix-loop-protocol.js.map

package/dist/skill/fix-loop-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-loop-protocol.js","sourceRoot":"","sources":["../../src/skill/fix-loop-protocol.ts"],"names":[],"mappings":"AAiBA,MAAM,CAAC,MAAM,iBAAiB,GAA6B;IACzD;QACE,OAAO,EAAE,qCAAqC;QAC9C,MAAM,EACJ,wGAAwG;YACxG,0GAA0G;YAC1G,gEAAgE;KACnE;IACD;QACE,OAAO,EAAE,kBAAkB;QAC3B,MAAM,EACJ,wGAAwG;YACxG,qEAAqE;KACxE;IACD;QACE,OAAO,EAAE,yDAAyD;QAClE,MAAM,EACJ,wGAAwG;YACxG,qGAAqG;YACrG,gEAAgE;KACnE;IACD;QACE,OAAO,EAAE,0CAA0C;QACnD,MAAM,EACJ,0GAA0G;YAC1G,0GAA0G;YAC1G,2DAA2D;KAC9D;IACD;QACE,OAAO,EAAE,oCAAoC;QAC7C,MAAM,EACJ,iGAAiG;YACjG,kGAAkG;YAClG,wFAAwF;KAC3F;IACD;QACE,OAAO,EAAE,6EAA6E;QACtF,MAAM,EACJ,0GAA0G;YAC1G,yGAAyG;YACzG,0EAA0E;KAC7E;CACF,CAAC"}

package/dist/skill/gates.d.ts

@@ -0,0 +1,2 @@
+export declare function renderGatesSection(): string;
+//# sourceMappingURL=gates.d.ts.map

package/dist/skill/gates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gates.d.ts","sourceRoot":"","sources":["../../src/skill/gates.ts"],"names":[],"mappings":"AAaA,wBAAgB,kBAAkB,IAAI,MAAM,CAO3C"}

package/dist/skill/gates.js

@@ -0,0 +1,20 @@
+/**
+ * Gate-list reference for `align skill` — reads `@spikedpunch/align-core`'s `GATE_KINDS` (derived from
+ * `CATEGORIES`, `types/violation.ts`), the same array `GateResult['gate']` is typed from.
+ * Implementation status (which gates actually execute today vs. are reserved for the Stage 5
+ * tool-wrapping growth path) is current-state prose, not itself schema-derived — there is no
+ * runtime "is this gate wired up" flag in v1 — so it is hand-maintained here and covered by
+ * `test/skill-completeness.test.ts` only insofar as every GATE_KINDS entry must be *named*
+ * somewhere in the rendered section (not that its status prose is correct).
+ */
+import { GATE_KINDS } from '@spikedpunch/align-core';
+const IMPLEMENTED = new Set(['parse', 'architecture', 'security']);
+export function renderGatesSection() {
+    const order = 'Priority order (ADR 007, fixed even though not every gate is wired up yet): architecture > security > types > lint > format.';
+    const rows = GATE_KINDS.map((gate) => {
+        const status = IMPLEMENTED.has(gate) ? 'implemented (v1)' : 'reserved — Stage 5 tool-wrapping growth path, not yet wired up';
+        return `- \`${gate}\` — ${status}`;
+    });
+    return [order, '', ...rows].join('\n');
+}
+//# sourceMappingURL=gates.js.map

package/dist/skill/gates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gates.js","sourceRoot":"","sources":["../../src/skill/gates.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,MAAM,WAAW,GAAwB,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC,CAAC;AAExF,MAAM,UAAU,kBAAkB;IAChC,MAAM,KAAK,GAAG,8HAA8H,CAAC;IAC7I,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACnC,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,gEAAgE,CAAC;QAC7H,OAAO,OAAO,IAAI,QAAQ,MAAM,EAAE,CAAC;IACrC,CAAC,CAAC,CAAC;IACH,OAAO,CAAC,KAAK,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC"}

package/dist/skill/install.d.ts

@@ -0,0 +1,25 @@
+import type { Command } from 'commander';
+/**
+ * Writes `.claude/skills/align/SKILL.md` into the target repo (Stage 5, IMPLEMENTATION_PLAN.md).
+ *
+ * Deliberately simpler than `init/claude-md.ts`'s preserve-content-around-the-block discipline:
+ * CLAUDE.md is a human-owned file align appends one section to, so re-running `init` must not
+ * clobber the surrounding human content. `.claude/skills/align/SKILL.md`, by contrast, is entirely
+ * align-generated (nothing else is expected to live in it, the same way nothing hand-written lives
+ * in `.align/generated-rules.json`) — every `--install` run fully regenerates it. The
+ * `<!-- align:start/end -->` markers are kept anyway for the same visual/debuggability reason
+ * every other generated-block file in this repo uses them, and so a future human addition after
+ * the block (unlikely, but not impossible) has a documented boundary to sit outside of.
+ *
+ * Always installs the full (`'all'`) guide regardless of the CLI invocation's `--topic` filter —
+ * `--topic` only scopes the stdout preview for a single call; the installed artifact is meant to
+ * be complete since it isn't re-run per interaction.
+ *
+ * The written block is stamped with the installing binary's `ALIGN_VERSION` (`version-stamp.ts`):
+ * a human-visible line plus a machine-parseable marker comment, both near the top of the block.
+ * Because the whole file is fully regenerated on every `--install` run (see above), re-running
+ * naturally updates the stamp in place — there is no separate "patch the existing stamp" step, and
+ * no risk of the block or the stamp duplicating.
+ */
+export declare function writeSkillFile(rootDir: string, program: Command): string;
+//# sourceMappingURL=install.d.ts.map

package/dist/skill/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/skill/install.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmBzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CASxE"}

package/dist/skill/install.js

@@ -0,0 +1,49 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ALIGN_VERSION } from '../telemetry/index.js';
+import { renderSkillMarkdown } from './render.js';
+import { renderVersionStamp } from './version-stamp.js';
+const START_MARKER = '<!-- align:start -->';
+const END_MARKER = '<!-- align:end -->';
+const FRONTMATTER = `---
+name: align
+description: >-
+  Guidance for authoring align architecture-conformance rules (DSL verbs, rule kinds, doc-authoring
+  bullet grammar) and for driving the align check-fix-recheck loop until green. Use when the user
+  asks to run align, fix an align/align_check violation, author an align.config.ts rule, understand
+  an architecture-conformance or dependency-direction failure, or asks what align rule kinds or DSL
+  verbs are available. Trigger phrases: "align check", "align violation", "architecture violation",
+  "align rule", "fix align", "align.config.ts", "dependency direction", "import cycle", "align skill".
+---`;
+/**
+ * Writes `.claude/skills/align/SKILL.md` into the target repo (Stage 5, IMPLEMENTATION_PLAN.md).
+ *
+ * Deliberately simpler than `init/claude-md.ts`'s preserve-content-around-the-block discipline:
+ * CLAUDE.md is a human-owned file align appends one section to, so re-running `init` must not
+ * clobber the surrounding human content. `.claude/skills/align/SKILL.md`, by contrast, is entirely
+ * align-generated (nothing else is expected to live in it, the same way nothing hand-written lives
+ * in `.align/generated-rules.json`) — every `--install` run fully regenerates it. The
+ * `<!-- align:start/end -->` markers are kept anyway for the same visual/debuggability reason
+ * every other generated-block file in this repo uses them, and so a future human addition after
+ * the block (unlikely, but not impossible) has a documented boundary to sit outside of.
+ *
+ * Always installs the full (`'all'`) guide regardless of the CLI invocation's `--topic` filter —
+ * `--topic` only scopes the stdout preview for a single call; the installed artifact is meant to
+ * be complete since it isn't re-run per interaction.
+ *
+ * The written block is stamped with the installing binary's `ALIGN_VERSION` (`version-stamp.ts`):
+ * a human-visible line plus a machine-parseable marker comment, both near the top of the block.
+ * Because the whole file is fully regenerated on every `--install` run (see above), re-running
+ * naturally updates the stamp in place — there is no separate "patch the existing stamp" step, and
+ * no risk of the block or the stamp duplicating.
+ */
+export function writeSkillFile(rootDir, program) {
+    const dir = path.join(rootDir, '.claude', 'skills', 'align');
+    const filePath = path.join(dir, 'SKILL.md');
+    fs.mkdirSync(dir, { recursive: true });
+    const body = renderSkillMarkdown('all', program);
+    const content = `${FRONTMATTER}\n\n${START_MARKER}\n${renderVersionStamp(ALIGN_VERSION)}\n\n${body}\n${END_MARKER}\n`;
+    fs.writeFileSync(filePath, content, 'utf8');
+    return filePath;
+}
+//# sourceMappingURL=install.js.map

package/dist/skill/install.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.js","sourceRoot":"","sources":["../../src/skill/install.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAExD,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAC5C,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAExC,MAAM,WAAW,GAAG;;;;;;;;;IAShB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,cAAc,CAAC,OAAe,EAAE,OAAgB;IAC9D,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IAC5C,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAEvC,MAAM,IAAI,GAAG,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACjD,MAAM,OAAO,GAAG,GAAG,WAAW,OAAO,YAAY,KAAK,kBAAkB,CAAC,aAAa,CAAC,OAAO,IAAI,KAAK,UAAU,IAAI,CAAC;IACtH,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5C,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/skill/render.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Composes the full `align skill` markdown from the generated sections (rule kinds, DSL verbs,
+ * bullet grammar, gates, CLI inventory — all read live from the installed binary, never
+ * hand-written prose lists, Stage 5 IMPLEMENTATION_PLAN.md) and the static prose sections
+ * (fix-loop protocol, doc-authoring guidance, baseline consent doctrine, MCP payload/tool
+ * reference).
+ */
+import type { Command } from 'commander';
+export type SkillTopic = 'authoring' | 'fixing' | 'all';
+/** `program` is the already-built `commander` `Command` tree (`buildProgram()`, `../program.js`)
+ * — passed in rather than imported here to avoid a cycle back to `program.ts`, which registers
+ * the `skill` command that reaches this module (`cli-inventory.ts`'s doc comment has the full
+ * rationale). */
+export declare function renderSkillMarkdown(topic: SkillTopic, program: Command): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/skill/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/skill/render.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,QAAQ,GAAG,KAAK,CAAC;AAMxD;;;iBAGiB;AACjB,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAuC/E"}

package/dist/skill/render.js

@@ -0,0 +1,35 @@
+import { renderRuleKindsSection } from './rule-kinds.js';
+import { renderDslVerbsSection } from './dsl-verbs.js';
+import { renderBulletGrammarSection } from './bullet-grammar.js';
+import { renderGatesSection } from './gates.js';
+import { renderCliInventorySection } from './cli-inventory.js';
+import { renderFixLoopProtocolSection, renderDocAuthoringSection, renderBaselineConsentSection, renderMcpPayloadReferenceSection } from './static-sections.js';
+function section(heading, body) {
+    return `## ${heading}\n\n${body}`;
+}
+/** `program` is the already-built `commander` `Command` tree (`buildProgram()`, `../program.js`)
+ * — passed in rather than imported here to avoid a cycle back to `program.ts`, which registers
+ * the `skill` command that reaches this module (`cli-inventory.ts`'s doc comment has the full
+ * rationale). */
+export function renderSkillMarkdown(topic, program) {
+    const parts = [
+        '# align — LLM skill guide',
+        '',
+        'align is an architecture-conformance verification oracle: a fluent TS DSL compiles to a portable JSON IR,',
+        'a language plugin evaluates it against the real dependency graph on every call (always a fresh scan — no',
+        'stale cache to distrust), and violations surface through the CLI and an MCP server. This guide is',
+        'generated by `align skill` from the installed binary\'s own live registries — the rule-kind list, DSL verb',
+        'table, bullet grammar, gate list, and CLI command inventory below can never drift from what this specific',
+        'install actually supports.',
+    ];
+    if (topic === 'authoring' || topic === 'all') {
+        parts.push('', section('Rule kinds', 'Every rule kind the installed IR schema supports (walked live off `ruleIRSchema`):\n\n' + renderRuleKindsSection()), '', section('DSL verbs', 'The authoring surface (`defineProject`\'s `c.*` factories), introspected off the live builder objects:\n\n' + renderDslVerbsSection()), '', section('Tier-2 bullet grammar (doc authoring)', 'Sentence forms `- **Rule**: ...` bullets in an architecture doc parse into deterministically, zero LLM:\n\n' +
+            renderBulletGrammarSection()), '', section('Doc authoring: the precision ladder', renderDocAuthoringSection()));
+    }
+    if (topic === 'fixing' || topic === 'all') {
+        parts.push('', section('Fix-loop protocol', renderFixLoopProtocolSection()), '', section('Baseline consent doctrine', renderBaselineConsentSection()), '', section('MCP payload & tool reference', renderMcpPayloadReferenceSection()));
+    }
+    parts.push('', section('Gates', renderGatesSection()), '', section('CLI commands', renderCliInventorySection(program)));
+    return parts.join('\n');
+}
+//# sourceMappingURL=render.js.map

package/dist/skill/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../../src/skill/render.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,4BAA4B,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AAI/J,SAAS,OAAO,CAAC,OAAe,EAAE,IAAY;IAC5C,OAAO,MAAM,OAAO,OAAO,IAAI,EAAE,CAAC;AACpC,CAAC;AAED;;;iBAGiB;AACjB,MAAM,UAAU,mBAAmB,CAAC,KAAiB,EAAE,OAAgB;IACrE,MAAM,KAAK,GAAa;QACtB,2BAA2B;QAC3B,EAAE;QACF,2GAA2G;QAC3G,0GAA0G;QAC1G,mGAAmG;QACnG,4GAA4G;QAC5G,2GAA2G;QAC3G,4BAA4B;KAC7B,CAAC;IAEF,IAAI,KAAK,KAAK,WAAW,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;QAC7C,KAAK,CAAC,IAAI,CACR,EAAE,EACF,OAAO,CACL,YAAY,EACZ,wFAAwF,GAAG,sBAAsB,EAAE,CACpH,EACD,EAAE,EACF,OAAO,CAAC,WAAW,EAAE,4GAA4G,GAAG,qBAAqB,EAAE,CAAC,EAC5J,EAAE,EACF,OAAO,CACL,uCAAuC,EACvC,6GAA6G;YAC3G,0BAA0B,EAAE,CAC/B,EACD,EAAE,EACF,OAAO,CAAC,qCAAqC,EAAE,yBAAyB,EAAE,CAAC,CAC5E,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;QAC1C,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,mBAAmB,EAAE,4BAA4B,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,2BAA2B,EAAE,4BAA4B,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,8BAA8B,EAAE,gCAAgC,EAAE,CAAC,CAAC,CAAC;IAC1O,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,OAAO,EAAE,kBAAkB,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,cAAc,EAAE,yBAAyB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAExH,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/skill/rule-kinds.d.ts

@@ -0,0 +1,12 @@
+/** Walks the live `ruleIRSchema` discriminated union and returns its member `kind` literals in
+ * declaration order — the "generated from the live schema/IR registry" source of truth. */
+export declare function getRuleKinds(): readonly string[];
+export interface RuleKindEntry {
+    readonly kind: string;
+    readonly description: string;
+}
+/** Fails fast if a live kind has no description — the mechanism that keeps this file from
+ * silently drifting behind a new rule kind. */
+export declare function describeRuleKinds(): readonly RuleKindEntry[];
+export declare function renderRuleKindsSection(): string;
+//# sourceMappingURL=rule-kinds.d.ts.map

package/dist/skill/rule-kinds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-kinds.d.ts","sourceRoot":"","sources":["../../src/skill/rule-kinds.ts"],"names":[],"mappings":"AAYA;2FAC2F;AAC3F,wBAAgB,YAAY,IAAI,SAAS,MAAM,EAAE,CAGhD;AAeD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;+CAC+C;AAC/C,wBAAgB,iBAAiB,IAAI,SAAS,aAAa,EAAE,CAa5D;AAED,wBAAgB,sBAAsB,IAAI,MAAM,CAG/C"}

package/dist/skill/rule-kinds.js

@@ -0,0 +1,47 @@
+/**
+ * Rule-kind reference (Stage 5, IMPLEMENTATION_PLAN.md "Elevated first items"): the *list* of
+ * kinds is walked live off `ruleIRSchema` (`@spikedpunch/align-core`'s zod discriminated union) — never
+ * hand-typed — so a new rule kind added to the IR shows up here automatically and a forgotten
+ * description fails fast (`describeRuleKinds`), the same discipline `dsl/verb-manifest.ts`
+ * applies to the DSL verb surface. `test/skill-completeness.test.ts` additionally asserts every
+ * live kind's text actually appears in the rendered skill markdown — the "adding a rule kind
+ * without skill coverage must fail CI" requirement.
+ */
+import { ruleIRSchema } from '@spikedpunch/align-core';
+/** Walks the live `ruleIRSchema` discriminated union and returns its member `kind` literals in
+ * declaration order — the "generated from the live schema/IR registry" source of truth. */
+export function getRuleKinds() {
+    const union = ruleIRSchema;
+    return union.options.map((option) => option.shape.kind.value);
+}
+// Hand-written one-liners, keyed by the live kind string above — RULE_KIND_DESCRIPTIONS is
+// prose, but its *coverage* is enforced: `describeRuleKinds` throws for any live kind missing an
+// entry here, and the skill-completeness test throws for any entry whose kind no longer exists.
+const RULE_KIND_DESCRIPTIONS = {
+    'arch.no-dependency': 'One component must not import from another. Authored via `arch.layer(x).cannotDependOn(y)` or `arch.component(x).isIsolated()`.',
+    'arch.no-cycles': 'No import cycle within a scope (component or the whole repo). Authored via `arch.noCycles(scope?, { includeTypeOnly? })`. Violations carry per-edge chain detail, not just file names.',
+    'arch.layers': 'A component may depend only on an explicit allowlist of other components. Authored via `arch.layer(x).canOnlyDependOn(...)`.',
+    'arch.metric': 'A component-scoped numeric limit — today only `metric: "loc"` (max lines per file) is promoted; fan-in/fan-out/instability remain reserved pending evidence. Authored via `arch.component(x).maxLinesPerFile(max)`.',
+    'custom.host': "An escape hatch referencing a `HostPredicate` your `align.config.ts` registers by name in its `hostRules` export (`Record<string, HostPredicate>`). REGISTRATION IS REQUIRED: `custom.host('foo')` in the ruleset with no `hostRules.foo` predicate hard-errors the gate at check time (it never silently reports green) — register the predicate, fix the name, or remove the rule. Authored via `custom.host(hostRuleName)`.",
+    'security.manifest.source-hygiene': 'Flags any dependency specifier resolving to a git/http(s)/file/link source instead of the registry or `workspace:`. Authored via `security.manifest.sourceHygiene()`. Repo-wide — no component scoping.',
+    'security.manifest.new-dependency': 'Fingerprints every current runtime/dev dependency at baseline time; a genuinely new dependency added afterward shows red until accepted. Authored via `security.manifest.newDependencyGate()`. Repo-wide — no component scoping.',
+};
+/** Fails fast if a live kind has no description — the mechanism that keeps this file from
+ * silently drifting behind a new rule kind. */
+export function describeRuleKinds() {
+    const kinds = getRuleKinds();
+    return kinds.map((kind) => {
+        const description = RULE_KIND_DESCRIPTIONS[kind];
+        if (description === undefined) {
+            throw new Error(`skill/rule-kinds.ts: live rule kind '${kind}' (from ruleIRSchema) has no entry in ` +
+                `RULE_KIND_DESCRIPTIONS. Add one so \`align skill\` cannot silently omit a rule kind the ` +
+                `installed binary actually supports.`);
+        }
+        return { kind, description };
+    });
+}
+export function renderRuleKindsSection() {
+    const lines = describeRuleKinds().map((entry) => `- \`${entry.kind}\` — ${entry.description}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=rule-kinds.js.map

package/dist/skill/rule-kinds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-kinds.js","sourceRoot":"","sources":["../../src/skill/rule-kinds.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAGvD;2FAC2F;AAC3F,MAAM,UAAU,YAAY;IAC1B,MAAM,KAAK,GAAG,YAA8F,CAAC;IAC7G,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED,2FAA2F;AAC3F,iGAAiG;AACjG,gGAAgG;AAChG,MAAM,sBAAsB,GAA2B;IACrD,oBAAoB,EAAE,iIAAiI;IACvJ,gBAAgB,EAAE,wLAAwL;IAC1M,aAAa,EAAE,8HAA8H;IAC7I,aAAa,EAAE,qNAAqN;IACpO,aAAa,EAAE,gaAAga;IAC/a,kCAAkC,EAAE,yMAAyM;IAC7O,kCAAkC,EAAE,kOAAkO;CACvQ,CAAC;AAOF;+CAC+C;AAC/C,MAAM,UAAU,iBAAiB;IAC/B,MAAM,KAAK,GAAG,YAAY,EAAE,CAAC;IAC7B,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,MAAM,WAAW,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CACb,wCAAwC,IAAI,wCAAwC;gBAClF,0FAA0F;gBAC1F,qCAAqC,CACxC,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAC/B,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,MAAM,KAAK,GAAG,iBAAiB,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,CAAC,IAAI,QAAQ,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;IAC/F,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/skill/static-sections.d.ts

@@ -0,0 +1,5 @@
+export declare function renderFixLoopProtocolSection(): string;
+export declare function renderDocAuthoringSection(): string;
+export declare function renderBaselineConsentSection(): string;
+export declare function renderMcpPayloadReferenceSection(): string;
+//# sourceMappingURL=static-sections.d.ts.map

package/dist/skill/static-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-sections.d.ts","sourceRoot":"","sources":["../../src/skill/static-sections.ts"],"names":[],"mappings":"AASA,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAyBlD;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAgBrD;AAED,wBAAgB,gCAAgC,IAAI,MAAM,CAkBzD"}

package/dist/skill/static-sections.js

@@ -0,0 +1,74 @@
+/**
+ * Hand-written, stable prose sections for `align skill` (Stage 5, IMPLEMENTATION_PLAN.md
+ * "Elevated first items" — the plan explicitly separates these from the generated-from-schema
+ * sections in rule-kinds.ts/dsl-verbs.ts/bullet-grammar.ts/gates.ts/cli-inventory.ts). These
+ * describe protocol and doctrine, not the live rule/verb/gate surface, so there is nothing to
+ * introspect — they're reviewed like any other doc, not tested for schema completeness.
+ */
+import { FIX_LOOP_PROTOCOL } from './fix-loop-protocol.js';
+export function renderFixLoopProtocolSection() {
+    return FIX_LOOP_PROTOCOL.map((p) => `- **${p.summary}** ${p.detail}`).join('\n');
+}
+export function renderDocAuthoringSection() {
+    return [
+        'A markdown architecture/best-practices doc is a buildable intent source (`align build`, ADR 011) — it',
+        "compiles to rules the way `package.json` resolves to a lockfile. `align build` (dry-run by default) and",
+        "the MCP `align_propose_rules` tool both compile a doc through the same **precision ladder**, most-trusted",
+        'form first — always author at the highest tier your intent allows:',
+        '',
+        '1. **Fenced ` ```align ` blocks compile verbatim, zero LLM.** Block content is a JSON `RuleFragment` — the',
+        "   structural fields of one rule kind, minus `id`/`provenance` (both are always assigned by the build",
+        '   pipeline). Highest trust, most precise, most work to author by hand.',
+        '2. **Structured `- **Rule**: ...` bullets parse deterministically** — see the generated bullet-grammar',
+        '   section above for the exact sentence forms. An LLM only grounds fuzzy component-name selectors against',
+        '   the components registry; it never invents rule structure.',
+        '3. **Free prose goes through two-pass clarification** (`align_propose_rules`, ADR 011): pass 1',
+        '   (Discovery) — read the doc, output a short list of *concerns*, no IR yet, human confirms or skips each.',
+        '   Pass 2 (Refinement) — IR is generated only for confirmed concerns, each selector grounded against',
+        '   component names (never raw paths), with a dry-run impact report before anything is written. This is the',
+        '   least-trusted, most-scaffolded path — never skip straight to writing rules from prose without the',
+        "   human confirmation gate in between; that's the overwhelm failure mode this mode exists to prevent.",
+        '',
+        'Nothing writes without an explicit `--apply` (CLI) or `apply: true` (MCP) — the default is always a',
+        'dry-run diff + impact delta ("adds N new violations / masks M baselined"). A rule-level diff is minimized',
+        "(IR-identical rules keep their ids verbatim), so a prose typo fix re-proposing a section yields an empty",
+        'diff, not id churn.',
+    ].join('\n');
+}
+export function renderBaselineConsentSection() {
+    return [
+        'The baseline tolerates existing debt so a new rule (or align\'s first run) on a mature repo does not',
+        'demand a wall of red on day one. Consent is explicit, never silent (ADR 006):',
+        '',
+        '- `align init` seeds the baseline from the first full check. **Interactive**: prints a loud summary and',
+        '  asks. **Non-interactive/CI**: requires an explicit `--accept-existing` flag — silence is never consent,',
+        '  and without the flag `align init` exits red.',
+        '- `align baseline accept [--rule <ruleId>]` accepts current violations (optionally scoped to one rule) —',
+        '  a human-invoked CLI command.',
+        '- **MCP never self-serves baseline acceptance by default**: `align_baseline_accept` is gated behind',
+        '  `allowBaselineFromMcp`, default `false`. An agent cannot grant itself amnesty from a rule it is failing.',
+        '  If a violation looks like it should be baselined as pre-existing debt rather than fixed, say so to the',
+        "  human and let them run the acceptance — don't call an acceptance tool unprompted under pressure to turn",
+        '  a red verdict green.',
+    ].join('\n');
+}
+export function renderMcpPayloadReferenceSection() {
+    return [
+        '`align mcp` (stdio) exposes:',
+        '',
+        '- **`align_check`** — fresh full scan, green/red/error verdict + per-gate counts. No arguments.',
+        '- **`align_violations`** — current violations in priority order (architecture > security > types > lint >',
+        '  format), structured fields only, paginated (`cursor`).',
+        '- **`align_explain_rule`** — one rule\'s kind, `.because()` rationale, constrained components with example',
+        '  files, and a Mermaid diagram for cycle/dependency violations. Pull-on-demand only — never inlined into',
+        '  `align_check`/`align_violations` payloads.',
+        '- **`align_propose_rules`** — two-pass doc-to-rules compilation (see the doc-authoring section above).',
+        '',
+        'Payload discipline applies to every tool above (ADR 007): passing gates are counts, never per-item text;',
+        'no `message` prose field duplicating structured fields (`fromFile`/`toFile`/`specifier`/`line`/`snippet`',
+        'already exist structurally — render prose yourself if you need it); results are priority-sorted before',
+        'pagination/truncation; caps and pagination are mandatory, not optional. A red `align_check` response for a',
+        'handful of violations costs roughly 1K tokens, not tens of thousands.',
+    ].join('\n');
+}
+//# sourceMappingURL=static-sections.js.map

package/dist/skill/static-sections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-sections.js","sourceRoot":"","sources":["../../src/skill/static-sections.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,MAAM,UAAU,4BAA4B;IAC1C,OAAO,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnF,CAAC;AAED,MAAM,UAAU,yBAAyB;IACvC,OAAO;QACL,uGAAuG;QACvG,yGAAyG;QACzG,2GAA2G;QAC3G,oEAAoE;QACpE,EAAE;QACF,4GAA4G;QAC5G,uGAAuG;QACvG,yEAAyE;QACzE,wGAAwG;QACxG,2GAA2G;QAC3G,8DAA8D;QAC9D,gGAAgG;QAChG,4GAA4G;QAC5G,sGAAsG;QACtG,4GAA4G;QAC5G,sGAAsG;QACtG,uGAAuG;QACvG,EAAE;QACF,qGAAqG;QACrG,2GAA2G;QAC3G,0GAA0G;QAC1G,qBAAqB;KACtB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,OAAO;QACL,sGAAsG;QACtG,+EAA+E;QAC/E,EAAE;QACF,yGAAyG;QACzG,2GAA2G;QAC3G,gDAAgD;QAChD,0GAA0G;QAC1G,gCAAgC;QAChC,qGAAqG;QACrG,4GAA4G;QAC5G,0GAA0G;QAC1G,2GAA2G;QAC3G,wBAAwB;KACzB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED,MAAM,UAAU,gCAAgC;IAC9C,OAAO;QACL,8BAA8B;QAC9B,EAAE;QACF,iGAAiG;QACjG,2GAA2G;QAC3G,0DAA0D;QAC1D,4GAA4G;QAC5G,0GAA0G;QAC1G,8CAA8C;QAC9C,wGAAwG;QACxG,EAAE;QACF,0GAA0G;QAC1G,0GAA0G;QAC1G,wGAAwG;QACxG,4GAA4G;QAC5G,uEAAuE;KACxE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/skill/version-stamp.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The version stamp embedded in every `align skill --install`-written SKILL.md (`install.ts`): a
+ * human-visible line plus a machine-parseable HTML-comment marker carrying the align version that
+ * generated the snapshot.
+ *
+ * Why this exists: `align skill` (no `--install`) generates its guide live from the running
+ * binary's own registries on every call, so it can never drift. `--install`, by contrast, writes a
+ * point-in-time snapshot — a SKILL.md installed before some feature shipped (e.g. tier-2
+ * `.because()` support) silently won't mention it, with nothing telling the human or agent the
+ * snapshot is behind. The stamp makes that staleness detectable: `doctor.ts`'s `stale-skill`
+ * advisory reads the marker back out of an installed file and compares it against the running
+ * binary's `ALIGN_VERSION`. Defined here (not inline in `install.ts` or `doctor.ts`) so the
+ * marker's exact format has exactly one source of truth shared between the writer and the reader.
+ */
+/** Rendered into the installed body, near the top of the `<!-- align:start -->` block — never as
+ * frontmatter, so it can't collide with the `name`/`description` keys a skill loader requires. */
+export declare function renderVersionStamp(version: string): string;
+/** Extracts the stamped version from an installed SKILL.md's content, or `undefined` if the file
+ * predates version stamping (no marker present) — the "missing marker" case `doctor.ts` treats as
+ * stale on its own, distinct from a present-but-outdated version. */
+export declare function parseSkillVersionMarker(content: string): string | undefined;
+//# sourceMappingURL=version-stamp.d.ts.map

package/dist/skill/version-stamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-stamp.d.ts","sourceRoot":"","sources":["../../src/skill/version-stamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH;kGACkG;AAClG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAK1D;AAED;;qEAEqE;AACrE,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3E"}

package/dist/skill/version-stamp.js

@@ -0,0 +1,29 @@
+/**
+ * The version stamp embedded in every `align skill --install`-written SKILL.md (`install.ts`): a
+ * human-visible line plus a machine-parseable HTML-comment marker carrying the align version that
+ * generated the snapshot.
+ *
+ * Why this exists: `align skill` (no `--install`) generates its guide live from the running
+ * binary's own registries on every call, so it can never drift. `--install`, by contrast, writes a
+ * point-in-time snapshot — a SKILL.md installed before some feature shipped (e.g. tier-2
+ * `.because()` support) silently won't mention it, with nothing telling the human or agent the
+ * snapshot is behind. The stamp makes that staleness detectable: `doctor.ts`'s `stale-skill`
+ * advisory reads the marker back out of an installed file and compares it against the running
+ * binary's `ALIGN_VERSION`. Defined here (not inline in `install.ts` or `doctor.ts`) so the
+ * marker's exact format has exactly one source of truth shared between the writer and the reader.
+ */
+const VERSION_MARKER_PREFIX = 'align-skill-version';
+/** Rendered into the installed body, near the top of the `<!-- align:start -->` block — never as
+ * frontmatter, so it can't collide with the `name`/`description` keys a skill loader requires. */
+export function renderVersionStamp(version) {
+    return (`> Generated by \`align skill\` v${version}. Re-run \`align skill --install\` after upgrading align to refresh this snapshot.\n` +
+        `<!-- ${VERSION_MARKER_PREFIX}: ${version} -->`);
+}
+/** Extracts the stamped version from an installed SKILL.md's content, or `undefined` if the file
+ * predates version stamping (no marker present) — the "missing marker" case `doctor.ts` treats as
+ * stale on its own, distinct from a present-but-outdated version. */
+export function parseSkillVersionMarker(content) {
+    const match = new RegExp(`<!--\\s*${VERSION_MARKER_PREFIX}:\\s*(\\S+)\\s*-->`).exec(content);
+    return match?.[1];
+}
+//# sourceMappingURL=version-stamp.js.map

package/dist/skill/version-stamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-stamp.js","sourceRoot":"","sources":["../../src/skill/version-stamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,qBAAqB,GAAG,qBAAqB,CAAC;AAEpD;kGACkG;AAClG,MAAM,UAAU,kBAAkB,CAAC,OAAe;IAChD,OAAO,CACL,mCAAmC,OAAO,sFAAsF;QAChI,QAAQ,qBAAqB,KAAK,OAAO,MAAM,CAChD,CAAC;AACJ,CAAC;AAED;;qEAEqE;AACrE,MAAM,UAAU,uBAAuB,CAAC,OAAe;IACrD,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,WAAW,qBAAqB,oBAAoB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7F,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC"}

package/dist/telemetry/check-event.d.ts

@@ -0,0 +1,7 @@
+import type { CheckEvent, CheckRun, CheckScope } from '@spikedpunch/align-core';
+/** Maps a `CheckRun` (the same value `align check` already prints/emits as `--json`) to the
+ * `check` telemetry event — real latency DISTRIBUTION across many invocations, not one cold
+ * number (IMPLEMENTATION_PLAN.md's telemetry spec). `scope` is always `'all'` in v1 (ADR 005:
+ * `align check` only ever does a full fresh scan) — see `CheckScope`'s doc comment. */
+export declare function buildCheckEvent(run: CheckRun, wallMs: number, scope?: CheckScope): CheckEvent;
+//# sourceMappingURL=check-event.d.ts.map

package/dist/telemetry/check-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-event.d.ts","sourceRoot":"","sources":["../../src/telemetry/check-event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAe,MAAM,yBAAyB,CAAC;AAQ5G;;;uFAGuF;AACvF,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,UAAkB,GAAG,UAAU,CAiBpG"}

package/dist/telemetry/check-event.js

@@ -0,0 +1,29 @@
+function countAdvisoriesByKind(advisories) {
+    const counts = new Map();
+    for (const a of advisories)
+        counts.set(a.kind, (counts.get(a.kind) ?? 0) + 1);
+    return [...counts.entries()].map(([kind, count]) => ({ kind, count }));
+}
+/** Maps a `CheckRun` (the same value `align check` already prints/emits as `--json`) to the
+ * `check` telemetry event — real latency DISTRIBUTION across many invocations, not one cold
+ * number (IMPLEMENTATION_PLAN.md's telemetry spec). `scope` is always `'all'` in v1 (ADR 005:
+ * `align check` only ever does a full fresh scan) — see `CheckScope`'s doc comment. */
+export function buildCheckEvent(run, wallMs, scope = 'all') {
+    const gates = run.gates.map((g) => ({
+        gate: g.gate,
+        status: g.status,
+        newCount: g.violations.length,
+        baselinedCount: g.baselinedCount,
+        passCount: g.passCount ?? 0,
+    }));
+    return {
+        kind: 'check',
+        verdict: run.verdict,
+        gates,
+        wallMs,
+        scope,
+        ungroundedComponentCount: run.ungroundedComponents.length,
+        advisoryCounts: countAdvisoriesByKind(run.advisories),
+    };
+}
+//# sourceMappingURL=check-event.js.map

package/dist/telemetry/check-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-event.js","sourceRoot":"","sources":["../../src/telemetry/check-event.ts"],"names":[],"mappings":"AAEA,SAAS,qBAAqB,CAAC,UAAkC;IAC/D,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,UAAU;QAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9E,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;uFAGuF;AACvF,MAAM,UAAU,eAAe,CAAC,GAAa,EAAE,MAAc,EAAE,QAAoB,KAAK;IACtF,MAAM,KAAK,GAAkB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACjD,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,QAAQ,EAAE,CAAC,CAAC,UAAU,CAAC,MAAM;QAC7B,cAAc,EAAE,CAAC,CAAC,cAAc;QAChC,SAAS,EAAE,CAAC,CAAC,SAAS,IAAI,CAAC;KAC5B,CAAC,CAAC,CAAC;IACJ,OAAO;QACL,IAAI,EAAE,OAAO;QACb,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,KAAK;QACL,MAAM;QACN,KAAK;QACL,wBAAwB,EAAE,GAAG,CAAC,oBAAoB,CAAC,MAAM;QACzD,cAAc,EAAE,qBAAqB,CAAC,GAAG,CAAC,UAAU,CAAC;KACtD,CAAC;AACJ,CAAC"}

package/dist/telemetry/index.d.ts

@@ -0,0 +1,8 @@
+export * from './resolve.js';
+export * from './session.js';
+export * from './process-context.js';
+export * from './recorder.js';
+export * from './ruleset-hash.js';
+export * from './violations.js';
+export * from './check-event.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/telemetry/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC"}

package/dist/telemetry/index.js

@@ -0,0 +1,8 @@
+export * from './resolve.js';
+export * from './session.js';
+export * from './process-context.js';
+export * from './recorder.js';
+export * from './ruleset-hash.js';
+export * from './violations.js';
+export * from './check-event.js';
+//# sourceMappingURL=index.js.map

package/dist/telemetry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/telemetry/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC"}

package/dist/telemetry/process-context.d.ts

@@ -0,0 +1,9 @@
+/** Single source of truth for the CLI's own version — `program.ts`'s `.version(...)` call imports
+ * this too, so there is exactly one place to bump on a release, not two literals that can drift. */
+export declare const ALIGN_VERSION = "0.1.0";
+/** Computed once, at module load — ESM caches a module instance per process, so every command
+ * within one `align` invocation that imports this sees the identical id (IMPLEMENTATION_PLAN.md:
+ * "sessionId injected, CLI generates one per process"). Never regenerated mid-process, never read
+ * from anywhere network-facing (`node:crypto`'s local `randomUUID`, `session.ts`). */
+export declare const TELEMETRY_SESSION_ID: string;
+//# sourceMappingURL=process-context.d.ts.map

package/dist/telemetry/process-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-context.d.ts","sourceRoot":"","sources":["../../src/telemetry/process-context.ts"],"names":[],"mappings":"AAEA;oGACoG;AACpG,eAAO,MAAM,aAAa,UAAU,CAAC;AAErC;;;sFAGsF;AACtF,eAAO,MAAM,oBAAoB,QAAsB,CAAC"}

package/dist/telemetry/process-context.js

@@ -0,0 +1,10 @@
+import { generateSessionId } from './session.js';
+/** Single source of truth for the CLI's own version — `program.ts`'s `.version(...)` call imports
+ * this too, so there is exactly one place to bump on a release, not two literals that can drift. */
+export const ALIGN_VERSION = '0.1.0';
+/** Computed once, at module load — ESM caches a module instance per process, so every command
+ * within one `align` invocation that imports this sees the identical id (IMPLEMENTATION_PLAN.md:
+ * "sessionId injected, CLI generates one per process"). Never regenerated mid-process, never read
+ * from anywhere network-facing (`node:crypto`'s local `randomUUID`, `session.ts`). */
+export const TELEMETRY_SESSION_ID = generateSessionId();
+//# sourceMappingURL=process-context.js.map

package/dist/telemetry/process-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-context.js","sourceRoot":"","sources":["../../src/telemetry/process-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD;oGACoG;AACpG,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAC;AAErC;;;sFAGsF;AACtF,MAAM,CAAC,MAAM,oBAAoB,GAAG,iBAAiB,EAAE,CAAC"}

package/dist/telemetry/recorder.d.ts

@@ -0,0 +1,43 @@
+import { type TelemetryEvent } from '@spikedpunch/align-core';
+export interface TelemetryRecorderOptions {
+    readonly rootDir: string;
+    readonly enabled: boolean;
+    readonly sessionId: string;
+    readonly alignVersion: string;
+    readonly command: string;
+    /** Injected, never `Date.now()` called ad hoc — every envelope from one recorder shares the
+     * same clock function (real deployments: `Date.now`; tests: a fixed/stepped fake). */
+    readonly now: () => number;
+    /** Test/override hook — mirrors `align check --ir <path>`'s override pattern. Defaults to
+     * `.align/telemetry.jsonl` (`align-dir.ts`). */
+    readonly jsonlPathOverride?: string;
+}
+/**
+ * The ONE wrapper that builds the envelope and writes it (IMPLEMENTATION_PLAN.md's telemetry spec:
+ * "prefer ONE wrapper... over scattering emit calls"). Every command that emits telemetry
+ * constructs exactly one of these (via `program.ts`'s `buildTelemetryRecorder`) and calls
+ * `.record()` with its own domain event — no command touches `appendTelemetryLine` or builds an
+ * envelope itself.
+ */
+export declare class TelemetryRecorder {
+    private readonly options;
+    constructor(options: TelemetryRecorderOptions);
+    get enabled(): boolean;
+    record(event: TelemetryEvent, opts?: {
+        readonly rulesetIrHash?: string;
+    }): void;
+}
+/** OFF-by-default (IMPLEMENTATION_PLAN.md): a recorder constructed with `enabled: false` never
+ * calls `appendTelemetryLine` — `.record()` is a no-op, so `.align/telemetry.jsonl` is never even
+ * created, let alone written to. */
+export declare function createDisabledTelemetryRecorder(rootDir: string, command: string): TelemetryRecorder;
+/**
+ * The composition-root factory every command calls (`program.ts` is the "central wiring point" —
+ * it resolves the pre-config half of the precedence via CLI flags/`ALIGN_TELEMETRY`, then each
+ * command finishes the resolution once it has loaded `align.config.ts`'s own `telemetry` export
+ * and calls this). `sessionId`/`alignVersion` always come from the shared process-wide constants
+ * (`process-context.ts`) — never re-derived per call — so every event in one `align` invocation,
+ * across however many commands ran, shares the same session id.
+ */
+export declare function createTelemetryRecorder(rootDir: string, command: string, preConfig: boolean | undefined, configTelemetry: boolean | undefined, jsonlPathOverride?: string): TelemetryRecorder;
+//# sourceMappingURL=recorder.d.ts.map

package/dist/telemetry/recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../src/telemetry/recorder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqD,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAKjH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;0FACsF;IACtF,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B;oDACgD;IAChD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,wBAAwB;IAE9D,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,MAAM,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,GAAE;QAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,IAAI;CAapF;AAED;;oCAEoC;AACpC,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAEnG;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,OAAO,GAAG,SAAS,EAC9B,eAAe,EAAE,OAAO,GAAG,SAAS,EACpC,iBAAiB,CAAC,EAAE,MAAM,GACzB,iBAAiB,CAWnB"}