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

package/src/transport.ts

@@ -1,8 +1,13 @@
-import { existsSync, readdirSync, readFileSync, statSync, mkdirSync, writeFileSync } from 'fs';
+// 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, serializeFrontmatter } from './frontmatter.js';
-import { now } from './filenames.js';
+import { parseFrontmatter } from './frontmatter.js';
+import { logError } from './state.js';
 
 export interface ChannelMessage {
   relPath: string;
@@ -28,9 +33,8 @@ function captureGit(cwd: string, args: string[]): { status: number; stdout: stri
   return { status: r.status ?? 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
 }
 
-// Detect and auto-recover from an interrupted rebase/merge in the working tree.
-// Returns true if recovery was performed (caller should treat as a non-fatal
-// infrastructure event). The error log surfaces the recovery in errors/.
+// 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'] },
@@ -41,7 +45,7 @@ export function recoverInterruptedGit(transportRoot: string): boolean {
   for (const { dir, abortArgs } of halfStates) {
     if (existsSync(join(transportRoot, dir))) {
       const r = captureGit(transportRoot, abortArgs);
-      writeErrorLog(
+      logError(
         transportRoot,
         'git_pull',
         `recovered from interrupted git state at ${dir} via 'git ${abortArgs.join(' ')}' (exit=${r.status})`,
@@ -52,17 +56,60 @@ export function recoverInterruptedGit(transportRoot: string): boolean {
   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 r = captureGit(transportRoot, ['pull', '--rebase', '--quiet']);
-  if (r.status !== 0) {
-    return { ok: false, error: (r.stderr || r.stdout).trim().slice(0, 500) };
+  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']);
+  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) };
   }
@@ -70,44 +117,30 @@ export function gitCommitAndPush(transportRoot: string, message: string): GitPus
     return { ok: true, committed: false, pushed: false };
   }
 
-  // Stage everything EXCEPT .turnq/ (machine-local runtime state; commits of
-  // this directory cause modify/delete conflicts the moment another clone
-  // untracks it via gitignore). Pathspec exclusion is independent of the
-  // transport's .gitignore — defensive against gitignore drift.
-  //
-  // Edge: `git add -A . :(exclude).turnq` exits non-zero with "The following
-  // paths are ignored by one of your .gitignore files: .turnq" because the
-  // exclude pathspec itself matches a gitignored path. The add still stages
-  // every other change correctly — only the exit code is misleading. So we
-  // treat that specific failure-pattern as benign and let the subsequent
-  // commit step decide whether anything actually got staged.
-  const add = captureGit(transportRoot, ['add', '-A', '.', ':(exclude).turnq']);
-  const addBenignIgnoredPath = add.status !== 0 &&
-                                /paths are ignored/.test(add.stderr);
-  if (add.status !== 0 && !addBenignIgnoredPath) {
+  const add = captureGit(transportRoot, ['add', '--', 'data/']);
+  if (add.status !== 0) {
     return { ok: false, committed: false, pushed: false, error: add.stderr.trim().slice(0, 500) };
   }
 
-  // If .turnq/ was previously committed (pre-alpha.4 transport), the index
-  // may still hold tracked .turnq/* entries. Untrack them here so subsequent
-  // pulls don't fight with operator clones that have untracked .turnq/. This
-  // is a one-time-per-transport heal; on a clean transport it's a no-op.
-  const indexedTurnq = captureGit(transportRoot, ['ls-files', '.turnq']);
-  if (indexedTurnq.status === 0 && indexedTurnq.stdout.trim().length > 0) {
-    captureGit(transportRoot, ['rm', '-r', '--cached', '--quiet', '.turnq']);
-  }
-
-  const commit = captureGit(transportRoot, ['commit', '-m', message]);
+  const commit = captureGit(transportRoot, ['commit', '-m', message, '--', 'data/']);
   if (commit.status !== 0) {
-    // Empty commit ("nothing to commit") is fine — the exclusion may have
-    // dropped the only change. Treat exit-1 with no error text as no-op.
     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) };
   }
 
-  const push = captureGit(transportRoot, ['push', '--quiet']);
+  // 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,
@@ -126,34 +159,23 @@ export function discoverChannels(transportRoot: string): string[] {
   try {
     entries = readdirSync(channelsDir);
   } catch (err) {
-    writeErrorLog(
-      transportRoot,
-      'fs',
-      `discoverChannels readdir failed on ${channelsDir}: ${(err as Error).message}`,
-    );
+    logError(transportRoot, 'fs', `discoverChannels readdir failed on ${channelsDir}: ${(err as Error).message}`);
     return [];
   }
   return entries.filter((name) => {
-    const dir = join(channelsDir, name);
     try {
-      return statSync(dir).isDirectory();
-    } catch (err) {
-      writeErrorLog(
-        transportRoot,
-        'fs',
-        `discoverChannels stat failed on ${dir}: ${(err as Error).message}`,
-      );
+      return statSync(join(channelsDir, name)).isDirectory();
+    } catch {
       return false;
     }
   });
 }
 
 function isValidMessageFrontmatter(data: Record<string, unknown>): boolean {
-  // Required: from (string), to (string or string[]), type (string), timestamp (string)
-  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;
+  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;
 }
 
@@ -175,19 +197,11 @@ export function listChannelMessages(transportRoot: string, channelUuid: string):
         try {
           parsed = parseFrontmatter(raw);
         } catch (err) {
-          writeErrorLog(
-            transportRoot,
-            'parse',
-            `frontmatter parse failed in ${channelUuid}/${rel}: ${(err as Error).message}`,
-          );
+          logError(transportRoot, 'parse', `frontmatter parse failed in ${channelUuid}/${rel}: ${(err as Error).message}`);
           continue;
         }
         if (!isValidMessageFrontmatter(parsed.data)) {
-          writeErrorLog(
-            transportRoot,
-            'parse',
-            `invalid message frontmatter in ${channelUuid}/${rel}: missing required field(s) (from, to, type, timestamp)`,
-          );
+          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 });
@@ -197,134 +211,3 @@ export function listChannelMessages(transportRoot: string, channelUuid: string):
   walk(channelDir, '');
   return results.sort((a, b) => a.relPath.localeCompare(b.relPath));
 }
-
-// ── errors/ log — infrastructure failures (git, fs, etc.) ──
-// Deduped by (kind + signature). If a matching entry exists, increment count
-// + update lastAt. Otherwise create a new entry.
-
-export type ErrorKind = 'git_pull' | 'git_push' | 'git_commit' | 'fs' | 'parse' | 'other';
-
-interface ErrorEntry {
-  id: string;
-  kind: ErrorKind;
-  signature: string;
-  count: number;
-  firstAt: string;
-  lastAt: string;
-  error: string;
-}
-
-function errorSignature(kind: ErrorKind, error: string): string {
-  const firstLine = error.split('\n')[0] ?? '';
-  return `${kind}::${firstLine.trim().slice(0, 120)}`;
-}
-
-export function writeErrorLog(transportRoot: string, kind: ErrorKind, error: string): string {
-  const dir = join(transportRoot, 'errors');
-  mkdirSync(dir, { recursive: true });
-  const sig = errorSignature(kind, error);
-
-  const files = existsSync(dir) ? readdirSync(dir).filter((f) => f.endsWith('.md')) : [];
-  for (const f of files) {
-    const path = join(dir, f);
-    try {
-      const { data } = parseFrontmatter<ErrorEntry>(readFileSync(path, 'utf-8'));
-      if (data.signature === sig) {
-        const updated: ErrorEntry = {
-          ...data,
-          count: (data.count ?? 1) + 1,
-          lastAt: new Date().toISOString(),
-          error: error.slice(0, 500),
-        };
-        writeFileSync(path, serializeFrontmatter(updated as unknown as Record<string, unknown>, error));
-        return data.id;
-      }
-    } catch { /* skip unparseable */ }
-  }
-
-  const ts = now();
-  const id = `${ts.fileTime}-${ts.hex}`;
-  const entry: ErrorEntry = {
-    id, kind, signature: sig,
-    count: 1,
-    firstAt: ts.iso, lastAt: ts.iso,
-    error: error.slice(0, 500),
-  };
-  writeFileSync(
-    join(dir, `${id}.md`),
-    serializeFrontmatter(entry as unknown as Record<string, unknown>, error),
-  );
-  return id;
-}
-
-export function countErrorEntries(transportRoot: string): number {
-  const dir = join(transportRoot, 'errors');
-  if (!existsSync(dir)) return 0;
-  return readdirSync(dir).filter((f) => f.endsWith('.md')).length;
-}
-
-// Sweep channels for read receipts older than `thresholdMs` that lack a
-// corresponding `type: text` reply from the same actor referencing the same
-// original message. Each stale receipt is logged once to errors/ kind=parse
-// (we reuse 'parse' rather than introduce another kind for one weak signal).
-// Returns the number of stale receipts surfaced.
-export function sweepStaleReadReceipts(
-  transportRoot: string,
-  thresholdMs: number,
-): number {
-  const channelsDir = join(transportRoot, 'data', 'channels');
-  if (!existsSync(channelsDir)) return 0;
-  let channels: string[];
-  try {
-    channels = readdirSync(channelsDir).filter((name) => {
-      try { return statSync(join(channelsDir, name)).isDirectory(); }
-      catch { return false; }
-    });
-  } catch { return 0; }
-
-  const now = Date.now();
-  let surfaced = 0;
-
-  for (const channelUuid of channels) {
-    const messages = listChannelMessages(transportRoot, channelUuid);
-
-    // Build: for each (fromActor, refRelPath), did a text reply follow the read receipt?
-    const readReceipts: { actor: string; ref: string; ts: number; relPath: string }[] = [];
-    const replyKeys = new Set<string>();
-
-    for (const msg of messages) {
-      const from = typeof msg.data['from'] === 'string' ? msg.data['from'] : null;
-      const type = typeof msg.data['type'] === 'string' ? msg.data['type'] : null;
-      const timestamp = typeof msg.data['timestamp'] === 'string' ? msg.data['timestamp'] : null;
-      const ref = typeof msg.data['ref'] === 'string' ? msg.data['ref'] : null;
-      if (!from || !type || !timestamp) continue;
-
-      if (type === 'read' && ref) {
-        readReceipts.push({
-          actor: from,
-          ref,
-          ts: new Date(timestamp).getTime(),
-          relPath: msg.relPath,
-        });
-      } else if (type === 'text') {
-        // A text reply doesn't carry a ref field. We approximate "did this
-        // actor reply after the read receipt" by keying on actor only; if
-        // any later text exists from the same actor in this channel, treat
-        // earlier read receipts as resolved. Imperfect but cheap.
-        replyKeys.add(from);
-      }
-    }
-
-    for (const rr of readReceipts) {
-      if (replyKeys.has(rr.actor)) continue;
-      if (now - rr.ts <= thresholdMs) continue;
-      writeErrorLog(
-        transportRoot,
-        'parse',
-        `stale read receipt ${channelUuid}/${rr.relPath}: actor=${rr.actor} claimed ref=${rr.ref} ${Math.floor((now - rr.ts) / 60000)}min ago, no reply yet`,
-      );
-      surfaced++;
-    }
-  }
-  return surfaced;
-}

package/src/turnq.ts

@@ -1,26 +1,20 @@
-// Thin wrapper around @cordfuse/turnq's coordinator.
+// Advisory turn coordination via @cordfuse/turnq.
 //
-// Two modes, picked automatically by the underlying coordinator:
-//
-//   Local (default, no env vars set): file lock via flock(2). Safe across
-//   multiple processes on the same host; the OS releases the lock if the
-//   process dies, so stale locks are impossible.
-//
-//   Distributed (env var TURNQ_URL set): HTTP coordinator running on a
-//   reachable turnq server. Serializes turns across multiple hosts. If
-//   the server is unreachable, falls back to local silently (default
-//   `fallback: true`).
+// The lock is an OPTIMIZATION, never a correctness requirement — git
+// arbitrates (collision-free filenames + push rejection/rebase retry).
+// So: wait a bounded time for the turn, then proceed without it. A turnq
+// bug or outage can never wedge a dispatcher; it just costs an occasional
+// rebase. Failures are loud (errors.log), never silently fallen back.
 //
 // Env vars:
-//   TURNQ_URL      — optional, e.g. http://turnq:3003 (unset → local mode)
+//   TURNQ_URL      — optional, e.g. http://turnq:3003 (unset → local flock)
 //   TURNQ_API_KEY  — required when TURNQ_URL is set
-//   TURNQ_CHANNEL  — optional namespace prefix (default: "crosstalk").
-//                    Concatenated with the lock name to form the actual
-//                    channel — e.g. "crosstalk/dispatch". Lets multiple
-//                    transports share the same turnq server without
-//                    colliding.
+//   TURNQ_CHANNEL  — optional namespace prefix (default: "crosstalk")
 
 import { createCoordinator } from '@cordfuse/turnq/coordinator';
+import { logError } from './state.js';
+
+const TURN_WAIT_MS = 15_000;
 
 interface Coordinator {
   withTurn<T>(channel: string, fn: () => Promise<T>): Promise<T>;
@@ -31,29 +25,67 @@ let coordinatorPromise: Promise<Coordinator> | null = null;
 
 function getCoordinator(): Promise<Coordinator> {
   if (!coordinatorPromise) {
-    const url = process.env.TURNQ_URL;
-    const apiKey = process.env.TURNQ_API_KEY;
+    const url = process.env['TURNQ_URL'];
+    const apiKey = process.env['TURNQ_API_KEY'];
     coordinatorPromise = createCoordinator(
-      url ? { url, apiKey, fallback: true } : {},
+      url ? { url, apiKey, fallback: false } : {},
     );
   }
   return coordinatorPromise;
 }
 
 function channelFor(name: string): string {
-  const prefix = process.env.TURNQ_CHANNEL ?? 'crosstalk';
+  const prefix = process.env['TURNQ_CHANNEL'] ?? 'crosstalk';
   return `${prefix}/${name}`;
 }
 
-/**
- * Run `fn` while holding the turn for the named lock. Queues if another
- * caller holds it; runs in FIFO order. The lock auto-releases when `fn`
- * resolves or rejects.
- *
- * In local mode this is a flock(2) on a temp file. In distributed mode
- * it's an HTTP turn on a cordfuse/turnq server.
- */
-export async function withLock<T>(name: string, fn: () => Promise<T>): Promise<T> {
-  const coordinator = await getCoordinator();
-  return coordinator.withTurn(channelFor(name), fn);
+// Run `fn` while holding the named turn if it can be acquired within
+// TURN_WAIT_MS; otherwise (timeout, coordinator error, server down) log
+// and run `fn` anyway. `fn` runs exactly once — the `ran` guard is safe
+// because the event loop is single-threaded.
+export async function withLock<T>(transportRoot: string, name: string, fn: () => Promise<T>): Promise<T> {
+  let ran = false;
+  const runOnce = (): Promise<T> => {
+    ran = true;
+    return fn();
+  };
+
+  let coordinator: Coordinator;
+  try {
+    coordinator = await getCoordinator();
+  } catch (err) {
+    coordinatorPromise = null;
+    logError(transportRoot, 'turnq', `coordinator init failed — proceeding without lock: ${(err as Error).message}`);
+    return runOnce();
+  }
+
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      if (ran) return;
+      logError(transportRoot, 'turnq', `turn '${name}' not granted within ${TURN_WAIT_MS}ms — proceeding without lock`);
+      runOnce().then(resolve, reject);
+    }, TURN_WAIT_MS);
+    timer.unref?.();
+
+    coordinator
+      .withTurn(channelFor(name), async () => {
+        clearTimeout(timer);
+        if (ran) return; // timeout path already ran fn; release the turn immediately
+        await runOnce().then(resolve, reject);
+      })
+      .catch((err) => {
+        clearTimeout(timer);
+        if (ran) return;
+        logError(transportRoot, 'turnq', `turn '${name}' failed — proceeding without lock: ${(err as Error).message}`);
+        runOnce().then(resolve, reject);
+      });
+  });
+}
+
+export async function closeCoordinator(): Promise<void> {
+  if (!coordinatorPromise) return;
+  try {
+    (await coordinatorPromise).close();
+  } catch { /* best-effort */ }
+  coordinatorPromise = null;
 }

