@mmnto/cli 1.123.0 → 2.0.0

package/dist/commands/spec.test.js

@@ -3,10 +3,10 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { GROUNDING_ANCHOR_FREE_TEXT, GROUNDING_ANCHOR_ISSUE, GROUNDING_ANCHOR_MIXED, GROUNDING_ANCHOR_RECORD, GroundingAnchorSchema, hasUnrenderableHookChar, PROMPT_SOURCE_BUILTIN, PROMPT_SOURCE_OVERRIDE, TotemConfigError, } from '@mmnto/totem';
+import { GROUNDING_ANCHOR_FREE_TEXT, GROUNDING_ANCHOR_ISSUE, GROUNDING_ANCHOR_MIXED, GROUNDING_ANCHOR_RECORD, GroundingAnchorSchema, hasUnrenderableHeadingChar, isRelevanceInRange, PROMPT_SOURCE_BUILTIN, PROMPT_SOURCE_OVERRIDE, TotemConfigError, } from '@mmnto/totem';
 import { cleanTmpDir } from '../test-utils.js';
 import { log } from '../ui.js';
-import { assemblePrompt, assertOutDoesNotOverwriteRecord, buildRecordSearchQuery, evaluateGroundingFloor, expandSpecQuery, formatGroundingRefusal, isRecordPathOutsideRoot, loadSpecRecord, MAX_LESSON_CHARS, MAX_LESSONS, resolveDefaultSpecPath, resolveGroundingAnchor, retrieveContext, sanitizeSpecFilename, SPEC_SYSTEM_PROMPT, specCommand, validateOutputOptions, validateSpecInvocation, } from './spec.js';
+import { assemblePrompt, assertOutDoesNotOverwriteRecord, buildRecordSearchQuery, evaluateGroundingFloor, expandSpecQuery, formatGroundingRefusal, isRecordPathOutsideRoot, loadSpecRecord, MAX_LESSON_CHARS, MAX_LESSONS, MAX_SPECS, resolveDefaultSpecPath, resolveGroundingAnchor, retrieveContext, sanitizeSpecFilename, SPEC_SEARCH_POOL, SPEC_SYSTEM_PROMPT, specCommand, validateOutputOptions, validateSpecInvocation, } from './spec.js';
 import { SPEC_REQUIRED_SECTIONS } from './spec-templates.js';
 // ─── Mocks for the executed `specCommand` suite ─────────
 //
