@mmnto/cli 1.114.0 → 1.116.0

package/dist/commands/mail.test.js

@@ -11,10 +11,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 { findTotemRepoRootSync, TotemError } from '@mmnto/totem';
+import { findTotemRepoRootSync, SEAT_LIFECYCLE_FILENAME, SEAT_LIFECYCLE_SCHEMA_VERSION, TotemError, writeSeatLifecycle, } from '@mmnto/totem';
 import { cleanTmpDir } from '../test-utils.js';
 import { log } from '../ui.js';
-import { composeDispatch, mailCommand, mailReply, mailSend, markSource, pollMail, resolveMailExitCode, resolveSelfSender, sanitizeEclBasename, validateDispatchContent, } from './mail.js';
+import { composeDispatch, formatTextResult, mailCommand, mailReply, mailSend, markSource, pollMail, resolveMailExitCode, resolveSelfSender, sanitizeEclBasename, validateDispatchContent, } from './mail.js';
 // ─── Fixture helpers ────────────────────────────────────
 let tmpRoot;
 let workspace;
@@ -59,6 +59,20 @@ function writeBroadcastProcessed(repo, recipientAgent, names) {
     for (const n of names)
         fs.writeFileSync(path.join(dir, n), '---\nto: broadcast\n---\n', 'utf-8');
 }
