@mmnto/cli 1.101.1 → 1.102.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 } from '@mmnto/totem';
+import { findTotemRepoRootSync, TotemError } from '@mmnto/totem';
 import { cleanTmpDir } from '../test-utils.js';
 import { log } from '../ui.js';
-import { composeDispatch, mailCommand, mailReply, mailSend, pollMail, resolveMailExitCode, resolveSelfSender, validateDispatchContent, } from './mail.js';
+import { composeDispatch, mailCommand, mailReply, mailSend, markSource, pollMail, resolveMailExitCode, resolveSelfSender, sanitizeEclBasename, validateDispatchContent, } from './mail.js';
 // ─── Fixture helpers ────────────────────────────────────
 let tmpRoot;
 let workspace;
@@ -400,6 +400,29 @@ describe('pollMail — broadcast marks are per-seat, not union (mmnto-ai/totem#2
         expect(poll({ env: TWO_SEATS }).mail).toEqual([]);
         expect(poll({ env: TWO_SEATS, includeProcessed: true }).mail).toHaveLength(1);
     });
+    it('a COLON-bearing broadcast-named file requires EVERY seat mark (CR @623 — classify on sanitized)', () => {
+        // Before the fix, `isBroadcastNamed` ran the raw `T\d{4}Z` stamp regex, which
+        // a colon stamp (`T05:10Z`) fails → the broadcast fell to the ANY-seat rule
+        // and one seat's mark hid it from the other (the #2412 class, resurrected for
+        // that name shape). Now classification runs on the sanitized basename.
+        const colon = '2026-07-18T05:10Z-broadcast-consumers.md';
+        const sanitized = sanitizeEclBasename(colon);
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: colon, to: 'broadcast', subject: 'consumers move' },
+        ]);
+        // Only meaningful where the FS preserves colons in a directory listing; NTFS
+        // turns the colon into an ADS the readdir never lists, so the corrupt inbound
+        // is simply absent there (no first-consumer-wins hazard). Guard so the
+        // assertion runs on colon-legal filesystems (CI/Linux) and no-ops on win32.
+        if (!fs.readdirSync(outbox).includes(colon))
+            return;
+        // Marks are stored sanitized; one seat's mark must NOT hide the broadcast.
+        writeProcessed('totem', 'totem-gemini', [sanitized]);
+        expect(poll({ env: TWO_SEATS }).mail.map((m) => sanitizeEclBasename(m.file))).toContain(sanitized);
+        // Only once EVERY resolved seat holds the mark does it subtract.
+        writeProcessed('totem', 'totem-claude', [sanitized]);
+        expect(poll({ env: TWO_SEATS }).mail).toEqual([]);
+    });
 });
 // ─── Cross-sender basename-collision sensor ─────────────
 describe('pollMail — cross-sender basename-collision sensor (mmnto-ai/totem#2311)', () => {
@@ -1658,7 +1681,10 @@ describe('mailReply — sugar (mmnto-ai/totem#2042)', () => {
         const src = writeSource();
         const res = mailReply(src, {
             from: 'totem-claude',
-            repoRoot: mkDir(path.join(workspace, 'totem')),
+            // Marker-bearing root: markSource resolves the repo root via the shared
+            // walk-up resolver (CR @1480), so a marker-less fixture would climb to a
+            // host ancestor `.totem`.
+            repoRoot: selfRepoRoot(),
             env: {},
             now: fixedClock,
             knownAgents: ['strategy-claude'],
@@ -1679,7 +1705,7 @@ describe('mailReply — sugar (mmnto-ai/totem#2042)', () => {
         fs.writeFileSync(src, '---\nto: totem-claude\nsubject: legacy mail\n---\n\nBody.\n', 'utf-8');
         const res = mailReply(src, {
             from: 'totem-claude',
-            repoRoot: mkDir(path.join(workspace, 'totem')),
+            repoRoot: selfRepoRoot(), // marker-bearing (CR @1480 resolver parity)
             env: {},
             now: fixedClock,
             knownAgents: ['strategy-claude'],
@@ -1824,4 +1850,333 @@ describe('validateDispatchContent / composeDispatch / resolveSelfSender (units)'
         expect(() => resolveSelfSender(totemRepo, {})).toThrow(/ambiguous/); // map → 2 agents
     });
 });
+// ─── Consume-marking: mail mark (mmnto-ai/totem#2396) ───
+describe('markSource — standalone mail mark (mmnto-ai/totem#2396)', () => {
+    const SOLO = { TOTEM_SELF_AGENT: 'totem-claude' };
+    function processedPath(seat, name, broadcast = false) {
+        const base = path.join(selfRepoRoot(), '.totem', 'orchestration', seat, 'processed');
+        return broadcast ? path.join(base, '_broadcast', name) : path.join(base, name);
+    }
+    it('marks a directed dispatch so a subsequent poll subtracts it (consume-atomicity)', () => {
+        const name = '2026-07-16T2200Z-totem-claude-handoff.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [
+            { name, to: 'totem-claude', subject: 'lane handoff' },
+        ]);
+        const source = path.join(outbox, name);
+        // Pre-mark: the dispatch is unread for this seat.
+        expect(poll({ env: SOLO }).mail.map((m) => m.file)).toContain(name);
+        const res = markSource(source, { repoRoot: selfRepoRoot(), env: SOLO });
+        expect(res.agent).toBe('totem-claude');
+        expect(res.broadcast).toBe(false);
+        expect(res.alreadyMarked).toBe(false);
+        // The mark is a same-basename FULL COPY of the source under the directed store.
+        expect(res.markPath).toBe(processedPath('totem-claude', name));
+        expect(fs.readFileSync(res.markPath, 'utf-8')).toBe(fs.readFileSync(source, 'utf-8'));
+        // Post-mark: the reader no longer surfaces it (phantom-unread closed).
+        expect(poll({ env: SOLO }).mail).toEqual([]);
+    });
+    it('marks a broadcast dispatch under processed/_broadcast/ (per-seat store)', () => {
+        const name = '2026-07-16T2213Z-broadcast-cohort-move.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [
+            { name, to: 'broadcast', subject: 'cohort move' },
+        ]);
+        const source = path.join(outbox, name);
+        const res = markSource(source, { repoRoot: selfRepoRoot(), agentId: 'totem-claude', env: {} });
+        expect(res.broadcast).toBe(true);
+        expect(res.markPath).toBe(processedPath('totem-claude', name, true));
+        // Single-seat poll subtracts it (broadcast needs every seat; SOLO = just this one).
+        expect(poll({ env: SOLO }).mail).toEqual([]);
+    });
+    it('is idempotent — a second mark is a no-op (alreadyMarked, same path)', () => {
+        const name = '2026-07-16T2200Z-totem-claude-x.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [{ name, to: 'totem-claude' }]);
+        const source = path.join(outbox, name);
+        const first = markSource(source, {
+            repoRoot: selfRepoRoot(),
+            agentId: 'totem-claude',
+            env: {},
+        });
+        expect(first.alreadyMarked).toBe(false);
+        const second = markSource(source, {
+            repoRoot: selfRepoRoot(),
+            agentId: 'totem-claude',
+            env: {},
+        });
+        expect(second.alreadyMarked).toBe(true);
+        expect(second.markPath).toBe(first.markPath);
+    });
+    it('marks only into the resolved seat OWN cursor (single-writer, § A2.3)', () => {
+        const name = '2026-07-16T2200Z-totem-gemini-item.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [{ name, to: 'totem-gemini' }]);
+        const source = path.join(outbox, name);
+        const res = markSource(source, { repoRoot: selfRepoRoot(), agentId: 'totem-gemini', env: {} });
+        expect(res.markPath).toBe(processedPath('totem-gemini', name));
+        // A different seat's cursor is untouched.
+        expect(fs.existsSync(processedPath('totem-claude', name))).toBe(false);
+    });
+    it('hard-errors when the source is missing', () => {
+        expect(() => markSource(path.join(tmpRoot, 'nope.md'), {
+            repoRoot: selfRepoRoot(),
+            agentId: 'totem-claude',
+            env: {},
+        })).toThrow(/cannot read mark source dispatch/);
+    });
+    it('hard-errors when the source is not parseable mail (a stray file is not markable)', () => {
+        const stray = path.join(mkDir(path.join(tmpRoot, 'stray')), 'not-mail.md');
+        fs.writeFileSync(stray, 'no frontmatter here\n', 'utf-8');
+        expect(() => markSource(stray, { repoRoot: selfRepoRoot(), agentId: 'totem-claude', env: {} })).toThrow(/not parseable mail/);
+    });
+    it('hard-errors on ambiguous self with no --agent-id; explicit --agent-id disambiguates', () => {
+        const name = '2026-07-16T2200Z-totem-claude-amb.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [{ name, to: 'totem-claude' }]);
+        const source = path.join(outbox, name);
+        // The `totem` repo hosts totem-claude + totem-gemini → ambiguous without --agent-id.
+        expect(() => markSource(source, { repoRoot: selfRepoRoot(), env: {} })).toThrow(/cannot resolve the consuming seat/);
+        const res = markSource(source, { repoRoot: selfRepoRoot(), agentId: 'totem-claude', env: {} });
+        expect(res.agent).toBe('totem-claude');
+    });
+    it('resolves the repo root by walking up from a subdirectory (CR @1480 parity)', () => {
+        const name = '2026-07-16T2200Z-totem-claude-subdir.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [{ name, to: 'totem-claude' }]);
+        const source = path.join(outbox, name);
+        // Invoke with a repoRoot BELOW the real root (which carries the `.totem`
+        // marker): the shared resolver must climb to the real root so the mark lands
+        // in the store the poll reads — not a phantom `<subdir>/.totem`.
+        const subdir = mkDir(path.join(selfRepoRoot(), 'packages', 'cli'));
+        const res = markSource(source, { repoRoot: subdir, agentId: 'totem-claude', env: {} });
+        expect(res.markPath).toBe(processedPath('totem-claude', name));
+        expect(fs.existsSync(processedPath('totem-claude', name))).toBe(true);
+        // Nothing was written under the subdir.
+        expect(fs.existsSync(path.join(subdir, '.totem'))).toBe(false);
+    });
+    it('refuses to mark a directed dispatch into a non-recipient seat (CR @1532 reject)', () => {
+        const name = '2026-07-16T2200Z-totem-gemini-owned.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [{ name, to: 'totem-gemini' }]);
+        const source = path.join(outbox, name);
+        // Directed to totem-gemini, but marking as totem-claude → any-seat subtraction
+        // would suppress gemini's dispatch in a union poll. Hard reject.
+        expect(() => markSource(source, { repoRoot: selfRepoRoot(), agentId: 'totem-claude', env: {} })).toThrow(/refusing to mark directed dispatch/);
+        // No mark was written into the wrong seat's cursor.
+        expect(fs.existsSync(processedPath('totem-claude', name))).toBe(false);
+    });
+    it('accepts a directed mark when the resolving seat IS the recipient (CR @1532 accept)', () => {
+        const name = '2026-07-16T2200Z-totem-gemini-owned2.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [{ name, to: 'totem-gemini' }]);
+        const source = path.join(outbox, name);
+        const res = markSource(source, { repoRoot: selfRepoRoot(), agentId: 'totem-gemini', env: {} });
+        expect(res.agent).toBe('totem-gemini');
+        expect(res.markPath).toBe(processedPath('totem-gemini', name));
+    });
+});
+describe('mailReply — atomic consume-mark (mmnto-ai/totem#2396)', () => {
+    const fixedClock = () => new Date('2026-07-16T18:00:00.000Z');
+    const SRC_NAME = '2026-07-16T1710Z-totem-claude-orig.md';
+    function writeSource(to = 'totem-claude') {
+        const outbox = mkDir(path.join(workspace, 'totem-strategy', '.totem', 'orchestration', 'strategy-claude', 'outbox'));
+        const p = path.join(outbox, SRC_NAME);
+        fs.writeFileSync(p, [
+            '---',
+            'schema: adr-098-v0.4',
+            'from: strategy-claude',
+            `to: ${to}`,
+            'timestamp: 2026-07-16T17:10:00.000Z',
+            'subject: Original',
+            '---',
+            '',
+            'orig body',
+            '',
+        ].join('\n'), 'utf-8');
+        return p;
+    }
+    it('marks the source processed in the same command as the reply (default; copy under the replying seat)', () => {
+        const src = writeSource();
+        const repoRoot = selfRepoRoot(); // marker-bearing (CR @1480 resolver parity)
+        const res = mailReply(src, {
+            from: 'totem-claude',
+            repoRoot,
+            env: {},
+            now: fixedClock,
+            knownAgents: ['strategy-claude'],
+        });
+        expect(res.mark).toBeDefined();
+        expect(res.mark.agent).toBe('totem-claude'); // = the replying seat (source's recipient)
+        expect(res.mark.broadcast).toBe(false);
+        expect(res.mark.alreadyMarked).toBe(false);
+        const expected = path.join(repoRoot, '.totem', 'orchestration', 'totem-claude', 'processed', SRC_NAME);
+        expect(res.mark.markPath).toBe(expected);
+        expect(fs.readFileSync(expected, 'utf-8')).toBe(fs.readFileSync(src, 'utf-8'));
+    });
+    it('a subsequent poll no longer surfaces the replied-to source', () => {
+        const src = writeSource();
+        // Pre-reply: the source IS unread for this seat (CR @2351 test-hardening —
+        // without this the post-reply assertion could pass vacuously).
+        expect(poll({ env: { TOTEM_SELF_AGENT: 'totem-claude' } }).mail.map((m) => m.file)).toContain(SRC_NAME);
+        mailReply(src, {
+            from: 'totem-claude',
+            repoRoot: selfRepoRoot(),
+            env: {},
+            now: fixedClock,
+            knownAgents: ['strategy-claude'],
+        });
+        expect(poll({ env: { TOTEM_SELF_AGENT: 'totem-claude' } }).mail.map((m) => m.file)).not.toContain(SRC_NAME);
+    });
+    it('when the mark fails after the reply lands, the error is distinguishable + anti-retry (greptile P1)', () => {
+        const src = writeSource();
+        const repoRoot = selfRepoRoot();
+        // Block ONLY the mark write: occupy the seat's `processed/` PATH with a file
+        // so markSource's mkdir fails — the reply (a sibling `outbox/` write) still
+        // lands. Distinct from a reply failure.
+        const seatDir = mkDir(path.join(repoRoot, '.totem', 'orchestration', 'totem-claude'));
+        fs.writeFileSync(path.join(seatDir, 'processed'), 'occupied (not a dir)', 'utf-8');
+        let threw;
+        try {
+            mailReply(src, {
+                from: 'totem-claude',
+                repoRoot,
+                env: {},
+                now: fixedClock,
+                knownAgents: ['strategy-claude'],
+            });
+        }
+        catch (e) {
+            threw = e;
+        }
+        expect(threw).toBeInstanceOf(TotemError);
+        const err = threw;
+        // Message names the LANDED reply path so a re-run is visibly unnecessary.
+        expect(err.message).toContain('reply written to');
+        expect(err.message).toContain(path.join('totem-claude', 'outbox'));
+        // Hint forbids the duplicate-producing retry and routes to `mail mark`.
+        expect(err.recoveryHint).toContain('do NOT retry mail reply');
+        expect(err.recoveryHint).toContain(`totem mail mark ${src}`);
+        // The reply really did land in the outbox.
+        const outbox = path.join(repoRoot, '.totem', 'orchestration', 'totem-claude', 'outbox');
+        expect(fs.readdirSync(outbox).filter((f) => f.endsWith('.md')).length).toBeGreaterThan(0);
+    });
+    it('--no-mark (noMark) leaves the source unmarked (stage-only reply)', () => {
+        const src = writeSource();
+        const repoRoot = mkDir(path.join(workspace, 'totem'));
+        const res = mailReply(src, {
+            from: 'totem-claude',
+            noMark: true,
+            repoRoot,
+            env: {},
+            now: fixedClock,
+            knownAgents: ['strategy-claude'],
+        });
+        expect(res.mark).toBeUndefined();
+        const markPath = path.join(repoRoot, '.totem', 'orchestration', 'totem-claude', 'processed', SRC_NAME);
+        expect(fs.existsSync(markPath)).toBe(false);
+    });
+    it('marks a broadcast source under processed/_broadcast/ even when the reply itself is directed', () => {
+        // Reply target derives from source.from (strategy-claude, directed), but the
+        // MARK follows the SOURCE's class — a broadcast source lands in _broadcast/.
+        const src = writeSource('broadcast');
+        const repoRoot = selfRepoRoot(); // marker-bearing (CR @1480 resolver parity)
+        const res = mailReply(src, {
+            from: 'totem-claude',
+            repoRoot,
+            env: {},
+            now: fixedClock,
+            knownAgents: ['strategy-claude'],
+        });
+        expect(res.header.to).toBe('strategy-claude'); // reply is directed to the sender
+        expect(res.mark.broadcast).toBe(true);
+        expect(res.mark.markPath).toBe(path.join(repoRoot, '.totem', 'orchestration', 'totem-claude', 'processed', '_broadcast', SRC_NAME));
+    });
+});
+// ─── NTFS-safe basename sanitization (mmnto-ai/totem#2431) ───
+// A colon in an ECL filename is an NTFS Alternate Data Stream separator: writing
+// `...T05:10Z-x.md` verbatim creates a 0-byte base file (`...T05`) with the real
+// bytes in an invisible stream `fs.readdirSync` never lists — so a colon-bearing
+// mark is unreadable and its dispatch reports unread forever. The writer stores
+// the sanitized name; the reader normalizes both sides before comparison.
+describe('sanitizeEclBasename (unit)', () => {
+    it('strips colons on all platforms and is idempotent', () => {
+        expect(sanitizeEclBasename('2026-07-18T05:10Z-foo.md')).toBe('2026-07-18T0510Z-foo.md');
+        // Full ISO with seconds (two colons) collapses to the compact stamp shape.
+        expect(sanitizeEclBasename('2026-07-18T05:10:23Z-foo.md')).toBe('2026-07-18T051023Z-foo.md');
+        // A colon-free basename passes through unchanged (idempotent).
+        expect(sanitizeEclBasename('2026-07-18T0510Z-foo.md')).toBe('2026-07-18T0510Z-foo.md');
+    });
+});
+describe('markSource — colon-bearing source basenames are sanitized (mmnto-ai/totem#2431)', () => {
+    const SOLO = { TOTEM_SELF_AGENT: 'totem-claude' };
+    function processedPath(seat, name, broadcast = false) {
+        const base = path.join(selfRepoRoot(), '.totem', 'orchestration', seat, 'processed');
+        return broadcast ? path.join(base, '_broadcast', name) : path.join(base, name);
+    }
+    it('(a) marks a colon-bearing directed source under the sanitized name; the poll subtracts it', () => {
+        const colon = '2026-07-18T05:10Z-totem-claude-legacy.md';
+        const sanitized = '2026-07-18T0510Z-totem-claude-legacy.md';
+        // `fs.writeFileSync` to the colon path round-trips via the ADS stream on
+        // win32, so `markSource`'s read of the source still works; the mark is
+        // written NTFS-safe (colon-free) so it is actually listable.
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: colon, to: 'totem-claude', subject: 'legacy colon name' },
+        ]);
+        const source = path.join(outbox, colon);
+        const res = markSource(source, { repoRoot: selfRepoRoot(), env: SOLO });
+        expect(res.fileName).toBe(sanitized); // stored NTFS-safe, not verbatim
+        expect(res.markPath).toBe(processedPath('totem-claude', sanitized));
+        expect(fs.existsSync(res.markPath)).toBe(true); // the mark is a real, listable file
+        // Wherever the colon inbound is discoverable (a colon-legal FS), the reader
+        // subtracts it via the shared sanitizer; on win32 the corrupt inbound is not
+        // listed at all, so this holds vacuously — never a phantom-unread either way.
+        const remaining = poll({ env: SOLO }).mail.map((m) => sanitizeEclBasename(m.file));
+        expect(remaining).not.toContain(sanitized);
+    });
+    it('(b) idempotent re-mark of a colon-bearing source is a no-op (sanitized-name check)', () => {
+        const colon = '2026-07-18T05:10Z-totem-claude-x.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: colon, to: 'totem-claude' },
+        ]);
+        const source = path.join(outbox, colon);
+        const first = markSource(source, {
+            repoRoot: selfRepoRoot(),
+            agentId: 'totem-claude',
+            env: {},
+        });
+        expect(first.alreadyMarked).toBe(false);
+        const second = markSource(source, {
+            repoRoot: selfRepoRoot(),
+            agentId: 'totem-claude',
+            env: {},
+        });
+        expect(second.alreadyMarked).toBe(true);
+        expect(second.markPath).toBe(first.markPath);
+    });
+    it('(c) sanitizes a colon-bearing broadcast source into processed/_broadcast/', () => {
+        const colon = '2026-07-18T05:10Z-broadcast-cohort.md';
+        const sanitized = '2026-07-18T0510Z-broadcast-cohort.md';
+        const outbox = writeOutbox('totem-strategy', 'strategy-claude', [
+            { name: colon, to: 'broadcast', subject: 'cohort move' },
+        ]);
+        const source = path.join(outbox, colon);
+        const res = markSource(source, { repoRoot: selfRepoRoot(), agentId: 'totem-claude', env: {} });
+        expect(res.broadcast).toBe(true);
+        expect(res.fileName).toBe(sanitized);
+        expect(res.markPath).toBe(processedPath('totem-claude', sanitized, true));
+        expect(fs.existsSync(res.markPath)).toBe(true);
+    });
+});
+describe('mailSend — the filename emitter is colon-free / ADS-safe (mmnto-ai/totem#2431)', () => {
+    it('(d) composes a colon-free compact-stamp outbox filename even from a seconds-bearing ISO clock', () => {
+        // The emitter path is compactStamp (drops the HH:MM colon) → fileToken →
+        // slugify, none of which can emit a colon. A raw ISO with seconds is the
+        // worst case; the written name must still carry no colon.
+        const res = mailSend({
+            to: 'strategy-claude',
+            subject: 'lane handoff',
+            from: 'totem-claude',
+            repoRoot: mkDir(path.join(workspace, 'totem')),
+            env: {},
+            now: () => new Date('2026-07-18T05:10:23.456Z'),
+            knownAgents: ['strategy-claude'],
+        });
+        expect(res.fileName).not.toContain(':');
+        expect(res.fileName).toMatch(/^2026-07-18T0510Z-/); // compact stamp, colon dropped
+        expect(path.basename(res.filePath)).not.toContain(':');
+    });
+});
 //# sourceMappingURL=mail.test.js.map