pi-crew 0.5.1 → 0.5.2

package/src/extension/plan-orchestrate.ts

@@ -0,0 +1,322 @@
+/**
+ * Plan Orchestrate — Decompose plan documents into agent chain commands.
+ *
+ * Parses tagged sections from markdown plan documents and builds commands
+ * for sequential agent chain execution based on ECC recommendations.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/**
+ * Tag → Agent chain mapping from ECC recommendations.
+ */
+export const TAG_TO_CHAIN: Record<string, string[]> = {
+	design: ["planner", "architect"],
+	impl: ["tdd-guide", "lang-reviewer"],
+	security: ["security-reviewer", "lang-reviewer"],
+	build: ["build-error-resolver"],
+	test: ["test-engineer", "verifier"],
+	review: ["reviewer"],
+} as const;
+
+/**
+ * Options for plan orchestration.
+ */
+export interface OrchestrateOptions {
+	/** Path to the plan markdown document. */
+	planPath: string;
+}
+
+/**
+ * A single orchestrated step parsed from a plan section.
+ */
+export interface OrchestratedStep {
+	/** Unique step identifier. */
+	stepId: string;
+	/** Tag from the parsed section. */
+	tag: string;
+	/** Agent chain for this step. */
+	chain: string[];
+	/** Prompt/goal text extracted from the section. */
+	prompt: string;
+	/** Raw heading text if present. */
+	heading?: string;
+}
+
+/**
+ * Parse tagged sections from a plan markdown document.
+ *
+ * Expected format:
+ * ```markdown
+ * # Design Phase
+ * <!-- tag: design -->
+ * Design the authentication system...
+ *
+ * # Implementation
+ * <!-- tag: impl -->
+ * Implement the JWT auth...
+ * ```
+ *
+ * @param planPath - Path to the plan markdown document.
+ * @returns Array of OrchestratedStep parsed from the document.
+ */
+export function parsePlanDocument(planPath: string): OrchestratedStep[] {
+	if (!fs.existsSync(planPath)) {
+		throw new Error(`Plan document not found: ${planPath}`);
+	}
+
+	const content = fs.readFileSync(planPath, "utf-8");
+	return parsePlanDocumentContent(content);
+}
+
+/**
+ * Parse tagged sections from plan content string.
+ * This is the core parsing logic used by both parsePlanDocument and parsePlanDocumentSimple.
+ */
+function parsePlanDocumentContent(content: string): OrchestratedStep[] {
+	const steps: OrchestratedStep[] = [];
+
+	// Find all tag matches with their positions
+	const tagRegex = /<!--\s*tag:\s*(\w+)\s*-->/g;
+	const tagMatches: Array<{ tag: string; start: number; end: number }> = [];
+
+	let match: RegExpExecArray | null;
+	while ((match = tagRegex.exec(content)) !== null) {
+		tagMatches.push({
+			tag: match[1],
+			start: match.index,
+			end: match.index + match[0].length,
+		});
+	}
+
+	if (tagMatches.length === 0) {
+		return [];
+	}
+
+	// For each tag, extract the content before it (to get heading)
+	// and the content after it until either another tag or section
+	for (let i = 0; i < tagMatches.length; i++) {
+		const current = tagMatches[i];
+		const nextTagStart = i < tagMatches.length - 1 ? tagMatches[i + 1].start : content.length;
+
+		// Find the heading by looking back from the tag position.
+		// Use global regex to find ALL headings in the window, then take the LAST
+		// (nearest to the tag) — simple `.match()` only finds the FIRST heading.
+		const textBeforeTag = content.slice(
+			Math.max(0, current.start - 500),
+			current.start,
+		);
+		const headingRegex = /(^|\n)(#{1,6})\s+(.+?)(\n|$)/g;
+		let lastHeadingMatch: RegExpExecArray | null = null;
+		let hm: RegExpExecArray | null;
+		while ((hm = headingRegex.exec(textBeforeTag)) !== null) {
+			lastHeadingMatch = hm;
+		}
+		const heading = lastHeadingMatch ? lastHeadingMatch[3].trim() : undefined;
+
+		// Get content after the tag until next tag or heading
+		// Start from end of tag comment, skip any whitespace/newline
+		const afterTagContent = content.slice(current.end);
+
+		// Find the section content: capture until next heading (##) or next tag
+		const sectionEndMatch = afterTagContent.search(/(^|\n)(#{1,6}\s|\n<!--\s*tag:)/m);
+		const sectionContent =
+			sectionEndMatch >= 0
+				? afterTagContent.slice(0, sectionEndMatch)
+				: afterTagContent;
+
+		// Extract prompt text - remove the tag comment lines and empty lines
+		const promptLines: string[] = [];
+		const lines = sectionContent.split("\n");
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("<!--")) continue;
+			promptLines.push(trimmed);
+		}
+
+		const prompt = promptLines.join("\n").trim();
+		if (!prompt) continue;
+
+		const chain = TAG_TO_CHAIN[current.tag] ?? [];
+
+		steps.push({
+			stepId: `step-${(i + 1).toString().padStart(2, "0")}-${current.tag}`,
+			tag: current.tag,
+			chain,
+			prompt,
+			heading,
+		});
+	}
+
+	return steps;
+}
+
+/**
+ * Alternative simpler parser for plans that use explicit tag blocks.
+ * Actually uses the same core logic as parsePlanDocument.
+ *
+ * @param planPath - Path to the plan markdown document.
+ * @returns Array of OrchestratedStep parsed from the document.
+ */
+export function parsePlanDocumentSimple(planPath: string): OrchestratedStep[] {
+	if (!fs.existsSync(planPath)) {
+		throw new Error(`Plan document not found: ${planPath}`);
+	}
+
+	const content = fs.readFileSync(planPath, "utf-8");
+	const steps = parsePlanDocumentContent(content);
+
+	if (steps.length === 0) {
+		// Try implicit detection
+		const tag = detectImplicitTag(content);
+		if (tag) {
+			return [
+				{
+					stepId: "step-01-unknown",
+					tag,
+					chain: TAG_TO_CHAIN[tag] ?? [],
+					prompt: content.trim(),
+				},
+			];
+		}
+	}
+
+	return steps;
+}
+
+/**
+ * Detect implicit tag from content keywords when no explicit tag is present.
+ */
+function detectImplicitTag(content: string): string | undefined {
+	const lowerContent = content.toLowerCase();
+	// Use word-boundary regex to avoid substring false matches.
+	// E.g., "implementation" must NOT trigger "impl" — only the word "implement" should.
+	const hasWord = (word: string): boolean =>
+		new RegExp(`\\b${word}\\b`).test(lowerContent);
+
+	if (hasWord("design") || hasWord("architecture")) return "design";
+	if (hasWord("implement") || hasWord("coding")) return "impl";
+	if (hasWord("security") || hasWord("audit")) return "security";
+	if (hasWord("build") || hasWord("compile")) return "build";
+	if (hasWord("test") || hasWord("verify")) return "test";
+	if (hasWord("review") || hasWord("feedback")) return "review";
+	return undefined;
+}
+
+/**
+ * Build agent chain command strings from orchestrated steps.
+ *
+ * @param steps - Array of OrchestratedStep to convert to commands.
+ * @returns Array of command strings for execution.
+ */
+export function buildAgentChain(steps: OrchestratedStep[]): string[] {
+	return steps.map((step) => {
+		const agentList = step.chain.join(",");
+		// Escape single quotes in the goal for shell safety
+		const escapedGoal = step.prompt.replace(/'/g, "'\\''");
+		return `team action='run' agent='${agentList}' goal='${escapedGoal}'`;
+	});
+}
+
+/**
+ * Build structured chain data (useful for programmatic use).
+ *
+ * @param steps - Array of OrchestratedStep to convert.
+ * @returns Array of chain objects with step data and commands.
+ */
+export function buildChainData(
+	steps: OrchestratedStep[],
+): Array<{
+	step: OrchestratedStep;
+	commands: string[];
+}> {
+	return steps.map((step) => ({
+		step,
+		commands: buildAgentChain([step]),
+	}));
+}
+
+/**
+ * Parse and return a formatted overview of the plan.
+ *
+ * @param planPath - Path to the plan markdown document.
+ * @returns Summary string with step count and breakdown by tag.
+ */
+export function formatPlanOverview(planPath: string): string {
+	const steps = parsePlanDocument(planPath);
+
+	if (steps.length === 0) {
+		// Try simple parser
+		const simpleSteps = parsePlanDocumentSimple(planPath);
+		if (simpleSteps.length === 0) {
+			return "No tagged sections found in plan document.";
+		}
+		return formatStepsOverview(simpleSteps);
+	}
+
+	return formatStepsOverview(steps);
+}
+
+function formatStepsOverview(steps: OrchestratedStep[]): string {
+	const lines: string[] = [
+		`Plan Orchestration: ${steps.length} step(s)`,
+		"",
+	];
+
+	const tagCounts: Record<string, number> = {};
+	for (const step of steps) {
+		tagCounts[step.tag] = (tagCounts[step.tag] ?? 0) + 1;
+	}
+
+	lines.push("Summary by tag:");
+	for (const [tag, count] of Object.entries(tagCounts)) {
+		const chain = TAG_TO_CHAIN[tag]?.join(", ") ?? "(unknown)";
+		lines.push(`  - ${tag}: ${count} step(s) → agents: ${chain}`);
+	}
+
+	lines.push("", "Steps:");
+	for (const step of steps) {
+		const preview =
+			step.prompt.length > 60
+				? step.prompt.slice(0, 60) + "..."
+				: step.prompt;
+		// Include heading if available (e.g., "Security Review" from the plan's heading)
+		const headingPrefix = step.heading ? `${step.heading}: ` : "";
+		lines.push(
+			`  ${step.stepId} [${step.tag}] ${step.chain.join(",")}: ${headingPrefix}${preview}`,
+		);
+	}
+
+	return lines.join("\n");
+}
+
+/**
+ * Main orchestration function that parses a plan and returns pre-formatted output.
+ */
+export async function orchestratePlan(
+	options: OrchestrateOptions,
+): Promise<{
+	steps: OrchestratedStep[];
+	chain: string[];
+	overview: string;
+}> {
+	const { planPath } = options;
+
+	// Try primary parser first
+	let steps = parsePlanDocument(planPath);
+
+	// Fall back to simple parser if no results
+	if (steps.length === 0) {
+		steps = parsePlanDocumentSimple(planPath);
+	}
+
+	if (steps.length === 0) {
+		throw new Error(`No tagged sections found in plan document: ${planPath}`);
+	}
+
+	const chain = buildAgentChain(steps);
+	const overview = formatPlanOverview(planPath);
+
+	return { steps, chain, overview };
+}

package/src/extension/register.ts

@@ -4,8 +4,9 @@ import { fileURLToPath } from "node:url";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 import { loadConfig } from "../config/config.ts";
+import { applyCrewSettingsToConfig, loadCrewSettings, saveCrewSettings } from "../runtime/settings-store.ts";
 // 2.7: Lazy-load LiveRunSidebar — only constructed when the user actually opens
 // a live run sidebar overlay. The class pulls in transcript-viewer and other
 // heavy UI modules.
@@ -50,10 +51,6 @@ import { listLiveAgents } from "../runtime/live-agent-manager.ts";
 import { createManifestCache } from "../runtime/manifest-cache.ts";
 import { checkProcessLiveness } from "../runtime/process-status.ts";
 import { CrewScheduler } from "../runtime/scheduler.ts";
-import {
-	applyCrewSettingsToConfig,
-	loadCrewSettings,
-} from "../runtime/settings-store.ts";
 import { appendEvent } from "../state/event-log.ts";
 import { loadRunManifestById, updateRunStatus } from "../state/state-store.ts";
 import type { TeamRunManifest } from "../state/types.ts";
@@ -109,6 +106,7 @@ import {
 } from "./registration/subagent-helpers.ts";
 import { registerSubagentTools } from "./registration/subagent-tools.ts";
 import { registerTeamTool } from "./registration/team-tool.ts";
+import { handleTeamTool } from "./team-tool.ts";
 
 let _cachedOTLPExporter: typeof OTLPExporterType | undefined;
 async function importOTLPExporter(): Promise<typeof OTLPExporterType> {
@@ -916,34 +914,6 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 							});
 						}
 					}
