@tmustier/pi-agent-teams 0.2.0 → 0.3.1

package/scripts/integration-todo-test.mts

@@ -17,7 +17,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import { spawnSync, type ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 
@@ -31,9 +31,7 @@ import {
 	type TeamTask,
 } from "../extensions/teams/task-store.js";
 
-function sleep(ms: number): Promise<void> {
-	return new Promise((r) => setTimeout(r, ms));
-}
+import { sleep, spawnTeamsWorkerRpc, terminateAll } from "./lib/pi-workers.js";
 
 function parseArgs(argv: readonly string[]): { timeoutSec: number; pollMs: number } {
 	let timeoutSec = 15 * 60;
@@ -60,30 +58,6 @@ function parseArgs(argv: readonly string[]): { timeoutSec: number; pollMs: numbe
 	return { timeoutSec, pollMs };
 }
 
-async function terminateAll(children: ChildProcess[]): Promise<void> {
-	for (const c of children) {
-		try {
-			c.kill("SIGTERM");
-		} catch {
-			// ignore
-		}
-	}
-
-	const deadline = Date.now() + 10_000;
-	for (const c of children) {
-		while (c.exitCode === null && Date.now() < deadline) {
-			await sleep(100);
-		}
-		if (c.exitCode === null) {
-			try {
-				c.kill("SIGKILL");
-			} catch {
-				// ignore
-			}
-		}
-	}
-}
-
 function spawnWorker(opts: {
 	cwd: string;
 	repoRoot: string;
@@ -93,17 +67,7 @@ function spawnWorker(opts: {
 	agentName: string;
 	logDir: string;
 }): ChildProcess {
-	const { cwd, repoRoot, entryPath, sessionsDir, teamId, agentName, logDir } = opts;
-
-	fs.mkdirSync(logDir, { recursive: true });
-	fs.mkdirSync(sessionsDir, { recursive: true });
-
-	const sessionFile = path.join(sessionsDir, `${agentName}.jsonl`);
-	fs.closeSync(fs.openSync(sessionFile, "a"));
-
-	const logPath = path.join(logDir, `${agentName}.log`);
-	const out = fs.openSync(logPath, "a");
-	const err = fs.openSync(logPath, "a");
+	const { cwd, entryPath, sessionsDir, teamId, agentName, logDir } = opts;
 
 	const systemAppend = [
 		"You are a teammate in an automated integration test.",
@@ -112,34 +76,19 @@ function spawnWorker(opts: {
 		"Always end with: ACCEPTED: <one-line acceptance confirmation>.",
 	].join(" ");
 
-	const args = [
-		"--mode",
-		"rpc",
-		"--session",
-		sessionFile,
-		"--session-dir",
-		sessionsDir,
-		"--no-extensions",
-		"-e",
+	return spawnTeamsWorkerRpc({
+		cwd,
 		entryPath,
-		"--append-system-prompt",
+		sessionsDir,
+		teamId,
+		taskListId: teamId,
+		agentName,
+		leadName: "team-lead",
+		style: "normal",
+		autoClaim: true,
+		planRequired: false,
 		systemAppend,
-	];
-
-	return spawn("pi", args, {
-		cwd,
-		env: {
-			...process.env,
-			PI_TEAMS_WORKER: "1",
-			PI_TEAMS_TEAM_ID: teamId,
-			PI_TEAMS_TASK_LIST_ID: teamId,
-			PI_TEAMS_AGENT_NAME: agentName,
-			PI_TEAMS_LEAD_NAME: "team-lead",
-			PI_TEAMS_STYLE: "normal",
-			PI_TEAMS_AUTO_CLAIM: "1",
-			PI_TEAMS_PLAN_REQUIRED: "0",
-		},
-		stdio: ["ignore", out, err],
+		logDir,
 	});
 }
 

package/scripts/lib/pi-workers.ts

@@ -0,0 +1,105 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawn, type ChildProcess } from "node:child_process";
+
+export function sleep(ms: number): Promise<void> {
+	return new Promise((r) => setTimeout(r, ms));
+}
+
+export async function terminateAll(children: readonly ChildProcess[]): Promise<void> {
+	for (const c of children) {
+		try {
+			c.kill("SIGTERM");
+		} catch {
+			// ignore
+		}
+	}
+
+	// Give them a moment to flush + exit.
+	const deadline = Date.now() + 10_000;
+	for (const c of children) {
+		while (c.exitCode === null && Date.now() < deadline) {
+			await sleep(100);
+		}
+		if (c.exitCode === null) {
+			try {
+				c.kill("SIGKILL");
+			} catch {
+				// ignore
+			}
+		}
+	}
+}
+
+export function spawnTeamsWorkerRpc(opts: {
+	cwd: string;
+	entryPath: string;
+	sessionsDir: string;
+	teamId: string;
+	taskListId: string;
+	agentName: string;
+	leadName: string;
+	style: "normal" | "soviet";
+	autoClaim: boolean;
+	planRequired: boolean;
+	systemAppend: string;
+	logDir: string;
+	extraEnv?: Record<string, string>;
+}): ChildProcess {
+	const {
+		cwd,
+		entryPath,
+		sessionsDir,
+		teamId,
+		taskListId,
+		agentName,
+		leadName,
+		style,
+		autoClaim,
+		planRequired,
+		systemAppend,
+		logDir,
+		extraEnv,
+	} = opts;
+
+	fs.mkdirSync(logDir, { recursive: true });
+	fs.mkdirSync(sessionsDir, { recursive: true });
+
+	const sessionFile = path.join(sessionsDir, `${agentName}.jsonl`);
+	fs.closeSync(fs.openSync(sessionFile, "a"));
+
+	const logPath = path.join(logDir, `${agentName}.log`);
+	const out = fs.openSync(logPath, "a");
+	const err = fs.openSync(logPath, "a");
+
+	const args = [
+		"--mode",
+		"rpc",
+		"--session",
+		sessionFile,
+		"--session-dir",
+		sessionsDir,
+		"--no-extensions",
+		"-e",
+		entryPath,
+		"--append-system-prompt",
+		systemAppend,
+	];
+
+	return spawn("pi", args, {
+		cwd,
+		env: {
+			...process.env,
+			PI_TEAMS_WORKER: "1",
+			PI_TEAMS_TEAM_ID: teamId,
+			PI_TEAMS_TASK_LIST_ID: taskListId,
+			PI_TEAMS_AGENT_NAME: agentName,
+			PI_TEAMS_LEAD_NAME: leadName,
+			PI_TEAMS_STYLE: style,
+			PI_TEAMS_AUTO_CLAIM: autoClaim ? "1" : "0",
+			PI_TEAMS_PLAN_REQUIRED: planRequired ? "1" : "0",
+			...(extraEnv ?? {}),
+		},
+		stdio: ["ignore", out, err],
+	});
+}

package/skills/agent-teams/SKILL.md

@@ -95,12 +95,14 @@ Spawning with `plan` restricts the teammate to read-only tools. After producing
 ```
 /team panel                    # interactive overlay with teammate details
 /team list                     # show teammates and their state
+/team shutdown                 # stop all teammates (RPC + best-effort manual) (leader session remains active)
 /team shutdown <name>          # graceful shutdown (teammate can reject if busy)
-/team kill                     # force kill all RPC teammates
+/team prune [--all]            # hide stale manual teammates (mark offline in config)
+/team kill <name>              # force-terminate one RPC teammate
 /team cleanup [--force]        # delete team directory after all teammates stopped
 ```
 
-Teammates reject shutdown requests when they have an active task. Use `/team kill` to force.
+Teammates reject shutdown requests when they have an active task. Use `/team kill <name>` to force.
 
 ## Other commands
 
@@ -111,13 +113,15 @@ Teammates reject shutdown requests when they have an active task. Use `/team kil
 
 ## Shared task list across sessions
 
-Set `PI_TEAMS_TASK_LIST_ID` env to reuse tasks across team sessions. Or switch mid-session:
+`PI_TEAMS_TASK_LIST_ID` is primarily **worker-side** (use it when you start a teammate manually).
+
+The leader switches task lists via:
 
 ```
 /team task use my-persistent-list
 ```
 
-Teammates spawned after the switch inherit the new task list ID.
+The chosen task list ID is persisted in `config.json`. Teammates spawned after the switch inherit the new task list ID; existing teammates need a restart to pick up changes.
 
 ## Message protocol
 

package/.github/workflows/ci.yml

@@ -1,32 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-jobs:
-  typecheck-and-smoke:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20.x"
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Typecheck (strict)
-        run: npm run typecheck
-
-      - name: Smoke test
-        run: npm run smoke-test
-
-      - name: Package (dry run)
-        run: npm pack --dry-run

package/scripts/smoke-test.mjs

@@ -1,199 +0,0 @@
-import * as assert from "node:assert/strict";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { createRequire } from "node:module";
-
-const require = createRequire(import.meta.url);
-const { createJiti } = require("/opt/homebrew/lib/node_modules/@mariozechner/pi-coding-agent/node_modules/@mariozechner/jiti");
-
-const jiti = createJiti(import.meta.url, {
-	interopDefault: true,
-});
-
-const root = process.cwd();
-const teamConfig = jiti(path.join(root, "extensions/teams/team-config.ts"));
-const mailbox = jiti(path.join(root, "extensions/teams/mailbox.ts"));
-const taskStore = jiti(path.join(root, "extensions/teams/task-store.ts"));
-const cleanup = jiti(path.join(root, "extensions/teams/cleanup.ts"));
-
-const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-teams-smoke-"));
-const teamId = "TEAM123";
-const taskListId = teamId;
-const teamDir = path.join(tmpRoot, "teams", teamId);
-
-console.log("tmpRoot:", tmpRoot);
-
-// -----------------------------------------------------------------------------
-// Team config
-// -----------------------------------------------------------------------------
-{
-	const cfg = await teamConfig.ensureTeamConfig(teamDir, { teamId, taskListId, leadName: "team-lead", style: "normal" });
-	assert.equal(cfg.teamId, teamId);
-	assert.equal(cfg.taskListId, taskListId);
-	assert.equal(cfg.leadName, "team-lead");
-	assert.ok(cfg.members.find((m) => m.name === "team-lead" && m.role === "lead"));
-
-	await teamConfig.upsertMember(teamDir, { name: "alice", role: "worker", status: "online" });
-	const cfg2 = await teamConfig.loadTeamConfig(teamDir);
-	assert.ok(cfg2);
-	assert.ok(cfg2.members.find((m) => m.name === "alice" && m.status === "online"));
-
-	await teamConfig.setMemberStatus(teamDir, "alice", "offline", { meta: { reason: "test" } });
-	const cfg3 = await teamConfig.loadTeamConfig(teamDir);
-	assert.ok(cfg3);
-	assert.ok(cfg3.members.find((m) => m.name === "alice" && m.status === "offline"));
-}
-
-// -----------------------------------------------------------------------------
-// Mailbox
-// -----------------------------------------------------------------------------
-{
-	await mailbox.writeToMailbox(teamDir, "team", "team-lead", {
-		from: "alice",
-		text: JSON.stringify({ type: "idle_notification", from: "alice", timestamp: new Date().toISOString() }),
-		timestamp: new Date().toISOString(),
-	});
-
-	const msgs = await mailbox.popUnreadMessages(teamDir, "team", "team-lead");
-	assert.equal(msgs.length, 1);
-	assert.equal(msgs[0].from, "alice");
-
-	const msgs2 = await mailbox.popUnreadMessages(teamDir, "team", "team-lead");
-	assert.equal(msgs2.length, 0);
-}
-
-// -----------------------------------------------------------------------------
-// Task store
-// -----------------------------------------------------------------------------
-{
-	const t1 = await taskStore.createTask(teamDir, taskListId, { subject: "Smoke task 1", description: "Do thing" });
-	assert.equal(t1.id, "1");
-
-	const t2 = await taskStore.createTask(teamDir, taskListId, { subject: "Smoke task 2", description: "Do other" });
-	assert.equal(t2.id, "2");
-
-	const t3 = await taskStore.createTask(teamDir, taskListId, { subject: "Smoke task 3", description: "Do third" });
-	assert.equal(t3.id, "3");
-
-	let tasks = await taskStore.listTasks(teamDir, taskListId);
-	assert.equal(tasks.length, 3);
-
-	// Dependencies: #2 depends on #1 (so #2 is blocked until #1 is completed)
-	const depRes = await taskStore.addTaskDependency(teamDir, taskListId, "2", "1");
-	assert.ok(depRes.ok);
-
-	const t1AfterDep = await taskStore.getTask(teamDir, taskListId, "1");
-	const t2AfterDep = await taskStore.getTask(teamDir, taskListId, "2");
-	assert.ok(t1AfterDep);
-	assert.ok(t2AfterDep);
-	assert.ok(t1AfterDep.blocks.includes("2"));
-	assert.ok(t2AfterDep.blockedBy.includes("1"));
-	assert.equal(await taskStore.isTaskBlocked(teamDir, taskListId, t2AfterDep), true);
-
-	const claimed = await taskStore.claimNextAvailableTask(teamDir, taskListId, "alice", { checkAgentBusy: true });
-	assert.ok(claimed);
-	assert.equal(claimed.id, "1");
-	assert.equal(claimed.owner, "alice");
-	assert.equal(claimed.status, "in_progress");
-
-	// Blocked self-claim: bob should skip #2 (blocked) and claim #3
-	const claimedBob = await taskStore.claimNextAvailableTask(teamDir, taskListId, "bob", { checkAgentBusy: true });
-	assert.ok(claimedBob);
-	assert.equal(claimedBob.id, "3");
-	assert.equal(claimedBob.owner, "bob");
-
-	// Busy check: should refuse a second claim while alice has in_progress
-	const claimed2 = await taskStore.claimNextAvailableTask(teamDir, taskListId, "alice", { checkAgentBusy: true });
-	assert.equal(claimed2, null);
-
-	await taskStore.completeTask(teamDir, taskListId, claimed.id, "alice", "done");
-
-	const t2AfterDepDone = await taskStore.getTask(teamDir, taskListId, "2");
-	assert.ok(t2AfterDepDone);
-	assert.equal(await taskStore.isTaskBlocked(teamDir, taskListId, t2AfterDepDone), false);
-
-	// Now alice can claim #2
-	const claimed3 = await taskStore.claimNextAvailableTask(teamDir, taskListId, "alice", { checkAgentBusy: true });
-	assert.ok(claimed3);
-	assert.equal(claimed3.id, "2");
-
-	// Create an additional pending task owned by alice (simulates assigned-but-not-started)
-	const t4 = await taskStore.createTask(teamDir, taskListId, {
-		subject: "Smoke task 4",
-		description: "Do fourth",
-		owner: "alice",
-	});
-	assert.equal(t4.id, "4");
-	assert.equal(t4.owner, "alice");
-	assert.equal(t4.status, "pending");
-
-	// Unassign a single task (should only unassign task 2, leaving task 4 assigned)
-	await taskStore.unassignTask(teamDir, taskListId, claimed3.id, "alice", "test abort", { abortedBy: "alice" });
-
-	tasks = await taskStore.listTasks(teamDir, taskListId);
-	const t2After = tasks.find((t) => t.id === "2");
-	assert.ok(t2After);
-	assert.equal(t2After.owner, undefined);
-	assert.equal(t2After.status, "pending");
-
-	const t4After = tasks.find((t) => t.id === "4");
-	assert.ok(t4After);
-	assert.equal(t4After.owner, "alice");
-	assert.equal(t4After.status, "pending");
-
-	// Unassign remaining non-completed tasks for alice (should unassign task 4)
-	const unassignedCount = await taskStore.unassignTasksForAgent(teamDir, taskListId, "alice", "test unassign");
-	assert.equal(unassignedCount, 1);
-
-	tasks = await taskStore.listTasks(teamDir, taskListId);
-	const t4After2 = tasks.find((t) => t.id === "4");
-	assert.ok(t4After2);
-	assert.equal(t4After2.owner, undefined);
-	assert.equal(t4After2.status, "pending");
-
-	// Complete bob's task so clear(completed) deletes both #1 and #3
-	await taskStore.completeTask(teamDir, taskListId, claimedBob.id, "bob", "done");
-
-	// Clear completed tasks (should delete tasks 1 + 3)
-	const clearedCompleted = await taskStore.clearTasks(teamDir, taskListId, "completed");
-	assert.equal(clearedCompleted.errors.length, 0);
-	assert.deepEqual([...clearedCompleted.deletedTaskIds].sort(), ["1", "3"]);
-
-	tasks = await taskStore.listTasks(teamDir, taskListId);
-	assert.equal(tasks.length, 2);
-	assert.deepEqual(
-		tasks.map((t) => t.id).sort(),
-		["2", "4"],
-	);
-
-	// Clear all remaining tasks
-	const clearedAll = await taskStore.clearTasks(teamDir, taskListId, "all");
-	assert.equal(clearedAll.errors.length, 0);
-
-	tasks = await taskStore.listTasks(teamDir, taskListId);
-	assert.equal(tasks.length, 0);
-}
-
-// -----------------------------------------------------------------------------
-// Cleanup
-// -----------------------------------------------------------------------------
-{
-	const teamsRootDir = path.join(tmpRoot, "teams");
-
-	// Put a sentinel file in the team dir, then delete it.
-	fs.mkdirSync(teamDir, { recursive: true });
-	fs.writeFileSync(path.join(teamDir, "sentinel.txt"), "sentinel");
-
-	await cleanup.cleanupTeamDir(teamsRootDir, teamDir);
-	assert.equal(fs.existsSync(teamDir), false);
-
-	// Refuse unsafe paths
-	await assert.rejects(
-		() => cleanup.cleanupTeamDir(teamsRootDir, path.join(tmpRoot, "outside", "TEAM123")),
-		/Refusing to operate on path outside teams root/,
-	);
-	await assert.rejects(() => cleanup.cleanupTeamDir(teamsRootDir, teamsRootDir), /Refusing to operate on path outside teams root/);
-}
-
-console.log("OK: smoke test passed");