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

package/src/dlq.ts

@@ -1,216 +0,0 @@
-// Dead-letter queue — machine-local (state dir), never committed.
-// A message that fails dispatch gets an entry; repeated failures inside
-// the window quarantine it so a poison message can't spin the dispatcher.
-// `crosstalk dlq --retry <id>` rewinds the cursor and clears the flag.
-
-import {
-  readdirSync,
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-  existsSync,
-  unlinkSync,
-} from 'fs';
-import { resolve, join, dirname } from 'path';
-import { pathToFileURL } from 'url';
-import { spawnSync } from 'child_process';
-import { now } from './filenames.js';
-import { serializeFrontmatter, parseFrontmatter } from './frontmatter.js';
-import { stateDir, cursorPath } from './state.js';
-
-const QUARANTINE_THRESHOLD_ATTEMPTS = 4;
-const QUARANTINE_WINDOW_MS = 60 * 60 * 1000; // 1 hour
-
-export interface DlqEntry {
-  id: string;
-  actor: string;
-  channel: string;
-  messageRelPath: string;
-  attempts: number;
-  quarantined: boolean;
-  firstFailedAt: string;
-  lastFailedAt: string;
-  error: string;
-}
-
-function dlqDir(transportRoot: string): string {
-  return join(stateDir(transportRoot), 'dlq');
-}
-
-function findEntry(
-  transportRoot: string,
-  actor: string,
-  channel: string,
-  messageRelPath: string,
-): { id: string; path: string; entry: DlqEntry } | null {
-  const dir = dlqDir(transportRoot);
-  if (!existsSync(dir)) return null;
-  for (const f of readdirSync(dir).filter((x) => x.endsWith('.md'))) {
-    const path = join(dir, f);
-    try {
-      const { data } = parseFrontmatter<DlqEntry>(readFileSync(path, 'utf-8'));
-      if (data.actor === actor && data.channel === channel && data.messageRelPath === messageRelPath) {
-        return { id: f.replace(/\.md$/, ''), path, entry: data };
-      }
-    } catch { /* skip unparseable */ }
-  }
-  return null;
-}
-
-export function isQuarantined(
-  transportRoot: string,
-  actor: string,
-  channel: string,
-  messageRelPath: string,
-): boolean {
-  return findEntry(transportRoot, actor, channel, messageRelPath)?.entry.quarantined ?? false;
-}
-
-export function writeDlqEntry(
-  transportRoot: string,
-  actor: string,
-  channelUuid: string,
-  messageRelPath: string,
-  error: string,
-): { id: string; attempts: number; quarantined: boolean } {
-  const dir = dlqDir(transportRoot);
-  mkdirSync(dir, { recursive: true });
-
-  const existing = findEntry(transportRoot, actor, channelUuid, messageRelPath);
-  const lastFailedAt = new Date().toISOString();
-
-  if (existing) {
-    const attempts = (existing.entry.attempts ?? 1) + 1;
-    const ageMs = Date.now() - new Date(existing.entry.firstFailedAt).getTime();
-    const quarantined =
-      existing.entry.quarantined ||
-      (attempts >= QUARANTINE_THRESHOLD_ATTEMPTS && ageMs < QUARANTINE_WINDOW_MS);
-    const updated: DlqEntry = {
-      ...existing.entry,
-      attempts,
-      lastFailedAt,
-      error: error.slice(0, 500),
-      quarantined,
-    };
-    writeFileSync(existing.path, serializeFrontmatter(updated as unknown as Record<string, unknown>, error));
-    return { id: existing.id, attempts, quarantined };
-  }
-
-  const ts = now();
-  const id = `${ts.fileTime}-${ts.hex}`;
-  const entry: DlqEntry = {
-    id,
-    actor,
-    channel: channelUuid,
-    messageRelPath,
-    attempts: 1,
-    quarantined: false,
-    firstFailedAt: ts.iso,
-    lastFailedAt,
-    error: error.slice(0, 500),
-  };
-  writeFileSync(join(dir, `${id}.md`), serializeFrontmatter(entry as unknown as Record<string, unknown>, error));
-  return { id, attempts: 1, quarantined: false };
-}
-
-export function countDlqEntries(transportRoot: string): { total: number; quarantined: number } {
-  const dir = dlqDir(transportRoot);
-  if (!existsSync(dir)) return { total: 0, quarantined: 0 };
-  let total = 0;
-  let quarantined = 0;
-  for (const f of readdirSync(dir).filter((x) => x.endsWith('.md'))) {
-    try {
-      const { data } = parseFrontmatter<DlqEntry>(readFileSync(join(dir, f), 'utf-8'));
-      total++;
-      if (data.quarantined) quarantined++;
-    } catch { /* skip */ }
-  }
-  return { total, quarantined };
-}
-
-// ── CLI entry point ──
-
-const isEntry = process.argv[1] ? import.meta.url === pathToFileURL(process.argv[1]).href : false;
-
-if (isEntry) {
-  const transportRoot = resolve(process.cwd());
-  const argv = process.argv.slice(2);
-  const flag = (name: string): string | undefined => {
-    const i = argv.indexOf(name);
-    return i === -1 || i === argv.length - 1 ? undefined : argv[i + 1];
-  };
-
-  const show = flag('--show');
-  const retryId = flag('--retry');
-  const clear = argv.includes('--clear');
-  const dir = dlqDir(transportRoot);
-
-  if (show) {
-    const path = join(dir, `${show}.md`);
-    if (!existsSync(path)) {
-      console.error(`No DLQ entry: ${show}`);
-      process.exit(1);
-    }
-    console.log(readFileSync(path, 'utf-8'));
-  } else if (clear) {
-    const files = existsSync(dir) ? readdirSync(dir).filter((f) => f.endsWith('.md')) : [];
-    for (const f of files) unlinkSync(join(dir, f));
-    console.log(`Cleared ${files.length} DLQ entries`);
-  } else if (retryId) {
-    const path = join(dir, `${retryId}.md`);
-    if (!existsSync(path)) {
-      console.error(`No DLQ entry: ${retryId}`);
-      process.exit(1);
-    }
-    const { data } = parseFrontmatter<DlqEntry>(readFileSync(path, 'utf-8'));
-    const cursorFile = cursorPath(transportRoot, data.actor, data.channel);
-
-    // Find the commit that introduced the failed message and rewind to its
-    // parent. This ensures the next dispatch tick re-sees the message.
-    // Fallback: if git log fails, wipe the cursor so a full re-scan runs
-    // (less targeted but still recovers the message).
-    const relPath = `data/channels/${data.channel}/${data.messageRelPath}`;
-    const logResult = spawnSync('git', ['log', '--format=%H', '-1', '--', relPath], {
-      cwd: transportRoot,
-      encoding: 'utf-8',
-    });
-    const msgCommit = logResult.status === 0 ? logResult.stdout.trim() : '';
-    let rewindTo = '';
-    if (msgCommit) {
-      const parentResult = spawnSync('git', ['rev-parse', `${msgCommit}^`], {
-        cwd: transportRoot,
-        encoding: 'utf-8',
-      });
-      if (parentResult.status === 0) rewindTo = parentResult.stdout.trim();
-    }
-
-    mkdirSync(dirname(cursorFile), { recursive: true });
-    writeFileSync(cursorFile, rewindTo ? rewindTo + '\n' : '');
-
-    if (data.quarantined) {
-      data.quarantined = false;
-      writeFileSync(path, serializeFrontmatter(data as unknown as Record<string, unknown>, data.error));
-    }
-    const rewindDesc = rewindTo ? rewindTo.slice(0, 12) : 'start (full re-scan)';
-    console.log(`Retried ${retryId}: cursor for ${data.actor}@${data.channel.slice(0, 8)} rewound to ${rewindDesc}; quarantine cleared.`);
-    console.log('  Entry kept — re-evaluated on next dispatch tick.');
-  } else {
-    const files = existsSync(dir) ? readdirSync(dir).filter((f) => f.endsWith('.md')).sort() : [];
-    let quarantinedCount = 0;
-    const rows: string[] = [];
-    for (const f of files) {
-      try {
-        const { data } = parseFrontmatter<DlqEntry>(readFileSync(join(dir, f), 'utf-8'));
-        if (data.quarantined) quarantinedCount++;
-        rows.push(
-          `  ${f.replace(/\.md$/, '')}${data.quarantined ? ' [QUARANTINED]' : ''}\n` +
-          `    actor=${data.actor} channel=${data.channel.slice(0, 8)} msg=${data.messageRelPath}\n` +
-          `    attempts=${data.attempts} first=${data.firstFailedAt} last=${data.lastFailedAt}\n` +
-          `    error=${(data.error || '').slice(0, 80)}`,
-        );
-      } catch { /* skip */ }
-    }
-    console.log(`DLQ entries: ${rows.length} (${quarantinedCount} quarantined)`);
-    for (const row of rows) console.log(row);
-  }
-}

