intercomm-aimfp 0.4.0

package/README.md

@@ -0,0 +1,353 @@
+# InterComm AIMFP
+
+Local-only coordination system for multiple Claude Code instances working on the same project. One instance is master, the rest are workers. The master delegates tasks and controls workers via tmux. All state lives in a single SQLite database — no servers, no HTTP, no sockets.
+
+**Requires tmux** and the **AIMFP MCP server**. InterComm AIMFP is a hard AIMFP addon — the worker flow runs `aimfp_run` and `git_create_branch`, and the master integrates each branch via `export_state_changeset` / `apply_state_changeset`. Without the AIMFP MCP server connected (listed in the project's `.mcp.json`), instances can still coordinate and isolate files via worktrees, but there is **no AIMFP tracking and no semantic-changeset merge**. (InterComm's own code stays AIMFP-agnostic — it never reads AIMFP's DB.)
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────┐
+│  User ↔ Master (Claude Code)                        │
+│    │                                                │
+│    ├── tmux send-keys ──→ Worker-1 (tmux session)   │
+│    ├── tmux send-keys ──→ Worker-2 (tmux session)   │
+│    └── tmux send-keys ──→ Worker-N (tmux session)   │
+│                                                     │
+│  All instances share: .intercomm-aimfp/intercomm.db  │
+└─────────────────────────────────────────────────────┘
+```
+
+1. The user talks to the **master** instance only.
+2. The user either tells the master "I have N tmux sessions available" or the master asks "please spin up N tmux sessions for this task."
+3. The master assigns work via `intercomm_assign` — a **thin-pointer task contract** that points the worker at an AIMFP work entity — and **wakes** the worker (via `intercomm_wake` / tmux send-keys).
+4. Each worker registers, reads its contract, runs `aimfp_run` in its own git worktree, continues the assigned AIMFP entity on its own branch, then reports `done` (with `branch` + `commit`) via InterComm.
+5. Workers do **not** poll. They sit idle until the master pushes a prompt via tmux.
+
+InterComm stays **AIMFP-agnostic**: it isolates files (worktrees), carries the pointer contract, and tracks status — it never reads AIMFP's DB and never runs `git merge`. The master uses AIMFP's `export_state_changeset` / `apply_state_changeset` to integrate each worker's DB tracking (see [Integration](#integration)).
+
+## Install
+
+1. Copy the `intercommAIMFP/` folder somewhere permanent on your machine.
+
+2. Install dependencies and build:
+   ```bash
+   cd /path/to/intercommAIMFP
+   npm install
+   npm run build
+   ```
+
+3. Add the MCP server to your project's `.mcp.json` (create it in your project root if it doesn't exist):
+   ```json
+   {
+     "mcpServers": {
+       "intercomm": {
+         "command": "node",
+         "args": ["/absolute/path/to/intercommAIMFP/dist/mcp-entry.js"]
+       }
+     }
+   }
+   ```
+   Replace `/absolute/path/to/intercommAIMFP` with the actual path on your machine.
+
+That's it — there is **no protocol to paste**. The master/worker coordination
+protocol is delivered automatically via the MCP server's `instructions` field the
+moment any instance connects (master or worker), the same way AIMFP injects its
+rules. It travels with the server into every project, so your `CLAUDE.md` stays
+yours (e.g. AIMFP-only) and is never touched. Any instance can re-read the full
+protocol on demand with the `intercomm_get_protocol` tool — useful after a long
+session compacts context. (`system-prompt.md` in this repo is the single in-repo
+source for that injected text; edit it there and rebuild.)
+
+## Install as a Claude Code plugin
+
+InterComm AIMFP is also packaged as a **Claude Code plugin** (the same model as
+AIMFP). Installing the plugin is the supported one-step distribution path — it
+wires up the MCP server, the slash commands, the setup skill, and the hooks in
+any project, and auto-updates the server. The manual `.mcp.json` install above is
+the **development** path (running your local `dist/`); the plugin is the
+**distribution** path. Use one or the other for a given project, not both, or you
+will get a duplicate `intercomm` server.
+
+Once the package is published to npm and this repo is pushed:
+
+```bash
+# add this repo as a plugin marketplace, then install
+claude plugin marketplace add aryanduntley/intercommAIMFP
+claude plugin install intercomm-aimfp
+```
+
+The plugin's `intercomm-plugin/.mcp.json` runs the server via
+`npx -y -p intercomm-aimfp@latest intercomm-mcp`, so npm compiles the native
+`better-sqlite3` binding for each machine on first run and `@latest` keeps the
+server current — no bundled binaries. It ships:
+
+- **MCP server** — all 19 coordination tools, with the protocol auto-injected via the server's `instructions` field.
+- **Commands** — `/register`, `/spawn`, `/status`, `/teardown`.
+- **Skill** — `intercomm-mode` (a tiny setup bootstrap; the real protocol lives in the injected instructions).
+- **Hooks** — a `SessionStart` note on how to begin coordinating.
+
+> **Requires the AIMFP MCP server.** InterComm AIMFP is a hard AIMFP addon. The
+> plugin does not bundle AIMFP — install it separately (its own plugin or
+> `python3 -m aimfp` in your `.mcp.json`). The master's startup preflight warns if
+> the AIMFP tools are absent.
+
+**Local development / testing (before publishing):**
+
+```bash
+# load the plugin straight from this working tree
+claude --plugin-dir /path/to/intercommAIMFP
+```
+
+### Releasing (versioning + publish)
+
+Bump every embedded version in one step, then commit and push — CI publishes:
+
+```bash
+node dev/bump-version.mjs <X.Y.Z>   # syncs package.json + .claude-plugin/plugin.json
+                                    # + the McpServer version in src/mcp-server.ts,
+                                    # resyncs the lockfile, then runs `npm run build`
+git commit -am "release X.Y.Z" && git push
+```
+
+`.github/workflows/publish.yml` publishes `intercomm-aimfp@X.Y.Z` to npm on push to
+`main` whenever the version is new (idempotent). It needs the repo secret
+`NPM_TOKEN`; see the one-time setup below.
+
+### One-time npm + CI setup
+
+Manual, one-time steps to connect GitHub → npm. After these, `bump → commit →
+push` is the whole release.
+
+1. **npm account + name.** Have an npm account and `npm login`. The package name
+   `intercomm-aimfp` must be free or owned by you (currently unpublished).
+2. **First publish by hand.** CI publishes *updates*, but the package must exist
+   first. Once, from the repo root:
+   ```bash
+   npm install && npm run build && npm publish --access public
+   ```
+   (`--access public` is required the first time for an unscoped public package.)
+3. **Create an npm token.** npm → Account → Access Tokens → Generate → **Automation**
+   type (works in CI without 2FA). Copy it.
+4. **Add it to GitHub.** Repo → Settings → Secrets and variables → Actions → New
+   repository secret → name it **`NPM_TOKEN`**, paste the token.
+
+That is the *entire* GitHub↔npm connection. There is **no separate "worker" to
+create** — the workflow file `.github/workflows/publish.yml` *is* the worker;
+GitHub Actions runs it automatically once it is on `main`. (Actions is enabled by
+default. The native `better-sqlite3` build is skipped in CI via `--ignore-scripts`;
+the published artifact is `dist/` + `system-prompt.md`, and the consumer's
+`npx`/`npm install` compiles the native binding.)
+
+## Usage
+
+The master spawns and controls workers itself through InterComm's MCP tools — no shell scripts and no manual tmux setup required. (The `scripts/*.sh` helpers remain as a dev-only fallback; see [Dev scripts](#dev-scripts).)
+
+### 1. Register the master
+
+In your main Claude Code instance, register as master (via the `intercomm_register(role: "master")` tool, or just tell it "you are the master"). This must happen **before** spawning workers, so workers can message `master` on startup.
+
+### 2. Spawn workers automatically
+
+From the master, run:
+
+From the master, call the **`intercomm_spawn`** tool:
+
+```
+intercomm_spawn(count: 3)
+```
+
+This creates 3 detached tmux sessions (`worker-1`, `worker-2`, `worker-3`), launches Claude Code in each (with `INTERCOMM_DB_ROOT` pinned to the shared bus, so they load `.mcp.json` + `CLAUDE.md`), auto-clears the first-run trust / MCP-approval dialogs, and wakes each to register and read its task. It returns immediately with the session list — workers self-register asynchronously, so call `intercomm_status` to confirm the `session ↔ worker-N` mapping.
+
+Useful parameters:
+
+| Param | Effect |
+|---|---|
+| `worktrees: true` | Launch each worker in its own isolated git worktree (branch-per-agent) |
+| `worktree_base` | Git ref each worktree checks out detached (default: `main`) |
+| `bootstrap` | Setup command run inside each new worktree (e.g. `npm install`) |
+| `perm_mode` | `claude --permission-mode` (default: `acceptEdits`; `bypassPermissions` for fully hands-off) |
+| `prefix` | tmux session-name prefix (default: `worker`) |
+| `ready_timeout` | Per-session seconds to clear boot dialogs (default: 20) |
+| `wake: false` | Create + launch only; wake them yourself later via `intercomm_wake` |
+
+### 3. Approve flagged permission prompts
+
+In the default `acceptEdits` mode, workers auto-accept file edits but **pause on Bash and other tools**. A blocked worker is frozen and cannot report over InterComm, so the master polls for them with **`intercomm_scan`**:
+
+```
+intercomm_scan()
+```
+
+It reports each worker pane's state (`blocked`, `trust`, `bypass`, `ready`, `running`, `idle`). Clear any pane that needs attention with **`intercomm_approve`**, which selects the right option for whichever dialog it's on:
+
+```
+intercomm_approve(worker: "worker-1")
+```
+
+To skip approvals entirely, spawn with `perm_mode: "bypassPermissions"`.
+
+### 4. Let it run, then tear down
+
+The master delegates via **`intercomm_assign`** (which builds the thin-pointer task contract, records it, and wakes the worker), monitors with `intercomm_scan` / `intercomm_read`, and collects results. When done, **`intercomm_teardown`** kills the sessions, removes the worktrees, and reaps the registry in one call:
+
+```
+intercomm_assign(
+  worker: "worker-1",
+  role_instructions: "AIMFP user=alice; stay within src/auth/**; report branch+commit when done",
+  target_type: "task", target_id: 42,
+)
+intercomm_teardown()                 # pass worktrees: true if you spawned with worktrees
+```
+
+## Task Contract (thin pointer)
+
+The master does **not** ship prose instructions to a worker. It ships a small JSON **pointer** to an AIMFP work entity; the worker resolves it itself by running `aimfp_run` in its clone and continuing that entity the normal AIMFP way (its own `git_create_branch` on `aimfp-{user}-{number}`, its own tracking + validation). InterComm carries the contract as opaque message content — it never resolves the pointer and never reads `project.db`.
+
+```json
+{
+  "kind": "task_contract",
+  "v": 2,
+  "role": "worker",
+  "role_instructions": "Continue the assigned AIMFP entity. Stay within your assigned files.",
+  "aimfp_target": { "type": "task", "id": 42, "slug": "task-implement-auth-9f3a1c20" },
+  "reportBack": ["branch", "commit"]
+}
+```
+
+| Field | Meaning |
+|---|---|
+| `role` / `role_instructions` | Worker role label + free-form guidance (assigned files, a **distinct AIMFP user identity** per worker so `aimfp-{user}-{number}` branches don't collide). |
+| `aimfp_target` | The AIMFP entity to continue: `type` (task / milestone / subtask / sidequest / item) plus an integer `id` and/or a stable `slug` (at least one). |
+| `reportBack` | Fields the worker returns on `done` — at minimum `branch` + `commit`, so the master can export a changeset from the branch. |
+
+`intercomm_assign` builds this for you; `intercomm_read` shows the worker a validated summary (or an error if the contract is malformed). A worker that can't parse the contract sends a `question` and waits — it never acts on a bad contract.
+
+## Integration
+
+When a worker reports `done`, the master integrates its branch — **source and AIMFP DB state are merged by different mechanisms**:
+
+1. **Text-merge the worker's source** into `main` (normal code review / conflict resolution). The binary `project.db` is **never** git-merged.
+2. **Export the worker's DB tracking** as a semantic changeset: AIMFP `export_state_changeset(base_main_commit, branch)` — an integer-free diff keyed on stable semantic keys.
+3. **Apply it onto main**: AIMFP `apply_state_changeset(changeset)` — a 3-way merge that auto-applies non-overlapping changes, mints canonical IDs, rewrites references, and reports conflicts for the master to resolve.
+4. **Commit** merged source + updated `project.db` to main; move to the next branch.
+
+InterComm only **tracks** the lifecycle (`intercomm_worktree_list` is the master's merge-queue view); the DB merge intelligence lives entirely in AIMFP.
+
+> **Parallel git-worktree runs are supported and validated end-to-end** — 4 workers in isolated worktrees through the full `export_state_changeset` → `apply_state_changeset` merge chain, including concurrent shared-type conflict prediction + resolution. Each worker's AIMFP tracking is committed on its own branch (requires the worktree-aware AIMFP build). One residual AIMFP-side caveat: a worker should treat `<its worktree>/src` as the source dir even if `get_source_directory()` still returns the shared-checkout path — the worker pre-flight guard checks this.
+
+### Dev scripts
+
+`scripts/spawn-workers.sh`, `scan-workers.sh`, and `kill-workers.sh` predate the tools and remain for local development / debugging only — they are **not** a runtime dependency. The MCP tools above are the supported path when InterComm is dropped into any project as an MCP server. (Claude Code's TUI needs a double `Enter` to submit a prompt; the tools and scripts both handle that for you.)
+
+## MCP Tools (19 total)
+
+**Identity & messaging**
+
+| Tool | Description |
+|---|---|
+| `intercomm_register` | Register as master or worker. Initializes DB. Workers auto-assign lowest available `worker-N` name. |
+| `intercomm_send` | Send a direct message to a specific peer. |
+| `intercomm_broadcast` | Broadcast a message to all peers. |
+| `intercomm_read` | Read all new messages since last check. Updates read cursor. For `task` messages, also surfaces the parsed, validated thin-pointer contract. |
+| `intercomm_escalate` | **Worker→master, no polling.** Persist a question/decision to the master AND wake it in its tmux pane (the server does the wake; the worker never touches tmux). Set `needs_user` when the master must ask the human. Returns `{persisted, woke, reason?}`. |
+| `intercomm_assign` | Master-only. Assign work as a thin-pointer task contract (`{role, role_instructions, aimfp_target, reportBack}`): builds it, records the `task` message, and wakes the worker. |
+| `intercomm_status` | Show all instances and their state. |
+| `intercomm_signoff` | Cleanly deactivate this instance before shutting down. |
+| `intercomm_clear` | Delete old messages (master-only). |
+| `intercomm_get_protocol` | Re-read the full master/worker coordination protocol on demand (the same text auto-injected via the server's MCP `instructions` on connect). No registration required. |
+
+**Orchestration (master-only) — the tool-driven lifecycle, no shell scripts**
+
+| Tool | Description |
+|---|---|
+| `intercomm_spawn` | Spawn N workers in detached tmux sessions; launch claude (optionally one git worktree each), auto-clear boot dialogs, wake to self-register. Non-blocking. |
+| `intercomm_wake` | Push a prompt into a worker's pane (resolves a worker id or raw tmux target). |
+| `intercomm_scan` | Report each worker pane's state (blocked / trust / bypass / ready / running / idle). |
+| `intercomm_approve` | Clear a worker's blocking dialog (trust / MCP-approval / bypass / permission prompt). |
+| `intercomm_teardown` | Kill worker sessions, remove their worktrees, and reap the instance rows in one call. |
+
+**Worktree registry (master-only) — branch-per-agent isolation**
+
+| Tool | Description |
+|---|---|
+| `intercomm_worktree_add` | Create an isolated git worktree (detached) for a worker and register it. |
+| `intercomm_worktree_list` | List registered worktrees and their lifecycle status (the merge-queue view). |
+| `intercomm_worktree_set_status` | Update a worktree's status; record the branch a worker reported back. |
+| `intercomm_worktree_remove` | Remove a worker's git worktree and mark it removed. |
+
+## Message Types
+
+| Type | Purpose |
+|---|---|
+| `task` | Master assigns work to a worker |
+| `status` | Instance reports progress |
+| `question` | Instance asks for input |
+| `answer` | Response to a question |
+| `announce` | Broadcast information to all |
+| `done` | Instance signals task completion |
+
+## Storage
+
+All state is stored in `.intercomm-aimfp/intercomm.db` (SQLite, WAL mode) created in the project root. Four tables: `instances` (incl. `tmux_target` for wake/scan/approve), `messages`, `read_cursors` (monotonic `last_read_seq` cursor), and `worktrees` (the branch-per-agent registry).
+
+## Stale Detection
+
+Every tool call updates the instance's `last_active` timestamp. An instance is considered stale after **30 seconds** of inactivity. If the master goes stale, a worker can claim master via `intercomm_register(role: "master")`.
+
+## Troubleshooting
+
+### MCP server fails to start after a Node.js upgrade
+
+`better-sqlite3` is a native (C++) addon compiled against a specific Node.js ABI. If you upgrade Node.js (via `nvm`, a system update, etc.), the prebuilt binary no longer loads and the MCP server exits immediately on startup — so every tool call fails. The give-away error (visible by running the entry point directly) looks like:
+
+```
+The module '.../better-sqlite3/build/Release/better_sqlite3.node'
+was compiled against a different Node.js version using
+NODE_MODULE_VERSION 131. This version of Node.js requires
+NODE_MODULE_VERSION 137.
+```
+
+**Fix:** rebuild the native module against your current Node.js:
+
+```bash
+cd /path/to/intercommAIMFP
+npm rebuild better-sqlite3   # or: npm install
+```
+
+To diagnose MCP startup failures in general, run the entry point manually and watch stderr:
+
+```bash
+node dist/mcp-entry.js   # prints "InterComm AIMFP MCP server error: ..." on failure
+```
+
+## Known Limitations
+
+### Worker Permission Prompts
+
+Claude Code requires approval for certain tool calls (e.g., running bash commands). When a worker hits a permission prompt it **blocks** until answered, and while blocked it cannot report over InterComm — so the master must detect blocked workers by polling their panes.
+
+This is handled, not eliminated:
+- Workers are spawned in `acceptEdits` mode by default (file edits auto-approved; Bash/other still prompt).
+- `intercomm_scan` polls every worker pane and reports which are blocked.
+- The master clears the dialog with `intercomm_approve` (it reads the pane via `capture-pane` and selects the right option via `send-keys`).
+
+**Reduce or remove the prompts further:**
+- Spawn with `--bypass` (`bypassPermissions`) for fully hands-off workers (use with caution — workers run anything unprompted).
+- Pre-approve common operations in `.claude/settings.local.json` (`permissions.allow`), e.g. `Bash(npm run:*)`. The InterComm MCP tools are already allowlisted in this repo.
+
+### tmux Prompt Submission
+
+Claude Code's input requires an extra `Enter` keystroke to submit prompts sent via `tmux send-keys`. Always use `Enter Enter` (double Enter) when waking workers.
+
+## CLI (Debug)
+
+The CLI is for debugging only — normal usage is through MCP tools.
+
+```
+intercomm status                                      Show all instances
+intercomm send --from <id> <to> <message> [--type t]  Send a direct message
+intercomm broadcast --from <id> <message> [--type t]  Broadcast to all
+intercomm read --id <id> [--all]                      Read new messages
+intercomm clear [--keep <n>]                          Clear old messages (default: keep 100)
+```

package/dist/claude-tui.d.ts

@@ -0,0 +1,7 @@
+export type PaneState = "trust" | "mcp_approval" | "bypass" | "blocked" | "ready" | "running" | "idle";
+export type KeyGroup = readonly string[];
+export declare const detectPaneState: (capture: string) => PaneState;
+export declare const clearKeystrokes: (state: PaneState) => readonly KeyGroup[];
+export declare const isBooted: (state: PaneState) => boolean;
+export declare const isBlocking: (state: PaneState) => boolean;
+//# sourceMappingURL=claude-tui.d.ts.map

package/dist/claude-tui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-tui.d.ts","sourceRoot":"","sources":["../src/claude-tui.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,SAAS,GACjB,OAAO,GACP,cAAc,GACd,QAAQ,GACR,SAAS,GACT,OAAO,GACP,SAAS,GACT,MAAM,CAAC;AAGX,MAAM,MAAM,QAAQ,GAAG,SAAS,MAAM,EAAE,CAAC;AAYzC,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,SAQjD,CAAC;AAQF,eAAO,MAAM,eAAe,GAAI,OAAO,SAAS,KAAG,SAAS,QAAQ,EAYnE,CAAC;AAIF,eAAO,MAAM,QAAQ,GAAI,OAAO,SAAS,KAAG,OACF,CAAC;AAG3C,eAAO,MAAM,UAAU,GAAI,OAAO,SAAS,KAAG,OACX,CAAC"}

package/dist/claude-tui.js

@@ -0,0 +1,55 @@
+// Pure logic for reading and clearing Claude Code's terminal (TUI) dialogs.
+//
+// Ported from scripts/spawn-workers.sh (wait_ready) and scripts/scan-workers.sh.
+// NO IO here — these functions take a captured pane string and return a state, or
+// the keystrokes that would clear it. tmux-wrapper.ts carries the keystrokes; the
+// spawn/scan/approve tools compose the two. Keeping detection pure makes the
+// dialog matrix unit-testable without a live tmux or Claude process.
+const TRUST_RE = /trust the files|do you trust/i;
+const MCP_RE = /new MCP servers found|Select any you wish to enable/i;
+const BYPASS_RE = /Yes, I accept/i;
+const BLOCKED_RE = /do you want to proceed/i;
+const READY_RE = /for shortcuts|shift\+tab to cycle|accept edits on|bypass permissions on|plan mode on|auto mode on/i;
+const RUNNING_RE = /esc to interrupt|tokens|Brewed|Thinking|Working|Running/i;
+// Classify a captured pane. Blocking dialogs first (so a stuck pane is never
+// reported "running"), then ready before running, then idle as the fallback.
+export const detectPaneState = (capture) => {
+    if (BLOCKED_RE.test(capture))
+        return "blocked";
+    if (TRUST_RE.test(capture))
+        return "trust";
+    if (MCP_RE.test(capture))
+        return "mcp_approval";
+    if (BYPASS_RE.test(capture))
+        return "bypass";
+    if (READY_RE.test(capture))
+        return "ready";
+    if (RUNNING_RE.test(capture))
+        return "running";
+    return "idle";
+};
+// The keystroke groups that clear a blocking dialog, in order. Each group is one
+// send-keys call; callers pause between groups (the bypass warning needs the "2"
+// selection to register before Enter confirms). Non-blocking states return [].
+//   trust / blocked -> option 1 (Yes / accept) + Enter
+//   mcp_approval    -> bare Enter (servers are pre-checked)
+//   bypass          -> "2" (Yes, I accept), then Enter  [default is "1. No, exit"]
+export const clearKeystrokes = (state) => {
+    switch (state) {
+        case "trust":
+        case "blocked":
+            return [["1", "Enter"]];
+        case "mcp_approval":
+            return [["Enter"]];
+        case "bypass":
+            return [["2"], ["Enter"]];
+        default:
+            return [];
+    }
+};
+// True once a pane has booted past first-run dialogs and is usable (ready or
+// actively running). spawn's bounded clear-loop uses this to know it can stop.
+export const isBooted = (state) => state === "ready" || state === "running";
+// True when the pane is stuck on a dialog that a keystroke can clear.
+export const isBlocking = (state) => clearKeystrokes(state).length > 0;
+//# sourceMappingURL=claude-tui.js.map

package/dist/claude-tui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-tui.js","sourceRoot":"","sources":["../src/claude-tui.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,EAAE;AACF,iFAAiF;AACjF,kFAAkF;AAClF,kFAAkF;AAClF,6EAA6E;AAC7E,qEAAqE;AAwBrE,MAAM,QAAQ,GAAG,+BAA+B,CAAC;AACjD,MAAM,MAAM,GAAG,sDAAsD,CAAC;AACtE,MAAM,SAAS,GAAG,gBAAgB,CAAC;AACnC,MAAM,UAAU,GAAG,yBAAyB,CAAC;AAC7C,MAAM,QAAQ,GACZ,oGAAoG,CAAC;AACvG,MAAM,UAAU,GAAG,0DAA0D,CAAC;AAE9E,6EAA6E;AAC7E,6EAA6E;AAC7E,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,OAAe,EAAa,EAAE;IAC5D,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,SAAS,CAAC;IAC/C,IAAI,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,OAAO,CAAC;IAC3C,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,cAAc,CAAC;IAChD,IAAI,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,QAAQ,CAAC;IAC7C,IAAI,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,OAAO,CAAC;IAC3C,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,SAAS,CAAC;IAC/C,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,iFAAiF;AACjF,iFAAiF;AACjF,+EAA+E;AAC/E,uDAAuD;AACvD,4DAA4D;AAC5D,mFAAmF;AACnF,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAgB,EAAuB,EAAE;IACvE,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,OAAO,CAAC;QACb,KAAK,SAAS;YACZ,OAAO,CAAC,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC;QAC1B,KAAK,cAAc;YACjB,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;QACrB,KAAK,QAAQ;YACX,OAAO,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;QAC5B;YACE,OAAO,EAAE,CAAC;IACd,CAAC;AACH,CAAC,CAAC;AAEF,6EAA6E;AAC7E,+EAA+E;AAC/E,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAgB,EAAW,EAAE,CACpD,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,SAAS,CAAC;AAE3C,sEAAsE;AACtE,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAgB,EAAW,EAAE,CACtD,eAAe,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC"}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// CLI entry point — debug-only interface for InterComm AIMFP
+import { initDb, closeDb, resolveRoot } from "./db.js";
+import * as store from "./store.js";
+// --- Pure argument parsing ---
+const parseArgs = (argv) => {
+    const args = argv.slice(2);
+    const command = args[0] ?? "";
+    const positional = [];
+    const flags = {};
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            if (next && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { command, positional, flags };
+};
+const getRoot = () => resolveRoot(process.cwd());
+// --- Command handlers ---
+const cmdInit = () => {
+    initDb(getRoot());
+    console.log("InterComm AIMFP initialized. DB ready.");
+};
+const cmdStatus = () => {
+    initDb(getRoot());
+    const instances = store.getAllInstances();
+    if (instances.length === 0) {
+        console.log("No instances registered.");
+        return;
+    }
+    console.log("Instances:");
+    for (const inst of instances) {
+        console.log(store.formatInstanceForDisplay(inst));
+    }
+};
+const cmdRegister = (args) => {
+    initDb(getRoot());
+    const role = args.positional[0] ?? "worker";
+    if (role !== "master" && role !== "worker") {
+        console.error("Usage: intercomm register [master|worker]");
+        process.exit(1);
+    }
+    const sessionId = `cli-${Date.now()}`;
+    const instance = store.registerAs(role, sessionId);
+    console.log(`Registered as "${instance.id}" (${instance.role})`);
+};
+const cmdSend = (args) => {
+    initDb(getRoot());
+    const from = args.flags["from"];
+    const to = args.positional[0];
+    const content = args.positional.slice(1).join(" ");
+    const type = args.flags["type"] ?? "status";
+    if (!from || !to || !content) {
+        console.error("Usage: intercomm send --from <id> <to> <message> [--type <type>]");
+        process.exit(1);
+    }
+    store.insertMessage(from, to, type, content);
+    store.touchInstance(from);
+    console.log(`Sent (${type}) to ${to}`);
+};
+const cmdBroadcast = (args) => {
+    initDb(getRoot());
+    const from = args.flags["from"];
+    const content = args.positional.join(" ");
+    const type = args.flags["type"] ?? "announce";
+    if (!from || !content) {
+        console.error("Usage: intercomm broadcast --from <id> <message> [--type <type>]");
+        process.exit(1);
+    }
+    store.insertMessage(from, "all", type, content);
+    store.touchInstance(from);
+    console.log(`Broadcast (${type}) to all`);
+};
+const cmdRead = (args) => {
+    initDb(getRoot());
+    const id = args.flags["id"];
+    const readAll = args.flags["all"] === true;
+    if (!id) {
+        console.error("Usage: intercomm read --id <instance-id> [--all]");
+        process.exit(1);
+    }
+    const messages = store.readNewMessages(id, readAll);
+    if (messages.length === 0) {
+        console.log("No new messages.");
+        return;
+    }
+    console.log(`--- ${messages.length} message(s) ---`);
+    for (const msg of messages) {
+        console.log(store.formatMessageForDisplay(msg));
+    }
+};
+const cmdClear = (args) => {
+    initDb(getRoot());
+    const keep = parseInt(args.flags["keep"], 10) || 100;
+    const deleted = store.clearOldMessages(keep);
+    console.log(`Cleared ${deleted} old messages (kept last ${keep}).`);
+};
+const USAGE = `InterComm AIMFP — Debug CLI
+
+Commands:
+  init                                    Initialize DB
+  status                                  Show all instances
+  register [master|worker]                Register as master or worker (default: worker)
+  send --from <id> <to> <message> [--type <type>]   Send a direct message
+  broadcast --from <id> <message> [--type <type>]    Broadcast to all
+  read --id <id> [--all]                  Read new messages
+  clear [--keep <n>]                      Clear old messages (default: keep 100)
+
+Message types: task, status, question, answer, announce, done
+`;
+// --- Main dispatch ---
+const commands = {
+    init: cmdInit,
+    status: cmdStatus,
+    register: cmdRegister,
+    send: cmdSend,
+    broadcast: cmdBroadcast,
+    read: cmdRead,
+    clear: cmdClear,
+};
+const main = () => {
+    const args = parseArgs(process.argv);
+    const handler = commands[args.command];
+    if (!handler) {
+        console.log(USAGE);
+        process.exit(args.command ? 1 : 0);
+    }
+    handler(args);
+    closeDb();
+};
+main();
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+export declare const STALE_THRESHOLD_MS = 30000;
+export declare const DEFAULT_KEEP = 100;
+export declare const ENV_DB_ROOT = "INTERCOMM_DB_ROOT";
+export declare const basePath: (root: string) => string;
+export declare const dbFile: (root: string) => string;
+export declare const resolveDbRoot: (opts: {
+    cwd: string;
+    envRoot?: string | undefined;
+    gitCommonDir?: string | null | undefined;
+}) => string;
+export declare const worktreesDir: (root: string) => string;
+export declare const worktreePath: (root: string, workerId: string) => string;
+export declare const rootMismatchWarning: (resolvedRoot: string, cwd: string) => string | null;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAE/C,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,MAAmC,CAAC;AAE5E,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,KAAG,MACF,CAAC;AASrC,eAAO,MAAM,aAAa,GAAI,MAAM;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC1C,KAAG,MAKH,CAAC;AAIF,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,MACH,CAAC;AAE1C,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,UAAU,MAAM,KAAG,MAC1B,CAAC;AASrC,eAAO,MAAM,mBAAmB,GAC9B,cAAc,MAAM,EACpB,KAAK,MAAM,KACV,MAAM,GAAG,IAOX,CAAC"}

package/dist/config.js

@@ -0,0 +1,44 @@
+// Pure functions for paths and constants
+import { dirname, join, resolve } from "node:path";
+const BASE_DIR_NAME = ".intercomm-aimfp";
+const DB_FILE_NAME = "intercomm.db";
+const WORKTREES_DIR_NAME = ".intercomm-worktrees";
+export const STALE_THRESHOLD_MS = 30_000;
+export const DEFAULT_KEEP = 100;
+export const ENV_DB_ROOT = "INTERCOMM_DB_ROOT";
+export const basePath = (root) => join(root, BASE_DIR_NAME);
+export const dbFile = (root) => join(basePath(root), DB_FILE_NAME);
+// Resolve the directory that holds the SHARED intercomm.db. With one worktree
+// per worker, the launch cwd differs per worker, so the bus must be pinned to a
+// single path. Precedence (all inputs supplied by the caller's IO layer):
+//   1. an explicit INTERCOMM_DB_ROOT override (exported by spawn-workers.sh),
+//   2. the parent of the repo's common git dir (same for every linked worktree),
+//   3. the launch cwd (non-git / single-tree fallback).
+// Pure: it only transforms the strings it is given.
+export const resolveDbRoot = (opts) => {
+    const env = opts.envRoot?.trim();
+    if (env)
+        return env;
+    if (opts.gitCommonDir)
+        return dirname(opts.gitCommonDir);
+    return opts.cwd;
+};
+// Default on-disk location for a worker's worktree: a sibling of the repo root
+// (outside the main checkout, so git does not recursively scan it).
+export const worktreesDir = (root) => resolve(root, "..", WORKTREES_DIR_NAME);
+export const worktreePath = (root, workerId) => join(worktreesDir(root), workerId);
+// Warn when the resolved bus root differs from the launch cwd — the signature of a
+// project nested inside ANOTHER git repo: with no INTERCOMM_DB_ROOT pin, resolveDbRoot
+// falls back to the parent of the git-common-dir, which for a nested checkout is the
+// OUTER repo's root, not this project's. That mis-root makes intercomm_spawn(worktrees)
+// create worktrees of the wrong repo (the Run-1 live-test bug). Pure: returns null when
+// root == cwd. The caller suppresses it when INTERCOMM_DB_ROOT was explicitly set
+// (root != cwd is then intentional, e.g. a pinned shared bus).
+export const rootMismatchWarning = (resolvedRoot, cwd) => {
+    if (resolve(resolvedRoot) === resolve(cwd))
+        return null;
+    return (`WARNING: InterComm bus root (${resolvedRoot}) differs from the launch directory (${cwd}). ` +
+        `If this project is nested inside another git repository, spawned worktrees may be created from the WRONG repo. ` +
+        `Pin INTERCOMM_DB_ROOT to the intended project root, or launch from a standalone (non-nested) checkout before spawning.`);
+};
+//# sourceMappingURL=config.js.map