@@ -18,6 +18,8 @@ import { SPEC_REQUIRED_SECTIONS } from './spec-templates.js';
 const harness = vi.hoisted(() => ({
     /** Store hits keyed by the `typeFilter` `retrieveContext` asks for. */
     searchResults: {},
+    /** Every `typeFilter` the store was asked for, in call order (mmnto-ai/totem#2735). */
+    searchTypeFilters: [],
     /** Every `runOrchestrator` invocation, in order — empty means no artifact could exist. */
     orchestratorArgs: [],
     /** What the stubbed orchestrator returns as the draft. */
@@ -39,6 +41,7 @@ vi.mock('@mmnto/totem', async () => {
                 harness.connects += 1;
             }
             async search({ typeFilter }) {
+                harness.searchTypeFilters.push(typeFilter);
                 return harness.searchResults[typeFilter] ?? [];
             }
         },
@@ -80,9 +83,11 @@ function makeLesson(overrides = {}) {
     return {
         content: '**Tags:** testing\n\nAlways validate input at boundaries.',
         contextPrefix: 'Totem Lessons > Lesson — Always validate input',
-        filePath: '.totem/lessons.md',
-        absoluteFilePath: '.totem/lessons.md',
-        type: 'spec',
+        // The post-mmnto-ai/totem#431 shape: lessons carry their own content type
+        // and live under `.totem/lessons/`, one file each.
+        filePath: '.totem/lessons/lesson-always-validate-input.md',
+        absoluteFilePath: '.totem/lessons/lesson-always-validate-input.md',
+        type: 'lesson',
         label: 'Totem Lessons > Lesson — Always validate input',
         score: 0.5,
         metadata: {},
@@ -286,19 +291,100 @@ describe('retrieveContext — cross-totem linked stores', () => {
         expect(withEmpty.specs.length).toBe(withUndefined.specs.length);
     });
 });
-describe('retrieveContext partitioning', () => {
-    it('lessons from lessons.md are separated from regular specs', async () => {
-        // Simulate what retrieveContext produces: lessons in lessons array, specs in specs array
+// ─── retrieveContext lesson delivery (mmnto-ai/totem#2735) ──
+/** A store that answers per `typeFilter` and records every request it received. */
+function typedStore(rows) {
+    const typeFilters = [];
+    const requests = [];
+    const store = {
+        search: async (req) => {
+            typeFilters.push(req.typeFilter);
+            requests.push({ typeFilter: req.typeFilter, maxResults: req.maxResults });
+            return rows[req.typeFilter] ?? [];
+        },
+    };
+    return { store, typeFilters, requests };
+}
+describe('retrieveContext — lessons are their own pool', () => {
+    it('delivers a lesson AND a spec when the store holds one of each', async () => {
+        const { store, typeFilters } = typedStore({
+            lesson: [makeLesson({ type: 'lesson', label: 'Lesson A' })],
+            spec: [makeSpec({ label: 'Spec A' })],
+        });
+        const ctx = await retrieveContext('test query', store);
+        // The regression mmnto-ai/totem#431 introduced: lessons were partitioned
+        // out of a `spec`-typed pool, so this length was 0 for every run since.
+        expect(ctx.lessons.length).toBe(1);
+        expect(ctx.lessons[0].label).toBe('Lesson A');
+        expect(ctx.specs.length).toBe(1);
+        expect(ctx.specs[0].label).toBe('Spec A');
+        expect(typeFilters).toContain('lesson');
+    });
+    it('never asks a LINKED store for lessons — lessons come from the primary only', async () => {
+        const primary = typedStore({ lesson: [makeLesson({ type: 'lesson' })], spec: [makeSpec()] });
+        const linked = typedStore({ spec: [makeSpec({ label: 'linked' })] });
+        const ctx = await retrieveContext('test query', primary.store, [linked.store]);
+        expect(ctx.lessons.length).toBe(1);
+        expect(primary.typeFilters).toContain('lesson');
+        expect(linked.typeFilters).not.toContain('lesson');
+        expect(linked.typeFilters).toEqual(['spec']);
+    });
+    // Request identity is the only thing that CAN pin "the specs delivered are
+    // unchanged" against a real store: on the hybrid path the requested width is
+    // the RRF fusion window (`packages/core/src/store/lance-search.ts` fetches
+    // `maxResults * HYBRID_OVERFETCH_FACTOR` per leg), so a narrower request
+    // changes WHICH rows survive fusion, not merely how many are cut.
+    it('asks for the spec pool at exactly SPEC_SEARCH_POOL, unchanged by this slice', async () => {
+        // The literal is the pin: bound to the constant alone, this test would go
+        // green on a change to the constant itself. 20 is the pre-mmnto-ai/totem#2735
+        // width, which is the hybrid fusion window.
+        expect(SPEC_SEARCH_POOL).toBe(20);
+        const { store, requests } = typedStore({ spec: [makeSpec()] });
+        await retrieveContext('test query', store);
+        const specRequests = requests.filter((r) => r.typeFilter === 'spec');
+        expect(specRequests).toEqual([{ typeFilter: 'spec', maxResults: SPEC_SEARCH_POOL }]);
+    });
+    it('asks a LINKED store for specs at the delivery cap, unchanged by this slice', async () => {
+        const primary = typedStore({ spec: [makeSpec()] });
+        const linked = typedStore({ spec: [makeSpec({ label: 'linked' })] });
+        await retrieveContext('test query', primary.store, [linked.store]);
+        expect(linked.requests).toEqual([{ typeFilter: 'spec', maxResults: MAX_SPECS }]);
+    });
+    it('delivers the top-MAX_SPECS specs by score, in score order', async () => {
+        const scores = [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3];
+        expect(scores.length).toBeGreaterThan(MAX_SPECS);
+        const { store } = typedStore({
+            spec: scores.map((score, i) => makeSpec({ label: `Spec ${i}`, score })),
+        });
+        const ctx = await retrieveContext('test query', store);
+        expect(ctx.specs.length).toBe(MAX_SPECS);
+        expect(ctx.specs.map((s) => s.score)).toEqual(scores.slice(0, MAX_SPECS));
+    });
+    it('delivers the top-MAX_SPECS by score ACROSS the primary and a linked store', async () => {
+        const primary = typedStore({
+            spec: [0.9, 0.7, 0.5, 0.3].map((score, i) => makeSpec({ label: `P${i}`, score })),
+        });
+        const linked = typedStore({
+            spec: [0.8, 0.6, 0.4, 0.2].map((score, i) => makeSpec({ label: `L${i}`, score })),
+        });
+        const ctx = await retrieveContext('test query', primary.store, [linked.store]);
+        expect(ctx.specs.length).toBe(MAX_SPECS);
+        expect(ctx.specs.map((s) => s.score)).toEqual([0.9, 0.8, 0.7, 0.6, 0.5]);
+    });
+});
+describe('assemblePrompt — lessons render in their own section', () => {
+    it('a lesson never appears inside the RELATED SPECS & ADRs section', async () => {
         const ctx = {
             specs: [makeSpec({ filePath: 'docs/reference/architecture.md' })],
             sessions: [],
             code: [],
-            lessons: [makeLesson({ filePath: '.totem/lessons.md' })],
+            lessons: [makeLesson({ type: 'lesson', filePath: '.totem/lessons/lesson-abc.md' })],
         };
         const result = await assemblePrompt([{ issue: null, freeText: 'test', record: null }], ctx, 'system prompt');
         // Lessons appear in their own section, not mixed with specs
         const specSection = result.split('RELATED SPECS & ADRs')[1]?.split('===')[0] ?? '';
-        expect(specSection).not.toContain('lessons.md');
+        expect(specSection).not.toContain('.totem/lessons/');
+        expect(result).toContain('=== RELEVANT LESSONS (HARD CONSTRAINTS) ===');
     });
 });
 // ─── expandSpecQuery (#1016) ────────────────────────────
@@ -445,19 +531,26 @@ describe('SPEC_REQUIRED_SECTIONS', () => {
             expect(promptLines, `${section} is not a line of SPEC_SYSTEM_PROMPT`).toContain(section);
         }
     });
-    it('every entry is renderable into the single-quoted node -e reader (the mmnto-ai/totem#2692 C4 predicate)', () => {
+    it('every entry is renderable into the single-quoted node -e reader as a HEADING (mmnto-ai/totem#2737)', () => {
         for (const section of SPEC_REQUIRED_SECTIONS) {
-            // A quote, backslash, dollar, backtick, control character or non-ASCII
-            // byte would break the `sh` single-quoted word, the JS string literal
-            // inside it, or both — and could forge hook lines.
-            expect(hasUnrenderableHookChar(section), `${section} cannot be rendered`).toBe(false);
+            // A quote, backslash, dollar, backtick or control character would break
+            // the `sh` single-quoted word, the JS string literal inside it, or both —
+            // and could forge hook lines. Printable non-ASCII could not: the heading
+            // predicate permits it where the PATH predicate cannot, because git
+            // C-quotes path bytes above 0x7e in the `diff --name-only` output the
+            // hooks' `grep -q` filters read and a heading meets no such filter. The
+            // executed proof that the em dash survives the render is the frozen
+            // falsifier in install-hooks.test.ts, over the four schema-constrained R3
+            // drafts that carry the Verification heading byte-identical.
+            expect(hasUnrenderableHeadingChar(section), `${section} cannot be rendered`).toBe(false);
         }
     });
-    it('names both promised sections, in prompt order', () => {
-        expect([...SPEC_REQUIRED_SECTIONS]).toEqual([
-            '### Problem Statement',
-            '### Implementation Tasks',
-        ]);
+    it('names all nine promised sections, in prompt order', () => {
+        // Copied from SPEC_SYSTEM_PROMPT rather than retyped, so the em dash in the
+        // Verification heading can never enter this file as a look-alike byte
+        // (the mmnto-ai/totem#2692 authoring trap).
+        expect([...SPEC_REQUIRED_SECTIONS]).toEqual(SPEC_SYSTEM_PROMPT.split('\n').filter((line) => line.startsWith('### ')));
+        expect(SPEC_REQUIRED_SECTIONS).toHaveLength(9);
     });
 });
 // ─── resolveGroundingAnchor (mmnto-ai/totem#2700) ────────
@@ -587,73 +680,210 @@ function relevantHit(relevance, overrides = {}) {
     });
 }
 const FLOOR = 0.25;
+/** The floor's PLACE exactly as a refusal renders it (`FLOOR_PLACE` in spec.ts). */
+const FLOOR_PLACE_TEXT = 'searchRelevanceFloor in totem.config.ts';
+/** The whole floor line when NO floor is configured (`FLOOR_LINE_UNSET` in spec.ts, mmnto-ai/totem#2727). */
+const FLOOR_LINE_UNSET_TEXT = 'floor none — searchRelevanceFloor unset in totem.config.ts (no default; calibrate per repo — see config-reference)';
+/**
+ * The refusal's floor LINE, whole. A `toContain` of the value-and-place text
+ * alone is satisfied by a line that appends MORE after it — which is exactly
+ * the retired "(schema default 0.25 when unset)" suffix — so the pins that
+ * guard that suffix's removal compare the entire line, not a prefix of it
+ * (mmnto-ai/totem#2727 fold, F3).
+ */
+function floorLineOf(message) {
+    const line = message.split('\n').find((candidate) => candidate.startsWith('floor '));
+    if (line === undefined)
+        throw new Error(`no floor line in refusal message:\n${message}`);
+    return line;
+}
+/**
+ * Every floor call below injects the SAME predicate production injects
+ * (mmnto-ai/totem#2738 fold 2, F2): core's `isRelevanceInRange`, the one the
+ * grounding bundle builder omits on. The predicate is a PARAMETER in
+ * production because a static value import from `@mmnto/totem` inside
+ * `commands/**` pulls LanceDB into every CLI startup (mmnto-ai/totem#2339);
+ * tests may import it statically — that rule excludes `**\/*.test.ts`.
+ *
+ * The predicate precedes `floor` in the real signature so mmnto-ai/totem#2758
+ * can make `floor` optional without a required-after-optional parameter.
+ */
+function evaluateFloor(context, floor) {
+    return evaluateGroundingFloor(context, isRelevanceInRange, floor);
+}
 describe('evaluateGroundingFloor', () => {
     it('0 retrieved items REFUSES — nothing grounds the run (the charter rule, not an MCP mirror)', () => {
-        const verdict = evaluateGroundingFloor(emptyContext(), FLOOR);
+        const verdict = evaluateFloor(emptyContext(), FLOOR);
         expect(verdict).toEqual({
             refuse: true,
             hits: 0,
             bestRelevance: null,
             withheld: [],
             floorExempt: 0,
+            faulted: 0,
         });
     });
     it('every signal-bearing hit below the floor, none exempt, REFUSES', () => {
-        const verdict = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(0.2), relevantHit(0.11)] }, FLOOR);
+        const verdict = evaluateFloor({ ...emptyContext(), specs: [relevantHit(0.2), relevantHit(0.11)] }, FLOOR);
         expect(verdict.refuse).toBe(true);
         expect(verdict.hits).toBe(2);
         expect(verdict.bestRelevance).toBeCloseTo(0.2, 10);
         expect(verdict.floorExempt).toBe(0);
     });
     it('one hit AT the floor PROCEEDS (the floor is inclusive)', () => {
-        const verdict = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(0.1), relevantHit(FLOOR)] }, FLOOR);
+        const verdict = evaluateFloor({ ...emptyContext(), specs: [relevantHit(0.1), relevantHit(FLOOR)] }, FLOOR);
         expect(verdict.refuse).toBe(false);
         expect(verdict.withheld).toEqual([]);
     });
     it('one floor-EXEMPT hit beside below-floor signal PROCEEDS (a keyword-only hit is never withheld for a weak sibling)', () => {
-        const verdict = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(0.05)], code: [relevantHit(undefined)] }, FLOOR);
+        const verdict = evaluateFloor({ ...emptyContext(), specs: [relevantHit(0.05)], code: [relevantHit(undefined)] }, FLOOR);
         expect(verdict.refuse).toBe(false);
         expect(verdict.floorExempt).toBe(1);
         expect(verdict.withheld).toEqual([]);
     });
