llm-party-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AALA Solutions
+
+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,392 @@
+<p align="center">
+  <h1 align="center">llm-party</h1>
+  <p align="center">
+    <strong>Bring your models. We'll bring the party.</strong>
+  </p>
+  <p align="center">
+    <a href="https://llm-party.party">Website</a> &middot;
+    <a href="https://www.npmjs.com/package/llm-party-cli">npm</a> &middot;
+    <a href="https://github.com/aalasolutions/llm-party">GitHub</a>
+  </p>
+  <p align="center">
+    <a href="https://www.npmjs.com/package/llm-party-cli"><img src="https://img.shields.io/npm/v/llm-party-cli?style=flat-square&color=cb3837" alt="npm version"></a>
+    <a href="https://github.com/aalasolutions/llm-party/blob/main/LICENSE"><img src="https://img.shields.io/github/license/aalasolutions/llm-party?style=flat-square" alt="license"></a>
+    <a href="https://github.com/aalasolutions/llm-party"><img src="https://img.shields.io/github/stars/aalasolutions/llm-party?style=flat-square" alt="stars"></a>
+  </p>
+</p>
+
+<br/>
+
+A peer orchestrator that puts **Claude**, **Codex**, **Copilot**, and **GLM** in the same terminal. You talk, they listen. They talk to each other. Nobody is the boss except you.
+
+```
+YOU > @claude review this function
+[CLAUDE] The error handling on line 42 swallows exceptions silently...
+
+YOU > @codex fix what claude found
+[CODEX] Fixed. Wrapped in try/catch with proper logging. See diff below.
+
+YOU > @copilot write tests for the fix
+[COPILOT] Added 3 test cases covering the happy path and both error branches.
+```
+
+No MCP. No master/servant. No window juggling. Just peers at a terminal table.
+
+<br/>
+
+## Why llm-party?
+
+| | Traditional multi-agent | llm-party |
+|---|---|---|
+| **Architecture** | MCP (master controls servants) | Peer orchestration (you control all) |
+| **Integration** | CLI wrapping, output scraping | Direct SDK adapters |
+| **Sessions** | Fresh each time | Persistent per provider |
+| **Context** | Agents are siloed | Every agent sees the full conversation |
+| **API tokens** | Separate keys per tool | Uses your existing CLI auth |
+
+<br/>
+
+## Getting started
+
+### Install and run
+
+```bash
+npm install -g llm-party-cli
+llm-party
+```
+
+That's it. Agents use your current working directory. Config defaults are included in the package.
+
+### Set up your agents
+
+Edit `configs/default.json`. Each agent needs a name, provider, and model:
+
+```json
+{
+  "humanName": "YOUR NAME",
+  "agents": [
+    {
+      "name": "Claude",
+      "tag": "claude",
+      "provider": "claude",
+      "model": "opus",
+      "systemPrompt": ["./prompts/base.md"]
+    },
+    {
+      "name": "Codex",
+      "tag": "codex",
+      "provider": "codex",
+      "model": "gpt-5.2",
+      "systemPrompt": ["./prompts/base.md"]
+    }
+  ]
+}
+```
+
+### Talk to your agents
+
+```
+@claude explain this error          # talk to one agent
+@claude @codex review this          # talk to multiple
+@all what does everyone think?      # broadcast to all agents
+@everyone same as @all              # alias
+```
+
+> **Note:** Once you tag an agent, all follow-up messages without a tag go to that same agent. Use `@all` or `@everyone` to broadcast again.
+
+### Agent-to-agent handoff
+
+Agents can pass the conversation to each other by ending their response with `@next:<tag>`. The orchestrator picks it up and dispatches automatically. Max 15 hops per cycle to prevent loops.
+
+<br/>
+
+## Before you start
+
+**Verify your CLIs work first.** Before adding an agent to `configs/default.json`, make sure its CLI is installed and authenticated:
+
+```bash
+claude --version        # Claude Code CLI
+codex --version         # OpenAI Codex CLI
+copilot --version       # GitHub Copilot CLI
+```
+
+If a CLI doesn't work on its own, it won't work inside llm-party.
+
+**No extra API tokens.** llm-party uses the original CLIs and SDKs under the hood. Your existing authentication and subscriptions are used directly. Sessions created by agents appear in each tool's native session history (Claude Code sessions, Codex threads, etc.) since the underlying SDKs manage their own persistence.
+
+**Run in isolation.** Always run llm-party inside a disposable environment: a Docker container, a VM, or at minimum a throwaway git branch. Agents have full filesystem and shell access with zero approval gates.
+
+<br/>
+
+## How we use the SDKs
+
+llm-party uses **official, publicly available SDKs and CLIs** published by each provider. Nothing is reverse-engineered, patched, or bypassed.
+
+| Provider | Official SDK | Published by |
+|----------|-------------|-------------|
+| Claude | [`@anthropic-ai/claude-agent-sdk`](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) | Anthropic |
+| Codex | [`@openai/codex-sdk`](https://www.npmjs.com/package/@openai/codex-sdk) | OpenAI |
+| Copilot | [`@github/copilot-sdk`](https://www.npmjs.com/package/@github/copilot-sdk) | GitHub |
+
+All authentication flows through the provider's own CLI login. Your API keys, OAuth tokens, and subscriptions are used as-is. llm-party does not store, proxy, or intercept credentials.
+
+If any provider believes this project violates their terms of service, please [open an issue](https://github.com/aalasolutions/llm-party/issues) and we will address it immediately.
+
+## Supported providers
+
+| Provider | SDK | Session | System Prompt |
+|----------|-----|---------|---------------|
+| **Claude** | `@anthropic-ai/claude-agent-sdk` | Persistent via session ID resume | Full control |
+| **Codex** | `@openai/codex-sdk` | Persistent thread with `run()` turns | Via `developer_instructions` (see limitations) |
+| **Copilot** | `@github/copilot-sdk` | Persistent via `sendAndWait()` | Full control |
+| **GLM** | Claude SDK + env proxy | Same as Claude | Full control |
+
+<br/>
+
+---
+
+<br/>
+
+## How it works
+
+Most multi-agent setups use MCP (one agent controls others) or CLI wrapping (spawn processes and scrape terminal output). Both are fragile and hierarchical.
+
+llm-party uses SDK adapters directly. Each agent gets a persistent session with its provider. Full tool access. Real conversation threading. The orchestrator owns routing, agents are peers.
+
+```
+Terminal (you)
+    |
+    v
+Orchestrator
+    |
+    +-- Agent Registry
+    |     +-- Claude  -> ClaudeAdapter  (SDK session, resume by ID)
+    |     +-- Codex   -> CodexAdapter   (SDK thread, persistent turns)
+    |     +-- Copilot -> CopilotAdapter (SDK session, sendAndWait)
+    |     +-- GLM     -> GlmAdapter     (Claude SDK + env proxy)
+    |
+    +-- Conversation Log (ordered, all messages, agent-prefixed)
+    |
+    +-- Transcript Writer (JSONL, append-only, per session)
+```
+
+Each agent receives a rolling window of recent messages (default 16) plus any unseen messages since its last turn. Messages from other agents are included so everyone sees the full multi-party conversation.
+
+<br/>
+
+## Provider details
+
+### Claude
+
+| | |
+|---|---|
+| SDK | `@anthropic-ai/claude-agent-sdk` |
+| Session | Persistent via `resume: sessionId`. First call creates a session, subsequent calls resume it. |
+| System prompt | Passed directly to the SDK via `options.systemPrompt`. Full control. |
+| Tools | Read, Write, Edit, Bash, Glob, Grep |
+| Permissions | `permissionMode: "bypassPermissions"` (all tools auto-approved) |
+
+System prompt works exactly as expected. Personality, behavior, workflow rules all respected.
+
+### Codex
+
+| | |
+|---|---|
+| SDK | `@openai/codex-sdk` |
+| Session | Persistent thread. `startThread()` creates it, `thread.run()` adds turns to the same conversation. |
+| System prompt | Injected via `developer_instructions` config key, passed as `--config` flag to the CLI subprocess. |
+| Tools | exec_command, apply_patch, file operations (Codex built-in toolset) |
+| Permissions | `sandboxMode: "danger-full-access"`, `approvalPolicy: "never"` |
+
+**Known limitation:** Codex ships with a massive built-in system prompt (~13k tokens) that cannot be overridden. Your `developer_instructions` are appended alongside it, not replacing it. This means:
+
+- **Works:** Action instructions (create files, follow naming conventions), formatting rules (prefix responses with agent name), workflow rules (handoff syntax, routing tags)
+- **Does not work:** Personality overrides, identity changes, behavioral rewrites
+
+We tested `instructions`, `developer_instructions`, and `experimental_instructions_file`. All three append to the built-in prompt. None replace it.
+
+**Also observed:** Codex is aggressive with file operations. When asked to "create your file," it read the orchestrator source code, ran the Codex CLI, and modified `src/ui/terminal.ts` instead of just creating a simple markdown file.
+
+### Copilot
+
+| | |
+|---|---|
+| SDK | `@github/copilot-sdk` |
+| Session | Persistent via `CopilotClient.createSession()`. Messages sent with `session.sendAndWait()`. |
+| System prompt | Set as `systemMessage: { content: prompt }` on session creation. |
+| Tools | Copilot built-in toolset |
+| Permissions | `onPermissionRequest: approveAll` (all actions auto-approved) |
+
+System prompt works as expected.
+
+### GLM
+
+| | |
+|---|---|
+| SDK | `@anthropic-ai/claude-agent-sdk` (same as Claude) |
+| Session | Same as Claude, but routed through a proxy. |
+| System prompt | Same as Claude. Full control. |
+| Tools | Same as Claude |
+| Permissions | Same as Claude |
+
+GLM is not tied to any specific CLI. It uses the Claude SDK as the transport layer because Claude Code supports environment variable overrides for base URL and model aliases, making it a convenient proxy bridge. Any CLI that supports similar env-based routing could be swapped in.
+
+<br/>
+
+## Config reference
+
+Config file: `configs/default.json`. Override with `LLM_PARTY_CONFIG` env var.
+
+### Top-level fields
+
+| Field | Required | Default | Description |
+|-------|----------|---------|-------------|
+| `humanName` | No | `USER` | Your name displayed in the terminal prompt and passed to agents |
+| `humanTag` | No | derived from `humanName` | Tag used for human handoff detection. When an agent says `@next:you`, the orchestrator stops and returns control to you |
+| `maxAutoHops` | No | `15` | Max agent-to-agent handoffs per cycle. Prevents infinite loops. Use `"unlimited"` to remove the cap |
+| `timeout` | No | `600` | Default timeout in seconds for all agents. 10 minutes by default |
+| `agents` | Yes | | Array of agent definitions. Must have at least one |
+
+### Agent fields
+
+| Field | Required | Default | Description |
+|-------|----------|---------|-------------|
+| `name` | Yes | | Display name shown in responses as `[AGENT NAME]` |
+| `tag` | No | derived from `name` | Routing tag for `@tag` targeting. Auto-generated as lowercase with dashes if omitted |
+| `provider` | Yes | | SDK adapter: `claude`, `codex`, `copilot`, or `glm` |
+| `model` | Yes | | Model ID passed to the provider. Examples: `opus`, `sonnet`, `gpt-5.2`, `gpt-4.1`, `glm-5` |
+| `systemPrompt` | Yes | | Path or array of paths to prompt markdown files. Relative to project root |
+| `executablePath` | No | PATH lookup | Path to the CLI binary. Supports `~/` for home directory. Only needed if the CLI is not in your PATH |
+| `env` | No | inherits `process.env` | Environment variable overrides for this agent's process |
+| `timeout` | No | top-level value | Per-agent timeout in seconds. Overrides the top-level default |
+
+### System prompts
+
+Single file or multiple files merged in order:
+
+```json
+"systemPrompt": "./prompts/base.md"
+"systemPrompt": ["./prompts/base.md", "./prompts/reviewer.md"]
+```
+
+Files are concatenated with `---` separators, then template variables are replaced. Available variables:
+
+| Variable | Description |
+|----------|-------------|
+| `{{agentName}}` | This agent's display name |
+| `{{agentTag}}` | This agent's routing tag |
+| `{{humanName}}` | The human's display name |
+| `{{humanTag}}` | The human's routing tag |
+| `{{agentCount}}` | Total number of active agents |
+| `{{allAgentNames}}` | All agent names, comma-separated |
+| `{{allAgentTags}}` | All agent tags as `@tag` |
+| `{{otherAgentList}}` | Other agents formatted as `- Name: use @tag` |
+| `{{otherAgentNames}}` | Other agent names, comma-separated |
+| `{{validHandoffTargets}}` | Valid `@next:tag` values for handoff |
+
+### GLM environment setup
+
+GLM requires environment overrides to route through a proxy. The adapter first tries to load env variables from your shell `glm` alias (`zsh -ic "alias glm"`). If you have a `glm` alias that sets `ANTHROPIC_AUTH_TOKEN` and `ANTHROPIC_BASE_URL`, it picks those up automatically.
+
+Without the alias, provide everything in the `env` block:
+
+```json
+{
+  "name": "GLM Agent",
+  "provider": "glm",
+  "model": "glm-5",
+  "systemPrompt": ["./prompts/base.md"],
+  "executablePath": "~/.local/bin/claude",
+  "env": {
+    "ANTHROPIC_AUTH_TOKEN": "your-glm-api-key",
+    "ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.5",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-5"
+  }
+}
+```
+
+<br/>
+
+## Session and transcript
+
+Every run generates a unique session ID and appends messages to a JSONL transcript file under `.llm-party/sessions/`. The session ID and transcript path are printed at startup.
+
+File changes made by agents during their turns are detected via `git status` after each response cycle. Newly modified files are printed with timestamps.
+
+Use `/save <path>` to export the full in-memory conversation as formatted JSON.
+
+<br/>
+
+## Terminal commands
+
+| Command | What it does |
+|---------|-------------|
+| `/agents` | List active agents with tag, provider, model |
+| `/history` | Print full conversation history |
+| `/save <path>` | Export conversation as JSON |
+| `/session` | Show session ID and transcript path |
+| `/changes` | Show git-modified files |
+| `/exit` | Quit |
+
+<br/>
+
+## Development
+
+```bash
+git clone https://github.com/aalasolutions/llm-party.git
+cd llm-party
+npm install
+npm run dev
+```
+
+Build and run from dist:
+
+```bash
+npm run build
+npm start
+```
+
+Override config path:
+
+```bash
+LLM_PARTY_CONFIG=/path/to/config.json npm run dev
+```
+
+<br/>
+
+## Troubleshooting
+
+**"ENOENT for prompt path"**
+Your `systemPrompt` points to a file that does not exist. Paths are relative to project root. Verify with `ls prompts/`.
+
+**"No agent matched @tag"**
+The tag you typed does not match any agent's `tag`, `name`, or `provider`. Run `/agents` to see what is available.
+
+**"Unsupported provider"**
+Your config has a provider value that is not one of: `claude`, `codex`, `copilot`, `glm`.
+
+**Agent modifies source code unexpectedly**
+Expected behavior with full-access permissions. Agents can read, write, and execute anything. Use git to review and revert. Codex in particular is aggressive with file operations.
+
+**Codex ignores personality instructions**
+Known limitation. Codex has a 13k+ token built-in system prompt that overrides personality and identity instructions. Functional instructions (naming, workflow, formatting) still work.
+
+**Agent response timeout**
+Claude and Copilot have a 120-second timeout. GLM has 240 seconds. If an agent consistently times out, check your API keys and network connectivity.
+
+<br/>
+
+## Warning
+
+All agents run with **full permissions**. They can read, write, edit files and execute shell commands. There is no confirmation step before any action.
+
+You are responsible for any changes, data loss, costs, or side effects. Do not run against production systems or repos you cannot recover from.
+
+<br/>
+
+<p align="center">
+  <a href="https://llm-party.party">llm-party.party</a> &middot;
+  Built by <a href="https://aalasolutions.com">AALA Solutions</a>
+</p>

package/configs/default.json

@@ -0,0 +1,22 @@
+{
+  "humanName": "AAMIR",
+  "humanTag": "aamir",
+  "maxAutoHops": 15,
+  "agents": [
+    {
+      "name": "Agent 2",
+      "tag": "opus",
+      "provider": "claude",
+      "model": "opus",
+      "systemPrompt": ["./prompts/base.md"],
+      "executablePath": "~/.local/bin/claude"
+    },
+    {
+      "name": "Agent 3",
+      "tag": "copilot",
+      "provider": "copilot",
+      "model": "gpt-4.1",
+      "systemPrompt": ["./prompts/base.md"]
+    }
+  ]
+}

package/dist/adapters/base.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/claude.js

@@ -0,0 +1,64 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+export class ClaudeAdapter {
+    name;
+    provider = "claude";
+    model;
+    systemPrompt = "";
+    sessionId = "";
+    runtimeEnv = {};
+    claudeExecutable;
+    constructor(name, model) {
+        this.name = name;
+        this.model = model;
+    }
+    async init(config) {
+        this.systemPrompt = Array.isArray(config.systemPrompt) ? config.systemPrompt.join("\n\n") : config.systemPrompt;
+        this.runtimeEnv = { ...process.env, ...(config.env ?? {}) };
+        this.claudeExecutable = config.executablePath ?? process.env.CLAUDE_CODE_EXECUTABLE;
+    }
+    async send(messages) {
+        const transcript = messages
+            .map((m) => `[${m.from}]: ${m.text}`)
+            .join("\n\n");
+        return await this.queryClaude(transcript);
+    }
+    async destroy() {
+        return;
+    }
+    async queryClaude(transcript) {
+        const executableOpt = this.claudeExecutable
+            ? { pathToClaudeCodeExecutable: this.claudeExecutable }
+            : {};
+        const options = {
+            cwd: process.cwd(),
+            env: this.runtimeEnv,
+            allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            systemPrompt: this.systemPrompt,
+            model: this.model,
+            settingSources: [],
+            ...(this.sessionId ? { resume: this.sessionId } : {}),
+            ...executableOpt
+        };
+        for await (const message of query({ prompt: transcript, options })) {
+            if (message &&
+                typeof message === "object" &&
+                "type" in message &&
+                "subtype" in message &&
+                "session_id" in message &&
+                message.type === "system" &&
+                message.subtype === "init" &&
+                typeof message.session_id === "string") {
+                this.sessionId = message.session_id;
+            }
+            if (message && typeof message === "object" && "result" in message) {
+                const result = message.result;
+                return typeof result === "string" && result.length > 0
+                    ? result
+                    : "[No text response from Claude]";
+            }
+        }
+        return "[No text response from Claude]";
+    }
+}

package/dist/adapters/codex.js

@@ -0,0 +1,46 @@
+import { Codex } from "@openai/codex-sdk";
+export class CodexAdapter {
+    name;
+    provider = "codex";
+    model;
+    codex;
+    thread;
+    constructor(name, model) {
+        this.name = name;
+        this.model = model;
+    }
+    async init(config) {
+        const cliPath = config.executablePath ?? process.env.CODEX_CLI_EXECUTABLE;
+        const systemPrompt = Array.isArray(config.systemPrompt)
+            ? config.systemPrompt.join("\n\n")
+            : config.systemPrompt;
+        this.codex = new Codex({
+            ...(cliPath ? { codexPathOverride: cliPath } : {}),
+            ...(config.env?.OPENAI_API_KEY ? { apiKey: config.env.OPENAI_API_KEY } : {}),
+            ...(systemPrompt ? { config: { developer_instructions: systemPrompt } } : {}),
+        });
+        this.thread = this.codex.startThread({
+            model: this.model,
+            sandboxMode: "danger-full-access",
+            workingDirectory: process.cwd(),
+            approvalPolicy: "never",
+        });
+    }
+    async send(messages) {
+        if (!this.thread) {
+            return "[Codex thread not initialized]";
+        }
+        const transcript = messages
+            .map((m) => `[${m.from}]: ${m.text}`)
+            .join("\n\n");
+        const turn = await this.thread.run(transcript);
+        if (turn.finalResponse && turn.finalResponse.length > 0) {
+            return turn.finalResponse;
+        }
+        return "[No text response from Codex]";
+    }
+    async destroy() {
+        this.thread = undefined;
+        this.codex = undefined;
+    }
+}

package/dist/adapters/copilot.js

@@ -0,0 +1,48 @@
+import { CopilotClient, approveAll } from "@github/copilot-sdk";
+export class CopilotAdapter {
+    name;
+    provider = "copilot";
+    model;
+    client;
+    session;
+    constructor(name, model) {
+        this.name = name;
+        this.model = model;
+    }
+    async init(config) {
+        const systemPrompt = Array.isArray(config.systemPrompt)
+            ? config.systemPrompt.join("\n\n")
+            : config.systemPrompt;
+        const cliPath = config.executablePath ?? process.env.COPILOT_CLI_EXECUTABLE;
+        this.client = new CopilotClient({
+            ...(cliPath ? { cliPath } : {}),
+        });
+        await this.client.start();
+        this.session = await this.client.createSession({
+            model: this.model,
+            systemMessage: { content: systemPrompt },
+            onPermissionRequest: approveAll,
+        });
+    }
+    async send(messages) {
+        if (!this.session) {
+            return "[Copilot session not initialized]";
+        }
+        const transcript = messages
+            .map((m) => `[${m.from}]: ${m.text}`)
+            .join("\n\n");
+        const response = await this.session.sendAndWait({ prompt: transcript });
+        if (response && response.data && typeof response.data.content === "string" && response.data.content.length > 0) {
+            return response.data.content;
+        }
+        return "[No text response from Copilot]";
+    }
+    async destroy() {
+        if (this.session) {
+            await this.session.disconnect();
+        }
+        if (this.client) {
+            await this.client.stop();
+        }
+    }
+}

package/dist/adapters/glm.js

@@ -0,0 +1,91 @@
+import { spawn } from "node:child_process";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+export class GlmAdapter {
+    name;
+    provider = "glm";
+    model;
+    systemPrompt = "";
+    sessionId = "";
+    runtimeEnv = {};
+    claudeExecutable;
+    constructor(name, model) {
+        this.name = name;
+        this.model = model;
+    }
+    async init(config) {
+        this.systemPrompt = Array.isArray(config.systemPrompt) ? config.systemPrompt.join("\n\n") : config.systemPrompt;
+        const aliasEnv = await loadGlmAliasEnv();
+        this.runtimeEnv = { ...process.env, ...aliasEnv, ...(config.env ?? {}) };
+        this.claudeExecutable = config.executablePath ?? process.env.CLAUDE_CODE_EXECUTABLE;
+    }
+    async send(messages) {
+        const transcript = messages
+            .map((m) => `[${m.from}]: ${m.text}`)
+            .join("\n\n");
+        return await this.queryGlm(transcript);
+    }
+    async destroy() {
+        return;
+    }
+    async queryGlm(transcript) {
+        const executableOpt = this.claudeExecutable
+            ? { pathToClaudeCodeExecutable: this.claudeExecutable }
+            : {};
+        const options = {
+            cwd: process.cwd(),
+            env: this.runtimeEnv,
+            allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            systemPrompt: this.systemPrompt,
+            model: this.model,
+            settingSources: [],
+            ...(this.sessionId ? { resume: this.sessionId } : {}),
+            ...executableOpt
+        };
+        for await (const message of query({ prompt: transcript, options })) {
+            if (message &&
+                typeof message === "object" &&
+                "type" in message &&
+                "subtype" in message &&
+                "session_id" in message &&
+                message.type === "system" &&
+                message.subtype === "init" &&
+                typeof message.session_id === "string") {
+                this.sessionId = message.session_id;
+            }
+            if (message && typeof message === "object" && "result" in message) {
+                const result = message.result;
+                return typeof result === "string" && result.length > 0
+                    ? result
+                    : "[No text response from GLM]";
+            }
+        }
+        return "[No text response from GLM]";
+    }
+}
+async function loadGlmAliasEnv() {
+    return new Promise((resolve) => {
+        const child = spawn("zsh", ["-ic", "alias glm"], {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.on("close", () => {
+            const env = {};
+            const tokens = stdout.match(/[A-Z_]+="[^"]*"/g) ?? [];
+            for (const token of tokens) {
+                const [key, raw] = token.split("=");
+                env[key] = raw.replace(/^"|"$/g, "");
+            }
+            resolve(env);
+        });
+        child.on("error", () => {
+            resolve({});
+        });
+    });
+}

package/dist/config/loader.js

@@ -0,0 +1,48 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+const VALID_PROVIDERS = ["claude", "codex", "copilot", "glm"];
+function validateConfig(data) {
+    if (!data || typeof data !== "object") {
+        throw new Error("Config must be an object");
+    }
+    const cfg = data;
+    if (!Array.isArray(cfg.agents)) {
+        throw new Error("Config must have 'agents' array");
+    }
+    if (cfg.agents.length === 0) {
+        throw new Error("Config 'agents' array cannot be empty");
+    }
+    for (let i = 0; i < cfg.agents.length; i++) {
+        const agent = cfg.agents[i];
+        if (!agent || typeof agent !== "object") {
+            throw new Error(`Agent at index ${i} must be an object`);
+        }
+        if (typeof agent.name !== "string" || agent.name.trim() === "") {
+            throw new Error(`Agent at index ${i} must have a non-empty 'name' string`);
+        }
+        if (typeof agent.model !== "string" || agent.model.trim() === "") {
+            throw new Error(`Agent '${agent.name}' must have a non-empty 'model' string`);
+        }
+        if (!VALID_PROVIDERS.includes(agent.provider)) {
+            throw new Error(`Agent '${agent.name}' has invalid provider '${agent.provider}'. Valid: ${VALID_PROVIDERS.join(", ")}`);
+        }
+        if (agent.systemPrompt !== undefined) {
+            const isString = typeof agent.systemPrompt === "string";
+            const isArray = Array.isArray(agent.systemPrompt) && agent.systemPrompt.every((p) => typeof p === "string");
+            if (!isString && !isArray) {
+                throw new Error(`Agent '${agent.name}' systemPrompt must be a string or string array`);
+            }
+        }
+    }
+    for (const agent of cfg.agents) {
+        if (typeof agent.executablePath === "string" && agent.executablePath.startsWith("~/")) {
+            agent.executablePath = homedir() + agent.executablePath.slice(1);
+        }
+    }
+    return cfg;
+}
+export async function loadConfig(path) {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return validateConfig(parsed);
+}

package/dist/index.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ClaudeAdapter } from "./adapters/claude.js";
+import { CodexAdapter } from "./adapters/codex.js";
+import { CopilotAdapter } from "./adapters/copilot.js";
+import { GlmAdapter } from "./adapters/glm.js";
+import { loadConfig } from "./config/loader.js";
+import { Orchestrator } from "./orchestrator.js";
+import { runTerminal } from "./ui/terminal.js";
+async function main() {
+    const appRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+    const configPath = process.env.LLM_PARTY_CONFIG
+        ? path.resolve(process.env.LLM_PARTY_CONFIG)
+        : path.join(appRoot, "configs", "default.json");
+    const config = await loadConfig(configPath);
+    const humanName = config.humanName?.trim() || "USER";
+    const humanTag = config.humanTag?.trim() || toTag(humanName);
+    const maxAutoHops = resolveMaxAutoHops(config.maxAutoHops);
+    const resolveFromAppRoot = (value) => {
+        return path.isAbsolute(value) ? value : path.resolve(appRoot, value);
+    };
+    const adapters = await Promise.all(config.agents.map(async (agent, index, allAgents) => {
+        const promptPaths = Array.isArray(agent.systemPrompt)
+            ? agent.systemPrompt.map((p) => resolveFromAppRoot(p))
+            : [resolveFromAppRoot(agent.systemPrompt)];
+        const promptParts = await Promise.all(promptPaths.map((p) => readFile(p, "utf8")));
+        const promptTemplate = promptParts.join("\n\n---\n\n");
+        const peers = allAgents.filter((candidate) => candidate.name !== agent.name);
+        const tag = agent.tag?.trim() || toTag(agent.name);
+        const otherAgentList = peers.length > 0
+            ? peers
+                .map((peer) => {
+                const peerTag = peer.tag?.trim() || toTag(peer.name);
+                return `- ${peer.name}: use @${peerTag}`;
+            })
+                .join("\n")
+            : "- None";
+        const validHandoffTargets = peers.length > 0
+            ? peers.map((peer) => `@next:${peer.tag?.trim() || toTag(peer.name)}`).join(", ")
+            : "none";
+        const prompt = renderPromptTemplate(promptTemplate, {
+            humanName,
+            humanTag,
+            agentName: agent.name,
+            agentTag: tag,
+            validHandoffTargets,
+            otherAgentList,
+            otherAgentNames: peers.map((peer) => peer.name).join(", ") || "none",
+            allAgentNames: allAgents.map((candidate) => candidate.name).join(", "),
+            allAgentTags: allAgents.map((candidate) => `@${candidate.tag?.trim() || toTag(candidate.name)}`).join(", "),
+            agentCount: String(allAgents.length)
+        });
+        const adapter = agent.provider === "claude"
+            ? new ClaudeAdapter(agent.name, agent.model)
+            : agent.provider === "codex"
+                ? new CodexAdapter(agent.name, agent.model)
+                : agent.provider === "copilot"
+                    ? new CopilotAdapter(agent.name, agent.model)
+                    : agent.provider === "glm"
+                        ? new GlmAdapter(agent.name, agent.model)
+                        : null;
+        if (!adapter) {
+            throw new Error(`Unsupported provider in Phase 1: ${agent.provider}`);
+        }
+        await adapter.init({ ...agent, systemPrompt: prompt });
+        return adapter;
+    }));
+    const defaultTimeout = typeof config.timeout === "number" && config.timeout > 0
+        ? config.timeout * 1000
+        : 600000;
+    const agentTimeouts = Object.fromEntries(config.agents
+        .filter((agent) => typeof agent.timeout === "number" && agent.timeout > 0)
+        .map((agent) => [agent.name, agent.timeout * 1000]));
+    const orchestrator = new Orchestrator(adapters, humanName, Object.fromEntries(config.agents.map((agent) => [agent.name, agent.tag?.trim() || toTag(agent.name)])), humanTag, defaultTimeout, agentTimeouts);
+    await runTerminal(orchestrator, { maxAutoHops });
+}
+function resolveMaxAutoHops(value) {
+    if (value === "unlimited") {
+        return Number.POSITIVE_INFINITY;
+    }
+    if (typeof value === "number" && Number.isFinite(value) && value >= 1) {
+        return Math.floor(value);
+    }
+    return 15;
+}
+function renderPromptTemplate(template, variables) {
+    return template.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_, key) => {
+        return variables[key] ?? "";
+    });
+}
+function toTag(value) {
+    const compact = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return compact || "agent";
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/orchestrator.js

@@ -0,0 +1,185 @@
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+export class Orchestrator {
+    agents;
+    agentTags;
+    conversation = [];
+    lastSeenByAgent = new Map();
+    humanName;
+    humanTag;
+    sessionId;
+    transcriptPath;
+    defaultTimeout;
+    agentTimeouts;
+    messageId = 0;
+    contextWindowSize = 16;
+    constructor(agents, humanName = "USER", agentTags, humanTag, defaultTimeout = 600000, agentTimeouts) {
+        this.agents = new Map(agents.map((agent) => [agent.name, agent]));
+        this.agentTags = new Map(agents.map((agent) => [agent.name, agentTags?.[agent.name] ?? defaultTagFor(agent.name)]));
+        this.humanName = humanName;
+        this.humanTag = humanTag ?? defaultTagFor(humanName);
+        this.defaultTimeout = defaultTimeout;
+        this.agentTimeouts = new Map(Object.entries(agentTimeouts ?? {}));
+        this.sessionId = createSessionId();
+        this.transcriptPath = path.resolve(".llm-party", "sessions", `transcript-${this.sessionId}.jsonl`);
+        for (const agent of agents) {
+            this.lastSeenByAgent.set(agent.name, 0);
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getTranscriptPath() {
+        return this.transcriptPath;
+    }
+    getHumanName() {
+        return this.humanName;
+    }
+    getHumanTag() {
+        return this.humanTag;
+    }
+    listAgents() {
+        return Array.from(this.agents.values()).map((agent) => ({
+            name: agent.name,
+            tag: this.agentTags.get(agent.name) ?? defaultTagFor(agent.name),
+            provider: agent.provider,
+            model: agent.model
+        }));
+    }
+    addUserMessage(text) {
+        const message = {
+            id: ++this.messageId,
+            from: this.humanName,
+            text,
+            createdAt: new Date().toISOString()
+        };
+        this.conversation.push(message);
+        return message;
+    }
+    getHistory() {
+        return [...this.conversation];
+    }
+    resolveTargets(selector) {
+        const normalized = selector.trim().toLowerCase();
+        if (normalized === "all" || normalized === "everyone") {
+            return Array.from(this.agents.keys());
+        }
+        const byName = Array.from(this.agents.values())
+            .filter((agent) => {
+            const tag = this.agentTags.get(agent.name) ?? defaultTagFor(agent.name);
+            return agent.name.toLowerCase() === normalized || tag.toLowerCase() === normalized;
+        })
+            .map((agent) => agent.name);
+        if (byName.length > 0) {
+            return byName;
+        }
+        return Array.from(this.agents.values())
+            .filter((agent) => agent.provider.toLowerCase() === normalized)
+            .map((agent) => agent.name);
+    }
+    async fanOut(targetAgentNames) {
+        return this.fanOutWithProgress(targetAgentNames, () => { });
+    }
+    async fanOutWithProgress(targetAgentNames, onMessage) {
+        const requestedTargets = targetAgentNames && targetAgentNames.length > 0
+            ? targetAgentNames
+            : Array.from(this.agents.keys());
+        const targets = requestedTargets
+            .map((name) => this.agents.get(name))
+            .filter((agent) => Boolean(agent));
+        const historyMaxId = this.messageId;
+        const settled = await Promise.allSettled(targets.map(async (agent) => {
+            const lastSeen = this.lastSeenByAgent.get(agent.name) ?? 0;
+            const unseen = this.conversation.filter((msg) => msg.id > lastSeen && msg.from.toUpperCase() !== agent.name.toUpperCase());
+            if (unseen.length === 0) {
+                this.lastSeenByAgent.set(agent.name, historyMaxId);
+                const response = {
+                    id: ++this.messageId,
+                    from: agent.name.toUpperCase(),
+                    text: "[No new messages for this agent]",
+                    createdAt: new Date().toISOString()
+                };
+                this.conversation.push(response);
+                await this.appendTranscript(response);
+                onMessage(response);
+                return response;
+            }
+            const inputMessages = this.buildInputForAgent(agent.name, unseen);
+            const responseText = await this.sendWithTimeout(agent, inputMessages, this.timeoutFor(agent.name));
+            const response = {
+                id: ++this.messageId,
+                from: agent.name.toUpperCase(),
+                text: responseText,
+                createdAt: new Date().toISOString()
+            };
+            this.lastSeenByAgent.set(agent.name, historyMaxId);
+            this.conversation.push(response);
+            await this.appendTranscript(response);
+            onMessage(response);
+            return response;
+        }));
+        const results = settled.map((item, idx) => {
+            if (item.status === "fulfilled") {
+                return item.value;
+            }
+            const agent = targets[idx];
+            const response = {
+                id: ++this.messageId,
+                from: agent.name.toUpperCase(),
+                text: `[Adapter Error] ${item.reason instanceof Error ? item.reason.message : String(item.reason)}`,
+                createdAt: new Date().toISOString()
+            };
+            this.lastSeenByAgent.set(agent.name, historyMaxId);
+            this.conversation.push(response);
+            void this.appendTranscript(response);
+            onMessage(response);
+            return response;
+        });
+        return results;
+    }
+    async appendTranscript(message) {
+        const transcriptDir = path.dirname(this.transcriptPath);
+        await mkdir(transcriptDir, { recursive: true });
+        await appendFile(this.transcriptPath, `${JSON.stringify(message)}\n`, "utf8");
+    }
+    async saveHistory(targetPath) {
+        await writeFile(targetPath, JSON.stringify(this.conversation, null, 2), "utf8");
+    }
+    async sendWithTimeout(agent, messages, timeoutMs) {
+        let timer;
+        const timeoutPromise = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                resolve(`[Timeout] ${agent.name} exceeded ${Math.floor(timeoutMs / 1000)}s`);
+            }, timeoutMs);
+        });
+        try {
+            return await Promise.race([agent.send(messages), timeoutPromise]);
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
+    timeoutFor(agentName) {
+        return this.agentTimeouts.get(agentName) ?? this.defaultTimeout;
+    }
+    buildInputForAgent(agentName, unseen) {
+        const recent = this.conversation.slice(-this.contextWindowSize);
+        const merged = [...recent, ...unseen];
+        const dedupById = new Map();
+        for (const msg of merged) {
+            dedupById.set(msg.id, msg);
+        }
+        const ordered = Array.from(dedupById.values()).sort((a, b) => a.id - b.id);
+        return ordered.filter((msg) => msg.from.toUpperCase() !== agentName.toUpperCase());
+    }
+}
+function createSessionId() {
+    const timestamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "").replace("T", "-");
+    return `${timestamp}-${process.pid}`;
+}
+function defaultTagFor(name) {
+    const compact = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return compact || "agent";
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/terminal.js

@@ -0,0 +1,213 @@
+import readline from "node:readline/promises";
+import { execFile } from "node:child_process";
+import { stdin as input, stdout as output } from "node:process";
+import chalk from "chalk";
+export async function runTerminal(orchestrator, options = {}) {
+    const rl = readline.createInterface({ input, output });
+    const humanName = orchestrator.getHumanName();
+    const tags = formatTagHints(orchestrator);
+    let lastTargets;
+    let knownChangedFiles = await getChangedFiles();
+    process.on("SIGINT", () => {
+        rl.close();
+        output.write("\n");
+        process.exit(0);
+    });
+    output.write(chalk.cyan(`llm-party Phase 1 started. Commands: /agents, /history, /save <path>, /session, /changes, /exit. Tags: ${tags}\n`));
+    output.write(chalk.gray(`Session: ${orchestrator.getSessionId()}\n`));
+    output.write(chalk.gray(`Transcript: ${orchestrator.getTranscriptPath()}\n`));
+    while (true) {
+        let line = "";
+        try {
+            line = (await rl.question(chalk.green(`${humanName} > `))).trim();
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ERR_USE_AFTER_CLOSE" || code === "ABORT_ERR") {
+                break;
+            }
+            throw error;
+        }
+        if (!line) {
+            continue;
+        }
+        if (line === "/exit") {
+            break;
+        }
+        if (line === "/history") {
+            const history = orchestrator.getHistory();
+            for (const msg of history) {
+                output.write(`${chalk.gray(msg.createdAt)} ${chalk.yellow("[" + msg.from + "]")} ${msg.text}\n`);
+            }
+            continue;
+        }
+        if (line === "/agents") {
+            const agents = orchestrator.listAgents();
+            for (const agent of agents) {
+                output.write(`${chalk.cyan(agent.name)} tag=@${agent.tag} provider=${agent.provider} model=${agent.model}\n`);
+            }
+            continue;
+        }
+        if (line === "/session") {
+            output.write(chalk.cyan(`Session: ${orchestrator.getSessionId()}\n`));
+            output.write(chalk.cyan(`Transcript: ${orchestrator.getTranscriptPath()}\n`));
+            continue;
+        }
+        if (line === "/changes") {
+            const changedFiles = await getChangedFiles();
+            if (changedFiles.length === 0) {
+                output.write(chalk.cyan("No modified files in git working tree.\n"));
+            }
+            else {
+                output.write(chalk.cyan("Modified files:\n"));
+                for (const file of changedFiles) {
+                    output.write(`- ${file}\n`);
+                }
+            }
+            continue;
+        }
+        if (line.startsWith("/save ")) {
+            const filePath = line.replace("/save ", "").trim();
+            if (!filePath) {
+                output.write(chalk.red("Usage: /save <path>\n"));
+                continue;
+            }
+            await orchestrator.saveHistory(filePath);
+            output.write(chalk.cyan(`Saved history to ${filePath}\n`));
+            continue;
+        }
+        const routing = parseRouting(line);
+        const explicitTargets = routing.targets && routing.targets.length > 0
+            ? Array.from(new Set(routing.targets.flatMap((target) => orchestrator.resolveTargets(target))))
+            : undefined;
+        if (routing.targets && routing.targets.length > 0 && (!explicitTargets || explicitTargets.length === 0)) {
+            output.write(chalk.red(`No agent matched ${routing.targets.map((target) => `@${target}`).join(", ")}. Use /agents to list names/providers.\n`));
+            continue;
+        }
+        const targets = explicitTargets ?? lastTargets;
+        if (explicitTargets && explicitTargets.length > 0) {
+            lastTargets = explicitTargets;
+        }
+        const userMessage = orchestrator.addUserMessage(routing.message);
+        await orchestrator.appendTranscript(userMessage);
+        knownChangedFiles = await dispatchWithHandoffs(orchestrator, output, targets, knownChangedFiles, options.maxAutoHops ?? 6);
+    }
+    rl.close();
+}
+async function getChangedFiles() {
+    return new Promise((resolve) => {
+        execFile("git", ["status", "--porcelain"], { cwd: process.cwd() }, (error, stdout) => {
+            if (error) {
+                resolve([]);
+                return;
+            }
+            const files = stdout
+                .split("\n")
+                .filter((line) => line.length >= 4)
+                .map((line) => line.slice(3).trim());
+            resolve(Array.from(new Set(files)));
+        });
+    });
+}
+async function dispatchWithHandoffs(orchestrator, out, initialTargets, previousChangedFiles = [], maxHops = 6) {
+    let targets = initialTargets;
+    let hops = 0;
+    let knownChangedFiles = previousChangedFiles;
+    while (true) {
+        const targetLabel = targets && targets.length > 0 ? targets.join(",") : "all";
+        out.write(chalk.gray(`Dispatching to ${targetLabel}...\n`));
+        const batch = [];
+        await orchestrator.fanOutWithProgress(targets, (msg) => {
+            batch.push(msg);
+            out.write(chalk.magenta(`[${msg.from}]`) + ` ${msg.text}\n\n`);
+        });
+        const latestChangedFiles = await getChangedFiles();
+        const newlyChanged = diffChangedFiles(knownChangedFiles, latestChangedFiles);
+        if (newlyChanged.length > 0) {
+            out.write(chalk.yellow(`LLM modified files at ${new Date().toISOString()}:\n`));
+            for (const file of newlyChanged) {
+                out.write(chalk.yellow(`- ${file}\n`));
+            }
+        }
+        knownChangedFiles = latestChangedFiles;
+        const nextSelectors = extractNextSelectors(batch);
+        if (nextSelectors.length === 0) {
+            return knownChangedFiles;
+        }
+        if (nextSelectors.some((selector) => {
+            const normalized = selector.toLowerCase();
+            return normalized === orchestrator.getHumanTag().toLowerCase()
+                || normalized === orchestrator.getHumanName().toLowerCase();
+        })) {
+            return knownChangedFiles;
+        }
+        const resolvedTargets = Array.from(new Set(nextSelectors.flatMap((selector) => orchestrator.resolveTargets(selector))));
+        if (resolvedTargets.length === 0) {
+            out.write(chalk.yellow(`Ignored @next target(s): ${nextSelectors.join(",")}\n`));
+            return knownChangedFiles;
+        }
+        hops += 1;
+        if (Number.isFinite(maxHops) && hops >= maxHops) {
+            out.write(chalk.yellow(`Stopped auto-handoff after ${maxHops} hops to prevent loops.\n`));
+            return knownChangedFiles;
+        }
+        out.write(chalk.gray(`Auto handoff via @next to ${resolvedTargets.join(",")}\n`));
+        targets = resolvedTargets;
+    }
+}
+function diffChangedFiles(before, after) {
+    const beforeSet = new Set(before);
+    return after.filter((file) => !beforeSet.has(file));
+}
+function formatTagHints(orchestrator) {
+    const agents = orchestrator.listAgents();
+    const tags = new Set();
+    tags.add("@all");
+    tags.add("@everyone");
+    for (const agent of agents) {
+        tags.add(`@${agent.tag}`);
+        tags.add(`@${agent.provider}`);
+    }
+    return Array.from(tags).join(", ");
+}
+function extractNextSelectors(messages) {
+    const selectors = [];
+    for (const msg of messages) {
+        const regex = /@next\s*:\s*([A-Za-z0-9_-]+)/gi;
+        let match = null;
+        while ((match = regex.exec(msg.text)) !== null) {
+            selectors.push(match[1]);
+        }
+        const controlMatch = msg.text.match(/@control[\s\S]*?next\s*:\s*([A-Za-z0-9_-]+)[\s\S]*?@end/i);
+        if (controlMatch?.[1]) {
+            selectors.push(controlMatch[1]);
+        }
+    }
+    return selectors;
+}
+function parseRouting(line) {
+    const normalizedStart = line.replace(/^[^A-Za-z0-9@_-]+/, "");
+    const startMatch = normalizedStart.match(/^@([A-Za-z0-9_-]+)[\.,:;!?-]*\s+([\s\S]+)$/);
+    if (startMatch) {
+        return {
+            targets: [startMatch[1].toLowerCase()],
+            message: startMatch[2].trim()
+        };
+    }
+    const mentionRegex = /(^|[^A-Za-z0-9_-])@([A-Za-z0-9_-]+)\b/g;
+    const targets = [];
+    let stripped = line;
+    let match = null;
+    while ((match = mentionRegex.exec(line)) !== null) {
+        targets.push(match[2].toLowerCase());
+    }
+    if (targets.length === 0) {
+        return { message: line };
+    }
+    stripped = stripped.replace(/(^|[^A-Za-z0-9_-])@([A-Za-z0-9_-]+)\b/g, (full, prefix) => prefix || "");
+    stripped = stripped.replace(/\s{2,}/g, " ").trim();
+    return {
+        targets,
+        message: stripped || line
+    };
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "llm-party-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "llm-party": "dist/index.js"
+  },
+  "description": "Bring your models. We'll bring the party.",
+  "license": "MIT",
+  "homepage": "https://llm-party.party",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aalasolutions/llm-party.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aalasolutions/llm-party/issues"
+  },
+  "author": "AALA Solutions <hello@aalasolutions.com> (https://aalasolutions.com)",
+  "keywords": [
+    "llm",
+    "multi-agent",
+    "orchestrator",
+    "claude",
+    "codex",
+    "copilot",
+    "terminal",
+    "ai",
+    "peer-orchestration",
+    "agent"
+  ],
+  "files": [
+    "dist",
+    "configs",
+    "prompts/base.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.74",
+    "@anthropic-ai/claude-code": "^2.1.74",
+    "@github/copilot-sdk": "^0.1.33-preview.2",
+    "@openai/codex-sdk": "^0.115.0",
+    "chalk": "^5.3.0",
+    "dotenv": "^16.4.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}

package/prompts/base.md

@@ -0,0 +1,54 @@
+# {{agentName}}
+
+You are {{agentName}}. You are one of {{agentCount}} AI agents working with {{humanName}} in a shared terminal orchestrator called llm-party.
+
+## Your Identity
+
+- Name: {{agentName}}
+- Tag: @{{agentTag}}
+- The human you serve: {{humanName}}
+
+## How the System Works
+
+{{humanName}} types messages in a terminal. The orchestrator routes them to one or more agents based on tags.
+
+Routing rules:
+
+- `@{{agentTag}}` routes the message only to you
+- `@all` or no tag routes the message to all active agents in parallel
+- Tags are case-insensitive and may include punctuation after the tag
+
+You receive a rolling window of recent conversation messages so you keep context between turns.
+
+## Agent-to-Agent Handoff
+
+You do have agent-to-agent handoff in this orchestrator. The orchestrator watches your plain text output for `@next:<tag>` and dispatches accordingly.
+
+If another agent should respond next, end your message with one of these valid targets:
+
+{{validHandoffTargets}}
+
+If you want {{humanName}} to take over, end with:
+
+```
+@next:{{humanTag}}
+```
+
+Rules:
+
+- Do not claim handoff is unavailable. It is available through the orchestrator parser.
+- Use agent tags for handoff, not provider names and not display names.
+- Max 15 automatic hops before the system stops to prevent loops.
+- Only use `@next` when another agent's perspective is genuinely useful.
+
+## Team Context
+
+- Active agent names: {{allAgentNames}}
+- Direct tag examples: {{allAgentTags}}, @all
+- Other agents besides you:
+{{otherAgentList}}
+
+## Behavior Rules
+
+- Address {{humanName}} by name.
+- NEVER LEAVE `cwd`