pi-crew 0.9.64 → 0.9.65

package/src/runtime/team-runner.ts

@@ -1,15 +1,15 @@
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewLimitsConfig, CrewReliabilityConfig, CrewRuntimeConfig } from "../config/config.ts";
 import { CrewError, ErrorCode } from "../errors.ts";
 import { appendHookEvent, executeHook } from "../hooks/registry.ts";
 import { childCorrelation, withCorrelation } from "../observability/correlation.ts";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
-import { PluginRegistry } from "../plugins/plugin-registry.ts";
-import { NextJsPlugin, VitePlugin, VitestPlugin } from "../plugins/plugins/index.ts";
 import { atomicWriteFile, flushPendingAtomicWrites } from "../state/atomic-write.ts";
-import { canTransitionRunStatus, TEAM_TASK_STATUSES, TEAM_TERMINAL_TASK_STATUSES, type TeamTaskStatus } from "../state/contracts.ts";
+import { canTransitionRunStatus } from "../state/contracts.ts";
 import { withRunLock } from "../state/coordination/locks.ts";
 import {
 	appendEvent,
@@ -35,6 +35,7 @@ import { effectivenessPolicyDecision, evaluateRunEffectiveness, formatRunEffecti
 import { applyGoalAchievement, assessGoalAchievement } from "./goal-workflow/goal-achievement.ts";
 import { deliverGroupJoin, resolveGroupJoinMode } from "./group-join.ts";
 import { terminateLiveAgentsForRun } from "./live-session/live-agent-manager.ts";
+import { isNonTerminalTaskStatus, mergeTaskUpdatesPreservingTerminal } from "./merge-gate.ts";
 import { resolveTaskRuntimeKind } from "./model/runtime-policy.ts";
 import type { CrewRuntimeCapabilities } from "./model/runtime-resolver.ts";
 import { filterReadyByWriteOverlap } from "./path-overlap.ts";
@@ -70,16 +71,6 @@ import {
 	type WorkflowStateMachine,
 } from "./workflow-state.ts";
 
-// Built-in plugin registry for framework awareness.
-// NOTE: This registry is registered here for future use. The integration
-// point (reading package.json deps, computing active plugin context, and
-// passing it into RunConfig / task-runner) is not yet implemented; see
-// `getPluginContext` in src/plugins/plugin-context.ts (planned).
-const builtInRegistry = new PluginRegistry();
-builtInRegistry.register(NextJsPlugin);
-builtInRegistry.register(VitestPlugin);
-builtInRegistry.register(VitePlugin);
-
 /**
  * Start a periodic heartbeat for the team-level run.
  *
@@ -128,6 +119,113 @@ function startTeamRunHeartbeat(stateRoot: string, runId: string): () => void {
 	return () => clearInterval(interval);
 }
 
+// ─── Perf observability (auto-attach, toggle per team) ─────────────────────
+// "Bộ đo luôn hoạt động khi pi-crew chạy": unless the team frontmatter says
+// `observability: false`, every run spawns the external resource sampler
+// (scripts/resource-sampler.mjs --watch-run — auto-resolves the runner PID
+// from state and auto-stops when the runner dies) and, after completion,
+// runs analyze-run to emit the perf report. Both are detached child
+// processes so a failure in the tooling never affects the run itself.
+const OBSERVABILITY_INTERVAL_MS = 2000;
+const OBSERVABILITY_ANALYZE_DELAY_MS = 3000;
+
+function perfScriptPath(scriptName: string): string | undefined {
+	try {
+		// Two layouts: dev (src/runtime/team-runner.ts → ../../scripts) and
+		// bundled (dist/index.mjs → ../scripts). Try both, use whichever exists.
+		const candidates = [
+			fileURLToPath(new URL(`../../scripts/${scriptName}`, import.meta.url)),
+			fileURLToPath(new URL(`../scripts/${scriptName}`, import.meta.url)),
+		];
+		return candidates.find((p) => fs.existsSync(p));
+	} catch {
+		return undefined;
+	}
+}
+
+function startPerfSampler(manifest: TeamRunManifest, team: TeamConfig): void {
+	// DIRECT fs marker (console may be swallowed by the host) — every branch
+	// writes artifacts/<runId>/perf-obs.log with the exact reason.
+	const marker = (msg: string): void => {
+		try {
+			fs.appendFileSync(path.join(manifest.artifactsRoot, "perf-obs.log"), `[${new Date().toISOString()}] ${msg}\n`);
+		} catch {
+			/* best-effort */
+		}
+	};
+	marker(`startPerfSampler entered (team=${team.name} observability=${String(team.observability)} importMetaUrl=${import.meta.url})`);
+	// Strict true: parsed team files default observability to true (parseTeamFile),
+	// while direct-object TeamConfig fixtures (unit tests) stay undefined and
+	// therefore do NOT spawn the sampler — keeps test isolation.
+	if (team.observability !== true) {
+		marker(`SKIP: observability=${String(team.observability)} !== true`);
+		return;
+	}
+	const samplerPath = perfScriptPath("resource-sampler.mjs");
+	if (!samplerPath) {
+		marker(`SKIP: resource-sampler.mjs not found (importMetaUrl=${import.meta.url})`);
+		return;
+	}
+	marker(`spawning sampler from ${samplerPath}`);
+	const crewRoot = path.dirname(path.dirname(path.dirname(manifest.stateRoot)));
+	const outPath = path.join(manifest.artifactsRoot, "resources.jsonl");
+	const logPath = path.join(manifest.artifactsRoot, "perf-obs.log");
+	try {
+		const child = spawn(
+			process.execPath,
+			[
+				"--experimental-strip-types",
+				samplerPath,
+				"--watch-run",
+				manifest.runId,
+				"--crew-root",
+				crewRoot,
+				"--interval",
+				String(OBSERVABILITY_INTERVAL_MS),
+				"--out",
+				outPath,
+			],
+			{ detached: true, stdio: ["ignore", "ignore", "pipe"] },
+		);
+		// diagnostics: sampler stderr → perf-obs.log (best-effort; never affects the run)
+		child.stderr?.on("data", (d: Buffer) => {
+			try {
+				fs.appendFileSync(logPath, String(d));
+			} catch {
+				/* best-effort */
+			}
+		});
+		child.unref();
+	} catch (err) {
+		console.warn(`[perf-obs] sampler spawn failed for ${manifest.runId}: ${String(err)}`);
+	}
+}
+
+function schedulePerfAnalyze(manifest: TeamRunManifest, team: TeamConfig): void {
+	// Strict true — same test-isolation rationale as startPerfSampler.
+	if (team.observability !== true) return;
+	const analyzePath = perfScriptPath("analyze-run.mjs");
+	const resourcesPath = path.join(manifest.artifactsRoot, "resources.jsonl");
+	// Only analyze when the sampler actually produced data (sampler may have
+	// been skipped/failed to spawn) AND the scripts exist.
+	if (!analyzePath || !fs.existsSync(resourcesPath)) return;
+	const crewRoot = path.dirname(path.dirname(path.dirname(manifest.stateRoot)));
+	// Delay so child-worker transcripts are fully flushed before analyze reads them.
+	const timer = setTimeout(() => {
+		try {
+			const child = spawn(
+				process.execPath,
+				["--experimental-strip-types", analyzePath, manifest.runId, "--crew-root", crewRoot, "--resources", resourcesPath],
+				{ detached: true, stdio: "ignore" },
+			);
+			child.unref();
+		} catch (err) {
+			console.warn(`[perf-obs] analyze spawn failed for ${manifest.runId}: ${String(err)}`);
+		}
+	}, OBSERVABILITY_ANALYZE_DELAY_MS);
+	timer.unref();
+}
+
 export interface ExecuteTeamRunInput {
 	manifest: TeamRunManifest;
 	tasks: TeamTaskState[];
@@ -241,9 +339,12 @@ function markBlocked(tasks: TeamTaskState[], reason: string): TeamTaskState[] {
 	);
 }
 
