@cordfuse/crosstalk 6.0.0-alpha.9 → 7.0.0-alpha.2

package/src/send.ts

@@ -1,122 +0,0 @@
-// crosstalk send — write a message into a channel and push it.
-//
-// `re:` is the whole activation story (CROSSTALK.md "Activation"):
-// inside a dispatched turn, CROSSTALK_DISPATCH_RE carries the relPath(s)
-// of the message(s) being answered (comma-separated for a batch), and
-// send links them all automatically. `--new` suppresses that — the
-// message becomes a fresh task and wakes its addressee unconditionally.
-// Operators (no env) always send new tasks.
-
-import { resolve, join } from 'path';
-import { mkdirSync, writeFileSync, existsSync } from 'fs';
-import { now, messageFilename } from './filenames.js';
-import { serializeFrontmatter } from './frontmatter.js';
-import { gitCommitAndPush, discoverChannels } from './transport.js';
-import { withLock } from './turnq.js';
-import { sendWakeSignal } from './state.js';
-
-const transportRoot = resolve(process.cwd());
-const argv = process.argv.slice(2);
-
-function flag(name: string): string | undefined {
-  const i = argv.indexOf(name);
-  if (i === -1 || i === argv.length - 1) return undefined;
-  return argv[i + 1];
-}
-
-async function main(): Promise<void> {
-  let channelUuid = flag('--channel') ?? process.env['CROSSTALK_DISPATCH_CHANNEL'];
-  const to = flag('--to');
-  const from = flag('--from')
-    ?? process.env['CROSSTALK_DISPATCH_ACTOR']
-    ?? process.env['USER']
-    ?? 'operator';
-  const tier = flag('--tier');
-  const isNew = argv.includes('--new');
-  const body = argv[argv.length - 1];
-
-  if (!to || !body || body.startsWith('--')) {
-    console.error(
-      'Usage: crosstalk send --to <actor[,actor...]> [--channel <uuid>] [--from <actor>] [--tier <name>] [--new] "<message body>"',
-    );
-    process.exit(1);
-  }
-
-  if (!channelUuid) {
-    const channels = discoverChannels(transportRoot);
-    if (channels.length === 1) {
-      channelUuid = channels[0]!;
-    } else if (channels.length === 0) {
-      console.error('crosstalk send: no channels found. Create one with: crosstalk channel create <name>');
-      process.exit(1);
-    } else {
-      console.error(`crosstalk send: multiple channels found — specify one with --channel <uuid>`);
-      console.error(`  Run 'crosstalk status' to list channel UUIDs.`);
-      process.exit(1);
-    }
-  }
-
-  // Warn when --to names an actor@host whose host file isn't in the transport
-  // yet. The dispatcher's high-water-mark seeds past any commit before the
-  // host file landed, so messages to an un-provisioned host are silently
-  // skipped on first boot. Surfacing this here turns the silent drop into an
-  // operator-visible error before the message is even written.
-  const recipients = to.split(',').map((s) => s.trim()).filter(Boolean);
-  for (const recipient of recipients) {
-    const at = recipient.indexOf('@');
-    if (at === -1) continue;
-    const host = recipient.slice(at + 1);
-    const hostPath = join(transportRoot, 'hosts', `${host}.md`);
-    if (!existsSync(hostPath)) {
-      console.error(
-        `crosstalk send: WARNING — no host file at hosts/${host}.md. ` +
-          `Messages addressed to '${recipient}' will be skipped by that host ` +
-          `until hosts/${host}.md is committed to the transport.`,
-      );
-    }
-  }
-
-  const reTargets = (isNew ? '' : process.env['CROSSTALK_DISPATCH_RE'] ?? '')
-    .split(',')
-    .map((s) => s.trim())
-    .filter(Boolean);
-
-  const ts = now();
-  const dir = join(transportRoot, 'data', 'channels', channelUuid, ts.pathDate);
-  mkdirSync(dir, { recursive: true });
-
-  const frontmatter: Record<string, unknown> = {
-    from,
-    to: to.includes(',') ? to.split(',').map((s) => s.trim()).filter(Boolean) : to,
-    type: 'text',
-    timestamp: ts.iso,
-  };
-  if (reTargets.length === 1) frontmatter['re'] = reTargets[0];
-  else if (reTargets.length > 1) frontmatter['re'] = reTargets;
-  if (tier) frontmatter['tier'] = tier;
-
-  const filename = messageFilename(ts);
-  writeFileSync(join(dir, filename), serializeFrontmatter(frontmatter, body));
-
-  // Lock only the commit+push — the narrow critical section. If the lock
-  // can't be had, git arbitrates anyway (see turnq.ts).
-  const pushResult = await withLock(transportRoot, 'git', async () =>
-    gitCommitAndPush(transportRoot, `send: ${from} -> ${to} in ${channelUuid.slice(0, 8)}`),
-  );
-
-  sendWakeSignal(transportRoot);
-
-  if (!pushResult.ok && pushResult.error) {
-    console.error(`Wrote locally: ${join(ts.pathDate, filename)}`);
-    console.error(`but git ${pushResult.committed ? 'push' : 'commit'} FAILED:`);
-    console.error(`  ${pushResult.error.slice(0, 300)}`);
-    console.error('\nYour message is in the local clone but not on origin. Recover with:');
-    console.error('  git fetch origin && git rebase origin/main && git push');
-    process.exit(3);
-  }
-
-  console.log(`Sent: ${join(ts.pathDate, filename)}${reTargets.length ? ` (re: ${reTargets.join(', ')})` : ''}`);
-  process.exit(0);
-}
-
-main();

