@cordfuse/crosstalk 7.0.0-beta.1 → 8.0.0-alpha.1

package/GUIDE-CLI.md

@@ -2,7 +2,7 @@
 
 Reference for the `crosstalk` CLI. Run `crosstalk <noun> --help` (or `crosstalk <noun> <verb> --help`) for inline flags.
 
-Requires: Node.js ≥ 20 + git on PATH. alpha.18 is a single-package install — `npm install -g @cordfuse/crosstalk`. The daemon lives as `crosstalk daemon …` inside the same package; there's no separate `crosstalkd` binary anymore.
+Requires: Node.js ≥ 20 + git on PATH. Single-package install: `npm install -g @cordfuse/crosstalk` (current: beta.1). The daemon lives as `crosstalk daemon …` inside the same package; there's no separate `crosstalkd` binary anymore (collapse landed in alpha.18; `@cordfuse/crosstalkd` is deprecated on npm).
 
 The surface is strict **noun-verb**, mirroring [`@cordfuse/llmux`](https://www.npmjs.com/package/@cordfuse/llmux):
 

package/README.md

@@ -1,16 +1,16 @@
 # Crosstalk
 
-**A shared message bus for humans and AI agents, built on git.**
+**A shared message bus for humans and AI agents. The bus is a directory — carried by git, or a plain/shared filesystem.**
 
-> **alpha.18 status.** Crosstalk is now a single npm package — `@cordfuse/crosstalk`. The separate `@cordfuse/crosstalkd` daemon package is deprecated; the daemon lives as `crosstalk daemon dispatch` inside this same package. CLI surface is strict noun-verb, mirroring `@cordfuse/llmux`. Operators on v7 (Docker) or alpha.17 should follow the upgrade notes at the bottom of this file.
+> **Status (8.x).** Crosstalk is a single npm package — `@cordfuse/crosstalk` (the separate `@cordfuse/crosstalkd` daemon package is deprecated; the daemon lives as `crosstalk daemon dispatch` inside this same package). CLI surface is strict noun-verb, mirroring `@cordfuse/llmux`. **As of 8.x the bus is transport-pluggable:** git (distributed, versioned, auditable) is the default; a local or shared filesystem — `transport: local`, including a mounted SMB/NFS share — needs no git and no remote. Select per transport with the `transport:` key in `data/crosstalk.yaml`.
 
 ---
 
 > ### Six words that come up everywhere on this page
 >
-> - **Transport** — a git repo, scaffolded by `crosstalk transport init`. It IS the message bus.
+> - **Transport** — the message bus, scaffolded by `crosstalk transport init`. A directory: a git repo (default — distributed, versioned) or a plain/shared filesystem (`transport: local`). It IS the bus.
 > - **Machine** — a host running one crosstalk engine. Identifies itself via the dispatcher `--alias` (defaulting to the transport name).
-> - **Message** — a markdown file with YAML frontmatter, committed to a channel. The unit of work.
+> - **Message** — a markdown file with YAML frontmatter, written to a channel. The unit of work.
 > - **Model** — a named agent invocation declared in `data/crosstalk.yaml` (e.g. `sonnet`, `codex-o3`).
 > - **Actor** — an optional persona file (`local/actors/<name>.md`) that prepends to a model's prompt as system context.
 > - **Channel** — a UUID directory under `data/channels/`. A conversation thread. Optionally parented.
@@ -32,15 +32,15 @@ The missing piece: a way to make **any** agent CLI talk to **any** other agent C
 
 ## The solution
 
-Crosstalk is that missing layer. The whole protocol is one idea — **a git repo is the message bus.**
+Crosstalk is that missing layer. The whole protocol is one idea — **a directory is the message bus.** Carry that directory with git (distributed, versioned, auditable) or a plain/shared filesystem (local, LAN, a mounted share) — same protocol either way.
 
 - **Any CLI participates.** If an agent's CLI runs one prompt non-interactively and prints a reply, it's a valid model. Mix Claude Code, Codex, Gemini CLI, Qwen Code, opencode, Antigravity — or any future CLI that follows the same shape — in one transport.
-- **Messages are commits.** Every send is a markdown file with YAML frontmatter, committed and pushed. The whole conversation is the git history: nothing to lose, nothing hidden, nothing to back up separately.
+- **Messages are files.** Every send is a markdown file with YAML frontmatter dropped into a channel. On the git transport each is a commit, so the whole conversation is git history — nothing to lose, nothing hidden, nothing to back up separately. On the filesystem transport it's just the files on disk.
 - **Peer-to-peer.** Each machine runs its own crosstalk engine. No broker, no central runtime, no registry.
-- **Multi-machine for free.** Git already solves "synchronize this across hosts." Crosstalk inherits that.
-- **Self-coordinating.** Collision-free filenames + rebase-retry on push mean the bus works correctly even with no central coordinator and concurrent writers.
+- **Multi-machine for free.** Git already solves "synchronize this across hosts"; a shared mount (SMB/NFS) does the same on a LAN. Crosstalk inherits whichever you point it at.
+- **Self-coordinating.** Collision-free filenames mean concurrent writers never clash; the git transport adds rebase-retry on push, the filesystem transport relies on the unique filenames alone. Either way the bus works correctly with no central coordinator.
 
-If you can `git push`, you can participate. No infrastructure to provision, no central server holding your conversation.
+No infrastructure to provision, no central server holding your conversation — just a directory, on git or a filesystem.
 
 ---
 
@@ -235,6 +235,26 @@ Same flow works for self-hosted Gitea or GitLab. Crosstalk doesn't care; it only
 
 ---
 
+## Local filesystem transport (no git)
+
+Don't want a git remote? Point Crosstalk at a plain directory instead — a local folder for a single host, or a **mounted SMB/NFS share** for several hosts on a LAN. No git, no remote, no infrastructure.
+
+```sh
+# Scaffold a local-fs transport straight onto the directory (e.g. a NAS mount):
+crosstalk transport init --transport local --path /mnt/share/crosstalk
+
+# Run the engine on it — the bus lives on the share, state stays machine-local:
+crosstalk server start --path /mnt/share/crosstalk
+```
+
+`--transport local` writes `transport: local` into `data/crosstalk.yaml` (no git init), and the dispatcher self-selects the filesystem transport: it reads/writes message files directly and picks up new ones via an mtime cursor — event-driven `fs.watch` on a true local FS, polling over a network mount. Each host that mounts the share runs its own engine and keeps its own machine-local cursor/heartbeat, so concurrent writers never clash (collision-free filenames).
+
+Tradeoffs vs. git: no version history, no audit trail, no conflict resolution beyond the unique filenames — but zero setup and no SSH/credentials. Reach for git when *what was said* matters; reach for the filesystem transport for quick local/LAN swarms.
+
+> **SFTP?** Mount it with `sshfs` and use `transport: local` — Crosstalk just sees a directory.
+
+---
+
 ## Adding a second machine
 
 Multi-machine adds exactly one new idea: **routing by alias.**
@@ -424,8 +444,8 @@ Transport git repos are portable — the storage path is unchanged (`~/.local/sh
 If you have a v7 Docker install:
 
 1. `docker compose -f <your-compose-file> down` first.
-2. `npm install -g @cordfuse/crosstalk@latest` — pulls alpha.18.
-3. If you previously installed `@cordfuse/crosstalkd`: `npm uninstall -g @cordfuse/crosstalkd` (deprecated, no longer published from alpha.18).
+2. `npm install -g @cordfuse/crosstalk@latest` — pulls the latest 8.x.
+3. If you previously installed `@cordfuse/crosstalkd`: `npm uninstall -g @cordfuse/crosstalkd` (deprecated, no longer published since alpha.18).
 4. In user mode: `export CROSSTALK_USER_MODE=1 && crosstalk server start --containername <name>`.
 5. In system mode: rerun `sudo ./deploy/install.sh` to lay down the new `crosstalk@.service` unit, then `sudo systemctl daemon-reload && sudo systemctl enable --now crosstalk@<name>`. The old `crosstalkd@<name>.service` files can be removed.
 
@@ -435,4 +455,4 @@ The v7 GHCR image `ghcr.io/cordfuse/crosstalk-server:*` is no longer being updat
 
 ## Status
 
-Crosstalk alpha.18 — single-package monorepo + strict noun-verb CLI. The protocol version lives at `CROSSTALK-VERSION` (single integer) at the transport root. Published as [`@cordfuse/crosstalk`](https://www.npmjs.com/package/@cordfuse/crosstalk).
+Crosstalk 8.x — single-package monorepo + strict noun-verb CLI, transport-pluggable (git or a local/shared filesystem). The protocol version lives at `CROSSTALK-VERSION` (single integer) at the transport root. Published as [`@cordfuse/crosstalk`](https://www.npmjs.com/package/@cordfuse/crosstalk).

package/commands/server.js

@@ -20,9 +20,10 @@
 
 import { spawn } from 'child_process';
 import { existsSync } from 'fs';
-import { has } from '../lib/argv.js';
+import { join, resolve } from 'path';
+import { has, flag } from '../lib/argv.js';
 import {
-  requireInitialized, storageMode,
+  requireInitialized, storageMode, parseContainerName,
   DEFAULT_CONTAINER_NAME,
 } from '../lib/resolve.js';
 import { startEngine, stopEngine, engineStatus } from '../lib/nativeServer.js';
@@ -56,7 +57,9 @@ function usage(exit = 0) {
 `Usage: crosstalk server <subverb> [--containername <name>]
 
 Subverbs:
-  start                start the engine as a detached host process
+  start [--path <dir>] start the engine; --path runs it on a transport at an
+                       arbitrary directory (e.g. a mounted share), state stays
+                       machine-local (user mode only)
   stop                 SIGTERM the running engine; SIGKILL after 5s grace
   restart              stop + start
   status [--probe]     report pid + uptime; --probe also pings /healthz
@@ -68,6 +71,35 @@ Storage mode defaults to 'system'; set CROSSTALK_USER_MODE=1 for user mode.
 }
 
 async function cmdStart(argv) {
+  // --path <dir>: run the engine on a transport at an arbitrary directory
+  // (e.g. a mounted SMB/NFS share) instead of the managed storage layout.
+  // State (cursor/heartbeat/pid/port) stays machine-local, keyed by name.
+  const transportPath = flag(argv, '--path');
+  if (transportPath) {
+    if (storageMode() === 'system') {
+      process.stderr.write(`crosstalk server start: --path is user-mode only (set CROSSTALK_USER_MODE=1).\n`);
+      return 1;
+    }
+    if (!existsSync(join(transportPath, 'CROSSTALK-VERSION'))) {
+      process.stderr.write(
+        `crosstalk server start: '${transportPath}' is not a crosstalk transport (no CROSSTALK-VERSION).\n` +
+        `  Scaffold it first:  crosstalk daemon init ${transportPath}\n`,
+      );
+      return 1;
+    }
+    const name = parseContainerName(argv);
+    const r = startEngine(name, { transportPath });
+    if (!r.ok) {
+      process.stderr.write(`crosstalk server start: ${r.error}\n`);
+      return 1;
+    }
+    process.stdout.write(
+      `'${name}' started on ${resolve(transportPath)} (pid ${r.pid}, api 127.0.0.1:${r.port}).\n` +
+      `  state stays machine-local; logs: crosstalk server logs${nameSuffix(name)} -f\n`,
+    );
+    return 0;
+  }
+
   const { name } = requireInitialized(argv);
   if (storageMode() === 'system') return redirectToSystemctl('start', name);
   const r = startEngine(name);

package/commands/transport.js

@@ -14,7 +14,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'fs';
 import { spawnSync } from 'child_process';
 import { createInterface } from 'readline';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { has, flag } from '../lib/argv.js';
 import {
   parseContainerName,
@@ -29,7 +29,7 @@ function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;
   w.write(
 `Usage:
-  crosstalk transport init [--containername <name>] [--remote <url>]
+  crosstalk transport init [--containername <name>] [--transport git|local] [--path <dir>] [--remote <url>]
   crosstalk transport rm   [--containername <name>] [--force]
   crosstalk transport --help
 
@@ -75,12 +75,22 @@ async function runInit(argv) {
   }
 
   const remote = flag(argv, '--remote');
+  const transportKind = flag(argv, '--transport') === 'local' ? 'local' : 'git';
+  if (transportKind === 'local' && remote) {
+    process.stderr.write(`crosstalk transport init: --remote is ignored for --transport local (no git, no upstream).\n`);
+  }
   const paths = storagePaths(name);
+  // --path <dir>: scaffold the transport at an arbitrary directory (e.g. a
+  // mounted share) instead of the managed storage layout. Port + state stay
+  // machine-local under the name-keyed storage root; only the transport
+  // (template + channels) lives at the path. Pairs with `server start --path`.
+  const customPath = flag(argv, '--path');
+  const transportDir = customPath ? resolve(customPath) : paths.transportDir;
   const report = [];
 
   // ── Phase 1: Storage layout ────────────────────────────────────────
   try {
-    mkdirSync(paths.transportDir,   { recursive: true });
+    mkdirSync(transportDir,         { recursive: true });
     mkdirSync(paths.crosstalkRoot,  { recursive: true });
     mkdirSync(paths.crosstalkState, { recursive: true });
   } catch (err) {
@@ -116,7 +126,7 @@ async function runInit(argv) {
   }
 
   // ── Phase 2: Transport scaffold ────────────────────────────────────
-  const crosstalkVersionFile = join(paths.transportDir, 'CROSSTALK-VERSION');
+  const crosstalkVersionFile = join(transportDir, 'CROSSTALK-VERSION');
   if (!existsSync(crosstalkVersionFile)) {
     // Scaffold via `crosstalk daemon init <path>` — the same self-bin
     // call pattern startEngine() uses.
@@ -129,7 +139,7 @@ async function runInit(argv) {
     }
     const initRun = spawnSync(
       process.execPath,
-      [selfBin, 'daemon', 'init', paths.transportDir],
+      [selfBin, 'daemon', 'init', transportDir],
       { stdio: 'pipe' },
     );
     if (initRun.status !== 0) {
@@ -145,40 +155,59 @@ async function runInit(argv) {
     report.push(`  template:   present (skipped scaffold)`);
   }
 
+  // ── Phase 2.5: local transport marker ──────────────────────────────
+  // Local (fs) transports carry no git history; persist the medium in the
+  // config so the dispatcher self-selects it (no --transport flag needed).
+  if (transportKind === 'local') {
+    const yamlPath = join(transportDir, 'data', 'crosstalk.yaml');
+    try {
+      const cur = existsSync(yamlPath) ? readFileSync(yamlPath, 'utf8') : '';
+      if (!/^\s*transport\s*:/m.test(cur)) {
+        writeFileSync(yamlPath, `transport: local\n${cur}`);
+      }
+      report.push(`  medium:     local (fs — no git)`);
+    } catch (err) {
+      process.stderr.write(`crosstalk transport init: failed to write transport key to ${yamlPath} — ${err.message}\n`);
+      return 1;
+    }
+  }
+
   // ── Phase 3: Git init + initial commit ─────────────────────────────
   if (!existsSync(crosstalkVersionFile)) {
     process.stderr.write(
-      `crosstalk transport init: transport template missing at ${paths.transportDir}\n` +
+      `crosstalk transport init: transport template missing at ${transportDir}\n` +
       `  Engine init didn't write template files. Try 'crosstalk transport rm' then re-init.\n`,
     );
     return 1;
   }
 
-  const gitSteps = [
-    ['init', '--quiet', '--initial-branch=main'],
-    ['add', '-A'],
-    ['commit', '--quiet', '-m', 'initial transport'],
-  ];
-  let gitOk = true;
-  for (const args of gitSteps) {
-    const gr = spawnSync('git', args, { cwd: paths.transportDir, stdio: 'pipe' });
-    if (gr.status !== 0) {
-      gitOk = false;
-      break;
+  if (transportKind === 'git') {
+    const gitSteps = [
+      ['init', '--quiet', '--initial-branch=main'],
+      ['add', '-A'],
+      ['commit', '--quiet', '-m', 'initial transport'],
+    ];
+    let gitOk = true;
+    for (const args of gitSteps) {
+      const gr = spawnSync('git', args, { cwd: transportDir, stdio: 'pipe' });
+      if (gr.status !== 0) {
+        gitOk = false;
+        break;
+      }
     }
+    report.push(gitOk ? `  git:        initialized + committed` : `  git:        already present (skipped)`);
   }
-  report.push(gitOk ? `  git:        initialized + committed` : `  git:        already present (skipped)`);
 
-  // ── Phase 4: Remote setup ──────────────────────────────────────────
-  if (remote) {
+  // ── Phase 4: Remote setup (git only) ───────────────────────────────
+  if (remote && transportKind === 'git') {
     const cur = spawnSync('git', ['remote', 'get-url', 'origin'], {
-      cwd: paths.transportDir,
+      cwd: transportDir,
       stdio: 'pipe',
     });
     const currentUrl = cur.status === 0 ? cur.stdout.toString().trim() : null;
     if (!currentUrl) {
       const rr = spawnSync('git', ['remote', 'add', 'origin', remote], {
-        cwd: paths.transportDir,
+        cwd: transportDir,
         stdio: 'pipe',
       });
       if (rr.status !== 0) {
@@ -202,9 +231,9 @@ async function runInit(argv) {
   process.stdout.write(
     `\nTransport '${name}' ready:\n` +
     `  storage:    ${paths.storageRoot}\n` +
-    `  transport:  ${paths.transportDir}\n` +
+    `  transport:  ${transportDir}\n` +
     report.join('\n') + '\n' +
-    `\nNext: crosstalk server start${name === DEFAULT_CONTAINER_NAME ? '' : ` --containername ${name}`}\n`,
+    `\nNext: crosstalk server start${customPath ? ` --path ${transportDir}` : (name === DEFAULT_CONTAINER_NAME ? '' : ` --containername ${name}`)}\n`,
   );
   return 0;
 }

package/lib/nativeServer.js

@@ -67,18 +67,27 @@ export function startEngine(name, opts = {}) {
   const poll = String(opts.pollSeconds ?? process.env.DISPATCH_POLL_SECONDS ?? 30);
   const port = String(apiPortFor(name));
 
+  // --path: the transport lives at an arbitrary directory (e.g. a mounted
+  // share). Point the engine there via CROSSTALK_TRANSPORT_PATH, and pin
+  // state machine-local (by name) so cursor/heartbeat never land on the
+  // share — each machine sharing the dir keeps its own local state.
+  const transportDir = opts.transportPath ? resolve(opts.transportPath) : paths.transportDir;
   const env = {
     ...process.env,
     CROSSTALK_API_PORT: port,
-    TRANSPORT_DIR: paths.transportDir,
+    TRANSPORT_DIR: transportDir,
   };
+  if (opts.transportPath) {
+    env.CROSSTALK_TRANSPORT_PATH = transportDir;
+    env.CROSSTALK_STATE_DIR = paths.crosstalkState;
+  }
 
   const logFd = openSync(paths.logFile, 'a');
   const child = spawn(
     process.execPath,
     [selfBin, 'daemon', 'dispatch', '--alias', alias, '--poll', poll, '--json'],
     {
-      cwd: paths.transportDir,
+      cwd: transportDir,
       env,
       stdio: ['ignore', logFd, logFd],
       detached: true,

package/lib/resolve.js

@@ -187,11 +187,13 @@ export function pickFreePort(name, mode = storageMode()) {
   throw new Error('Could not find a free port between 7001 and 7999.');
 }
 
-// True if `<base>/<name>/transport/.git` exists. The cheapest signal that
-// a transport has been initialized for this name.
+// True if the transport has been scaffolded for this name. Checks the
+// CROSSTALK-VERSION marker that `daemon init` writes for EVERY transport —
+// git and local-fs alike. (Was '.git', which wrongly rejected no-git local
+// transports: `server start` reported "no transport 'mc'".)
 export function isInitialized(name) {
   const paths = storagePaths(name);
-  return existsSync(join(paths.transportDir, '.git'));
+  return existsSync(join(paths.transportDir, 'CROSSTALK-VERSION'));
 }
 
 // True if the crosstalk engine is running for this transport. Source of truth:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cordfuse/crosstalk",
-  "version": "7.0.0-beta.1",
-  "description": "Crosstalk — agent-agnostic swarm communication protocol built on git. Operator CLI + daemon in one binary.",
+  "version": "8.0.0-alpha.1",
+  "description": "Crosstalk — agent-agnostic swarm communication protocol over a shared directory (git or filesystem transport). Operator CLI + daemon in one binary.",
   "type": "module",
   "license": "MIT",
   "homepage": "https://github.com/cordfuse/crosstalk",
@@ -26,7 +26,7 @@
   "scripts": {
     "build": "tsc --noEmit",
     "lint": "tsc --noEmit",
-    "test": "bun test",
+    "test": "node --import tsx --test tests/*.test.ts",
     "prepack": "cp -r transport template",
     "postpack": "rm -rf template"
   },

package/src/api.ts

@@ -33,8 +33,8 @@ import { now, messageFilename } from './filenames.js';
 import { parseFrontmatter, serializeFrontmatter } from './frontmatter.js';
 import {
   discoverChannels,
-  gitCommitAndPush,
   listChannelMessages,
+  type Transport,
 } from './transport.js';
 import { sendWakeSignal, readHeartbeat, readCursor, countErrors } from './state.js';
 import { reList } from './activation.js';
@@ -66,6 +66,9 @@ export interface ApiContext {
   version: string;
   registry: ModelsRegistry;
   claimed: Map<string, ModelEntry>;  // shorthand for registry.claimed
+  /** v8: the bus medium (git default, or local-fs). Web-UI writes publish
+   *  through this so a local-fs deployment never shells out to git. */
+  transport: Transport;
   /** Auth stores; v8-native. Optional — engine still runs without auth
    *  if the operator doesn't want it (just the web UI gating turns off). */
   userStore?: UserStore;
@@ -205,6 +208,7 @@ function handleStatus(ctx: ApiContext): JsonRes {
     status: 200,
     body: {
       transport_root: transportRoot,
+      transport_kind: ctx.transport.kind,
       alias: ctx.alias,
       version: ctx.version,
       claimed_models: [...ctx.claimed.keys()],
@@ -281,7 +285,7 @@ function handleCreateChannel(ctx: ApiContext, body: CreateChannelReq): JsonRes {
   const dir = join(transportRoot, 'data', 'channels', uuid);
   mkdirSync(dir, { recursive: true });
   writeFileSync(join(dir, 'CHANNEL.md'), serializeFrontmatter({ name: body.name }, ''));
-  const push = gitCommitAndPush(transportRoot, `channel(create): ${body.name} (${uuid.slice(0, 8)})`);
+  const push = ctx.transport.publish(`channel(create): ${body.name} (${uuid.slice(0, 8)})`);
   if (!push.committed && push.error) {
     // Commit itself failed (e.g. file system / git config issue).
     throw new HttpError(500, `commit failed: ${push.error.slice(0, 300)}`);
@@ -316,8 +320,7 @@ function handleRenameChannel(ctx: ApiContext, handle: string, body: RenameChanne
   const fm: Record<string, unknown> = { name: body.name };
   if (meta.parent) fm['parent'] = meta.parent;
   writeFileSync(chPath, serializeFrontmatter(fm, ''));
-  const push = gitCommitAndPush(
-    transportRoot,
+  const push = ctx.transport.publish(
     `channel(rename): ${meta.name ?? '(unnamed)'} -> ${body.name} (${meta.uuid.slice(0, 8)})`,
   );
   if (!push.committed && push.error) {
@@ -348,8 +351,7 @@ function handleDeleteChannel(ctx: ApiContext, handle: string, confirm: string |
   }
   const dir = join(transportRoot, 'data', 'channels', meta.uuid);
   rmSync(dir, { recursive: true, force: true });
-  const push = gitCommitAndPush(
-    transportRoot,
+  const push = ctx.transport.publish(
     `channel(delete): ${meta.name ?? '(unnamed)'} (${meta.uuid.slice(0, 8)})`,
   );
   if (!push.committed && push.error) {
@@ -458,7 +460,7 @@ function handlePostMessage(ctx: ApiContext, body: PostMessageReq): JsonRes {
       fanout === 1
         ? `run: ${from} -> ${toQualified} in ${channelUuid.slice(0, 8)}`
         : `run: ${from} -> ${toQualified} x${fanout} in ${channelUuid.slice(0, 8)}`;
-    const push = gitCommitAndPush(transportRoot, commitMsg);
+    const push = ctx.transport.publish(commitMsg);
     sendWakeSignal(transportRoot);
     if (!push.committed && push.error) {
       throw new HttpError(500, `commit failed: ${push.error.slice(0, 300)}`);
@@ -494,8 +496,7 @@ function handlePostMessage(ctx: ApiContext, body: PostMessageReq): JsonRes {
       extraFrontmatter,
       workflow: true,
     });
-    const push = gitCommitAndPush(
-      transportRoot,
+    const push = ctx.transport.publish(
       `run(workflow): ${from} child ${childUuid.slice(0, 8)}`,
     );
     sendWakeSignal(transportRoot);
@@ -1007,8 +1008,7 @@ async function tryWebApiRoute(ctx: ApiContext, req: IncomingMessage, res: Server
       extraFrontmatter,
       workflow: true,
     });
-    const push = gitCommitAndPush(
-      ctx.transportRoot,
+    const push = ctx.transport.publish(
       `run(workflow): ${me.username} child ${childUuid.slice(0, 8)} (composed)`,
     );
     sendWakeSignal(ctx.transportRoot);
@@ -1088,6 +1088,7 @@ async function tryHtmlRoute(ctx: ApiContext, req: IncomingMessage, res: ServerRe
     const channels = allChannelMeta(ctx.transportRoot);
     writeHtml(res, 200, dashboardPage({
       host, alias: ctx.alias, version: ctx.version, transportRoot: ctx.transportRoot,
+      transportKind: ctx.transport.kind,
       heartbeat: hb ? { ts: hb.ts, pid: hb.pid, version: hb.version, alias: hb.alias } : null,
       cursor: cursor ?? null,
       claimedModels: [...ctx.claimed.keys()],

package/src/dispatch.ts

@@ -20,16 +20,8 @@ import { readFileSync, existsSync, appendFileSync } from 'fs';
 import { watch } from 'fs/promises';
 import { fileURLToPath } from 'url';
 
-import { loadRegistry, type ModelEntry, type ModelsRegistry } from './models.js';
-import {
-  discoverChannels,
-  listChannelMessages,
-  gitPull,
-  gitCommitAndPush,
-  cursorBaseline,
-  newFilesSince,
-  type ChannelMessage,
-} from './transport.js';
+import { loadRegistry, loadTransportKind, type ModelEntry, type ModelsRegistry } from './models.js';
+import { GitTransport, LocalFsTransport, type Transport, type ChannelMessage } from './transport.js';
 import {
   stateDir,
   readCursor,
@@ -72,7 +64,10 @@ const RUNTIME_VERSION: string = (() => {
   }
 })();
 
-const transportRoot = resolve(process.cwd());
+// CROSSTALK_TRANSPORT_PATH points the engine at a transport directory
+// directly (defaults to cwd) — pairs with CROSSTALK_TRANSPORT_TYPE to run the
+// bus on a given directory (e.g. a mounted share) without a cd.
+const transportRoot = resolve(process.env['CROSSTALK_TRANSPORT_PATH'] ?? process.cwd());
 const argv = process.argv.slice(2);
 
 function flag(name: string): string | undefined {
@@ -87,6 +82,21 @@ const jsonMode = argv.includes('--json');
 const pollSeconds = Number(flag('--poll')) || 30;
 const logFile = flag('--log-file');
 
+// v8: the dispatch loop drives the bus through a Transport, not git calls.
+// Selection precedence: --transport flag > CROSSTALK_TRANSPORT_TYPE env >
+// `transport:` in crosstalk.yaml > git default. local = plain-fs, incl. a
+// mounted SMB/NFS share. The fs transport drops in with zero changes below.
+const transportOverride = flag('--transport') ?? process.env['CROSSTALK_TRANSPORT_TYPE'];
+if (transportOverride !== undefined && transportOverride !== 'git' && transportOverride !== 'local') {
+  console.error(`crosstalk daemon dispatch: unknown transport '${transportOverride}' (expected git|local); falling back to config/default.`);
+}
+const transportKind = (transportOverride === 'git' || transportOverride === 'local')
+  ? transportOverride
+  : loadTransportKind(transportRoot);
+const transport: Transport = transportKind === 'local'
+  ? new LocalFsTransport(transportRoot)
+  : new GitTransport(transportRoot);
+
 if (!alias) {
   console.error('crosstalk daemon dispatch: --alias <name> is required (machine identity in the bus).');
   process.exit(1);
@@ -208,14 +218,14 @@ async function dispatchTick(registry: ModelsRegistry, protocolPrompt: string): P
   const claimed = registry.claimed;
   writeHeartbeat(transportRoot, RUNTIME_VERSION, alias!);
 
-  const pullResult = gitPull(transportRoot);
+  const pullResult = transport.sync();
   if (!pullResult.ok) {
     logError(transportRoot, `git pull failed: ${pullResult.error}`, 'warn');
     log('git_pull_failed', { error: (pullResult.error ?? '').slice(0, 200) });
     return false;
   }
 
-  const head = cursorBaseline(transportRoot);
+  const head = transport.head();
   if (!head) {
     logError(transportRoot, 'git rev-parse failed for origin/HEAD and HEAD — skipping tick');
     return false;
@@ -231,7 +241,7 @@ async function dispatchTick(registry: ModelsRegistry, protocolPrompt: string): P
     cursor = head;
     log('cursor_seeded', { commit: head.slice(0, 12) });
   }
-  const channels = discoverChannels(transportRoot);
+  const channels = transport.discoverChannels();
   const activationDue = cursor !== head;
 
   let didWork = false;
@@ -252,7 +262,7 @@ async function dispatchTick(registry: ModelsRegistry, protocolPrompt: string): P
 
   const writeNeeded = didWork || workflowProgressed;
   if (writeNeeded) {
-    const push = gitCommitAndPush(transportRoot, `dispatch(${alias}): replies ${new Date().toISOString()}`);
+    const push = transport.publish(`dispatch(${alias}): replies ${new Date().toISOString()}`);
     if (!push.ok && push.error) {
       // Commit failed is a real error (local state out of sync); push
       // failed with the commit landing is a warning (push will retry).
@@ -271,17 +281,15 @@ async function runActivationPass(
   cursor: string,
   head: string,
 ): Promise<boolean> {
-  const addedList = newFilesSince(transportRoot, cursor);
+  const addedList = transport.newFilesSince(cursor, head);
   if (addedList === null) {
     logError(transportRoot, `cursor ${cursor.slice(0, 12)} unknown — re-scanning all channels`, 'warn');
   }
   const added: Set<string> | null = addedList === null ? null : new Set(addedList);
-
-  void head;  // head is the diff's upper bound implicitly (newFilesSince uses HEAD).
   const pending: PendingDispatch[] = [];
 
   for (const channelUuid of channels) {
-    const messages = listChannelMessages(transportRoot, channelUuid);
+    const messages = transport.listChannelMessages(channelUuid);
     const senderByRelPath = new Map(messages.map((m) => [m.relPath, messageSender(m)]));
     // Normalize asker identity the same way self-suppression does: strip
     // the @machine suffix before comparing against actorName. Without
@@ -336,18 +344,46 @@ async function runActivationPass(
   return results.some(Boolean);
 }
 
+// Block until something worth a tick happens, or `ms` elapses (the poll
+// fallback). Two wake sources race the timeout:
+//   • the state dir's `wake.signal` — written by sendWakeSignal on a
+//     same-host API post (channel/message create).
+//   • the transport's inbound dir (local-fs: data/channels, watched
+//     recursively) — zero-lag pickup when a writer drops a message straight
+//     onto the bus (a peer on a shared mount, a file drop). git returns null
+//     (a remote isn't watchable); fs.watch also won't fire over SMB/NFS — so
+//     the poll timeout stays the always-on backstop.
 async function waitForWakeOrTimeout(ms: number): Promise<void> {
-  const dir = stateDir(transportRoot);
   const ac = new AbortController();
   const timer = setTimeout(() => ac.abort(), ms);
-  try {
-    const watcher = watch(dir, { signal: ac.signal });
-    for await (const ev of watcher) {
-      if (ev.filename === 'wake.signal') return;
+
+  const watchFor = async (dir: string, recursive: boolean): Promise<void> => {
+    try {
+      const watcher = watch(dir, { signal: ac.signal, recursive });
+      for await (const ev of watcher) {
+        // state dir: only wake.signal. bus dir: any new .md is a candidate
+        // message — wake and let the tick's cursor decide if it's new.
+        if (recursive ? (ev.filename?.endsWith('.md') ?? false) : ev.filename === 'wake.signal') return;
+      }
+    } catch {
+      if (ac.signal.aborted) return;  // timeout — expected
+      // watch unavailable (recursive unsupported, network FS, missing dir):
+      // don't spin — wait out the poll interval via the abort signal.
+      await new Promise<void>((res) => {
+        if (ac.signal.aborted) res();
+        else ac.signal.addEventListener('abort', () => res(), { once: true });
+      });
     }
-  } catch {
-    /* abort = timeout */
+  };
+
+  const waits: Promise<void>[] = [watchFor(stateDir(transportRoot), false)];
+  const busDir = transport.watchDir();
+  if (busDir && existsSync(busDir)) waits.push(watchFor(busDir, true));
+
+  try {
+    await Promise.race(waits);
   } finally {
+    ac.abort();
     clearTimeout(timer);
   }
 }
@@ -371,7 +407,7 @@ async function main(): Promise<void> {
     }
     removePidfile(transportRoot);
     if (alias) removeRegistryEntry(transportRoot, alias);
-    const push = gitCommitAndPush(transportRoot, `dispatch(${alias}): deregister entry`);
+    const push = transport.publish(`dispatch(${alias}): deregister entry`);
     if (!push.ok && push.error) {
       logError(transportRoot, `registry deregister failed: ${push.error}`, 'warn');
     }
@@ -414,13 +450,14 @@ async function main(): Promise<void> {
   // races to duplicate. Commit+push immediately so cross-machine
   // visibility doesn't wait for first reply traffic.
   writeRegistryEntry(transportRoot, alias!, [...registry.claimed.keys()], RUNTIME_VERSION);
-  const registryPush = gitCommitAndPush(transportRoot, `dispatch(${alias}): register entry`);
+  const registryPush = transport.publish(`dispatch(${alias}): register entry`);
   if (!registryPush.ok && registryPush.error) {
     logError(transportRoot, `registry publish failed: ${registryPush.error}`, 'warn');
   }
 
   log('dispatch_start', {
     transport: transportRoot,
+    transport_kind: transport.kind,
     alias,
     version: RUNTIME_VERSION,
     state_dir: stateDir(transportRoot),
@@ -454,6 +491,7 @@ async function main(): Promise<void> {
     apiServer = startApi(
       {
         transportRoot,
+        transport,
         alias: alias!,
         version: RUNTIME_VERSION,
         registry,

package/src/models.ts

@@ -102,6 +102,23 @@ function parseInlineEnv(
   return Object.keys(out).length > 0 ? out : null;
 }
 
+export type TransportKind = 'git' | 'local';
+
+// The optional top-level `transport:` key in data/crosstalk.yaml selects the
+// bus medium. 'local' = the filesystem transport (a plain directory, incl. a
+// mounted SMB/NFS share); absent / anything else / unreadable → 'git'. A
+// --transport flag at dispatch boot overrides this.
+export function loadTransportKind(transportRoot: string): TransportKind {
+  const path = crosstalkYamlPath(transportRoot);
+  if (!existsSync(path)) return 'git';
+  try {
+    const parsed = parseYaml(readFileSync(path, 'utf8')) as Record<string, unknown> | null;
+    return parsed && parsed['transport'] === 'local' ? 'local' : 'git';
+  } catch {
+    return 'git';
+  }
+}
+
 export function readModels(transportRoot: string): {
   all: Map<string, ModelEntry>;
   byBareName: Map<string, ModelEntry[]>;

package/src/state.ts

@@ -44,18 +44,23 @@ export function stateDir(transportRoot: string): string {
 
 // ── cursor (single, machine-global) ──
 //
-// A cursor is the git commit hash the transport was last scanned at. NOT a
-// message relPath: filenames order by sender timestamp, but messages reach
-// origin in PUSH order — a message that loses a push race can land on
-// origin with a timestamp earlier than one already processed, and a
-// relPath cursor would skip it forever. Commit-based cursors can't.
+// The cursor is an opaque, transport-OWNED token marking where this machine
+// last scanned. Storage here is format-agnostic: any non-empty string round-
+// trips, and each transport validates + interprets its own token. An
+// unrecognized token (e.g. after switching transports) makes the transport's
+// newFilesSince return null, and the loop full-scans to recover.
+//
+// Git's token is a commit SHA, and that choice is deliberate: filenames order
+// by sender timestamp, but messages reach origin in PUSH order — a message
+// that loses a push race can land with a timestamp earlier than one already
+// processed, and a relPath/time cursor would skip it forever. Commit cursors
+// can't. The local-fs transport uses an mtime watermark instead, which is
+// safe ONLY because a single local machine has one clock and no push races.
 //
 // v6 kept one cursor per (actor × channel). v7 collapses to a single
 // machine-global cursor: a dispatcher processes everything new since the
 // cursor in one tick, regardless of channel or claimed model.
 
-const VALID_CURSOR = /^[0-9a-f]{40}$/;
-
 export function cursorPath(transportRoot: string): string {
   return join(stateDir(transportRoot), 'cursor');
 }
@@ -71,15 +76,11 @@ export function readCursor(transportRoot: string): string | null {
     return null;
   }
   if (raw.length === 0) return null;
-  if (!VALID_CURSOR.test(raw)) {
-    logError(transportRoot, `invalid cursor '${raw.slice(0, 80)}' — re-scanning from origin`, 'warn');
-    return null;
-  }
   return raw;
 }
 
-export function writeCursor(transportRoot: string, commit: string): void {
-  writeFileSync(cursorPath(transportRoot), commit + '\n');
+export function writeCursor(transportRoot: string, token: string): void {
+  writeFileSync(cursorPath(transportRoot), token + '\n');
 }
 
 // ── pidfile ──

package/src/transport.ts

@@ -1,4 +1,6 @@
-// Git transport layer. The dispatcher's commits contain ONLY data/ —
+// Transport layer. The git transport functions are here; the Transport
+// interface + GitTransport/LocalFsTransport live at the foot of this file.
+// The git 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.
@@ -78,9 +80,9 @@ export function cursorBaseline(transportRoot: string): string | null {
 // 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 {
+export function newFilesSince(transportRoot: string, sinceCommit: string, head: string): string[] | null {
   const r = captureGit(transportRoot, [
-    'diff', '--name-only', '--diff-filter=A', `${sinceCommit}..HEAD`, '--', 'data/channels/',
+    'diff', '--name-only', '--diff-filter=A', `${sinceCommit}..${head}`, '--', 'data/channels/',
   ]);
   if (r.status !== 0) return null;
   return r.stdout.split('\n').filter(Boolean);
@@ -241,3 +243,111 @@ export function listChannelMessages(transportRoot: string, channelUuid: string):
   walk(channelDir, '');
   return results.sort((a, b) => a.relPath.localeCompare(b.relPath));
 }
+
+// ── Transport abstraction (v8) ──
+//
+// The dispatch loop talks to a medium through this interface, never to git
+// directly. The CURSOR is an opaque, transport-owned token: dispatch.ts
+// persists whatever string a transport hands back and round-trips it to
+// `newFilesSince` next tick without interpreting it. Git's token is a
+// 40-hex commit SHA (see state.ts on why commit cursors, not relPaths);
+// a future fs transport is free to use a different token shape that is
+// correct for its medium. `head()` returns the upper bound for this tick;
+// `newFilesSince(cursor)` returns repo-relative message paths added in
+// (cursor, head], or null when the cursor is unrecognizable (caller then
+// full-scans). `sync()` pulls remote state in; `publish()` flushes locally
+// written replies out. Message reads (discoverChannels/listChannelMessages)
+// are already plain-fs and identical across every transport.
+export interface Transport {
+  readonly kind: string;
+  sync(): GitResult;
+  head(): string | null;
+  newFilesSince(cursor: string, head: string): string[] | null;
+  publish(message: string): GitPushResult;
+  discoverChannels(): string[];
+  listChannelMessages(channelUuid: string): ChannelMessage[];
+  /** A directory to fs.watch for inbound messages (zero-lag wake), or null
+   *  if the medium can't be watched (git: a remote isn't watchable — the
+   *  poll loop covers it). fs.watch also won't fire over SMB/NFS, so the
+   *  poll stays the backstop even when this is non-null. */
+  watchDir(): string | null;
+}
+
+// Git transport — the original and, until the fs transport lands, the only
+// implementation. A thin pass-through to the module functions above; it
+// adds no behavior, it only moves them behind the interface so dispatch.ts
+// stops importing git operations by name.
+export class GitTransport implements Transport {
+  readonly kind = 'git';
+  constructor(private readonly root: string) {}
+  sync(): GitResult { return gitPull(this.root); }
+  head(): string | null { return cursorBaseline(this.root); }
+  newFilesSince(cursor: string, head: string): string[] | null { return newFilesSince(this.root, cursor, head); }
+  publish(message: string): GitPushResult { return gitCommitAndPush(this.root, message); }
+  discoverChannels(): string[] { return discoverChannels(this.root); }
+  listChannelMessages(channelUuid: string): ChannelMessage[] { return listChannelMessages(this.root, channelUuid); }
+  watchDir(): string | null { return null; }  // a git remote isn't fs.watchable — poll covers inbound
+}
+
+// Local filesystem transport — single machine, no remote, no git. The bus is
+// just a directory tree (it can sit on an SMB/NFS mount; from here it's all
+// the same plain fs). Mount this on /mnt/share and two daemons on the same
+// host, or on hosts sharing the mount, see each other's messages with zero
+// infrastructure.
+//
+// sync()/publish() are no-ops: there's no remote to pull from, and replies
+// are written straight to disk by writeReply — the write IS the publish.
+//
+// The cursor is an epoch-millis mtime watermark. head() is "now" at tick
+// start; newFilesSince returns message files with mtime in (cursor, head].
+// mtime is a sound ordering key HERE and ONLY here: a single local machine
+// has one monotonic clock and no push-race reordering — the exact failure
+// mode state.ts forbids relPath/time cursors over for git/remote media. Do
+// NOT lift this watermark onto SMB/NFS spanning multiple writers without
+// revisiting that guarantee.
+export class LocalFsTransport implements Transport {
+  readonly kind = 'local';
+  constructor(private readonly root: string) {}
+
+  sync(): GitResult { return { ok: true }; }
+  publish(_message: string): GitPushResult { return { ok: true, committed: true, pushed: false }; }
+  head(): string | null { return String(Date.now()); }
+  discoverChannels(): string[] { return discoverChannels(this.root); }
+  listChannelMessages(channelUuid: string): ChannelMessage[] { return listChannelMessages(this.root, channelUuid); }
+  // Watch the channels tree for inbound message drops — event-driven, zero
+  // lag, the v1.1.0 "real-time local" property. Fires only on a true local
+  // FS; a share-mounted dir falls back to the dispatch loop's poll.
+  watchDir(): string | null { return join(this.root, 'data', 'channels'); }
+
+  newFilesSince(cursor: string, head: string): string[] | null {
+    const since = Number(cursor);
+    const until = Number(head);
+    // Unrecognized token (e.g. a git SHA left over from a transport switch)
+    // → null tells the loop to full-scan, after which we write our own.
+    if (!Number.isFinite(since) || !Number.isFinite(until)) return null;
+    const channelsDir = join(this.root, 'data', 'channels');
+    if (!existsSync(channelsDir)) return [];
+    const out: string[] = [];
+    for (const channelUuid of this.discoverChannels()) {
+      const walk = (dir: string, prefix: string): void => {
+        let entries: string[];
+        try { entries = readdirSync(dir); } catch { return; }
+        for (const entry of entries) {
+          const full = join(dir, entry);
+          let stat;
+          try { stat = statSync(full); } catch { continue; }
+          if (stat.isDirectory()) {
+            walk(full, prefix ? `${prefix}/${entry}` : entry);
+          } else if (entry.endsWith('.md') && entry !== 'CHANNEL.md') {
+            if (stat.mtimeMs > since && stat.mtimeMs <= until) {
+              const rel = prefix ? `${prefix}/${entry}` : entry;
+              out.push(`data/channels/${channelUuid}/${rel}`);
+            }
+          }
+        }
+      };
+      walk(join(channelsDir, channelUuid), '');
+    }
+    return out;
+  }
+}

package/src/web/dashboard.ts

@@ -9,6 +9,7 @@ export interface DashboardData {
   alias: string;
   version: string;
   transportRoot: string;
+  transportKind: string;
   heartbeat: { ts: string; pid: number; version: string; alias: string | undefined } | null;
   cursor: string | null;
   claimedModels: string[];
@@ -34,7 +35,7 @@ export function dashboardPage(d: DashboardData): string {
     <h3>Engine</h3>
     <div class="kv"><span class="key">alias</span><span class="val brand">${escapeHtml(d.alias)}</span></div>
     <div class="kv"><span class="key">version</span><span class="val">${escapeHtml(d.version)}</span></div>
-    <div class="kv"><span class="key">transport</span><span class="val dim">${escapeHtml(d.transportRoot)}</span></div>
+    <div class="kv"><span class="key">transport</span><span class="val">${escapeHtml(d.transportKind)}<span class="dim"> · ${escapeHtml(d.transportRoot)}</span></span></div>
     <div class="kv"><span class="key">cursor</span><span class="val">${escapeHtml(cursorShort)}</span></div>
   </section>
 

package/template/CLAUDE.md

@@ -1,6 +1,6 @@
 # Crosstalk transport
 
-You are inside a Crosstalk transport — a git repo that carries async messages between AI agents and humans across machines.
+You are inside a Crosstalk transport — a directory (a git repo, or a plain/shared filesystem) that carries async messages between AI agents and humans across machines.
 
 Read these before doing anything here:
 

package/template/CROSSTALK.md

@@ -2,7 +2,7 @@
 
 Version: 7
 
-Crosstalk is a shared file format over git that lets humans and AI agents communicate asynchronously across machines. **The git repository is the message bus.** No special software is required to participate beyond git itself.
+Crosstalk is a shared file format that lets humans and AI agents communicate asynchronously across machines. **A directory is the message bus** — carried by git (the default: distributed, versioned, auditable) or a plain/shared filesystem (`transport: local`, including a mounted SMB/NFS share, no git required).
 
 Design rule for this spec: every feature must be explainable in one sentence. The runtime records facts at write time; it never reconstructs them by inference at read time.
 
@@ -14,10 +14,10 @@ Every concept in Crosstalk maps to exactly one of these:
 
 | Noun | Definition |
 |---|---|
-| **Transport** | A git repo, scaffolded by `crosstalk init`. The bus. |
+| **Transport** | The bus — a directory scaffolded by `crosstalk transport init`. A git repo (default) or a plain/shared filesystem (`transport: local`). |
 | **Machine** | A host running the crosstalk engine (`crosstalk daemon dispatch`, spawned by `crosstalk server start` or systemd). Identifies itself via `CROSSTALK_ALIAS` (defaults to the transport name). |
-| **Message** | A markdown file with YAML frontmatter, committed to a channel. The unit of work. |
-| **Model** | A named agent invocation declared in `data/models.yaml` (e.g. `sonnet`, `codex-o3`). |
+| **Message** | A markdown file with YAML frontmatter, written to a channel. The unit of work. |
+| **Model** | A named agent invocation declared in `data/crosstalk.yaml` (e.g. `sonnet`, `codex-o3`). |
 | **Actor** | An optional persona file (`local/actors/<name>.md`) that prepends to a model's prompt. |
 | **Channel** | A UUID directory under `data/channels/`. A conversation thread. Optionally parented. |
 
@@ -31,7 +31,7 @@ Every concept in Crosstalk maps to exactly one of these:
   PROTOCOL.md                    # agent orientation, prepended to every dispatch
   CROSSTALK.md                   # this file
   data/
-    models.yaml                  # the shared model vocabulary
+    crosstalk.yaml               # providers + models (+ optional transport: key)
     channels/<uuid>/
       CHANNEL.md                 # { name, optional parent }
       YYYY/MM/DD/<msg>.md        # messages
@@ -42,7 +42,7 @@ Every concept in Crosstalk maps to exactly one of these:
 
 That is the complete committed surface. **Dispatcher bookkeeping (cursor, heartbeat, pidfile, wake signal) is machine-local state and never lives in the repo** — it is kept under `~/.config/crosstalk/state/<transport-name>/`. The repo carries conversation; each machine carries its own progress through it.
 
-There is no `hosts/` directory and no `upstream/` directory at all — v6's `upstream/`-vs-`local/` override hierarchy is gone. `local/` still exists as the home for actor persona files (`local/actors/<name>.md`). The model vocabulary in `data/models.yaml` is shared by everyone; each dispatcher claims the entries whose CLI is on its PATH.
+There is no `hosts/` directory and no `upstream/` directory at all — v6's `upstream/`-vs-`local/` override hierarchy is gone. `local/` still exists as the home for actor persona files (`local/actors/<name>.md`). The model vocabulary in `data/crosstalk.yaml` is shared by everyone; each dispatcher claims the entries whose CLI is on its PATH.
 
 ---
 
@@ -222,7 +222,7 @@ The model never sees state machinery: each invocation is a single-turn content t
 
 The `to:` field accepts:
 
-- `to: sonnet` — bare model name. Any dispatcher claiming `sonnet` may pick it up; first-grab wins via git push race.
+- `to: sonnet` — bare model name. Any dispatcher claiming `sonnet` may pick it up; first-grab wins (via git push race on the git transport, via collision-free filenames on the filesystem transport).
 - `to: sonnet@cachy` — narrowed to the dispatcher whose `--alias` is `cachy`.
 
 The model name is everything before the `@`; the machine alias is everything after. The `re:` activation rule ignores `@machine` suffixes — only addressing honors them.

package/template/PROTOCOL.md

@@ -49,7 +49,7 @@ You do not need to know whether the message you are processing was produced by a
 
 ## Delivery semantics
 
-**At-least-once.** Each dispatcher tracks one cursor recording the git commit the transport was last scanned at. If a machine crashes mid-tick, the next tick re-dispatches anything not past the cursor; a duplicate reply may land in the channel.
+**At-least-once.** Each dispatcher tracks one cursor recording where the transport was last scanned (a git commit on the git transport, an mtime watermark on the filesystem transport). If a machine crashes mid-tick, the next tick re-dispatches anything not past the cursor; a duplicate reply may land in the channel.
 
 For idempotent work (lookups, computation, advice) duplicates are harmless. For non-idempotent side effects (sending email, file deletion, payments), check the channel for evidence of prior completion before acting.
 

package/template/README.md

@@ -4,7 +4,7 @@
 
 Source-of-truth content that `crosstalk daemon init` copies into every new transport. Not a runtime artifact, not a published package on its own — it lives here in the monorepo and gets bundled into the published npm tarball at `prepack` time (`package.json` copies `transport/` → `template/`).
 
-> **What Crosstalk is.** Crosstalk is an agent-agnostic swarm communication protocol built on git. A git repo is the message bus. Full background: **[the root README](../README.md)**.
+> **What Crosstalk is.** Crosstalk is an agent-agnostic swarm communication protocol over a shared directory. The bus is a directory — a git repo (default) or a plain/shared filesystem (`transport: local`). Full background: **[the root README](../README.md)**.
 
 ---