@damian87/omp 0.6.0 → 0.8.0

package/.github/skills/team/SKILL.md

@@ -1,102 +1,127 @@
 ---
 name: team
-description: Split an approved plan into parallel tmux panes, each running an independent Copilot CLI agent. Use when work has independent lanes and you want visual parallel execution in split terminals. Use when user says /team, team, or wants parallel agent execution.
-argument-hint: "<number of lanes or plan reference>"
+description: Split an approved plan into parallel tmux panes in the current window so the user can watch agents work. Prefer this visual flow by default; use `omp team` only when the user explicitly wants background execution or runtime messaging/status APIs.
+argument-hint: "<number of workers> <task description>"
 ---
 
 # Team — tmux-based parallel agent execution
 
-`/team` splits work into parallel tmux panes in the **current window**, each running an independent interactive agent session. You see all agents working side-by-side immediately.
+`/team` launches independent Copilot CLI agents in parallel tmux panes.
+
+**Default behavior:** use the **split-window** flow so the user sees agents working in the current tmux window.
+
+Use **runtime mode** (`omp team`) only when the user explicitly asks for background execution, detached monitoring, or runtime APIs like status, nudging, or worker messaging.
+
+Two modes available:
+
+| Mode | Command | Panes visible in | Best for |
+|------|---------|-------------------|----------|
+| **Split** | `team-launch.sh` | Current window | **Default**. Visual demo, watching agents work |
+| **Runtime** | `omp team N:copilot "task"` | Separate tmux session | Explicit background jobs, task tracking, nudging, messaging |
 
 ## When to use
 
 - Work has **independent lanes** (no shared files, no ordering constraints)
-- You want visual, demo-friendly parallel execution in split terminals
+- You want parallel execution in split terminals
 
-## Agent execution steps (FOLLOW EXACTLY)
+## Default mode — Split window (`team-launch.sh`)
 
-When `/team` is invoked, you MUST execute these steps in order:
+Use this unless the user asks for background execution.
 
-### Step 1 — Identify lanes
+### When to choose it
 
-Collect independent work lanes from the conversation context. Each lane needs:
-- `id`: short kebab-case identifier (e.g. `lane-a`, `fix-auth`)
-- `name`: human-readable name (e.g. `Upgrade dependencies`)
-- `prompt`: complete task prompt — must be self-contained with all context the agent needs (files to change, what to do, commit message)
+- The user wants to **see** the agents working
+- You want panes in the **current tmux window**
+- You are demoing or smoke-testing the skill
 
-If no plan or lanes exist yet, ask the user what work to split.
+### Step 1 — Write lanes JSON
 
-### Step 2 — Write lanes JSON
-
-Write a temporary lanes file at `/tmp/team-lanes-<timestamp>.json`:
+Write a temporary file at `/tmp/team-lanes-<timestamp>.json`:
 
 ```json
 [
-  {
-    "id": "lane-a",
-    "name": "Short descriptive name",
-    "prompt": "Complete self-contained task prompt for the agent..."
-  },
-  {
-    "id": "lane-b",
-    "name": "Another lane name",
-    "prompt": "Another complete task prompt..."
-  }
+  { "id": "lane-a", "name": "Short name", "prompt": "Complete self-contained task prompt..." },
+  { "id": "lane-b", "name": "Another lane", "prompt": "Another task prompt..." }
 ]
 ```
 
-### Step 3 — Launch the team
-
-Run the launch script, passing the session name and lanes file path:
+### Step 2 — Launch
 
+```bash
+bash ~/.copilot/installed-plugins/oh-my-copilot/oh-my-copilot/.github/skills/team/scripts/team-launch.sh \
+  --session "team-<name>" --lanes <lanes-file>
 ```
