shellmates 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rohith Sathyanarayana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,134 @@
+# shellmates
+
+Your terminal. Multiple AI models. All talking to each other.
+
+```
+┌──────────────────────────┬──────────────────────────┬──────────────────────────┐
+│  claude                  │  gemini                  │  codex                   │
+│                          │                          │                          │
+│  Planning phase 3...     │  Reading the plan...     │  Reading the plan...     │
+│  Delegating to agents... │  Writing auth.py...      │  Writing tests...        │
+│  Waiting for signals...  │  Tests passing ✓         │  All passing ✓           │
+│  Nice. On to phase 4.    │  PHASE_COMPLETE: done    │  PHASE_COMPLETE: done    │
+└──────────────────────────┴──────────────────────────┴──────────────────────────┘
+```
+
+Claude plans. Gemini builds. Codex verifies. They coordinate through your terminal using nothing but tmux — no APIs between them, no glue code, just agents passing messages like coworkers at adjacent desks.
+
+---
+
+## What
+
+shellmates is a lightweight orchestration layer for your terminal. It connects Claude Code, Gemini CLI, and Codex in side-by-side tmux panes — Claude holds the plan and delegates, the others execute in parallel and signal back when done.
+
+No new framework. No shared memory. No API calls between models. Just text in a terminal.
+
+---
+
+## Why
+
+Every AI coding tool runs one model in one context. You hit a wall when the task gets big — context fills up, the model loses the thread, architectural decisions get buried in implementation noise.
+
+shellmates splits the work the way a good team does:
+
+- **One agent thinks.** Claude holds the plan, reviews the work, decides what's next. Uses [GSD](https://github.com/gsd-build/get-shit-done) to produce structured plans that sub-agents can execute without needing your entire conversation history.
+- **Other agents build.** Gemini and Codex get a fresh context, a clear plan, and a specific job. They commit, signal done, and wait.
+- **The terminal is the meeting room.** tmux `send-keys` delivers tasks. `capture-pane` reads the replies. That's the whole protocol.
+
+---
+
+## How it works
+
+```
+You describe what to build
+        ↓
+Claude plans it with /gsd:plan-phase  →  PLAN.md on disk
+        ↓
+Claude sends the plan to Gemini       →  tmux send-keys
+Claude sends the plan to Codex        →  tmux send-keys  (in parallel)
+        ↓
+Gemini implements, tests, commits
+Codex implements, tests, commits      (simultaneously)
+        ↓
+Both signal: PHASE_COMPLETE           →  Claude reads with capture-pane
+        ↓
+Claude reviews, decides next step
+        ↓
+repeat
+```
+
+The plan lives on disk. Sub-agents read it fresh every time. No conversation history required, no context bleed between agents, no awkward handoffs.
+
+---
+
+![shellmates demo](docs/demo.gif)
+
+---
+
+## Get started
+
+**Point your AI agent at this:**
+
+```
+Read https://raw.githubusercontent.com/rs07-git/shellmates/main/INIT.md and set up shellmates for this project.
+```
+
+That's it. Your agent will install the tools, update your project files, fill in the config, and drop a personalized tutorial in your terminal. No manual steps required.
+
+> Works with Claude Code, Gemini CLI, Codex, or any AI that can read a URL and run shell commands.
+
+---
+
+## Want to understand what's happening first?
+
+**→ [QUICKSTART.md](QUICKSTART.md)** — step-by-step walkthrough you can follow yourself
+
+---
+
+## Mix and match
+
+| Orchestrator | Executor(s) | Good for |
+|---|---|---|
+| Claude | Gemini | Large context tasks, Google Search grounding |
+| Claude | Codex | Sandboxed execution, internal multi-agent roles |
+| Claude | Gemini + Codex | Parallel tracks — implement and verify simultaneously |
+| Claude | Multiple Gemini panes | Fan-out across many files at once |
+
+---
+
+## What's in the box
+
+```
+shellmates/
+├── INIT.md                ← agent-executable setup (point your AI here)
+├── QUICKSTART.md          ← human-readable setup guide
+├── ORCHESTRATOR.md        ← Claude's operating instructions (copied to your project)
+├── templates/
+│   ├── CLAUDE.md          ← snippet added to your project's CLAUDE.md
+│   ├── GEMINI.md          ← filled in and added to your project root
+│   ├── AGENTS.md          ← for Codex
+│   └── .codex/            ← Codex multi-agent role configs
+├── scripts/
+│   ├── launch.sh          ← spin up a 2-pane session
+│   ├── launch-full-team.sh ← spin up a 4-pane session
+│   └── monitor.sh         ← watch for signals in the background
+└── docs/
+    ├── WORKFLOW.md        ← the plan/execute split explained
+    ├── PROTOCOL.md        ← full tmux IPC reference
+    ├── ROLES.md           ← patterns and when to use each
+    └── TROUBLESHOOTING.md
+```
+
+---
+
+## The protocol in one paragraph
+
+Claude sends a task by running `tmux send-keys -t pane "do X" Enter`. The sub-agent does the work and prints `PHASE_COMPLETE: Phase N — summary` when done. Claude reads the output with `tmux capture-pane -t pane -p | tail -20`. No framework, no SDK, no shared state. Just text in a terminal.
+
+Full spec in [docs/PROTOCOL.md](docs/PROTOCOL.md).
+
+---
+
+## License
+
+MIT

