ai-fob 1.11.2 → 1.11.3

package/assets/pi/extensions/inter-agent-team/README.md

@@ -6,7 +6,7 @@ Project-local MVP extension for persistent, PTY-backed teammates.
 
 - Runtime: Pi by default; experimental terminal-level Claude Code support via `runtime: "claude-code"`
 - Tool: `inter_agent_team`
-- Actions: `create`, `list`, `show`, `send`, `attach`, `close_agent`, `close_team`, `kill_agent`
+- Actions: `create`, `list`, `show`, `send`, `attach`, `close_agent`, `close_team`, `kill_agent`, `start_build_feature`, `status_build_feature`, `resume_build_feature`, `stop_build_feature`
 - Storage: `.pi/inter-agent-team/`
 - Nested team spawning: disabled by policy/environment guard
 
@@ -67,6 +67,59 @@ This launches roughly:
 claude --dangerously-skip-permissions "tell me about this repo"
 ```
 
+## Extension-backed build-feature monitor
+
+The extension can run a deterministic multi-phase build-feature monitor that launches Claude Code teammates phase-by-phase and polls filesystem completion reports.
+
+Start:
+
+```ts
+inter_agent_team({
+  action: "start_build_feature",
+  plan: "specs/07_instagram-x-creator-feed/07_instagram-x-creator-feed_V1.md",
+  startPhase: 2,
+  endPhase: 5,
+  pollSeconds: 600,
+  closeTeams: true
+})
+```
+
+Status:
+
+```ts
+inter_agent_team({ action: "status_build_feature", plan: "specs/.../plan.md" })
+```
+
+Resume after interruption/restart:
+
+```ts
+inter_agent_team({ action: "resume_build_feature", plan: "specs/.../plan.md" })
+```
+
+Stop monitor:
+
+```ts
+inter_agent_team({ action: "stop_build_feature", plan: "specs/.../plan.md", closeTeams: false })
+```
+
+Workflow state is stored under:
+
+```txt
+.pi/inter-agent-team/workflows/build-feature/<feature-slug>.json
+```
+
+The monitor uses phase reports as the primary completion contract:
+
+```txt
+{SPEC_DIR}/phase<N>_*/phase_completion_report.md
+```
+
+and launches each phase with Claude Code:
+
+```bash
+claude --dangerously-skip-permissions "/build-phase-V2 <plan> <phase>"
+```
+
 ## Attach behavior
 
 `attach` is modal and captures keyboard focus. Use it only when the user explicitly wants to take over or interact directly with the teammate terminal.

package/assets/pi/extensions/inter-agent-team/index.ts

@@ -2,12 +2,14 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getSessionManager } from "./runtime/session-manager.js";
 import { registerInterAgentTeamTool } from "./tool.js";
 import { registerInterAgentTeamWidget } from "./widget.js";
+import { getBuildFeatureWorkflowManager } from "./workflows/build-feature/manager.js";
 
 export default function interAgentTeamExtension(pi: ExtensionAPI): void {
 	const manager = getSessionManager();
+	const buildFeatureManager = getBuildFeatureWorkflowManager(manager);
 
-	registerInterAgentTeamTool(pi, manager);
-	registerInterAgentTeamWidget(pi, manager);
+	registerInterAgentTeamTool(pi, manager, buildFeatureManager);
+	registerInterAgentTeamWidget(pi, manager, buildFeatureManager);
 
 	pi.on("session_start", (_event, ctx) => {
 		if (process.env.PI_INTER_AGENT_TEAM_CAN_SPAWN === "false") {
@@ -16,6 +18,7 @@ export default function interAgentTeamExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("session_shutdown", async () => {
+		buildFeatureManager.stopAllTimers();
 		await manager.closeAll({ force: true, reason: "pi_session_shutdown" });
 	});
 }

package/assets/pi/extensions/inter-agent-team/schema.ts

@@ -11,6 +11,10 @@ export const InterAgentTeamParams = Type.Object({
 		"close_agent",
 		"close_team",
 		"kill_agent",
+		"start_build_feature",
+		"status_build_feature",
+		"resume_build_feature",
+		"stop_build_feature",
 	] as const),
 
 	team: Type.Optional(Type.String({ description: "Team id or name" })),
@@ -20,6 +24,13 @@ export const InterAgentTeamParams = Type.Object({
 	message: Type.Optional(Type.String({ description: "Message to send to a teammate" })),
 	task: Type.Optional(Type.String({ description: "Initial team task" })),
 
+	plan: Type.Optional(Type.String({ description: "High-level build plan path for build-feature workflows" })),
+	workflow: Type.Optional(Type.String({ description: "Build-feature workflow id, feature slug, or plan path" })),
+	startPhase: Type.Optional(Type.Number({ description: "First phase to run" })),
+	endPhase: Type.Optional(Type.Number({ description: "Last phase to run" })),
+	pollSeconds: Type.Optional(Type.Number({ description: "Polling interval in seconds for build-feature workflows" })),
+	closeTeams: Type.Optional(Type.Boolean({ description: "Whether completed phase teams should be closed automatically" })),
+
 	agents: Type.Optional(
 		Type.Array(
 			Type.Object({
@@ -43,4 +54,8 @@ export type InterAgentTeamAction =
 	| "attach"
 	| "close_agent"
 	| "close_team"
-	| "kill_agent";
+	| "kill_agent"
+	| "start_build_feature"
+	| "status_build_feature"
+	| "resume_build_feature"
+	| "stop_build_feature";

package/assets/pi/extensions/inter-agent-team/tool.ts

@@ -6,6 +6,8 @@ import type { TeamAgentRecord, TeamRecord, ToolDetails } from "./types.js";
 import { getRuntimeAdapter } from "./runtime/runtime-adapter.js";
 import type { InterAgentSessionManager } from "./runtime/session-manager.js";
 import { TeammateOverlay } from "./ui/teammate-overlay.js";
+import type { BuildFeatureWorkflowManager } from "./workflows/build-feature/manager.js";
+import { formatBuildFeatureWorkflow } from "./workflows/build-feature/manager.js";
 
 function textResult(text: string, details: ToolDetails): AgentToolResult<ToolDetails> {
 	return { content: [{ type: "text", text }], details };
@@ -47,7 +49,7 @@ function syncTeamStatuses(team: TeamRecord, manager: InterAgentSessionManager):
 	return team;
 }
 
-export function registerInterAgentTeamTool(pi: ExtensionAPI, manager: InterAgentSessionManager): void {
+export function registerInterAgentTeamTool(pi: ExtensionAPI, manager: InterAgentSessionManager, buildFeatureManager?: BuildFeatureWorkflowManager): void {
 	pi.registerTool({
 		name: "inter_agent_team",
 		label: "Inter-Agent Team",
@@ -60,13 +62,49 @@ export function registerInterAgentTeamTool(pi: ExtensionAPI, manager: InterAgent
 			"Do not use inter_agent_team attach automatically after create, list, show, or send.",
 			"Do not use inter_agent_team for simple one-shot delegation; use subagent for disposable tasks instead.",
 			"Do not create nested inter-agent teams from inside a teammate session.",
+			"Use start_build_feature/status_build_feature/resume_build_feature/stop_build_feature for extension-backed multi-phase build orchestration instead of manual long-running polling.",
 		],
 		parameters: InterAgentTeamParams,
 
 		async execute(_toolCallId, params: any, _signal, _onUpdate, ctx: any) {
 			try {
 				switch (params.action) {
-					case "create": {
+					case "start_build_feature": {
+					if (!buildFeatureManager) throw new Error("Build-feature workflow manager is not available.");
+					const plan = requireString(params.plan, "plan");
+					const workflow = await buildFeatureManager.start({
+						cwd: ctx.cwd ?? process.cwd(),
+						plan,
+						startPhase: typeof params.startPhase === "number" ? params.startPhase : undefined,
+						endPhase: typeof params.endPhase === "number" ? params.endPhase : undefined,
+						pollSeconds: typeof params.pollSeconds === "number" ? params.pollSeconds : undefined,
+						closeTeams: typeof params.closeTeams === "boolean" ? params.closeTeams : undefined,
+					});
+					return textResult(`Started build-feature workflow.\n\n${formatBuildFeatureWorkflow(workflow)}`, { ok: true, workflow });
+				}
+
+				case "status_build_feature": {
+					if (!buildFeatureManager) throw new Error("Build-feature workflow manager is not available.");
+					const result = await buildFeatureManager.status({ cwd: ctx.cwd ?? process.cwd(), workflow: params.workflow, plan: params.plan });
+					if (result.workflow) return textResult(formatBuildFeatureWorkflow(result.workflow), { ok: true, workflow: result.workflow });
+					const workflows = result.workflows ?? [];
+					const text = workflows.length ? workflows.map(formatBuildFeatureWorkflow).join("\n\n") : "No build-feature workflows found.";
+					return textResult(text, { ok: true, workflows });
+				}
+
+				case "resume_build_feature": {
+					if (!buildFeatureManager) throw new Error("Build-feature workflow manager is not available.");
+					const workflow = await buildFeatureManager.resume({ cwd: ctx.cwd ?? process.cwd(), workflow: params.workflow, plan: params.plan });
+					return textResult(`Resumed build-feature workflow.\n\n${formatBuildFeatureWorkflow(workflow)}`, { ok: true, workflow });
+				}
+
+				case "stop_build_feature": {
+					if (!buildFeatureManager) throw new Error("Build-feature workflow manager is not available.");
+					const workflow = await buildFeatureManager.stop({ cwd: ctx.cwd ?? process.cwd(), workflow: params.workflow, plan: params.plan, closeTeams: params.closeTeams === true });
+					return textResult(`Stopped build-feature workflow.\n\n${formatBuildFeatureWorkflow(workflow)}`, { ok: true, workflow });
+				}
+
+				case "create": {
 						if (process.env.PI_INTER_AGENT_TEAM_CAN_SPAWN === "false") {
 							throw new Error("Nested inter-agent-team creation is disabled for teammate sessions.");
 						}

package/assets/pi/extensions/inter-agent-team/types.ts

@@ -57,11 +57,64 @@ export interface CreateTeamInput {
 	cwd?: string;
 }
 
+export type BuildFeatureWorkflowStatus = "running" | "completed" | "blocked" | "failed" | "stopped" | "interrupted";
+
+export type BuildFeaturePhaseStatus = "pending" | "running" | "completed" | "blocked" | "failed" | "interrupted" | "skipped";
+
+export interface BuildFeaturePhaseRecord {
+	phase: number;
+	status: BuildFeaturePhaseStatus;
+	teamId?: string;
+	teamName?: string;
+	agentId?: string;
+	agentName?: string;
+	launchPrompt?: string;
+	startedAt?: string;
+	completedAt?: string;
+	lastPollAt?: string;
+	completionReport?: string;
+	result?: "complete" | "blocked" | "failed" | "unknown";
+	validationResult?: "pass" | "pass-with-followups" | "blocked" | "fail" | "unknown" | string;
+	stateHashBefore?: string;
+	stateHashAfter?: string;
+	note?: string;
+}
+
+export interface BuildFeatureWorkflowRecord {
+	workflow: "build-feature-interagent";
+	id: string;
+	status: BuildFeatureWorkflowStatus;
+	planPath: string;
+	planPathAbs: string;
+	projectRoot: string;
+	specDir: string;
+	featureSlug: string;
+	taskName: string;
+	teamName: string;
+	createdAt: string;
+	updatedAt: string;
+	startedAt?: string;
+	completedAt?: string;
+	stoppedAt?: string;
+	startPhase: number;
+	endPhase: number;
+	totalPhases: number;
+	currentPhase: number;
+	pollSeconds: number;
+	closeTeams: boolean;
+	lastPollAt?: string;
+	nextPollAt?: string;
+	lastMessage?: string;
+	phases: BuildFeaturePhaseRecord[];
+}
+
 export interface ToolDetails {
 	ok: boolean;
 	team?: TeamRecord;
 	teams?: TeamRecord[];
 	agent?: TeamAgentRecord;
+	workflow?: BuildFeatureWorkflowRecord;
+	workflows?: BuildFeatureWorkflowRecord[];
 	output?: string;
 	error?: string;
 }

package/assets/pi/extensions/inter-agent-team/widget.ts

@@ -1,7 +1,8 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getProjectRegistry } from "./registry.js";
 import type { InterAgentSessionManager, ManagedTeammateSession } from "./runtime/session-manager.js";
-import type { TeamAgentRecord, TeamRecord } from "./types.js";
+import type { TeamAgentRecord, TeamRecord, BuildFeatureWorkflowRecord } from "./types.js";
+import type { BuildFeatureWorkflowManager } from "./workflows/build-feature/manager.js";
 
 const WIDGET_KEY = "inter-agent-team";
 
@@ -28,8 +29,19 @@ function renderAgentLine(team: TeamRecord, agent: TeamAgentRecord, live: Managed
 	return `${theme.fg(role(status), icon(status))} ${theme.fg("text", agent.name)} ${theme.fg("muted", `[${agent.runtime}]`)} ${theme.fg(role(status), `— ${suffix}`)}`;
 }
 
-function renderLines(activeTeams: TeamRecord[], liveSessions: ManagedTeammateSession[], theme: any): string[] {
+function renderWorkflowLine(workflow: BuildFeatureWorkflowRecord, theme: any): string {
+	const phase = workflow.phases.find((item) => item.phase === workflow.currentPhase);
+	const next = workflow.nextPollAt ? ` next poll ${workflow.nextPollAt}` : "";
+	return `${theme.fg(role(workflow.status), icon(workflow.status))} ${theme.fg("text", workflow.featureSlug)} ${theme.fg("muted", `— ${workflow.status}; phase ${workflow.currentPhase}/${workflow.endPhase}${phase ? ` ${phase.status}` : ""}${next}`)}`;
+}
+
+function renderLines(activeTeams: TeamRecord[], liveSessions: ManagedTeammateSession[], workflows: BuildFeatureWorkflowRecord[], theme: any): string[] {
 	const lines: string[] = [theme.fg("accent", "Inter-Agent Teams")];
+	const activeWorkflows = workflows.filter((workflow) => workflow.status === "running" || workflow.status === "blocked" || workflow.status === "failed" || workflow.status === "interrupted");
+	if (activeWorkflows.length > 0) {
+		lines.push(theme.fg("accent", "Build Feature Workflows"));
+		for (const workflow of activeWorkflows) lines.push(renderWorkflowLine(workflow, theme));
+	}
 	for (const team of activeTeams) {
 		lines.push(theme.fg("muted", `Team: ${team.name} (${team.id}) — ${team.status}`));
 		if (team.agents.length === 0) {
@@ -44,7 +56,7 @@ function renderLines(activeTeams: TeamRecord[], liveSessions: ManagedTeammateSes
 	return lines;
 }
 
-export function registerInterAgentTeamWidget(pi: ExtensionAPI, manager: InterAgentSessionManager): void {
+export function registerInterAgentTeamWidget(pi: ExtensionAPI, manager: InterAgentSessionManager, buildFeatureManager?: BuildFeatureWorkflowManager): void {
 	let lastCtx: any | null = null;
 	let repainting = false;
 	let repaintQueued = false;
@@ -59,11 +71,13 @@ export function registerInterAgentTeamWidget(pi: ExtensionAPI, manager: InterAge
 		try {
 			const registry = getProjectRegistry(ctx.cwd ?? process.cwd());
 			const activeTeams = (await registry.listTeams()).filter((team) => team.status === "active");
-			if (activeTeams.length === 0) {
+			const workflows = buildFeatureManager ? await buildFeatureManager.list(ctx.cwd ?? process.cwd()) : [];
+			const visibleWorkflows = workflows.filter((workflow) => workflow.status === "running" || workflow.status === "blocked" || workflow.status === "failed" || workflow.status === "interrupted");
+			if (activeTeams.length === 0 && visibleWorkflows.length === 0) {
 				ctx.ui.setWidget(WIDGET_KEY, undefined);
 				return;
 			}
-			ctx.ui.setWidget(WIDGET_KEY, renderLines(activeTeams, manager.list(), ctx.ui.theme), { placement: "belowEditor" });
+			ctx.ui.setWidget(WIDGET_KEY, renderLines(activeTeams, manager.list(), workflows, ctx.ui.theme), { placement: "belowEditor" });
 		} finally {
 			repainting = false;
 			if (repaintQueued) {
@@ -77,6 +91,10 @@ export function registerInterAgentTeamWidget(pi: ExtensionAPI, manager: InterAge
 		if (lastCtx) void repaint(lastCtx);
 	});
 
+	buildFeatureManager?.onChange(() => {
+		if (lastCtx) void repaint(lastCtx);
+	});
+
 	pi.on("session_start", (_event: any, ctx: any) => {
 		lastCtx = ctx;
 		void repaint(ctx);