package/src/filenames.ts

@@ -1,28 +0,0 @@
-import { randomBytes } from 'crypto';
-
-export interface Timestamp {
-  iso: string;
-  pathDate: string;
-  fileTime: string;
-  hex: string;
-}
-
-export function now(): Timestamp {
-  const d = new Date();
-  const iso = d.toISOString();
-  const yyyy = iso.slice(0, 4);
-  const mm = iso.slice(5, 7);
-  const dd = iso.slice(8, 10);
-  const time = iso.slice(11, 13) + iso.slice(14, 16) + iso.slice(17, 19);
-  const ms = iso.slice(20, 23);
-  return {
-    iso,
-    pathDate: `${yyyy}/${mm}/${dd}`,
-    fileTime: `${time}${ms}Z`,
-    hex: randomBytes(4).toString('hex'),
-  };
-}
-
-export function messageFilename(ts: Timestamp = now()): string {
-  return `${ts.fileTime}-${ts.hex}.md`;
-}

package/src/frontmatter.ts

@@ -1,26 +0,0 @@
-import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
-
-export interface ParsedDocument<T = Record<string, unknown>> {
-  data: T;
-  body: string;
-}
-
-export function parseFrontmatter<T = Record<string, unknown>>(raw: string): ParsedDocument<T> {
-  if (!raw.startsWith('---')) return { data: {} as T, body: raw };
-  const lines = raw.split('\n');
-  let end = -1;
-  for (let i = 1; i < lines.length; i++) {
-    if (lines[i].trim() === '---') { end = i; break; }
-  }
-  if (end === -1) return { data: {} as T, body: raw };
-  const yamlBlock = lines.slice(1, end).join('\n');
-  const body = lines.slice(end + 1).join('\n').replace(/^\n/, '');
-  const data = (parseYaml(yamlBlock) as T) ?? ({} as T);
-  return { data, body };
-}
-
-export function serializeFrontmatter(data: Record<string, unknown>, body: string): string {
-  const yaml = stringifyYaml(data).trimEnd();
-  const trailing = body.endsWith('\n') ? '' : '\n';
-  return `---\n${yaml}\n---\n\n${body}${trailing}`;
-}