package/bin/shellmates.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { program } from 'commander'
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'))
+
+program
+  .name('shellmates')
+  .description('Seamless tmux multi-agent orchestration')
+  .version(pkg.version)
+
+// ── shellmates init ──────────────────────────────────────────────────────────
+program
+  .command('init')
+  .description('First-time setup — create config and directories')
+  .option('--force', 'Reset config to defaults even if it already exists')
+  .action(async (opts) => {
+    const { init } = await import('../lib/commands/init.js')
+    await init(opts)
+  })
+
+// ── shellmates config ────────────────────────────────────────────────────────
+program
+  .command('config')
+  .description('Interactive settings — agent, permission mode, orchestrator')
+  .action(async () => {
+    const { config } = await import('../lib/commands/config.js')
+    await config()
+  })
+
+// ── shellmates spawn ─────────────────────────────────────────────────────────
+program
+  .command('spawn')
+  .description('Dispatch a task to a worker agent in a new tmux session')
+  .option('-t, --task <text>', 'Inline task text to dispatch')
+  .option('-f, --task-file <path>', 'Path to a file containing the task')
+  .option('-a, --agent <name>', 'Override agent for this task (gemini|codex)')
+  .option('-s, --session <name>', 'tmux session name (default: shellmates-<ts>)')
+  .option('-p, --project <path>', 'Project directory for the worker (default: cwd)')
+  .option('-w, --watch', 'Wait and print result when the agent finishes')
+  .option('--no-ping', 'Skip background inbox watcher')
+  .action(async (opts) => {
+    const { spawn } = await import('../lib/commands/spawn.js')
+    await spawn({
+      task: opts.task,
+      taskFile: opts.taskFile,
+      agent: opts.agent,
+      session: opts.session,
+      project: opts.project,
+      watch: opts.watch,
+      noPing: !opts.ping,
+    })
+  })
+
+// ── shellmates status ────────────────────────────────────────────────────────
+program
+  .command('status')
+  .description('Show active sessions, config, and inbox results')
+  .action(async () => {
+    const { status } = await import('../lib/commands/status.js')
+    await status()
+  })
+
+// ── shellmates install-hook ──────────────────────────────────────────────────
+program
+  .command('install-hook')
+  .description('Install Claude Code PostToolUse hook for native AGENT_PING notifications')
+  .option('--force', 'Overwrite existing hook and re-add settings entry')
+  .action(async (opts) => {
+    const { installHook } = await import('../lib/commands/install-hook.js')
+    await installHook(opts)
+  })
+
+// ── shellmates teardown ──────────────────────────────────────────────────────
+program
+  .command('teardown [session]')
+  .description('Kill shellmates tmux sessions and clean up (default: all)')
+  .action(async (session) => {
+    const { execSync } = await import('child_process')
+    const chalk = (await import('chalk')).default
+    let sessions = []
+    try {
+      const out = execSync('tmux list-sessions -F "#{session_name}"', {
+        encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore']
+      })
+      sessions = out.trim().split('\n').filter(Boolean)
+    } catch {}
+
+    const targets = session
+      ? sessions.filter(s => s === session)
+      : sessions.filter(s => s.startsWith('shellmates'))
+
+    if (targets.length === 0) {
+      console.log(chalk.dim('\n  No shellmates sessions to tear down.\n'))
+      return
+    }
+
+    for (const s of targets) {
+      try {
+        execSync(`tmux kill-session -t ${s}`, { stdio: 'ignore' })
+        console.log(chalk.green('  ✓') + ` Killed session: ${s}`)
+      } catch {
+        console.log(chalk.red('  ✗') + ` Could not kill: ${s}`)
+      }
+    }
+    console.log('')
+  })
+
+program.parse()

