agent-relay 0.1.0 → 1.0.0

package/docs/TMUX_IMPLEMENTATION_NOTES.md

@@ -0,0 +1,364 @@
+# tmux Implementation Notes
+
+## Previous Failure Analysis
+
+### What Failed: "Game never even started"
+
+The previous tmux implementation had these issues:
+
+1. **Nested PTY Attachment**: Created tmux session, then attached via node-pty
+   ```typescript
+   // Created tmux session
+   execSync(`tmux new-session -d -s ${session} '${command}'`);
+   // Then attached via PTY
+   this.ptyProcess = pty.spawn('tmux', ['attach-session', '-t', session]);
+   ```
+   This creates: Agent CLI → tmux → tmux attach → node-pty
+   Double terminal layer causes escape sequence issues.
+
+2. **Command Quoting Problem**: Single quotes break complex commands
+   ```bash
+   tmux new-session -d -s session 'claude -p "You're playing..."'
+   # The apostrophe in "You're" breaks the quoting
+   ```
+
+3. **Environment Variables Not Passed**: ENV vars set on attach, not on session
+   - The agent process inside tmux doesn't see AGENT_RELAY_NAME
+
+4. **No Session Ready Wait**: Attached immediately after creating session
+   - Session might not be ready, causing race conditions
+
+## New Architecture: No Attachment
+
+```
+┌──────────────────────────────────┐
+│  tmux session "relay-AgentX"     │
+│  (detached, running in background)│
+│  ┌────────────────────────────┐  │
+│  │  agent CLI process         │  │
+│  │  (claude, codex, etc)      │  │
+│  └────────────────────────────┘  │
+└──────────────────────────────────┘
+         ↑                    ↓
+    send-keys            capture-pane
+    (inject input)       (read output)
+         │                    │
+┌──────────────────────────────────┐
+│  TmuxWrapper (this process)      │
+│  - Polls capture-pane @ 100ms    │
+│  - Detects new output (diff)     │
+│  - Parses @relay: commands       │
+│  - Writes to stdout for user     │
+│  - Injects messages via send-keys│
+│  - Forwards user stdin to tmux   │
+└──────────────────────────────────┘
+```
+
+## Key Differences from Previous Implementation
+
+1. **No PTY attachment** - Eliminates double-terminal problem
+2. **capture-pane polling** - Direct access to terminal content
+3. **Proper command escaping** - Use shell escaping, not simple quotes
+4. **Environment via tmux** - Set ENV in tmux session directly
+5. **Session ready wait** - Wait for session to be active before proceeding
+
+## Implementation Details
+
+### Starting a Session
+
+```bash
+# Set environment variables IN the tmux session
+tmux new-session -d -s relay-AgentX \
+  -x 120 -y 40 \
+  "export AGENT_RELAY_NAME=AgentX; exec claude"
+```
+
+### Capturing Output
+
+```bash
+# Capture entire scrollback (not just visible pane)
+tmux capture-pane -t relay-AgentX -p -S -
+```
+
+### Sending Input
+
+```bash
+# Use -l for literal string (no escaping needed)
+tmux send-keys -t relay-AgentX -l "Your message here"
+tmux send-keys -t relay-AgentX Enter
+```
+
+### Handling User Input
+
+Forward process stdin to tmux session:
+```typescript
+process.stdin.on('data', (data) => {
+  execSync(`tmux send-keys -t ${session} -l "${escape(data)}"`);
+});
+```
+
+## Edge Cases to Handle
+
+1. **Fast output**: capture-pane might miss fast scrolling
+   - Solution: Use -S - to get full scrollback, diff against last capture
+
+2. **Binary/escape sequences**: Output might contain control characters
+   - Solution: Strip ANSI codes before parsing @relay:
+
+3. **Session death**: tmux session might exit
+   - Solution: Monitor with `tmux has-session -t session`
+
+4. **Multiple messages**: Several @relay: in one capture
+   - Solution: Track last processed line/position
+
+5. **Stdin race conditions**: User types while we inject
+   - Solution: Queue injections, use mutex/lock
+
+## Testing Plan
+
+1. **Basic session start**: Does claude actually launch in tmux?
+2. **Output capture**: Can we see claude's output?
+3. **Input injection**: Can we send text and get response?
+4. **@relay detection**: Does parser find @relay: commands?
+5. **Full game**: Two agents playing tic-tac-toe
+
+## Rollback Plan
+
+If this doesn't work, fall back to:
+1. File-based inbox (already implemented)
+2. Hook-based polling (Claude only)
+3. Spawn-per-message (loses context)
+
+---
+
+## Implementation Complete - Testing Instructions
+
+### Build Status: SUCCESS
+
+The new TmuxWrapper has been implemented at:
+- `src/wrapper/tmux-wrapper.ts`
+
+CLI updated to support `--tmux2` flag.
+
+### Quick Test: Basic Session Start
+
+```bash
+# Test 1: Does bash work in tmux?
+node dist/cli/index.js wrap --tmux2 -n TestAgent -- bash
+
+# You should see:
+# - "Mode: tmux2 (new simplified tmux wrapper)"
+# - Bash prompt in your terminal
+# - Type commands, they should work
+# - Ctrl+C to exit
+```
+
+### Test 2: Simple Echo Command
+
+```bash
+# Start with echo (should immediately show output and exit)
+node dist/cli/index.js wrap --tmux2 -n TestAgent -- echo "Hello World"
+```
+
+### Test 3: Claude CLI (No Relay)
+
+```bash
+# Test Claude starts correctly
+node dist/cli/index.js wrap --tmux2 -n PlayerX -- claude
+
+# Expected: Claude CLI starts, you can interact with it
+```
+
+### Test 4: With Relay Daemon
+
+```bash
+# Terminal 1: Start daemon
+node dist/cli/index.js start -f
+
+# Terminal 2: Start PlayerX
+node dist/cli/index.js wrap --tmux2 -n PlayerX -- claude
+
+# Terminal 3: Start PlayerO
+node dist/cli/index.js wrap --tmux2 -n PlayerO -- claude
+
+# Terminal 4: Send a test message
+node dist/cli/index.js send -f Coordinator -t PlayerX -m "Hello from Coordinator"
+
+# Expected: PlayerX terminal should show the message and inject it
+```
+
+### Test 5: Tic-Tac-Toe
+
+```bash
+# Terminal 1: Daemon
+node dist/cli/index.js start -f
+
+# Terminal 2: PlayerX
+node dist/cli/index.js wrap --tmux2 -n PlayerX -- claude -p "You are PlayerX playing tic-tac-toe. Use @relay:PlayerO to send moves. Start with your first move."
+
+# Terminal 3: PlayerO
+node dist/cli/index.js wrap --tmux2 -n PlayerO -- claude -p "You are PlayerO playing tic-tac-toe. Use @relay:PlayerX to send moves. Wait for PlayerX to start."
+```
+
+### Debugging
+
+```bash
+# Check if tmux session exists
+tmux list-sessions
+
+# Attach to session manually to see what's happening
+tmux attach -t relay-PlayerX-<pid>
+
+# Kill stuck sessions
+tmux kill-server
+```
+
+### Key Differences from Old tmux Implementation
+
+1. **No PTY attachment** - We don't `tmux attach` via node-pty
+2. **capture-pane polling** - Read output by polling, not events
+3. **send-keys -l** - Use literal mode for text injection
+4. **Environment via tmux setenv** - Set ENV vars in tmux session directly
+5. **Simpler architecture** - Less layers = fewer failure points
+
+---
+
+## Test Results - December 19, 2025
+
+### Basic Test: PASSED
+
+Message injection into bash session works:
+
+```
+[daemon] Agent registered: TestAgent
+[router] Coordinator -> TestAgent: Hello TestAgent!...
+[router] Delivered to TestAgent: success
+[tmux:TestAgent] ← Coordinator: Hello TestAgent!...
+[tmux:TestAgent] Injecting message from Coordinator
+[tmux:TestAgent] Message injected successfully
+bash-3.2$ Relay message from Coordinator: Hello TestAgent!
+```
+
+The message was successfully typed into the bash terminal via tmux send-keys.
+
+### What Works
+
+1. **Session creation** - tmux session starts correctly
+2. **Output capture** - capture-pane polling detects new output
+3. **Relay connection** - Agent connects to daemon
+4. **Message routing** - Messages route between agents
+5. **Message injection** - Text is typed into the terminal via send-keys
+
+### Next Steps
+
+1. Test with Claude CLI (replace bash with claude)
+2. Test full tic-tac-toe game between two agents
+3. Verify @relay: command parsing works in both directions
+4. Check if multi-round injection remains stable (previous implementations failed after 2-3 rounds)
+
+### Critical Question
+
+Does this implementation avoid the "fails after a few rounds" problem? The key difference:
+
+- **Old approach**: PTY stdin write (`ptyProcess.write()`) - corrupts over time
+- **New approach**: tmux send-keys (`tmux send-keys -l "..."`) - should be more stable
+
+---
+
+## December 19, 2025 - Attach-Based Implementation: SUCCESS
+
+### Problem with First tmux Attempt
+
+The first tmux wrapper tried to:
+1. Poll `capture-pane` for output
+2. Write output to stdout
+3. This caused display corruption after message injection
+
+### Solution: Direct Attach
+
+New architecture:
+1. Start agent in detached tmux session
+2. **Attach user directly** via `spawn('tmux', ['attach'], { stdio: 'inherit' })`
+3. Background polling is **completely silent** (no stdout writes)
+4. Injection via `send-keys` works on attached session
+5. Logs only to stderr
+
+### Test Result: PASSED
+
+Message injection works without display corruption:
+```bash
+# Terminal 1: Daemon
+node dist/cli/index.js start -f
+
+# Terminal 2: Agent
+node dist/cli/index.js wrap --tmux2 -n PlayerX -- claude
+
+# Terminal 3: Send message
+node dist/cli/index.js send -f Test -t PlayerX -m "Hello!"
+# → Message injected successfully, display intact
+```
+
+### Next: Multi-Round Tic-Tac-Toe Test
+
+The critical test is whether injection remains stable over multiple rounds:
+```bash
+# Terminal 1: Daemon
+node dist/cli/index.js start -f
+
+# Terminal 2: PlayerX
+node dist/cli/index.js wrap --tmux2 -n PlayerX -- claude -p "Play tic-tac-toe. Use @relay:PlayerO to send moves."
+
+# Terminal 3: PlayerO
+node dist/cli/index.js wrap --tmux2 -n PlayerO -- claude -p "Play tic-tac-toe. Use @relay:PlayerX to send moves."
+```
+
+If this works for a full game (5-9 moves), we've solved the problem.
+
+---
+
+## December 19, 2025 - Command Quoting Fix
+
+### Problem
+
+Running with `-p` flag failed:
+```bash
+node dist/cli/index.js wrap --tmux2 -n PlayerX -- claude -p "You are PlayerX..."
+# Result: Claude terminal didn't open
+```
+
+### Root Cause
+
+The CLI was joining all command parts into a single string at line 229:
+```typescript
+const command = commandParts.join(' ');
+```
+
+And passing only this joined string to TmuxWrapper. But by the time args reach Node.js,
+the shell has already stripped the outer quotes, so `commandParts` = `['claude', '-p', 'You are PlayerX...']`.
+
+When joined back together without re-quoting: `claude -p You are PlayerX...` - the prompt is split.
+
+### Fix
+
+1. **CLI (index.ts)**: Split command and args separately:
+   ```typescript
+   const [mainCommand, ...commandArgs] = commandParts;
+   // Pass to TmuxWrapper as:
+   // command: mainCommand ('claude')
+   // args: commandArgs (['-p', 'You are PlayerX...'])
+   ```
+
+2. **TmuxWrapper**: `buildCommand()` re-quotes args containing spaces:
+   ```typescript
+   private buildCommand(): string {
+     const quotedArgs = this.config.args.map(arg => {
+       if (arg.includes(' ') || arg.includes('"') || arg.includes("'")) {
+         return `"${arg.replace(/"/g, '\\"')}"`;
+       }
+       return arg;
+     });
+     return `${this.config.command} ${quotedArgs.join(' ')}`;
+   }
+   ```
+
+Result: `claude -p "You are PlayerX..."` is correctly sent to tmux.

package/docs/removable-code-analysis.md

@@ -0,0 +1,24 @@
+# Removable Code Analysis
+
+Requested: identify code/assets likely safe to remove (unused, legacy, or duplicates).
+
+## Candidates
+1) `run-dashboard.js`  
+   - Purpose: helper to start dashboard from built `dist/dashboard/server.js`.  
+   - Evidence: Dashboard now exposed via CLI subcommand `dashboard` in `src/cli/index.ts`. No `rg` references to `run-dashboard.js`. Redundant helper.
+
+2) `scripts/games/*` and `scripts/tictactoe-setup.sh`  
+   - Purpose: old demo/game scripts (hearts/tictactoe).  
+   - Evidence: Not referenced by CLI commands or docs (checked with `rg`). Pure examples; removable if demos not needed.
+
+3) `src/hooks/check-inbox.sh`  
+   - Purpose: legacy hook example for Claude stop-event inbox check.  
+   - Evidence: Replaced by compiled hook in `dist/hooks/inbox-check/*` and TypeScript sources in `src/hooks/inbox-check/*`. No other references via `rg`, so redundant.
+
+4) `coverage/` directory  
+   - Purpose: test coverage artifacts.  
+   - Evidence: Generated output; not source. Safe to delete/regenerate.
+
+5) `TOMORROW.md`  
+   - Purpose: session notes / planning doc.  
+   - Evidence: Not used by runtime or tests; optional to keep for historical notes only.

package/install.sh

@@ -42,8 +42,16 @@ install_source() {
         curl -fsSL "https://github.com/$REPO/archive/main.tar.gz" | tar -xz -C "$INSTALL_DIR" --strip-components=1
     fi
 
-    cd "$INSTALL_DIR" && npm ci && npm run build
-    ln -sf "$INSTALL_DIR/dist/cli/index.js" "$BIN_DIR/agent-relay"
+    cd "$INSTALL_DIR" && npm ci && npm rebuild better-sqlite3 && npm run build
+
+    # Remove any existing symlink or file (old installs used symlinks which cause issues)
+    rm -f "$BIN_DIR/agent-relay"
+
+    # Create wrapper script that runs from install dir (for node_modules resolution)
+    cat > "$BIN_DIR/agent-relay" << WRAPPER
+#!/usr/bin/env bash
+cd "$INSTALL_DIR" && exec node dist/cli/index.js "\$@"
+WRAPPER
     chmod +x "$BIN_DIR/agent-relay"
 
     [[ ":$PATH:" != *":$BIN_DIR:"* ]] && warn "Add to PATH: export PATH=\"\$PATH:$BIN_DIR\""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Real-time agent-to-agent communication system",
   "type": "module",
   "main": "dist/index.js",
@@ -12,9 +12,8 @@
     "dist/",
     "install.sh",
     "README.md",
-    "PROTOCOL.md",
-    "CHANGELOG.md",
-    "LICENSE"
+    "LICENSE",
+    "docs/"
   ],
   "publishConfig": {
     "access": "public"

package/dist/games/index.d.ts

@@ -1,2 +0,0 @@
-export * from './tictactoe.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/games/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/games/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/games/index.js

@@ -1,2 +0,0 @@
-export * from './tictactoe.js';
-//# sourceMappingURL=index.js.map

package/dist/games/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/games/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/games/tictactoe.d.ts

@@ -1,24 +0,0 @@
-/**
- * Tic-Tac-Toe Setup Helpers
- *
- * This is a lightweight “game module” focused on generating instructions and
- * directory setup for manual or scripted agent runs.
- *
- * It intentionally does NOT spawn agent processes (that stays in CLI tooling),
- * and it uses the inbox CLI commands (`inbox-poll`, `inbox-write`) so it works
- * with any agent runtime.
- */
-export interface TicTacToeSetupOptions {
-    dataDir: string;
-    playerX?: string;
-    playerO?: string;
-}
-export interface TicTacToeSetupResult {
-    dataDir: string;
-    playerX: string;
-    playerO: string;
-    instructionsXPath: string;
-    instructionsOPath: string;
-}
-export declare function setupTicTacToe(options: TicTacToeSetupOptions): TicTacToeSetupResult;
-//# sourceMappingURL=tictactoe.d.ts.map

