@selesai/code 0.1.5 → 0.1.6

package/dist/extensions/pi-subagents/src/runs/background/chain-root-attachment.ts

@@ -0,0 +1,161 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AcceptanceLedger, AsyncStatus, ModelAttempt } from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
+
+export interface ImportedAsyncRoot {
+	runId: string;
+	asyncDir: string;
+	resultPath: string;
+	index: number;
+}
+
+export interface ImportedAsyncRootResult {
+	agent: string;
+	output: string;
+	success: boolean;
+	exitCode: number;
+	error?: string;
+	sessionFile?: string;
+	intercomTarget?: string;
+	model?: string;
+	attemptedModels?: string[];
+	modelAttempts?: ModelAttempt[];
+	structuredOutput?: unknown;
+	structuredOutputPath?: string;
+	structuredOutputSchemaPath?: string;
+	acceptance?: AcceptanceLedger;
+}
+
+interface AsyncResultFile {
+	state?: string;
+	success?: boolean;
+	summary?: string;
+	results?: Array<{
+		agent?: string;
+		output?: string;
+		error?: string;
+		success?: boolean;
+		sessionFile?: string;
+		intercomTarget?: string;
+		model?: string;
+		attemptedModels?: string[];
+		modelAttempts?: ModelAttempt[];
+		structuredOutput?: unknown;
+		structuredOutputPath?: string;
+		structuredOutputSchemaPath?: string;
+		acceptance?: AcceptanceLedger;
+	}>;
+}
+
+const TERMINAL_STATES = new Set(["complete", "failed", "paused"]);
+const TERMINAL_STEP_STATUSES = new Set(["complete", "completed", "failed", "paused"]);
+
+function readResultFile(resultPath: string): AsyncResultFile | undefined {
+	try {
+		return JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultFile;
+	} catch (error) {
+		if (typeof error === "object" && error !== null && "code" in error && (error as NodeJS.ErrnoException).code === "ENOENT") {
+			return undefined;
+		}
+		throw error;
+	}
+}
+
+function selectedStatusStep(status: AsyncStatus | null, index: number): NonNullable<AsyncStatus["steps"]>[number] | undefined {
+	return status?.steps?.[index];
+}
+
+function isTerminalStatus(status: AsyncStatus | null, index: number): boolean {
+	if (!status) return false;
+	const step = selectedStatusStep(status, index);
+	if (step && TERMINAL_STEP_STATUSES.has(step.status)) return true;
+	return TERMINAL_STATES.has(status.state);
+}
+
+function resultState(result: AsyncResultFile | undefined, child: NonNullable<AsyncResultFile["results"]>[number] | undefined): "complete" | "failed" | "paused" | undefined {
+	if (!result) return undefined;
+	if (child?.success === true) return "complete";
+	if (child?.success === false) return result.state === "paused" ? "paused" : "failed";
+	if (result.state === "complete" || result.state === "failed" || result.state === "paused") return result.state;
+	if (result.success === true) return "complete";
+	if (result.success === false) return "failed";
+	return undefined;
+}
+
+function outputFromTerminalStatus(root: ImportedAsyncRoot, status: AsyncStatus, step: NonNullable<AsyncStatus["steps"]>[number] | undefined): ImportedAsyncRootResult {
+	const agent = step?.agent ?? status.steps?.[root.index]?.agent ?? "subagent";
+	const message = step?.error ?? status.error ?? `Attached async root ${root.runId} ended without a result file at ${root.resultPath}.`;
+	return {
+		agent,
+		output: message,
+		success: false,
+		exitCode: 1,
+		error: message,
+		...(step?.sessionFile ?? status.sessionFile ? { sessionFile: step?.sessionFile ?? status.sessionFile } : {}),
+		...(step?.model ? { model: step.model } : {}),
+		...(step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
+		...(step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {}),
+		...(step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {}),
+		...(step?.structuredOutputPath ? { structuredOutputPath: step.structuredOutputPath } : {}),
+		...(step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: step.structuredOutputSchemaPath } : {}),
+		...(step?.acceptance ? { acceptance: step.acceptance } : {}),
+	};
+}
+
+function buildImportedResult(root: ImportedAsyncRoot, status: AsyncStatus | null, result: AsyncResultFile): ImportedAsyncRootResult {
+	const child = result.results?.[root.index];
+	const step = selectedStatusStep(status, root.index);
+	const state = resultState(result, child);
+	const agent = child?.agent ?? step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent";
+	const output = child?.output ?? result.summary ?? "";
+	const success = state === "complete";
+	const error = child?.error ?? (success ? undefined : result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
+	return {
+		agent,
+		output: success ? output : (output || error || ""),
+		success,
+		exitCode: success ? 0 : 1,
+		...(error ? { error } : {}),
+		...(child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile ? { sessionFile: child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile } : {}),
+		...(child?.intercomTarget ? { intercomTarget: child.intercomTarget } : {}),
+		...(child?.model ?? step?.model ? { model: child?.model ?? step?.model } : {}),
+		...(child?.attemptedModels ?? step?.attemptedModels ? { attemptedModels: child?.attemptedModels ?? step?.attemptedModels } : {}),
+		...(child?.modelAttempts ?? step?.modelAttempts ? { modelAttempts: child?.modelAttempts ?? step?.modelAttempts } : {}),
+		...(child?.structuredOutput !== undefined ? { structuredOutput: child.structuredOutput } : step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {}),
+		...(child?.structuredOutputPath ?? step?.structuredOutputPath ? { structuredOutputPath: child?.structuredOutputPath ?? step?.structuredOutputPath } : {}),
+		...(child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath } : {}),
+		...(child?.acceptance ?? step?.acceptance ? { acceptance: child?.acceptance ?? step?.acceptance } : {}),
+	};
+}
+
+export async function waitForImportedAsyncRoot(
+	root: ImportedAsyncRoot,
+	options: { pollIntervalMs?: number; terminalResultGraceMs?: number; now?: () => number } = {},
+): Promise<ImportedAsyncRootResult> {
+	const pollIntervalMs = options.pollIntervalMs ?? 500;
+	const terminalResultGraceMs = options.terminalResultGraceMs ?? 1_000;
+	const now = options.now ?? Date.now;
+	let terminalSince: number | undefined;
+	for (;;) {
+		const status = readStatus(root.asyncDir);
+		const result = readResultFile(root.resultPath);
+		if (result) return buildImportedResult(root, status, result);
+		if (isTerminalStatus(status, root.index)) {
+			terminalSince ??= now();
+			if (now() - terminalSince >= terminalResultGraceMs) {
+				return outputFromTerminalStatus(root, status!, selectedStatusStep(status, root.index));
+			}
+		} else {
+			terminalSince = undefined;
+		}
+		if (!status && !fs.existsSync(root.asyncDir)) {
+			throw new Error(`Attached async root '${root.runId}' directory does not exist: ${root.asyncDir}`);
+		}
+		await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+	}
+}
+
+export function resolveAsyncRootResultPath(resultsDir: string, runId: string): string {
+	return path.join(resultsDir, `${runId}.json`);
+}