-function isNonTerminalTaskStatus(status: TeamTaskState["status"]): boolean {
-	return status === "queued" || status === "running" || status === "waiting";
-}
+// isNonTerminalTaskStatus, safeFinishedAt, isMalformedFinishedAtReplacement,
+// statusMergeKey, REJECTED_STATUS_MERGE_TRANSITIONS, shouldMergeTaskUpdate,
+// __test__shouldMergeTaskUpdate, mergeTaskUpdatesPreservingTerminal,
+// __test__mergeTaskUpdates — moved to ./merge-gate.ts (2026-08-10
+// improvement-plan Tier 2 team-runner split, self-contained portion).
+// Re-imported below to preserve all in-file callers.
 
 /**
  * CORE-6: Unified cancel/fail of non-terminal tasks. Replaces hand-rolled
@@ -281,193 +382,6 @@ export function cancelNonTerminalTasks(
 	});
 }
 
-/**
- * Returns the finishedAt timestamp as a number, or Infinity for invalid/malformed dates.
- * This makes comparison logic in shouldMergeTaskUpdate more readable by abstracting
- * the NaN handling into a single well-named function.
- */
-function safeFinishedAt(task: TeamTaskState): number {
-	if (!task.finishedAt) return -Infinity;
-	const ms = new Date(task.finishedAt).getTime();
-	return Number.isNaN(ms) ? Infinity : ms;
-}
-
-/**
- * Returns true when the current task has a malformed finishedAt (NaN/Infinity)
- * and the updated task has a valid finite finishedAt. Malformed finishedAt
- * should be replaced rather than persisting corruption.
- */
-function isMalformedFinishedAtReplacement(currentTime: number, updatedTime: number): boolean {
-	return !Number.isFinite(currentTime) && Number.isFinite(updatedTime);
-}
-
-/**
- * RT-16: status-level gate for shouldMergeTaskUpdate. Returns the stable
- * "from->to" key used by REJECTED_STATUS_MERGE_TRANSITIONS.
- */
-function statusMergeKey(from: TeamTaskStatus, to: TeamTaskStatus): string {
-	return `${from}->${to}`;
-}
-
-/**
- * RT-16 — derived merge-gate transition table.
- *
- * The set of old->new status pairs that shouldMergeTaskUpdate must REJECT based
- * solely on the status transition (before any field-level comparison). It
- * replaces the former 13 hand-written status guards that hand-duplicated the
- * lifecycle table. Built once from the single source-of-truth table
- * (TEAM_TASK_STATUSES + TEAM_TERMINAL_TASK_STATUSES — the terminal half of
- * TEAM_TASK_STATUS_TRANSITIONS) plus two merge-specific policies that are
- * STRICTER than the lifecycle table on the parallel-merge path:
- *
- *  P1 Terminal preservation — every terminal->non-terminal pair is rejected.
- *    The lifecycle table permits retries (e.g. completed->queued), but a stale
- *    worker snapshot must never resurrect a settled task.
- *  P2 Completed integrity — five terminal->terminal flips that touch the
- *    "completed" success terminal are rejected: completed->failed,
- *    completed->needs_attention, failed->completed, cancelled->completed,
- *    needs_attention->completed. (completed may still move to
- *    cancelled/skipped; that is intentionally allowed, so these are NOT simply
- *    "every illegal terminal->terminal flip".)
- *  P3 waiting->running regression — the single stale-snapshot case.
- *
- * The decision for every old->new pair is byte-for-byte identical to the former
- * 7 status guards (verified exhaustively in
- * test/unit/team-runner-should-merge-table.test.ts).
- */
-const REJECTED_STATUS_MERGE_TRANSITIONS: ReadonlySet<string> = (() => {
-	const rejected = new Set<string>();
-	// P1 — terminal preservation: reject every terminal->non-terminal pair.
-	for (const from of TEAM_TASK_STATUSES) {
-		if (!TEAM_TERMINAL_TASK_STATUSES.has(from)) continue;
-		for (const to of TEAM_TASK_STATUSES) {
-			if (!TEAM_TERMINAL_TASK_STATUSES.has(to)) rejected.add(statusMergeKey(from, to));
-		}
-	}
-	// P3 — waiting->running stale-snapshot regression.
-	rejected.add(statusMergeKey("waiting", "running"));
-	// P2 — completed integrity flips (bespoke terminal->terminal policy).
-	const completedIntegrityFlips: ReadonlyArray<[TeamTaskStatus, TeamTaskStatus]> = [
-		["completed", "failed"],
-		["completed", "needs_attention"],
-		["failed", "completed"],
-		["cancelled", "completed"],
-		["needs_attention", "completed"],
-	];
-	for (const [from, to] of completedIntegrityFlips) rejected.add(statusMergeKey(from, to));
-	return rejected;
-})();
-
-function shouldMergeTaskUpdate(current: TeamTaskState, updated: TeamTaskState): boolean {
-	// RT-16: status-level gate — reject stale/dangerous transitions via the
-	// derived transition table (REJECTED_STATUS_MERGE_TRANSITIONS) instead of
-	// hand-written guards. Parallel workers receive the same input snapshot; a
-	// later result may still carry stale copies. The table encodes three
-	// merge-specific policies stricter than the lifecycle table: terminal
-	// preservation (no terminal->non-terminal resurrection), completed integrity
-	// (no flipping the "completed" success terminal to/from failed or
-	// needs_attention), and the waiting->running stale-snapshot regression.
-	if (REJECTED_STATUS_MERGE_TRANSITIONS.has(statusMergeKey(current.status, updated.status))) return false;
-	// Guard: when current is "running" but has resultArtifact (another worker already
-	// completed it), a stale updated with status="running" and no resultArtifact
-	// must not overwrite the actual completed state.
-	if (current.status === updated.status && updated.status === "running" && current.resultArtifact && !updated.resultArtifact)
-		return false;
-	// Guard: when current is "completed" and has resultArtifact but updated is also
-	// "completed" without resultArtifact, block the stale update from overwriting
-	// a task that successfully produced output.
-	if (current.status === updated.status && current.status === "completed" && current.resultArtifact && !updated.resultArtifact)
-		return false;
-	// Prevent a stale completed task from overwriting a fresher one.
-	// Restructure to handle undefined current.finishedAt as a special case:
-	// - undefined current + valid updated: allow the update
-	// - valid current + undefined updated: block the update (don't lose completion time)
-	// - both undefined: finishedAt guard does not apply, fall through to heartbeat check
-	// - both valid: compare timestamps as before
-	if (current.finishedAt !== undefined && updated.finishedAt !== undefined) {
-		const currentTime = safeFinishedAt(current);
-		const updatedTime = safeFinishedAt(updated);
-		// Malformed finishedAt (NaN) is treated as Infinity — invalid state should be
-		// replaced rather than persisting corruption. Log warning for visibility.
-		if (!Number.isFinite(currentTime)) {
-			console.warn(`[team-runner] Task ${current.id} has malformed finishedAt: ${current.finishedAt}`);
-		}
-		if (isMalformedFinishedAtReplacement(currentTime, updatedTime)) {
-			return true;
-		}
-		if (updatedTime < currentTime) return false;
-	}
-	// Block if updated is trying to establish a terminal status without a finishedAt
-	// timestamp. Heartbeat-only updates (status='running', no finishedAt) are
-	// allowed if heartbeat has changed (checked separately in hasMeaningfulUpdate).
-	if (!updated.finishedAt && !isNonTerminalTaskStatus(updated.status)) return false;
-	// Explicitly enumerate all fields that constitute a meaningful update so that
-	// adding a new important field requires updating this list (rather than silently
-	// losing data if a field is forgotten in the boolean OR chain below).
-	const hasMeaningfulUpdate =
-		updated.status !== current.status ||
-		updated.finishedAt !== current.finishedAt ||
-		updated.startedAt !== current.startedAt ||
-		Boolean(updated.resultArtifact) !== Boolean(current.resultArtifact) ||
-		(Boolean(updated.resultArtifact) && updated.resultArtifact !== current.resultArtifact) ||
-		Boolean(updated.error) ||
-		Boolean(updated.modelAttempts?.length) ||
-		Boolean(updated.usage) ||
-		Boolean(updated.attempts?.length) ||
-		updated.heartbeat?.lastSeenAt !== current.heartbeat?.lastSeenAt ||
-		updated.jsonEvents !== current.jsonEvents ||
-		updated.agentProgress?.lastActivityAt !== current.agentProgress?.lastActivityAt;
-	return hasMeaningfulUpdate;
-}
-/** Exposed for the exhaustive status-merge table test (RT-16). */
-export const __test__shouldMergeTaskUpdate = shouldMergeTaskUpdate;
-
-// H4 fix: rename to descriptive name. Kept __test__ as alias for backward
-// compat test imports.
-// FIX (perf P10): replace O(N×M) .find() + .map() inside nested loops with a
-// single-pass Map-based merge. Build an index of `merged` once, then for each
-// incoming updated task do O(1) lookup; the final pass reassembles `merged`
-// preserving original order. For a 20-task run × 5-batch merger with
-// ~10 updates per result, this reduces from O(50×20) = 1000 ops to O(120).
-// Behavior is unchanged: skipped updates (shouldMergeTaskUpdate=false) still
-// leave the existing task in place.
-export function mergeTaskUpdatesPreservingTerminal(base: TeamTaskState[], results: Array<{ tasks: TeamTaskState[] }>): TeamTaskState[] {
-	// Index current merged state by id for O(1) lookup during the merge pass.
-	const indexById = new Map<string, TeamTaskState>();
-	for (const task of base) indexById.set(task.id, task);
-
-	let skipped = 0;
-	for (const result of results) {
-		for (const updated of result.tasks) {
-			const current = indexById.get(updated.id);
-			if (!current) continue;
-			if (!shouldMergeTaskUpdate(current, updated)) {
-				// Log skipped merges for visibility into rejected parallel updates.
-				// In distributed systems with parallel workers, rejected merges may
-				// indicate bugs (wrong status, timestamp corruption) if they accumulate.
-				console.debug("[team-runner] Skipping stale merge for task", updated.id, {
-					currentStatus: current.status,
-					updatedStatus: updated.status,
-					currentFinishedAt: current.finishedAt,
-					updatedFinishedAt: updated.finishedAt,
-				});
-				skipped += 1;
-				continue;
-			}
-			indexById.set(updated.id, updated);
-		}
-	}
-	// Reassemble in original `base` order so downstream snapshots stay stable.
-	const merged = base.map((task) => indexById.get(task.id) ?? task);
-	// `skipped` is intentional visibility — currently no caller reads it but
-	// we'd rather leave the count available for future instrumentation than
-	// remove the cumulative silent-rejection signal it provides.
-	void skipped;
-	return refreshTaskGraphQueues(merged);
-}
-/** @deprecated Use mergeTaskUpdatesPreservingTerminal. Kept for backward test import compat. */
-export const __test__mergeTaskUpdates = mergeTaskUpdatesPreservingTerminal;
-
 // 2.8: adaptive-plan parsing/repair/injection moved to src/runtime/goal-workflow/adaptive-plan.ts.
 // Re-export the test-only helpers so existing test imports still resolve.
 export {
@@ -475,6 +389,10 @@ export {
 	__test__repairAdaptivePlan,
 } from "./goal-workflow/adaptive-plan.ts";
 
+// Merge-gate extracted to ./merge-gate.ts (2026-08-10 improvement-plan Tier 2).
+// Re-export the test-only helpers so existing test imports still resolve.
+export { __test__mergeTaskUpdates, __test__shouldMergeTaskUpdate } from "./merge-gate.ts";
+
 import { injectAdaptivePlanIfReady } from "./goal-workflow/adaptive-plan.ts";
 
 function formatTaskProgress(task: TeamTaskState): string {
@@ -912,6 +830,10 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 	// heartbeats; the team-level run had no heartbeat, so any multi-phase
 	// workflow lasting >5min was marked stale and cancelled.
 	const stopTeamHeartbeat = startTeamRunHeartbeat(manifest.stateRoot, manifest.runId);
+	// Perf observability: auto-attach the resource sampler for this run (toggle:
+	// team frontmatter `observability: false`). Detached + unref'd — the sampler
+	// auto-stops when the runner dies, so no explicit cleanup needed.
+	startPerfSampler(manifest, input.team);
 
 	const cleanupUsage = (): void => {
 		for (const task of input.tasks) clearTrackedTaskUsage(task.id);
@@ -994,6 +916,9 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		// this single flush at run-end coalesces any pending progress bursts
 		// before manifest updates are observed by readers.
 		await flushEventLogBuffer();
+		// Perf observability: emit the post-run perf report (detached, delayed so
+		// child transcripts are flushed). Never affects run outcome.
+		schedulePerfAnalyze(manifest, input.team);
 		return result;
 	} catch (error) {
 		// Round 27 (BUG 1): the success path calls stopTeamHeartbeat() but this

package/src/schema/team-tool-schema.ts

@@ -268,10 +268,12 @@ const sharedFields = {
 		}),
 	),
 	budgetTotal: Type.Optional(
+		// Empty-string unset marker accepted (Tier-9: models emit "" when unset).
 		// 0 accepted as "unset/disabled" (models emit 0 for off); still rejects 1-999
 		// as the MISCONFIGURATION GUARD against typo'd silent-abort configs.
 		Type.Union(
 			[
+				Type.Literal(""),
 				Type.Literal(0),
 				Type.Number({
 					minimum: 1000,

package/src/teams/discover-teams.ts

@@ -111,6 +111,8 @@ function parseTeamFile(filePath: string, source: ResourceSource): TeamConfig | u
 			defaultWorkflow: frontmatter.defaultWorkflow || frontmatter.workflow || undefined,
 			workspaceMode: frontmatter.workspaceMode?.trim() === "worktree" ? "worktree" : "single",
 			maxConcurrency: frontmatter.maxConcurrency ? Number.parseInt(frontmatter.maxConcurrency, 10) : undefined,
+			// observability defaults ON ("luôn hoạt động"); explicit `observability: false` disables.
+			observability: frontmatter.observability === undefined ? true : frontmatter.observability !== "false",
 			routing: triggers || useWhen || avoidWhen || cost || category ? { triggers, useWhen, avoidWhen, cost, category } : undefined,
 		};
 	} catch {

package/src/teams/team-config.ts

@@ -23,6 +23,13 @@ export interface TeamConfig {
 	defaultWorkflow?: string;
 	workspaceMode?: "single" | "worktree";
 	maxConcurrency?: number;
+	/**
+	 * Perf observability: when true (default), the run auto-attaches the
+	 * resource sampler (scripts/resource-sampler.mjs --watch-run) and runs
+	 * analyze-run after completion. Set `observability: false` in the team
+	 * frontmatter to disable.
+	 */
+	observability?: boolean;
 	routing?: RoutingMetadata;
 	/**
 	 * Optional git-based source URL when this team config is sourced from a remote URL.

package/src/teams/team-serializer.ts

@@ -24,6 +24,7 @@ export function serializeTeam(team: TeamConfig): string {
 		team.defaultWorkflow ? `defaultWorkflow: ${team.defaultWorkflow}` : undefined,
 		team.workspaceMode ? `workspaceMode: ${team.workspaceMode}` : undefined,
 		team.maxConcurrency !== undefined ? `maxConcurrency: ${team.maxConcurrency}` : undefined,
+		team.observability !== undefined ? `observability: ${team.observability}` : undefined,
 		line("triggers", team.routing?.triggers),
 		line("useWhen", team.routing?.useWhen),
 		line("avoidWhen", team.routing?.avoidWhen),

package/src/ui/mascot.ts

@@ -99,7 +99,6 @@ export class AnimatedMascot {
 	private currentArminGrid: string[][];
 	private effectState: EffectState = {};
 	private effectDone = false;
-	private visible = true;
 	private frame = 0;
 	private effectPhase = 0;
 	private gridVersion = 0;
@@ -200,10 +199,7 @@ export class AnimatedMascot {
 			this.gridVersion++;
 		}
 		this.invalidate();
-		// Only request a re-render when the mascot is visible (not obscured by
-		// another overlay such as the dashboard or live sidebar).  This avoids
-		// pointless repaints on every animation frame while hidden.
-		if (this.visible) this.requestRender?.();
+		this.requestRender?.();
 	}
 
 	private tickArminEffect(): boolean {
@@ -432,15 +428,6 @@ export class AnimatedMascot {
 		}
 	}
 
-	/**
-	 * Set whether the mascot is currently visible (not obscured by another
-	 * overlay).  When invisible, tick() skips requestRender so the animation
-	 * does not trigger needless repaints while hidden.
-	 */
-	setVisible(visible: boolean): void {
-		this.visible = visible;
-	}
-
 	dispose(): void {
 		this.doneGuard.called = true;
 		if (this.interval) clearInterval(this.interval);

package/teams/default.team.md

@@ -1,5 +1,6 @@
 ---
 name: default
+observability: true
 description: Balanced team for ordinary implementation tasks
 defaultWorkflow: default
 workspaceMode: single

package/teams/fast-fix.team.md

@@ -1,5 +1,6 @@
 ---
 name: fast-fix
+observability: true
 description: Small team for quick bug fixes
 defaultWorkflow: fast-fix
 workspaceMode: single

package/src/observability/event-bus.ts

@@ -1,86 +0,0 @@
-import type { AgentProgress } from "../runtime/output/progress-tracker.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-
-export type CrewEventType = "agent:progress" | "agent:complete" | "agent:error" | "run:start" | "run:complete";
-
-export interface CrewEvent {
-	type: CrewEventType;
-	runId: string;
-	agentId?: string;
-	payload?: AgentProgress | string;
-	timestamp: number;
-}
-
-type CrewEventListener = (event: CrewEvent) => void;
-
-class EventBus {
-	private static readonly MAX_LISTENERS_PER_EVENT = 100;
-	private listeners = new Map<CrewEventType, Set<CrewEventListener>>();
-	private static _instance?: EventBus;
-
-	static getInstance(): EventBus {
-		if (!EventBus._instance) {
-			EventBus._instance = new EventBus();
-		}
-		return EventBus._instance;
-	}
-
-	/**
-	 * Dispose of the EventBus instance and clear all listeners.
-	 * Resets the singleton so a new instance can be created.
-	 */
-	dispose(): void {
-		this.listeners.clear();
-		EventBus._instance = undefined;
-	}
-
-	emit(event: CrewEvent): void {
-		const listeners = this.listeners.get(event.type);
-		if (listeners) {
-			for (const listener of listeners) {
-				try {
-					listener(event);
-				} catch (e) {
-					// FIX (Round 15, L1): Use logInternalError for consistency with
-					// the rest of the codebase. Previously console.error may not be
-					// visible in all environments (e.g. JSON-RPC mode, redirected
-					// stderr).
-					logInternalError("event-bus.listener", e, `type=${event.type} runId=${event.runId}`);
-				}
-			}
-		}
-	}
-
-	on(type: CrewEventType, listener: CrewEventListener): () => void {
-		if (!this.listeners.has(type)) {
-			this.listeners.set(type, new Set());
-		}
-		const set = this.listeners.get(type)!;
-		if (set.size >= EventBus.MAX_LISTENERS_PER_EVENT) {
-			logInternalError(
-				"event-bus.listener-cap",
-				new Error(`Max ${EventBus.MAX_LISTENERS_PER_EVENT} listeners reached for event type '${type}'`),
-				`type=${type} currentCount=${set.size}`,
-			);
-		}
-		set.add(listener);
-
-		return () => {
-			this.listeners.get(type)?.delete(listener);
-		};
-	}
-
-	off(type: CrewEventType, listener: CrewEventListener): void {
-		this.listeners.get(type)?.delete(listener);
-	}
-}
-
-/**
- * Global event bus for crew lifecycle events.
- *
- * NOTE: Currently only emits — no production subscribers yet.
- * The `runEventBus` (from `ui/run-event-bus.ts`) is the active event system.
- * This bus is retained for future observability/SIEM integration.
- * See also: progress-tracker.ts which emits agent:progress events.
- */
-export const crewEventBus = EventBus.getInstance();

package/src/plugins/plugin-define.ts

@@ -1,6 +0,0 @@
-/**
- * Simplifies plugin struct definition.
- */
-export function definePlugin<T extends { name: string; enablers: readonly string[] }>(spec: T): T {
-	return spec;
-}

package/src/plugins/plugin-registry.ts

@@ -1,32 +0,0 @@
-export interface Plugin {
-	readonly name: string;
-	readonly enablers: readonly string[];
-	readonly entryPatterns?: readonly string[];
-	readonly configPatterns?: readonly string[];
-	readonly toolingDependencies?: readonly string[];
-	readonly pathAliases?: readonly string[][];
-	readonly virtualModulePrefixes?: readonly string[];
-}
-
-export class PluginRegistry {
-	private plugins: Plugin[] = [];
-
-	register(plugin: Plugin): void {
-		this.plugins.push(plugin);
-	}
-
-	activePlugins(allDeps: string[]): Plugin[] {
-		return this.plugins.filter((p) =>
-			p.enablers.some((enabler) => {
-				if (enabler.endsWith("/")) {
-					return allDeps.some((d) => d.startsWith(enabler));
-				}
-				return allDeps.includes(enabler);
-			}),
-		);
-	}
-
-	allPlugins(): Plugin[] {
-		return [...this.plugins];
-	}
-}

package/src/plugins/plugins/index.ts

@@ -1,3 +0,0 @@
-export { NextJsPlugin } from "./nextjs.ts";
-export { VitePlugin } from "./vite.ts";
-export { VitestPlugin } from "./vitest.ts";

package/src/plugins/plugins/nextjs.ts

@@ -1,19 +0,0 @@
-import { definePlugin } from "../plugin-define.ts";
-
-export const NextJsPlugin = definePlugin({
-	name: "nextjs",
-	enablers: ["next"],
-	entryPatterns: [
-		"src/app/**/*.{ts,tsx}",
-		"src/pages/**/*.{ts,tsx}",
-		"src/app/**/page.{ts,tsx}",
-		"src/app/**/layout.{ts,tsx}",
-		"src/app/**/route.{ts,tsx}",
-		"middleware.{ts,js}",
-		"next.config.{ts,js,mjs}",
-	],
-	configPatterns: ["next.config.{ts,js,mjs}"],
-	toolingDependencies: ["next", "@next/font", "@next/mdx"],
-	pathAliases: [["~", "src"]],
-	virtualModulePrefixes: ["next:"],
-});

package/src/plugins/plugins/vite.ts

@@ -1,10 +0,0 @@
-import { definePlugin } from "../plugin-define.ts";
-
-export const VitePlugin = definePlugin({
-	name: "vite",
-	enablers: ["vite", "rolldown-vite"],
-	entryPatterns: ["src/main.{ts,tsx,js,jsx}", "src/index.{ts,tsx,js,jsx}", "index.html"],
-	configPatterns: ["vite.config.{ts,js,mts,mjs}"],
-	toolingDependencies: ["vite"],
-	virtualModulePrefixes: ["virtual:"],
-});

package/src/plugins/plugins/vitest.ts

@@ -1,9 +0,0 @@
-import { definePlugin } from "../plugin-define.ts";
-
-export const VitestPlugin = definePlugin({
-	name: "vitest",
-	enablers: ["vitest"],
-	entryPatterns: ["**/*.test.{ts,tsx}", "**/*.spec.{ts,tsx}", "src/**/*.test.{ts,tsx}", "src/**/*.spec.{ts,tsx}"],
-	configPatterns: ["vitest.config.{ts,js,mjs}", "vite.config.ts"],
-	toolingDependencies: ["vitest"],
-});