-.github/skills/team/scripts/team-launch.sh --session "team-<name>" --lanes <lanes-file>
+
+The script:
+1. Splits the **current window** into panes
+2. Launches `omp --madmax` in each
+3. Auto-accepts folder trust prompts
+4. Waits for readiness, sends prompts
+5. Monitors completion and prints a results summary
+
+### Step 3 — Report
+
+The script blocks and prints all results. Relay the output to the user.
+
+## Optional mode — Runtime (`omp team`)
+
+Choose this only when the user explicitly wants the team to run in the background or needs runtime features.
+
+### When to choose it
+
+- The user asked for a **background** team
+- You need `omp team status`, shutdown, or runtime task APIs
+- You do **not** need the panes in the current tmux window
+
+### Launch
+
+```bash
+omp team <N>:copilot "<task description>"
 ```
 
-This will:
-- Split the **current tmux window** into panes (leader keeps its pane)
-- Launch `omp --madmax` interactively in each pane, then send the prompt
-- Arrange panes in a tiled grid layout
-- Print pane IDs and navigation commands
+The runtime automatically:
+1. Creates a tmux session with split panes
+2. Launches `copilot --allow-all-tools` in each pane
+3. Auto-accepts folder trust prompts
+4. Waits for readiness, then sends the task prompt
+5. Tracks task state, heartbeats, and supports idle-nudging
 
-### Step 4 — Report to user
+### Monitor and cleanup
 
-Show the user:
-- Which panes were created and what each is working on
-- Navigation: `Ctrl-b + arrow keys` to move between panes
-- How to check output: `tmux capture-pane -t <pane-id> -p -S -50`
-- How to kill panes when done
+```bash
+omp team status <team-name>       # check progress
+tmux attach -t omp-team-<name>    # watch panes live
+omp team shutdown <team-name>     # kill when done
+```
 
 ## Prerequisites
 
-- `tmux` installed and running inside a tmux session
-- `omp` (oh-my-copilot) on PATH — preferred, launches with `omp --madmax`
-- Falls back to `copilot` if `omp` is not available
-- `jq` for JSON parsing
+- `tmux` installed and session running
+- `omp` on PATH
+- `jq` for JSON parsing (split mode only)
 
-## Prompt guidelines
+## Task / prompt guidelines
 
-Each lane prompt must be **self-contained**. The agent in that pane has no context from this session. Include:
+Each task must be **self-contained**. The agent has no context from this session. Include:
 - Exact files or directories to work in
-- What to do (fix, upgrade, accept, etc.)
-- How to verify (run tests, npm audit, etc.)
+- What to do (fix, upgrade, etc.)
+- How to verify (run tests, etc.)
 - Commit message to use
 
-### Good prompt example
+### Good example
 
-> You are working in /Users/me/project. In src/auth/login.ts, replace the bcrypt password check with argon2. Update the import, change the verify call, and run `npm test -- --grep auth` to confirm. Commit with message "refactor: switch password hashing to argon2".
+> In src/auth/login.ts, replace bcrypt with argon2. Update the import, change the verify call, run `npm test -- --grep auth`. Commit: "refactor: switch to argon2".
 
-### Bad prompt example
+### Bad example
 
-> Fix the auth module. (Too vague — which file? What fix? How to verify?)
+> Fix the auth module. (Too vague)
 
 ## Composition
 
-Use `/ralplan` before `/team` to produce the plan that defines lanes. Use `/verify` after all panes complete to confirm combined results don't conflict.
+Use `/ralplan` before `/team` to produce the plan. Use `/verify` after completion.
 
 ## Limitations
 
-- Each pane is an independent agent session — no shared state or messaging
-- Agents cannot communicate with each other — if tasks depend on each other, use `/ralph` instead
-- Leader (you) must manually verify results after all panes complete
-- Best for independent, non-conflicting work streams
+- Each pane is an independent session — no shared state
+- Workers can message each other via `omp team api send-message` (runtime mode only)
+- If tasks depend on each other, use `/ralph` instead

package/.github/skills/team/scripts/team-launch.sh

@@ -7,9 +7,11 @@ set -euo pipefail
 # Usage:
 #   team-launch.sh --session <name> --lanes <lanes.json>
 #
