@mu-crew/mu 3.9.0 → 3.10.0

package/dist/tui-sync-worker.js

@@ -0,0 +1,16 @@
+import {
+  ambientSyncPass,
+  openDb
+} from "./chunk-YIF3X32A.js";
+import "./chunk-4PACTXAB.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/tui/sync-worker.ts
+import { parentPort, workerData } from "worker_threads";
+var port = parentPort;
+if (port === null) throw new Error("tui-sync-worker must run as a worker_thread");
+var db = openDb({ path: workerData.dbPath });
+port.on("message", () => {
+  void ambientSyncPass(db, { quiet: true }).catch(() => null).then((result) => port.postMessage(result));
+});
+//# sourceMappingURL=tui-sync-worker.js.map

package/dist/tui-sync-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/tui/sync-worker.ts"],"sourcesContent":["// worker_thread entry for the TUI's ambient sync pass (built to\n// dist/tui-sync-worker.js). ingest and flush are synchronous SQLite and\n// file work (seconds on a first read, hundreds of ms per peer append on\n// a 40 MB segment), so on ink's thread they froze input and repaints.\n// Here they block only this thread. The worker owns its own connection\n// to the same DB file: WAL serves the TUI's reads meanwhile, and the\n// TUI sees the result on its next read.\n//\n// Protocol: the parent posts any message to start one pass, and the\n// worker replies with the pass's result (`null` if it threw) when the\n// pass is over. ambientSyncPass is total, and `quiet` keeps stderr off\n// the alternate screen.\n\nimport { parentPort, workerData } from \"node:worker_threads\";\nimport { openDb } from \"../../db.js\";\nimport { ambientSyncPass } from \"../../sync.js\";\n\nconst port = parentPort;\nif (port === null) throw new Error(\"tui-sync-worker must run as a worker_thread\");\nconst db = openDb({ path: (workerData as { dbPath: string }).dbPath });\nport.on(\"message\", () => {\n  void ambientSyncPass(db, { quiet: true })\n    .catch(() => null)\n    .then((result) => port.postMessage(result));\n});\n"],"mappings":";;;;;;;;AAaA,SAAS,YAAY,kBAAkB;AAIvC,IAAM,OAAO;AACb,IAAI,SAAS,KAAM,OAAM,IAAI,MAAM,6CAA6C;AAChF,IAAM,KAAK,OAAO,EAAE,MAAO,WAAkC,OAAO,CAAC;AACrE,KAAK,GAAG,WAAW,MAAM;AACvB,OAAK,gBAAgB,IAAI,EAAE,OAAO,KAAK,CAAC,EACrC,MAAM,MAAM,IAAI,EAChB,KAAK,CAAC,WAAW,KAAK,YAAY,MAAM,CAAC;AAC9C,CAAC;","names":[]}

package/dist/yank-T3AYQTVR.js

@@ -0,0 +1,12 @@
+import {
+  osc52Sequence,
+  probeClipboardBackend,
+  yank
+} from "./chunk-77GBZ2KR.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  osc52Sequence,
+  probeClipboardBackend,
+  yank
+};
+//# sourceMappingURL=yank-T3AYQTVR.js.map

package/dist/yank-T3AYQTVR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/docs/ARCHITECTURE.md

@@ -88,7 +88,7 @@ hub that re-exports them. `src/tasks.ts`, `src/agents.ts`, `src/mux.ts`,
 
 | Module | Responsibility |
 | --- | --- |