package/src/state.ts

@@ -1,173 +0,0 @@
-// Machine-local dispatcher state. NONE of this lives in the transport repo —
-// the repo carries conversation; each machine carries its own progress
-// through it. That separation is what makes the dispatcher's git operations
-// conflict-free: its commits only ever contain data/ (messages).
-//
-// Layout under the state dir:
-//   cursors/<actor>/<channel-uuid>     — last-scanned git commit hash
-//   dlq/<id>.md                        — failed-dispatch entries
-//   errors.log                         — infra failures, JSONL, append-only
-//   heartbeat                          — last tick timestamp + pid + version
-//   dispatcher.pid                     — PID of the running dispatcher process
-//   wake.signal                        — touched to wake the dispatch loop
-//
-// Location: $CROSSTALK_STATE_DIR if set (exact dir — container-friendly),
-// else ~/.local/state/crosstalk/<transport-id> where <transport-id> is a
-// hash of the git origin URL (or the repo path when there is no origin).
-
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-  appendFileSync,
-} from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-import { createHash } from 'crypto';
-import { spawnSync } from 'child_process';
-
-const resolved = new Map<string, string>();
-
-export function stateDir(transportRoot: string): string {
-  const cached = resolved.get(transportRoot);
-  if (cached) return cached;
-  let dir = process.env['CROSSTALK_STATE_DIR'];
-  if (!dir) {
-    const origin = spawnSync('git', ['config', '--get', 'remote.origin.url'], {
-      cwd: transportRoot,
-      encoding: 'utf-8',
-    });
-    const identity = origin.status === 0 && origin.stdout.trim()
-      ? origin.stdout.trim()
-      : transportRoot;
-    const id = createHash('sha256').update(identity).digest('hex').slice(0, 12);
-    dir = join(homedir(), '.local', 'state', 'crosstalk', id);
-  }
-  mkdirSync(dir, { recursive: true });
-  resolved.set(transportRoot, dir);
-  return dir;
-}
-
-// ── cursors ──
-
-// A cursor is the git commit hash the channel was last scanned at. NOT a
-// message relPath: filenames order by sender timestamp, but messages reach
-// origin in PUSH order — a message that loses a push race can land on
-// origin with a timestamp earlier than one already processed, and a
-// relPath cursor would skip it forever. Commit-based cursors can't: a late
-// arrival is always in a new commit. (Found by the Monte Carlo harness.)
-const VALID_CURSOR = /^[0-9a-f]{40}$/;
-
-export function cursorPath(transportRoot: string, actor: string, channelUuid: string): string {
-  return join(stateDir(transportRoot), 'cursors', actor, channelUuid);
-}
-
-export function readCursor(transportRoot: string, actor: string, channelUuid: string): string | null {
-  const p = cursorPath(transportRoot, actor, channelUuid);
-  if (!existsSync(p)) return null;
-  let raw: string;
-  try {
-    raw = readFileSync(p, 'utf-8').trim();
-  } catch (err) {
-    logError(transportRoot, 'fs', `cursor read failed for ${actor}@${channelUuid}: ${(err as Error).message}`);
-    return null;
-  }
-  if (raw.length === 0) return null;
-  if (!VALID_CURSOR.test(raw)) {
-    logError(
-      transportRoot,
-      'parse',
-      `invalid cursor for ${actor}@${channelUuid}: '${raw.slice(0, 80)}' — re-scanning channel from start`,
-    );
-    return null;
-  }
-  return raw;
-}
-
-export function writeCursor(
-  transportRoot: string,
-  actor: string,
-  channelUuid: string,
-  commit: string,
-): void {
-  const p = cursorPath(transportRoot, actor, channelUuid);
-  mkdirSync(dirname(p), { recursive: true });
-  writeFileSync(p, commit + '\n');
-}
-
-// ── pidfile ──
-
-export function pidfilePath(transportRoot: string): string {
-  return join(stateDir(transportRoot), 'dispatcher.pid');
-}
-
-export function writePidfile(transportRoot: string): void {
-  try {
-    writeFileSync(pidfilePath(transportRoot), `${process.pid}\n`);
-  } catch { /* best-effort */ }
-}
-
-export function removePidfile(transportRoot: string): void {
-  try {
-    unlinkSync(pidfilePath(transportRoot));
-  } catch { /* already gone */ }
-}
-
-export function readPidfile(transportRoot: string): number | null {
-  try {
-    const raw = readFileSync(pidfilePath(transportRoot), 'utf-8').trim();
-    const n = parseInt(raw, 10);
-    return Number.isFinite(n) && n > 0 ? n : null;
-  } catch {
-    return null;
-  }
-}
-
-// ── heartbeat + wake ──
-
-export function writeHeartbeat(transportRoot: string, version: string): void {
-  try {
-    const data = { ts: new Date().toISOString(), pid: process.pid, version };
-    writeFileSync(join(stateDir(transportRoot), 'heartbeat'), JSON.stringify(data) + '\n');
-  } catch { /* best-effort */ }
-}
-
-export function readHeartbeat(transportRoot: string): { ts: string; pid: number; version: string } | null {
-  try {
-    return JSON.parse(readFileSync(join(stateDir(transportRoot), 'heartbeat'), 'utf-8'));
-  } catch {
-    return null;
-  }
-}
-
-export function wakeSignalPath(transportRoot: string): string {
-  return join(stateDir(transportRoot), 'wake.signal');
-}
-
-export function sendWakeSignal(transportRoot: string): void {
-  try {
-    writeFileSync(wakeSignalPath(transportRoot), `${Date.now()}\n`);
-  } catch { /* best-effort */ }
-}
-
-// ── error log — infra failures, JSONL append ──
-
-export type ErrorKind = 'git_pull' | 'git_push' | 'git_commit' | 'fs' | 'parse' | 'turnq' | 'other';
-
-export function logError(transportRoot: string, kind: ErrorKind, message: string): void {
-  try {
-    const line = JSON.stringify({ ts: new Date().toISOString(), kind, message: message.slice(0, 500) });
-    appendFileSync(join(stateDir(transportRoot), 'errors.log'), line + '\n');
-  } catch { /* best-effort */ }
-}
-
-export function countErrors(transportRoot: string): number {
-  try {
-    const raw = readFileSync(join(stateDir(transportRoot), 'errors.log'), 'utf-8');
-    return raw.split('\n').filter((l) => l.trim().length > 0).length;
-  } catch {
-    return 0;
-  }
-}

