@mmnto/cli 1.124.0 → 2.1.0

package/dist/commands/spec.test.js

@@ -3,7 +3,7 @@ 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, MAX_SPECS, resolveDefaultSpecPath, resolveGroundingAnchor, retrieveContext, sanitizeSpecFilename, SPEC_SEARCH_POOL, SPEC_SYSTEM_PROMPT, specCommand, validateOutputOptions, validateSpecInvocation, } from './spec.js';
@@ -531,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) ────────
@@ -674,32 +681,62 @@ 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 (schema default 0.25 when unset)';
+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([]);
@@ -710,14 +747,14 @@ describe('evaluateGroundingFloor', () => {
     // 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 = evaluateGroundingFloor({ ...emptyContext(), lessons: [relevantHit(undefined, { type: 'lesson' })] }, FLOOR);
+        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 = evaluateGroundingFloor({
+        const verdict = evaluateFloor({
             ...emptyContext(),
             specs: [relevantHit(0.05, { filePath: 'docs/weak.md' })],
             lessons: [relevantHit(undefined, { type: 'lesson' })],
@@ -728,7 +765,7 @@ describe('evaluateGroundingFloor', () => {
         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 = evaluateGroundingFloor({
+        const verdict = evaluateFloor({
             ...emptyContext(),
             specs: [relevantHit(FLOOR)],
             lessons: [relevantHit(undefined, { type: 'lesson' }), relevantHit(0.9, { type: 'lesson' })],
@@ -741,38 +778,102 @@ describe('evaluateGroundingFloor', () => {
         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 NaN hit beside a genuinely weak one is not disclosed as a withheld candidate', () => {
-        const verdict = evaluateGroundingFloor({
+    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, 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('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 = evaluateGroundingFloor({
+        const verdict = evaluateFloor({
             specs: [relevantHit(0.9)],
             sessions: [relevantHit(0.8)],
             code: [relevantHit(0.7)],
@@ -782,7 +883,7 @@ describe('evaluateGroundingFloor', () => {
         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' }),
@@ -794,15 +895,75 @@ 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 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
@@ -811,26 +972,26 @@ describe('formatGroundingRefusal', () => {
         // The seeded count IS the delivered count — the invariant production holds,
         // where the caller passes `context.lessons.length`.
         const lessons = [makeLesson(), makeLesson()];
-        const verdict = evaluateGroundingFloor({ ...emptyContext(), lessons }, FLOOR);
+        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 (mmnto-ai/totem#2727 rules whether they may).',
+            '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 = evaluateGroundingFloor({ ...emptyContext(), lessons: [makeLesson()] }, FLOOR);
+        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 (mmnto-ai/totem#2727 rules whether they may).');
+        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 = evaluateGroundingFloor(emptyContext(), FLOOR);
+        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.',
@@ -838,8 +999,44 @@ describe('formatGroundingRefusal', () => {
             `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 = evaluateGroundingFloor({ ...emptyContext(), specs: [relevantHit(0.2, { filePath: 'docs/a.md' })] }, FLOOR);
+        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.',
@@ -851,7 +1048,7 @@ describe('formatGroundingRefusal', () => {
         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' }),
@@ -864,7 +1061,7 @@ describe('formatGroundingRefusal', () => {
         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, 0);
+        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');
@@ -1421,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([]);
     });
@@ -1445,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