-| `src/db.ts` | better-sqlite3 connection (WAL); schema v11 (11 tables, 3 views) in `applySchema`; installs capture; owns `SYNCED_ENTITIES`, `PORTABLE_TABLES`, `MACHINE_LOCAL_TABLES`; refuses older (`SchemaTooOldError`) or newer (`SchemaTooNewError`) DBs, exit 4 |
+| `src/db.ts` | better-sqlite3 connection (WAL); schema v11 (12 tables, 3 views) in `applySchema`; installs capture; owns `SYNCED_ENTITIES`, `PORTABLE_TABLES`, `MACHINE_LOCAL_TABLES`; refuses older (`SchemaTooOldError`) or newer (`SchemaTooNewError`) DBs, exit 4 |
 | `src/hlc.ts` | hybrid logical clock, serialized as sortable TEXT |
 | `src/capture.ts` | TEMP triggers recording each portable write as an op, and refusing natural-key changes |
 | `src/op-context.ts` | `withOpContext` (intent, actor, group); `withCaptureSuppressed` echo guard |
@@ -106,6 +106,8 @@ hub that re-exports them. `src/tasks.ts`, `src/agents.ts`, `src/mux.ts`,
 | Module | Responsibility |
 | --- | --- |
 | `src/segments.ts` | JSONL segments: flush own ops, ingest peers from a watermark |
+| `src/segment-manifest.ts` | segment `.manifest` sidecar: read, write, seal, and the self-consistency check the owner's flush runs before trusting it |
+| `src/sha256-resumable.ts` | SHA-256 with a serialisable running state, so the segment manifest hashes only appended bytes |
 | `src/sync.ts` | peer status, the ambient hook, `--from`, `--repair` |
 | `src/file-lock.ts` | cross-process advisory lock through atomic `fs.mkdir` |
 | `src/fleet-hazards.ts` | mixed-fleet checks: DB inside `MU_SYNC_DIR`, network mount, case collisions |
@@ -141,7 +143,7 @@ hub that re-exports them. `src/tasks.ts`, `src/agents.ts`, `src/mux.ts`,
 | `src/ctl/client.ts` | `ctlRequest`, `ctlProbe`, version and unknown-op errors |
 | `extension/mu-pi.ts` | pi extension, child side: serves `$MU_CTL_SOCK`; built to `dist/extension/mu-pi.js` |
 | `extension/delegate.ts` | pi extension, parent side: `mu_delegate` / `mu_delegate_cancel`, which shell out to `mu` |
-| `extension/nudge.ts` | pi extension: the keep-driving nudge. Arms on a `mu` dispatch, checks `mu state --json` at `agent_before_settle`, injects the SKILL.md rule once per prompt, logs `--kind nudge`. Also the close nudge (worker settles owning a task) and the refute nudge (`task claim --for` on a task with no refute decision in `mu task notes --json`; one notice, no continuation) |
+| `extension/nudge.ts` | pi extension: the keep-driving nudge. Arms on a `mu` dispatch, checks `mu state --json` at `agent_before_settle`, injects the SKILL.md rule once per prompt, logs `--kind nudge`. Also the close nudge (worker settles owning a task) and the refute nudge (`task claim --for` on a task with no refute decision in `mu task notes --json`; one notice, no continuation). `parallelSettle` runs the three settle checks in parallel behind one `agent_before_settle` handler and merges their entries; `mu log` breadcrumbs are not awaited |
 | `src/link.ts` | `mu link pi`: extension shim, skill symlink, `inspectLinks` for doctor |
 
 ### Tasks, workspaces and workstreams
@@ -167,14 +169,18 @@ hub that re-exports them. `src/tasks.ts`, `src/agents.ts`, `src/mux.ts`,
 
 | Module | Responsibility |
 | --- | --- |