-					// Always send followUp notification regardless of ownerCurrent.
-					// The run completed — the assistant needs to know even if the
-					// originating session generation has changed (compaction, etc.).
-					if (runId) {
-						const loaded = loadRunManifestById(ctx.cwd, runId);
-						const status = loaded?.manifest.status ?? "finished";
-						const teamName = loaded?.manifest.team ?? "unknown";
-						const goalSummary = (loaded?.manifest.goal ?? "").slice(
-							0,
-							100,
-						);
-						try {
-							pi.sendUserMessage(
-								[
-									`pi-crew run ${status}: ${runId} (${teamName})`,
-									`Goal: ${goalSummary}`,
-									status === "completed"
-										? "Review the run results. If the run modified source files, run tests to verify. Summarize what was done."
-										: "The run ended with status: " +
-											status +
-											". Check the run artifacts and take appropriate action.",
-								].join("\n"),
-								{ deliverAs: "followUp" },
-							);
-						} catch {
-							/* non-critical */
-						}
-					}
 					if (ownerCurrent && currentCtx) {
 						const config = loadConfig(currentCtx.cwd).config.ui;
 						updateCrewWidget(
@@ -1325,18 +1295,43 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		applyCrewSettingsToConfig(loadedConfig.config, crewSettings);
 
 		// Start scheduler with event-based executor
+		// Resolve sessionId before the scheduler executor closure captures it.
+		const sessionId =
+			ctx.sessionManager?.getSessionId?.() ??
+			(typeof ctx === "object" && ctx !== null && "sessionId" in ctx
+				? (ctx as Record<string, unknown>).sessionId
+				: undefined);
 		crewScheduler = new CrewScheduler();
 		crewScheduler.start({
 			emit: (event) => {
 				if (cleanedUp) return;
+				pi.events?.emit?.("crew-scheduler", event);
 			},
 			executor: (job) => {
+				let runParams: { action: string; team: string; goal: string };
+				try {
+					runParams = JSON.parse(job.prompt);
+				} catch {
+					runParams = { action: "run", team: "default", goal: job.prompt };
+				}
+				if (runParams.action !== "run") return `scheduled-${job.id}-${Date.now()}`;
+				setImmediate(async () => {
+					try {
+						await handleTeamTool(
+							{ action: "run", team: runParams.team, goal: runParams.goal, async: true },
+							{ cwd: ctx.cwd, sessionId },
+						);
+					} catch (err) {
+						logInternalError("scheduler.execute", err);
+					}
+				});
 				return `scheduled-${job.id}-${Date.now()}`;
 			},
-			finalizer: (_jobId, _agentId) => {
-				// no-op for now; future: launch team run
-			},
+			finalizer: () => {},
 		});
+		// Wire scheduler into handle-schedule.ts so handlers can add/list jobs.
+		// Uses a global symbol so the module doesn't need a direct circular import.
+		(globalThis as Record<symbol | string, unknown>)[Symbol.for("pi-crew:scheduler")] = crewScheduler;
 		// Load scheduled jobs from settings if present
 		if (Array.isArray((crewSettings as any).scheduledJobs)) {
 			for (const job of (crewSettings as any).scheduledJobs) {
@@ -1351,11 +1346,6 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		configureNotifications(ctx);
 		configureObservability(ctx);
 		configureDeliveryCoordinator();
-		const sessionId =
-			ctx.sessionManager?.getSessionId?.() ??
-			(typeof ctx === "object" && ctx !== null && "sessionId" in ctx
-				? (ctx as Record<string, unknown>).sessionId
-				: undefined);
 		if (typeof sessionId === "string" && sessionId)
 			deliveryCoordinator?.activate(sessionId);
 		tryRegisterSessionCleanup(pi, () => {

package/src/extension/registration/command-utils.ts

@@ -1,4 +1,4 @@
-import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 
 export function parseRunArgs(args: string): TeamToolParamsValue {

package/src/extension/registration/commands.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { loadConfig } from "../../config/config.ts";
 // Lazy-loaded: team-tool.ts pulls in entire runtime chain (1.4s+).
 import type { handleTeamTool as HandleTeamToolFn } from "../team-tool.ts";

package/src/extension/registration/compaction-guard.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { listRecentRuns } from "../run-index.ts";
 import type { ArtifactDescriptor, TeamRunManifest } from "../../state/types.ts";
 

package/src/extension/registration/subagent-helpers.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { loadRunManifestById } from "../../state/state-store.ts";
 import { savePersistedSubagentRecord, type SubagentRecord, type SubagentSpawnOptions } from "../../subagents/manager.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";

package/src/extension/registration/subagent-tools.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 // Lazy-loaded: team-tool.ts pulls in entire runtime chain.

package/src/extension/registration/team-tool.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { loadConfig } from "../../config/config.ts";
 import { TeamToolParams, type TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import type { CrewWidgetState } from "../../ui/crew-widget.ts";

package/src/extension/registration/viewers.ts

@@ -1,4 +1,4 @@
-import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { loadRunManifestById } from "../../state/state-store.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { loadConfig } from "../../config/config.ts";

package/src/extension/session-summary.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
 import { listRuns } from "./run-index.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";

package/src/extension/team-manager-command.ts

@@ -1,4 +1,4 @@
-import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { listRuns } from "./run-index.ts";
 // Lazy-loaded: team-tool.ts pulls in entire runtime chain.
 import type { handleTeamTool as HandleTeamToolFn } from "./team-tool.ts";

package/src/extension/team-tool/context.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { PiTeamsConfig } from "../../config/config.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
 import type { TeamToolDetails } from "../team-tool-types.ts";