pi-crew 0.9.33 → 0.9.35

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

@@ -10,6 +10,11 @@ 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[];
+	remove(id: string): boolean;
+	update(
+		id: string,
+		patch: Partial<import("../../runtime/scheduler.ts").ScheduledJob>,
+	): import("../../runtime/scheduler.ts").ScheduledJob | undefined;
 };
 
 function getCrewScheduler(): SchedulerRef | undefined {
@@ -65,7 +70,27 @@ function buildScheduleSpec(params: ScheduleParams): {
 	throw new Error("schedule requires one of: cron, interval, or once.");
 }
 
+function getSubAction(params: TeamToolParamsValue): string | undefined {
+	const raw = params.subAction ?? (params.config as { subAction?: unknown } | undefined)?.subAction;
+	return typeof raw === "string" ? raw.toLowerCase() : undefined;
+}
+
+function getJobIdParam(params: TeamToolParamsValue): string {
+	const fromTop = typeof params.jobId === "string" ? params.jobId : "";
+	const fromConfig = ((params.config as { jobId?: unknown } | undefined)?.jobId as string | undefined) ?? "";
+	return (fromTop || fromConfig).trim();
+}
+
 export function handleSchedule(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	// Route subactions FIRST so remove/disable/enable don't require a goal.
+	const subAction = getSubAction(params);
+	if (subAction === "remove" || subAction === "delete") {
+		return handleRemoveScheduled(params, ctx);
+	}
+	if (subAction === "disable" || subAction === "enable" || subAction === "update") {
+		return handleUpdateScheduled(params, ctx);
+	}
+
 	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);
@@ -239,3 +264,80 @@ export function handleListScheduled(_params: TeamToolParamsValue, ctx: TeamConte
 	}
 	return result(lines.join("\n"), { action: "scheduled", status: "ok" });
 }
+
+/**
+ * Remove a scheduled job. Mirrors the `cancel` action for runs.
+ *
+ * Usage:
+ *   team action='schedule' subAction='remove' jobId='<uuid>'
+ *   team action='schedule' subAction='delete' jobId='<uuid>'
+ */
+export function handleRemoveScheduled(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	const jobId = getJobIdParam(params);
+	if (!jobId) {
+		return result(
+			"subAction=remove requires jobId. Usage: team action='schedule' subAction='remove' jobId='<uuid>'",
+			{ action: "schedule", status: "error" },
+			true,
+		);
+	}
+	const scheduler = getCrewScheduler();
+	if (!scheduler) {
+		return result("Scheduler not running.", { action: "schedule", status: "error" }, true);
+	}
+	const removed = scheduler.remove(jobId);
+	persistScheduledJobRemove(ctx.cwd, jobId);
+	if (!removed) {
+		return result(`No scheduled job with id '${jobId}'.`, { action: "schedule", status: "error" }, true);
+	}
+	return result([`Scheduled job removed.`, `  Job ID: ${jobId}`].join("\n"), {
+		action: "schedule",
+		status: "ok",
+		data: { jobId, removed: true },
+	});
+}
+
+/**
+ * Update a scheduled job — toggle enabled flag or apply patches.
+ *
+ * Usage:
+ *   team action='schedule' subAction='disable' jobId='<uuid>'
+ *   team action='schedule' subAction='enable'  jobId='<uuid>'
+ *   team action='schedule' subAction='update'  jobId='<uuid>' cron='0 9 * * *'
+ */
+export function handleUpdateScheduled(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	const jobId = getJobIdParam(params);
+	if (!jobId) {
+		return result(
+			"subAction=update requires jobId. Usage: team action='schedule' subAction='update|enable|disable' jobId='<uuid>'",
+			{ action: "schedule", status: "error" },
+			true,
+		);
+	}
+	const subAction = typeof params.subAction === "string" ? params.subAction.toLowerCase() : "update";
+	const scheduler = getCrewScheduler();
+	if (!scheduler) {
+		return result("Scheduler not running.", { action: "schedule", status: "error" }, true);
+	}
+
+	const patch: Partial<import("../../runtime/scheduler.ts").ScheduledJob> = {};
+	if (subAction === "disable") patch.enabled = false;
+	if (subAction === "enable") patch.enabled = true;
+	// For generic "update", allow patch of cron / interval / goal.
+	if (subAction === "update") {
+		if (typeof params.cron === "string") patch.schedule = params.cron;
+		if (typeof params.goal === "string" || typeof params.task === "string") {
+			patch.description = typeof params.task === "string" ? params.task : params.goal;
+		}
+	}
+
+	const updated = scheduler.update(jobId, patch);
+	if (!updated) {
+		return result(`No scheduled job with id '${jobId}'.`, { action: "schedule", status: "error" }, true);
+	}
+	persistScheduledJobUpdate(ctx.cwd, updated);
+	return result(
+		[`Scheduled job updated.`, `  Job ID: ${jobId}`, `  Enabled: ${updated.enabled}`, `  Schedule: ${updated.schedule}`].join("\n"),
+		{ action: "schedule", status: "ok", data: { jobId, enabled: updated.enabled, schedule: updated.schedule } },
+	);
+}

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

