pi-crew 0.5.1 → 0.5.2

package/src/extension/team-tool/handle-schedule.ts

@@ -0,0 +1,183 @@
+import * as crypto from "node:crypto";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { result, type TeamContext } from "./context.ts";
+import { humanizeSchedule, nextRunTime, parseSchedule } from "../../runtime/scheduler.ts";
+import { loadConfig } from "../../config/config.ts";
+import { loadCrewSettings, saveCrewSettings } from "../../runtime/settings-store.ts";
+
+// Global key for cross-module scheduler access.
+const CREW_SCHEDULER_KEY = Symbol.for("pi-crew:scheduler");
+type SchedulerRef = { add(job: import("../../runtime/scheduler.ts").ScheduledJob): void; list(): import("../../runtime/scheduler.ts").ScheduledJob[] };
+
+function getCrewScheduler(): SchedulerRef | undefined {
+	return (globalThis as Record<symbol | string, unknown>)[CREW_SCHEDULER_KEY] as SchedulerRef | undefined;
+}
+
+export function registerCrewScheduler(scheduler: SchedulerRef): void {
+	(globalThis as Record<symbol | string, unknown>)[CREW_SCHEDULER_KEY] = scheduler;
+}
+
+interface ScheduleParams {
+	team?: string;
+	goal?: string;
+	task?: string;
+	cron?: string;
+	interval?: number;
+	once?: number | string;
+}
+
+function buildScheduleSpec(params: ScheduleParams): {
+	spec: import("../../runtime/scheduler.ts").ScheduleSpec;
+	schedule: string;
+	scheduleType: import("../../runtime/scheduler.ts").ScheduleType;
+	intervalMs?: number;
+} {
+	// Priority: cron > interval > once
+	if (params.cron) {
+		const parsed = parseSchedule(params.cron);
+		if ("error" in parsed) throw new Error(parsed.error);
+		return { spec: parsed, schedule: params.cron, scheduleType: "cron" as const };
+	}
+	if (params.interval !== undefined && params.interval > 0) {
+		const specStr = `${params.interval}ms`;
+		const spec = parseSchedule(specStr);
+		if ("error" in spec) throw new Error(spec.error);
+		return { spec, schedule: specStr, scheduleType: "interval" as const, intervalMs: params.interval };
+	}
+	if (params.once !== undefined) {
+		const ts = typeof params.once === "number" ? new Date(params.once).toISOString() : params.once;
+		const parsed = parseSchedule(ts);
+		if ("error" in parsed) throw new Error(parsed.error);
+		return { spec: parsed, schedule: ts, scheduleType: "once" as const };
+	}
+	throw new Error("schedule requires one of: cron, interval, or once.");
+}
+
+export function handleSchedule(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	const team = params.team ?? "default";
+	const goal = params.goal ?? params.task ?? "";
+	if (!goal) return result("Schedule requires goal or task.", { action: "schedule", status: "error" }, true);
+
+	let specResult: ReturnType<typeof buildScheduleSpec>;
+	try {
+		specResult = buildScheduleSpec({
+			team,
+			goal,
+			cron: params.cron,
+			interval: params.interval,
+			once: params.once as ScheduleParams["once"],
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		return result(msg, { action: "schedule", status: "error" }, true);
+	}
+
+	const { spec, schedule, scheduleType, intervalMs } = specResult;
+	const next = nextRunTime(spec);
+	if ("error" in next) return result(next.error, { action: "schedule", status: "error" }, true);
+
+	// Build the ScheduledJob
+	const job: import("../../runtime/scheduler.ts").ScheduledJob = {
+		id: crypto.randomUUID(),
+		name: `${team}: ${goal.slice(0, 60)}`,
+		description: `Scheduled run for team '${team}'`,
+		schedule,
+		scheduleType,
+		intervalMs,
+		subagentType: "team",
+		prompt: JSON.stringify({ action: "run", team, goal }),
+		enabled: true,
+		createdAt: new Date().toISOString(),
+		nextRun: next.toISOString(),
+		runCount: 0,
+	};
+
+	const scheduler = getCrewScheduler();
+	if (!scheduler) {
+		// Persist even if scheduler isn't running yet — register.ts loads them on startup.
+		persistScheduledJob(ctx.cwd, job);
+		return result(
+			[
+				`Scheduled job created (scheduler not yet running — will activate on next session start):`,
+				`  Job ID: ${job.id}`,
+				`  Team: ${team}`,
+				`  Goal: ${goal}`,
+				`  Schedule: ${humanizeSchedule(spec)}`,
+				`  Next run: ${next.toISOString()}`,
+			].join("\n"),
+			{
+				action: "schedule",
+				status: "ok",
+				data: {
+					jobId: job.id,
+					team,
+					goal,
+					schedule: humanizeSchedule(spec),
+					nextRun: next.toISOString(),
+					pending: true,
+				},
+			},
+		);
+	}
+
+	scheduler.add(job);
+	persistScheduledJob(ctx.cwd, job);
+
+	return result(
+		[
+			`Scheduled job registered.`,
+			`  Job ID: ${job.id}`,
+			`  Team: ${team}`,
+			`  Goal: ${goal}`,
+			`  Schedule: ${humanizeSchedule(spec)}`,
+			`  Next run: ${next.toISOString()}`,
+		].join("\n"),
+		{
+			action: "schedule",
+			status: "ok",
+			data: {
+				jobId: job.id,
+				team,
+				goal,
+				schedule: humanizeSchedule(spec),
+				nextRun: next.toISOString(),
+			},
+		},
+	);
+}
+
+function persistScheduledJob(cwd: string, job: import("../../runtime/scheduler.ts").ScheduledJob): void {
+	try {
+		const settings = loadCrewSettings(cwd);
+		const existingJobs: import("../../runtime/scheduler.ts").ScheduledJob[] = Array.isArray(
+			(settings as Record<string, unknown>).scheduledJobs,
+		)
+			? ((settings as Record<string, unknown>).scheduledJobs as import("../../runtime/scheduler.ts").ScheduledJob[])
+			: [];
+		saveCrewSettings(
+			{ ...settings, scheduledJobs: [...existingJobs, job] } as Parameters<typeof saveCrewSettings>[0],
+			cwd,
+		);
+	} catch {
+		/* best-effort persistence */
+	}
+}
+
+export function handleListScheduled(_params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	const scheduler = getCrewScheduler();
+	if (!scheduler) return result("Scheduler not running.", { action: "scheduled", status: "error" }, true);
+	const jobs = scheduler.list();
+	if (jobs.length === 0) return result("No scheduled jobs.", { action: "scheduled", status: "ok" });
+	const lines: string[] = [`Scheduled jobs (${jobs.length}):`];
+	for (const job of jobs) {
+		lines.push(
+			`  [${job.id}] ${job.name}`,
+			`    Schedule: ${job.schedule} (${job.scheduleType})`,
+			`    Enabled: ${job.enabled}`,
+			`    Next run: ${job.nextRun ?? "(unscheduled)"}`,
+			`    Runs: ${job.runCount}, Last: ${job.lastRun ?? "(never)"} [${job.lastStatus ?? "?"}]`,
+		);
+	}
+	return result(lines.join("\n"), { action: "scheduled", status: "ok" });
+}

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

@@ -0,0 +1,102 @@
+/**
+ * Handler for `team action='orchestrate' planPath='/path/to/plan.md'`
+ *
+ * Parses a plan document and outputs agent chain commands.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+import {
+	buildAgentChain,
+	formatPlanOverview,
+	parsePlanDocument,
+	parsePlanDocumentSimple,
+	type OrchestratedStep,
+} from "../plan-orchestrate.ts";
+
+/**
+ * Handle the orchestrate action.
+ *
+ * Parses a plan document (markdown with `<!-- tag: <tag> -->` comments)
+ * and outputs the decomposed agent chain commands.
+ *
+ * Usage: `team action='orchestrate' planPath='/path/to/plan.md'`
+ */
+export function handleOrchestrate(
+	params: TeamToolParamsValue,
+	ctx: TeamContext,
+): PiTeamsToolResult {
+	const planPath = params.planPath as string | undefined;
+
+	if (!planPath) {
+		return result(
+			"orchestrate requires planPath parameter pointing to a markdown plan document.",
+			{ action: "orchestrate", status: "error" },
+			true,
+		);
+	}
+
+	// Resolve relative paths against ctx.cwd
+	const resolvedPath = path.isAbsolute(planPath)
+		? planPath
+		: path.resolve(ctx.cwd, planPath);
+
+	if (!fs.existsSync(resolvedPath)) {
+		return result(
+			`Plan document not found: ${resolvedPath}`,
+			{ action: "orchestrate", status: "error" },
+			true,
+		);
+	}
+
+	// Try primary parser
+	let steps: OrchestratedStep[] = parsePlanDocument(resolvedPath);
+
+	// Fallback to simple parser
+	if (steps.length === 0) {
+		steps = parsePlanDocumentSimple(resolvedPath);
+	}
+
+	if (steps.length === 0) {
+		return result(
+			`No tagged sections found in plan document: ${resolvedPath}\n\nExpected format: <!-- tag: <tag> --> in markdown sections`,
+			{ action: "orchestrate", status: "error" },
+			true,
+		);
+	}
+
+	// Build overview and commands
+	const overview = formatPlanOverview(resolvedPath);
+	const commands = buildAgentChain(steps);
+
+	const outputLines: string[] = [
+		`Plan: ${resolvedPath}`,
+		`Steps: ${steps.length}`,
+		"",
+		"# Agent Chain Commands",
+		"",
+		...commands.map((cmd, i) => `${i + 1}. ${cmd}`),
+		"",
+		"# Full Overview",
+		overview,
+	];
+
+	return result(outputLines.join("\n"), {
+		action: "orchestrate",
+		status: "ok",
+		data: {
+			planPath: resolvedPath,
+			stepCount: steps.length,
+			commands,
+			steps: steps.map((sqs) => ({
+				stepId: sqs.stepId,
+				tag: sqs.tag,
+				chain: sqs.chain,
+				prompt: sqs.prompt,
+				heading: sqs.heading,
+			})),
+		},
+	});
+}

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

@@ -1,5 +1,4 @@
 import { allAgents, discoverAgents } from "../../agents/discover-agents.ts";
-import { ensureCrewDirectory } from "../../state/crew-init.ts";
 import { allTeams, discoverTeams } from "../../teams/discover-teams.ts";
 import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workflows.ts";
 import { loadConfig } from "../../config/config.ts";
@@ -28,8 +27,11 @@ import { resolveCrewRuntime, runtimeResolutionState } from "../../runtime/runtim
 import { normalizeSkillOverride } from "../../runtime/skill-instructions.ts";
 import { expandParallelResearchWorkflow } from "../../runtime/parallel-research.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
+import { waitForRun } from "../../runtime/run-tracker.ts";
 import { hasAsyncStartMarker } from "../../runtime/async-marker.ts";
+import { collectRunMetrics } from "../../state/run-metrics.ts";
 import * as fs from "node:fs";
+import * as path from "node:path";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { buildParentContext, result, type TeamContext } from "./context.ts";
 import { effectiveRunConfig } from "./config-patch.ts";
@@ -76,7 +78,10 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const intentPrefix = goal.length > 60 ? `${goal.slice(0, 57)}...` : goal;
 
 	// P0: Ensure .crew directory structure exists before creating any manifests.
-	await ensureCrewDirectory(ctx.cwd);
+	// Dynamic import to avoid module binding issues in child-process contexts.
+	const workingDir = ctx.cwd ?? process.cwd();
+	const { ensureCrewDirectory } = await import("../../state/crew-init.ts");
+	await ensureCrewDirectory(workingDir);
 
 	const teams = allTeams(discoverTeams(ctx.cwd));
 	const workflows = allWorkflows(discoverWorkflows(ctx.cwd));
@@ -166,19 +171,110 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		atomicWriteJson(paths.manifestPath, asyncManifest);
 		appendEvent(effectiveManifest.eventsPath, { type: "async.spawned", runId: effectiveManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });
 		scheduleBackgroundEarlyExitGuard(ctx.cwd, effectiveManifest.runId, spawned.pid, spawned.logPath);
-		const text = [
-			`Started async pi-crew run ${updatedManifest.runId}.`,
-			`Team: ${team.name}`,
-			`Workflow: ${workflow.name}`,
-			`Status: ${updatedManifest.status}`,
-			`Tasks: ${tasks.length}`,
-			`State: ${updatedManifest.stateRoot}`,
-			`Artifacts: ${updatedManifest.artifactsRoot}`,
-			`Background log: ${spawned.logPath}`,
-			"",
-			`Check status with: team status runId=${updatedManifest.runId}`,
-		].join("\n");
-		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot, intent: `running ${team.name}: ${intentPrefix}` });
+		// Wait for the async run to complete and return actual results.
+		try {
+			const completed = await waitForRun(updatedManifest.runId, ctx.cwd, { timeoutMs: 3600000 });
+			const metrics = collectRunMetrics(ctx.cwd, completed.manifest.runId);
+			const lines: string[] = [
+				`pi-crew run ${completed.manifest.status}: ${completed.manifest.runId} (${team.name})`,
+				`Goal: ${goal.slice(0, 100)}`,
+			];
+			if (metrics) {
+				lines.push("");
+				lines.push(`Metrics: ${metrics.completedCount}/${metrics.taskCount} tasks, ${metrics.totalTokens} tokens, ${metrics.durationMs}ms, consistency=${metrics.consistencyScore}`);
+			}
+
+			if (completed.tasks.length > 0) {
+				// Read run-level summary artifact if present
+				let summaryContent: string | undefined;
+				const summaryArtifact = completed.manifest.artifacts?.find(
+					(a: { kind?: string }) => a.kind === "summary",
+				);
+				if (summaryArtifact) {
+					try {
+						const sumPath = path.join(completed.manifest.artifactsRoot, summaryArtifact.path);
+						summaryContent = fs.readFileSync(sumPath, "utf-8").trim().slice(0, 4000);
+					} catch {
+						/* summary unavailable */
+					}
+				}
+
+				const taskLines: string[] = [];
+				let failedCount = 0;
+				const failedIds: string[] = [];
+				for (const task of completed.tasks) {
+					let resultExcerpt = "";
+					if (task.resultArtifact?.path) {
+						try {
+							const resPath = path.isAbsolute(task.resultArtifact.path)
+							? task.resultArtifact.path
+							: path.join(completed.manifest.artifactsRoot, task.resultArtifact.path);
+							resultExcerpt = fs.readFileSync(resPath, "utf-8").trim().slice(0, 2000);
+						} catch {
+							resultExcerpt = "(result unavailable)";
+						}
+					}
+					const shortResult = resultExcerpt.slice(0, 500);
+					const statusTag =
+						task.status === "completed" ? "✓"
+						: task.status === "failed" ? "✗"
+						: task.status === "cancelled" ? "⊘"
+						: "·";
+					taskLines.push(
+						`- ${statusTag} ${task.id} [${task.role}]: ${task.status}${shortResult ? " — " + shortResult : ""}${task.error ? ` | Error: ${task.error.slice(0, 200)}` : ""}`,
+					);
+					if (task.status === "failed" || task.status === "needs_attention") {
+						failedCount++;
+						failedIds.push(task.id);
+					}
+				}
+
+				lines.push("");
+				lines.push(`Tasks (${completed.tasks.length}):`);
+				lines.push(...taskLines);
+
+				if (summaryContent) {
+					lines.push("");
+					lines.push("Summary:");
+					lines.push(summaryContent.slice(0, 2000));
+				}
+
+				if (failedCount === 0) {
+					lines.push("");
+					lines.push("All tasks completed successfully.");
+				} else {
+					lines.push("");
+					lines.push(
+						`${failedCount} task(s) failed: ${failedIds.join(", ")}. Consider retrying.`,
+					);
+				}
+			} else {
+				lines.push(
+					completed.manifest.status === "completed"
+						? "Run completed with no task results."
+						: `The run ended with status: ${completed.manifest.status}. Check the run artifacts for details.`,
+				);
+			}
+
+			const runFailed = completed.manifest.status === "failed" || completed.manifest.status === "blocked";
+			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot }, runFailed);
+		} catch (waitError: unknown) {
+			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
+			return result(
+				[
+					`pi-crew run timed out or failed: ${updatedManifest.runId}`,
+					`Team: ${team.name}`,
+					`Workflow: ${workflow.name}`,
+					`Error: ${errorMessage}`,
+					"",
+					`Check status with: team status runId=${updatedManifest.runId}`,
+					`State: ${updatedManifest.stateRoot}`,
+					`Background log: ${spawned.logPath}`,
+				].join("\n"),
+				{ action: "run", status: "error", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot },
+				true,
+			);
+		}
 	}
 
 	if (runtime.safety === "blocked") {
@@ -207,19 +303,110 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 				unregisterActiveRun(updatedManifest.runId);
 			}
 		}, updatedManifest.runId);