-# Each pane launches an interactive `omp --madmax` (or `copilot`) session,
-# then sends the lane prompt via tmux send-keys so the agent stays alive
-# for follow-up interaction.
+# Flow:
+#   1. Split panes and launch agent CLI in each
+#   2. Wait for each agent to be ready (auto-accept folder trust prompts)
+#   3. Send lane prompts via send-keys
+#   4. Monitor until all agents finish, then print summary
 
 SESSION=""
 LANES_FILE=""
@@ -33,13 +35,11 @@ if [[ ! -f "$LANES_FILE" ]]; then
 fi
 
 if ! command -v tmux &>/dev/null; then
-  echo "tmux not found" >&2
-  exit 1
+  echo "tmux not found" >&2; exit 1
 fi
 
 if [[ -z "${TMUX:-}" ]]; then
-  echo "Not inside a tmux session. Run this from within tmux." >&2
-  exit 1
+  echo "Not inside a tmux session. Run this from within tmux." >&2; exit 1
 fi
 
 if command -v omp &>/dev/null; then
@@ -47,31 +47,60 @@ if command -v omp &>/dev/null; then
 elif command -v copilot &>/dev/null; then
   AGENT_CMD="copilot"
 else
-  echo "Neither omp nor copilot CLI found" >&2
-  exit 1
+  echo "Neither omp nor copilot CLI found" >&2; exit 1
 fi
 
 LANE_COUNT=$(jq length "$LANES_FILE")
 if [[ "$LANE_COUNT" -lt 1 ]]; then
-  echo "No lanes defined in $LANES_FILE" >&2
-  exit 1
+  echo "No lanes defined in $LANES_FILE" >&2; exit 1
 fi
 
 CWD=$(pwd)
-WAIT_SECS="${TEAM_AGENT_WAIT:-5}"
+POLL="${TEAM_POLL_INTERVAL:-2}"
+MAX_READY="${TEAM_MAX_READY_WAIT:-60}"
+MAX_DONE="${TEAM_MAX_COMPLETION_WAIT:-300}"
+
+# ── helpers ──────────────────────────────────────────────────────────
+
+# Capture visible pane content (last N lines)
+pane_text() { tmux capture-pane -t "$1" -p -S "-${2:-20}" 2>/dev/null || true; }
+
+# Wait until the agent CLI is fully ready ('/ commands' status bar visible).
+# Auto-accepts the folder-trust dialog if it appears.
+wait_for_ready() {
+  local pane="$1" elapsed=0 accepted=0
+  while (( elapsed < MAX_READY )); do
+    local txt
+    txt=$(pane_text "$pane" 25)
+
+    # Ready: the '/ commands' status bar means the CLI input prompt is active
+    if echo "$txt" | grep -q '/ commands'; then
+      return 0
+    fi
+
+    # Auto-accept folder trust dialog
+    if (( accepted == 0 )) && echo "$txt" | grep -q 'Do you trust'; then
+      tmux send-keys -t "$pane" C-m
+      accepted=1
+      echo "    ↳ Auto-accepted folder trust for $pane"
+    fi
+
+    sleep "$POLL"
+    elapsed=$((elapsed + POLL))
+  done
+  return 1
+}
+
+# ── step 1: create panes ─────────────────────────────────────────────
 
 echo "🚀 Splitting current window into $LANE_COUNT panes ($SESSION)"
 echo ""
 
-# Collect pane IDs as we create them
 PANE_IDS=()
-
 for i in $(seq 0 $((LANE_COUNT - 1))); do
   LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
-  LANE_PROMPT=$(jq -r ".[$i].prompt" "$LANES_FILE")
   LANE_ID=$(jq -r ".[$i].id" "$LANES_FILE")
 
-  # Split: alternate horizontal/vertical for a grid
   if (( i == 0 )); then
     PANE_ID=$(tmux split-window -h -c "$CWD" -P -F '#{pane_id}')
   elif (( i % 2 == 1 )); then
