@vitos-pizza/vitos-pizza 0.1.0 → 0.2.0

package/packages/subagents/extensions/index.ts

@@ -1,164 +1,164 @@
-/**
- * @vitos-pizza/subagents — subprocess subagent delegation for Vito's Pizzeria.
- */
-
-import type {
-	ExtensionAPI,
-	ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "../src/env.ts";
-import { createSubagentRuntime } from "../src/runtime.ts";
-import type { SubagentRuntime } from "../src/runtime.ts";
-import { SUBAGENTS_READY } from "../src/rpc/channels.ts";
-import { startSubagentRpcServer } from "../src/rpc/client.ts";
-import {
-	clearSubagentResultAnimation,
-	ensureSubagentResultAnimation,
-} from "../src/render-animation.ts";
-import {
-	renderSubagentCall,
-	renderSubagentResult,
-	subagentResultIsRunning,
-	renderWaitCall,
-	renderWaitResult,
-} from "../src/render.ts";
-import { SubagentParams, WaitParams } from "../src/schema.ts";
-import type { ExecuteSubagentInput, WaitInput } from "../src/types.ts";
-
-export interface SubagentsTestHarness {
-	handlers: {
-		session_start?: (event: unknown, ctx: ExtensionContext) => void;
-		session_shutdown?: (event: unknown, ctx: ExtensionContext) => void;
-	};
-	runtime?: SubagentRuntime;
-}
-
-export function registerSubagents(
-	pi: ExtensionAPI,
-): SubagentsTestHarness {
-	const handlers: SubagentsTestHarness["handlers"] = {};
-	let currentCtx: ExtensionContext | null = null;
-	let rpcDispose: (() => void) | null = null;
-
-	const runtime = createSubagentRuntime({
-		getContext: () => currentCtx,
-		events: pi.events,
-	}) as SubagentRuntime & { _restore(sessionFile: string | null): void };
-
-	pi.registerTool({
-		name: "subagent",
-		label: "Subagent",
-		description:
-			"Delegate tasks to specialized subagents. Modes: single (agent+task), parallel (tasks[]), chain (chain[] with {previous}). Use async:true for background runs.",
-		parameters: SubagentParams,
-		async execute(_toolCallId, params, signal, onUpdate, ctx) {
-			currentCtx = ctx;
-			return runtime.execute(params as ExecuteSubagentInput, {
-				signal,
-				onUpdate: onUpdate
-					? (partial) => onUpdate(partial)
-					: undefined,
-			});
-		},
-		renderCall(args, theme) {
-			return renderSubagentCall(args as Record<string, unknown>, theme);
-		},
-		renderResult(result, options, theme, context) {
-			if (subagentResultIsRunning(
-				result as {
-					content: Array<{ type: string; text?: string }>;
-					details?: import("../src/types.ts").SubagentDetails;
-				},
-				options,
-			)) {
-				ensureSubagentResultAnimation(context);
-			} else {
-				clearSubagentResultAnimation(context);
-			}
-			return renderSubagentResult(
-				result as {
-					content: Array<{ type: string; text?: string }>;
-					details?: import("../src/types.ts").SubagentDetails;
-				},
-				options,
-				theme,
-				context,
-			);
-		},
-	});
-
-	pi.registerTool({
-		name: "wait",
-		label: "Wait",
-		description:
-			"Block until background subagent runs finish. Default returns when the first run completes; use all:true to wait for every active run.",
-		parameters: WaitParams,
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			currentCtx = ctx;
-			const outcome = await runtime.wait(params as WaitInput);
-			const summaries = outcome.completed.map((run) => {
-				const status = run.state;
-				const output = run.finalOutput ?? "(no output)";
-				return `- ${run.id} [${run.agents.join(", ")}] ${status}: ${output}`;
-			});
-			const header = outcome.timedOut
-				? `Wait timed out (${outcome.activeRemaining} still active).`
-				: `Wait complete (${outcome.completed.length} run(s)).`;
-			return {
-				content: [
-					{
-						type: "text",
-						text: `${header}\n${summaries.join("\n") || "(none)"}`,
-					},
-				],
-				details: outcome,
-			};
-		},
-		renderCall(args, theme) {
-			return renderWaitCall(args as Record<string, unknown>, theme);
-		},
-		renderResult(result, _options, theme) {
-			return renderWaitResult(
-				result as { content: Array<{ type: string; text?: string }> },
-				theme,
-			);
-		},
-	});
-
-	handlers.session_start = (_event, ctx) => {
-		currentCtx = ctx;
-		if (!process.env[SUBAGENT_CHILD_ENV]) {
-			const sessionId = ctx.sessionManager.getSessionId?.();
-			if (sessionId) {
-				process.env[SUBAGENT_PARENT_SESSION_ENV] = sessionId;
-			}
-		}
-		const sessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
-		(runtime as SubagentRuntime & { _restore(sessionFile: string | null): void })._restore(
-			sessionFile,
-		);
-		rpcDispose?.();
-		rpcDispose = startSubagentRpcServer(pi.events, runtime);
-		pi.events.emit(SUBAGENTS_READY, { version: 1 });
-	};
-
-	pi.on("session_start", handlers.session_start);
-
-	handlers.session_shutdown = () => {
-		delete process.env[SUBAGENT_PARENT_SESSION_ENV];
-		rpcDispose?.();
-		rpcDispose = null;
-		currentCtx = null;
-	};
-
-	pi.on("session_shutdown", handlers.session_shutdown);
-
-	return { handlers, runtime };
-}
-
-export default function subagentsExtension(pi: ExtensionAPI) {
-	if (process.env[SUBAGENT_CHILD_ENV] === "1") {
-		return;
-	}
-	registerSubagents(pi);
-}
+/**
+ * @vitos-pizza/subagents — subprocess subagent delegation for Vito's Pizzeria.
+ */
+
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "../src/env.ts";
+import { createSubagentRuntime } from "../src/runtime.ts";
+import type { SubagentRuntime } from "../src/runtime.ts";
+import { SUBAGENTS_READY } from "../src/rpc/channels.ts";
+import { startSubagentRpcServer } from "../src/rpc/client.ts";
+import {
+	clearSubagentResultAnimation,
+	ensureSubagentResultAnimation,
+} from "../src/render-animation.ts";
+import {
+	renderSubagentCall,
+	renderSubagentResult,
+	subagentResultIsRunning,
+	renderWaitCall,
+	renderWaitResult,
+} from "../src/render.ts";
+import { SubagentParams, WaitParams } from "../src/schema.ts";
+import type { ExecuteSubagentInput, WaitInput } from "../src/types.ts";
+
+export interface SubagentsTestHarness {
+	handlers: {
+		session_start?: (event: unknown, ctx: ExtensionContext) => void;
+		session_shutdown?: (event: unknown, ctx: ExtensionContext) => void;
+	};
+	runtime?: SubagentRuntime;
+}
+
+export function registerSubagents(
+	pi: ExtensionAPI,
+): SubagentsTestHarness {
+	const handlers: SubagentsTestHarness["handlers"] = {};
+	let currentCtx: ExtensionContext | null = null;
+	let rpcDispose: (() => void) | null = null;
+
+	const runtime = createSubagentRuntime({
+		getContext: () => currentCtx,
+		events: pi.events,
+	}) as SubagentRuntime & { _restore(sessionFile: string | null): void };
+
+	pi.registerTool({
+		name: "subagent",
+		label: "Subagent",
+		description:
+			"Delegate tasks to specialized subagents. Modes: single (agent+task), parallel (tasks[]), chain (chain[] with {previous}). Use async:true for background runs.",
+		parameters: SubagentParams,
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			currentCtx = ctx;
+			return runtime.execute(params as ExecuteSubagentInput, {
+				signal,
+				onUpdate: onUpdate
+					? (partial) => onUpdate(partial)
+					: undefined,
+			});
+		},
+		renderCall(args, theme) {
+			return renderSubagentCall(args as Record<string, unknown>, theme);
+		},
+		renderResult(result, options, theme, context) {
+			if (subagentResultIsRunning(
+				result as {
+					content: Array<{ type: string; text?: string }>;
+					details?: import("../src/types.ts").SubagentDetails;
+				},
+				options,
+			)) {
+				ensureSubagentResultAnimation(context);
+			} else {
+				clearSubagentResultAnimation(context);
+			}
+			return renderSubagentResult(
+				result as {
+					content: Array<{ type: string; text?: string }>;
+					details?: import("../src/types.ts").SubagentDetails;
+				},
+				options,
+				theme,
+				context,
+			);
+		},
+	});
+
+	pi.registerTool({
+		name: "wait",
+		label: "Wait",
+		description:
+			"Block until background subagent runs finish. Default returns when the first run completes; use all:true to wait for every active run.",
+		parameters: WaitParams,
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			currentCtx = ctx;
+			const outcome = await runtime.wait(params as WaitInput);
+			const summaries = outcome.completed.map((run) => {
+				const status = run.state;
+				const output = run.finalOutput ?? "(no output)";
+				return `- ${run.id} [${run.agents.join(", ")}] ${status}: ${output}`;
+			});
+			const header = outcome.timedOut
+				? `Wait timed out (${outcome.activeRemaining} still active).`
+				: `Wait complete (${outcome.completed.length} run(s)).`;
+			return {
+				content: [
+					{
+						type: "text",
+						text: `${header}\n${summaries.join("\n") || "(none)"}`,
+					},
+				],
+				details: outcome,
+			};
+		},
+		renderCall(args, theme) {
+			return renderWaitCall(args as Record<string, unknown>, theme);
+		},
+		renderResult(result, _options, theme) {
+			return renderWaitResult(
+				result as { content: Array<{ type: string; text?: string }> },
+				theme,
+			);
+		},
+	});
+
+	handlers.session_start = (_event, ctx) => {
+		currentCtx = ctx;
+		if (!process.env[SUBAGENT_CHILD_ENV]) {
+			const sessionId = ctx.sessionManager.getSessionId?.();
+			if (sessionId) {
+				process.env[SUBAGENT_PARENT_SESSION_ENV] = sessionId;
+			}
+		}
+		const sessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
+		(runtime as SubagentRuntime & { _restore(sessionFile: string | null): void })._restore(
+			sessionFile,
+		);
+		rpcDispose?.();
+		rpcDispose = startSubagentRpcServer(pi.events, runtime);
+		pi.events.emit(SUBAGENTS_READY, { version: 1 });
+	};
+
+	pi.on("session_start", handlers.session_start);
+
+	handlers.session_shutdown = () => {
+		delete process.env[SUBAGENT_PARENT_SESSION_ENV];
+		rpcDispose?.();
+		rpcDispose = null;
+		currentCtx = null;
+	};
+
+	pi.on("session_shutdown", handlers.session_shutdown);
+
+	return { handlers, runtime };
+}
+
+export default function subagentsExtension(pi: ExtensionAPI) {
+	if (process.env[SUBAGENT_CHILD_ENV] === "1") {
+		return;
+	}
+	registerSubagents(pi);
+}

