@mmnto/totem 1.22.0 → 1.24.0

package/dist/pack-discovery.test.js

@@ -93,18 +93,18 @@ describe('loadInstalledPacks: malformed manifest', () => {
                 version: 1,
                 packs: [
                     {
-                        name: '@totem/pack-rust',
+                        name: '@mmnto/pack-rust',
                         resolvedPath: path.resolve('/abs/a'),
                         declaredEngineRange: '^1.19.0',
                     },
                     {
-                        name: '@totem/pack-rust',
+                        name: '@mmnto/pack-rust',
                         resolvedPath: path.resolve('/abs/b'),
                         declaredEngineRange: '^1.19.0',
                     },
                 ],
             }));
-            expect(() => loadInstalledPacks({ projectRoot: tmpRoot, totemDir: '.totem' })).toThrowError(/duplicate pack entry '@totem\/pack-rust'/);
+            expect(() => loadInstalledPacks({ projectRoot: tmpRoot, totemDir: '.totem' })).toThrowError(/duplicate pack entry '@mmnto\/pack-rust'/);
         }
         finally {
             fs.rmSync(tmpRoot, { recursive: true, force: true });
@@ -119,8 +119,8 @@ describe('loadInstalledPacks: malformed manifest', () => {
                 version: 1,
                 packs: [
                     {
-                        name: '@totem/pack-relative',
-                        resolvedPath: 'node_modules/@totem/pack-relative',
+                        name: '@mmnto/pack-relative',
+                        resolvedPath: 'node_modules/@mmnto/pack-relative',
                         declaredEngineRange: '^1.19.0',
                     },
                 ],
@@ -136,19 +136,19 @@ describe('loadInstalledPacks: peerDependencies engine version mismatch', () => {
     it('throws structured error naming pack name + declared range + actual engine version', () => {
         const fakeCallback = () => { };
         const fakePack = {
-            name: '@totem/pack-fake',
+            name: '@mmnto/pack-fake',
             resolvedPath: '/fake/path',
             declaredEngineRange: '^2.0.0',
         };
         expect(() => loadInstalledPacks({
             engineVersion: '1.21.0',
             inMemoryPacks: [{ pack: fakePack, callback: fakeCallback }],
-        })).toThrowError(/Pack '@totem\/pack-fake' requires @mmnto\/totem '\^2\.0\.0'.*running engine is 1\.21\.0/);
+        })).toThrowError(/Pack '@mmnto\/pack-fake' requires @mmnto\/totem '\^2\.0\.0'.*running engine is 1\.21\.0/);
     });
     it('passes when engine version satisfies declared range', () => {
         const fakeCallback = () => { };
         const fakePack = {
-            name: '@totem/pack-fake',
+            name: '@mmnto/pack-fake',
             resolvedPath: '/fake/path',
             declaredEngineRange: '^1.19.0',
         };
@@ -157,12 +157,12 @@ describe('loadInstalledPacks: peerDependencies engine version mismatch', () => {
             inMemoryPacks: [{ pack: fakePack, callback: fakeCallback }],
         });
         expect(packs).toHaveLength(1);
-        expect(packs[0]?.name).toBe('@totem/pack-fake');
+        expect(packs[0]?.name).toBe('@mmnto/pack-fake');
     });
     it('throws when declared range is invalid semver', () => {
         const fakeCallback = () => { };
         const fakePack = {
-            name: '@totem/pack-fake',
+            name: '@mmnto/pack-fake',
             resolvedPath: '/fake/path',
             declaredEngineRange: 'not-a-semver-range',
         };
@@ -185,7 +185,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
             api.registerLanguage('.rs', 'rust', () => '/fake/tree-sitter-rust.wasm');
         };
         const fakePack = {
-            name: '@totem/pack-rust-architecture',
+            name: '@mmnto/pack-rust-architecture',
             resolvedPath: '/fake/path',
             declaredEngineRange: '^1.19.0',
         };
@@ -203,7 +203,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
             api.registerChunkStrategy('rust-ast', FakeChunker);
         };
         const fakePack = {
-            name: '@totem/pack-rust-architecture',
+            name: '@mmnto/pack-rust-architecture',
             resolvedPath: '/fake/path',
             declaredEngineRange: '^1.19.0',
         };
@@ -218,7 +218,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
             api.registerChunkStrategy('async-strat', FakeChunker);
         });
         const fakePack = {
-            name: '@totem/pack-async',
+            name: '@mmnto/pack-async',
             resolvedPath: '/fake/path',
             declaredEngineRange: '^1.19.0',
         };