@@ -79,54 +108,123 @@ for i in $(seq 0 $((LANE_COUNT - 1))); do
   else
     PANE_ID=$(tmux split-window -v -t "${PANE_IDS[$((i-2))]}" -c "$CWD" -P -F '#{pane_id}')
   fi
-
   PANE_IDS+=("$PANE_ID")
 
-  # Set pane title
   tmux select-pane -t "$PANE_ID" -T "$LANE_ID: $LANE_NAME"
+  tmux send-keys -t "$PANE_ID" "$AGENT_CMD" C-m
 
-  # Launch interactive agent session (NOT with -p)
-  tmux send-keys -t "$PANE_ID" "echo '═══ $LANE_NAME ═══' && $AGENT_CMD" C-m
-
-  echo "  ✅ Pane $PANE_ID → $LANE_NAME (launching agent...)"
+  echo "  ✅ Pane $PANE_ID → $LANE_NAME"
 done
 
-# Rebalance layout
 tmux select-layout tiled
 
-# Wait for agents to start up before sending prompts
+# ── step 2: wait for readiness ───────────────────────────────────────
+
 echo ""
-echo "⏳ Waiting ${WAIT_SECS}s for agents to initialise..."
-sleep "$WAIT_SECS"
+echo "⏳ Waiting for agents to initialise (up to ${MAX_READY}s)..."
 
-# Now send prompts to each interactive session
+for i in $(seq 0 $((LANE_COUNT - 1))); do
+  PANE_ID="${PANE_IDS[$i]}"
+  LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
+  if wait_for_ready "$PANE_ID"; then
+    echo "  ✅ $PANE_ID ($LANE_NAME) ready"
+  else
+    echo "  ⚠️  $PANE_ID ($LANE_NAME) not ready after ${MAX_READY}s — sending anyway"
+  fi
+done
+
+# ── step 3: send prompts (literal text + Enter separately) ───────────
+
+echo ""
+echo "📨 Sending prompts..."
 for i in $(seq 0 $((LANE_COUNT - 1))); do
   LANE_PROMPT=$(jq -r ".[$i].prompt" "$LANES_FILE")
   LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
   PANE_ID="${PANE_IDS[$i]}"
 
-  # Write prompt to temp file and use tmux load-buffer + paste for reliable delivery
-  PROMPT_FILE="/tmp/team-prompt-${SESSION}-${i}.txt"
-  printf '%s' "$LANE_PROMPT" > "$PROMPT_FILE"
-
-  # Send via tmux send-keys -l (literal) then Enter
-  tmux send-keys -t "$PANE_ID" -l "$(cat "$PROMPT_FILE")"
+  # -l = literal (no key interpretation), then C-m = Enter as a separate call
+  tmux send-keys -t "$PANE_ID" -l "$LANE_PROMPT"
+  sleep 0.3
   tmux send-keys -t "$PANE_ID" C-m
 
-  echo "  📨 Sent prompt to $PANE_ID ($LANE_NAME)"
+  echo "  📨 Sent to $PANE_ID ($LANE_NAME)"
 done
 
-# Switch focus back to the original (leader) pane
 tmux select-pane -t '{left}'
 
+# ── step 4: monitor completion ───────────────────────────────────────
+
 echo ""
