llm-party-cli 0.2.0 → 0.2.2

package/dist/index.js

@@ -76490,8 +76490,10 @@ function detectBinary(command) {
     const proc = spawn4(command, ["--version"], {
       stdio: ["ignore", "pipe", "ignore"],
       shell: true,
-      timeout: DETECT_TIMEOUT
+      timeout: DETECT_TIMEOUT,
+      detached: true
     });
+    proc.unref();
     let output = "";
     proc.stdout?.on("data", (chunk) => {
       output += chunk.toString();
@@ -76516,8 +76518,10 @@ function detectAlias(command) {
     const timer = setTimeout(() => resolve4({ available: false }), DETECT_TIMEOUT);
     const proc = spawn4(shell, ["-ic", `type ${command}`], {
       stdio: ["ignore", "pipe", "ignore"],
-      timeout: DETECT_TIMEOUT
+      timeout: DETECT_TIMEOUT,
+      detached: true
     });
+    proc.unref();
     proc.on("close", (code) => {
       clearTimeout(timer);
       resolve4({ available: code === 0 });
@@ -76798,6 +76802,9 @@ function ConfigWizard({ isFirstRun, onComplete, onCancel, existingConfig }) {
     detectProviders().then((results) => {
       setDetection(results);
       setStep("providers");
+    }).catch(() => {
+      setDetection([]);
+      setStep("providers");
     });
   }, []);
   const existingByProvider = new Map((existingConfig?.agents || []).map((a2) => [a2.provider, a2]));
@@ -76902,6 +76909,9 @@ function ConfigWizard({ isFirstRun, onComplete, onCancel, existingConfig }) {
   }, [selectedIds, existingConfig]);
   useKeyboard((key) => {
     if (step !== "configure") {
+      if (step === "detect") {
+        return;
+      }
       if (step === "done") {
         if (key.name === "enter" || key.name === "return" || key.name === "space") {
           onComplete();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-party-cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "bin": {
     "llm-party": "dist/index.js"

package/dist/adapters/base.js

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

package/dist/adapters/claude.js

@@ -1,64 +0,0 @@
-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 = config.resolvedPrompt ?? "";
-        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

@@ -1,44 +0,0 @@
-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 = config.resolvedPrompt ?? "";
-        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

@@ -1,46 +0,0 @@
-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 = config.resolvedPrompt ?? "";
-        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

@@ -1,91 +0,0 @@
-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 = config.resolvedPrompt ?? "";
-        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

@@ -1,131 +0,0 @@
-import { readFile, writeFile, access, mkdir } from "node:fs/promises";
-import { homedir, userInfo } from "node:os";
-import path from "node:path";
-const VALID_PROVIDERS = ["claude", "codex", "copilot", "glm"];
-const LLM_PARTY_HOME = path.join(homedir(), ".llm-party");
-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.prompts !== undefined) {
-            const isArray = Array.isArray(agent.prompts) && agent.prompts.every((p) => typeof p === "string");
-            if (!isArray) {
-                throw new Error(`Agent '${agent.name}' prompts must be a string array`);
-            }
-        }
-    }
-    for (const agent of cfg.agents) {
-        if (typeof agent.executablePath === "string" && agent.executablePath.startsWith("~/")) {
-            agent.executablePath = homedir() + agent.executablePath.slice(1);
-        }
-    }
-    if (!cfg.humanName || (typeof cfg.humanName === "string" && cfg.humanName.trim() === "")) {
-        cfg.humanName = userInfo().username || "USER";
-    }
-    return cfg;
-}
-export async function resolveConfigPath(appRoot) {
-    if (process.env.LLM_PARTY_CONFIG) {
-        return path.resolve(process.env.LLM_PARTY_CONFIG);
-    }
-    const globalConfig = path.join(LLM_PARTY_HOME, "config.json");
-    try {
-        await access(globalConfig);
-        return globalConfig;
-    }
-    catch {
-        // fall through to package default
-    }
-    return path.join(appRoot, "configs", "default.json");
-}
-export async function resolveBasePrompt(appRoot) {
-    const bundledBase = path.join(appRoot, "prompts", "base.md");
-    return await readFile(bundledBase, "utf8");
-}
-export async function resolveArtifactsPrompt(appRoot) {
-    const bundledArtifacts = path.join(appRoot, "prompts", "artifacts.md");
-    return await readFile(bundledArtifacts, "utf8");
-}
-export async function initProjectFolder(cwd) {
-    const projectHome = path.join(cwd, ".llm-party");
-    const memoryDir = path.join(projectHome, "memory");
-    const skillsDir = path.join(projectHome, "skills");
-    await mkdir(memoryDir, { recursive: true });
-    await mkdir(skillsDir, { recursive: true });
-    const tasksFile = path.join(projectHome, "TASKS.md");
-    try {
-        await access(tasksFile);
-    }
-    catch {
-        await writeFile(tasksFile, "# Tasks\n", "utf8");
-    }
-    const projectMd = path.join(memoryDir, "project.md");
-    try {
-        await access(projectMd);
-    }
-    catch {
-        await writeFile(projectMd, "# Project Memory\n\n## Current State\n\nLast Updated:\nActive:\nBlockers:\nNext:\n\n---\n\n## Log\n", "utf8");
-    }
-    const decisionsMd = path.join(memoryDir, "decisions.md");
-    try {
-        await access(decisionsMd);
-    }
-    catch {
-        await writeFile(decisionsMd, "# Decisions\n", "utf8");
-    }
-}
-export async function initLlmPartyHome(appRoot) {
-    await mkdir(LLM_PARTY_HOME, { recursive: true });
-    await mkdir(path.join(LLM_PARTY_HOME, "sessions"), { recursive: true });
-    await mkdir(path.join(LLM_PARTY_HOME, "network"), { recursive: true });
-    await mkdir(path.join(LLM_PARTY_HOME, "agents"), { recursive: true });
-    const projectsYml = path.join(LLM_PARTY_HOME, "network", "projects.yml");
-    try {
-        await access(projectsYml);
-    }
-    catch {
-        await writeFile(projectsYml, "projects: []\n", "utf8");
-    }
-    const librariesYml = path.join(LLM_PARTY_HOME, "network", "libraries.yml");
-    try {
-        await access(librariesYml);
-    }
-    catch {
-        await writeFile(librariesYml, "libraries: []\n", "utf8");
-    }
-    const globalConfig = path.join(LLM_PARTY_HOME, "config.json");
-    try {
-        await access(globalConfig);
-    }
-    catch {
-        const bundledConfig = await readFile(path.join(appRoot, "configs", "default.json"), "utf8");
-        await writeFile(globalConfig, bundledConfig, "utf8");
-    }
-}
-export async function loadConfig(configPath) {
-    const raw = await readFile(configPath, "utf8");
-    const parsed = JSON.parse(raw);
-    return validateConfig(parsed);
-}
-export { LLM_PARTY_HOME };

package/dist/orchestrator.js

@@ -1,185 +0,0 @@
-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

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

package/dist/ui/terminal.js

@@ -1,219 +0,0 @@
-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";
-import { initProjectFolder } from "../config/loader.js";
-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();
-    let projectFolderReady = false;
-    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;
-        }
-        if (!projectFolderReady) {
-            await initProjectFolder(process.cwd());
-            projectFolderReady = true;
-        }
-        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
-    };
-}