@@ -242,7 +242,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
             throw new Error('pack-side bug');
         };
         const fakePack = {
-            name: '@totem/pack-broken',
+            name: '@mmnto/pack-broken',
             resolvedPath: '/fake/path',
             declaredEngineRange: '^1.19.0',
         };
@@ -258,7 +258,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
         }
         expect(caught).toBeInstanceOf(Error);
         const outer = caught;
-        expect(outer.message).toMatch(/Pack '@totem\/pack-broken' registration callback threw/);
+        expect(outer.message).toMatch(/Pack '@mmnto\/pack-broken' registration callback threw/);
         expect(outer.message).toMatch(/must be fixed or removed/);
         expect(outer.cause).toBeInstanceOf(Error);
         expect(outer.cause.message).toBe('pack-side bug');
@@ -277,7 +277,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
                 inMemoryPacks: [
                     {
                         pack: {
-                            name: '@totem/pack-a',
+                            name: '@mmnto/pack-a',
                             resolvedPath: '/a',
                             declaredEngineRange: '^1.19.0',
                         },
@@ -285,7 +285,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
                     },
                     {
                         pack: {
-                            name: '@totem/pack-b',
+                            name: '@mmnto/pack-b',
                             resolvedPath: '/b',
                             declaredEngineRange: '^1.19.0',
                         },
@@ -298,7 +298,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
             caught = err;
         }
         expect(caught).toBeInstanceOf(Error);
-        expect(caught.message).toMatch(/Pack '@totem\/pack-b' registration callback threw/);
+        expect(caught.message).toMatch(/Pack '@mmnto\/pack-b' registration callback threw/);
         expect(caught.cause.message).toMatch(/already registered/);
     });
     it('two packs registering same extension to different langs: second fails loud', () => {
@@ -315,7 +315,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
                 inMemoryPacks: [
                     {
                         pack: {
-                            name: '@totem/pack-a',
+                            name: '@mmnto/pack-a',
                             resolvedPath: '/a',
                             declaredEngineRange: '^1.19.0',
                         },
@@ -323,7 +323,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
                     },
                     {
                         pack: {
-                            name: '@totem/pack-b',
+                            name: '@mmnto/pack-b',
                             resolvedPath: '/b',
                             declaredEngineRange: '^1.19.0',
                         },
@@ -336,7 +336,7 @@ describe('loadInstalledPacks: pack callback registration', () => {
             caught = err;
         }
         expect(caught).toBeInstanceOf(Error);
-        expect(caught.message).toMatch(/Pack '@totem\/pack-b' registration callback threw/);
+        expect(caught.message).toMatch(/Pack '@mmnto\/pack-b' registration callback threw/);
         expect(caught.cause.message).toMatch(/already registered to language/);
     });
 });

package/dist/pack-manifest-writer.d.ts

@@ -2,7 +2,7 @@
  * `installed-packs.json` writer (mmnto-ai/totem#1768, Step 4).
  *
  * Walks two source surfaces — the consumer's `package.json` dependencies
- * for `@totem/pack-*` entries, and the consumer's `totem.config.ts`
+ * for `@mmnto/pack-*` entries, and the consumer's `totem.config.ts`
  * `extends` array — deduplicates, resolves each pack's installed path
  * via npm/pnpm semantics, and writes `.totem/installed-packs.json` for
  * `pack-discovery.ts:loadInstalledPacks()` to consume at boot.
@@ -69,7 +69,7 @@ export interface ResolveInstalledPacksInput {
     readonly resolvePackPath?: (name: string, fromDir: string) => string | undefined;
 }
 /**
- * Compute the deduplicated union of `package.json` `@totem/pack-*` deps
+ * Compute the deduplicated union of `package.json` `@mmnto/pack-*` deps
  * and `totem.config.ts` `extends` entries. Returns the manifest payload
  * shape ready for `installed-packs.json` plus per-pack warnings for any
  * surface mismatch.

package/dist/pack-manifest-writer.js

@@ -2,7 +2,7 @@
  * `installed-packs.json` writer (mmnto-ai/totem#1768, Step 4).
  *
  * Walks two source surfaces — the consumer's `package.json` dependencies
- * for `@totem/pack-*` entries, and the consumer's `totem.config.ts`
+ * for `@mmnto/pack-*` entries, and the consumer's `totem.config.ts`
  * `extends` array — deduplicates, resolves each pack's installed path
  * via npm/pnpm semantics, and writes `.totem/installed-packs.json` for
  * `pack-discovery.ts:loadInstalledPacks()` to consume at boot.
@@ -28,9 +28,9 @@ import * as fs from 'node:fs';
 import { createRequire } from 'node:module';
 import * as path from 'node:path';
 // ─── Resolver ───────────────────────────────────────
-const PACK_NAME_PREFIX = '@totem/pack-';
+const PACK_NAME_PREFIX = '@mmnto/pack-';
 /**
- * Compute the deduplicated union of `package.json` `@totem/pack-*` deps
+ * Compute the deduplicated union of `package.json` `@mmnto/pack-*` deps
  * and `totem.config.ts` `extends` entries. Returns the manifest payload
  * shape ready for `installed-packs.json` plus per-pack warnings for any
  * surface mismatch.

package/dist/pack-manifest-writer.test.js

@@ -74,52 +74,52 @@ function makeConfig(extendsList) {
 describe('resolveInstalledPacks: union of deps + extends', () => {
     it('resolves a pack present in both deps and extends with no warning', () => {
         const root = makeTmpRoot();
-        writeFixturePack(root, '@totem/pack-fake', '^1.19.0');
+        writeFixturePack(root, '@mmnto/pack-fake', '^1.19.0');
         const result = resolveInstalledPacks({
             projectRoot: root,
-            config: makeConfig(['@totem/pack-fake']),
-            packageJsonDeps: { '@totem/pack-fake': '0.1.0' },
+            config: makeConfig(['@mmnto/pack-fake']),
+            packageJsonDeps: { '@mmnto/pack-fake': '0.1.0' },
         });
         expect(result.warnings).toEqual([]);
         expect(result.resolved).toHaveLength(1);
-        expect(result.resolved[0]?.name).toBe('@totem/pack-fake');
+        expect(result.resolved[0]?.name).toBe('@mmnto/pack-fake');
         expect(result.resolved[0]?.declaredEngineRange).toBe('^1.19.0');
     });
     it('emits dep-only warning when pack is in deps but not extends', () => {
         const root = makeTmpRoot();
-        writeFixturePack(root, '@totem/pack-orphan-dep', '^1.19.0');
+        writeFixturePack(root, '@mmnto/pack-orphan-dep', '^1.19.0');
         const result = resolveInstalledPacks({
             projectRoot: root,
             config: makeConfig([]),
-            packageJsonDeps: { '@totem/pack-orphan-dep': '0.1.0' },
+            packageJsonDeps: { '@mmnto/pack-orphan-dep': '0.1.0' },
         });
-        expect(result.warnings).toEqual([{ name: '@totem/pack-orphan-dep', reason: 'dep-only' }]);
+        expect(result.warnings).toEqual([{ name: '@mmnto/pack-orphan-dep', reason: 'dep-only' }]);
         expect(result.resolved).toEqual([]);
     });
     it('emits extends-only warning when pack is in extends but not deps', () => {
         const root = makeTmpRoot();
         const result = resolveInstalledPacks({
             projectRoot: root,
-            config: makeConfig(['@totem/pack-orphan-extends']),
+            config: makeConfig(['@mmnto/pack-orphan-extends']),
             packageJsonDeps: {},
         });
         expect(result.warnings).toEqual([
-            { name: '@totem/pack-orphan-extends', reason: 'extends-only' },
+            { name: '@mmnto/pack-orphan-extends', reason: 'extends-only' },
         ]);
         expect(result.resolved).toEqual([]);
     });
     it('emits not-a-pack warning when pack lacks peerDependencies[@mmnto/totem]', () => {
         const root = makeTmpRoot();
-        writeFixturePack(root, '@totem/pack-broken', undefined);
+        writeFixturePack(root, '@mmnto/pack-broken', undefined);
         const result = resolveInstalledPacks({
             projectRoot: root,
-            config: makeConfig(['@totem/pack-broken']),
-            packageJsonDeps: { '@totem/pack-broken': '0.1.0' },
+            config: makeConfig(['@mmnto/pack-broken']),
+            packageJsonDeps: { '@mmnto/pack-broken': '0.1.0' },
         });
-        expect(result.warnings).toEqual([{ name: '@totem/pack-broken', reason: 'not-a-pack' }]);
+        expect(result.warnings).toEqual([{ name: '@mmnto/pack-broken', reason: 'not-a-pack' }]);
         expect(result.resolved).toEqual([]);
     });
-    it('ignores non-pack dependencies (no @totem/pack- prefix)', () => {
+    it('ignores non-pack dependencies (no @mmnto/pack- prefix)', () => {
         const root = makeTmpRoot();
         const result = resolveInstalledPacks({
             projectRoot: root,
@@ -131,17 +131,17 @@ describe('resolveInstalledPacks: union of deps + extends', () => {
     });
     it('returns sorted output (alphabetical by pack name)', () => {
         const root = makeTmpRoot();
-        writeFixturePack(root, '@totem/pack-zulu', '^1.19.0');
-        writeFixturePack(root, '@totem/pack-alpha', '^1.19.0');
+        writeFixturePack(root, '@mmnto/pack-zulu', '^1.19.0');
+        writeFixturePack(root, '@mmnto/pack-alpha', '^1.19.0');
         const result = resolveInstalledPacks({
             projectRoot: root,
-            config: makeConfig(['@totem/pack-zulu', '@totem/pack-alpha']),
+            config: makeConfig(['@mmnto/pack-zulu', '@mmnto/pack-alpha']),
             packageJsonDeps: {
-                '@totem/pack-zulu': '0.1.0',
-                '@totem/pack-alpha': '0.1.0',
+                '@mmnto/pack-zulu': '0.1.0',
+                '@mmnto/pack-alpha': '0.1.0',
             },
         });
-        expect(result.resolved.map((p) => p.name)).toEqual(['@totem/pack-alpha', '@totem/pack-zulu']);
+        expect(result.resolved.map((p) => p.name)).toEqual(['@mmnto/pack-alpha', '@mmnto/pack-zulu']);
     });
 });
 describe('writeInstalledPacksManifest', () => {
@@ -152,7 +152,7 @@ describe('writeInstalledPacksManifest', () => {
             version: 1,
             packs: [
                 {
-                    name: '@totem/pack-fake',
+                    name: '@mmnto/pack-fake',
                     resolvedPath: '/fake/path',
                     declaredEngineRange: '^1.19.0',
                 },
@@ -164,7 +164,7 @@ describe('writeInstalledPacksManifest', () => {
         const parsed = JSON.parse(raw);
         const validation = InstalledPacksManifestSchema.safeParse(parsed);
         expect(validation.success).toBe(true);
-        expect(validation.success && validation.data.packs[0]?.name).toBe('@totem/pack-fake');
+        expect(validation.success && validation.data.packs[0]?.name).toBe('@mmnto/pack-fake');
     });
     it('creates the totemDir if it does not exist', () => {
         const root = makeTmpRoot();

package/dist/pack-merge.d.ts

@@ -8,7 +8,7 @@
  *
  * ADR-089 carves out a narrow exception: rules shipped by a pack with
  * `immutable: true` AND `severity: 'error'` cannot be locally downgraded
- * or archived. Security packs like `@totem/pack-agent-security` rely on
+ * or archived. Security packs like `@mmnto/pack-agent-security` rely on
  * this contract to guarantee that enforcement cannot be silently weakened
  * by a motivated local override.
  *

package/dist/pack-merge.js

@@ -8,7 +8,7 @@
  *
  * ADR-089 carves out a narrow exception: rules shipped by a pack with
  * `immutable: true` AND `severity: 'error'` cannot be locally downgraded
- * or archived. Security packs like `@totem/pack-agent-security` rely on
+ * or archived. Security packs like `@mmnto/pack-agent-security` rely on
  * this contract to guarantee that enforcement cannot be silently weakened
  * by a motivated local override.
  *

package/dist/rule-engine.js

@@ -337,7 +337,7 @@ export async function applyAstRulesToAdditions(ctx, rules, additions, workingDir
                 // intentionally NOT in the message argument here — duplicating it
                 // would produce `[Totem Error] [Totem Error] AST rule ...` at
                 // runtime. See `errors.ts` for the prefix contract.
-                throw new TotemParseError(`AST rule '${ruleExpectingThisFile.lessonHash}' (${ruleExpectingThisFile.lessonHeading}) is scoped to '${file}' (extension '${ext}') but no Tree-sitter language is registered for that extension`, `Install the pack that provides '${ext}' support (e.g., \`@totem/pack-rust-architecture\` for '.rs'), or correct the rule's fileGlobs to exclude this extension.`);
+                throw new TotemParseError(`AST rule '${ruleExpectingThisFile.lessonHash}' (${ruleExpectingThisFile.lessonHeading}) is scoped to '${file}' (extension '${ext}') but no Tree-sitter language is registered for that extension`, `Install the pack that provides '${ext}' support (e.g., \`@mmnto/pack-rust-architecture\` for '.rs'), or correct the rule's fileGlobs to exclude this extension.`);
             }
             continue;
         }

package/dist/verification-outcomes.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+/**
+ * Stage 4 outcome literals serialized into `.totem/verification-outcomes.json`
+ * (mmnto-ai/totem#1684, ADR-091 § Bootstrap CI-first). Mirrors the
+ * `Stage4Outcome` type from `stage4-verifier.ts` exactly so the storage
+ * vocabulary matches the runtime type and we avoid a translation layer that
+ * would drift on Stage 4 evolution.
+ *
+ * The `_OutcomeAlignment` type below enforces the mirror at compile time —
+ * if either side adds, drops, or renames a literal, the assertion below
+ * fails the build before drift can land in the corpus.
+ */
+export declare const Stage4OutcomeStored: z.ZodEnum<["no-matches", "out-of-scope", "in-scope-bad-example", "candidate-debt"]>;
+/**
+ * One verification record per pack-installed rule (keyed by `lessonHash` in
+ * the file-level record). Persisted across lint runs so subsequent passes
+ * skip re-verification when the rule's content hash matches a recorded
+ * outcome.
+ */
+export declare const VerificationOutcomeEntrySchema: z.ZodObject<{
+    /**
+     * `lessonHash` of the rule the outcome was recorded against. Persisted
+     * inside the entry as well as serving as the file-level record key so a
+     * tampered key (key/value mismatch) can be detected on read.
+     */
+    ruleHash: z.ZodString;
+    /** ISO-8601 timestamp of when the verifier produced the outcome. */
+    verifiedAt: z.ZodString;
+    /** The terminal Stage 4 outcome that was recorded. */
+    outcome: z.ZodEnum<["no-matches", "out-of-scope", "in-scope-bad-example", "candidate-debt"]>;
+    /** Repo-relative paths of baseline-scoped files where the rule fired. */
+    baselineMatches: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Repo-relative paths of in-scope files where the rule fired. */
+    inScopeMatches: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * In-scope match lines that did not match the `badExample` shape — the
+     * Candidate Debt evidence carried forward to the `totem doctor` UX
+     * surface in mmnto-ai/totem#1685. Empty unless `outcome === 'candidate-debt'`.
+     */
+    candidateDebtLines: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ruleHash: string;
+    outcome: "out-of-scope" | "no-matches" | "in-scope-bad-example" | "candidate-debt";
+    baselineMatches: string[];
+    inScopeMatches: string[];
+    candidateDebtLines: string[];
+    verifiedAt: string;
+}, {
+    ruleHash: string;
+    outcome: "out-of-scope" | "no-matches" | "in-scope-bad-example" | "candidate-debt";
+    verifiedAt: string;
+    baselineMatches?: string[] | undefined;
+    inScopeMatches?: string[] | undefined;
+    candidateDebtLines?: string[] | undefined;
+}>;
+/**
+ * The on-disk shape of `.totem/verification-outcomes.json`. Wraps the
+ * per-rule record in a versioned envelope so structural changes can break
+ * the file forward without silent migration: a loader that sees an unknown
+ * `version` treats the file as empty and re-verifies, instead of risking a
+ * partial parse against a newer schema.
+ */
+export declare const VerificationOutcomesFileSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    outcomes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        /**
+         * `lessonHash` of the rule the outcome was recorded against. Persisted
+         * inside the entry as well as serving as the file-level record key so a
+         * tampered key (key/value mismatch) can be detected on read.
+         */
+        ruleHash: z.ZodString;
+        /** ISO-8601 timestamp of when the verifier produced the outcome. */
+        verifiedAt: z.ZodString;
+        /** The terminal Stage 4 outcome that was recorded. */
+        outcome: z.ZodEnum<["no-matches", "out-of-scope", "in-scope-bad-example", "candidate-debt"]>;
+        /** Repo-relative paths of baseline-scoped files where the rule fired. */
+        baselineMatches: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Repo-relative paths of in-scope files where the rule fired. */
+        inScopeMatches: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * In-scope match lines that did not match the `badExample` shape — the
+         * Candidate Debt evidence carried forward to the `totem doctor` UX
+         * surface in mmnto-ai/totem#1685. Empty unless `outcome === 'candidate-debt'`.
+         */
+        candidateDebtLines: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        ruleHash: string;
+        outcome: "out-of-scope" | "no-matches" | "in-scope-bad-example" | "candidate-debt";
+        baselineMatches: string[];
+        inScopeMatches: string[];
+        candidateDebtLines: string[];
+        verifiedAt: string;
+    }, {
+        ruleHash: string;
+        outcome: "out-of-scope" | "no-matches" | "in-scope-bad-example" | "candidate-debt";
+        verifiedAt: string;
+        baselineMatches?: string[] | undefined;
+        inScopeMatches?: string[] | undefined;
+        candidateDebtLines?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    outcomes: Record<string, {
+        ruleHash: string;
+        outcome: "out-of-scope" | "no-matches" | "in-scope-bad-example" | "candidate-debt";
+        baselineMatches: string[];
+        inScopeMatches: string[];
+        candidateDebtLines: string[];
+        verifiedAt: string;
+    }>;
+}, {
+    outcomes: Record<string, {
+        ruleHash: string;
+        outcome: "out-of-scope" | "no-matches" | "in-scope-bad-example" | "candidate-debt";
+        verifiedAt: string;
+        baselineMatches?: string[] | undefined;
+        inScopeMatches?: string[] | undefined;
+        candidateDebtLines?: string[] | undefined;
+    }>;
+    version?: 1 | undefined;
+}>;
+export type Stage4OutcomeStoredValue = z.infer<typeof Stage4OutcomeStored>;
+export type VerificationOutcomeEntry = z.infer<typeof VerificationOutcomeEntrySchema>;
+export type VerificationOutcomesFile = z.infer<typeof VerificationOutcomesFileSchema>;
+/**
+ * Convenience alias for the in-memory mapping of `lessonHash` to its recorded
+ * verification outcome. The file-level wrapper holds the same record under
+ * `outcomes`; this alias exists so call sites that operate on the mapping
+ * directly (the first-lint promotion interceptor in particular) can carry
+ * a focused type without re-derivation. Reserved by mmnto-ai/totem#1684 §
+ * "Vocabulary alignment" — `VerificationOutcomesStore` is the canonical name
+ * for the in-memory mapping.
+ */
+export type VerificationOutcomesStore = VerificationOutcomesFile['outcomes'];
+/**
+ * Load the per-rule verification outcomes from a `verification-outcomes.json`
+ * file. Returns an empty store when the file is missing, contains malformed
+ * JSON, or fails schema validation — the corpus self-heals on the next
+ * write. The interceptor that wrote the corrupt file (or a future pass with
+ * a refreshed schema) will overwrite it on the next promotion run, so the
+ * cache state cannot wedge.
+ *
+ * Invariant: schema-version mismatch is treated as "no outcomes recorded"
+ * rather than attempted migration. A v2 file read by a v1 loader returns
+ * an empty store and warns; the next write produces a valid v1 file.
+ */
+export declare function readVerificationOutcomes(filePath: string, onWarn?: (msg: string) => void): VerificationOutcomesStore;
+/**
+ * Persist the per-rule verification outcomes to disk via temp-file +
+ * atomic rename, so a concurrent CI lint pass that interrupts mid-write
+ * leaves the prior valid file intact rather than producing a truncated
+ * partial-write that the next loader would reject.
+ *
+ * Output is canonicalized (recursive object-key sort) before serialization
+ * so two lint passes that produce the same outcomes write byte-identical
+ * files — Invariant #11 in the design doc, which keeps consumer repos
+ * from seeing phantom diffs on every CI run.
+ */
+export declare function writeVerificationOutcomes(filePath: string, outcomes: VerificationOutcomesStore): void;
+//# sourceMappingURL=verification-outcomes.d.ts.map

package/dist/verification-outcomes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-outcomes.d.ts","sourceRoot":"","sources":["../src/verification-outcomes.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,qFAK9B,CAAC;AAYH;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B;IACzC;;;;OAIG;;IAEH,oEAAoE;;IAEpE,sDAAsD;;IAEtD,yEAAyE;;IAEzE,kEAAkE;;IAElE;;;;OAIG;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;;QA7BzC;;;;WAIG;;QAEH,oEAAoE;;QAEpE,sDAAsD;;QAEtD,yEAAyE;;QAEzE,kEAAkE;;QAElE;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcH,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC3E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;;;;;;;GAQG;AACH,MAAM,MAAM,yBAAyB,GAAG,wBAAwB,CAAC,UAAU,CAAC,CAAC;AAI7E;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC7B,yBAAyB,CA8C3B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,yBAAyB,GAClC,IAAI,CAiBN"}