@cordfuse/crosstalk 5.0.0-alpha.7 → 6.0.0-alpha.10

package/src/dlq.ts

@@ -1,3 +1,8 @@
+// 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,
@@ -6,22 +11,21 @@ import {
   existsSync,
   unlinkSync,
 } from 'fs';
-import { resolve, join } from 'path';
+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 type DlqKind = 'dispatch' | 'config';
-
 export interface DlqEntry {
   id: string;
-  kind: DlqKind;
   actor: string;
-  channel: string; // "(config)" for kind=config without channel context
-  messageRelPath: string; // "(config)" for kind=config
+  channel: string;
+  messageRelPath: string;
   attempts: number;
   quarantined: boolean;
   firstFailedAt: string;
@@ -29,41 +33,23 @@ export interface DlqEntry {
   error: string;
 }
 
-export interface FoundDlqEntry {
-  id: string;
-  path: string;
-  entry: DlqEntry;
-}
-
-export interface WriteDlqResult {
-  id: string;
-  attempts: number;
-  quarantined: boolean;
-}
-
 function dlqDir(transportRoot: string): string {
-  return join(transportRoot, 'dlq');
+  return join(stateDir(transportRoot), 'dlq');
 }
 
-export function findDlqEntry(
+function findEntry(
   transportRoot: string,
-  kind: DlqKind,
   actor: string,
   channel: string,
   messageRelPath: string,
-): FoundDlqEntry | null {
+): { 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.kind === kind &&
-        data.actor === actor &&
-        data.channel === channel &&
-        data.messageRelPath === messageRelPath
-      ) {
+      if (data.actor === actor && data.channel === channel && data.messageRelPath === messageRelPath) {
         return { id: f.replace(/\.md$/, ''), path, entry: data };
       }
     } catch { /* skip unparseable */ }
@@ -73,49 +59,32 @@ export function findDlqEntry(
 
 export function isQuarantined(
   transportRoot: string,
-  kind: DlqKind,
   actor: string,
   channel: string,
   messageRelPath: string,
 ): boolean {
-  return findDlqEntry(transportRoot, kind, actor, channel, messageRelPath)?.entry.quarantined ?? false;
-}
-
-export function isActorQuarantined(transportRoot: string, actor: string): boolean {
-  // Any config-kind DLQ entry for this actor that's quarantined gates the whole actor.
-  const dir = dlqDir(transportRoot);
-  if (!existsSync(dir)) return false;
-  for (const f of readdirSync(dir).filter((x) => x.endsWith('.md'))) {
-    try {
-      const { data } = parseFrontmatter<DlqEntry>(readFileSync(join(dir, f), 'utf-8'));
-      if (data.kind === 'config' && data.actor === actor && data.quarantined) return true;
-    } catch { /* skip */ }
-  }
-  return false;
+  return findEntry(transportRoot, actor, channel, messageRelPath)?.entry.quarantined ?? false;
 }
 
 export function writeDlqEntry(
   transportRoot: string,
-  kind: DlqKind,
   actor: string,
   channelUuid: string,
   messageRelPath: string,
   error: string,
-): WriteDlqResult {
+): { id: string; attempts: number; quarantined: boolean } {
   const dir = dlqDir(transportRoot);
   mkdirSync(dir, { recursive: true });
 
-  const existing = findDlqEntry(transportRoot, kind, actor, channelUuid, messageRelPath);
+  const existing = findEntry(transportRoot, actor, channelUuid, messageRelPath);
   const lastFailedAt = new Date().toISOString();
 
   if (existing) {
     const attempts = (existing.entry.attempts ?? 1) + 1;
-    const firstFailedAt = existing.entry.firstFailedAt;
-    const ageMs = Date.now() - new Date(firstFailedAt).getTime();
+    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,
@@ -123,10 +92,7 @@ export function writeDlqEntry(
       error: error.slice(0, 500),
       quarantined,
     };
-    writeFileSync(
-      existing.path,
-      serializeFrontmatter(updated as unknown as Record<string, unknown>, error),
-    );
+    writeFileSync(existing.path, serializeFrontmatter(updated as unknown as Record<string, unknown>, error));
     return { id: existing.id, attempts, quarantined };
   }
 
@@ -134,7 +100,6 @@ export function writeDlqEntry(
   const id = `${ts.fileTime}-${ts.hex}`;
   const entry: DlqEntry = {
     id,
-    kind,
     actor,
     channel: channelUuid,
     messageRelPath,
@@ -144,120 +109,108 @@ export function writeDlqEntry(
     lastFailedAt,
     error: error.slice(0, 500),
   };
-  writeFileSync(
-    join(dir, `${id}.md`),
-    serializeFrontmatter(entry as unknown as Record<string, unknown>, error),
-  );
+  writeFileSync(join(dir, `${id}.md`), serializeFrontmatter(entry as unknown as Record<string, unknown>, error));
   return { id, attempts: 1, quarantined: false };
 }
 
-export function deleteDlqEntry(transportRoot: string, id: string): boolean {
-  const path = join(dlqDir(transportRoot), `${id}.md`);
-  if (!existsSync(path)) return false;
-  unlinkSync(path);
-  return true;
-}
-
-function listEntries(transportRoot: string): { id: string; entry: DlqEntry }[] {
+export function countDlqEntries(transportRoot: string): { total: number; quarantined: number } {
   const dir = dlqDir(transportRoot);
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir)
-    .filter((f) => f.endsWith('.md'))
-    .sort()
-    .map((f) => {
-      const raw = readFileSync(join(dir, f), 'utf-8');
-      const { data } = parseFrontmatter<DlqEntry>(raw);
-      return { id: f.replace(/\.md$/, ''), entry: data };
-    });
+  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 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 isEntry = process.argv[1] ? import.meta.url === pathToFileURL(process.argv[1]).href : false;
 
 if (isEntry) {
-  const list = argv.includes('--list');
+  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 (list || (!show && !retryId && !clear && argv.length === 0)) {
-    const entries = listEntries(transportRoot);
-    const quarantinedCount = entries.filter((e) => e.entry.quarantined).length;
-    console.log(`DLQ entries: ${entries.length} (${quarantinedCount} quarantined)`);
-    for (const { id, entry } of entries) {
-      const quarantineMark = entry.quarantined ? ' [QUARANTINED]' : '';
-      console.log(`  ${id}${quarantineMark}`);
-      console.log(`    kind=${entry.kind} actor=${entry.actor} channel=${entry.channel?.slice(0, 8)}`);
-      console.log(`    msg=${entry.messageRelPath}`);
-      console.log(`    error=${(entry.error || '').slice(0, 80)}`);
-      console.log(`    attempts=${entry.attempts}  first=${entry.firstFailedAt}  last=${entry.lastFailedAt}`);
-    }
-  } else if (show) {
-    const path = join(dlqDir(transportRoot), `${show}.md`);
+  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 dir = dlqDir(transportRoot);
-    if (!existsSync(dir)) {
-      console.log('dlq/ does not exist; nothing to clear');
-      process.exit(0);
-    }
-    const files = readdirSync(dir).filter((f) => f.endsWith('.md'));
+    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(dlqDir(transportRoot), `${retryId}.md`);
+    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'));
-    if (data.kind === 'dispatch') {
-      const cursorFile = join(transportRoot, 'cursors', data.actor, `${data.channel}.md`);
-      if (existsSync(cursorFile)) {
-        writeFileSync(cursorFile, '\n');
-      }
-      // Also clear the quarantine flag — otherwise dispatch would skip the
-      // message on the next tick and retry would be a no-op.
-      if (data.quarantined) {
-        data.quarantined = false;
-        writeFileSync(path, serializeFrontmatter(data as unknown as Record<string, unknown>, data.error));
-      }
-      console.log(
-        `Retried DLQ entry ${retryId}. Cursor for ${data.actor}@${data.channel.slice(0, 8)} cleared; quarantine flag reset.`,
-      );
-      console.log(
-        '  (DLQ entry kept — will be re-evaluated on next dispatch. If it fails again, attempts will increment.)',
-      );
-      console.log('  Run: npm run dispatch -- --once  (or wait for next tick)');
-    } else if (data.kind === 'config') {
-      // For config errors: clear the quarantine flag so the actor is retried.
+    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));
-      console.log(
-        `Retried config DLQ entry ${retryId}. Quarantine flag cleared on ${data.actor}.`,
-      );
-      console.log('  Run: npm run dispatch -- --once  (or wait for next tick)');
-    } else {
-      console.error(`Unknown DLQ kind: ${data.kind}`);
-      process.exit(1);
     }
+    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 {
-    console.error(
-      'Usage: npm run dlq -- [--list | --show <id> | --retry <id> | --clear]',
-    );
-    process.exit(1);
+    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/init.ts

@@ -1,17 +1,15 @@
-// crosstalk init <directory> — scaffold a new transport
+// crosstalk init <directory> — scaffold a new transport.
 //
-// Copies the bundled transport template (markdown spec, agent pointer
-// files, default actor profiles) into the target directory, then adds
-// host-specific scaffolding (host file for this machine, first channel,
-// runtime state directories).
+// 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)
+//   1. <runtime_root>/template/      — bundled at publish time (production)
 //   2. <runtime_root>/../transport/  — monorepo layout (local dev)
-//
-// If neither exists, exits with a clear error.
 
-import { existsSync, mkdirSync, writeFileSync, cpSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, cpSync, renameSync } from 'fs';
 import { resolve, join, dirname } from 'path';
 import { hostname as osHostname } from 'os';
 import { randomUUID } from 'crypto';
@@ -27,7 +25,7 @@ if (positional.length === 0) {
   process.exit(1);
 }
 
-const targetDir = resolve(positional[0]);
+const targetDir = resolve(positional[0]!);
 
 if (existsSync(join(targetDir, 'upstream', 'CROSSTALK-VERSION')) && !force) {
   console.error(`crosstalk init: ${targetDir} already contains a transport.`);
@@ -35,9 +33,7 @@ if (existsSync(join(targetDir, 'upstream', 'CROSSTALK-VERSION')) && !force) {
   process.exit(1);
 }
 
-// Locate the bundled transport template.
-const thisFileDir = dirname(fileURLToPath(import.meta.url));
-const runtimeRoot = resolve(thisFileDir, '..');
+const runtimeRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const candidates = [
   join(runtimeRoot, 'template'),
   join(runtimeRoot, '..', 'transport'),
@@ -53,19 +49,17 @@ if (!templateDir) {
 }
 
 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);
 
-// Copy the template, excluding the template's own README.md (operator
-// gets a fresh README, generated below).
-function copyTemplate(): void {
-  cpSync(templateDir!, targetDir, {
-    recursive: true,
-    force,
-    filter: (src) => !src.endsWith('/transport/README.md') && !src.endsWith('\\transport\\README.md'),
-  });
-}
-copyTemplate();
-
-// Host file: per-machine actor declaration.
 const hostname = osHostname();
 const hostsDir = join(targetDir, 'hosts');
 mkdirSync(hostsDir, { recursive: true });
@@ -85,7 +79,7 @@ actors:
 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 add an actor with multiple parallel slots (e.g. 10 junior-developer instances
+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:
@@ -97,7 +91,6 @@ each picking up messages independently), use \`count: N\` under the tier:
   );
 }
 
-// First channel.
 const chId = randomUUID();
 const channelDir = join(targetDir, 'data', 'channels', chId);
 mkdirSync(channelDir, { recursive: true });
@@ -116,15 +109,6 @@ General channel. First channel of this transport.
   );
 }
 
-// Runtime state directories (cursors, dlq, errors) — start empty.
-for (const d of ['cursors', 'dlq', 'errors']) {
-  const dir = join(targetDir, d);
-  mkdirSync(dir, { recursive: true });
-  const keep = join(dir, '.gitkeep');
-  if (!existsSync(keep)) writeFileSync(keep, '');
-}
-
-// Fresh transport README replacing the template's self-description.
 const readmePath = join(targetDir, 'README.md');
 if (!existsSync(readmePath) || force) {
   writeFileSync(
@@ -134,12 +118,9 @@ if (!existsSync(readmePath) || force) {
 A Crosstalk transport created by \`crosstalk init\`.
 
 - Spec: \`upstream/CROSSTALK.md\`
-- Agent orientation: \`upstream/PROTOCOL.md\` and \`upstream/OPERATOR.md\`
+- Agent orientation: \`upstream/PROTOCOL.md\`
 - Your custom actor profiles: \`local/actors/\`
 - Host configuration for this machine: \`hosts/${hostname}.md\`
-
-To run dispatch: \`crosstalk dispatch\`. To chat with deployed actors via your
-preferred agent CLI: \`crosstalk attach\`.
 `,
   );
 }
@@ -153,5 +134,5 @@ 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 dispatch loop locally');
-console.log('  crosstalk attach         # chat with actors via your preferred CLI');
+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,12 +1,22 @@
+// 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 } from 'fs';
+import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync } from 'fs';
 import { randomUUID } from 'crypto';
 import { createInterface } from 'readline/promises';
-import { statSync } from 'fs';
 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());
@@ -21,10 +31,10 @@ function flag(name: string): string | undefined {
 const actorName = flag('--actor');
 let channelUuid = flag('--channel');
 const hostOverride = flag('--host');
-const operatorName = flag('--as') ?? process.env.USER ?? 'steve';
+const operatorName = flag('--as') ?? process.env['USER'] ?? 'operator';
 
 if (!actorName) {
-  console.error('Usage: npm run open -- --actor <name> [--channel <uuid>] [--host <alias>] [--as <name>]');
+  console.error('Usage: crosstalk open --actor <name> [--channel <uuid>] [--host <alias>] [--as <name>]');
   process.exit(1);
 }
 
@@ -46,15 +56,15 @@ created_by: ${operatorName}
 created_at: ${new Date().toISOString()}
 ---
 
-Interactive session channel — \`npm run open\` invocation.
+Interactive session channel — \`crosstalk open\` invocation.
 `,
   );
   console.log(`(created channel ${channelUuid})`);
 }
 
 const protocolPath = join(transportRoot, 'upstream', 'PROTOCOL.md');
-const actorProfilePath = join(transportRoot, 'local', 'actors', `${actorName}.md`);
-const fwActorProfilePath = join(transportRoot, 'upstream', 'actors', `${actorName}.md`);
+const localProfilePath = join(transportRoot, 'local', 'actors', `${actorName}.md`);
+const upstreamProfilePath = join(transportRoot, 'upstream', 'actors', `${actorName}.md`);
 
 interface CachedPrompt {
   systemPrompt: string;
@@ -75,7 +85,7 @@ function loadComposedPrompt(): CachedPrompt {
   const systemPrompt = [protocolPrompt, profile.systemPrompt]
     .filter((p) => p.length > 0)
     .join('\n\n---\n\n');
-  const profilePath = existsSync(actorProfilePath) ? actorProfilePath : fwActorProfilePath;
+  const profilePath = existsSync(localProfilePath) ? localProfilePath : upstreamProfilePath;
   return {
     systemPrompt,
     protocolMtime: mtime(protocolPath),
@@ -96,20 +106,33 @@ function getCurrentSystemPrompt(): string {
   return cached.systemPrompt;
 }
 
-const { cli } = pickTier(host.actors[actorName]);
+const { cli } = pickTier(host.actors[actorName]!);
 
-function logToChannel(from: string, to: string, body: string): void {
+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 content = serializeFrontmatter(
-    { from, to, type: 'text', timestamp: ts.iso },
-    body,
+  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)}`,
+    ),
   );
-  writeFileSync(join(dir, messageFilename(ts)), content);
+  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 v4 open — actor=${actorName} channel=${channelUuid.slice(0, 8)}`);
+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('');
 
@@ -120,7 +143,7 @@ async function main(): Promise<void> {
     while (true) {
       let userMsg: string;
       try {
-        userMsg = await rl.question('you> ');
+        userMsg = await rl.question(`${operatorName}> `);
       } catch {
         break;
       }
@@ -128,9 +151,7 @@ async function main(): Promise<void> {
       const trimmed = userMsg.trim();
       if (!trimmed) continue;
 
-      const ts = now();
-      const userMsgRelPath = `${ts.pathDate}/${messageFilename(ts)}`;
-      logToChannel(operatorName, actorName!, trimmed);
+      const userMsgRelPath = logToChannel(operatorName, actorName!, trimmed);
 
       const fullPrompt = `${getCurrentSystemPrompt()}\n\n---\n\n${trimmed}`;
       const parts = tokenizeCli(cli);
@@ -138,16 +159,21 @@ async function main(): Promise<void> {
         console.error('\n[open] tokenized cli is empty — check host file\n');
         continue;
       }
-      const result = spawnSync(parts[0], parts.slice(1), {
+      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,
-          'dispatch',
           actorName!,
           channelUuid!,
           userMsgRelPath,
@@ -155,29 +181,27 @@ async function main(): Promise<void> {
         );
         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) {
-        const r = writeDlqEntry(
-          transportRoot,
-          'dispatch',
-          actorName!,
-          channelUuid!,
-          userMsgRelPath,
-          'cli returned empty reply (open mode)',
-        );
-        console.error(`\n[empty reply → dlq:${r.id}] (run dlq --show ${r.id} for context)\n`);
+        // 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);
+      logToChannel(actorName!, operatorName, reply, userMsgRelPath);
+      await commitTurn();
     }
   } finally {
     rl.close();
   }
+  process.exit(0);
 }
 
 main();