-		const text = [
-			`Started foreground pi-crew run ${updatedManifest.runId}.`,
-			`Team: ${team.name}`,
-			`Workflow: ${workflow.name}`,
-			"Status: running",
-			`Tasks: ${tasks.length}`,
-			`Runtime: ${runtime.kind}`,
-			`State: ${updatedManifest.stateRoot}`,
-			`Artifacts: ${updatedManifest.artifactsRoot}`,
-			"",
-			"The run continues in this Pi session without blocking the chat. It will be interrupted on session shutdown. Use /team-dashboard or /team-status to watch it.",
-		].join("\n");
-		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot, intent: `running ${team.name}: ${intentPrefix}` });
+
+		// Wait for the foreground run to complete and return actual results.
+		try {
+			const completed = await waitForRun(updatedManifest.runId, ctx.cwd, { timeoutMs: 3600000 });
+			const metrics = collectRunMetrics(ctx.cwd, completed.manifest.runId);
+			const lines: string[] = [
+				`pi-crew run ${completed.manifest.status}: ${completed.manifest.runId} (${team.name})`,
+				`Goal: ${goal.slice(0, 100)}`,
+			];
+			if (metrics) {
+				lines.push("");
+				lines.push(`Metrics: ${metrics.completedCount}/${metrics.taskCount} tasks, ${metrics.totalTokens} tokens, ${metrics.durationMs}ms, consistency=${metrics.consistencyScore}`);
+			}
+
+			if (completed.tasks.length > 0) {
+				// Read run-level summary artifact if present
+				let summaryContent: string | undefined;
+				const summaryArtifact = completed.manifest.artifacts?.find(
+					(a: { kind?: string }) => a.kind === "summary",
+				);
+				if (summaryArtifact) {
+					try {
+						const sumPath = path.join(completed.manifest.artifactsRoot, summaryArtifact.path);
+						summaryContent = fs.readFileSync(sumPath, "utf-8").trim().slice(0, 4000);
+					} catch {
+						/* summary unavailable */
+					}
+				}
+
+				const taskLines: string[] = [];
+				let failedCount = 0;
+				const failedIds: string[] = [];
+				for (const task of completed.tasks) {
+					let resultExcerpt = "";
+					if (task.resultArtifact?.path) {
+						try {
+							const resPath = path.isAbsolute(task.resultArtifact.path)
+							? task.resultArtifact.path
+							: path.join(completed.manifest.artifactsRoot, task.resultArtifact.path);
+							resultExcerpt = fs.readFileSync(resPath, "utf-8").trim().slice(0, 2000);
+						} catch {
+							resultExcerpt = "(result unavailable)";
+						}
+					}
+					const shortResult = resultExcerpt.slice(0, 500);
+					const statusTag =
+						task.status === "completed" ? "✓"
+						: task.status === "failed" ? "✗"
+						: task.status === "cancelled" ? "⊘"
+						: "·";
+					taskLines.push(
+						`- ${statusTag} ${task.id} [${task.role}]: ${task.status}${shortResult ? " — " + shortResult : ""}${task.error ? ` | Error: ${task.error.slice(0, 200)}` : ""}`,
+					);
+					if (task.status === "failed" || task.status === "needs_attention") {
+						failedCount++;
+						failedIds.push(task.id);
+					}
+				}
+
+				lines.push("");
+				lines.push(`Tasks (${completed.tasks.length}):`);
+				lines.push(...taskLines);
+
+				if (summaryContent) {
+					lines.push("");
+					lines.push("Summary:");
+					lines.push(summaryContent.slice(0, 2000));
+				}
+
+				if (failedCount === 0) {
+					lines.push("");
+					lines.push("All tasks completed successfully.");
+				} else {
+					lines.push("");
+					lines.push(
+						`${failedCount} task(s) failed: ${failedIds.join(", ")}. Consider retrying.`,
+					);
+				}
+			} else {
+				lines.push(
+					completed.manifest.status === "completed"
+						? "Run completed with no task results."
+						: `The run ended with status: ${completed.manifest.status}. Check the run artifacts for details.`,
+				);
+			}
+
+			const runFailed = completed.manifest.status === "failed" || completed.manifest.status === "blocked";
+			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot }, runFailed);
+		} catch (waitError: unknown) {
+			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
+			return result(
+				[
+					`pi-crew run timed out or failed: ${updatedManifest.runId}`,
+					`Team: ${team.name}`,
+					`Workflow: ${workflow.name}`,
+					`Error: ${errorMessage}`,
+					"",
+					`Check status with: team status runId=${updatedManifest.runId}`,
+					`State: ${updatedManifest.stateRoot}`,
+				].join("\n"),
+				{ action: "run", status: "error", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot },
+				true,
+			);
+		}
 	}
 	let executed: Awaited<ReturnType<typeof executeTeamRun>>;
 	try {

package/src/extension/team-tool.ts

@@ -165,7 +165,9 @@ import {
 import { FileCheckpointStore } from "../runtime/checkpoint.ts";
 import { buildTeamOnboarding } from "./team-onboard.ts";
 import { handleParallel } from "./team-tool/parallel-dispatch.ts";
+import { handleSchedule, handleListScheduled } from "./team-tool/handle-schedule.ts";
 import { handlePlan } from "./team-tool/plan.ts";
+import { handleOrchestrate } from "./team-tool/orchestrate.ts";
 import { handleRespond } from "./team-tool/respond.ts";
 import { handleStatus } from "./team-tool/status.ts";
 
@@ -187,10 +189,12 @@ export {
 	handlePrune,
 	handleWorktrees,
 } from "./team-tool/lifecycle-actions.ts";
+export { handleSchedule } from "./team-tool/handle-schedule.ts";
 export { handlePlan } from "./team-tool/plan.ts";
 export { handleStatus } from "./team-tool/status.ts";
 export type { TeamToolDetails } from "./team-tool-types.ts";
 export { handleRun };
+export { handleOrchestrate } from "./team-tool/orchestrate.ts";
 
 export function handleList(
 	params: TeamToolParamsValue,
@@ -1089,6 +1093,8 @@ export async function handleTeamTool(
 			return await handleParallel(params, ctx);
 		case "plan":
 			return handlePlan(params, ctx);
+		case "orchestrate":
+			return handleOrchestrate(params, ctx);
 		case "resume":
 			return handleResume(params, ctx);
 		case "create":
@@ -1147,6 +1153,10 @@ export async function handleTeamTool(
 				return result(`Search failed: ${msg}`, { action: "search", status: "error" }, true);
 			}
 		}
+		case "schedule":
+			return handleSchedule(params, ctx);
+		case "scheduled":
+			return handleListScheduled(params, ctx);
 		case "onboard": {
 			const team = params.team ?? "default";
 			const onboarding = buildTeamOnboarding(team, ctx.cwd);

package/src/extension/tool-result.ts

@@ -1,4 +1,4 @@
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { TeamToolDetails } from "./team-tool-types.ts";
 
 export type PiTeamsToolResult<TDetails = TeamToolDetails> = AgentToolResult<TDetails> & { isError?: boolean };

package/src/i18n.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 type Params = Record<string, string | number>;
 

package/src/observability/event-to-metric.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { MetricRegistry } from "./metric-registry.ts";
 
 function recordValue(value: unknown): Record<string, unknown> {

package/src/prompt/prompt-runtime.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export const PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV = "PI_TEAMS_INHERIT_PROJECT_CONTEXT";
 export const PI_TEAMS_INHERIT_SKILLS_ENV = "PI_TEAMS_INHERIT_SKILLS";