indus-swarms 0.1.0

package/scripts/start-tmux-team.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Start a Pi Teams leader + N worker sessions inside tmux.
+#
+# This is primarily a dogfooding helper so we can run a "Claude-like" split-pane
+# setup (leader + interactive workers) while still using the same filesystem
+# primitives (task list + mailboxes).
+#
+# Usage:
+#   ./scripts/start-tmux-team.sh [session-name] [worker1 worker2 ...]
+#
+# Example:
+#   ./scripts/start-tmux-team.sh pi-teams alice bob carol
+
+SESSION_NAME=${1:-pi-teams}
+shift || true
+
+WORKERS=("$@")
+if [[ ${#WORKERS[@]} -eq 0 ]]; then
+  WORKERS=("alice" "bob")
+fi
+
+SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+REPO_DIR=$(cd -- "${SCRIPT_DIR}/.." && pwd)
+EXT_ENTRY="${REPO_DIR}/extensions/teams/index.ts"
+
+if [[ ! -f "${EXT_ENTRY}" ]]; then
+  echo "ERROR: extension entry not found: ${EXT_ENTRY}" >&2
+  exit 1
+fi
+
+# Use a fresh temp root per run unless the caller provided one.
+TEAMS_ROOT=${PI_TEAMS_ROOT_DIR:-"/tmp/pi-teams-$(date +%Y%m%d-%H%M%S)"}
+mkdir -p "${TEAMS_ROOT}"
+
+# If the session already exists, refuse (avoid clobbering a running team).
+if tmux has-session -t "${SESSION_NAME}" 2>/dev/null; then
+  echo "ERROR: tmux session already exists: ${SESSION_NAME}" >&2
+  echo "Attach with: tmux attach -t ${SESSION_NAME}" >&2
+  exit 1
+fi
+
+echo "Starting leader..."
+# Leader (interactive)
+tmux new-session -d -s "${SESSION_NAME}" -c "${REPO_DIR}" \
+  "PI_TEAMS_ROOT_DIR=${TEAMS_ROOT} indusagi -e ${EXT_ENTRY}"
+
+# Wait for the leader to create the team directory.
+TEAM_ID=""
+for _ in {1..80}; do
+  # First directory directly under TEAMS_ROOT.
+  TEAM_DIR=$(find "${TEAMS_ROOT}" -mindepth 1 -maxdepth 1 -type d -print -quit 2>/dev/null || true)
+  if [[ -n "${TEAM_DIR}" ]]; then
+    TEAM_ID=$(basename "${TEAM_DIR}")
+    break
+  fi
+  sleep 0.25
+done
+
+if [[ -z "${TEAM_ID}" ]]; then
+  echo "ERROR: timed out waiting for team directory under ${TEAMS_ROOT}" >&2
+  echo "Check leader pane: tmux attach -t ${SESSION_NAME}" >&2
+  exit 1
+fi
+
+echo "TeamId: ${TEAM_ID}"
+
+echo "Starting workers: ${WORKERS[*]}"
+for name in "${WORKERS[@]}"; do
+  # Each worker is an interactive indusagi session running the extension in worker mode.
+  tmux new-window -t "${SESSION_NAME}" -n "${name}" -c "${REPO_DIR}" \
+    "PI_TEAMS_ROOT_DIR=${TEAMS_ROOT} PI_TEAMS_WORKER=1 PI_TEAMS_TEAM_ID=${TEAM_ID} PI_TEAMS_AGENT_NAME=${name} indusagi -e ${EXT_ENTRY}"
+done
+
+cat <<EOF
+
+OK
+
+tmux session: ${SESSION_NAME}
+teams root:   ${TEAMS_ROOT}
+team id:      ${TEAM_ID}
+
+Attach:
+  tmux attach -t ${SESSION_NAME}
+
+In the leader pane, try:
+  /team help
+  /team task add ${WORKERS[0]}: say hello
+  /team task list
+EOF

package/skills/agent-teams/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: agent-teams
+description: "Coordinate multi-agent teamwork with shared task lists, mailbox messaging, and long-lived teammates. Use when the user asks to spawn workers, delegate tasks, work in parallel with agents, or manage a team of workers via the indus-swarms extension."
+---
+
+# Agent Teams
+
+Spawn and coordinate teammate agents that work in parallel on shared task lists, communicating via file-based mailboxes. Modeled after Claude Code Agent Teams.
+
+## Core concepts
+
+- **Leader** (you): orchestrates, delegates, reviews. Runs the `/team` command and the `teams` LLM tool.
+- **Teammates**: child indus processes that poll for tasks, execute them, and report back. Sessions are named `indus-swarms - <role> <name>` where `<role>` depends on the current style (e.g. teammate/comrade/matey).
+- **Task list**: file-per-task store with statuses (pending/in_progress/completed), owners, and dependency tracking.
+- **Mailbox**: file-based message queue. Two namespaces: `team` (DMs, notifications, shutdown) and `taskListId` (task assignments).
+
+## UI style (terminology + naming)
+
+Built-in styles:
+- `normal` (default): Team leader + Teammate <name>
+- `soviet`: Chairman + Comrade <name>
+- `pirate`: Captain + Matey <name>
+
+Configure via `INDUS_TEAMS_STYLE=<name>` or `/team style <name>` (see `/team style list`).
+
+Custom styles reside under `~/.indusagi/agent/teams/_styles/<style>.json` and can also be bootstrapped with:
+
+- `/team style init <name> [extends <base>]`
+
+## Spawning teammates
+
+Use the **`teams` tool** (LLM-callable) for delegation, task/messaging mutations, lifecycle, and governance:
+
+| Action | Required fields | Notes |
+| --- | --- | --- |
+| `delegate` | `tasks` | Spawns as needed, creates and assigns tasks. |
+| `task_assign` | `taskId`, `assignee` | Assign/reassign owner. |
+| `task_unassign` | `taskId` | Clear owner. |
+| `task_set_status` | `taskId`, `status` | `pending` \| `in_progress` \| `completed`. |
+| `task_dep_add` / `task_dep_rm` | `taskId`, `depId` | Dependency graph edits. |
+| `task_dep_ls` | `taskId` | Dependency/block inspection. |
+| `message_dm` | `name`, `message` | Mailbox DM. |
+| `message_broadcast` | `message` | Mailbox broadcast. |
+| `message_steer` | `name`, `message` | RPC steer for running teammate. |
+| `member_spawn` | `name` | Supports context/workspace/model/thinking/plan options. |
+| `member_shutdown` | `name` or `all=true` | Graceful mailbox shutdown request. |
+| `member_kill` | `name` | Force-stop RPC teammate. |
+| `member_prune` | _(none)_ | Mark stale workers offline (`all=true` to force). |
+| `plan_approve` / `plan_reject` | `name` | Resolve pending plan approvals (`feedback` optional for reject). |
+| `hooks_policy_get` | _(none)_ | Read team hooks policy (configured + effective). |
+| `hooks_policy_set` | one or more: `hookFailureAction`, `hookMaxReopensPerTask`, `hookFollowupOwner` | Update team hooks policy at runtime (`hooksPolicyReset=true` clears team overrides first). |
+| `model_policy_get` | _(none)_ | Inspect teammate model policy and current leader inheritance behavior. |
+| `model_policy_check` | optional `model` | Validate a model override before spawn (`<provider>/<modelId>` or `<modelId>`). |
+
+Examples:
+
+```
+teams({ action: "delegate", tasks: [{ text: "Implement auth", assignee: "alice" }] })
+teams({ action: "task_assign", taskId: "12", assignee: "alice" })
+teams({ action: "task_dep_add", taskId: "12", depId: "7" })
+teams({ action: "message_broadcast", message: "Sync: finishing this milestone" })
+teams({ action: "member_kill", name: "alice" })
+teams({ action: "plan_reject", name: "alice", feedback: "Include rollback strategy" })
+teams({ action: "hooks_policy_get" })
+teams({ action: "hooks_policy_set", hookFailureAction: "reopen_followup", hookMaxReopensPerTask: 2, hookFollowupOwner: "member" })
+teams({ action: "model_policy_get" })
+teams({ action: "model_policy_check", model: "openai-codex/gpt-5.1-codex-mini" })
+```
+
+This covers most day-to-day orchestration without slash commands. For nuanced/manual control, use `/team ...` commands directly.
+
+For more control, use `/team spawn`:
+
+```
+/team spawn alice              # default: fresh context, shared workspace
+/team spawn bob branch shared  # clone leader session context
+/team spawn carol fresh worktree  # git worktree isolation
+/team spawn dave plan          # plan-required mode (read-only until approved)
+```
+
+## Task management
+
+```
+/team task add <text...>                # create a task
+/team task add alice: review the API    # create + assign (prefix with name:)
+/team task assign <id> <agent>          # assign existing task
+/team task unassign <id>                # unassign
+/team task list                         # show all tasks with status + deps
+/team task show <id>                    # full task details + result
+/team task dep add <id> <depId>         # task depends on depId
+/team task dep rm <id> <depId>          # remove dependency
+/team task dep ls <id>                  # show dependency graph
+/team task clear [completed|all]        # delete tasks
+/team task use <taskListId>             # switch to a different task list
+```
+
+Teammates auto-claim unassigned, unblocked tasks by default.
+
+## Communication
+
+```
+/team dm <name> <msg...>       # direct message to one teammate
+/team broadcast <msg...>       # message all teammates
+/team send <name> <msg...>     # RPC-based (immediate, for spawned teammates)
+```
+
+Teammates can also message each other directly via the `team_message` tool, with the leader CC'd.
+
+## Governance modes
+
+### Delegate mode
+
+Restricts the leader to coordination-only (blocks bash/edit/write tools). Use when you want to force all implementation through teammates.
+
+```
+/team delegate on    # enable
+/team delegate off   # disable
+```
+
+### Plan approval
+
+Spawning with `plan` restricts the teammate to read-only tools. After producing a plan, the teammate submits it for leader approval before proceeding.
+
+```
+/team spawn alice plan         # spawn in plan-required mode
+/team plan approve alice       # approve plan, teammate gets full tools
+/team plan reject alice <feedback...>  # reject, teammate revises
+```
+
+## Lifecycle
+
+```
+/team panel                    # interactive overlay with teammate details
+/team list                     # show teammates and their state
+/team attach list              # discover existing teams under <teamsRoot>
+/team attach <teamId> [--claim] # attach this session to an existing team workspace (force takeover with --claim)
+/team detach                   # return to this session's own team workspace
+/team shutdown                 # stop all teammates (RPC + best-effort manual) (leader session remains active)
+/team shutdown <name>          # graceful shutdown (teammate can reject if busy)
+/team prune [--all]            # hide stale manual teammates (mark offline in config)
+/team kill <name>              # force-terminate one RPC teammate
+/team cleanup [--force]        # delete team directory after all teammates stopped
+```
+
+Teammates reject shutdown requests when they have an active task. Use `/team kill <name>` to force.
+
+## Other commands
+
+```
+/team id       # show team ID, task list ID, paths
+/team env <n>  # print env vars for manually spawning a teammate named <n>
+```
+
+## Shared task list across sessions
+
+Set `INDUS_TEAMS_TASK_LIST_ID` whenever you start a teammate manually or launch an indus-swarms worker via `indusagi --mode rpc`. New teammates inherit this task list, and you can switch leaders using `/team task use <taskListId>` to persist the selection.
+
+The leader switches task lists via:
+
+```
+/team task use my-persistent-list
+```
+
+The chosen task list ID is persisted in `config.json`. Teammates spawned after the switch inherit the new task list ID; existing teammates need a restart to pick up changes.
+
+## Message protocol
+
+Teammates and the leader communicate via JSON messages with a `type` field:
+
+| Type | Direction | Purpose |
+|---|---|---|
+| `task_assignment` | leader -> teammate | Notify of assigned task |
+| `idle_notification` | teammate -> leader | Teammate finished, no more work |
+| `shutdown_request` | leader -> teammate | Ask to shut down |
+| `shutdown_approved` | teammate -> leader | Will shut down |
+| `shutdown_rejected` | teammate -> leader | Busy, can't shut down now |
+| `plan_approval_request` | teammate -> leader | Plan ready for review |
+| `plan_approved` | leader -> teammate | Proceed with implementation |
+| `plan_rejected` | leader -> teammate | Revise plan (includes feedback) |
+| `peer_dm_sent` | teammate -> leader | CC notification of peer message |

package/tsconfig.strict.json

@@ -0,0 +1,22 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"lib": ["ES2022"],
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"types": ["node"],
+
+		"strict": true,
+		"noImplicitAny": true,
+		"useUnknownInCatchVariables": true,
+		"noUncheckedIndexedAccess": true,
+
+		"verbatimModuleSyntax": true,
+		"forceConsistentCasingInFileNames": true,
+		"skipLibCheck": true,
+
+		"noEmit": true
+	},
+	"include": ["extensions/**/*.ts", "scripts/**/*.ts", "scripts/**/*.mts"],
+	"exclude": ["node_modules", "dist", "build", "coverage"]
+}