@@ -1,6 +1,5 @@
 import { allAgents, discoverAgents } from "../../agents/discover-agents.ts";
 import { loadConfig } from "../../config/config.ts";
-import { PipelineRunner, type PipelineWorkflow } from "../../runtime/pipeline-runner.ts";
 import { sanitizeTaskText } from "../../runtime/task-packet.ts";
 // Heavy runtime — lazy-loaded to avoid 1.4s import cost at extension registration.
 import type { executeTeamRun as ExecuteTeamRunFn } from "../../runtime/team-runner.ts";
@@ -374,47 +373,6 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		}
 	}
 
-	// Check if this is a pipeline workflow - special handling for multi-stage execution
-	const isPipelineWorkflow = workflowName === "pipeline" && !directAgent;
-	if (isPipelineWorkflow) {
-		// For pipeline workflows, use PipelineRunner for execution
-		const pipelineRunner = new PipelineRunner();
-		const pipelineWorkflow: PipelineWorkflow = {
-			name: workflow.name,
-			description: workflow.description,
-			goal,
-			stages: workflow.steps.map((step) => ({
-				name: step.id,
-				team: step.role,
-				inputs: step.task,
-				usePreviousResults: step.dependsOn && step.dependsOn.length > 0,
-			})),
-			stopOnError: true,
-			defaultMaxConcurrency: workflow.maxConcurrency ?? 5,
-		};
-
-		// For now, show pipeline workflow info - full integration would require
-		// connecting PipelineRunner to the actual team execution system
-		const stageInfo = pipelineWorkflow.stages.map((s) => `- ${s.name} (${s.team})`).join("\n");
-		return result(
-			[
-				`Pipeline workflow '${workflow.name}' is not yet wired into the team execution system.`,
-				`Goal: ${goal}`,
-				`Defined stages (${pipelineWorkflow.stages.length}):`,
-				stageInfo,
-				"",
-				"To actually run work right now, use a supported workflow instead:",
-				"  - action='run' workflow='default'  (explore → plan → execute → verify)",
-				"  - action='run' workflow='implementation'  (adaptive, parallel specialists)",
-				"  - action='run' workflow='research'  (explore → analyze → write)",
-				"",
-				"Run action='list' resource='workflow' to see all available workflows.",
-			].join("\n"),
-			{ action: "run", status: "ok" },
-			false,
-		);
-	}
-
 	// LAZY: dodge the jiti ESM/CJS interop TDZ race on the static `import { validateWorkflowForTeam }` above (issue #28, RFC 17).
 	const { validateWorkflowForTeam: validateWorkflow } = await import("../../workflows/validate-workflow.ts");
 	const validationErrors = validateWorkflow(workflow, team);

package/src/extension/team-tool.ts

@@ -11,7 +11,7 @@ import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent, appendEventFireAndForget } from "../state/event-log.ts";
 import { withRunLock } from "../state/locks.ts";
 import { replayPendingMailboxMessages } from "../state/mailbox.ts";