-echo "✅ $LANE_COUNT interactive agent sessions running in split panes"
+echo "⏳ Monitoring agents for completion (up to ${MAX_DONE}s)..."
+
+# Brief pause so agents start processing before we poll
+sleep 5
+
+# State per lane: 0=waiting-for-busy, 1=busy, 2=done
+LANE_STATE=()
+for i in $(seq 0 $((LANE_COUNT - 1))); do LANE_STATE[$i]=0; done
+
+COMPLETED=0
+ELAPSED=0
+while (( COMPLETED < LANE_COUNT && ELAPSED < MAX_DONE )); do
+  sleep "$POLL"
+  ELAPSED=$((ELAPSED + POLL))
+
+  for i in $(seq 0 $((LANE_COUNT - 1))); do
+    [[ "${LANE_STATE[$i]}" == "2" ]] && continue
+
+    PANE_ID="${PANE_IDS[$i]}"
+    LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
+
+    # Pane died?
+    if ! tmux list-panes -a -F '#{pane_id}' 2>/dev/null | grep -q "^${PANE_ID}$"; then
+      echo "  ❌ $PANE_ID ($LANE_NAME) — pane died"
+      LANE_STATE[$i]=2; COMPLETED=$((COMPLETED + 1)); continue
+    fi
+
+    local_capture=$(pane_text "$PANE_ID" 15)
+
+    # State 0→1: agent started working (response marker ● appears)
+    if [[ "${LANE_STATE[$i]}" == "0" ]]; then
+      if echo "$local_capture" | grep -q '●'; then
+        LANE_STATE[$i]=1
+      fi
+      continue
+    fi
+
+    # State 1→2: agent finished (back to idle — '/ commands' in last 5 lines)
+    if echo "$local_capture" | tail -5 | grep -q '/ commands'; then
+      echo "  ✅ $PANE_ID ($LANE_NAME) — agent finished"
+      LANE_STATE[$i]=2; COMPLETED=$((COMPLETED + 1))
+    fi
+  done
+done
+
 echo ""
-echo "Pane IDs: ${PANE_IDS[*]}"
+if (( COMPLETED == LANE_COUNT )); then
+  echo "🎉 All $LANE_COUNT agents completed!"
+else
+  echo "⏰ Timeout — $((LANE_COUNT - COMPLETED)) agent(s) still running"
+fi
+
+# ── summary ──────────────────────────────────────────────────────────
+
 echo ""
-echo "Commands:"
-echo "  tmux select-layout tiled              # rebalance layout"
-echo "  tmux capture-pane -t <pane-id> -p -S -50  # read pane output"
-echo "  Ctrl-b + arrow keys                   # navigate between panes"
+echo "═══ Results Summary ═══"
+for i in $(seq 0 $((LANE_COUNT - 1))); do
+  PANE_ID="${PANE_IDS[$i]}"
+  LANE_NAME=$(jq -r ".[$i].name" "$LANES_FILE")
+  LANE_ID=$(jq -r ".[$i].id" "$LANES_FILE")
+  echo ""
+  echo "── $LANE_ID: $LANE_NAME ($PANE_ID) ──"
+  if tmux list-panes -a -F '#{pane_id}' 2>/dev/null | grep -q "^${PANE_ID}$"; then
+    pane_text "$PANE_ID" 40 | grep -E '●|✅|❌|⚠|error|Error|FAIL|PASS|done|Done' | tail -10 || echo "  (no notable output captured)"
+  else
+    echo "  (pane no longer exists)"
+  fi
+done
+
 echo ""
-echo "💡 Agents are interactive — you can send follow-up prompts to any pane"
+echo "Pane IDs: ${PANE_IDS[*]}"
+echo "Navigate: Ctrl-b + arrow keys"
+echo "💡 Agents are interactive — send follow-up prompts to any pane"

package/README.md

@@ -82,6 +82,7 @@ That's it.
 ### Developer Experience
 
 - **MCP server** ships with `notepad`, `project-memory`, `shared-memory`, `state`, and `trace` tools out of the box
+- **Lightweight Copilot context** — managed instructions keep only the repo goal plus on-demand memory commands; set `OMP_DISABLE_INSTRUCTIONS_MEMORY=1` to skip writing the managed block entirely
 - **File-state coordination** — outbox JSONL + byte cursor, atomic `O_EXCL` task locks, optimistic CAS on claim
 - **Idle nudge** — content-based pane idle detection that pokes stuck workers
 - **Mode-state loops** — single source of truth per loop (Ralph/Ultrawork/UltraQA state files)
@@ -183,6 +184,7 @@ omp list                                    # show discovered skills and agents
 omp setup [--dry-run] [--scope project|user]
 omp launch -- [copilot flags…]              # forward arbitrary args to copilot
 omp --madmax -p "edit src/foo.ts"           # bare-flag, maps to copilot --yolo