package/dist/extensions/pi-subagents/src/runs/background/completion-dedupe.ts

@@ -0,0 +1,63 @@
+interface CompletionDataLike {
+	id?: unknown;
+	agent?: unknown;
+	timestamp?: unknown;
+	sessionId?: unknown;
+	taskIndex?: unknown;
+	totalTasks?: unknown;
+	success?: unknown;
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asFiniteNumber(value: unknown): number | undefined {
+	if (typeof value !== "number") return undefined;
+	return Number.isFinite(value) ? value : undefined;
+}
+
+export function buildCompletionKey(data: CompletionDataLike, fallback: string): string {
+	const id = asNonEmptyString(data.id);
+	if (id) return `id:${id}`;
+	const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
+	const agent = asNonEmptyString(data.agent) ?? "unknown";
+	const timestamp = asFiniteNumber(data.timestamp);
+	const taskIndex = asFiniteNumber(data.taskIndex);
+	const totalTasks = asFiniteNumber(data.totalTasks);
+	const success = typeof data.success === "boolean" ? (data.success ? "1" : "0") : "?";
+	return [
+		"meta",
+		sessionId,
+		agent,
+		timestamp !== undefined ? String(timestamp) : "no-ts",
+		taskIndex !== undefined ? String(taskIndex) : "-",
+		totalTasks !== undefined ? String(totalTasks) : "-",
+		success,
+		fallback,
+	].join(":");
+}
+
+function pruneSeenMap(seen: Map<string, number>, now: number, ttlMs: number): void {
+	for (const [key, ts] of seen.entries()) {
+		if (now - ts > ttlMs) seen.delete(key);
+	}
+}
+
+export function markSeenWithTtl(seen: Map<string, number>, key: string, now: number, ttlMs: number): boolean {
+	pruneSeenMap(seen, now, ttlMs);
+	if (seen.has(key)) return true;
+	seen.set(key, now);
+	return false;
+}
+
+export function getGlobalSeenMap(storeKey: string): Map<string, number> {
+	const globalStore = globalThis as Record<string, unknown>;
+	const existing = globalStore[storeKey];
+	if (existing instanceof Map) return existing as Map<string, number>;
+	const map = new Map<string, number>();
+	globalStore[storeKey] = map;
+	return map;
+}

package/dist/extensions/pi-subagents/src/runs/background/control-channel.ts

@@ -0,0 +1,177 @@
+/**
+ * Cross-OS control channel for async subagent runs.
+ *
+ * Background runs are detached OS processes. The original control path delivered
+ * an interrupt with `process.kill(pid, SIGUSR2|SIGBREAK)`, but Windows cannot
+ * deliver those signals cross-process via `process.kill` and throws `ENOSYS`,
+ * which left async runs uninterruptible (no stop, no live steer) on Windows.
+ *
+ * This module adds a portable, file-based control inbox inside the run directory.
+ * The parent drops an interrupt request file; the runner watches the inbox and
+ * routes the request into its existing graceful `interruptRunner()` (pause +
+ * resumable), identically on every platform. The OS signal is kept only as an
+ * opportunistic fast-path; its failure is non-fatal because the file inbox is
+ * authoritative.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { POLL_INTERVAL_MS } from "../../shared/types.ts";
+
+/**
+ * Opportunistic fast-path interrupt signal. On Unix `SIGUSR2` is trapped by the
+ * runner; on Windows `process.kill(pid, "SIGBREAK")` is not deliverable
+ * cross-process and throws `ENOSYS`, so the file inbox below is the real channel.
+ */
+export const INTERRUPT_SIGNAL: NodeJS.Signals = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2";
+
+export type ControlChannelFs = Pick<typeof fs, "mkdirSync" | "existsSync" | "rmSync" | "watch">;
+export type ControlChannelTimers = { setInterval: typeof setInterval; clearInterval: typeof clearInterval };
+type KillFn = (pid: number, signal?: NodeJS.Signals | 0) => unknown;
+
+export interface InterruptRequest {
+	type: "interrupt";
+	ts?: number;
+	source?: string;
+	reason?: string;
+}
+
+/** Control inbox directory inside an async run dir. */
+export function controlInboxDir(asyncDir: string): string {
+	return path.join(asyncDir, "control");
+}
+
+/** Path of the portable interrupt request file. */
+export function interruptRequestPath(asyncDir: string): string {
+	return path.join(controlInboxDir(asyncDir), "interrupt.json");
+}
+
+/**
+ * Parent side: drop a portable interrupt request the runner's inbox watcher will
+ * pick up regardless of OS. Written atomically (temp + rename), dir auto-created.
+ */
+export function requestAsyncInterrupt(
+	asyncDir: string,
+	payload: Omit<InterruptRequest, "type"> = {},
+	deps: { now?: () => number } = {},
+): string {
+	const requestPath = interruptRequestPath(asyncDir);
+	const request: InterruptRequest = { ...payload, ts: payload.ts ?? deps.now?.() ?? Date.now(), type: "interrupt" };
+	writeAtomicJson(requestPath, request);
+	return requestPath;
+}
+
+/**
+ * Runner side: consume a pending interrupt request. Idempotent — removes the file
+ * so each distinct request fires exactly once. Returns whether one was pending.
+ */
+export function consumeInterruptRequest(
+	asyncDir: string,
+	fsImpl: Pick<typeof fs, "existsSync" | "rmSync"> = fs,
+): boolean {
+	const requestPath = interruptRequestPath(asyncDir);
+	if (!fsImpl.existsSync(requestPath)) return false;
+	try {
+		fsImpl.rmSync(requestPath, { force: true, recursive: true });
+	} catch {
+		// Already removed by a concurrent check — still counts as consumed.
+	}
+	return true;
+}
+
+/**
+ * Parent side: portable interrupt = authoritative file request + best-effort OS
+ * signal. The signal is only a latency optimization on Unix; ENOSYS on Windows
+ * is swallowed because the file inbox is authoritative there. Other signal
+ * failures are surfaced because they usually mean the runner is not alive to
+ * consume the request.
+ */
+export function deliverInterruptRequest(input: {
+	asyncDir: string;
+	pid?: number;
+	kill?: KillFn;
+	signal?: NodeJS.Signals;
+	now?: () => number;
+	source?: string;
+}): void {
+	const requestPath = requestAsyncInterrupt(input.asyncDir, input.source ? { source: input.source } : {}, { now: input.now });
+	if (typeof input.pid === "number" && input.pid > 0) {
+		try {
+			(input.kill ?? process.kill)(input.pid, input.signal ?? INTERRUPT_SIGNAL);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException | undefined)?.code === "ENOSYS") {
+				// File inbox is authoritative when custom cross-process signals are unavailable.
+				return;
+			}
+			try {
+				fs.rmSync(requestPath, { force: true });
+			} catch {
+				// Best effort cleanup; the caller still gets the signal failure.
+			}
+			throw error;
+		}
+	}
+}
+
+/**
+ * Runner side: watch the control inbox and route interrupt requests into
+ * `onInterrupt`. Uses `fs.watch` when available plus an interval poll as a
+ * portable safety net (covers filesystems/platforms where `fs.watch` is
+ * unreliable). Fires once per distinct request. Returns a disposer.
+ */
+export function watchAsyncControlInbox(
+	asyncDir: string,
+	opts: {
+		onInterrupt: () => void;
+		pollIntervalMs?: number;
+		fs?: ControlChannelFs;
+		timers?: ControlChannelTimers;
+	},
+): () => void {
+	const fsImpl = opts.fs ?? fs;
+	const timers = opts.timers ?? { setInterval, clearInterval };
+	const dir = controlInboxDir(asyncDir);
+	try {
+		fsImpl.mkdirSync(dir, { recursive: true });
+	} catch {
+		// Best effort — the poll/watch below tolerates a missing dir.
+	}
+
+	let disposed = false;
+	const check = (): void => {
+		if (disposed) return;
+		try {
+			if (consumeInterruptRequest(asyncDir, fsImpl)) opts.onInterrupt();
+		} catch {
+			// Never let inbox errors crash the runner.
+		}
+	};
+
+	// Handle a request that may have arrived before the watcher started.
+	check();
+
+	let watcher: fs.FSWatcher | undefined;
+	try {
+		watcher = fsImpl.watch(dir, () => check());
+		watcher.on?.("error", () => {
+			// fs.watch can emit on transient FS errors; the interval poll keeps us live.
+		});
+	} catch {
+		watcher = undefined;
+	}
+
+	const interval = timers.setInterval(check, opts.pollIntervalMs ?? POLL_INTERVAL_MS);
+	interval.unref?.();
+
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		try {
+			watcher?.close();
+		} catch {
+			// ignore
+		}
+		timers.clearInterval(interval);
+	};
+}