package/lib/commands/config.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { readConfig, writeConfig, ensureDirs } from '../utils/config.js'
+
+const AGENT_CHOICES = [
+  { name: 'Gemini CLI  (google/gemini-cli)', value: 'gemini' },
+  { name: 'Codex CLI   (openai/codex)', value: 'codex' },
+  { name: 'Ask me each time', value: 'ask' },
+]
+
+const ORCHESTRATOR_CHOICES = [
+  { name: 'Claude Code  (this session)', value: 'claude' },
+  { name: 'Gemini CLI', value: 'gemini' },
+  { name: 'Codex CLI', value: 'codex' },
+]
+
+export async function config() {
+  ensureDirs()
+  const current = readConfig()
+
+  console.log('')
+  console.log(chalk.bold('  Shellmates — Settings'))
+  console.log(chalk.dim('  ────────────────────────────────────'))
+  console.log(chalk.dim(`  Current config: ~/.shellmates/config.json`))
+  console.log('')
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'default_agent',
+      message: 'Default worker agent:',
+      choices: AGENT_CHOICES,
+      default: current.default_agent,
+      prefix: ' ',
+    },
+    {
+      type: 'list',
+      name: 'orchestrator',
+      message: 'Orchestrator (who dispatches tasks):',
+      choices: ORCHESTRATOR_CHOICES,
+      default: current.orchestrator,
+      prefix: ' ',
+    },
+    {
+      type: 'list',
+      name: 'permission_mode',
+      message: 'Permission mode:',
+      choices: [
+        {
+          name: 'default  — agents ask before modifying files or running commands',
+          value: 'default',
+        },
+        {
+          name: 'bypass   — agents run fully autonomously (gemini --yolo, codex --full-auto)',
+          value: 'bypass',
+        },
+      ],
+      default: current.permission_mode,
+      prefix: ' ',
+    },
+    {
+      type: 'confirm',
+      name: 'bypass_confirmed',
+      message: chalk.yellow('Bypass mode lets agents modify files without asking. Are you sure?'),
+      default: false,
+      prefix: ' ',
+      when: (ans) => ans.permission_mode === 'bypass' && current.permission_mode !== 'bypass',
+    },
+  ])
+
+  // If user chose bypass but didn't confirm, revert to default
+  if (answers.permission_mode === 'bypass' && answers.bypass_confirmed === false) {
+    answers.permission_mode = 'default'
+    console.log('')
+    console.log(chalk.dim('  Permission mode kept as: default'))
+  }
+
+  const { bypass_confirmed, ...toSave } = answers
+  writeConfig(toSave)
+
+  console.log('')
+  console.log(chalk.green('  ✓') + ' Settings saved.')
+  console.log('')
+  console.log(chalk.dim('  permission_mode: ') + chalk.bold(toSave.permission_mode))
+  console.log(chalk.dim('  default_agent:   ') + chalk.bold(toSave.default_agent))
+  console.log(chalk.dim('  orchestrator:    ') + chalk.bold(toSave.orchestrator))
+  console.log('')
+}