-| `src/cli.ts` | Commander wiring (`buildProgram`) |
+| `src/main.ts` | the `mu` bin (`dist/cli.js`): enables the compile cache, then `import()`s `src/cli.ts` |
+| `src/compile-cache.ts`, `src/state-dir.ts` | best-effort V8 compile cache under `<state>/compile-cache`; builtins-only state-dir resolution |
+| `src/cli.ts` | Commander wiring (`buildProgram`, `runCli`) |
 | `src/cli/*.ts` | one file per verb namespace, thin wrappers over the SDK; `format.ts` renders tables, `handle.ts` maps errors to exit codes and runs ambient sync |
 | `src/cli/tasks/*.ts` | the `mu task` namespace, including `mu me tasks` / `mu me next` |
 | `src/cli/dispatch-hints.ts` | dispatch-time `Next:` hints for pi agents (`--fresh`, `--interrupt`, abort) |
 | `src/cli/stdin.ts` | `-` as a text argument: reads note / send text from stdin (heredoc prose) |
 | `src/cli/agents-remote.ts` | `mu agent remote-env`: prints the ssh forward and env, runs nothing |
 | `src/cli/tui-launch-focus.ts` | initial-tab focus ladder for bare `mu` and `mu state --tui` |
+| `src/cli/tui-load.ts` | lazy `import()` of the TUI with `NODE_ENV` defaulted to `production` (React prod build) |
 | `src/cli/tui/` | the ink TUI; the only place ink and react are imported |
+| `src/cli/tui/sync-worker.ts` | worker_thread (`dist/tui-sync-worker.js`) running the TUI's slow-tick sync pass off ink's thread |
 | `src/output.ts`, `src/shell-quote.ts` | `printNextSteps` / `errorNextSteps`; POSIX quoting for hints |
 | `src/glyphs.ts` | the one glyph vocabulary (single-cell Nerd Font codepoints) |
 | `src/index.ts` | SDK entry point |

package/docs/architecture/control-socket.md

@@ -132,7 +132,11 @@ probes `refused`, and `mu agent close` or the reaper deletes it.
 when `MU_MANAGED_AGENT` is set (inside a mu-spawned pane) or
 `MU_DELEGATE=0`. The tools shell out to the `mu` CLI (spawn, send,
 `wait --json`, read, abort, close) and only format the CLI's