package/src/status.ts

@@ -1,75 +0,0 @@
-// crosstalk status — transport + dispatcher health at a glance.
-
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { resolve, join } from 'path';
-import { findHostFile } from './actor.js';
-import { discoverChannels } from './transport.js';
-import { stateDir, readCursor, readHeartbeat, countErrors } from './state.js';
-import { countDlqEntries } from './dlq.js';
-
-const transportRoot = resolve(process.cwd());
-
-console.log(`Crosstalk transport: ${transportRoot}`);
-console.log(`Machine state dir:   ${stateDir(transportRoot)}`);
-console.log('');
-
-let actorNames: string[] = [];
-try {
-  const host = findHostFile(transportRoot);
-  console.log(`Host file: hosts/${host.alias}.md`);
-  actorNames = Object.keys(host.actors);
-  for (const a of actorNames) {
-    const tierDescs = Object.entries(host.actors[a]!).map(([t, v]) => {
-      const count = typeof v === 'object' && v.count ? `x${v.count}` : '';
-      return `${t}${count}`;
-    });
-    console.log(`  ${a}: ${tierDescs.join(', ')}`);
-  }
-} catch (err) {
-  console.log(`Host file: ERROR — ${(err as Error).message}`);
-}
-
-console.log('');
-
-const hb = readHeartbeat(transportRoot);
-if (hb) {
-  const ageS = Math.floor((Date.now() - new Date(hb.ts).getTime()) / 1000);
-  const label = ageS < 120 ? 'LIVE' : ageS > 300 ? 'STALE' : 'idle';
-  console.log(`dispatch heartbeat: ${label} (pid ${hb.pid}, last tick ${ageS}s ago, ${hb.version})`);
-} else {
-  console.log('dispatch heartbeat: never (no dispatch has run on this machine)');
-}
-
-console.log('');
-
-const channels = discoverChannels(transportRoot);
-console.log(`Channels: ${channels.length}`);
-for (const ch of channels) {
-  const channelDir = join(transportRoot, 'data', 'channels', ch);
-  let name = '(no CHANNEL.md)';
-  const chPath = join(channelDir, 'CHANNEL.md');
-  if (existsSync(chPath)) {
-    const m = readFileSync(chPath, 'utf-8').match(/^name:\s*(.+)$/m);
-    if (m) name = m[1]!.trim();
-  }
-  let msgCount = 0;
-  const walk = (d: string): void => {
-    for (const e of readdirSync(d)) {
-      const p = join(d, e);
-      if (statSync(p).isDirectory()) walk(p);
-      else if (e.endsWith('.md') && e !== 'CHANNEL.md') msgCount++;
-    }
-  };
-  try { walk(channelDir); } catch { /* ignore */ }
-  console.log(`  ${ch.slice(0, 8)}... — ${name} (${msgCount} msgs)`);
-  for (const actor of actorNames) {
-    const cursor = readCursor(transportRoot, actor, ch);
-    if (cursor) console.log(`    cursor[${actor}] -> ${cursor}`);
-  }
-}
-
-console.log('');
-
-const dlq = countDlqEntries(transportRoot);
-console.log(`DLQ entries: ${dlq.total} (${dlq.quarantined} quarantined)`);
-console.log(`Infrastructure errors logged: ${countErrors(transportRoot)}`);