package/src/init.ts

@@ -1,138 +0,0 @@
-// crosstalk init <directory> — scaffold a new transport.
-//
-// Copies the bundled transport template (spec, agent pointer files, default
-// actor profiles), then adds a host file for this machine and a first
-// channel. No state directories — machine state lives outside the repo
-// (state.ts) and is created on demand.
-//
-// Template lookup order:
-//   1. <runtime_root>/template/      — bundled at publish time (production)
-//   2. <runtime_root>/../transport/  — monorepo layout (local dev)
-
-import { existsSync, mkdirSync, writeFileSync, cpSync, renameSync } from 'fs';
-import { resolve, join, dirname } from 'path';
-import { hostname as osHostname } from 'os';
-import { randomUUID } from 'crypto';
-import { fileURLToPath } from 'url';
-
-const argv = process.argv.slice(2);
-const force = argv.includes('--force');
-
-const positional = argv.filter((a) => !a.startsWith('--'));
-if (positional.length === 0) {
-  console.error('Usage: crosstalk init <directory> [--force]');
-  console.error('       crosstalk init .                  (scaffold into current dir)');
-  process.exit(1);
-}
-
-const targetDir = resolve(positional[0]!);
-
-if (existsSync(join(targetDir, 'upstream', 'CROSSTALK-VERSION')) && !force) {
-  console.error(`crosstalk init: ${targetDir} already contains a transport.`);
-  console.error('Pass --force to overwrite.');
-  process.exit(1);
-}
-
-const runtimeRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const candidates = [
-  join(runtimeRoot, 'template'),
-  join(runtimeRoot, '..', 'transport'),
-];
-const templateDir = candidates.find((c) => existsSync(join(c, 'upstream', 'CROSSTALK-VERSION')));
-
-if (!templateDir) {
-  console.error('crosstalk init: cannot find the transport template.');
-  console.error('Looked in:');
-  for (const c of candidates) console.error(`  ${c}`);
-  console.error('The @cordfuse/crosstalk installation may be corrupted; try reinstalling.');
-  process.exit(1);
-}
-
-mkdirSync(targetDir, { recursive: true });
-cpSync(templateDir, targetDir, {
-  recursive: true,
-  force,
-  filter: (src) => !src.endsWith('/transport/README.md') && !src.endsWith('\\transport\\README.md'),
-});
-// npm strips .gitignore from published packages; the template ships it as
-// `gitignore` and we rename it here.
-const gitignoreSrc = join(targetDir, 'gitignore');
-const gitignoreDst = join(targetDir, '.gitignore');
-if (existsSync(gitignoreSrc)) renameSync(gitignoreSrc, gitignoreDst);
-
-const hostname = osHostname();
-const hostsDir = join(targetDir, 'hosts');
-mkdirSync(hostsDir, { recursive: true });
-const hostPath = join(hostsDir, `${hostname}.md`);
-if (!existsSync(hostPath) || force) {
-  writeFileSync(
-    hostPath,
-    `---
-alias: ${hostname}
-hostname: ${hostname}
-actors:
-  concierge:
-    claude:
-      cli: claude --print --dangerously-skip-permissions
----
-
-Host file for ${hostname}. One actor (concierge) on Claude Code by default.
-Add more actors as you need them; declare each tier under its CLI invocation.
-
-To give an actor multiple parallel slots (e.g. 10 junior-developer instances
-each picking up messages independently), use \`count: N\` under the tier:
-
-    actors:
-      junior-developer:
-        haiku:
-          cli: claude --model claude-haiku-4-5 --print --dangerously-skip-permissions
-          count: 10
-`,
-  );
-}
-
-const chId = randomUUID();
-const channelDir = join(targetDir, 'data', 'channels', chId);
-mkdirSync(channelDir, { recursive: true });
-const channelMd = join(channelDir, 'CHANNEL.md');
-if (!existsSync(channelMd) || force) {
-  writeFileSync(
-    channelMd,
-    `---
-name: general
-created_by: ${process.env['USER'] || 'operator'}
-created_at: ${new Date().toISOString()}
----
-
-General channel. First channel of this transport.
-`,
-  );
-}
-
-const readmePath = join(targetDir, 'README.md');
-if (!existsSync(readmePath) || force) {
-  writeFileSync(
-    readmePath,
-    `# Transport
-
-A Crosstalk transport created by \`crosstalk init\`.
-
-- Spec: \`upstream/CROSSTALK.md\`
-- Agent orientation: \`upstream/PROTOCOL.md\`
-- Your custom actor profiles: \`local/actors/\`
-- Host configuration for this machine: \`hosts/${hostname}.md\`
-`,
-  );
-}
-
-console.log('');
-console.log(`Transport initialized at ${targetDir}`);
-console.log(`  host file:           hosts/${hostname}.md`);
-console.log(`  first channel UUID:  ${chId}`);
-console.log('');
-console.log('Next steps:');
-console.log(`  cd ${targetDir}`);
-console.log('  git init && git add -A && git commit -m "initial transport"');
-console.log('  crosstalk status         # verify scaffold');
-console.log('  crosstalk dispatch       # run the dispatch loop on this machine');
-console.log('  crosstalk send --to concierge "hello"   # first message');