package/dist/extensions/pi-subagents/src/runs/background/notify.ts

@@ -0,0 +1,108 @@
+/**
+ * Subagent completion notifications.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
+
+interface ChainStepResult {
+	agent: string;
+	output: string;
+	success: boolean;
+}
+
+export interface SubagentNotifyDetails {
+	agent: string;
+	status: "completed" | "failed" | "paused";
+	taskInfo?: string;
+	resultPreview: string;
+	durationMs?: number;
+	sessionLabel?: string;
+	sessionValue?: string;
+}
+
+interface SubagentResult {
+	id: string | null;
+	agent: string | null;
+	success: boolean;
+	summary: string;
+	exitCode?: number;
+	state?: string;
+	timestamp: number;
+	durationMs?: number;
+	sessionFile?: string;
+	shareUrl?: string;
+	gistUrl?: string;
+	shareError?: string;
+	results?: ChainStepResult[];
+	taskIndex?: number;
+	totalTasks?: number;
+}
+
+export default function registerSubagentNotify(pi: ExtensionAPI): void {
+	const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
+	const globalStore = globalThis as Record<string, unknown>;
+	const previousUnsubscribe = globalStore[unsubscribeStoreKey];
+	if (typeof previousUnsubscribe === "function") {
+		try {
+			previousUnsubscribe();
+		} catch {
+			// Best effort cleanup for stale handlers from an older reload.
+		}
+	}
+
+	const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
+	const ttlMs = 10 * 60 * 1000;
+
+	const handleComplete = (data: unknown) => {
+		const result = data as SubagentResult;
+		const now = Date.now();
+		const key = buildCompletionKey(result, "notify");
+		if (markSeenWithTtl(seen, key, now, ttlMs)) return;
+
+		const agent = result.agent ?? "unknown";
+		const summary = typeof result.summary === "string" ? result.summary : "";
+		const paused = !result.success && (
+			result.exitCode === 0
+			|| result.state === "paused"
+			|| summary.startsWith("Paused after interrupt.")
+		);
+		const status = paused ? "paused" : result.success ? "completed" : "failed";
+
+		const taskInfo =
+			result.taskIndex !== undefined && result.totalTasks !== undefined
+				? ` (${result.taskIndex + 1}/${result.totalTasks})`
+				: "";
+
+		const sessionLine = result.shareUrl
+			? `Session: ${result.shareUrl}`
+			: result.shareError
+				? `Session share error: ${result.shareError}`
+				: result.sessionFile
+					? `Session file: ${result.sessionFile}`
+					: undefined;
+
+		const displaySummary = summary.trim() ? summary : "(no output)";
+		const content = [
+			`Background task ${status}: **${agent}**${taskInfo}`,
+			"",
+			displaySummary,
+			sessionLine ? "" : undefined,
+			sessionLine,
+		]
+			.filter((line) => line !== undefined)
+			.join("\n");
+
+		pi.sendMessage(
+			{
+				customType: "subagent-notify",
+				content,
+				display: true,
+			},
+			{ triggerTurn: true },
+		);
+	};
+
+	globalStore[unsubscribeStoreKey] = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
+}

package/dist/extensions/pi-subagents/src/runs/background/parallel-groups.ts

@@ -0,0 +1,45 @@
+import type { AsyncParallelGroupStatus } from "../../shared/types.ts";
+
+function isValidParallelGroup(group: unknown, stepCount: number, chainStepCount: number): group is AsyncParallelGroupStatus {
+	if (typeof group !== "object" || group === null) return false;
+	const { start, count, stepIndex } = group as Partial<AsyncParallelGroupStatus>;
+	return typeof start === "number"
+		&& typeof count === "number"
+		&& typeof stepIndex === "number"
+		&& Number.isInteger(start)
+		&& Number.isInteger(count)
+		&& Number.isInteger(stepIndex)
+		&& start >= 0
+		&& count > 0
+		&& stepIndex >= 0
+		&& stepIndex < chainStepCount
+		&& start + count <= stepCount;
+}
+
+export function normalizeParallelGroups(groups: unknown, stepCount: number, chainStepCount: number): AsyncParallelGroupStatus[] {
+	if (!Array.isArray(groups)) return [];
+	return groups
+		.filter((group): group is AsyncParallelGroupStatus => isValidParallelGroup(group, stepCount, chainStepCount))
+		.sort((left, right) => left.stepIndex - right.stepIndex || left.start - right.start);
+}
+
+export function flatToLogicalStepIndex(flatIndex: number, chainStepCount: number, groups: AsyncParallelGroupStatus[]): number {
+	let logicalIndex = 0;
+	let cursor = 0;
+	for (const group of groups) {
+		while (cursor < group.start && logicalIndex < chainStepCount) {
+			if (cursor === flatIndex) return logicalIndex;
+			cursor++;
+			logicalIndex++;
+		}
+		if (flatIndex >= group.start && flatIndex < group.start + group.count) return group.stepIndex;
+		cursor = group.start + group.count;
+		logicalIndex = group.stepIndex + 1;
+	}
+	while (cursor <= flatIndex && logicalIndex < chainStepCount) {
+		if (cursor === flatIndex) return logicalIndex;
+		cursor++;
+		logicalIndex++;
+	}
+	return Math.max(0, chainStepCount - 1);
+}