package/src/stop.ts

@@ -1,37 +0,0 @@
-// crosstalk stop — send SIGTERM to the running dispatcher and wait for it to exit.
-
-import { resolve } from 'path';
-import { spawnSync } from 'child_process';
-import { readPidfile, removePidfile } from './state.js';
-
-const transportRoot = resolve(process.cwd());
-
-function processRunning(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-const pid = readPidfile(transportRoot);
-if (pid === null) {
-  console.error('crosstalk stop: no dispatcher.pid found — is dispatch running?');
-  process.exit(1);
-}
-
-if (!processRunning(pid)) {
-  console.error(`crosstalk stop: pid ${pid} is not running — removing stale pidfile`);
-  removePidfile(transportRoot);
-  process.exit(1);
-}
-
-process.kill(pid, 'SIGTERM');
-
-const deadline = Date.now() + 5_000;
-while (Date.now() < deadline) {
-  if (!processRunning(pid)) {
-    console.log(`crosstalk stop: dispatcher (pid ${pid}) stopped`);
-    process.exit(0);
-  }
-  spawnSync('sleep', ['0.1']);
-}
-
-console.error(`crosstalk stop: pid ${pid} did not exit within 5s — try: kill -9 ${pid}`);
-process.exit(1);

package/src/transport.ts

@@ -1,213 +0,0 @@
-// Git transport layer. The dispatcher's commits contain ONLY data/ —
-// machine-local state lives in the state dir (state.ts), so there is
-// nothing to exclude, untrack, or heal. Push rejection means another
-// machine won the race: pull --rebase and retry at the call site.
-
-import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
-import { join } from 'path';
-import { spawnSync } from 'child_process';
-import { parseFrontmatter } from './frontmatter.js';
-import { logError } from './state.js';
-
-export interface ChannelMessage {
-  relPath: string;
-  fullPath: string;
-  data: Record<string, unknown>;
-  body: string;
-}
-
-export interface GitResult {
-  ok: boolean;
-  error?: string;
-}
-
-export interface GitPushResult {
-  ok: boolean;
-  committed: boolean;
-  pushed: boolean;
-  error?: string;
-}
-
-function captureGit(cwd: string, args: string[]): { status: number; stdout: string; stderr: string } {
-  const r = spawnSync('git', args, { cwd, encoding: 'utf-8' });
-  return { status: r.status ?? 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
-}
-
-// Detect and abort an interrupted rebase/merge left by a killed process.
-// Returns true if recovery was performed.
-export function recoverInterruptedGit(transportRoot: string): boolean {
-  const halfStates: { dir: string; abortArgs: string[] }[] = [
-    { dir: '.git/rebase-merge', abortArgs: ['rebase', '--abort'] },
-    { dir: '.git/rebase-apply', abortArgs: ['rebase', '--abort'] },
-    { dir: '.git/MERGE_HEAD', abortArgs: ['merge', '--abort'] },
-    { dir: '.git/CHERRY_PICK_HEAD', abortArgs: ['cherry-pick', '--abort'] },
-  ];
-  for (const { dir, abortArgs } of halfStates) {
-    if (existsSync(join(transportRoot, dir))) {
-      const r = captureGit(transportRoot, abortArgs);
-      logError(
-        transportRoot,
-        'git_pull',
-        `recovered from interrupted git state at ${dir} via 'git ${abortArgs.join(' ')}' (exit=${r.status})`,
-      );
-      return true;
-    }
-  }
-  return false;
-}
-
-// The commit cursors anchor to. Prefer the origin tip: origin history is
-// append-only, so a cursor pointing there can never be orphaned by a local
-// `pull --rebase` rewriting unpushed commits. HEAD is the fallback for
-// transports without a remote.
-export function cursorBaseline(transportRoot: string): string | null {
-  for (const ref of ['origin/HEAD', 'origin/main', 'HEAD']) {
-    const r = captureGit(transportRoot, ['rev-parse', ref]);
-    if (r.status === 0) return r.stdout.trim();
-  }
-  return null;
-}
-
-// Find the commit that introduced this actor's host file. Used to seed
-// the cursor on first boot: messages sent after the host file landed are
-// deliverable (store-and-forward); pre-join history is ignored. Falls back
-// to HEAD if git log fails (conservative: no history replay in that case).
-export function hostFileCommit(transportRoot: string, hostname: string): string | null {
-  const hostPath = `hosts/${hostname}.md`;
-  const r = captureGit(transportRoot, ['log', '--format=%H', '--diff-filter=A', '--', hostPath]);
-  if (r.status !== 0 || !r.stdout.trim()) return null;
-  // `git log` lists newest first; the last line is the introducing commit.
-  const lines = r.stdout.trim().split('\n').filter(Boolean);
-  return lines[lines.length - 1] ?? null;
-}
-
-// Repo-relative paths of message files added between `sinceCommit` and
-// HEAD. Returns null when the commit is unknown to this clone (state dir
-// copied across transports, history rewritten) — caller falls back to a
-// full channel scan.
-export function newFilesSince(transportRoot: string, sinceCommit: string): string[] | null {
-  const r = captureGit(transportRoot, [
-    'diff', '--name-only', '--diff-filter=A', `${sinceCommit}..HEAD`, '--', 'data/channels/',
-  ]);
-  if (r.status !== 0) return null;
-  return r.stdout.split('\n').filter(Boolean);
-}
-
-export function gitPull(transportRoot: string): GitResult {
-  recoverInterruptedGit(transportRoot);
-  const fetch = captureGit(transportRoot, ['fetch', 'origin', '--quiet']);
-  if (fetch.status !== 0) {
-    return { ok: false, error: (fetch.stderr || fetch.stdout).trim().slice(0, 500) };
-  }
-  const rebase = captureGit(transportRoot, ['rebase', 'origin/main']);
-  if (rebase.status !== 0) {
-    return { ok: false, error: (rebase.stderr || rebase.stdout).trim().slice(0, 500) };
-  }
-  return { ok: true };
-}
-
-// Stage data/ only, commit, push. On push rejection, one pull --rebase +
-// re-push — collision-free filenames make the rebase trivially clean.
-export function gitCommitAndPush(transportRoot: string, message: string): GitPushResult {
-  const status = captureGit(transportRoot, ['status', '--porcelain', '--', 'data/']);
-  if (status.status !== 0) {
-    return { ok: false, committed: false, pushed: false, error: status.stderr.trim().slice(0, 500) };
-  }
-  if (!status.stdout.trim()) {
-    return { ok: true, committed: false, pushed: false };
-  }
-
-  const add = captureGit(transportRoot, ['add', '--', 'data/']);
-  if (add.status !== 0) {
-    return { ok: false, committed: false, pushed: false, error: add.stderr.trim().slice(0, 500) };
-  }
-
-  const commit = captureGit(transportRoot, ['commit', '-m', message, '--', 'data/']);
-  if (commit.status !== 0) {
-    const noop = commit.stdout.includes('nothing to commit') ||
-                 commit.stderr.includes('nothing to commit');
-    if (noop) return { ok: true, committed: false, pushed: false };
-    return { ok: false, committed: false, pushed: false, error: commit.stderr.trim().slice(0, 500) };
-  }
-
-  // Push rejection is NORMAL under concurrent writers — git is the
-  // arbiter and collision-free filenames make every rebase clean. Retry
-  // with jitter; many writers racing one origin converge within a few
-  // rounds (verified by the Monte Carlo harness).
-  let push = captureGit(transportRoot, ['push', '--quiet']);
-  for (let attempt = 0; push.status !== 0 && attempt < 5; attempt++) {
-    spawnSync('sleep', [(0.05 + Math.random() * 0.3 * (attempt + 1)).toFixed(2)]);
-    const pull = gitPull(transportRoot);
-    if (!pull.ok) continue;
-    push = captureGit(transportRoot, ['push', '--quiet']);
-  }
-  if (push.status !== 0) {
-    return {
-      ok: false,
-      committed: true,
-      pushed: false,
-      error: (push.stderr || push.stdout).trim().slice(0, 500),
-    };
-  }
-  return { ok: true, committed: true, pushed: true };
-}
-
-export function discoverChannels(transportRoot: string): string[] {
-  const channelsDir = join(transportRoot, 'data', 'channels');
-  if (!existsSync(channelsDir)) return [];
-  let entries: string[];
-  try {
-    entries = readdirSync(channelsDir);
-  } catch (err) {
-    logError(transportRoot, 'fs', `discoverChannels readdir failed on ${channelsDir}: ${(err as Error).message}`);
-    return [];
-  }
-  return entries.filter((name) => {
-    try {
-      return statSync(join(channelsDir, name)).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-}
-
-function isValidMessageFrontmatter(data: Record<string, unknown>): boolean {
-  if (typeof data['from'] !== 'string') return false;
-  if (typeof data['to'] !== 'string' && !Array.isArray(data['to'])) return false;
-  if (typeof data['type'] !== 'string') return false;
-  if (typeof data['timestamp'] !== 'string') return false;
-  return true;
-}
-
-export function listChannelMessages(transportRoot: string, channelUuid: string): ChannelMessage[] {
-  const channelDir = join(transportRoot, 'data', 'channels', channelUuid);
-  if (!existsSync(channelDir)) return [];
-  const results: ChannelMessage[] = [];
-  const walk = (dir: string, prefix: string): void => {
-    for (const entry of readdirSync(dir)) {
-      const full = join(dir, entry);
-      const rel = prefix ? `${prefix}/${entry}` : entry;
-      let stat;
-      try { stat = statSync(full); } catch { continue; }
-      if (stat.isDirectory()) {
-        walk(full, rel);
-      } else if (entry.endsWith('.md') && entry !== 'CHANNEL.md') {
-        const raw = readFileSync(full, 'utf-8');
-        let parsed;
-        try {
-          parsed = parseFrontmatter(raw);
-        } catch (err) {
-          logError(transportRoot, 'parse', `frontmatter parse failed in ${channelUuid}/${rel}: ${(err as Error).message}`);
-          continue;
-        }
-        if (!isValidMessageFrontmatter(parsed.data)) {
-          logError(transportRoot, 'parse', `invalid message frontmatter in ${channelUuid}/${rel}: missing required field(s) (from, to, type, timestamp)`);
-          continue;
-        }
-        results.push({ relPath: rel, fullPath: full, data: parsed.data, body: parsed.body });
-      }
-    }
-  };
-  walk(channelDir, '');
-  return results.sort((a, b) => a.relPath.localeCompare(b.relPath));
-}