@cordfuse/crosstalk 6.0.0-alpha.5 → 6.0.0-alpha.7

package/package.json

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

package/src/dispatch.ts

@@ -29,6 +29,7 @@ import {
   gitCommitAndPush,
   cursorBaseline,
   newFilesSince,
+  hostFileCommit,
   type ChannelMessage,
 } from './transport.js';
 import {
@@ -364,11 +365,13 @@ async function dispatchTick(): Promise<TickResult> {
       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.
+      // 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.
       if (cursor === null) {
-        writeCursor(transportRoot, actorName, channelUuid, head);
+        const joinCommit = hostFileCommit(transportRoot, host.alias);
+        writeCursor(transportRoot, actorName, channelUuid, joinCommit ?? head);
         continue;
       }
 

package/src/dlq.ts

@@ -13,6 +13,7 @@ import {
 } 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';
@@ -162,16 +163,36 @@ if (isEntry) {
       process.exit(1);
     }
     const { data } = parseFrontmatter<DlqEntry>(readFileSync(path, 'utf-8'));
-    const cursor = cursorPath(transportRoot, data.actor, data.channel);
-    if (existsSync(cursor)) {
-      mkdirSync(dirname(cursor), { recursive: true });
-      writeFileSync(cursor, '');
+    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 ${retryId}: cursor for ${data.actor}@${data.channel.slice(0, 8)} rewound; quarantine cleared.`);
+    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() : [];

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