package/lib/commands/init.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk'
+import { existsSync } from 'fs'
+import { CONFIG_PATH, CONFIG_DIR, INBOX_DIR, readConfig, writeConfig, ensureDirs } from '../utils/config.js'
+import { tmuxAvailable } from '../utils/tmux.js'
+import { printLogo } from '../utils/logo.js'
+
+export async function init({ force = false } = {}) {
+  const { readFileSync } = await import('fs')
+  const { join, dirname, fileURLToPath } = await import('path')
+  const { fileURLToPath: fu } = await import('url')
+  let version = '0.1.0'
+  try {
+    const __dirname = dirname(fu(import.meta.url))
+    const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'))
+    version = pkg.version
+  } catch {}
+
+  printLogo(version)
+  console.log(chalk.dim('  ─────────────────────────────'))
+  console.log('')
+
+  // tmux check
+  if (!tmuxAvailable()) {
+    console.log(chalk.red('  ✗ tmux not found'))
+    console.log(chalk.dim('    Install it: brew install tmux'))
+    console.log('')
+    process.exit(1)
+  }
+  console.log(chalk.green('  ✓') + ' tmux found')
+
+  // Create dirs
+  ensureDirs()
+  console.log(chalk.green('  ✓') + ` ~/.shellmates/ ready`)
+  console.log(chalk.green('  ✓') + ` ~/.shellmates/inbox/ ready`)
+
+  // Config
+  if (existsSync(CONFIG_PATH) && !force) {
+    console.log(chalk.yellow('  ~') + ` Config already exists at ${CONFIG_PATH}`)
+    console.log(chalk.dim('    Run with --force to reset, or use: shellmates config'))
+  } else {
+    writeConfig({
+      permission_mode: 'default',
+      default_agent: 'gemini',
+      orchestrator: 'claude',
+    })
+    console.log(chalk.green('  ✓') + ` Config created at ${CONFIG_PATH}`)
+  }
+
+  console.log('')
+  console.log(chalk.bold('  Ready.'))
+  console.log('')
+  console.log('  Next steps:')
+  console.log(chalk.dim('    shellmates config') + '  — configure agents and permission mode')
+  console.log(chalk.dim('    shellmates spawn') + '   — dispatch a task to a worker agent')
+  console.log('')
+}

package/lib/commands/install-hook.js

@@ -0,0 +1,83 @@
+import chalk from 'chalk'
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, chmodSync } from 'fs'
+import { join, dirname, fileURLToPath } from 'path'
+import { homedir } from 'os'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const TEMPLATES_DIR = join(__dirname, '..', '..', 'templates', 'hooks')
+
+const CLAUDE_DIR = join(homedir(), '.claude')
+const HOOKS_DIR = join(CLAUDE_DIR, 'hooks')
+const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json')
+const HOOK_SCRIPT = join(HOOKS_DIR, 'shellmates-notify.sh')
+
+const HOOK_ENTRY = {
+  matcher: 'Bash',
+  hooks: [
+    {
+      type: 'command',
+      command: '~/.claude/hooks/shellmates-notify.sh',
+      async: true,
+      asyncRewake: true,
+    },
+  ],
+}
+
+export async function installHook({ force = false } = {}) {
+  console.log('')
+  console.log(chalk.bold('  Shellmates — Install Claude Code Hook'))
+  console.log(chalk.dim('  ─────────────────────────────────────────'))
+  console.log('')
+  console.log(chalk.dim('  This installs a PostToolUse hook that notifies Claude natively'))
+  console.log(chalk.dim('  when a shellmates agent finishes — no polling needed.'))
+  console.log('')
+
+  // 1. Copy hook script
+  mkdirSync(HOOKS_DIR, { recursive: true })
+  if (existsSync(HOOK_SCRIPT) && !force) {
+    console.log(chalk.yellow('  ~') + ` Hook script already exists (use --force to overwrite)`)
+  } else {
+    copyFileSync(join(TEMPLATES_DIR, 'shellmates-notify.sh'), HOOK_SCRIPT)
+    chmodSync(HOOK_SCRIPT, 0o755)
+    console.log(chalk.green('  ✓') + ` Hook script installed: ~/.claude/hooks/shellmates-notify.sh`)
+  }
+
+  // 2. Merge hook entry into settings.json
+  let settings = {}
+  if (existsSync(SETTINGS_PATH)) {
+    try {
+      settings = JSON.parse(readFileSync(SETTINGS_PATH, 'utf8'))
+    } catch {
+      console.log(chalk.yellow('  ~') + ` Could not parse ${SETTINGS_PATH} — will create fresh`)
+    }
+  }
+
+  // Check if our hook is already there
+  const postToolUse = settings?.hooks?.PostToolUse || []
+  const alreadyInstalled = postToolUse.some(
+    entry => entry.hooks?.some(h => h.command?.includes('shellmates-notify'))
+  )
+
+  if (alreadyInstalled && !force) {
+    console.log(chalk.yellow('  ~') + ` Hook entry already in settings.json (use --force to re-add)`)
+  } else {
+    if (!settings.hooks) settings.hooks = {}
+    if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = []
+    // Remove old shellmates entry if force
+    if (force) {
+      settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
+        e => !e.hooks?.some(h => h.command?.includes('shellmates-notify'))
+      )
+    }
+    settings.hooks.PostToolUse.push(HOOK_ENTRY)
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n')
+    console.log(chalk.green('  ✓') + ` Hook entry added to ~/.claude/settings.json`)
+  }
+
+  console.log('')
+  console.log(chalk.bold('  Done.'))
+  console.log('')
+  console.log('  After your next ' + chalk.dim('shellmates spawn') + ', Claude will be notified')
+  console.log('  automatically when the agent finishes — no polling.')
+  console.log('')
+}

