@iletai/nzb 1.4.9 → 1.5.0

package/dist/copilot/orchestrator.js

@@ -1,7 +1,7 @@
 import { approveAll } from "@github/copilot-sdk";
 import { config, DEFAULT_MODEL } from "../config.js";
 import { SESSIONS_DIR } from "../paths.js";
-import { deleteState, getMemorySummary, getRecentConversation, getState, logConversation, setState, } from "../store/db.js";
+import { completeTeam, deleteState, getMemorySummary, getRecentConversation, getState, logConversation, setState, updateTeamMemberResult, } from "../store/db.js";
 import { resetClient } from "./client.js";
 import { loadMcpConfig } from "./mcp-config.js";
 import { getSkillDirectories } from "./skills.js";
@@ -25,6 +25,7 @@ export function setWorkerNotify(fn) {
 }
 let copilotClient;
 const workers = new Map();
+const teams = new Map();
 let healthCheckTimer;
 // Persistent orchestrator session
 let orchestratorSession;
@@ -48,6 +49,7 @@ function getSessionConfig() {
         cachedTools = createTools({
             client: copilotClient,
             workers,
+            teams,
             onWorkerComplete: feedBackgroundResult,
             onWorkerEvent: (event) => {
                 const worker = workers.get(event.name);
@@ -67,7 +69,38 @@ function getSessionConfig() {
 export function feedBackgroundResult(workerName, result) {
     const worker = workers.get(workerName);
     const channel = worker?.originChannel;
-    console.log(`[nzb] Feeding background result from worker '${workerName}' (channel: ${channel ?? "none"})`);
+    const teamId = worker?.teamId;
+    console.log(`[nzb] Feeding background result from worker '${workerName}' (channel: ${channel ?? "none"}, team: ${teamId ?? "none"})`);
+    // If this worker is part of a team, handle team aggregation
+    if (teamId) {
+        const team = teams.get(teamId);
+        if (team) {
+            const status = result.startsWith("Error:") ? "error" : "completed";
+            updateTeamMemberResult(teamId, workerName, result, status);
+            team.completedMembers.add(workerName);
+            team.memberResults.set(workerName, result);
+            // Check if all members completed
+            if (team.completedMembers.size >= team.members.length) {
+                const aggregated = Array.from(team.memberResults.entries())
+                    .map(([name, res]) => `## ${name}\n${res}`)
+                    .join("\n\n---\n\n");
+                completeTeam(teamId, aggregated);
+                const prompt = `[Agent Team Completed] Team '${teamId}' finished.\n\n` +
+                    `Task: ${team.taskDescription}\n\n` +
+                    `${team.members.length} members completed:\n\n${aggregated}\n\n` +
+                    `Please synthesize these results into a coherent summary for the user.`;
+                sendToOrchestrator(prompt, { type: "background" }, (_text, done) => {
+                    if (done && proactiveNotifyFn) {
+                        proactiveNotifyFn(_text, team.originChannel);
+                    }
+                });
+                // Cleanup team from memory (DB record persists)
+                teams.delete(teamId);
+            }
+            return;
+        }
+    }
+    // Non-team worker: original behavior
     const prompt = `[Background task completed] Worker '${workerName}' finished:\n\n${result}`;
     sendToOrchestrator(prompt, { type: "background" }, (_text, done) => {
         if (done && proactiveNotifyFn) {

package/dist/copilot/system-message.js

@@ -48,6 +48,17 @@ Worker tools are **non-blocking** — dispatch and return immediately:
 - Never do complex work yourself — delegate to workers.
 - Only orchestrator turns block the queue.
 
+## Agent Teams
+
+Create agent teams for parallel collaborative work:
+1. Use \`create_agent_team\` to spawn 2-5 specialized workers
+2. Each member works independently with their own role
+3. Results auto-aggregate when all members finish → you get \`[Agent Team Completed]\` → synthesize for user
+4. Use \`get_team_status\` to check progress
+5. Use \`send_team_message\` to broadcast updates
+
+Best for: multi-angle code review, competing debug hypotheses, parallel feature implementation, research from different perspectives.
+
 ## Skills Workflow
 
 1. Search skills.sh first for existing community skills.

package/dist/copilot/tools.js

@@ -33,6 +33,7 @@ const BLOCKED_WORKER_DIRS = [
     ".pypirc",
 ];
 const MAX_CONCURRENT_WORKERS = 5;
+const MAX_CONCURRENT_TEAMS = 3;
 export function createTools(deps) {
     return [
         defineTool("create_worker_session", {
@@ -220,6 +221,200 @@ export function createTools(deps) {
                 return `Worker '${args.name}' terminated.`;
             },
         }),
+        // ── Agent Team Tools ──────────────────────────────────────────
+        defineTool("create_agent_team", {
+            description: "Create an agent team — multiple workers collaborating on a task in parallel. Each member gets a role " +
+                "and works independently. Results are automatically aggregated when all members complete. Use for tasks " +
+                "that benefit from parallel work: code review from multiple angles, investigating competing hypotheses, " +
+                "implementing independent modules, etc.",
+            parameters: z.object({
+                team_name: z.string().describe("Unique name for the team, e.g. 'pr-review-team'"),
+                task_description: z.string().describe("Overall task description shared with all members"),
+                members: z
+                    .array(z.object({
+                    name: z.string().describe("Unique worker name for this member, e.g. 'security-reviewer'"),
+                    role: z.string().describe("Role description, e.g. 'Review code for security vulnerabilities'"),
+                    prompt: z.string().describe("Specific prompt/instructions for this member"),
+                }))
+                    .min(2)
+                    .max(5)
+                    .describe("Team members (2-5). Each gets their own worker session."),
+                working_dir: z.string().describe("Absolute path to working directory for all members"),
+            }),
+            handler: async (args) => {
+                const activeTeams = Array.from(deps.teams.values()).filter((t) => t.completedMembers.size < t.members.length);
+                if (activeTeams.length >= MAX_CONCURRENT_TEAMS) {
+                    return `❌ Maximum ${MAX_CONCURRENT_TEAMS} concurrent teams reached. Wait for an active team to complete.`;
+                }
+                const totalWorkers = deps.workers.size + args.members.length;
+                if (totalWorkers > MAX_CONCURRENT_WORKERS) {
+                    return `❌ Adding ${args.members.length} members would exceed max workers (${MAX_CONCURRENT_WORKERS}). Currently ${deps.workers.size} active. Kill some workers first.`;
+                }
+                const home = homedir();
+                const resolvedDir = resolve(args.working_dir);
+                for (const blocked of BLOCKED_WORKER_DIRS) {
+                    const blockedPath = join(home, blocked);
+                    if (resolvedDir === blockedPath || resolvedDir.startsWith(blockedPath + sep)) {
+                        return `❌ Working directory '${args.working_dir}' is a sensitive directory. Workers cannot operate in ${blocked}.`;
+                    }
+                }
+                for (const member of args.members) {
+                    if (deps.workers.has(member.name)) {
+                        return `❌ Worker '${member.name}' already exists. Use unique names.`;
+                    }
+                }
+                const teamId = args.team_name;
+                const originChannel = getCurrentSourceChannel();
+                const { createTeam: dbCreateTeam, addTeamMember: dbAddTeamMember } = await import("../store/db.js");
+                dbCreateTeam(teamId, args.task_description, originChannel);
+                const teamInfo = {
+                    id: teamId,
+                    taskDescription: args.task_description,
+                    members: args.members.map((m) => m.name),
+                    originChannel,
+                    completedMembers: new Set(),
+                    memberResults: new Map(),
+                };
+                deps.teams.set(teamId, teamInfo);
+                const spawnResults = [];
+                for (const member of args.members) {
+                    try {
+                        const session = await deps.client.createSession({
+                            model: config.copilotModel,
+                            configDir: SESSIONS_DIR,
+                            workingDirectory: args.working_dir,
+                            onPermissionRequest: approveAll,
+                        });
+                        const worker = {
+                            name: member.name,
+                            session,
+                            workingDir: resolvedDir,
+                            status: "running",
+                            startedAt: Date.now(),
+                            originChannel,
+                            teamId,
+                        };
+                        deps.workers.set(member.name, worker);
+                        deps.onWorkerEvent?.({ type: "created", name: member.name, workingDir: resolvedDir });
+                        const db = getDb();
+                        db.prepare(`INSERT OR REPLACE INTO worker_sessions (name, copilot_session_id, working_dir, status) VALUES (?, ?, ?, 'running')`).run(member.name, session.sessionId, resolvedDir);
+                        dbAddTeamMember(teamId, member.name, member.role);
+                        const teamPrompt = `Working directory: ${args.working_dir}\n\n${member.prompt}\n\n` +
+                            `Context: You are part of team '${teamId}'. Your role: ${member.role}\n` +
+                            `Overall task: ${args.task_description}\n\nProvide your results clearly. Focus on your role.`;
+                        const timeoutMs = config.workerTimeoutMs;
+                        session
+                            .sendAndWait({ prompt: teamPrompt }, timeoutMs)
+                            .then((result) => {
+                            worker.lastOutput = result?.data?.content || "No response";
+                            worker.status = "idle";
+                            deps.onWorkerEvent?.({ type: "completed", name: member.name });
+                            deps.onWorkerComplete(member.name, worker.lastOutput);
+                        })
+                            .catch((err) => {
+                            const errMsg = formatWorkerError(member.name, worker.startedAt, timeoutMs, err);
+                            worker.lastOutput = errMsg;
+                            worker.status = "error";
+                            deps.onWorkerEvent?.({ type: "error", name: member.name, error: errMsg });
+                            deps.onWorkerComplete(member.name, errMsg);
+                        })
+                            .finally(() => {
+                            session.destroy().catch(() => { });
+                            deps.workers.delete(member.name);
+                            try {
+                                getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(member.name);
+                            }
+                            catch { }
+                        });
+                        spawnResults.push(`✅ ${member.name} (${member.role})`);
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        spawnResults.push(`❌ ${member.name}: ${errMsg}`);
+                    }
+                }
+                return (`🏗️ Agent team '${teamId}' created with ${args.members.length} members:\n` +
+                    `${spawnResults.join("\n")}\n\n` +
+                    `All agents dispatched in parallel. Results will be aggregated automatically when all members complete.`);
+            },
+        }),
+        defineTool("get_team_status", {
+            description: "Get the status of agent teams — shows active teams, their members, and progress.",
+            parameters: z.object({
+                team_name: z
+                    .string()
+                    .optional()
+                    .describe("Specific team name to check. Omit to list all active teams."),
+            }),
+            handler: async (args) => {
+                if (args.team_name) {
+                    const team = deps.teams.get(args.team_name);
+                    if (!team)
+                        return `❌ Team '${args.team_name}' not found.`;
+                    const lines = [
+                        `🏗️ Team: ${team.id}`,
+                        `📋 Task: ${team.taskDescription}`,
+                        `📊 Progress: ${team.completedMembers.size}/${team.members.length}`,
+                        "",
+                        "Members:",
+                    ];
+                    for (const memberName of team.members) {
+                        const worker = deps.workers.get(memberName);
+                        const completed = team.completedMembers.has(memberName);
+                        const status = completed
+                            ? "✅ done"
+                            : worker?.status === "running"
+                                ? "⏳ running"
+                                : worker?.status === "error"
+                                    ? "❌ error"
+                                    : "🔄 pending";
+                        const elapsed = worker?.startedAt
+                            ? `${Math.round((Date.now() - worker.startedAt) / 1000)}s`
+                            : "";
+                        lines.push(`  ${status} ${memberName} ${elapsed}`);
+                    }
+                    return lines.join("\n");
+                }
+                const activeTeams = Array.from(deps.teams.values());
+                if (activeTeams.length === 0)
+                    return "No active agent teams.";
+                const lines = [`📋 Active teams (${activeTeams.length}):`];
+                for (const team of activeTeams) {
+                    lines.push(`  🏗️ ${team.id}: ${team.completedMembers.size}/${team.members.length} done — ${team.taskDescription.slice(0, 80)}`);
+                }
+                return lines.join("\n");
+            },
+        }),
+        defineTool("send_team_message", {
+            description: "Send a message to all active members of a team. Use to provide additional instructions, " +
+                "context, or redirect the team's work.",
+            parameters: z.object({
+                team_name: z.string().describe("Name of the team"),
+                message: z.string().describe("Message to send to all active team members"),
+            }),
+            handler: async (args) => {
+                const team = deps.teams.get(args.team_name);
+                if (!team)
+                    return `❌ Team '${args.team_name}' not found.`;
+                const activeMembers = team.members.filter((name) => !team.completedMembers.has(name) && deps.workers.has(name));
+                if (activeMembers.length === 0)
+                    return `❌ No active members in team '${args.team_name}'.`;
+                let sent = 0;
+                for (const memberName of activeMembers) {
+                    const worker = deps.workers.get(memberName);
+                    if (worker && worker.status !== "error") {
+                        try {
+                            worker.session
+                                .sendAndWait({ prompt: `[Team message from coordinator]: ${args.message}` }, 60_000)
+                                .catch(() => { });
+                            sent++;
+                        }
+                        catch { }
+                    }
+                }
+                return `📨 Message sent to ${sent}/${activeMembers.length} active members of team '${args.team_name}'.`;
+            },
+        }),
         defineTool("list_machine_sessions", {
             description: "List ALL Copilot CLI sessions on this machine — including sessions started from VS Code, " +
                 "the terminal, or other tools. Shows session ID, summary, working directory. " +

package/dist/store/db.js

@@ -55,6 +55,32 @@ export function getDb() {
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
         last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
       )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_teams (
+        id TEXT PRIMARY KEY,
+        status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'completed', 'error')),
+        task_description TEXT NOT NULL,
+        origin_channel TEXT,
+        member_count INTEGER NOT NULL DEFAULT 0,
+        completed_count INTEGER NOT NULL DEFAULT 0,
+        aggregated_result TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        completed_at DATETIME
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS team_members (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        team_id TEXT NOT NULL,
+        worker_name TEXT NOT NULL,
+        role TEXT NOT NULL DEFAULT 'member',
+        status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'running', 'completed', 'error')),
+        result TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        completed_at DATETIME,
+        FOREIGN KEY(team_id) REFERENCES agent_teams(id)
+      )
     `);
         // Migrate: if the table already existed with a stricter CHECK, recreate it
         try {
@@ -266,6 +292,55 @@ export function getMemorySummary() {
     });
     return sections.join("\n");
 }
+// ── Agent Teams CRUD ──────────────────────────────────────────
+export function createTeam(id, taskDescription, originChannel) {
+    const db = getDb();
+    db.prepare(`INSERT INTO agent_teams (id, task_description, origin_channel) VALUES (?, ?, ?)`).run(id, taskDescription, originChannel ?? null);
+}
+export function addTeamMember(teamId, workerName, role) {
+    const db = getDb();
+    db.prepare(`INSERT INTO team_members (team_id, worker_name, role, status) VALUES (?, ?, ?, 'pending')`).run(teamId, workerName, role);
+    db.prepare(`UPDATE agent_teams SET member_count = member_count + 1 WHERE id = ?`).run(teamId);
+}
+export function updateTeamMemberResult(teamId, workerName, result, status) {
+    const db = getDb();
+    db.prepare(`UPDATE team_members SET result = ?, status = ?, completed_at = CURRENT_TIMESTAMP WHERE team_id = ? AND worker_name = ?`).run(result, status, teamId, workerName);
+    if (status === "completed" || status === "error") {
+        db.prepare(`UPDATE agent_teams SET completed_count = completed_count + 1 WHERE id = ?`).run(teamId);
+    }
+}
+export function getTeam(id) {
+    const db = getDb();
+    return db.prepare(`SELECT * FROM agent_teams WHERE id = ?`).get(id);
+}
+export function getTeamMembers(teamId) {
+    const db = getDb();
+    return db
+        .prepare(`SELECT worker_name, role, status, result FROM team_members WHERE team_id = ? ORDER BY id`)
+        .all(teamId);
+}
+export function completeTeam(teamId, aggregatedResult, status = "completed") {
+    const db = getDb();
+    db.prepare(`UPDATE agent_teams SET status = ?, aggregated_result = ?, completed_at = CURRENT_TIMESTAMP WHERE id = ?`).run(status, aggregatedResult, teamId);
+}
+export function getActiveTeams() {
+    const db = getDb();
+    return db
+        .prepare(`SELECT id, status, task_description, member_count, completed_count, created_at FROM agent_teams WHERE status = 'active' ORDER BY created_at DESC`)
+        .all();
+}
+export function getTeamByWorkerName(workerName) {
+    const db = getDb();
+    const row = db
+        .prepare(`SELECT team_id FROM team_members WHERE worker_name = ? AND status IN ('pending', 'running') LIMIT 1`)
+        .get(workerName);
+    return row?.team_id;
+}
+export function cleanupTeam(teamId) {
+    const db = getDb();
+    db.prepare(`DELETE FROM team_members WHERE team_id = ?`).run(teamId);
+    db.prepare(`DELETE FROM agent_teams WHERE id = ?`).run(teamId);
+}
 export function closeDb() {
     if (db) {
         stmtCache = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@iletai/nzb",
-    "version": "1.4.9",
+    "version": "1.5.0",
     "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
     "bin": {
         "nzb": "dist/cli.js"