@volter/supercode-teams 0.3.191 → 0.3.193

package/bin/teams-cli.mjs

@@ -49,7 +49,7 @@ import { APP_DOOR_PATH, appDoorFile, appDoorLink, normalOrigin, readAppDoor, rea
 
 const MACHINE_VERBS = new Set(['machine', 'slow', 'describe', 'records', 'panes', 'input', 'suspend', 'resume', 'files', 'ports', 'port', 'browser', 'stream', 'jobs', 'workspace', 'title', 'attention', 'watch', 'rpc', 'launches', 'log', 'mail', 'board', 'health', 'app-door']);
 // Every flag a machine verb reads; any other is refused rather than silently ignored.
-const KNOWN_FLAGS = new Set(['home', 'since', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path', 'repo', 'branch', 'solo', 'card', 'create', 'presence-only', 'processes', 'panes', 'clear-draft', 'message-ids', 'harness', 'observe', 'attach-context', 'json', 'all', 'origin', 'port', 'remove-origin', 'open', 'foreign']);
+const KNOWN_FLAGS = new Set(['apply', 'prefer-live-maildir', 'restart', 'home', 'since', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path', 'repo', 'branch', 'solo', 'card', 'create', 'presence-only', 'processes', 'panes', 'clear-draft', 'message-ids', 'harness', 'observe', 'attach-context', 'json', 'all', 'origin', 'port', 'remove-origin', 'open', 'foreign']);
 
 const argv = process.argv.slice(2);
 const flags = {};
@@ -66,7 +66,7 @@ for (let i = 0; i < argv.length; i += 1) {
   } else positional.push(a);
 }
 const [verb, sub, ...rest] = positional;
-const migrationRead = verb === 'mail' && ['migration-check', 'upgrade-check', 'upgrade-inspect', 'retain-release'].includes(sub);
+const migrationRead = verb === 'mail' && ['recover', 'migration-check', 'upgrade-check', 'upgrade-inspect', 'retain-release'].includes(sub);
 // A Windows scheduled task keeps no output (launchd and systemd name log files), so its unit names one here.
 // The local migration preflight does not open the service log or timing log.
 if (!migrationRead && process.env.SUPERCODE_TEAMS_LOG) {
@@ -82,7 +82,7 @@ const LONG_RUNNING = new Set(['connect', 'watch', 'port', 'stream', 'attach', 's
 const [timedVerb, timedSub] = verb === 'teams' ? [sub, rest[0]] : [verb, sub];
 if (!migrationRead && !LONG_RUNNING.has(timedVerb) && !(timedVerb === 'machine' && timedSub === 'start') && !(timedVerb === 'message' && timedSub === 'watch')) timeCommand(`teams ${[timedVerb, timedSub].filter(Boolean).join(' ')}`, argv);
 
-const MACHINE_HELP = 'machine verbs: machine start|status|restart, slow [--since 1h], describe, panes, input, suspend, resume, files, ports, port, stream, jobs, workspace, title, attention, watch, rpc, launches, log, health, browser, app-door on|off|rotate|status|link (add --machine NAME for an enrolled machine); local read: mail migration-check|upgrade-check [--home dir] [--json]';
+const MACHINE_HELP = 'machine verbs: machine start|status|restart, slow [--since 1h], describe, panes, input, suspend, resume, files, ports, port, stream, jobs, workspace, title, attention, watch, rpc, launches, log, health, browser, app-door on|off|rotate|status|link (add --machine NAME for an enrolled machine); local read: mail migration-check|upgrade-check|recover [--home dir] [--json]; offline recovery: mail recover --apply --prefer-live-maildir [--restart]';
 
 if (verb === undefined || verb === 'help') {
   process.stdout.write(`supercode teams: ${MACHINE_HELP}\n`);
@@ -401,6 +401,12 @@ async function main() {
       return;
     }
     case 'mail': {
+      if (sub === 'recover') {
+        if (Object.keys(flags).some(flag => !['home', 'json', 'apply', 'prefer-live-maildir', 'restart'].includes(flag)) || rest.length || flags.home === true) die('mail recover takes --home, --json, --apply, --prefer-live-maildir and --restart');
+        const { reconcileMaildir } = await import('../mail/reconcile-maildir.mjs');
+        out(await reconcileMaildir(resolve(home), { apply: flags.apply === true, preferLiveMaildir: flags['prefer-live-maildir'] === true, restart: flags.restart === true }));
+        return;
+      }
       if (sub === 'retain-release') {
         if (!flags.supercode || Object.keys(flags).some(flag => !['home', 'json', 'supercode'].includes(flag)) || rest.length) die('mail retain-release requires --supercode and takes --home and --json');
         const { prepareRetainedRelease } = await import('./workspace/retain-release.mjs');

package/machine.mjs

@@ -1195,7 +1195,10 @@ export class TeamsMachine extends MachineCore {
         producer.note('sessions_activity', `the sessions' activity could not be followed: ${error.message}; a session's turn changes on index events only until it is`);
         this.emit('records-log', `machine record: the sessions' activity could not be followed (${error.message}); tried again in ${Math.round(activityBackoff / 1000)} s`);
         clearTimeout(this.recordsActivityRetry);
-        if (!this.recordsStopped) this.recordsActivityRetry = setTimeout(() => void this.recordsFollowActivity(producer.record.sessions), activityBackoff); this.recordsActivityRetry.unref?.();
+        if (!this.recordsStopped) {
+          this.recordsActivityRetry = setTimeout(() => void this.recordsFollowActivity(producer.record.sessions), activityBackoff);
+          this.recordsActivityRetry.unref?.();
+        }
       }
     };
     // A folder watched for the record: a watch that failed or could not be made holds its retry until it is kept, said

package/mail/import-maildir.mjs

@@ -48,8 +48,11 @@ async function* logRecords(stream, start) {
   else if (fragments.length) yield { bytes: assembled(), offset: position };
 }
 
-export async function importMaildir(database, root, { log = () => {}, legacyRoot = root, deferOperational = false } = {}) {
+export async function importMaildir(database, root, { log = () => {}, legacyRoot = root, deferOperational = false, budgetMs = null } = {}) {
   const began = performance.now();
+  const budget = () => {
+    if (budgetMs != null && performance.now() - began >= budgetMs) throw Object.assign(new Error('mail import yielded its committed progress'), { code: 'mail_import_yield' });
+  };
   const work = { source_reads: 0, source_bytes: 0, committed_batches: 0, max_queued_operations: 0, resumed_directories: 0, resumed_entries: 0, resumed_log_bytes: 0, elapsed_ms: 0 };
   const complete = database.metadata('maildir_import');
   if (complete?.complete === true) return complete;
@@ -116,7 +119,9 @@ export async function importMaildir(database, root, { log = () => {}, legacyRoot
   };
   const progress = new ImportProgress(database, root, queue, work);
   await progress.start();
-  const entries = (dir) => progress.entries(dir);
+  const entries = async function* (dir) {
+    for await (const entry of progress.entries(dir)) { budget(); yield entry; }
+  };
   const recordDirectory = async (dir, collection, { nested = false, text = false } = {}) => {
     for await (const entry of entries(dir)) {
       const path = join(dir, entry.name);
@@ -145,8 +150,10 @@ export async function importMaildir(database, root, { log = () => {}, legacyRoot
 
   // Pass 1 imports envelopes before their claims, subscriptions and deliveries,
   // so the database's foreign keys enforce the same message ownership throughout.
+  try {
   const boxes = [];
   for (const entry of roots) {
+    budget();
     if (!entry.isDirectory()) continue;
     const dir = join(root, entry.name);
     let address;
@@ -312,6 +319,7 @@ export async function importMaildir(database, root, { log = () => {}, legacyRoot
       const stream = start < stat.size ? createReadStream(path, { start, end: stat.size - 1 }) : null;
       try {
         if (stream) for await (const row of logRecords(stream, start)) {
+          budget();
           number++;
           work.source_bytes += row.offset - readAt;
           readAt = row.offset;
@@ -393,4 +401,9 @@ export async function importMaildir(database, root, { log = () => {}, legacyRoot
   database.setMetadata('maildir_import', result);
   log(`mail import complete: ${result.messages} envelopes, ${result.records} operational records, ${result.skipped} retained unreadable sources; ${work.source_reads} source reads, ${work.source_bytes} bytes, ${work.committed_batches} batches in ${work.elapsed_ms} ms`);
   return result;
+  } catch (error) {
+    if (error.code !== 'mail_import_yield') throw error;
+    flush();
+    return { complete: false, yielded: true, progress: database.metadata('maildir_resume'), elapsed_ms: Math.round(performance.now() - began) };
+  }
 }

package/mail/import-progress.mjs

@@ -32,10 +32,11 @@ export class ImportProgress {
     if (kept && !same(binding, kept)) throw new Error('mail import progress belongs to a different snapshot');
     if (!kept) this.database.setMetadata('maildir_resume_root', binding);
 
-    // A refused input must still be repairable. Revisit its directory and every
-    // enclosing iterator that might otherwise skip that directory entirely.
+    // A refused input must still be repairable. Retained historical diagnostics
+    // are not refused input: resetting their directories on every bounded call
+    // can keep an orphan claim's large directory from ever finishing.
     const retry = new Set();
-    for (const { source } of this.database.statement('SELECT source FROM mail_import_errors').all()) {
+    for (const { source } of this.database.statement("SELECT source FROM mail_import_errors WHERE NOT (source LIKE 'sent/%/log.jsonl' OR detail = 'claim has no imported message')").all()) {
       if (typeof source !== 'string' || isAbsolute(source) || !resolve(this.root, source).startsWith(this.root + sep)) {
         throw new Error('mail import error record is outside its snapshot');
       }

package/mail/migration-readiness.mjs

@@ -76,6 +76,27 @@ function endpointChild(pid, seed, before, after) {
   return children.length === 1 ? children[0] : null;
 }
 
+async function completedEndpoint(pid, before, after) {
+  // A restored Maildir can have lost a bootstrap record while its pane and
+  // native server are still alive. The wrapper writes that record before it
+  // starts its remote TUI, then never writes it again. Observe both stable
+  // children instead of mistaking a missing record for unfinished publication.
+  const servers = [...after].filter(([child, row]) => row.parent === pid && same(before.get(child), row)
+    && / app-server --listen unix:\/\/\S+$/.test(row.command));
+  if (servers.length !== 1) return null;
+  const server = servers[0], socketPath = / app-server --listen unix:\/\/(\S+)$/.exec(server[1].command)[1];
+  if (!isAbsolute(socketPath)) return null;
+  const endpoint = `unix://${socketPath}`;
+  const remote = new RegExp(`(?:^|\\s)--remote(?:\\s+|=)${endpoint.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\s|$)`);
+  const clients = [...after].filter(([child, row]) => child !== server[0] && row.parent === pid
+    && same(before.get(child), row) && remote.test(row.command));
+  if (clients.length !== 1) return null;
+  let socket;
+  try { socket = await stat(socketPath); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  return socket?.isSocket() ? { endpoint_pid: server[0], endpoint_birth: server[1].birth,
+    client_pid: clients[0][0], client_birth: clients[0][1].birth, publication: 'stable_native_children' } : null;
+}
+
 /** Checks only the wrapper boundary, without opening SQLite or moving files. */
 export async function inspectLegacyMaildir(root) {
   root = resolve(root);
@@ -121,6 +142,8 @@ export async function inspectLegacyMaildir(root) {
     const binding = wrapperBinding(current);
     if (binding === false) { block(name, pid, 'legacy wrapper arguments cannot be read unambiguously'); continue; }
     if (binding !== path) { result.stale.push({ seed: name, pid, reason: 'current process does not name this legacy binding' }); continue; }
+    const completed = await completedEndpoint(pid, before, after);
+    if (completed) { result.live.push({ seed: name, pid, birth: current.birth, ...completed }); continue; }
     if (seed.kind !== 'codex' || typeof seed.socketPath !== 'string' || !isAbsolute(seed.socketPath)) {
       block(name, pid, 'legacy endpoint publication is incomplete'); continue;
     }
@@ -148,8 +171,14 @@ export async function inspectLegacyMaildir(root) {
     }
     if (!binding?.startsWith(directory + sep)) continue;
     const item = seeds.get(binding);
+    if (same(before.get(pid), after.get(pid)) && !result.live.some(entry => entry.pid === pid)) {
+      const completed = await completedEndpoint(pid, before, after);
+      if (completed) result.live.push({ seed: item?.name ?? basename(binding), pid, birth: row.birth,
+        seed_present: Boolean(item), ...completed });
+    }
     if (!same(before.get(pid), after.get(pid)) || item?.seed?.ownerPid !== pid
-      || !result.live.some((entry) => entry.pid === pid && entry.seed === item.name)) {
+      || !result.live.some((entry) => entry.pid === pid && entry.seed === (item?.name ?? basename(binding)))) {
+      if (same(before.get(pid), after.get(pid)) && result.live.some(entry => entry.pid === pid && entry.publication === 'stable_native_children')) continue;
       block(item?.name ?? basename(binding), pid, 'legacy wrapper has not completed endpoint publication');
     }
   }

package/mail/reconcile-maildir.mjs

@@ -0,0 +1,290 @@
+// Explicit offline recovery selects current legacy operational state. Historical
+// envelopes are unioned without overwriting a current envelope or its read state.
+// Old operational revisions and damaged bytes remain in their original stores.
+import { DatabaseSync } from 'node:sqlite';
+import { isDeepStrictEqual } from 'node:util';
+import { createHash, randomUUID } from 'node:crypto';
+import { lstat, mkdir, open, readFile, readdir, rename, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { MailDatabase, MailOwner } from './sqlite.mjs';
+import { importMaildir } from './import-maildir.mjs';
+import { verifyImportedMaildir } from './retire-maildir.mjs';
+import { requireLegacyMaildirReady } from './migration-readiness.mjs';
+import { blake3Hex } from './envelope.mjs';
+import { fileStamp, requireRecoverySource } from './recovery-source.mjs';
+
+const stat = async path => { try { return await lstat(path); } catch (error) { if (error.code === 'ENOENT') return null; throw error; } };
+const json = async path => { try { return JSON.parse(await readFile(path, 'utf8')); } catch (error) { if (error.code === 'ENOENT') return null; throw error; } };
+const identity = value => value && ({ device: value.dev, inode: value.ino });
+const same = (a, b) => isDeepStrictEqual(a, b);
+const alive = pid => { if (!Number.isSafeInteger(pid) || pid < 1) return false; try { process.kill(pid, 0); return true; } catch (error) { return error.code !== 'ESRCH'; } };
+const save = async (path, value) => {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify(value) + '\n', { mode: 0o600 });
+  await rename(temporary, path);
+};
+
+// A caller may leave during restoration too. Copy bounded chunks into an owned
+// temporary file; only a complete, synced copy replaces the canonical database.
+async function restoreOriginal(journal, journalPath, suffix, deadline) {
+  const original = join(journal.directory, `failed-mail.sqlite${suffix}`);
+  const source = await stat(original);
+  if (!source) return true;
+  if (!source.isFile()) throw new Error('retained recovery database is not a regular file');
+  const path = join(journal.home, `mail.sqlite${suffix}`), temporary = `${path}.${journal.id}.restore.tmp`;
+  journal.restart_files ??= {};
+  let progress = journal.restart_files[suffix];
+  if (progress && !same(progress.source, fileStamp(source))) throw new Error('retained recovery database changed during restoration');
+  if (progress && (!Number.isSafeInteger(progress.offset) || progress.offset < 0 || progress.offset > source.size)) throw new Error('recovery database restoration has an invalid cursor');
+  if (progress?.complete) return true;
+  if (!progress || !await stat(temporary)) {
+    progress = journal.restart_files[suffix] = { source: fileStamp(source), offset: 0 };
+    await save(journalPath, journal);
+  }
+  const input = await open(original, 'r');
+  let output;
+  try {
+    output = await open(temporary, await stat(temporary) ? 'r+' : 'w+', 0o600);
+    await output.truncate(progress.offset);
+    const buffer = Buffer.allocUnsafe(1 << 20);
+    while (progress.offset < source.size && performance.now() < deadline) {
+      const { bytesRead } = await input.read(buffer, 0, Math.min(buffer.length, source.size - progress.offset), progress.offset);
+      if (!bytesRead) throw new Error('retained recovery database ended during restoration');
+      let written = 0;
+      while (written < bytesRead) {
+        const { bytesWritten } = await output.write(buffer, written, bytesRead - written, progress.offset + written);
+        if (!bytesWritten) throw new Error('recovery database restoration made no progress');
+        written += bytesWritten;
+      }
+      progress.offset += bytesRead;
+    }
+    await output.sync();
+  } finally { await input.close(); await output?.close(); }
+  if (!same(fileStamp(await stat(original)), progress.source)) throw new Error('retained recovery database changed during restoration');
+  if (progress.offset === source.size) {
+    await rename(temporary, path);
+    progress.complete = true;
+  }
+  await save(journalPath, journal);
+  return progress.complete === true;
+}
+
+async function offline(teamsHome, root) {
+  const serving = await json(join(teamsHome, 'machine.json'));
+  if (alive(serving?.pid)) throw new Error('mail recovery requires the machine daemon stopped through its owner; it stops no process');
+  // The guard admits only wrappers whose endpoint publication has finished.
+  // Those panes use the native socket and do not write the Maildir again.
+  // A pending publisher still refuses recovery, without closing its pane.
+  await requireLegacyMaildirReady(root);
+}
+
+function envelope(database, mailbox, value, state, report) {
+  if (!/^sc:[^:\s]+:[^:\s]+:\S+$/.test(mailbox) || !value || typeof value !== 'object'
+    || !/^[A-Za-z0-9_-]+$/.test(value.id) || !Number.isSafeInteger(value.created_at_ms) || typeof value.body !== 'string') {
+    throw new Error('historical envelope cannot be decoded without loss; original stores retained');
+  }
+  const { body, ...header } = value;
+  const existing = database.statement('SELECT header, body FROM messages WHERE mailbox = ? AND id = ?').get(mailbox, value.id);
+  if (existing) {
+    if (!same(JSON.parse(existing.header), header) || existing.body !== body) throw new Error(`conflicting historical envelope ${value.id}; original stores retained`);
+    report.matched_messages++;
+    return;
+  }
+  if (!database.statement('SELECT 1 FROM mailboxes WHERE address = ?').get(mailbox)) {
+    const harness = mailbox.split(':')[2].replace(/[^A-Za-z0-9-]/g, '_');
+    database.statement('INSERT INTO mailboxes(address, folder) VALUES (?, ?)').run(mailbox, `${harness}-${blake3Hex(mailbox).slice(0, 24)}`);
+  }
+  // A historical PID/token never authorizes a resumed claim. Preserve unread
+  // mail as unread, and leave the original claim receipt in the old archive.
+  database.statement(`INSERT INTO messages(mailbox, id, thread, sender, kind, subject, created_at_ms, state, header, body, first_line, read_at_ms)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(mailbox, value.id, value.thread ?? value.id, value.from ?? '', value.kind ?? 'peer', value.subject ?? null,
+    value.created_at_ms, state === 'cur' ? 'cur' : 'new', JSON.stringify(header), body, Array.from(body.split('\n', 1)[0]).slice(0, 400).join(''), state === 'cur' ? value.created_at_ms : null);
+  report.restored_messages++;
+}
+
+/** Each invocation makes bounded resumable work, reserving time for the CLI,
+ * source checks and durable journal publication. No automatic install
+ * selects a store; --prefer-live-maildir is an explicit operator choice. */
+export async function reconcileMaildir(teamsHome, { apply = false, preferLiveMaildir = false, restart = false } = {}) {
+  teamsHome = resolve(teamsHome);
+  const home = dirname(teamsHome), root = join(home, 'mail'), base = join(home, 'mail-recovery'), journalPath = join(base, 'current.json');
+  let journal = await json(journalPath);
+  if (restart && !apply) throw new Error('mail recover --restart requires --apply --prefer-live-maildir');
+  if (!apply) return { stage: 'mail_recovery', policy: 'prefer-live-maildir', requires_offline: true, journal,
+    live_maildir: Boolean(await stat(root)), failed_sqlite: Boolean(await stat(join(home, 'mail.sqlite'))) };
+  if (!preferLiveMaildir) throw new Error('mail recover --apply requires --prefer-live-maildir; no store was selected');
+  await offline(teamsHome, root);
+  const owner = new MailOwner(join(home, 'mail-owner.sqlite'));
+  let database, restarted = false;
+  try {
+    if (journal?.home && journal.home !== home) throw new Error('mail recovery journal belongs to another home');
+    if (journal && (!/^[0-9a-f-]{36}$/.test(journal.id) || journal.directory !== join(base, journal.id) || journal.root !== root || journal.candidate !== join(journal.directory, 'recovered.sqlite')
+      || dirname(resolve(journal.archive)) !== join(home, 'mail-retired') || journal.recovered_archive !== join(home, 'mail-retired', `recovered-${journal.id}`))) throw new Error('mail recovery journal contains paths outside its owned home');
+    if ((restart || journal?.state === 'restarting') && journal) {
+      if (!same(identity(await stat(root)), journal.live_identity)) throw new Error('restart requires the selected original Maildir still at its live path');
+      if (journal.state === 'publish') {
+        if (await stat(join(journal.directory, 'failed-mail.sqlite'))) {
+          // Publication may have moved the old database before caller loss.
+          // Restore it through the same resumable path used by a prepared home.
+          journal.state = 'restarting';
+          await save(journalPath, journal);
+        } else if (!await stat(journal.candidate)) {
+          throw new Error('interrupted recovery cannot locate its retained original database');
+        }
+        // Before any move the canonical database is still the old one, and
+        // the candidate can simply remain with the abandoned journal.
+      }
+      if (['complete', 'restarting'].includes(journal.state)) {
+        if (journal.state === 'complete') {
+          const reader = new MailDatabase(join(home, 'mail.sqlite'));
+          let retirement;
+          try { retirement = reader.metadata('maildir_retirement'); } finally { reader.close(); }
+          if (retirement?.complete || retirement?.explicit_recovery !== journal.id) throw new Error('activated recovery cannot be abandoned');
+          journal.state = 'restarting';
+          await save(journalPath, journal);
+        }
+        const restoreDeadline = performance.now() + 2000;
+        for (const suffix of ['', '-wal', '-shm']) {
+          const path = join(home, `mail.sqlite${suffix}`), abandoned = join(journal.directory, `abandoned-mail.sqlite${suffix}`);
+          if (!await stat(abandoned) && await stat(path)) await rename(path, abandoned);
+          if (!await restoreOriginal(journal, journalPath, suffix, restoreDeadline)) return journal;
+        }
+      }
+      journal.state = 'abandoned'; journal.abandoned_at_ms = Date.now();
+      await save(journalPath, journal);
+      await rename(journalPath, join(journal.directory, 'abandoned.json'));
+      journal = null; restarted = true;
+    }
+    if (journal?.state === 'complete') {
+      const reader = new MailDatabase(join(home, 'mail.sqlite'));
+      try {
+        if (!reader.metadata('maildir_retirement')?.complete) await requireRecoverySource(reader, root);
+      } finally { reader.close(); }
+      return journal;
+    }
+    if (!journal) {
+      const reader = new DatabaseSync(join(home, 'mail.sqlite'), { readOnly: true });
+      let retirement;
+      try { retirement = JSON.parse(reader.prepare("SELECT value FROM mail_metadata WHERE key = 'maildir_retirement'").get()?.value ?? 'null'); }
+      finally { reader.close(); }
+      if (!retirement || retirement.source !== root || !retirement.archive || dirname(resolve(retirement.archive)) !== join(home, 'mail-retired')) throw new Error('mail recovery requires this home’s existing migration receipt');
+      const live = await stat(root), archived = await stat(retirement.archive);
+      if (!live?.isDirectory() || !archived?.isDirectory()) throw new Error('mail recovery requires both regular Maildir stores; originals retained');
+      if (retirement.inode != null && !same(identity(archived), { device: retirement.device, inode: retirement.inode })) throw new Error('retired Maildir differs from its ownership receipt');
+      const id = randomUUID(), directory = join(base, id);
+      await mkdir(directory, { recursive: true, mode: 0o700 });
+      journal = { version: 1, id, home, directory, state: 'import', root, archive: retirement.archive, live_identity: identity(live), archive_identity: identity(archived),
+        recovered_archive: join(home, 'mail-retired', `recovered-${id}`), candidate: join(directory, 'recovered.sqlite'),
+        historical: [{ directory: '', last: '' }], matched_messages: 0, restored_messages: 0, operational_revisions: 0, conflicts: [], sql_cursor: ['', ''] };
+      await save(journalPath, journal);
+      // Restoration and a fresh import each get their own bounded invocation.
+      if (restarted) return journal;
+    }
+    if (!/^[0-9a-f-]{36}$/.test(journal.id) || journal.directory !== join(base, journal.id) || journal.root !== root || journal.candidate !== join(journal.directory, 'recovered.sqlite')
+      || dirname(resolve(journal.archive)) !== join(home, 'mail-retired') || journal.recovered_archive !== join(home, 'mail-retired', `recovered-${journal.id}`)) throw new Error('mail recovery journal contains paths outside its owned home');
+    if (!same(identity(await stat(journal.archive)), journal.archive_identity)) throw new Error('historical Maildir changed identity during recovery');
+    if (journal.state !== 'publish' && !same(identity(await stat(root)), journal.live_identity)) throw new Error('selected Maildir changed identity during recovery');
+    if (journal.state !== 'publish') {
+      database = new MailDatabase(journal.candidate);
+      database.statement('CREATE TABLE IF NOT EXISTS mail_recovery_revisions(source TEXT PRIMARY KEY, old_sha256 TEXT NOT NULL, live_sha256 TEXT)').run();
+    }
+    const phase = journal.state;
+    const deadline = performance.now() + 4500;
+    if (journal.state === 'import') {
+      const imported = await importMaildir(database, root, { budgetMs: 4500 });
+      journal.import = imported;
+      if (imported.complete) {
+        const unsafe = database.statement("SELECT source FROM mail_import_errors WHERE NOT (source LIKE 'sent/%/log.jsonl' OR detail = 'claim has no imported message') LIMIT 1").get();
+        if (unsafe) throw new Error(`mail recovery cannot lose unreadable input ${unsafe.source}; originals retained`);
+        journal.state = 'verify';
+      }
+    } else if (journal.state === 'verify') {
+      const verified = await verifyImportedMaildir(database, root, { after: journal.verified_after ?? '', budgetMs: 4500, rememberStamps: true });
+      journal.verified_after = verified.cursor;
+      if (verified.complete) journal.state = 'archive';
+    } else if (journal.state === 'archive') {
+      while (journal.historical.length && performance.now() < deadline) {
+        const group = journal.historical.at(-1), directory = join(journal.archive, group.directory);
+        const entries = (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        let exhausted = true;
+        for (const entry of entries) {
+          if (entry.name <= group.last) continue;
+          if (performance.now() >= deadline) { exhausted = false; break; }
+          const relative = join(group.directory, entry.name), path = join(journal.archive, relative);
+          if (entry.isDirectory()) { group.last = entry.name; journal.historical.push({ directory: relative, last: '' }); exhausted = false; break; }
+          if (entry.isFile()) {
+            const parts = relative.split(/[/\\]/);
+            if (parts.length === 3 && ['new', 'cur', 'claimed'].includes(parts[1]) && entry.name.endsWith('.json')) {
+              const address = (await readFile(join(journal.archive, parts[0], 'address'), 'utf8')).trim();
+              envelope(database, address, await json(path), parts[1], journal);
+            } else {
+              const current = await stat(join(root, relative));
+              if (current && !current.isFile()) throw new Error(`historical operational input ${relative} changed record type; originals retained`);
+              const previousBytes = await readFile(path), currentBytes = current ? await readFile(join(root, relative)) : null;
+              if (!currentBytes || !previousBytes.equals(currentBytes)) {
+                journal.operational_revisions++;
+                const revision = { source: relative, selected: 'live-maildir', old_sha256: createHash('sha256').update(previousBytes).digest('hex'), live_sha256: currentBytes ? createHash('sha256').update(currentBytes).digest('hex') : null };
+                database.statement('INSERT OR REPLACE INTO mail_recovery_revisions(source, old_sha256, live_sha256) VALUES (?, ?, ?)').run(relative, revision.old_sha256, revision.live_sha256);
+                if (journal.conflicts.length < 20) journal.conflicts.push(revision);
+              }
+            }
+          } else if (!entry.isSocket()) throw new Error(`historical input ${relative} is not a regular record; originals retained`);
+          group.last = entry.name;
+        }
+        if (exhausted) journal.historical.pop();
+      }
+      if (!journal.historical.length) journal.state = 'sqlite';
+    } else if (journal.state === 'sqlite') {
+      const legacy = new DatabaseSync(join(home, 'mail.sqlite'), { readOnly: true });
+      try {
+        const rows = legacy.prepare('SELECT mailbox, id, header, body, state FROM messages WHERE (mailbox, id) > (?, ?) ORDER BY mailbox, id LIMIT 256');
+        while (performance.now() < deadline) {
+          const batch = rows.all(...journal.sql_cursor);
+          if (!batch.length) { journal.state = 'publish'; break; }
+          for (const row of batch) {
+            if (performance.now() >= deadline) break;
+            if (row.body == null) {
+              const current = database.statement('SELECT header FROM messages WHERE mailbox = ? AND id = ?').get(row.mailbox, row.id);
+              if (!current || !same(JSON.parse(current.header), JSON.parse(row.header))) throw new Error(`bodyless historical envelope ${row.id} is absent or conflicting; originals retained`);
+            } else envelope(database, row.mailbox, { ...JSON.parse(row.header), body: row.body }, row.state, journal);
+            journal.sql_cursor = [row.mailbox, row.id];
+          }
+          // Comparison is read-only apart from restoring missing envelopes.
+          // Persist its cursor between batches so caller loss cannot discard
+          // the whole invocation's progress.
+          await save(journalPath, journal);
+        }
+      } finally { legacy.close(); }
+      if (journal.state === 'publish') {
+        database.setMetadata('maildir_import', { ...database.metadata('maildir_import'), messages: database.statement('SELECT count(*) AS count FROM messages').get().count });
+        database.setMetadata('maildir_retirement', { version: 2, source: root, archive: journal.recovered_archive, ...journal.live_identity,
+          complete: false, originals_retained: true, explicit_recovery: journal.id });
+        database.setMetadata('maildir_recovery', { policy: 'prefer-live-maildir', prepared: true, historical_maildir: journal.archive, historical_database: join(journal.directory, 'failed-mail.sqlite'), at_ms: Date.now() });
+        database.statement('PRAGMA wal_checkpoint(TRUNCATE)').get();
+      }
+    }
+    database?.close(); database = null;
+    await save(journalPath, journal);
+    // Publication has its own invocation: its full source-stamp check must
+    // not share the preceding comparison's work budget.
+    if (journal.state === 'publish' && phase !== 'sqlite') {
+      await offline(teamsHome, root);
+      const path = await stat(journal.candidate) ? journal.candidate : join(home, 'mail.sqlite');
+      const reader = new MailDatabase(path);
+      try { await requireRecoverySource(reader, root); } finally { reader.close(); }
+      // The journal precedes every move. Re-running after interruption finishes
+      // the same moves; no old database or Maildir is deleted or overwritten.
+      for (const suffix of ['', '-wal', '-shm']) {
+        const from = join(home, `mail.sqlite${suffix}`), to = join(journal.directory, `failed-mail.sqlite${suffix}`);
+        if (!await stat(to) && await stat(from)) await rename(from, to);
+      }
+      if (await stat(journal.candidate)) await rename(journal.candidate, join(home, 'mail.sqlite'));
+      // The old unit and the retained predecessor still have a populated
+      // Maildir. Only candidate activation retires it, after its checkpoint.
+      if (!same(identity(await stat(root)), journal.live_identity) || !await stat(join(home, 'mail.sqlite'))) throw new Error('recovery publication cannot locate its live Maildir or prepared database');
+      journal.state = 'complete'; journal.completed_at_ms = Date.now();
+      await save(journalPath, journal);
+    }
+    return journal;
+  } finally { database?.close(); owner.close(); }
+}

package/mail/recovery-source.mjs

@@ -0,0 +1,51 @@
+// Recovery prepares SQLite while the readable legacy tree stays in place.
+// Admission and retirement recheck the exact files the offline door verified.
+import { lstatSync } from 'node:fs';
+import { isDeepStrictEqual } from 'node:util';
+import { isAbsolute, resolve, sep } from 'node:path';
+
+export const fileStamp = value => ({ device: value.dev, inode: value.ino,
+  size: value.size, mtime: value.mtimeMs, ctime: value.ctimeMs });
+const inspect = path => { try { return lstatSync(path); } catch (error) { if (error.code === 'ENOENT') return null; throw error; } };
+
+function inside(root, relative) {
+  const path = resolve(root, relative);
+  if (isAbsolute(relative) || (path !== root && !path.startsWith(root + sep))) throw new Error('recovery source receipt is outside its Maildir');
+  return path;
+}
+
+function requireDirectories(database, root) {
+  for (const row of database.statement("SELECT key, value FROM mail_metadata WHERE key LIKE 'maildir_directory:%'").iterate()) {
+    const saved = JSON.parse(row.value), path = inside(root, row.key.slice('maildir_directory:'.length));
+    const current = inspect(path);
+    if (saved.stamp === null && current === null) continue;
+    if (!current?.isDirectory() || !saved.stamp) throw new Error('selected Maildir directory changed; use mail recover --restart while offline');
+    const stamp = { device: current.dev, inode: current.ino, mtime: current.mtimeMs, ctime: current.ctimeMs };
+    const expected = { ...saved.stamp };
+    // Retirement and rollback rename this same root inode. Those renames change
+    // its ctime, not its entries; root mtime and every child/file stamp still
+    // detect a writer. Nested directories are never renamed by this protocol.
+    if (path === root) { delete stamp.ctime; delete expected.ctime; }
+    if (!current.isDirectory() || !isDeepStrictEqual(stamp, expected)) throw new Error('selected Maildir changed after verification; use mail recover --restart while offline');
+  }
+}
+
+/** Recheck every verified file and directory in the admission worker. A new, removed
+ * or replaced entry during the file pass invalidates the whole observation. */
+export async function requireRecoverySource(database, root) {
+  root = resolve(root);
+  requireDirectories(database, root);
+  let count = 0;
+  for (const row of database.statement('SELECT source, stamp FROM mail_recovery_sources').iterate()) {
+    // This pass reads metadata only. Scheduling a promise and filesystem job
+    // for each of a large home's files put the prepared admission back over
+    // its deadline. Direct observations keep every exact stamp check while
+    // avoiding those 128,000 asynchronous jobs and their batch barriers.
+    const current = inspect(inside(root, row.source));
+    if (!current?.isFile() || !isDeepStrictEqual(fileStamp(current), JSON.parse(row.stamp))) throw new Error(`verified source changed: ${row.source}; use mail recover --restart while offline`);
+    count++;
+  }
+  if (count !== database.statement('SELECT count(*) AS count FROM mail_import_sources').get().count) throw new Error('recovery has unverified input; publication refused');
+  requireDirectories(database, root);
+  return count;
+}

package/mail/retire-maildir.mjs

@@ -7,13 +7,26 @@ import { createHash, randomUUID } from 'node:crypto';
 import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
 import { importMaildir } from './import-maildir.mjs';
 import { requireLegacyMaildirReady } from './migration-readiness.mjs';
+import { fileStamp, requireRecoverySource } from './recovery-source.mjs';
+import { isDeepStrictEqual } from 'node:util';
 
 const stat = async (path) => {
   try { return await lstat(path); }
   catch (error) { if (error.code === 'ENOENT') return null; throw error; }
 };
 
-export async function verifyImportedMaildir(database, root) {
+export async function verifyImportedMaildir(database, root, { after = '', budgetMs = null, rememberStamps = false } = {}) {
+  const began = performance.now();
+  if (rememberStamps) database.statement('CREATE TABLE IF NOT EXISTS mail_recovery_sources(source TEXT PRIMARY KEY, stamp TEXT NOT NULL)').run();
+  const stamps = [];
+  const flushStamps = () => {
+    if (!stamps.length) return;
+    database.transaction(() => {
+      const insert = database.statement('INSERT OR REPLACE INTO mail_recovery_sources(source, stamp) VALUES (?, ?)');
+      for (const [source, stamp] of stamps) insert.run(source, stamp);
+    });
+    stamps.length = 0;
+  };
   for (const { key, value } of database.statement("SELECT key, value FROM mail_metadata WHERE key LIKE 'maildir_directory:%'").all()) {
     const saved = JSON.parse(value), path = resolve(root, key.slice('maildir_directory:'.length));
     if (path !== root && !path.startsWith(root + sep)) throw new Error('mail import directory receipt is outside its source');
@@ -22,11 +35,12 @@ export async function verifyImportedMaildir(database, root) {
     if (JSON.stringify(saved.stamp) !== JSON.stringify(stamp)) throw new Error(`mail source directory changed before retirement: ${path}`);
   }
   const sources = database.statement('SELECT source, sha256 FROM mail_import_sources WHERE source > ? ORDER BY source LIMIT 256');
-  let cursor = '';
+  let cursor = after;
   for (;;) {
     const batch = sources.all(cursor);
-    if (!batch.length) return;
+    if (!batch.length) { flushStamps(); return { complete: true, cursor }; }
     for (const row of batch) {
+      if (budgetMs != null && performance.now() - began >= budgetMs) { flushStamps(); return { complete: false, cursor }; }
       const path = resolve(root, row.source);
       if (isAbsolute(row.source) || !path.startsWith(root + sep)) throw new Error('an imported source is outside its Maildir');
       let parent = dirname(path);
@@ -34,10 +48,18 @@ export async function verifyImportedMaildir(database, root) {
         if (!(await stat(parent))?.isDirectory()) throw new Error(`mail source directory changed before retirement: ${row.source}`);
         parent = dirname(parent);
       }
-      if (!(await stat(path))?.isFile()) throw new Error(`mail source changed before retirement: ${row.source}`);
+      const before = await stat(path);
+      if (!before?.isFile()) throw new Error(`mail source changed before retirement: ${row.source}`);
       const hash = createHash('sha256');
       for await (const bytes of createReadStream(path)) hash.update(bytes);
       if (hash.digest('hex') !== row.sha256) throw new Error(`mail source bytes changed before retirement: ${row.source}`);
+      if (rememberStamps) {
+        const current = await stat(path);
+        if (!current?.isFile() || !isDeepStrictEqual(fileStamp(before), fileStamp(current))) throw new Error(`mail source changed during verification: ${row.source}`);
+        stamps.push([row.source, JSON.stringify(fileStamp(current))]);
+        if (stamps.length === 256) flushStamps();
+      }
+      cursor = row.source;
     }
     cursor = batch.at(-1).source;
   }
@@ -55,6 +77,25 @@ export async function migrateMaildir(database, root, { log = () => {}, committed
     database.setMetadata('maildir_retirement', retirement);
   }
   if (retirement.source !== root) throw new Error('the mail migration source differs from its stored receipt');
+  if (!retirement.complete && retirement.explicit_recovery && database.metadata('maildir_recovery')?.prepared === true) {
+    const archive = resolve(retirement.archive);
+    if (dirname(archive) !== resolve(dirname(root), 'mail-retired') || !source?.isDirectory() || await stat(archive)) throw new Error('prepared recovery requires its original live Maildir and unused archive');
+    await requireLegacyMaildirReady(root);
+    await requireRecoverySource(database, root);
+    await rename(root, archive);
+    try {
+      await requireRecoverySource(database, archive);
+      if (await stat(root)) throw new Error('a writer recreated the Maildir during recovery activation; both stores retained');
+    }
+    catch (error) {
+      if (!await stat(root)) await rename(archive, root);
+      throw error;
+    }
+    const original = await stat(archive);
+    database.setMetadata('maildir_retirement', { ...retirement, inode: original.ino, device: original.dev, complete: true, completed_at_ms: Date.now() });
+    log(`prepared recovery retired at activation; original Maildir retained at ${archive}`);
+    return database.metadata('maildir_import');
+  }
   if (retirement.complete) {
     if (source && !committed) throw new Error(`the retired Maildir was recreated at ${root}; it is retained, and this daemon will not choose between two mail stores`);
     if (source) log(`committed SQLite mailbox remains serving; recreated legacy records at ${root} are retained for explicit recovery`);

package/mail/upgrade-readiness.mjs

@@ -4,17 +4,32 @@
 import { DatabaseSync } from 'node:sqlite';
 import { lstat } from 'node:fs/promises';
 import { join, dirname, resolve } from 'node:path';
-import { MailDatabase } from './sqlite.mjs';
+import { MailDatabase, MAIL_SCHEMA_VERSION } from './sqlite.mjs';
 import { importMaildir } from './import-maildir.mjs';
 import { requireLegacyMaildirReady } from './migration-readiness.mjs';
 import { verifyImportedMaildir } from './retire-maildir.mjs';
 import { requireSessionIndexRuntime } from '../session-index-owner.mjs';
+import { requireRecoverySource } from './recovery-source.mjs';
 
 const exists = async (path) => {
   try { return await lstat(path); }
   catch (error) { if (error.code === 'ENOENT') return null; throw error; }
 };
 
+async function preparedAdmission(database, home, root, guard) {
+  const retirement = database.metadata('maildir_retirement');
+  if (retirement?.complete || !retirement?.explicit_recovery || database.metadata('maildir_recovery')?.prepared !== true
+    || database.metadata('schema_version') !== MAIL_SCHEMA_VERSION) return null;
+  if (retirement.source !== root) throw new Error('mail migration source differs from its stored receipt');
+  if (!retirement.archive || dirname(resolve(retirement.archive)) !== resolve(home, 'mail-retired')) throw new Error('migration snapshot is outside this home');
+  if (!(await exists(root))?.isDirectory() || await exists(retirement.archive)) throw new Error('prepared recovery no longer has its original live Maildir');
+  await requireRecoverySource(database, root);
+  const imported = database.metadata('maildir_import');
+  return { version: 1, stage: 'upgrade_admission', admitted: true, home,
+    messages: imported.messages, records: imported.records, retained_diagnostics: imported.skipped,
+    legacy_wrappers: guard.live.length, schema: database.metadata('schema_version'), prepared_recovery: retirement.explicit_recovery };
+}
+
 export async function inspectUpgradeReadiness(teamsHome, directory) {
   requireSessionIndexRuntime();
   // Resolve all daemon modules before admission, without starting its carrier,
@@ -29,6 +44,23 @@ export async function inspectUpgradeReadiness(teamsHome, directory) {
     if (await exists(live)) {
       const reader = new DatabaseSync(live, { readOnly: true });
       try {
+        // This release's offline recovery has already applied its schema and
+        // verified every input. Inspect that prepared state in one read-only
+        // SQLite transaction; it needs no speculative writable database copy.
+        reader.exec('BEGIN');
+        if (reader.prepare("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name = 'mail_metadata'").get()) {
+          const statements = new Map();
+          const view = { statement(sql) {
+            if (!statements.has(sql)) statements.set(sql, reader.prepare(sql));
+            return statements.get(sql);
+          }, metadata(key) {
+            const row = this.statement('SELECT value FROM mail_metadata WHERE key = ?').get(key);
+            return row ? JSON.parse(row.value) : null;
+          } };
+          const prepared = await preparedAdmission(view, home, root, guard);
+          if (prepared) return prepared;
+        }
+        reader.exec('ROLLBACK');
         // SQLite creates a coherent snapshot, including committed WAL pages;
         // copying the db/WAL files independently cannot establish that.
         reader.prepare('VACUUM INTO ?').run(candidate);
@@ -37,9 +69,11 @@ export async function inspectUpgradeReadiness(teamsHome, directory) {
     database = new MailDatabase(candidate);
     const retirement = database.metadata('maildir_retirement');
     const source = await exists(root);
-    let input = root;
     if (retirement?.source && retirement.source !== root) throw new Error('mail migration source differs from its stored receipt');
     if (retirement?.archive && dirname(resolve(retirement.archive)) !== resolve(home, 'mail-retired')) throw new Error('migration snapshot is outside this home');
+    const prepared = await preparedAdmission(database, home, root, guard);
+    if (prepared) return prepared;
+    let input = root;
     if (retirement?.archive && await exists(retirement.archive)) {
       if (source) throw new Error('both the original migration snapshot and a recreated Maildir exist; explicit recovery is required before activation');
       input = retirement.archive;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.191",
+  "version": "0.3.193",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",

package/terminal-mail.mjs

@@ -1,5 +1,6 @@
 // Per-recipient terminal mailbox. A retained paste is never repeated: retries
-// press Enter and look for the exact user message in the native transcript.
+// press Enter and look for the exact message in the native transcript (a user row, or the queued_command
+// attachment a running Claude Code turn absorbs it as).
 import { statSync, openSync, readSync, closeSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
@@ -52,7 +53,16 @@ function claudeHolds(batch, shown, owned = false) {
   return batch.placeholder === placeholder[0];
 }
 
-function confirmed(batch) {
+/** Whether Claude Code recorded `text` as the prompt `wanted`. Claude records a large paste in a native
+ *  `<pasted_content>` envelope; its whole body is compared, with line-ending and outer-whitespace normalization. */
+function claudeSame(text, wanted) {
+  const native = normalized(text), want = normalized(wanted);
+  if (native === want) return true;
+  const pasted = /^<pasted_content id="([0-9a-f]{4})">\n([\s\S]*)\n<\/pasted_content id="\1">$/u.exec(native);
+  return Boolean(pasted) && normalized(pasted[2]) === want;
+}
+
+export function confirmed(batch) {
   let fd;
   try { fd = openSync(batch.path, 'r'); } catch (error) { if (error.code === 'ENOENT') return false; throw error; }
   try {
@@ -68,6 +78,12 @@ function confirmed(batch) {
       while ((end = buffered.indexOf('\n')) >= 0) {
         const line = buffered.slice(0, end); buffered = buffered.slice(end + 1);
         let row; try { row = JSON.parse(line); } catch { continue; }
+        // A prompt submitted while a turn runs is queued, and reaches the model as a `queued_command` attachment when
+        // the turn absorbs it (queue-operation remove, reason absorbed_mid_turn); no `user` row is written for it.
+        // That attachment is its delivery. An enqueue alone is not: a queued prompt can still be withdrawn.
+        if (batch.kind === 'claude-code' && row.type === 'attachment' && row.attachment?.type === 'queued_command'
+          && row.isSidechain !== true && (!batch.sessionId || row.sessionId === batch.sessionId)
+          && typeof row.attachment.prompt === 'string' && claudeSame(row.attachment.prompt, batch.text)) return { fragments: 1 };
         const content = batch.kind === 'codex' && row.type === 'response_item' && row.payload?.type === 'message' && row.payload.role === 'user'
           ? row.payload.content : batch.kind === 'claude-code' && row.type === 'user' && !row.isMeta && (!batch.sessionId || row.sessionId === batch.sessionId)
             ? row.message?.content : batch.kind === 'grok' && row.type === 'user' ? row.content : null;
@@ -75,13 +91,7 @@ function confirmed(batch) {
         if (text === null || text.length === 0) continue;
         if (text === batch.text) return { fragments: 1 };
         if (batch.kind === 'claude-code') {
-          const native = normalized(text), wanted = normalized(batch.text);
-          if (native === wanted) return { fragments: 1 };
-          // Claude records a large paste in this native envelope. Compare its
-          // whole body with matching identifiers, using the existing line-ending
-          // and outer-whitespace normalization.
-          const pasted = /^<pasted_content id="([0-9a-f]{4})">\n([\s\S]*)\n<\/pasted_content id="\1">$/u.exec(native);
-          if (pasted && normalized(pasted[2]) === wanted) return { fragments: 1 };
+          if (claudeSame(text, batch.text)) return { fragments: 1 };
           continue;
         }
         // A Windows Codex is pasted its text with line ends as `\n` (codexWindowsPastes).