package/lib/commands/spawn.js

@@ -0,0 +1,98 @@
+import chalk from 'chalk'
+import { spawnSync } from 'child_process'
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { tmpdir, homedir } from 'os'
+import { readConfig } from '../utils/config.js'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const SCRIPTS_DIR = join(__dirname, '..', '..', 'scripts')
+const INBOX_DIR = join(homedir(), '.shellmates', 'inbox')
+
+export async function spawn(options) {
+  const config = readConfig()
+
+  const agent = options.agent || config.default_agent
+  const session = options.session || `shellmates-${Date.now()}`
+  const project = options.project || process.cwd()
+  const noPing = options.noPing || false
+
+  // Resolve task content
+  let taskFile = options.taskFile
+  if (!taskFile && options.task) {
+    // Inline task string → write to temp file
+    const tmp = join(tmpdir(), `shellmates-task-${Date.now()}.txt`)
+    writeFileSync(tmp, options.task)
+    taskFile = tmp
+  }
+
+  if (!taskFile || !existsSync(taskFile)) {
+    console.error(chalk.red('  ✗ No task provided. Use --task "..." or --task-file path'))
+    process.exit(1)
+  }
+
+  console.log('')
+  console.log(chalk.bold('  Shellmates — Spawning'))
+  console.log(chalk.dim('  ─────────────────────────────────────'))
+  console.log(chalk.dim('  Agent:   ') + chalk.bold(agent))
+  console.log(chalk.dim('  Session: ') + chalk.bold(session))
+  console.log(chalk.dim('  Mode:    ') + chalk.bold(config.permission_mode))
+  console.log('')
+
+  const spawnScript = join(SCRIPTS_DIR, 'spawn-team.sh')
+  const args = [
+    '--task-file', taskFile,
+    '--project', project,
+    '--session', session,
+    '--agent', agent,
+  ]
+  if (noPing) args.push('--no-ping')
+
+  const result = spawnSync('bash', [spawnScript, ...args], { stdio: 'inherit' })
+
+  if (result.status !== 0) {
+    console.error(chalk.red('\n  ✗ Spawn failed'))
+    process.exit(result.status || 1)
+  }
+
+  // If --watch, tail the inbox until the job file appears
+  if (options.watch) {
+    await watchInbox(session)
+  }
+}
+
+async function watchInbox(session) {
+  const { readdir } = await import('fs/promises')
+  console.log('')
+  console.log(chalk.dim('  Watching for result...  (Ctrl+C to stop)'))
+
+  const before = new Set(existsSync(INBOX_DIR)
+    ? (await readdir(INBOX_DIR)).filter(f => f.endsWith('.txt'))
+    : [])
+
+  let elapsed = 0
+  const timeout = 300
+  while (elapsed < timeout) {
+    await new Promise(r => setTimeout(r, 2000))
+    elapsed += 2
+    if (!existsSync(INBOX_DIR)) continue
+    const after = (await readdir(INBOX_DIR)).filter(f => f.endsWith('.txt'))
+    const newFiles = after.filter(f => !before.has(f))
+    if (newFiles.length > 0) {
+      for (const f of newFiles) {
+        const content = readFileSync(join(INBOX_DIR, f), 'utf8')
+        console.log('')
+        console.log(chalk.green('  ✓ Result received') + chalk.dim(` (${f})`))
+        console.log('')
+        for (const line of content.trim().split('\n')) {
+          console.log('  ' + chalk.dim(line.split(':')[0] + ':') + ' ' + line.split(':').slice(1).join(':').trim())
+        }
+        console.log('')
+      }
+      return
+    }
+  }
+
+  console.log(chalk.yellow('\n  ~ Timed out waiting for result'))
+}