package/src/open.ts

@@ -1,207 +0,0 @@
-// crosstalk open — interactive session with an actor, spawning its CLI
-// locally on every turn. Needs the actor's CLI installed and authed on
-// this machine; does not use any dispatcher (and must not run while one
-// is processing this transport — the two would race).
-//
-// Each turn: log the operator's message to the channel, spawn the actor's
-// CLI with the composed system prompt (PROTOCOL.md + actor profile), log
-// the reply with re: pointing at the operator's message, commit + push.
-
-import { resolve, join } from 'path';
-import { spawnSync } from 'child_process';
-import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync } from 'fs';
-import { randomUUID } from 'crypto';
-import { createInterface } from 'readline/promises';
-import { findHostFile, loadActorProfile, pickTier, tokenizeCli } from './actor.js';
-import { now, messageFilename } from './filenames.js';
-import { serializeFrontmatter } from './frontmatter.js';
-import { gitCommitAndPush } from './transport.js';
-import { withLock } from './turnq.js';
-import { writeDlqEntry } from './dlq.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];
-}
-
-const actorName = flag('--actor');
-let channelUuid = flag('--channel');
-const hostOverride = flag('--host');
-const operatorName = flag('--as') ?? process.env['USER'] ?? 'operator';
-
-if (!actorName) {
-  console.error('Usage: crosstalk open --actor <name> [--channel <uuid>] [--host <alias>] [--as <name>]');
-  process.exit(1);
-}
-
-const host = findHostFile(transportRoot, hostOverride);
-if (!host.actors[actorName]) {
-  console.error(`Actor '${actorName}' not declared in host file ${host.alias}`);
-  process.exit(1);
-}
-
-if (!channelUuid) {
-  channelUuid = randomUUID();
-  const dir = join(transportRoot, 'data', 'channels', channelUuid);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(
-    join(dir, 'CHANNEL.md'),
-    `---
-name: open-${actorName}-${now().fileTime}
-created_by: ${operatorName}
-created_at: ${new Date().toISOString()}
----
-
-Interactive session channel — \`crosstalk open\` invocation.
-`,
-  );
-  console.log(`(created channel ${channelUuid})`);
-}
-
-const protocolPath = join(transportRoot, 'upstream', 'PROTOCOL.md');
-const localProfilePath = join(transportRoot, 'local', 'actors', `${actorName}.md`);
-const upstreamProfilePath = join(transportRoot, 'upstream', 'actors', `${actorName}.md`);
-
-interface CachedPrompt {
-  systemPrompt: string;
-  protocolMtime: number;
-  profileMtime: number;
-  profilePath: string;
-}
-
-function mtime(p: string): number {
-  try { return statSync(p).mtimeMs; } catch { return 0; }
-}
-
-function loadComposedPrompt(): CachedPrompt {
-  const profile = loadActorProfile(transportRoot, actorName!);
-  const protocolPrompt = existsSync(protocolPath)
-    ? readFileSync(protocolPath, 'utf-8').trim()
-    : '';
-  const systemPrompt = [protocolPrompt, profile.systemPrompt]
-    .filter((p) => p.length > 0)
-    .join('\n\n---\n\n');
-  const profilePath = existsSync(localProfilePath) ? localProfilePath : upstreamProfilePath;
-  return {
-    systemPrompt,
-    protocolMtime: mtime(protocolPath),
-    profileMtime: mtime(profilePath),
-    profilePath,
-  };
-}
-
-let cached = loadComposedPrompt();
-
-function getCurrentSystemPrompt(): string {
-  const currentProtocolMtime = mtime(protocolPath);
-  const currentProfileMtime = mtime(cached.profilePath);
-  if (currentProtocolMtime !== cached.protocolMtime || currentProfileMtime !== cached.profileMtime) {
-    console.log('(reloaded actor profile + PROTOCOL.md after detected mtime change)\n');
-    cached = loadComposedPrompt();
-  }
-  return cached.systemPrompt;
-}
-
-const { cli } = pickTier(host.actors[actorName]!);
-
-function logToChannel(from: string, to: string, body: string, re?: string): string {
-  const ts = now();
-  const dir = join(transportRoot, 'data', 'channels', channelUuid!, ts.pathDate);
-  mkdirSync(dir, { recursive: true });
-  const frontmatter: Record<string, unknown> = { from, to, type: 'text', timestamp: ts.iso };
-  if (re) frontmatter['re'] = re;
-  const filename = messageFilename(ts);
-  writeFileSync(join(dir, filename), serializeFrontmatter(frontmatter, body));
-  return `${ts.pathDate}/${filename}`;
-}
-
-async function commitTurn(): Promise<void> {
-  const r = await withLock(transportRoot, 'git', async () =>
-    gitCommitAndPush(
-      transportRoot,
-      `open: ${operatorName} <-> ${actorName} in ${channelUuid!.slice(0, 8)}`,
-    ),
-  );
-  if (!r.ok && r.error) {
-    const kind = r.committed ? 'push' : 'commit';
-    console.error(`(${kind} failed: ${r.error.slice(0, 200)} — turn is local-only)`);
-  }
-}
-
-console.log(`crosstalk open — actor=${actorName} channel=${channelUuid.slice(0, 8)}`);
-console.log('Type a message and press Enter. Ctrl-C or Ctrl-D to exit.');
-console.log('');
-
-async function main(): Promise<void> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-
-  try {
-    while (true) {
-      let userMsg: string;
-      try {
-        userMsg = await rl.question(`${operatorName}> `);
-      } catch {
-        break;
-      }
-      if (userMsg === undefined || userMsg === null) break;
-      const trimmed = userMsg.trim();
-      if (!trimmed) continue;
-
-      const userMsgRelPath = logToChannel(operatorName, actorName!, trimmed);
-
-      const fullPrompt = `${getCurrentSystemPrompt()}\n\n---\n\n${trimmed}`;
-      const parts = tokenizeCli(cli);
-      if (parts.length === 0) {
-        console.error('\n[open] tokenized cli is empty — check host file\n');
-        continue;
-      }
-      const result = spawnSync(parts[0]!, parts.slice(1), {
-        input: fullPrompt,
-        encoding: 'utf-8',
-        timeout: 5 * 60_000,
-        env: {
-          ...process.env,
-          CROSSTALK_DISPATCH_ACTOR: actorName!,
-          CROSSTALK_DISPATCH_CHANNEL: channelUuid!,
-          CROSSTALK_DISPATCH_RE: userMsgRelPath,
-        },
-      });
-
-      if (result.status !== 0) {
-        const r = writeDlqEntry(
-          transportRoot,
-          actorName!,
-          channelUuid!,
-          userMsgRelPath,
-          `cli exit=${result.status} (open mode)\n${(result.stderr || '').slice(0, 1000)}`,
-        );
-        const quarantineMark = r.quarantined ? ' [QUARANTINED]' : '';
-        console.error(`\n[cli exit=${result.status} → dlq:${r.id}${quarantineMark}] ${(result.stderr || '').slice(0, 200)}\n`);
-        await commitTurn();
-        continue;
-      }
-
-      const reply = (result.stdout || '').trim();
-      if (reply.length === 0) {
-        // Legitimate: the actor may have routed its answer via `crosstalk
-        // send` (re: auto-linked from the env above). Not a failure.
-        console.log(`(${actorName} replied silently — check the channel)\n`);
-        await commitTurn();
-        continue;
-      }
-
-      console.log(`${actorName}> ${reply}\n`);
-      logToChannel(actorName!, operatorName, reply, userMsgRelPath);
-      await commitTurn();
-    }
-  } finally {
-    rl.close();
-  }
-  process.exit(0);
-}
-
-main();

