@tmustier/pi-agent-teams 0.5.3 → 0.5.5

package/extensions/teams/session-parent.ts

@@ -1,4 +1,4 @@
-import { SessionManager } from "@mariozechner/pi-coding-agent";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
 import type { TeamAttachClaimHeartbeatResult } from "./team-attach-claim.js";
 
 interface SessionManagerWithHeader {

package/extensions/teams/spawn-types.ts

@@ -1,5 +1,5 @@
-import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 export type ContextMode = "fresh" | "branch";
 export type WorkspaceMode = "shared" | "worktree";

package/extensions/teams/teammate-rpc.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import type { AgentEvent } from "@mariozechner/pi-agent-core";
+import type { AgentEvent } from "@earendil-works/pi-agent-core";
 
 export type TeammateStatus = "starting" | "idle" | "streaming" | "stopped" | "error";
 

package/extensions/teams/teams-panel.ts

@@ -1,5 +1,5 @@
-import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import type { Theme, ThemeColor, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { Theme, ThemeColor, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import type { TeammateRpc } from "./teammate-rpc.js";
 import type { ActivityTracker, TranscriptLog, TranscriptEntry } from "./activity-tracker.js";
 import type { TeamTask } from "./task-store.js";

package/extensions/teams/teams-ui-shared.ts

@@ -1,5 +1,5 @@
-import type { Theme, ThemeColor } from "@mariozechner/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { TeamConfig, TeamMember } from "./team-config.js";
 import type { TeamTask } from "./task-store.js";
 import type { TeammateRpc, TeammateStatus } from "./teammate-rpc.js";

package/extensions/teams/teams-widget.ts

@@ -1,6 +1,6 @@
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import type { Component, TUI } from "@mariozechner/pi-tui";
-import type { Theme, ThemeColor } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
 import type { TeammateRpc } from "./teammate-rpc.js";
 import type { ActivityTracker } from "./activity-tracker.js";
 import type { TeamTask } from "./task-store.js";

package/extensions/teams/worker.ts

@@ -1,5 +1,5 @@
-import type { AgentMessage, AgentToolResult } from "@mariozechner/pi-agent-core";
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AgentMessage, AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "@sinclair/typebox";
 import { randomUUID } from "node:crypto";
 import { popUnreadMessages, writeToMailbox } from "./mailbox.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmustier/pi-agent-teams",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Claude Code agent teams style workflow for Pi.",
   "license": "MIT",
   "author": "Thomas Mustier",
@@ -35,14 +35,15 @@
     "integration-spawn-overrides-test": "tsx scripts/integration-spawn-overrides-test.mts",
     "integration-hooks-remediation-test": "tsx scripts/integration-hooks-remediation-test.mts",
     "integration-todo-test": "tsx scripts/integration-todo-test.mts",
-    "integration-cleanup-test": "tsx scripts/integration-cleanup-test.mts"
+    "integration-cleanup-test": "tsx scripts/integration-cleanup-test.mts",
+    "integration-branch-context-test": "tsx scripts/integration-branch-context-test.mts"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@mariozechner/pi-agent-core": "^0.62.0",
-    "@mariozechner/pi-ai": "^0.62.0",
-    "@mariozechner/pi-coding-agent": "^0.62.0",
-    "@mariozechner/pi-tui": "^0.62.0",
+    "@earendil-works/pi-agent-core": "^0.74.0",
+    "@earendil-works/pi-ai": "^0.74.0",
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0",
     "@sinclair/typebox": "^0.34.48",
     "eslint": "^9.39.2",
     "tsx": "^4.20.5",
@@ -50,10 +51,10 @@
     "typescript-eslint": "^8.54.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-agent-core": "*",
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
     "@sinclair/typebox": "*"
   }
 }

package/scripts/integration-branch-context-test.mts

@@ -0,0 +1,299 @@
+/**
+ * Integration test: branch-mode worker sessions should strip the leader's
+ * in-progress tool-use turn before starting delegated work.
+ *
+ * What this covers:
+ * - Prepare a persisted parent session whose leaf ends inside an unfinished
+ *   assistant/tool-use turn (user -> assistant toolUse -> toolResult)
+ * - Derive a branch session using the same clean-turn selection logic used by
+ *   teammate spawning
+ * - Start a real worker process from that branched session in worktree mode
+ *   context conditions (git repo + persisted session)
+ * - Deliver an assigned task and verify the worker starts and completes it
+ *
+ * Usage:
+ *   npx tsx scripts/integration-branch-context-test.mts
+ *   npx tsx scripts/integration-branch-context-test.mts --timeoutSec 120
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { writeToMailbox } from "../extensions/teams/mailbox.js";
+import { taskAssignmentPayload } from "../extensions/teams/protocol.js";
+import { branchSelectionNote, resolveBranchLeafSelection } from "../extensions/teams/session-branching.js";
+import { createTask, getTask } from "../extensions/teams/task-store.js";
+import { ensureTeamConfig, loadTeamConfig } from "../extensions/teams/team-config.js";
+import { sleep, terminateAll } from "./lib/pi-workers.js";
+
+function parseArgs(argv: readonly string[]): { timeoutSec: number } {
+	let timeoutSec = 120;
+	for (let i = 0; i < argv.length; i += 1) {
+		if (argv[i] === "--timeoutSec") {
+			const v = argv[i + 1];
+			if (v) timeoutSec = Number.parseInt(v, 10);
+			i += 1;
+		}
+	}
+	if (!Number.isFinite(timeoutSec) || timeoutSec < 30) timeoutSec = 120;
+	return { timeoutSec };
+}
+
+function assert(condition: boolean, message: string): void {
+	if (!condition) throw new Error(message);
+}
+
+async function waitFor(
+	fn: () => boolean | Promise<boolean>,
+	opts: { timeoutMs: number; pollMs: number; label: string },
+): Promise<void> {
+	const { timeoutMs, pollMs, label } = opts;
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (await fn()) return;
+		await sleep(pollMs);
+	}
+	throw new Error(`Timeout waiting for ${label}`);
+}
+
+function git(args: string[], cwd: string): void {
+	const res = spawnSync("git", args, {
+		cwd,
+		encoding: "utf8",
+	});
+	if (res.status !== 0) {
+		throw new Error(`git ${args.join(" ")} failed: ${res.stderr || res.stdout}`);
+	}
+}
+
+async function latestMemberStatus(teamDir: string, name: string): Promise<{ status?: string; sessionFile?: string } | null> {
+	const cfg = await loadTeamConfig(teamDir);
+	if (!cfg) return null;
+	const member = cfg.members.find((m) => m.name === name);
+	if (!member) return null;
+	return { status: member.status, sessionFile: member.sessionFile };
+}
+
+const { timeoutSec } = parseArgs(process.argv.slice(2));
+const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-teams-branch-context-"));
+const teamsRootDir = path.join(tmpRoot, "teams-root");
+const repoDir = path.join(tmpRoot, "repo");
+const teamId = "branch-context-team";
+const taskListId = teamId;
+const teamDir = path.join(teamsRootDir, teamId);
+const sessionsDir = path.join(teamDir, "sessions");
+const agentName = "alpha";
+const leadName = "team-lead";
+const procs: ChildProcess[] = [];
+
+try {
+	fs.mkdirSync(repoDir, { recursive: true });
+	fs.mkdirSync(sessionsDir, { recursive: true });
+
+	git(["init", "-b", "main"], repoDir);
+git(["config", "user.name", "Test User"], repoDir);
+git(["config", "user.email", "test@example.com"], repoDir);
+fs.writeFileSync(path.join(repoDir, "README.md"), "branch context integration\n", "utf8");
+git(["add", "README.md"], repoDir);
+git(["commit", "-m", "init"], repoDir);
+
+const parent = SessionManager.create(repoDir, sessionsDir);
+parent.appendModelChange("openai-codex", "gpt-5.4");
+parent.appendThinkingLevelChange("minimal");
+parent.appendMessage({
+	role: "user",
+	content: [{ type: "text", text: "Summarize the repo history." }],
+	timestamp: Date.now(),
+});
+const stableAssistantId = parent.appendMessage({
+	role: "assistant",
+	content: [{ type: "text", text: "The repo history is summarized." }],
+	api: "test",
+	provider: "test",
+	model: "test",
+	usage: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	},
+	stopReason: "stop",
+	timestamp: Date.now(),
+});
+const compactionId = parent.appendCompaction("summarized", stableAssistantId, 1234);
+const currentUserId = parent.appendMessage({
+	role: "user",
+	content: [{ type: "text", text: "Investigate the repo, then delegate part of it." }],
+	timestamp: Date.now(),
+});
+const toolUseAssistant: AssistantMessage = {
+	role: "assistant",
+	content: [{ type: "toolCall", id: "call-1", name: "read", arguments: { path: "README.md" } }],
+	api: "test",
+	provider: "test",
+	model: "test",
+	usage: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	},
+	stopReason: "toolUse",
+	timestamp: Date.now(),
+};
+parent.appendMessage(toolUseAssistant);
+parent.appendMessage({
+	role: "toolResult",
+	toolCallId: "call-1",
+	toolName: "read",
+	content: [{ type: "text", text: "branch context integration" }],
+	isError: false,
+	timestamp: Date.now(),
+});
+
+const parentLeafId = parent.getLeafId();
+assert(parentLeafId !== null, "expected parent leaf id");
+if (!parentLeafId) {
+	throw new Error("Missing parent leaf id");
+}
+
+const selection = resolveBranchLeafSelection(parent.getBranch(parentLeafId), parentLeafId);
+assert(selection.adjusted, "expected unfinished turn branch selection to adjust away from active leaf");
+assert(selection.leafId === compactionId, `expected branch selection to use the stable pre-user boundary id, got ${selection.leafId}`);
+assert(branchSelectionNote(selection) === "branch(clean-turn)", "expected clean-turn branch note");
+assert(selection.replayUserMessage?.role === "user", "expected the active user request to be replayed into the cleaned child branch");
+
+const branchedSessionFile = parent.createBranchedSession(selection.leafId);
+assert(Boolean(branchedSessionFile), "expected branched session file to be created");
+if (!branchedSessionFile) {
+	throw new Error("Missing branched session file");
+}
+if (selection.replayUserMessage) {
+	parent.appendMessage(JSON.parse(JSON.stringify(selection.replayUserMessage)) as Parameters<typeof parent.appendMessage>[0]);
+}
+
+const childEntries = parent.getEntries();
+assert(childEntries.some((entry) => entry.id === stableAssistantId), "child session should retain the latest completed assistant message");
+assert(childEntries.some((entry) => entry.id === compactionId), "child session should retain the compaction entry before the active user");
+assert(!childEntries.some((entry) => entry.id === currentUserId), "child session should drop the original unfinished-turn user entry");
+assert(
+	childEntries.some(
+		(entry) =>
+			entry.type === "message" &&
+			typeof entry.message === "object" &&
+			entry.message !== null &&
+			(entry.message as { role?: string }).role === "user" &&
+			JSON.stringify((entry.message as { content?: unknown }).content).includes("Investigate the repo, then delegate part of it."),
+	),
+	"child session should replay the active user request onto the cleaned branch",
+);
+assert(
+	!childEntries.some(
+		(entry) =>
+			entry.type === "message" &&
+			typeof entry.message === "object" &&
+			entry.message !== null &&
+			(entry.message as { role?: string }).role === "assistant" &&
+			entry.id !== stableAssistantId,
+	),
+	"child session should exclude the in-progress assistant tool-use message",
+);
+assert(
+	!childEntries.some(
+		(entry) => entry.type === "message" && typeof entry.message === "object" && entry.message !== null && (entry.message as { role?: string }).role === "toolResult",
+	),
+	"child session should exclude trailing tool results from the unfinished turn",
+);
+
+await ensureTeamConfig(teamDir, { teamId, taskListId, leadName, style: "normal" });
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(scriptDir, "..");
+const entryPath = path.join(repoRoot, "extensions", "teams", "index.ts");
+assert(fs.existsSync(entryPath), `Missing teams entry path: ${entryPath}`);
+
+const worker = spawn(
+	"pi",
+	[
+		"--mode",
+		"rpc",
+		"--session",
+		branchedSessionFile,
+		"--session-dir",
+		sessionsDir,
+		"--provider",
+		"openai-codex",
+		"--model",
+		"gpt-5.4",
+		"--thinking",
+		"minimal",
+		"--no-extensions",
+		"-e",
+		entryPath,
+		"--append-system-prompt",
+		`You are teammate '${agentName}'. Prefer working from the shared task list.`,
+	],
+	{
+		cwd: repoDir,
+		env: {
+			...process.env,
+			PI_TEAMS_ROOT_DIR: teamsRootDir,
+			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: "normal",
+			PI_TEAMS_AUTO_CLAIM: "0",
+		},
+		stdio: ["pipe", "pipe", "pipe"],
+	},
+);
+procs.push(worker);
+
+await waitFor(
+	async () => {
+		const member = await latestMemberStatus(teamDir, agentName);
+		return member?.status === "online";
+	},
+	{ timeoutMs: timeoutSec * 1000, pollMs: 250, label: `${agentName} online` },
+);
+
+const task = await createTask(teamDir, taskListId, {
+	subject: "Branch context integration",
+	description: "Reply with exactly 'branch context integration ok'. Do not edit files.",
+	owner: agentName,
+});
+await writeToMailbox(teamDir, taskListId, agentName, {
+	from: leadName,
+	text: JSON.stringify(taskAssignmentPayload(task, leadName)),
+	timestamp: new Date().toISOString(),
+});
+
+await waitFor(
+	async () => {
+		const current = await getTask(teamDir, taskListId, task.id);
+		const result = current?.metadata?.result;
+		return current?.status === "completed" && typeof result === "string" && result.includes("branch context integration ok");
+	},
+	{ timeoutMs: timeoutSec * 1000, pollMs: 500, label: `task #${task.id} completion` },
+);
+
+	console.log("PASS: branch context integration test passed");
+} finally {
+	await terminateAll(procs);
+	try {
+		fs.rmSync(tmpRoot, { recursive: true, force: true });
+	} catch {
+		// ignore
+	}
+}