pi-crew 0.9.50 → 0.9.52

package/src/runtime/scheduler.ts

@@ -1,353 +0,0 @@
-export type ScheduleType = "cron" | "once" | "interval";
-
-export interface ScheduledJob {
-	id: string;
-	name: string;
-	description: string;
-	schedule: string;
-	scheduleType: ScheduleType;
-	intervalMs?: number;
-	subagentType: string;
-	prompt: string;
-	enabled: boolean;
-	createdAt: string;
-	lastRun?: string;
-	lastStatus?: "success" | "error" | "running";
-	nextRun?: string;
-	runCount: number;
-	/** Run IDs spawned by this job. Used to cancel runs when job is removed. */
-	spawnedRunIds?: string[];
-}
-
-export type ScheduleChangeEvent =
-	| { type: "added"; job: ScheduledJob }
-	| { type: "removed"; jobId: string; spawnedRunIds?: string[] }
-	| { type: "updated"; job: ScheduledJob }
-	| { type: "fired"; jobId: string; agentId: string; name: string }
-	| { type: "error"; jobId: string; error: string };
-
-export class CrewScheduler {
-	private jobs = new Map<string, ScheduledJob>();
-	private timers = new Map<string, ReturnType<typeof setInterval | typeof setTimeout>>();
-	private emit?: (event: ScheduleChangeEvent) => void;
-	private executor?: (job: ScheduledJob) => string;
-	private finalizer?: (jobId: string, agentId: string) => void;
-	private runCancelFn?: (runId: string) => void;
-
-	start(options: {
-		emit: (event: ScheduleChangeEvent) => void;
-		executor: (job: ScheduledJob) => string;
-		finalizer: (jobId: string, agentId: string) => void;
-		/** Optional callback to cancel a spawned run by runId. */
-		runCancelFn?: (runId: string) => void;
-	}): void {
-		this.emit = options.emit;
-		this.executor = options.executor;
-		this.finalizer = options.finalizer;
-		this.runCancelFn = options.runCancelFn;
-	}
-
-	stop(): void {
-		for (const t of this.timers.values()) {
-			clearInterval(t as ReturnType<typeof setInterval>);
-			clearTimeout(t as ReturnType<typeof setTimeout>);
-		}
-		this.timers.clear();
-		this.emit = undefined;
-		this.executor = undefined;
-		this.finalizer = undefined;
-		this.runCancelFn = undefined;
-	}
-
-	add(job: ScheduledJob): void {
-		this.jobs.set(job.id, job);
-		if (job.enabled) this.arm(job);
-		this.emit?.({ type: "added", job });
-	}
-
-	remove(id: string): boolean {
-		const job = this.jobs.get(id);
-		const spawnedRunIds = job?.spawnedRunIds;
-		this.disarm(id);
-		// Cancel all spawned runs that are still active
-		if (spawnedRunIds && this.runCancelFn) {
-			for (const runId of spawnedRunIds) {
-				try {
-					this.runCancelFn(runId);
-				} catch {
-					/* best-effort */
-				}
-			}
-		}
-		const ok = this.jobs.delete(id);
-		if (ok) this.emit?.({ type: "removed", jobId: id, spawnedRunIds });
-		return ok;
-	}
-
-	update(id: string, patch: Partial<ScheduledJob>): ScheduledJob | undefined {
-		const existing = this.jobs.get(id);
-		if (!existing) return undefined;
-		this.disarm(id);
-		const updated = { ...existing, ...patch };
-		this.jobs.set(id, updated);
-		if (updated.enabled) this.arm(updated);
-		this.emit?.({ type: "updated", job: updated });
-		return updated;
-	}
-
-	list(): ScheduledJob[] {
-		return [...this.jobs.values()];
-	}
-
-	/** Record a runId spawned by a job. Call this after executor fires. */
-	recordSpawnedRun(jobId: string, runId: string): void {
-		const job = this.jobs.get(jobId);
-		if (!job) return;
-		const spawnedRunIds = [...(job.spawnedRunIds ?? []), runId];
-		this.jobs.set(jobId, { ...job, spawnedRunIds });
-	}
-
-	private arm(job: ScheduledJob): void {
-		if (this.timers.has(job.id)) return;
-		if (job.scheduleType === "interval" && job.intervalMs) {
-			const t = setInterval(() => this.fire(job.id), job.intervalMs);
-			t.unref();
-			this.timers.set(job.id, t);
-		} else if (job.scheduleType === "once") {
-			const target = new Date(job.schedule).getTime();
-			const delay = target - Date.now();
-			if (delay > 0) {
-				const t = setTimeout(() => {
-					this.fire(job.id);
-					this.update(job.id, { enabled: false });
-				}, delay);
-				t.unref();
-				this.timers.set(job.id, t);
-			} else {
-				this.update(job.id, { enabled: false, lastStatus: "error" });
-				this.emit?.({
-					type: "error",
-					jobId: job.id,
-					error: `Scheduled time ${job.schedule} is in the past`,
-				});
-			}
-		}
-	}
-
-	private disarm(id: string): void {
-		const t = this.timers.get(id);
-		if (t) {
-			// Branch on timer type to use correct clear function
-			const job = this.jobs.get(id);
-			if (job?.scheduleType === "once") {
-				clearTimeout(t as ReturnType<typeof setTimeout>);
-			} else {
-				clearInterval(t as ReturnType<typeof setInterval>);
-			}
-			this.timers.delete(id);
-		}
-	}
-
-	private fire(id: string): void {
-		const job = this.jobs.get(id);
-		if (!job?.enabled || !this.executor) return;
-		this.update(id, { lastStatus: "running" });
-		let agentId: string;
-		try {
-			agentId = this.executor(job);
-		} catch (err) {
-			const error = err instanceof Error ? err.message : String(err);
-			this.update(id, {
-				lastRun: new Date().toISOString(),
-				lastStatus: "error",
-			});
-			this.emit?.({ type: "error", jobId: id, error });
-			return;
-		}
-		this.emit?.({ type: "fired", jobId: id, agentId, name: job.name });
-		this.finalizer?.(id, agentId);
-	}
-
-	static detectSchedule(s: string): {
-		type: ScheduleType;
-		intervalMs?: number;
-		normalized: string;
-	} {
-		const trimmed = s.trim();
-		// Relative: +10m
-		const rel = trimmed.match(/^\+(\d+)(s|m|h|d)$/);
-		if (rel) {
-			const ms = parseInt(rel[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[rel[2] as "s" | "m" | "h" | "d"];
-			return {
-				type: "once",
-				normalized: new Date(Date.now() + ms).toISOString(),
-			};
-		}
-		// Interval: 5m
-		const ivl = trimmed.match(/^(\d+)(s|m|h|d)$/);
-		if (ivl) {
-			const ms = parseInt(ivl[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[ivl[2] as "s" | "m" | "h" | "d"];
-			return { type: "interval", intervalMs: ms, normalized: trimmed };
-		}
-		// ISO timestamp
-		if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
-			const d = new Date(trimmed);
-			if (!Number.isNaN(d.getTime())) {
-				if (d.getTime() <= Date.now()) throw new Error(`Scheduled time ${d.toISOString()} is in the past.`);
-				return { type: "once", normalized: d.toISOString() };
-			}
-		}
-		// Simple cron-like (5 fields)
-		const cronFields = trimmed.split(/\s+/);
-		if (cronFields.length >= 5) {
-			return { type: "cron", normalized: trimmed };
-		}
-		throw new Error(`Invalid schedule "${s}". Use "5m", "+10m", ISO timestamp, or cron expression.`);
-	}
-}
-
-export interface ScheduleSpec {
-	kind: "once" | "interval" | "cron";
-	spec: string;
-}
-
-function parseIntervalMs(s: string): number | undefined {
-	let ms = 0;
-	let remaining = s;
-	const unitMs: Record<string, number> = {
-		s: 1000,
-		m: 60_000,
-		h: 3_600_000,
-		d: 86_400_000,
-	};
-	while (remaining.length > 0) {
-		const m = remaining.match(/^(\d+)(s|m|h|d)/);
-		if (!m) return undefined;
-		ms += parseInt(m[1], 10) * unitMs[m[2]];
-		remaining = remaining.slice(m[0].length);
-	}
-	return ms;
-}
-
-function nextCronDate(spec: string, from: Date): Date | { error: string } | null {
-	const parts = spec.split(/\s+/);
-	if (parts.length < 5) return { error: "Invalid cron expression" };
-	const [minStr, hourStr, domStr, monthStr, dowStr] = parts;
-
-	function matchField(value: number, str: string, min: number, max: number): boolean {
-		if (str === "*") return true;
-		const n = parseInt(str, 10);
-		if (!Number.isNaN(n) && n >= min && n <= max && n === value) return true;
-		if (/^\d+-\d+$/.test(str)) {
-			const [a, b] = str.split("-").map(Number);
-			return value >= a && value <= b;
-		}
-		if (str.includes(",")) {
-			return str.split(",").some((part) => matchField(value, part.trim(), min, max));
-		}
-		return false;
-	}
-
-	let cursor = new Date(from.getTime());
-	cursor.setSeconds(0, 0);
-	cursor = new Date(cursor.getTime() + 60_000);
-
-	const maxIterations = 366 * 24 * 60;
-	for (let i = 0; i < maxIterations; i++) {
-		const min = cursor.getUTCMinutes();
-		const hour = cursor.getUTCHours();
-		const dom = cursor.getUTCDate();
-		const month = cursor.getUTCMonth() + 1;
-		const dow = cursor.getUTCDay();
-
-		if (
-			matchField(min, minStr, 0, 59) &&
-			matchField(hour, hourStr, 0, 23) &&
-			matchField(dom, domStr, 1, 31) &&
-			matchField(month, monthStr, 1, 12) &&
-			matchField(dow, dowStr, 0, 6)
-		) {
-			return cursor;
-		}
-
-		cursor = new Date(cursor.getTime() + 60_000);
-	}
-
-	return { error: "No next cron occurrence found within search window" };
-}
-
-export function parseSchedule(spec: string): ScheduleSpec | { error: string } {
-	const trimmed = spec.trim();
-	if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
-		const d = new Date(trimmed);
-		if (!Number.isNaN(d.getTime())) {
-			return { kind: "once", spec: trimmed };
-		}
-	}
-	if (/^\+\d+(s|m|h|d)$/.test(trimmed)) {
-		return { kind: "once", spec: trimmed };
-	}
-	const ivlMs = parseIntervalMs(trimmed);
-	if (ivlMs !== undefined && ivlMs > 0) {
-		return { kind: "interval", spec: trimmed };
-	}
-	const fields = trimmed.split(/\s+/);
-	if (fields.length >= 5) {
-		return { kind: "cron", spec: trimmed };
-	}
-	return {
-		error: `Invalid schedule "${spec}". Use "5m", "+10m", ISO timestamp, or cron expression.`,
-	};
-}
-
-export function nextRunTime(spec: ScheduleSpec, from: Date = new Date()): Date | { error: string } {
-	if (spec.kind === "once") {
-		const rel = spec.spec.match(/^\+(\d+)(s|m|h|d)$/);
-		if (rel) {
-			const ms = parseInt(rel[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[rel[2] as "s" | "m" | "h" | "d"];
-			return new Date(from.getTime() + ms);
-		}
-		const d = new Date(spec.spec);
-		if (Number.isNaN(d.getTime())) {
-			return { error: `Invalid once schedule: ${spec.spec}` };
-		}
-		return d;
-	}
-	if (spec.kind === "interval") {
-		const ms = parseIntervalMs(spec.spec);
-		if (ms === undefined || ms <= 0) {
-			return { error: `Invalid interval: ${spec.spec}` };
-		}
-		return new Date(from.getTime() + ms);
-	}
-	if (spec.kind === "cron") {
-		const next = nextCronDate(spec.spec, from);
-		if (!next || !(next instanceof Date)) {
-			return (
-				(next as { error: string } | null) ?? {
-					error: "Invalid cron expression",
-				}
-			);
-		}
-		return next;
-	}
-	return {
-		error: `Unknown schedule kind: ${(spec as unknown as Record<string, unknown>).kind}`,
-	};
-}
-
-export function humanizeSchedule(spec: ScheduleSpec): string {
-	if (spec.kind === "once") {
-		if (/^\+\d+(s|m|h|d)$/.test(spec.spec)) {
-			return `once in ${spec.spec.slice(1)}`;
-		}
-		return `once at ${spec.spec}`;
-	}
-	if (spec.kind === "interval") {
-		return `every ${spec.spec}`;
-	}
-	if (spec.kind === "cron") {
-		return `cron ${spec.spec}`;
-	}
-	return "unknown schedule";
-}

package/src/runtime/semaphore.ts

@@ -1,141 +0,0 @@
-/**
- * Phase 6: Semaphore and fail-fast parallel execution.
- *
- * Adapted from oh-my-pi's `parallel.ts` Semaphore class and
- * `mapWithConcurrencyLimit` implementation. Provides:
- * - Explicit acquire/release Semaphore for concurrency control
- * - Fail-fast on first error (via Promise.race)
- * - AbortSignal support for graceful cancellation
- * - Partial results on abort
- */
-
-/**
- * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
- */
-export class Semaphore {
-	#max: number;
-	#current = 0;
-	#queue: Array<() => void> = [];
-	// FIX (Round 15): Cap the waiter queue to prevent unbounded memory growth
-	// if the semaphore is held for a long period and many tasks accumulate.
-	static readonly MAX_QUEUE = 10_000;
-
-	constructor(max: number) {
-		this.#max = Math.max(1, max);
-	}
-
-	async acquire(): Promise<void> {
-		if (this.#current < this.#max) {
-			this.#current++;
-			return;
-		}
-		// FIX (Round 15): Reject when the waiter queue is full. The previous
-		// implementation let #queue grow without bound, risking memory
-		// exhaustion under sustained high concurrency with slow releases.
-		if (this.#queue.length >= Semaphore.MAX_QUEUE) {
-			throw new Error(`Semaphore queue full: ${this.#queue.length} waiters (max ${Semaphore.MAX_QUEUE}); cannot acquire slot`);
-		}
-		const { promise, resolve } = (() => {
-			let res: () => void;
-			const p = new Promise<void>((r) => {
-				res = r;
-			});
-			return { promise: p, resolve: res! };
-		})();
-		this.#queue.push(resolve);
-		return promise;
-	}
-
-	release(): void {
-		const next = this.#queue.shift();
-		if (next) {
-			next();
-		} else if (this.#current > 0) {
-			this.#current--;
-		}
-		// Guard: over-release is a no-op to prevent #current going negative
-	}
-
-	/** Current number of acquired slots. */
-	get current(): number {
-		return this.#current;
-	}
-
-	/** Number of waiters in the queue. */
-	get waiting(): number {
-		return this.#queue.length;
-	}
-}
-
-/**
- * Result of parallel execution with fail-fast support.
- */
-export interface ParallelResult<R> {
-	/** Results array — undefined entries indicate tasks that were skipped due to abort. */
-	results: (R | undefined)[];
-	/** Whether execution was aborted before all tasks completed. */
-	aborted: boolean;
-	/** The first error that triggered fail-fast, if any. */
-	firstError?: unknown;
-}
-
-/**
- * Execute items with a concurrency limit, fail-fast, and abort signal support.
- *
- * - On first error: aborts remaining workers and rethrows.
- * - On external abort: returns partial results with `aborted: true`.
- * - Results are returned in the same order as input items.
- *
- * Adapted from oh-my-pi's `mapWithConcurrencyLimit`.
- */
-/** @internal */
-async function mapWithFailFast<T, R>(
-	items: T[],
-	concurrency: number,
-	fn: (item: T, index: number, signal: AbortSignal) => Promise<R>,
-	signal?: AbortSignal,
-): Promise<ParallelResult<R>> {
-	const limit = Math.max(1, Math.min(concurrency, items.length));
-	const results: (R | undefined)[] = new Array(items.length);
-	let nextIndex = 0;
-
-	// Internal abort controller for fail-fast
-	const abortController = new AbortController();
-	const workerSignal = signal ? AbortSignal.any([signal, abortController.signal]) : abortController.signal;
-
-	// Promise that rejects on first error — used for fail-fast
-	let rejectFirst: (error: unknown) => void;
-	const firstErrorPromise = new Promise<never>((_, reject) => {
-		rejectFirst = reject;
-	});
-
-	const worker = async (): Promise<void> => {
-		while (true) {
-			if (workerSignal.aborted) return;
-			const index = nextIndex++;
-			if (index >= items.length) return;
-			try {
-				results[index] = await fn(items[index], index, workerSignal);
-			} catch (error) {
-				if (!workerSignal.aborted) {
-					abortController.abort();
-					rejectFirst(error);
-					throw error;
-				}
-			}
-		}
-	};
-
-	const workers = Array.from({ length: limit }, () => worker());
-
-	try {
-		await Promise.race([Promise.all(workers), firstErrorPromise]);
-	} catch (error) {
-		if (signal?.aborted) {
-			return { results, aborted: true, firstError: error };
-		}
-		throw error;
-	}
-
-	return { results, aborted: signal?.aborted ?? false };
-}

package/src/runtime/sensitive-paths.ts

@@ -1,93 +0,0 @@
-/**
- * Sensitive file detection for worker constraints.
- *
- * Inspired by caveman's compress.py — prevents workers from reading
- * or compressing files that contain secrets, credentials, or PII.
- *
- * Workers should refuse operations on matching paths. This is enforced
- * in the worker prompt and validated here for defense-in-depth.
- */
-
-import * as path from "node:path";
-
-/** Basenames that almost certainly hold secrets or PII */
-const SENSITIVE_BASENAMES = /\.(?:env|pem|key|p12|pfx|crt|cer|jks|keystore|asc|gpg)(?:\..+)?$/i;
-const SENSITIVE_EXACT =
-	/^(?:\.env|\.netrc|\.npmrc|\.pypirc|credentials|secrets?|passwords?|id_(?:rsa|dsa|ecdsa|ed25519)(?:\.pub)?|authorized_keys|known_hosts|jwt\.json|session\.cookie|\.token)$/i;
-
-/** Path components that indicate sensitive directories */
-const SENSITIVE_DIRS = new Set([".ssh", ".aws", ".gnupg", ".kube", ".docker", ".config/gcloud", ".config/gh"]);
-
-/** Name tokens that suggest sensitive content */
-const SENSITIVE_TOKENS = ["secret", "credential", "password", "passwd", "apikey", "accesskey", "token", "privatekey"];
-
-/**
- * Check if a file path looks like it contains sensitive data.
- * Returns true if the path should be refused for worker operations.
- */
-export function isSensitivePath(filePath: string): boolean {
-	const resolved = path.resolve(filePath);
-	const basename = path.basename(resolved);
-	const lower = basename.toLowerCase();
-
-	// Check exact sensitive filenames
-	if (SENSITIVE_EXACT.test(basename)) return true;
-
-	// Check sensitive extensions
-	if (SENSITIVE_BASENAMES.test(basename)) return true;
-
-	// Check path components
-	const parts = resolved.split(/[/\\]/).map((p) => p.toLowerCase());
-	for (const dir of SENSITIVE_DIRS) {
-		const dirParts = dir.split("/");
-		for (let i = 0; i <= parts.length - dirParts.length; i++) {
-			const slice = parts.slice(i, i + dirParts.length);
-			if (slice.join("/") === dir) return true;
-		}
-	}
-
-	// Check name tokens with word-boundary awareness to reduce false positives.
-	// Strategy: split filename on separators to get "words", then check if
-	// any token matches. For substring matching in the normalized form,
-	// we require the token to end at a segment boundary or string end.
-	// This matches 'secret', 'secrets' but NOT 'secretary'.
-	const words = lower.split(/[_\-\s.\W]+/).filter(Boolean);
-	const normalized = lower.replace(/[_\-\s.]/g, "");
-	for (const token of SENSITIVE_TOKENS) {
-		// Check individual words — exact match or token is prefix and word is <= token+2 chars
-		for (const word of words) {
-			if (word === token) return true;
-			// 'secrets' starts with 'secret' and is only 1 char longer → match
-			// 'secretary' starts with 'secret' but is 4 chars longer → no match
-			if (word.startsWith(token) && word.length <= token.length + 2) return true;
-		}
-		// Check fully-normalized form for compound tokens like 'api-key' → 'apikey'
-		// The token must appear as a complete segment (not a partial substring).
-		// After the token, the remaining chars must be a complete word (extension).
-		const idx = normalized.indexOf(token);
-		if (idx !== -1) {
-			const after = idx + token.length;
-			if (after === normalized.length) return true;
-			// Check if remaining chars after token correspond to a known word segment
-			const remaining = normalized.slice(after);
-			if (words.some((w) => remaining === w || remaining.startsWith(w))) return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Build a worker prompt constraint block listing forbidden paths.
- * This goes into the worker system prompt to prevent accidental reads.
- */
-export function buildSensitivePathConstraint(): string {
-	return [
-		"## Security Constraints",
-		"NEVER read, compress, or include content from:",
-		"- Files matching: .env*, *.pem, *.key, *.p12, credentials*, secrets*, passwords*, id_rsa*",
-		"- Directories: .ssh/, .aws/, .gnupg/, .kube/, .docker/",
-		"- Files with names containing: secret, credential, password, apikey, token, privatekey",
-		"If asked to read such a file, refuse and explain the security risk.",
-	].join("\n");
-}

package/src/runtime/session-resources.ts

@@ -1,25 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { logInternalError } from "../utils/internal-error.ts";
-
-/**
- * Try to register a cleanup function with Pi's session resource cleanup API (v0.72+).
- * Falls back to returning undefined if the API is not available.
- *
- * The returned function (if defined) can be called to unregister the cleanup.
- */
-export function tryRegisterSessionCleanup(pi: ExtensionAPI, cleanup: () => void): (() => void) | undefined {
-	const api = pi as unknown as Record<string, unknown>;
-	const registerFn = api.registerSessionResourceCleanup;
-	if (typeof registerFn === "function") {
-		try {
-			const unregister = (registerFn as (fn: () => void) => (() => void) | void)(cleanup);
-			if (typeof unregister === "function") return unregister;
-			// API returned void — cleanup is registered but cannot be unregistered
-			return undefined;
-		} catch (error) {
-			logInternalError("session-resources.register", error);
-			return undefined;
-		}
-	}
-	return undefined;
-}

package/src/runtime/session-snapshot.ts

@@ -1,59 +0,0 @@
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-
-/**
- * Creates a lightweight snapshot of task state for event emission.
- * Prevents mutation-during-callback issues by copying relevant fields.
- */
-export function snapshotTaskState(task: TeamTaskState): Readonly<TeamTaskState> {
-	return {
-		...task,
-		dependsOn: [...task.dependsOn],
-		usage: task.usage ? { ...task.usage } : undefined,
-		agentProgress: task.agentProgress ? { ...task.agentProgress } : undefined,
-		heartbeat: task.heartbeat ? { ...task.heartbeat } : undefined,
-		modelAttempts: task.modelAttempts?.map((a) => ({ ...a })),
-		modelRouting: task.modelRouting ? { ...task.modelRouting } : undefined,
-		claim: task.claim ? { ...task.claim } : undefined,
-		checkpoint: task.checkpoint ? { ...task.checkpoint } : undefined,
-		attempts: task.attempts?.map((a) => ({ ...a })),
-		worktree: task.worktree ? { ...task.worktree } : undefined,
-	};
-}
-
-/**
- * Session state snapshot for persistence before session switches.
- * Captures the minimal set of data needed to resume operations.
- */
-export interface SessionStateSnapshot {
-	/** ISO timestamp of the snapshot */
-	capturedAt: string;
-	/** Active run IDs at time of snapshot */
-	activeRunIds: string[];
-	/** Number of pending deliveries */
-	pendingDeliveryCount: number;
-	/** Session generation counter */
-	sessionGeneration: number;
-	/** Summary of active tasks by status */
-	taskSummary: Record<string, number>;
-}
-
-/**
- * Create a session state snapshot for pre-switch persistence.
- */
-export function createSessionSnapshot(
-	activeRuns: TeamRunManifest[],
-	pendingDeliveryCount: number,
-	sessionGeneration: number,
-): SessionStateSnapshot {
-	const taskSummary: Record<string, number> = {};
-	for (const run of activeRuns) {
-		taskSummary[run.status] = (taskSummary[run.status] ?? 0) + 1;
-	}
-	return {
-		capturedAt: new Date().toISOString(),
-		activeRunIds: activeRuns.map((r) => r.runId),
-		pendingDeliveryCount,
-		sessionGeneration,
-		taskSummary,
-	};
-}