package/src/replies.ts

@@ -1,59 +0,0 @@
-// crosstalk replies — have my messages been answered yet?
-//
-// Checks each given relPath for a message whose `re:` points back at it.
-// This replaces v5's read-receipt machinery: instead of recipients writing
-// "I saw it" markers into the channel, the asker just looks for actual
-// replies. Exit 0 when everything is answered, 2 while anything is pending
-// — so agents can poll cheaply in a loop.
-
-import { resolve } from 'path';
-import { gitPull, discoverChannels, listChannelMessages } from './transport.js';
-import { reList } from './activation.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];
-}
-
-const reArg = flag('--re');
-const channelArg = flag('--channel') ?? process.env['CROSSTALK_DISPATCH_CHANNEL'];
-
-if (!reArg) {
-  console.error('Usage: crosstalk replies --re <relPath[,relPath...]> [--channel <uuid>]');
-  process.exit(1);
-}
-
-const targets = reArg.split(',').map((s) => s.trim()).filter(Boolean);
-
-gitPull(transportRoot); // best-effort freshness; a failed pull just means slightly stale answers
-
-const channels = channelArg ? [channelArg] : discoverChannels(transportRoot);
-
-// target relPath -> reply found
-const found = new Map<string, { from: string; relPath: string }>();
-for (const channel of channels) {
-  for (const msg of listChannelMessages(transportRoot, channel)) {
-    for (const entry of reList(msg.data['re'])) {
-      if (targets.includes(entry) && !found.has(entry)) {
-        found.set(entry, { from: String(msg.data['from']), relPath: msg.relPath });
-      }
-    }
-  }
-}
-
-let pending = 0;
-for (const target of targets) {
-  const reply = found.get(target);
-  if (reply) {
-    console.log(`REPLIED  ${target}  <- ${reply.from} (${reply.relPath})`);
-  } else {
-    console.log(`PENDING  ${target}`);
-    pending++;
-  }
-}
-
-process.exit(pending > 0 ? 2 : 0);