+    // Lessons are DELIVERED but never judged by the floor (mmnto-ai/totem#2735).
+    // The gate was ruled over the spec/session/code partitions while the lesson
+    // partition was structurally empty; feeding a now-populated one in would
+    // silently loosen the refusal arm, since an FTS-only lesson is floor-EXEMPT
+    // and `refuse` requires `floorExempt === 0`.
+    it('a run whose ONLY retrieved item is an FTS-only lesson REFUSES as 0 hits', () => {
+        const verdict = evaluateFloor({ ...emptyContext(), lessons: [relevantHit(undefined, { type: 'lesson' })] }, FLOOR);
+        expect(verdict.refuse).toBe(true);
+        expect(verdict.hits).toBe(0);
+        expect(verdict.floorExempt).toBe(0);
+        expect(verdict.bestRelevance).toBeNull();
+    });
+    it('a below-floor spec beside an FTS-only lesson still REFUSES (a lesson is not floor-exempt evidence)', () => {
+        const verdict = evaluateFloor({
+            ...emptyContext(),
+            specs: [relevantHit(0.05, { filePath: 'docs/weak.md' })],
+            lessons: [relevantHit(undefined, { type: 'lesson' })],
+        }, FLOOR);
+        expect(verdict.refuse).toBe(true);
+        expect(verdict.hits).toBe(1);
+        expect(verdict.floorExempt).toBe(0);
+        expect(verdict.withheld).toEqual([{ filePath: 'docs/weak.md', relevance: 0.05 }]);
+    });
+    it('an AT-floor spec beside lessons PROCEEDS, and the lessons are not counted as hits', () => {
+        const verdict = evaluateFloor({
+            ...emptyContext(),
+            specs: [relevantHit(FLOOR)],
+            lessons: [relevantHit(undefined, { type: 'lesson' }), relevantHit(0.9, { type: 'lesson' })],
+        }, FLOOR);
+        // Delivery is not the gate: `retrieveContext` still returns those lessons
+        // (see the lesson-delivery suite) and the executed-command suite proves
+        // they reach the prompt. The floor simply never reads them.
+        expect(verdict.refuse).toBe(false);
+        expect(verdict.hits).toBe(1);
+        expect(verdict.bestRelevance).toBeCloseTo(FLOOR, 10);
+    });
     it('no relevance anywhere PROCEEDS — a pure-FTS corpus is never demoted', () => {
-        const verdict = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(undefined), relevantHit(undefined)] }, FLOOR);
+        const verdict = evaluateFloor({ ...emptyContext(), specs: [relevantHit(undefined), relevantHit(undefined)] }, FLOOR);
         expect(verdict.refuse).toBe(false);
         expect(verdict.bestRelevance).toBeNull();
         expect(verdict.floorExempt).toBe(2);
     });