package/packages/subagents/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/subagents",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "Subagent delegation for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",

package/packages/subagents/skills/subagents/SKILL.md

@@ -1,80 +1,86 @@
----
-name: subagents
-description: Delegate exploration, planning, and implementation to Vito's Pizzeria subagents (scout, planner, worker).
----
-
-# Subagents (Vito's Pizzeria)
-
-Use the `subagent` tool to delegate work to focused child agents with isolated context.
-
-## Agent modes
-
-Vito's Pizzeria uses three modes via `/mode` or `F6`:
-
-| Mode | When to use |
-|------|-------------|
-| **agent** | Default balanced work |
-| **plan** | Read-only exploration — scout → planner, `question` for clarification |
-| **execute** | Full implementation after plan is approved |
-
-In **plan** mode the main agent cannot write/edit/bash. Delegate with subagents:
-
-```
-scout → planner → (user confirms) → switch to execute → worker
-```
-
-## Built-in agents
-
-| Agent | Use when |
-|-------|----------|
-| `scout` | Fast codebase recon; returns compressed context |
-| `planner` | Turn context + requirements into an implementation plan |
-| `worker` | Execute an approved plan with narrow, correct edits |
-| `title` | Generate short session titles (used by `@vitos-pizza/session-title`) |
-
-## Typical workflow
-
-```
-scout → planner → worker
-```
-
-### Chain (one tool call)
-
-```json
-{
-  "chain": [
-    { "agent": "scout", "task": "Map the auth module and key entry points" },
-    { "agent": "planner", "task": "Create a plan based on {previous}" },
-    { "agent": "worker", "task": "Implement the plan from {previous}" }
-  ]
-}
-```
-
-### Parallel
-
-```json
-{
-  "tasks": [
-    { "agent": "scout", "task": "Scan packages/subagents" },
-    { "agent": "scout", "task": "Scan packages/permission-system" }
-  ]
-}
-```
-
-### Async + wait
-
-Start work in the background, then block until it finishes:
-
-```json
-{ "agent": "worker", "task": "...", "async": true }
-```
-
-```json
-{ "id": "<runId>" }
-```
-
-via the `wait` tool.
-
-## External modules
-
-Other Vito's Pizzeria extensions can request subagent runs via `pi.events` RPC (`subagents:rpc:run`). Import helpers from `@vitos-pizza/subagents/rpc/client` if needed.
+---
+name: subagents
+description: Delegate exploration, planning, and implementation to Vito's Pizzeria subagents (scout, planner, worker).
+---
+
+# Subagents (Vito's Pizzeria)
+
+Use the `subagent` tool to delegate work to focused child agents with isolated context.
+
+## Agent modes
+
+Vito's Pizzeria uses three modes via `/mode` or `F6`:
+
+| Mode | When to use |
+|------|-------------|
+| **agent** | Default balanced work |
+| **plan** | Read-only planning — planner (+ optional scout), `question` for clarification; optional short **Next** footer |
+| **execute** | Full implementation after plan is approved |
+
+In **plan** mode the main agent cannot write/edit/bash. Delegate with subagents. Scout is optional — use it only when codebase recon is needed; otherwise call planner directly. When recon spans independent areas, run multiple scouts in parallel (`tasks: [...]`) then planner:
+
+```
+[optional scout(s) →] planner → (user confirms) → switch to execute → worker
+```
+
+## Built-in agents
+
+| Agent | Use when |
+|-------|----------|
+| `scout` | Fast codebase recon; returns compressed context |
+| `planner` | Turn context + requirements into an implementation plan |
+| `worker` | Execute an approved plan with narrow, correct edits |
+| `title` | Generate short session titles (used by `@vitos-pizza/session-title`) |
+
+## Typical workflow
+
+```
+[optional scout →] planner → worker
+```
+
+### Planner only (enough context)
+
+```json
+{ "agent": "planner", "task": "Create an implementation plan for ..." }
+```
+
+### Chain with scout (when recon is needed)
+
+```json
+{
+  "chain": [
+    { "agent": "scout", "task": "Map the auth module and key entry points" },
+    { "agent": "planner", "task": "Create a plan based on {previous}" },
+    { "agent": "worker", "task": "Implement the plan from {previous}" }
+  ]
+}
+```
+
+### Parallel
+
+```json
+{
+  "tasks": [
+    { "agent": "scout", "task": "Scan packages/subagents" },
+    { "agent": "scout", "task": "Scan packages/permission-system" }
+  ]
+}
+```
+
+### Async + wait
+
+Start work in the background, then block until it finishes:
+
+```json
+{ "agent": "worker", "task": "...", "async": true }
+```
+
+```json
+{ "id": "<runId>" }
+```
+
+via the `wait` tool.
+
+## External modules
+
+Other Vito's Pizzeria extensions can request subagent runs via `pi.events` RPC (`subagents:rpc:run`). Import helpers from `@vitos-pizza/subagents/rpc/client` if needed.