package/dist/games/tictactoe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tictactoe.d.ts","sourceRoot":"","sources":["../../src/games/tictactoe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAwID,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,oBAAoB,CAmBnF"}

package/dist/games/tictactoe.js

@@ -1,160 +0,0 @@
-/**
- * Tic-Tac-Toe Setup Helpers
- *
- * This is a lightweight “game module” focused on generating instructions and
- * directory setup for manual or scripted agent runs.
- *
- * It intentionally does NOT spawn agent processes (that stays in CLI tooling),
- * and it uses the inbox CLI commands (`inbox-poll`, `inbox-write`) so it works
- * with any agent runtime.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-function instructionsForPlayerX(dataDir, playerX, playerO) {
-    return `# Tic-Tac-Toe Autonomous Game Protocol
-
-You are **${playerX}** (X). You play FIRST. Your opponent is **${playerO}** (O).
-
-## Board Positions
-\`\`\`
- 1 | 2 | 3
------------
- 4 | 5 | 6
------------
- 7 | 8 | 9
-\`\`\`
-
-## Commands Available
-You have these \`agent-relay\` commands to communicate:
-
-**Wait for opponent's message (blocking):**
-\`\`\`bash
-agent-relay inbox-poll -n ${playerX} -d ${dataDir} --clear
-\`\`\`
-
-**Send a move to opponent:**
-\`\`\`bash
-agent-relay inbox-write -t ${playerO} -f ${playerX} -m "MOVE: X at position N" -d ${dataDir}
-\`\`\`
-
-## PROTOCOL (follow EXACTLY)
-
-### Since you're X, you go FIRST:
-1. Make your first move to position 5 (center)
-2. Send it to opponent:
-   \`\`\`bash
-   agent-relay inbox-write -t ${playerO} -f ${playerX} -m "MOVE: X at position 5" -d ${dataDir}
-   \`\`\`
-
-### Then enter the game loop:
-1. **WAIT** for opponent's response (this will block until they respond):
-   \`\`\`bash
-   agent-relay inbox-poll -n ${playerX} -d ${dataDir} --clear
-   \`\`\`
-
-2. **UPDATE** your mental board state with opponent's move
-
-3. **CHECK** for win/draw. If game over, send result and announce:
-   \`\`\`bash
-   agent-relay inbox-write -t ${playerO} -f ${playerX} -m "GAME OVER: X wins!" -d ${dataDir}
-   \`\`\`
-
-4. **MAKE** your next move and send it:
-   \`\`\`bash
-   agent-relay inbox-write -t ${playerO} -f ${playerX} -m "MOVE: X at position N" -d ${dataDir}
-   \`\`\`
-
-5. **REPEAT** from step 1 until game over
-
-## Rules
-- Valid moves: positions 1-9 that are empty
-- Win: 3 in a row (horizontal, vertical, or diagonal)
-- Draw: all 9 positions filled with no winner
-
-## CRITICAL
-- NEVER stop mid-game
-- ALWAYS use the inbox-poll command to wait (it blocks until opponent responds)
-- Keep track of the board state
-- Announce result when game ends
-
-## START NOW
-Make your FIRST MOVE to position 5, then wait for opponent's response.
-`;
-}
-function instructionsForPlayerO(dataDir, playerX, playerO) {
-    return `# Tic-Tac-Toe Autonomous Game Protocol
-
-You are **${playerO}** (O). ${playerX} plays first, so you WAIT for their move.
-
-## Board Positions
-\`\`\`
- 1 | 2 | 3
------------
- 4 | 5 | 6
------------
- 7 | 8 | 9
-\`\`\`
-
-## Commands Available
-You have these \`agent-relay\` commands to communicate:
-
-**Wait for opponent's message (blocking):**
-\`\`\`bash
-agent-relay inbox-poll -n ${playerO} -d ${dataDir} --clear
-\`\`\`
-
-**Send a move to opponent:**
-\`\`\`bash
-agent-relay inbox-write -t ${playerX} -f ${playerO} -m "MOVE: O at position N" -d ${dataDir}
-\`\`\`
-
-## PROTOCOL (follow EXACTLY)
-
-### Since you're O, you go SECOND. Start by waiting:
-1. **WAIT** for opponent's first move (this will block until they move):
-   \`\`\`bash
-   agent-relay inbox-poll -n ${playerO} -d ${dataDir} --clear
-   \`\`\`
-
-2. **UPDATE** your mental board state with opponent's move
-
-3. **CHECK** for win/draw. If game over, announce result.
-
-4. **MAKE** your response move and send it:
-   \`\`\`bash
-   agent-relay inbox-write -t ${playerX} -f ${playerO} -m "MOVE: O at position N" -d ${dataDir}
-   \`\`\`
-
-5. **WAIT** for opponent's next move (back to step 1)
-
-## Rules
-- Valid moves: positions 1-9 that are empty
-- Win: 3 in a row (horizontal, vertical, or diagonal)
-- Draw: all 9 positions filled with no winner
-
-## CRITICAL
-- NEVER stop mid-game
-- ALWAYS use the inbox-poll command to wait (it blocks until opponent responds)
-- Keep track of the board state
-- Announce result when game ends
-
-## START NOW
-Run the inbox-poll command to WAIT for ${playerX}'s first move.
-`;
-}
-export function setupTicTacToe(options) {
-    const dataDir = options.dataDir;
-    const playerX = options.playerX ?? 'PlayerX';
-    const playerO = options.playerO ?? 'PlayerO';
-    fs.mkdirSync(path.join(dataDir, playerX), { recursive: true });
-    fs.mkdirSync(path.join(dataDir, playerO), { recursive: true });
-    // Clear inboxes
-    fs.writeFileSync(path.join(dataDir, playerX, 'inbox.md'), '', 'utf-8');
-    fs.writeFileSync(path.join(dataDir, playerO, 'inbox.md'), '', 'utf-8');
-    const instructionsXPath = path.join(dataDir, playerX, 'GAME_INSTRUCTIONS.md');
-    const instructionsOPath = path.join(dataDir, playerO, 'GAME_INSTRUCTIONS.md');
-    fs.writeFileSync(instructionsXPath, instructionsForPlayerX(dataDir, playerX, playerO), 'utf-8');
-    fs.writeFileSync(instructionsOPath, instructionsForPlayerO(dataDir, playerX, playerO), 'utf-8');
-    return { dataDir, playerX, playerO, instructionsXPath, instructionsOPath };
-}
-//# sourceMappingURL=tictactoe.js.map

package/dist/games/tictactoe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tictactoe.js","sourceRoot":"","sources":["../../src/games/tictactoe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAgB7B,SAAS,sBAAsB,CAAC,OAAe,EAAE,OAAe,EAAE,OAAe;IAC/E,OAAO;;YAEG,OAAO,8CAA8C,OAAO;;;;;;;;;;;;;;;;4BAgB5C,OAAO,OAAO,OAAO;;;;;6BAKpB,OAAO,OAAO,OAAO,kCAAkC,OAAO;;;;;;;;;gCAS3D,OAAO,OAAO,OAAO,kCAAkC,OAAO;;;;;;+BAM/D,OAAO,OAAO,OAAO;;;;;;;gCAOpB,OAAO,OAAO,OAAO,+BAA+B,OAAO;;;;;gCAK3D,OAAO,OAAO,OAAO,kCAAkC,OAAO;;;;;;;;;;;;;;;;;;CAkB7F,CAAC;AACF,CAAC;AAED,SAAS,sBAAsB,CAAC,OAAe,EAAE,OAAe,EAAE,OAAe;IAC/E,OAAO;;YAEG,OAAO,WAAW,OAAO;;;;;;;;;;;;;;;;4BAgBT,OAAO,OAAO,OAAO;;;;;6BAKpB,OAAO,OAAO,OAAO,kCAAkC,OAAO;;;;;;;;+BAQ5D,OAAO,OAAO,OAAO;;;;;;;;;gCASpB,OAAO,OAAO,OAAO,kCAAkC,OAAO;;;;;;;;;;;;;;;;;yCAiBrD,OAAO;CAC/C,CAAC;AACF,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,OAA8B;IAC3D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAChC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,SAAS,CAAC;IAC7C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,SAAS,CAAC;IAE7C,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/D,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE/D,gBAAgB;IAChB,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;IACvE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;IAEvE,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,sBAAsB,CAAC,CAAC;IAC9E,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,sBAAsB,CAAC,CAAC;IAE9E,EAAE,CAAC,aAAa,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;IAChG,EAAE,CAAC,aAAa,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;IAEhG,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,CAAC;AAC7E,CAAC"}

package/dist/supervisor/inbox.d.ts

@@ -1,38 +0,0 @@
-/**
- * Supervisor Inbox Utilities
- *
- * Provides an atomic "claim" for an agent inbox file to avoid losing messages
- * that arrive while the supervisor is processing.
- */
-export interface InboxMessage {
-    from: string;
-    timestamp: string;
-    body: string;
-}
-export interface ClaimedInbox {
-    inboxPath: string;
-    processingPath: string;
-    content: string;
-}
-/**
- * Parse inbox markdown into structured messages.
- *
- * Expected format (repeated blocks):
- * ## Message from <sender> | <timestamp>
- * <body>
- */
-export declare function parseInboxMarkdown(content: string): InboxMessage[];
-/**
- * Atomically claim an inbox by renaming it to a processing file.
- * New incoming messages will be written to a new inbox.md.
- */
-export declare function claimInbox(inboxPath: string): ClaimedInbox | null;
-/**
- * Finalize a claimed inbox.
- *
- * - On success: delete processing file.
- * - On failure: re-queue the claimed content back into inbox.md without
- *   overwriting any messages that arrived while processing.
- */
-export declare function finalizeClaim(claim: ClaimedInbox, success: boolean): void;
-//# sourceMappingURL=inbox.d.ts.map

package/dist/supervisor/inbox.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inbox.d.ts","sourceRoot":"","sources":["../../src/supervisor/inbox.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAeD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CA4DlE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAyBjE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CA6CzE"}