-`outcome` into a follow-up message. `delegateOutcome`
+`outcome` into a follow-up message. A call runs one
+`mu agent spawn --next-free --send <task> --json` (mu picks the free
+name under its spawn lock and returns the send's `runs`), then one
+`mu agent wait --after-runs <runs>` in the background; with `record`,
+a `mu task show` comes first. `delegateOutcome`
 (`src/agents/delegate.ts`) maps one wait result to `done`, `empty`,
 `error`, `died`, `timeout` or `pending`. The extension imports nothing from pi;
 it types pi's API structurally.

package/docs/architecture/sync.md

@@ -15,7 +15,12 @@ Litestream, cr-sqlite or a peer list, and why the DB must never sit in
 - `flushSegment` appends this machine's unflushed ops to
   `<MU_SYNC_DIR>/<machine_id>.jsonl`.
 - `ingestSegment` reads a peer segment from its watermark into
-  `applyOp`.
+  `applyOp`. Ambient ingest skips a peer that is caught up: the manifest
+  counts the watermark, and the segment's size, exact mtime and
+  manifest sha256 equal what the last clean read to the end recorded
+  (in `sync_fingerprints`). Any change, including a rewrite with a
+  backdated mtime, fails that check, so the full read hashes the file
+  and reports the mismatch. `mu sync` always reads every line.
 - Peer discovery is implicit: every non-self `*.jsonl` is a peer. A
   peer disappears only when its segment is deleted.
 - A Syncthing conflict copy (`<machine>.sync-conflict-….jsonl`) is
@@ -25,7 +30,11 @@ Litestream, cr-sqlite or a peer list, and why the DB must never sit in
 **Single writer per file.** A machine appends only to its own segment,
 so nothing is contended and any folder syncer is adequate. Segments
 are regenerable, so there is no fsync. `src/file-lock.ts` stops two
-local `mu` processes from interleaving partial lines.
+local `mu` processes from interleaving partial lines. A flush never
+appends without that lock: if another process still holds it after
+2 s (15 s for `mu sync`), the flush writes nothing, the ops stay
+pending in `ops`, and the next invocation appends them. A stale lock
+(holder crashed, older than 30 s) is broken as before.
 
 **Only `SYNCED_ENTITIES` and only this machine's ops are flushed.**
 Pane ids and absolute paths never leave the machine, and peers never
@@ -118,8 +127,13 @@ edge puts that are resolvable now but unprojected. It skips ops whose
 parent task is gone and keys with a newer `del`, so a deleted edge is
 never resurrected and an orphan is not retried forever. It runs once
 per ingest pass, not per peer, because an edge in one segment may name
-a task in another. On a healthy DB it is two indexed queries returning
-zero rows.
+a task in another. Ambient ingest runs it only while SQLite's
+`user_version` is 1. `applyIncomingOp` sets that marker in the same
+transaction whenever an op changes a row or defers (`absent`), whether
+it came from a segment, `--from`, or an SDK caller; the repair clears
+it. A process that dies between
+the two leaves the marker set, so the next invocation runs the repair.
+`mu sync` and `--from` always run it.
 
 There is no retry queue. A queue would be a second source of truth and
 would not survive a short-lived `mu` process when the parent arrives

package/docs/guide/dispatch.md

@@ -58,6 +58,10 @@ socket. Pick the mode by what the agent is doing:
   pastes nothing. `--via mux` pastes into the pane on purpose.
 
 After a claim, spawn, or wait, the `Next:` block prints the right send.
+`mu agent spawn --send <text>` spawns and sends the first prompt in one
+call; `--next-free` takes the next free name when `<name>` is taken
+(`worker-1` → `worker-2`; the stem is cut to keep the name within 32
+chars, and it gives up with exit 4 when no free name is near).
 
 ### Non-pi agents
 

package/docs/guide/sql.md

@@ -25,7 +25,7 @@ FAIL-row failure, `6` reaped pane, `7` stall.
 
 ## Read the schema
 
-The schema has 11 tables and 3 views (`ready`, `blocked`, `goals`).
+The schema has 12 tables and 3 views (`ready`, `blocked`, `goals`).
 Four tables travel between machines: `workstreams`, `tasks`,
 `task_edges`, and `task_notes`. List them all:
 

package/docs/reference/env.md

@@ -10,7 +10,7 @@ milliseconds; `0` disables a wait unless noted.
 | Name | Effect | Default |
 | --- | --- | --- |
 | `MU_DB_PATH` | SQLite file path. Wins over the state dir. | `<state-dir>/mu.db` |
-| `MU_STATE_DIR` | State directory. | `$XDG_STATE_HOME/mu` |
+| `MU_STATE_DIR` | State directory. Also holds `compile-cache/` (V8 code cache for the CLI; `NODE_DISABLE_COMPILE_CACHE=1` turns it off). | `$XDG_STATE_HOME/mu` |
 | `XDG_STATE_HOME` | XDG state base; mu appends `mu/`. An empty or relative value is ignored. | `~/.local/state` |
 | `MU_SESSION` | Active workstream when `-w` is absent. | current `mu-<name>` mux session |
 | `MU_SYNC_DIR` | Folder holding one segment per machine. This is the whole sync setup; there is no peer list. | unset: sync off |
@@ -86,6 +86,7 @@ pi agent's `--command`. mu never reads them back.
 | `MU_FORCE_COLOR` | Truthy forces colour on. `""`, `0`, and `false` opt out. Checked before `FORCE_COLOR`. | unset |
 | `MU_NO_TUI` | `1` makes bare `mu` print help instead of opening the TUI. | unset |
 | `MU_TUI_DEBUG_MOUSE` | `1` logs mouse hit-tests to stderr. | unset |
+| `NODE_ENV` | Unset: the TUI loads React's production build. Set it (e.g. `development`) to get React's dev build and warnings. | unset |
 
 ## Tests
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mu-crew/mu",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "description": "A persistent, observable crew of pi agents running in one tmux or herdr session per workstream, coordinated through a built-in task DAG.",
   "publishConfig": {
     "access": "public"