package/lib/commands/status.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk'
+import { readdirSync, readFileSync, existsSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+import { execSync } from 'child_process'
+import { readConfig, INBOX_DIR } from '../utils/config.js'
+
+export async function status() {
+  const config = readConfig()
+
+  console.log('')
+  console.log(chalk.bold('  Shellmates — Status'))
+  console.log(chalk.dim('  ────────────────────────────────────'))
+  console.log('')
+
+  // Config summary
+  console.log(chalk.dim('  Config'))
+  console.log('  ' + chalk.dim('permission_mode: ') + chalk.bold(config.permission_mode))
+  console.log('  ' + chalk.dim('default_agent:   ') + chalk.bold(config.default_agent))
+  console.log('  ' + chalk.dim('orchestrator:    ') + chalk.bold(config.orchestrator))
+  console.log('')
+
+  // Active tmux sessions
+  let sessions = []
+  try {
+    const out = execSync('tmux list-sessions -F "#{session_name}"', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+    sessions = out.trim().split('\n').filter(Boolean)
+  } catch {
+    // tmux not running or no sessions
+  }
+
+  const shellmateSessions = sessions.filter(s => s.startsWith('shellmates'))
+  console.log(chalk.dim('  Active sessions'))
+  if (shellmateSessions.length === 0) {
+    console.log('  ' + chalk.dim('none'))
+  } else {
+    for (const s of shellmateSessions) {
+      console.log('  ' + chalk.green('●') + ' ' + s)
+    }
+  }
+  console.log('')
+
+  // Inbox files
+  console.log(chalk.dim('  Inbox'))
+  if (!existsSync(INBOX_DIR)) {
+    console.log('  ' + chalk.dim('empty'))
+  } else {
+    const files = readdirSync(INBOX_DIR).filter(f => f.endsWith('.txt'))
+    if (files.length === 0) {
+      console.log('  ' + chalk.dim('empty'))
+    } else {
+      for (const f of files) {
+        try {
+          const content = readFileSync(join(INBOX_DIR, f), 'utf8')
+          const statusLine = content.split('\n').find(l => l.startsWith('STATUS:'))
+          const resultLine = content.split('\n').find(l => l.startsWith('RESULT:'))
+          const statusVal = statusLine?.split(':')[1]?.trim() || '?'
+          const resultVal = resultLine?.split(':').slice(1).join(':').trim() || ''
+          const icon = statusVal === 'complete' ? chalk.green('✓') : chalk.yellow('~')
+          console.log('  ' + icon + ' ' + chalk.dim(f))
+          if (resultVal) console.log('    ' + chalk.dim(resultVal.split('\n')[0]))
+        } catch {
+          console.log('  ' + chalk.dim(f))
+        }
+      }
+    }
+  }
+  console.log('')
+}