-    // A non-finite relevance is what the CORE builder drops: the item it writes
-    // carries no relevance at all, exactly an FTS-only hit's shape. The floor
-    // must read it the same way, or the artifact and the judgment disagree.
-    it.each([NaN, Infinity, -Infinity])('a non-finite relevance (%s) is floor-EXEMPT, never counted as signal', (relevance) => {
-        const verdict = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(relevance)] }, FLOOR);
-        expect(verdict.floorExempt).toBe(1);
+    // A relevance the CORE builder drops is one the floor must not read as
+    // signal: the item it writes carries no relevance at all, so counting it as
+    // a measurement would make the judgment and the artifact disagree about the
+    // same hit. The predicate is literally shared — `isRelevanceInRange` from
+    // `@mmnto/totem` (mmnto-ai/totem#2738 fold 2, F2) — which covers non-finite
+    // values AND finite ones outside [0, 1]. The range arm matters: before it, a
+    // relevance of `2` (a negative `_distance` under l2) set `bestRelevance`
+    // above the floor and DEFEATED the refusal, while the artifact write threw
+    // on that same value.
+    //
+    // But a fault is not a keyword-only hit either (the mmnto-ai/totem#2761 bot
+    // round, Greptile P1): counting it EXEMPT let it save a run. It is FAULTED —
+    // neither signal nor exemption — and a run whose every hit is faulted has
+    // nothing usable and refuses.
+    it.each([NaN, Infinity, -Infinity, 2, -1e-16])('a relevance outside [0, 1] (%s) is FAULTED — not signal, not exempt — and alone it REFUSES', (relevance) => {
+        const verdict = evaluateFloor({ ...emptyContext(), specs: [relevantHit(relevance)] }, FLOOR);
+        expect(verdict.faulted).toBe(1);
+        expect(verdict.floorExempt).toBe(0);
         expect(verdict.bestRelevance).toBeNull();
         expect(verdict.withheld).toEqual([]);
-        expect(verdict.refuse).toBe(false);
+        expect(verdict.refuse).toBe(true);
+    });
+    it('a NEGATIVE relevance beside a weak one does NOT save the run — a fault is not evidence (Greptile P1)', () => {
+        // The build's earlier reading counted the fault as exempt, so this context
+        // proceeded into synthesis on the strength of an SDK fault. It refuses: the
+        // weak sibling is the only signal, it is below the floor, and nothing
+        // legitimately exempts it. The fault is disclosed by count, never withheld
+        // as a measurement.
+        const verdict = evaluateFloor({
+            ...emptyContext(),
+            specs: [relevantHit(0.05, { filePath: 'docs/weak.md' }), relevantHit(-0.5)],
+        }, FLOOR);
+        expect(verdict.refuse).toBe(true);
+        expect(verdict.faulted).toBe(1);
+        expect(verdict.floorExempt).toBe(0);
+        expect(verdict.bestRelevance).toBeCloseTo(0.05, 10);
+        expect(verdict.withheld).toEqual([{ filePath: 'docs/weak.md', relevance: 0.05 }]);
     });