package/src/upgrade.ts

@@ -8,26 +8,27 @@
 // files into the operator's transport so they catch up.
 //
 // What this command DOES touch:
-//   - upstream/CROSSTALK.md, PROTOCOL.md, OPERATOR.md, JITTER.md
+//   - upstream/CROSSTALK.md, PROTOCOL.md, OPERATOR.md
 //   - upstream/CROSSTALK-VERSION
 //   - upstream/actors/ (default actor profile starter set)
 //
 // What this command NEVER touches:
 //   - local/ — operator-owned actor profiles and identity
-//   - hosts/ — operator-owned host file
+//   - hosts/ — operator-owned host files
 //   - data/ — channels and memories
-//   - cursors/, dlq/, errors/ — dispatcher-owned runtime state
 //   - root pointer files (CLAUDE.md etc.) — only updated if a --pointers flag
 //     is passed, since they rarely change and overwriting them surprises
 //     operators who've customized them
+// (Dispatcher state — cursors, dlq, error logs — lives outside the repo
+// in the state dir and is never in scope.)
 //
 // Usage:
 //   crosstalk upgrade           — sync upstream/ from runtime template
 //   crosstalk upgrade --dry-run — show what would change, no writes
-//   crosstalk upgrade --pointers — also overwrite the 11 entry pointer files
+//   crosstalk upgrade --pointers — also overwrite the entry pointer files
 