+omp suggest "fix flaky tests"               # recommend a slash-skill workflow
 omp team 3:executor "fix all type errors"   # spawn tmux workers
 omp team status <name>
 omp team shutdown <name>
@@ -190,6 +192,12 @@ omp ralph start "<task>" [--max-iterations N]
 omp ultrawork start "<objective>" [--task-count N]
 omp ultraqa start "<goal>" [--max-cycles N]
 omp council "<question>" [--models a,b,c] [--context @file] [--json]   # multi-model council
+omp comms status | send | recv | ask        # drive a running copilot tmux session
+omp gateway serve [--only slack]            # run chat connectors (today: slack)
+omp gateway status [--json]                 # per-connector readiness (no sockets)
+omp slack serve                             # deprecated alias of `gateway serve --only slack`
+omp slack doctor [--json]                   # deprecated alias of `gateway status --only slack`
+omp env init [--force]                      # write ~/.omp/.env (interactive Slack token setup)
 omp schedule add --id <id> --cron "*/15 * * * *" --prompt "<text>" [--allow-all-tools] [--cwd <dir>] [--model <m>] [--timeout <ms>] [--max-runs N] [--ttl-hours H] [--dry-run]
 omp schedule list                           # registered jobs + OS-install status
 omp schedule status <id>                    # last run + result summary
@@ -217,6 +225,29 @@ run results are surfaced automatically at the start of new Copilot sessions. Alw
 `omp schedule remove`, never delete `.omp/state/schedule/` by hand, so the OS entry is
 uninstalled cleanly.
 
+### Chat bridge: drive Copilot from Slack
+
+`omp gateway` runs long-lived chat connectors that forward messages into a running
+Copilot CLI session (via tmux) and post replies back. Today's connector is `slack`
+(WebSocket Socket Mode — no public URL needed); the runtime is generic so future
+connectors (Telegram, Discord, webhooks) drop in as one file each.
+
+```bash
+# 1. a Copilot tmux session is running (any `omp-<digits>` name)
+tmux new-session -d -s omp-9999
+
+# 2. interactive setup — explains where to grab each token and writes
+#    ~/.omp/.env (chmod 600). Re-runnable; masks existing values.
+#    `omp` auto-loads ~/.omp/.env every invocation; shell exports still win.
+omp env init
+
+# 3. preflight, then run
+omp gateway status              # ready=true means tokens + session look good
+omp gateway serve               # blocks; ^C stops cleanly
+```
+
+Full Slack-app setup (manifest + scopes) lives in [`docs/slack-setup.md`](docs/slack-setup.md).
+
 ---
 
 ## Roadmap

package/catalog/skills-general.json

@@ -91,8 +91,8 @@
       "source": ".github/skills/team/SKILL.md",
       "sourcePath": ".github/skills/team/SKILL.md",
       "canonicalPath": ".github/skills/team/SKILL.md",
-      "description": "Split approved plans into parallel lanes.",
-      "summary": "Split approved plans into parallel lanes.",
+      "description": "Split approved plans into visible tmux lanes in the current window by default.",
+      "summary": "Split approved plans into visible tmux lanes by default.",
       "support": "project-skill",
       "aliases": [],
       "slashCommands": [

package/dist/src/cli.d.ts

@@ -1,10 +1,5 @@
 #!/usr/bin/env node
-interface CliResult {
-    ok: boolean;
-    exitCode?: number;
-    output?: unknown;
-    message?: string;
-}
+import type { CliResult } from "./commands/types.js";
 export declare function runCli(argv?: string[]): Promise<CliResult>;
 /** Parse a --models value: comma-separated `model` or `model:role:weight` tokens. */
 export declare function parseModelsFlag(value: string): {
@@ -14,4 +9,3 @@ export declare function parseModelsFlag(value: string): {
 }[];
 /** Parse a numeric flag as a finite positive integer; throw on malformed input. */
 export declare function parsePositiveIntFlag(value: string | undefined, flag: string): number | undefined;
-export {};