+/**
+ * Declare a seat's lifecycle at `<repo>/.totem/orchestration/<seat>/lifecycle.json`
+ * (mmnto-ai/totem#2511) through CORE'S REAL WRITER — the same producer the
+ * `totem seat` verbs use — so the fixture can never be weaker than the on-disk
+ * contract the poll reads back (a hand-rolled JSON fixture could drift from the
+ * strict schema and quietly test nothing). Returns the marker path.
+ */
+function writeLifecycleMarker(repo, seat, state) {
+    return writeSeatLifecycle(path.join(workspace, repo), seat, {
+        schemaVersion: SEAT_LIFECYCLE_SCHEMA_VERSION,
+        state,
+        since: '2026-08-11T00:00:00.000Z',
+    });
+}
 /**
  * `totem` is the only cohort name resolveSelfAgents pre-knows; using it as
  * the "self" repo keeps the SELF_AGENT resolution working off the basename
@@ -424,6 +438,272 @@ describe('pollMail — broadcast marks are per-seat, not union (mmnto-ai/totem#2
         expect(poll({ env: TWO_SEATS }).mail).toEqual([]);
     });
 });
+// ─── Lifecycle-aware broadcast denominators ────────────
+// mmnto-ai/totem#2511: a suspended-but-dir-present seat pinned every broadcast
+// open forever (the denominator failure). The declared lifecycle marker takes
+// such a seat OUT OF THE DENOMINATOR only — resolution stays lifecycle-blind,
+// so directed mail keeps surfacing (a transition does not discharge an
+// obligation edge, OQ4) and directed marks keep subtracting (an already-handled
+// dispatch resurfacing as unread is the ADR-106 § A2.1 false-unread bomb).
+describe('pollMail — lifecycle-aware broadcast denominators (mmnto-ai/totem#2511)', () => {
+    const BROADCAST_FILE = '2026-08-11T0930Z-broadcast-lifecycle-note.md';
+    const TWO_SEATS = { TOTEM_SELF_AGENT: 'totem-claude,totem-gemini' };
+    function writeBroadcast() {
+        writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: BROADCAST_FILE, to: 'broadcast', subject: 'cohort note' },
+        ]);
+    }
+    it("a suspended seat leaves the denominator — the ACTIVE seats' marks alone close the broadcast", () => {
+        writeBroadcast();
+        writeLifecycleMarker('totem', 'totem-gemini', 'suspended');
+        // Only the ACTIVE seat holds a mark. Pre-#2511 the requirement was 2 and
+        // this broadcast stayed unread forever — the pinned-open denominator.
+        writeBroadcastProcessed('totem', 'totem-claude', [BROADCAST_FILE]);
+        expect(poll({ env: TWO_SEATS }).mail).toEqual([]);
+    });
+    it("a suspended seat's mark alone cannot close a broadcast the active seat has not marked", () => {
+        writeBroadcast();
+        writeLifecycleMarker('totem', 'totem-gemini', 'suspended');
+        // The SUSPENDED seat's mark, and only it. The requirement is 1 (one active
+        // seat), so a shared count map would read 1 >= 1 and vacuously consume the
+        // broadcast for the active seat that never saw it — which is why the
+        // broadcast count is folded from the ACTIVE seats' marks only.
+        writeBroadcastProcessed('totem', 'totem-gemini', [BROADCAST_FILE]);
+        expect(poll({ env: TWO_SEATS }).mail.map((m) => m.file)).toEqual([BROADCAST_FILE]);
+    });
+    it('a suspended seat stays RESOLVED: its directed mail surfaces, annotated once per poll', () => {
+        writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: '2026-08-11T0931Z-totem-gemini-held-one.md', to: 'totem-gemini' },
+            { name: '2026-08-11T0932Z-totem-gemini-held-two.md', to: 'totem-gemini' },
+        ]);
+        writeLifecycleMarker('totem', 'totem-gemini', 'suspended');
+        const result = poll({ env: TWO_SEATS });
+        // Resolution is lifecycle-blind — the seat is still SELF.
+        expect(result.selfAgents.agents).toEqual(['totem-claude', 'totem-gemini']);
+        // Sense, never hide: both held dispatches surface (OQ4 — a suspension does
+        // not discharge the obligation edge).
+        expect(result.mail).toHaveLength(2);
+        // Bounded annotation: ONE notice for the seat, not one per file — and it
+        // rides the NON-GATING notices channel, never warnings (finding 1 of the
+        // falsification round: warnings arm three gates).
+        expect(result.warnings).toEqual([]);
+        const held = result.notices.filter((n) => n.includes('suspended seat'));
+        expect(held).toHaveLength(1);
+        expect(held[0]).toContain('totem-gemini');
+        expect(held[0]).toContain('obligation held, not discharged');
+        expect(held[0]).toContain('mmnto-ai/totem-status#127');
+    });
+    it('a suspended seat with held mail never pins the verdict to INCOMPLETE (the #2516 discriminator stays honest)', () => {
+        writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: '2026-08-11T0939Z-totem-gemini-held.md', to: 'totem-gemini' },
+        ]);
+        writeLifecycleMarker('totem', 'totem-gemini', 'suspended');
+        const rendered = formatTextResult(poll({ env: TWO_SEATS }));
+        // The scan IS complete: the annotation renders as a Note line and the
+        // verdict must not claim degradation — a suspended seat must leave the
+        // INCOMPLETE token meaning "scan not trustworthy", not "lifecycle exists".
+        expect(rendered).toContain('Note: directed mail surfacing for suspended seat');
+        expect(rendered).not.toContain('INCOMPLETE');
+        expect(rendered).toContain('1 unread:');
+    });
+    it("a suspended seat's already-consumed directed mail stays consumed (no false-unread)", () => {
+        writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: '2026-08-11T0933Z-totem-gemini-done.md', to: 'totem-gemini', subject: 'handled' },
+            { name: '2026-08-11T0934Z-totem-gemini-live.md', to: 'totem-gemini', subject: 'still open' },
+        ]);
+        writeProcessed('totem', 'totem-gemini', ['2026-08-11T0933Z-totem-gemini-done.md']);
+        writeLifecycleMarker('totem', 'totem-gemini', 'suspended');
+        // NON-VACUITY: the unconsumed sibling still surfaces, so "the handled one is
+        // gone" is a subtraction, not an empty scan.
+        expect(poll({ env: TWO_SEATS }).mail.map((m) => m.file)).toEqual([
+            '2026-08-11T0934Z-totem-gemini-live.md',
+        ]);
+    });
+    it('mail addressed to a RETIRED seat surfaces, with the retired-addressee warning (sense, never hide)', () => {
+        writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: '2026-08-11T0935Z-totem-gemini-late.md', to: 'totem-gemini' },
+            { name: '2026-08-11T0936Z-totem-gemini-later.md', to: 'totem-gemini' },
+        ]);
+        writeLifecycleMarker('totem', 'totem-gemini', 'retired');
+        const result = poll({ env: TWO_SEATS });
+        expect(result.mail).toHaveLength(2);
+        // Notices channel, never warnings — same channel discipline as suspended.
+        expect(result.warnings).toEqual([]);
+        const retired = result.notices.filter((n) => n.includes('addressed to retired seat'));
+        expect(retired).toHaveLength(1);
+        expect(retired[0]).toContain('totem-gemini');
+    });
+    it('channel discipline: annotations ride the non-gating notices channel on BOTH paths; only the corrupt-marker warning arms the gates', () => {
+        // The `warnings` channel arms THREE gates (ecl-gc A2.2, A2.4
+        // verifyComplete, the #2516 INCOMPLETE verdict). Lifecycle annotations are
+        // informational senses on a healthy scan — they ride `notices`, which no
+        // gate reads, uniformly on the reader AND the compaction-discovery path. A
+        // corrupt marker IS a denominator-integrity anomaly and stays a warning on
+        // both paths.
+        writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: '2026-08-11T0937Z-totem-gemini-held.md', to: 'totem-gemini' },
+            { name: '2026-08-11T0938Z-totem-claude-note.md', to: 'totem-claude' },
+        ]);
+        writeLifecycleMarker('totem', 'totem-gemini', 'suspended');
+        const readerView = poll({ env: TWO_SEATS });
+        const discoveryView = poll({ env: TWO_SEATS, includeProcessed: true });
+        for (const view of [readerView, discoveryView]) {
+            expect(view.warnings).toEqual([]);
+            expect(view.notices.filter((n) => n.includes('suspended seat'))).toHaveLength(1);
+            expect(view.mail).toHaveLength(2);
+        }
+        // Corrupt the marker: the integrity warning fires on the discovery path
+        // too (naming the marker path), redding the compaction gate by design.
+        const markerPath = path.join(workspace, 'totem', '.totem', 'orchestration', 'totem-gemini', SEAT_LIFECYCLE_FILENAME);
+        fs.writeFileSync(markerPath, '{not json', 'utf-8');
+        const corruptDiscovery = poll({ env: TWO_SEATS, includeProcessed: true });
+        const corruptWarnings = corruptDiscovery.warnings.filter((w) => w.includes(markerPath));
+        expect(corruptWarnings).toHaveLength(1);
+    });
+    it('all self seats suspended ⇒ broadcasts NEVER subtract, and the hold is NAMED with its recovery (never a clean render)', () => {
+        writeBroadcast();
+        writeLifecycleMarker('totem', 'totem-claude', 'suspended');
+        writeLifecycleMarker('totem', 'totem-gemini', 'suspended');
+        writeBroadcastProcessed('totem', 'totem-claude', [BROADCAST_FILE]);
+        writeBroadcastProcessed('totem', 'totem-gemini', [BROADCAST_FILE]);
+        // activeCount 0 ⇒ required stays 1 (`max(…, 1)`) and the active-mark map is
+        // EMPTY, so the count is 0: an empty required set is never "closed" (the
+        // inherited orchestration.go boundary). Never vacuously consumed.
+        const result = poll({ env: TWO_SEATS });
+        expect(result.mail.map((m) => m.file)).toEqual([BROADCAST_FILE]);
+        // Falsification finding 2: the permanently-pinned broadcast must not
+        // render as a clean unread line — one notice names the all-suspended
+        // cause and the reactivation recovery. Warnings stay empty (the scan is
+        // healthy; nothing here may red a gate).
+        expect(result.warnings).toEqual([]);
+        const held = result.notices.filter((n) => n.includes('suspended/retired'));
+        expect(held).toHaveLength(1);
+        expect(held[0]).toContain('--reactivate');
+    });
+    it('all seats RETIRED ⇒ the hold notice routes to a fresh ruling, never to the --reactivate the CLI refuses (re-arm D-1)', () => {
+        writeBroadcast();
+        writeLifecycleMarker('totem', 'totem-claude', 'retired');
+        writeLifecycleMarker('totem', 'totem-gemini', 'retired');
+        const result = poll({ env: TWO_SEATS });
+        expect(result.mail.map((m) => m.file)).toEqual([BROADCAST_FILE]);
+        const held = result.notices.filter((n) => n.includes('retired'));
+        expect(held).toHaveLength(1);
+        // `seat add --reactivate` hard-errors on a retired seat — the notice must
+        // never advertise a recovery the CLI structurally refuses.
+        expect(held[0]).not.toContain('--reactivate');
+        expect(held[0]).toContain('register a replacement seat');
+    });
+    it('a broadcast-NAMED file whose parsed to: is directed earns no hold notice (re-arm D-2, the codex-F2 mislabel class)', () => {
+        // The filename token alone selected the flag pre-fold; parsed truth rules
+        // now — a mislabeled directed dispatch must not render a "held broadcast"
+        // claim above a verdict that shows nothing held.
+        writeOutbox('totem-strategy', 'strategy-claude', [
+            {
+                name: '2026-08-11T0940Z-broadcast-mislabeled.md',
+                to: 'strategy-claude',
+                subject: 'directed despite the name',
+            },
+        ]);
+        writeLifecycleMarker('totem', 'totem-claude', 'suspended');
+        writeLifecycleMarker('totem', 'totem-gemini', 'suspended');
+        const result = poll({ env: TWO_SEATS });
+        // Addressed to a non-self seat: no mail surfaces, and no hold exists.
+        expect(result.mail).toEqual([]);
+        expect(result.notices.filter((n) => n.includes('broadcast dispatches'))).toEqual([]);
+    });
+    it('a marker declaring `active` behaves exactly like no marker (absent ⇒ active)', () => {
+        writeBroadcast();
+        writeLifecycleMarker('totem', 'totem-gemini', 'active');
+        writeBroadcastProcessed('totem', 'totem-claude', [BROADCAST_FILE]);
+        const result = poll({ env: TWO_SEATS });
+        // Both seats are in the denominator, so one mark does not close it.
+        expect(result.mail.map((m) => m.file)).toEqual([BROADCAST_FILE]);
+        expect(result.warnings).toEqual([]);
+        expect(result.notices).toEqual([]);
+    });
+    it('markerless tree: the FULL poll result is identical to the pre-#2511 snapshot', () => {
+        // The snapshot below was captured by running this exact fixture through
+        // HEAD's pre-#2511 `pollMail` and the post-change one side by side and
+        // deep-equalling the two results (directed + broadcast + marks + a
+        // half-marked broadcast + a roster-invalid address + a cross-sender
+        // collision, over a two-seat poll). Pinning the WHOLE object — not a
+        // spot-check — is what makes "markerless trees behave bit-identically"
+        // (#2511 data-model invariant) a test rather than a claim.
+        const DATE = '2026-08-01T1700Z';
+        writeOutbox('totem-strategy', 'strategy-claude', [
+            {
+                name: '2026-08-01T1700Z-totem-claude-directed.md',
+                to: 'totem-claude',
+                subject: 'one',
+                date: DATE,
+            },
+            {
+                name: '2026-08-01T1701Z-totem-claude-consumed.md',
+                to: 'totem-claude',
+                subject: 'done',
+                date: DATE,
+            },
+            {
+                name: '2026-08-01T1702Z-broadcast-cohort.md',
+                to: 'broadcast',
+                subject: 'bcast',
+                date: DATE,
+            },
+            { name: '2026-08-01T1703Z-broadcast-half.md', to: 'broadcast', subject: 'half', date: DATE },
+            {
+                name: '2026-08-01T1704Z-cohort-bad-address.md',
+                to: 'cohort',
+                subject: 'nobody',
+                date: DATE,
+            },
+            { name: '2026-08-01T1705Z-collide.md', to: 'totem-gemini', subject: 'collide-a', date: DATE },
+        ]);
+        writeOutbox('liquid-city', 'lc-claude', [
+            { name: '2026-08-01T1705Z-collide.md', to: 'totem-gemini', subject: 'collide-b', date: DATE },
+            {
+                name: '2026-08-01T1706Z-totem-gemini-directed.md',
+                to: 'totem-gemini',
+                subject: 'two',
+                date: DATE,
+            },
+        ]);
+        writeProcessed('totem', 'totem-claude', [
+            '2026-08-01T1701Z-totem-claude-consumed.md',
+            '2026-08-01T1703Z-broadcast-half.md',
+        ]);
+        writeProcessed('totem', 'totem-gemini', ['2026-08-01T1702Z-broadcast-cohort.md']);
+        writeBroadcastProcessed('totem', 'totem-claude', ['2026-08-01T1702Z-broadcast-cohort.md']);
+        const entry = (repo, sender, file, to, subject) => ({
+            file,
+            repo,
+            from: sender,
+            to,
+            date: DATE,
+            subject,
+            filePath: path.join(workspace, repo, '.totem', 'orchestration', sender, 'outbox', file),
+        });
+        expect(poll({ env: TWO_SEATS })).toEqual({
+            selfAgents: { agents: ['totem-claude', 'totem-gemini'], source: 'env' },
+            mail: [
+                entry('liquid-city', 'lc-claude', '2026-08-01T1706Z-totem-gemini-directed.md', 'totem-gemini', 'two'),
+                entry('totem-strategy', 'strategy-claude', '2026-08-01T1703Z-broadcast-half.md', 'broadcast', 'half'),
+                entry('totem-strategy', 'strategy-claude', '2026-08-01T1700Z-totem-claude-directed.md', 'totem-claude', 'one'),
+                entry('liquid-city', 'lc-claude', '2026-08-01T1705Z-collide.md', 'totem-gemini', 'collide-b'),
+                entry('totem-strategy', 'strategy-claude', '2026-08-01T1705Z-collide.md', 'totem-gemini', 'collide-a'),
+            ],
+            scanned: 6,
+            truncated: false,
+            workspace,
+            warnings: [
+                'unresolvable outbox address: totem-strategy/strategy-claude/2026-08-01T1704Z-cohort-bad-address.md — to: "cohort" matches no roster agent; invisible to every seat-scoped poll',
+                'cross-sender basename collision: 2026-08-01T1705Z-collide.md from liquid-city/lc-claude and totem-strategy/strategy-claude — a single processed/ mark would shadow both',
+            ],
+            // Additive field (fold): a markerless tree emits zero notices — the
+            // channel's existence is the only delta vs the pre-#2511 result shape.
+            notices: [],
+        });
+    });
+});
 // ─── Cross-sender basename-collision sensor ─────────────
 describe('pollMail — cross-sender basename-collision sensor (mmnto-ai/totem#2311)', () => {
     const NAME = '2026-07-06T1717Z-totem-claude-blind-reply.md';
@@ -1291,7 +1571,15 @@ describe('mailCommand — --json output', () => {
 // ─── Exit contract + NOT-DERIVED verdict (mmnto-ai/totem#2312) ─────────────
 describe('resolveMailExitCode (unit)', () => {
     function result(selfAgents) {
-        return { selfAgents, mail: [], scanned: 0, truncated: false, workspace: '/w', warnings: [] };
+        return {
+            selfAgents,
+            mail: [],
+            scanned: 0,
+            truncated: false,
+            workspace: '/w',
+            warnings: [],
+            notices: [],
+        };
     }
     it('is 2 when self is unresolved (source none), 0 when resolved', () => {
         expect(resolveMailExitCode(result({ agents: [], source: 'none' }))).toBe(2);