-import { existsSync, readFileSync, writeFileSync, cpSync, statSync, readdirSync } from 'fs';
-import { resolve, join, dirname, relative } from 'path';
+import { existsSync, readFileSync, cpSync, statSync, readdirSync, mkdirSync } from 'fs';
+import { resolve, join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
 const transportRoot = resolve(process.cwd());
@@ -195,10 +196,7 @@ if (updatePointers) {
     const fromPath = join(templateDir, pf);
     const toPath = join(transportRoot, pf);
     if (!existsSync(fromPath)) continue;
-    const targetDir = dirname(toPath);
-    if (!existsSync(targetDir)) {
-      cpSync(targetDir, targetDir, { recursive: true });
-    }
+    mkdirSync(dirname(toPath), { recursive: true });
     cpSync(fromPath, toPath, { force: true });
   }
   console.log(`  ✓ pointer files synced`);
@@ -210,4 +208,4 @@ console.log(`Commit the upstream/ changes when ready:`);
 console.log(`  git add upstream/${updatePointers ? ' ' + POINTER_FILES.slice(0, 3).join(' ') + ' ...' : ''}`);
 console.log(`  git commit -m "spec: upgrade to ${toVersion}"`);
 console.log('');
-console.log('Your local/, hosts/, data/, cursors/, dlq/, errors/ were not touched.');
+console.log('Your local/, hosts/, and data/ were not touched.');

package/src/wake.ts

@@ -1,8 +1,7 @@
-import { writeFileSync, mkdirSync } from 'fs';
-import { resolve, join } from 'path';
+// crosstalk wake — poke the local dispatcher to tick immediately.
 
-const transportRoot = resolve(process.cwd());
-const wakeDir = join(transportRoot, '.turnq');
-mkdirSync(wakeDir, { recursive: true });
-writeFileSync(join(wakeDir, 'wake.signal'), `${Date.now()}\n`);
+import { resolve } from 'path';
+import { sendWakeSignal } from './state.js';
+
+sendWakeSignal(resolve(process.cwd()));
 console.log('wake signal sent');

package/template/CLAUDE.md

@@ -1,2 +1,12 @@
-Read [local/CROSSTALK.md](local/CROSSTALK.md) for your identity configuration (if you are a dispatched actor).
-Read [upstream/CROSSTALK.md](upstream/CROSSTALK.md) for the protocol specification.
+# Crosstalk transport
+
+You are inside a Crosstalk transport — a git repo that carries async
+messages between AI agents across machines.
+
+Read these before doing anything here:
+
+1. `upstream/PROTOCOL.md` — how to behave when dispatched (start here)
+2. `upstream/CROSSTALK.md` — the full protocol spec, if you need details
+
+Do not edit files under `data/` by hand — messages are written only by
+`crosstalk send` and the dispatcher.

package/template/gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+Thumbs.db
+node_modules/
+.turnq/

package/template/upstream/CROSSTALK-VERSION

@@ -1 +1 @@
-5.0
+6.0