@cordfuse/crosstalk 6.0.0-alpha.6 → 6.0.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cordfuse/crosstalk",
-  "version": "6.0.0-alpha.6",
+  "version": "6.0.0-alpha.8",
   "description": "Crosstalk runtime — async messaging between agents over git, across machines.",
   "type": "module",
   "license": "MIT",

package/src/actor.ts

@@ -1,8 +1,31 @@
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { hostname as osHostname } from 'os';
+import { hostname as osHostname, platform } from 'os';
+import { spawnSync } from 'child_process';
 import { parseFrontmatter } from './frontmatter.js';
 
+// Collect the names this machine might be known by. On macOS, the kernel
+// hostname (`os.hostname()`) drifts with DHCP/VPN/Tailscale when the static
+// HostName is unset — `scutil --get LocalHostName` is the stable Bonjour
+// name (e.g. `Steves-MacBook-Air`), and host files commonly use the `.local`
+// form. Trying all variants makes auto-detect deterministic across network
+// state without forcing every Mac operator to pin `--host`.
+function candidateHostNames(): string[] {
+  const names = new Set<string>();
+  names.add(osHostname());
+  if (platform() === 'darwin') {
+    const r = spawnSync('scutil', ['--get', 'LocalHostName'], { encoding: 'utf-8' });
+    if (r.status === 0) {
+      const local = r.stdout.trim();
+      if (local) {
+        names.add(local);
+        names.add(`${local}.local`);
+      }
+    }
+  }
+  return [...names];
+}
+
 export interface HostActorTier {
   cli: string;
   count?: number;
@@ -36,13 +59,15 @@ export function findHostFile(transportRoot: string, override?: string): HostFile
     if (!target) throw new Error(`Host file '${override}' not found in ${dir}`);
     return parseHostFile(join(dir, target));
   }
-  const hostName = osHostname();
+  const names = candidateHostNames();
   for (const f of files) {
     const parsed = parseHostFile(join(dir, f));
-    if (parsed.hostname === hostName || parsed.alias === hostName) return parsed;
+    for (const n of names) {
+      if (parsed.hostname === n || parsed.alias === n) return parsed;
+    }
   }
   throw new Error(
-    `No host file matches hostname '${hostName}' in ${dir}. ` +
+    `No host file matches any of [${names.join(', ')}] in ${dir}. ` +
       `Pass --host <alias> to override.`,
   );
 }

package/src/dispatch.ts

@@ -29,6 +29,7 @@ import {
   gitCommitAndPush,
   cursorBaseline,
   newFilesSince,
+  hostFileCommit,
   type ChannelMessage,
 } from './transport.js';
 import {
@@ -361,15 +362,23 @@ async function dispatchTick(): Promise<TickResult> {
     const pending: PendingDispatch[] = [];
 
     for (const channelUuid of channels) {
-      const cursor = readCursor(transportRoot, actorName, channelUuid);
-      if (cursor === head) continue;
-
-      // First encounter: seed to HEAD so only future messages are dispatched.
-      // Without this, a null cursor falls through to `post = messages` and
-      // replays the full channel history on every fresh-state boot.
-      if (cursor === null) {
-        writeCursor(transportRoot, actorName, channelUuid, head);
-        continue;
+      const persistedCursor = readCursor(transportRoot, actorName, channelUuid);
+      if (persistedCursor === head) continue;
+
+      // First encounter: seed to the commit that introduced this actor's host
+      // file. Messages sent after the host joined are delivered (store-and-
+      // forward); pre-join history is ignored. Seeding to HEAD would silently
+      // drop messages sent while the dispatcher was offline — the wrong trade.
+      // Fall through after seeding so this tick processes the post-join backlog
+      // (otherwise `--once` users hit a seed-then-dispatch two-tick gotcha).
+      let cursor: string;
+      if (persistedCursor === null) {
+        const joinCommit = hostFileCommit(transportRoot, host.alias);
+        cursor = joinCommit ?? head;
+        writeCursor(transportRoot, actorName, channelUuid, cursor);
+        if (cursor === head) continue;
+      } else {
+        cursor = persistedCursor;
       }
 
       const messages = listChannelMessages(transportRoot, channelUuid);

package/src/transport.ts

@@ -68,6 +68,19 @@ export function cursorBaseline(transportRoot: string): string | null {
   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