-    it('a NaN hit beside a genuinely weak one is not disclosed as a withheld candidate', () => {
-        const verdict = evaluateGroundingFloor({
+    it('a NaN hit beside a genuinely weak one is not disclosed as a withheld candidate, and does not save the run', () => {
+        const verdict = evaluateFloor({
             ...emptyContext(),
             specs: [relevantHit(0.05, { filePath: 'docs/weak.md' }), relevantHit(NaN)],
         }, FLOOR);
-        // One exempt hit is enough to proceed — and nothing is withheld.
-        expect(verdict.floorExempt).toBe(1);
+        expect(verdict.faulted).toBe(1);
+        expect(verdict.floorExempt).toBe(0);
+        expect(verdict.refuse).toBe(true);
+        expect(verdict.withheld).toEqual([{ filePath: 'docs/weak.md', relevance: 0.05 }]);
+    });
+    it('a fault beside a hit AT or above the floor PROCEEDS on the real signal', () => {
+        const verdict = evaluateFloor({ ...emptyContext(), specs: [relevantHit(-0.5), relevantHit(0.6)] }, FLOOR);
         expect(verdict.refuse).toBe(false);
+        expect(verdict.faulted).toBe(1);
+        expect(verdict.bestRelevance).toBeCloseTo(0.6, 10);
         expect(verdict.withheld).toEqual([]);
     });
-    it('counts hits across ALL FOUR partitions', () => {
-        const verdict = evaluateGroundingFloor({
+    it('a fault beside a keyword-only hit PROCEEDS — the exemption is the keyword hit, never the fault', () => {
+        const verdict = evaluateFloor({ ...emptyContext(), specs: [relevantHit(-0.5)], code: [relevantHit(undefined)] }, FLOOR);
+        expect(verdict.refuse).toBe(false);
+        expect(verdict.faulted).toBe(1);
+        expect(verdict.floorExempt).toBe(1);
+        expect(verdict.bestRelevance).toBeNull();
+    });
+    it('the refusal names an all-faulted retrieval and a faulted count beside a weak signal', () => {
+        const allFaulted = evaluateFloor({ ...emptyContext(), specs: [relevantHit(-0.5), relevantHit(2)] }, FLOOR);
+        expect(allFaulted.refuse).toBe(true);
+        const { message: allFaultedText } = formatGroundingRefusal('weak topic', allFaulted, FLOOR, 0);
+        expect(allFaultedText).toContain('Retrieval returned 2 hits, but every one carried a relevance that is not a finite number in [0, 1]');
+        expect(allFaultedText).toContain('nothing usable grounds this run');
+        // The cause is the search layer's to name (metric-specific); the refusal must
+        // not assert an l2 fault the running metric might not have (leg F3).
+        expect(allFaultedText).not.toContain('l2');
+        // The delivered-lessons disclosure the zero-hit arm carries (mmnto-ai/totem#2735).
+        const { message: withLessons } = formatGroundingRefusal('weak topic', allFaulted, FLOOR, 3);
+        expect(withLessons).toContain('3 lessons were retrieved, but lessons do not ground a run (ruled mmnto-ai/totem#2727).');
+        expect(allFaultedText).not.toContain('best relevance');
+        const mixed = evaluateFloor({
+            ...emptyContext(),
+            specs: [relevantHit(0.05, { filePath: 'docs/weak.md' }), relevantHit(-0.5)],
+        }, FLOOR);
+        const { message: mixedText } = formatGroundingRefusal('weak topic', mixed, FLOOR, 0);
+        expect(mixedText).toContain('best relevance 0.050 is below the floor');
+        expect(mixedText).toContain('1 hit carried a relevance that is not a finite number in [0, 1] (tallied out of range by the search layer) and did not count as signal or as exemption.');
+        expect(mixedText).toContain('1. docs/weak.md — relevance 0.050');
+    });
+    // Was "counts hits across ALL FOUR partitions" when the lesson partition was
+    // structurally empty and could not change the count. mmnto-ai/totem#2735
+    // makes it populated, so the gate holds its ruled inputs: the three
+    // partitions it was exercised over. A delivered lesson is counted on the
+    // `Found:` line and in the artifact, never as a grounding hit.
+    it('counts hits across the spec, session and code partitions — never lessons', () => {
+        const verdict = evaluateFloor({
             specs: [relevantHit(0.9)],
             sessions: [relevantHit(0.8)],
             code: [relevantHit(0.7)],
-            lessons: [relevantHit(0.6)],
+            lessons: [relevantHit(0.6, { type: 'lesson' })],
         }, FLOOR);
-        expect(verdict.hits).toBe(4);
+        expect(verdict.hits).toBe(3);
         expect(verdict.bestRelevance).toBeCloseTo(0.9, 10);
     });
     it('the withheld list carries every below-floor candidate as path + relevance (linked hits keep their store)', () => {
-        const verdict = evaluateGroundingFloor({
+        const verdict = evaluateFloor({
             ...emptyContext(),
             specs: [
                 relevantHit(0.2, { filePath: 'docs/a.md' }),
@@ -665,31 +895,173 @@ describe('evaluateGroundingFloor', () => {
             { filePath: 'doctrine/b.md', sourceRepo: 'strategy', relevance: 0.1 },
         ]);
     });
+    // --- No floor configured (mmnto-ai/totem#2727) ---
+    //
+    // `searchRelevanceFloor` lost its default, so `undefined` is the shape a
+    // repo that never set the key hands this function. The below-floor arm has
+    // to be unreachable then — not reachable at some fallback number.
+    it('with NO floor, hits far below any plausible floor still PROCEED and withhold nothing', () => {
+        const verdict = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(0.01), relevantHit(0.02)] }, isRelevanceInRange, undefined);
+        expect(verdict.refuse).toBe(false);
+        expect(verdict.withheld).toEqual([]);
+        // The MEASUREMENT is not conditional on a floor — it is still reported.
+        expect(verdict.hits).toBe(2);
+        expect(verdict.bestRelevance).toBeCloseTo(0.02, 10);
+        expect(verdict.floorExempt).toBe(0);
+    });
+    it('with NO floor, the ZERO-HIT arm still refuses (it is not a floor arm)', () => {
+        expect(evaluateGroundingFloor(emptyContext(), isRelevanceInRange, undefined)).toEqual({
+            refuse: true,
+            hits: 0,
+            bestRelevance: null,
+            withheld: [],
+            floorExempt: 0,
+            faulted: 0,
+        });
+    });
+    it('with NO floor, floorExempt is still counted for FTS-only hits', () => {
+        const verdict = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(undefined), relevantHit(0.01)] }, isRelevanceInRange, undefined);
+        expect(verdict.refuse).toBe(false);
+        expect(verdict.floorExempt).toBe(1);
+        expect(verdict.bestRelevance).toBeCloseTo(0.01, 10);
+    });
+    // The one state the mmnto-ai/totem#2758 rebase created: the all-faulted arm
+    // needs no floor (final leg, F12). A fault beside a real signal proceeds with
+    // no floor to judge; every hit faulted refuses regardless.
+    it('with NO floor, an all-faulted retrieval still REFUSES, and a fault beside real signal proceeds', () => {
+        const allFaulted = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(-0.5), relevantHit(2)] }, isRelevanceInRange, undefined);
+        expect(allFaulted).toEqual({
+            refuse: true,
+            hits: 2,
+            bestRelevance: null,
+            withheld: [],
+            floorExempt: 0,
+            faulted: 2,
+        });
+        const { message } = formatGroundingRefusal('an-unanchored-slug', allFaulted, undefined, 0);
+        expect(message).toBe([
+            'Refusing to draft an unanchored spec for topic(s): an-unanchored-slug.',
+            'Retrieval returned 2 hits, but every one carried a relevance that is not a finite number in [0, 1] (tallied out of range by the search layer) — so nothing usable grounds this run.',
+            FLOOR_LINE_UNSET_TEXT,
+        ].join('\n'));
+        const beside = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(-0.5), relevantHit(0.001)] }, isRelevanceInRange, undefined);
+        expect(beside.refuse).toBe(false);
+        expect(beside.faulted).toBe(1);
+    });
+    it('omitting the floor argument entirely is the same as passing undefined', () => {
+        const context = { ...emptyContext(), specs: [relevantHit(0.01)] };
+        expect(evaluateGroundingFloor(context, isRelevanceInRange)).toEqual(evaluateGroundingFloor(context, isRelevanceInRange, undefined));
+    });
 });
 // ─── formatGroundingRefusal (mmnto-ai/totem#2700) ────────
 describe('formatGroundingRefusal', () => {
     it('a 0-hit refusal names the topic, the 0 hits, and the floor VALUE and PLACE', () => {
-        const verdict = evaluateGroundingFloor(emptyContext(), FLOOR);
-        const { message } = formatGroundingRefusal('an-unanchored-slug', verdict, FLOOR);
+        const verdict = evaluateFloor(emptyContext(), FLOOR);
+        const { message } = formatGroundingRefusal('an-unanchored-slug', verdict, FLOOR, 0);
         expect(message).toContain('an-unanchored-slug');
         expect(message).toContain('0 hits');
-        expect(message).toContain('floor 0.250 — searchRelevanceFloor in totem.config.ts (schema default 0.25 when unset)');
+        // The WHOLE line, not a prefix of it: a `toContain` of the value-and-place
+        // text alone still passes if the retired "(schema default 0.25 when unset)"
+        // suffix is restored after it (mmnto-ai/totem#2727 fold, F3).
+        expect(floorLineOf(message)).toBe('floor 0.250 — searchRelevanceFloor in totem.config.ts');
+    });
+    // With lessons delivered, "nothing in the index grounds this run" sits beside
+    // a `Found: … N lessons` line. The message names the contradiction rather
+    // than leaving the reader to reconcile the two (mmnto-ai/totem#2735).
+    it('a 0-hit refusal on a lesson-holding index names the lessons it did not judge', () => {
+        // The seeded count IS the delivered count — the invariant production holds,
+        // where the caller passes `context.lessons.length`.
+        const lessons = [makeLesson(), makeLesson()];
+        const verdict = evaluateFloor({ ...emptyContext(), lessons }, FLOOR);
+        expect(verdict.hits).toBe(0);
+        const { message } = formatGroundingRefusal('an-unanchored-slug', verdict, FLOOR, lessons.length);
+        expect(message).toBe([
+            'Refusing to draft an unanchored spec for topic(s): an-unanchored-slug.',
+            'Retrieval returned 0 grounding hits (specs, sessions, code) — nothing in the index grounds this run.',
+            '2 lessons were retrieved, but lessons do not ground a run (ruled mmnto-ai/totem#2727).',
+            `floor 0.250 — ${FLOOR_PLACE_TEXT}`,
+        ].join('\n'));
+    });
+    it('a single delivered lesson reads as one, not as "1 lessons"', () => {
+        const verdict = evaluateFloor({ ...emptyContext(), lessons: [makeLesson()] }, FLOOR);
+        const { message } = formatGroundingRefusal('an-unanchored-slug', verdict, FLOOR, 1);
+        expect(message).toContain('1 lesson was retrieved, but lessons do not ground a run (ruled mmnto-ai/totem#2727).');
+    });
+    // Pinned against the LITERAL pre-mmnto-ai/totem#2735 message, not against a
+    // sibling call: the guarantee is that this text did not move, and only an
+    // exact comparison with the old bytes can say so.
+    it('with NO lessons delivered the 0-hit message is the pre-fold text, byte for byte', () => {
+        const verdict = evaluateFloor(emptyContext(), FLOOR);
+        const { message } = formatGroundingRefusal('an-unanchored-slug', verdict, FLOOR, 0);
+        expect(message).toBe([
+            'Refusing to draft an unanchored spec for topic(s): an-unanchored-slug.',
+            'Retrieval returned 0 hits — nothing in the index grounds this run.',
+            `floor 0.250 — ${FLOOR_PLACE_TEXT}`,
+        ].join('\n'));
+    });
+    // --- The floor line's two forms (mmnto-ai/totem#2727) ---
+    //
+    // Byte-pinned in BOTH forms. The unset form must never render a number: a
+    // refusal that reached here with no floor did so on an arm that needs none —
+    // zero hits, or every hit faulted — and printing `floor 0.250` would claim a
+    // judgment no floor made.
+    it('with NO floor the 0-hit refusal names the floor as none, byte for byte', () => {
+        const verdict = evaluateGroundingFloor(emptyContext(), isRelevanceInRange, undefined);
+        const { message } = formatGroundingRefusal('an-unanchored-slug', verdict, undefined, 0);
+        expect(message).toBe([
+            'Refusing to draft an unanchored spec for topic(s): an-unanchored-slug.',
+            'Retrieval returned 0 hits — nothing in the index grounds this run.',
+            FLOOR_LINE_UNSET_TEXT,
+        ].join('\n'));
+        expect(message).not.toContain('0.250');
+    });
+    it('with a floor CONFIGURED the 0-hit refusal names the value and its place, byte for byte', () => {
+        const verdict = evaluateGroundingFloor(emptyContext(), isRelevanceInRange, FLOOR);
+        const { message } = formatGroundingRefusal('an-unanchored-slug', verdict, FLOOR, 0);
+        expect(message).toBe([
+            'Refusing to draft an unanchored spec for topic(s): an-unanchored-slug.',
+            'Retrieval returned 0 hits — nothing in the index grounds this run.',
+            'floor 0.250 — searchRelevanceFloor in totem.config.ts',
+        ].join('\n'));
+    });
+    it('with NO floor the lessons clause still renders, above the none line', () => {
+        const lessons = [makeLesson(), makeLesson()];
+        const verdict = evaluateGroundingFloor({ ...emptyContext(), lessons }, isRelevanceInRange, undefined);
+        const { message } = formatGroundingRefusal('an-unanchored-slug', verdict, undefined, lessons.length);
+        expect(message).toBe([
+            'Refusing to draft an unanchored spec for topic(s): an-unanchored-slug.',
+            'Retrieval returned 0 grounding hits (specs, sessions, code) — nothing in the index grounds this run.',
+            '2 lessons were retrieved, but lessons do not ground a run (ruled mmnto-ai/totem#2727).',
+            FLOOR_LINE_UNSET_TEXT,
+        ].join('\n'));
+    });
+    it('the below-floor message is the pre-fold text whether or not lessons were delivered', () => {
+        const verdict = evaluateFloor({ ...emptyContext(), specs: [relevantHit(0.2, { filePath: 'docs/a.md' })] }, FLOOR);
+        const expected = [
+            'Refusing to draft an unanchored spec for topic(s): weak topic.',
+            'Retrieval returned 1 hits, but best relevance 0.200 is below the floor.',
+            `floor 0.250 — ${FLOOR_PLACE_TEXT}`,
+            'Withheld candidates (path + relevance only, no content):',
+            '1. docs/a.md — relevance 0.200',
+        ].join('\n');
+        expect(formatGroundingRefusal('weak topic', verdict, FLOOR, 10).message).toBe(expected);
+        expect(formatGroundingRefusal('weak topic', verdict, FLOOR, 0).message).toBe(expected);
     });
     it('a below-floor refusal names the best relevance and DISCLOSES every withheld candidate', () => {
-        const verdict = evaluateGroundingFloor({
+        const verdict = evaluateFloor({
             ...emptyContext(),
             specs: [
                 relevantHit(0.2, { filePath: 'docs/a.md' }),
                 relevantHit(0.1, { filePath: 'doctrine/b.md', sourceRepo: 'strategy' }),
             ],
         }, FLOOR);
-        const { message } = formatGroundingRefusal('weak topic', verdict, FLOOR);
+        const { message } = formatGroundingRefusal('weak topic', verdict, FLOOR, 0);
         expect(message).toContain('best relevance 0.200');
         expect(message).toContain('1. docs/a.md — relevance 0.200');
         expect(message).toContain('2. [strategy] doctrine/b.md — relevance 0.100');
     });
     it('the hint names both cures and the --raw inspection path', () => {
-        const { recoveryHint } = formatGroundingRefusal('topic', evaluateGroundingFloor(emptyContext(), FLOOR), FLOOR);
+        const { recoveryHint } = formatGroundingRefusal('topic', evaluateFloor(emptyContext(), FLOOR), FLOOR, 0);
         expect(recoveryHint).toContain('totem spec <issue>');
         expect(recoveryHint).toContain('totem spec --from <record>');
         expect(recoveryHint).toContain('--raw');
@@ -1063,6 +1435,7 @@ describe('specCommand — anchored evidence, executed against stubbed seams', ()
         originalCwd = process.cwd();
         process.chdir(tmpDir);
         harness.searchResults = {};
+        harness.searchTypeFilters = [];
         harness.orchestratorArgs = [];
         harness.orchestratorContent = 'DRAFT';
         harness.connects = 0;
@@ -1126,6 +1499,27 @@ describe('specCommand — anchored evidence, executed against stubbed seams', ()
         expect(harness.orchestratorArgs).toEqual([]);
         expect(runArtifactNames()).toEqual([]);
     });
+    it('asks the store for lessons and carries them into the prompt (mmnto-ai/totem#2735)', async () => {
+        harness.searchResults = {
+            spec: [relevantHit(0.7)],
+            lesson: [
+                relevantHit(0.7, {
+                    type: 'lesson',
+                    label: 'Lesson A',
+                    filePath: '.totem/lessons/lesson-abc.md',
+                    content: 'Always validate input at boundaries.',
+                }),
+            ],
+        };
+        await specCommand(['2735'], { stdout: true });
+        expect(harness.searchTypeFilters).toContain('lesson');
+        const prompt = String(harness.orchestratorArgs[0]['prompt']);
+        // The real section header (`formatLessonSection` in utils.ts), not the bare
+        // phrase — the system prompt carries "RELEVANT LESSONS" on its own, so a
+        // `toContain` on that alone passes with zero lessons delivered.
+        expect(prompt).toContain('=== RELEVANT LESSONS (HARD CONSTRAINTS) ===');
+        expect(prompt).toContain('Always validate input at boundaries.');
+    });
     it('a --from run anchors on the record, leaves its bytes UNCHANGED, and drafts to stdout', async () => {
         const record = writeRecord('# Design record\n\nThe ruled contract.\n');
         const before = sha256Of(record);
@@ -1202,6 +1596,15 @@ describe('specCommand — anchored evidence, executed against stubbed seams', ()
         await expect(specCommand(['nonsense slug'], { stdout: true })).rejects.toThrowError(/Retrieval returned 0 hits/);
         expect(harness.orchestratorArgs).toEqual([]);
     });
+    // The WIRING, not the formatter: this is the only test that fails if the
+    // caller stops passing `context.lessons.length` (a literal 0 there leaves
+    // every formatter-level test green). One delivered lesson, no spec/session/
+    // code rows — the count in the refusal has to come from the delivered pool.
+    it('a free-text run with 0 grounding hits carries the DELIVERED lesson count into the refusal', async () => {
+        harness.searchResults = { lesson: [makeLesson()] };
+        await expect(specCommand(['nonsense slug'], { stdout: true })).rejects.toThrowError(/1 lesson was retrieved, but lessons do not ground a run/);
+        expect(harness.orchestratorArgs).toEqual([]);
+    });
     it('a free-text run entirely below the floor REFUSES, naming the floor and every withheld candidate', async () => {
         harness.searchResults = { spec: [relevantHit(0.1, { filePath: 'docs/a.md' })] };
         let thrown;
@@ -1215,7 +1618,8 @@ describe('specCommand — anchored evidence, executed against stubbed seams', ()
         const message = String(thrown.message);
         expect(message).toContain('weak slug');
         expect(message).toContain('best relevance 0.100');
-        expect(message).toContain('floor 0.250 — searchRelevanceFloor in totem.config.ts (schema default 0.25 when unset)');
+        // Full-line pin — see `floorLineOf` (mmnto-ai/totem#2727 fold, F3).
+        expect(floorLineOf(message)).toBe('floor 0.250 — searchRelevanceFloor in totem.config.ts');
         expect(message).toContain('docs/a.md — relevance 0.100');
         expect(harness.orchestratorArgs).toEqual([]);
     });
@@ -1239,5 +1643,40 @@ describe('specCommand — anchored evidence, executed against stubbed seams', ()
         await specCommand(['2700'], { stdout: true });
         expect(artifactRequest()['floor']).toBe(0.6);
     });
+    // --- No floor configured (mmnto-ai/totem#2727) ---
+    it('with NO floor configured, a weak free-text run PROCEEDS instead of being refused', async () => {
+        const { searchRelevanceFloor: _dropped, ...unfloored } = harness.config;
+        harness.config = unfloored;
+        // 0.1 is far below the 0.25 this suite otherwise configures — the sibling
+        // test 'a free-text run entirely below the floor REFUSES' uses this exact
+        // fixture WITH a floor and gets a GATE_INVALID. Same retrieval, no floor,
+        // no refusal: that contrast is the invariant.
+        harness.searchResults = { spec: [relevantHit(0.1, { filePath: 'docs/a.md' })] };
+        await specCommand(['weak slug'], { stdout: true });
+        expect(harness.orchestratorArgs.length).toBe(1);
+    });
+    it('with NO floor configured, the artifact OMITS grounding.floor rather than inventing one', async () => {
+        const { searchRelevanceFloor: _dropped, ...unfloored } = harness.config;
+        harness.config = unfloored;
+        harness.searchResults = { spec: [relevantHit(0.9)] };
+        await specCommand(['2700'], { stdout: true });
+        expect(artifactRequest()['floor']).toBeUndefined();
+    });
+    it('with NO floor configured, a ZERO-HIT free-text run still refuses — with the none form', async () => {
+        const { searchRelevanceFloor: _dropped, ...unfloored } = harness.config;
+        harness.config = unfloored;
+        let thrown;
+        try {
+            await specCommand(['nonsense slug'], { stdout: true });
+        }
+        catch (err) {
+            thrown = err;
+        }
+        expect(thrown).toMatchObject({ code: 'GATE_INVALID' });
+        const message = String(thrown.message);
+        expect(message).toContain('Retrieval returned 0 hits');
+        expect(message).toContain(FLOOR_LINE_UNSET_TEXT);
+        expect(harness.orchestratorArgs).toEqual([]);
+    });
 });
 //# sourceMappingURL=spec.test.js.map