-import { loadRunManifestById, saveRunManifest, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
+import { loadRunManifestById, saveRunManifestAsync, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { assertSafePathId } from "../utils/safe-paths.ts";
@@ -59,7 +59,7 @@ async function handleRun(...args: Parameters<HandleRunFn>): Promise<Awaited<Retu
 
 import { FileCheckpointStore } from "../runtime/checkpoint.ts";
 import { waitForRun } from "../runtime/run-tracker.ts";
-import { normalizeSkillOverride } from "../runtime/skill-instructions.ts";
+import { getSkillCacheStats, normalizeSkillOverride } from "../runtime/skill-instructions.ts";
 import { computeRunCacheKey, getCachedRun, getCacheStats } from "../state/run-cache.ts";
 import { listRunGraphs, loadRunGraph } from "../state/run-graph.ts";
 import { searchAgents, searchTeams } from "../utils/bm25-search.ts";
@@ -223,10 +223,10 @@ function artifactKey(artifact: ArtifactDescriptor): string {
 	return `${artifact.kind}:${artifact.path}`;
 }
 
-function recoverCheckpointedTasks(
+async function recoverCheckpointedTasks(
 	manifest: TeamRunManifest,
 	tasks: TeamTaskState[],
-): { manifest: TeamRunManifest; tasks: TeamTaskState[]; recovered: string[] } {
+): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[]; recovered: string[] }> {
 	const recovered: string[] = [];
 	let nextManifest = manifest;
 	const nextTasks = tasks.map((task) => {
@@ -302,7 +302,7 @@ function recoverCheckpointedTasks(
 			artifacts: [...artifacts.values()],
 			updatedAt: new Date().toISOString(),
 		};
-		saveRunManifest(nextManifest);
+		await saveRunManifestAsync(nextManifest);
 		saveRunTasks(nextManifest, nextTasks);
 	}
 	return { manifest: nextManifest, tasks: nextTasks, recovered };
@@ -346,7 +346,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		const lockedManifest = fresh?.manifest ?? loaded.manifest;
 		const lockedTasks = fresh?.tasks ?? loaded.tasks;
 		const loadedConfig = loadConfig(ctx.cwd);
-		const recovered = recoverCheckpointedTasks(lockedManifest, lockedTasks);
+		const recovered = await recoverCheckpointedTasks(lockedManifest, lockedTasks);
 		const resumeManifest = recovered.manifest;
 		const executedConfig = {
 			...effectiveRunConfig(loadedConfig.config, params.config),
@@ -372,7 +372,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 			runtimeResolution,
 			updatedAt: new Date().toISOString(),
 		};
-		saveRunManifest(runtimeManifest);
+		await saveRunManifestAsync(runtimeManifest);
 		appendEvent(runtimeManifest.eventsPath, {
 			type: "runtime.resolved",
 			runId: runtimeManifest.runId,
@@ -974,7 +974,12 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 				});
 			}
 			const stats = getCacheStats(ctx.cwd);
-			return result(`Cache stats: ${stats.entries} entries, ${stats.sizeBytes} bytes`, { action: "cache", status: "ok" });
+			const skillStats = getSkillCacheStats();
+			return result(
+				`Run cache: ${stats.entries} entries, ${stats.sizeBytes} bytes\n` +
+					`Skill cache: ${skillStats.hits} hits, ${skillStats.misses} misses (${(skillStats.hitRate * 100).toFixed(1)}% hit rate), ${skillStats.currentSize}/${skillStats.maxEntries} entries, ${skillStats.evictions} evictions`,
+				{ action: "cache", status: "ok" },
+			);
 		}
 		case "checkpoint": {
 			if (!params.runId || !params.taskId) {

package/src/observability/exporters/otlp-exporter.ts

@@ -38,12 +38,34 @@ export function validateEndpoint(endpoint: string): void {
 	// Reject IPv6 loopback and private
 	if (hostname.startsWith("[")) {
 		const bare = hostname.replace(/^\[|\]$/g, "");
-		if (bare === "::1") {
+		const lower = bare.toLowerCase();
+		if (lower === "::1") {
 			throw new Error(`OTLP endpoint must not target loopback address: ${endpoint}`);
 		}
-		if (bare.toLowerCase().startsWith("fd") || bare.toLowerCase().startsWith("fc")) {
+		// Unique Local Addresses (fc00::/7) — fd and fc prefixes
+		if (lower.startsWith("fd") || lower.startsWith("fc")) {
 			throw new Error(`OTLP endpoint must not target private IPv6 address: ${endpoint}`);
 		}
+		// Link-Local (fe80::/10) — fe8x, fe9x, feax, febx prefixes
+		if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb")) {
+			throw new Error(`OTLP endpoint must not target IPv6 link-local address: ${endpoint}`);
+		}
+		// Site-Local (fec0::/10) — deprecated but still routable on misconfigured networks
+		if (lower.startsWith("fec") || lower.startsWith("fed") || lower.startsWith("fee") || lower.startsWith("fef")) {
+			throw new Error(`OTLP endpoint must not target IPv6 site-local address: ${endpoint}`);
+		}
+		// Multicast (ff00::/8) — prefix ff
+		if (lower.startsWith("ff")) {
+			throw new Error(`OTLP endpoint must not target IPv6 multicast address: ${endpoint}`);
+		}
+		// Unspecified address ::
+		if (lower === "::") {
+			throw new Error(`OTLP endpoint must not target IPv6 unspecified address: ${endpoint}`);
+		}
+		// IPv4-mapped IPv6 (::ffff:x.x.x.x)
+		if (lower.startsWith("::ffff:")) {
+			throw new Error(`OTLP endpoint must not target IPv4-mapped IPv6 address: ${endpoint}`);
+		}
 	}
 
 	// Reject IPv4 private/reserved ranges

package/src/runtime/adaptive-plan.ts

@@ -17,7 +17,7 @@
 import * as fs from "node:fs";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
-import { saveRunManifest } from "../state/state-store.ts";
+import { saveRunManifestAsync } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
@@ -369,7 +369,7 @@ export interface InjectAdaptivePlanResult {
 	missingPlan: boolean;
 }
 
-export function injectAdaptivePlanIfReady(input: InjectAdaptivePlanInput): InjectAdaptivePlanResult {
+export async function injectAdaptivePlanIfReady(input: InjectAdaptivePlanInput): Promise<InjectAdaptivePlanResult> {
 	if (input.workflow.name !== "implementation")
 		return {
 			tasks: input.tasks,
@@ -442,7 +442,7 @@ export function injectAdaptivePlanIfReady(input: InjectAdaptivePlanInput): Injec
 				producer: assessTask.id,
 				content: `${JSON.stringify({ reason: repair.reason, phases: repair.plan.phases.map((phase) => ({ name: phase.name, count: phase.tasks.length, roles: phase.tasks.map((task) => task.role) })) }, null, 2)}\n`,
 			});
-			saveRunManifest({
+			await saveRunManifestAsync({
 				...input.manifest,
 				updatedAt: new Date().toISOString(),
 				artifacts: [...input.manifest.artifacts, repairArtifact],

package/src/runtime/background-runner.ts

@@ -4,7 +4,7 @@ import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
 import { loadConfig } from "../config/config.ts";
 import { appendEvent } from "../state/event-log.ts";
 import { withRunLockSync } from "../state/locks.ts";
-import { createRunPaths, loadRunManifestById, saveRunManifest, updateRunStatus } from "../state/state-store.ts";
+import { createRunPaths, loadRunManifestById, saveRunManifestAsync, updateRunStatus } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
@@ -621,7 +621,7 @@ async function main(): Promise<void> {
 					status: runStatus,
 					updatedAt: new Date().toISOString(),
 				};
-				saveRunManifest(finalGoalManifest);
+				await saveRunManifestAsync(finalGoalManifest);
 				earlyResult = {
 					manifest: finalGoalManifest,
 					tasks: goalResult.tasks,
@@ -642,7 +642,7 @@ async function main(): Promise<void> {
 					signal: abortController.signal,
 					tokenBudget: wf.maxTokenBudget,
 				});
-				saveRunManifest(dwfResult.manifest);
+				await saveRunManifestAsync(dwfResult.manifest);
 				earlyResult = dwfResult;
 			}
 			console.log(`[background-runner] ${manifest.runKind} returned, status=${earlyResult.manifest.status}`);
@@ -687,7 +687,7 @@ async function main(): Promise<void> {
 				runConfig,
 				updatedAt: new Date().toISOString(),
 			};
-			saveRunManifest(manifest);
+			await saveRunManifestAsync(manifest);
 			appendEvent(manifest.eventsPath, {
 				type: "runtime.resolved",
 				runId: manifest.runId,