pi-ui-extend 0.1.1

package/external/pi-tools-suite/src/async-subagents/core/state.ts

@@ -0,0 +1,281 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isDir } from "./paths.js";
+import { readStructuredResult } from "./structured-result.js";
+import type { AgentResult, AgentState, RpcEventRecord, RunState } from "./types.js";
+
+const MAX_RPC_EVENT_LINE_CHARS = 1024 * 1024;
+
+interface AgentStateReadOptions {
+	includeLineCounts?: boolean;
+	checkRpcPromptFailure?: boolean;
+}
+
+export function getAgentState(
+	runDir: string,
+	agentId: string,
+	options: AgentStateReadOptions = {},
+): AgentState | null {
+	const agentDir = path.join(runDir, agentId);
+	if (!isDir(agentDir)) return null;
+	if (!fs.existsSync(path.join(agentDir, "prompt.md"))) return null;
+	const includeLineCounts = options.includeLineCounts ?? true;
+	const checkRpcPromptFailure = options.checkRpcPromptFailure ?? true;
+
+	const state: AgentState = { id: agentId, status: "planned" };
+	const pid = readPid(path.join(agentDir, "pid"));
+	if (pid !== undefined) state.pid = pid;
+
+	const exitCodeFile = path.join(agentDir, "exit_code");
+	if (fs.existsSync(exitCodeFile)) {
+		const code = parseInt(fs.readFileSync(exitCodeFile, "utf-8").trim(), 10);
+		if (isNaN(code)) {
+			state.status = "stopped";
+		} else {
+			state.exitCode = code;
+			state.status = code === 0 ? "done" : "failed";
+		}
+	} else if (
+		checkRpcPromptFailure &&
+		hasRpcPromptFailure(path.join(agentDir, "events.jsonl"))
+	) {
+		state.exitCode = 1;
+		state.status = "failed";
+	} else {
+		if (pid !== undefined) {
+			try {
+				process.kill(pid, 0);
+				state.status = "running";
+			} catch {
+				state.status = "stopped";
+			}
+		}
+	}
+
+	const startedAtFile = path.join(agentDir, "started_at");
+	if (fs.existsSync(startedAtFile)) {
+		state.startedAt = fs.readFileSync(startedAtFile, "utf-8").trim();
+	}
+
+	const finishedAtFile = path.join(agentDir, "finished_at");
+	if (fs.existsSync(finishedAtFile)) {
+		state.finishedAt = fs.readFileSync(finishedAtFile, "utf-8").trim();
+	}
+
+	const retryPendingFile = path.join(agentDir, "retry_pending");
+	const stopRequestedFile = path.join(agentDir, "stop_requested");
+	if (fs.existsSync(retryPendingFile) && !fs.existsSync(stopRequestedFile) && state.status !== "running" && state.status !== "done") {
+		state.status = "retrying";
+		const nextRetryAt = readTrimmed(path.join(agentDir, "next_retry_at"));
+		if (nextRetryAt) state.nextRetryAt = nextRetryAt;
+	}
+
+	if (includeLineCounts) {
+		const resultLines = countFileLines(path.join(agentDir, "result.md"));
+		if (resultLines !== undefined) state.resultLines = resultLines;
+
+		const stderrLines = countFileLines(path.join(agentDir, "stderr.log"));
+		if (stderrLines !== undefined && stderrLines > 0)
+			state.stderrLines = stderrLines;
+
+		const eventLines = countFileLines(path.join(agentDir, "events.jsonl"));
+		if (eventLines !== undefined) state.eventLines = eventLines;
+	}
+
+	// Read retry count if present.
+	const retryCountFile = path.join(agentDir, "retry_count");
+	if (fs.existsSync(retryCountFile)) {
+		const count = parseInt(fs.readFileSync(retryCountFile, "utf-8").trim(), 10);
+		if (!isNaN(count) && count > 0) state.retryCount = count;
+	}
+
+	return state;
+}
+
+function readTrimmed(filePath: string): string | undefined {
+	if (!fs.existsSync(filePath)) return undefined;
+	const value = fs.readFileSync(filePath, "utf-8").trim();
+	return value || undefined;
+}
+
+function readPid(pidFile: string): number | undefined {
+	if (!fs.existsSync(pidFile)) return undefined;
+	const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+	return isNaN(pid) ? undefined : pid;
+}
+
+function hasRpcPromptFailure(eventsFile: string): boolean {
+	if (!fs.existsSync(eventsFile)) return false;
+	let fd: number | undefined;
+	try {
+		fd = fs.openSync(eventsFile, "r");
+		const buffer = Buffer.allocUnsafe(64 * 1024);
+		const decoder = new TextDecoder();
+		let pending = "";
+
+		while (true) {
+			const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+			if (bytesRead === 0) break;
+			pending += decoder.decode(buffer.subarray(0, bytesRead), { stream: true });
+			if (pending.length > MAX_RPC_EVENT_LINE_CHARS) return false;
+			const lines = pending.split(/\r?\n/);
+			pending = lines.pop() ?? "";
+			for (const line of lines) {
+				if (isRpcPromptFailureLine(line)) return true;
+			}
+		}
+
+		pending += decoder.decode();
+		if (isRpcPromptFailureLine(pending)) return true;
+	} catch {
+		return false;
+	} finally {
+		if (fd !== undefined) fs.closeSync(fd);
+	}
+	return false;
+}
+
+function isRpcPromptFailureLine(line: string): boolean {
+	if (!line.trim()) return false;
+	const event = JSON.parse(line) as RpcEventRecord;
+	return event.type === "response" && event.command === "prompt" && event.success === false;
+}
+
+function countFileLines(filePath: string): number | undefined {
+	if (!fs.existsSync(filePath)) return undefined;
+	let fd: number | undefined;
+	try {
+		fd = fs.openSync(filePath, "r");
+		const buffer = Buffer.allocUnsafe(64 * 1024);
+		let newlines = 0;
+		let bytesTotal = 0;
+		let lastByte: number | undefined;
+
+		while (true) {
+			const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+			if (bytesRead === 0) break;
+			bytesTotal += bytesRead;
+			for (let i = 0; i < bytesRead; i++) {
+				if (buffer[i] === 0x0a) newlines++;
+			}
+			lastByte = buffer[bytesRead - 1];
+		}
+
+		if (bytesTotal === 0) return 0;
+		return lastByte === 0x0a ? newlines : newlines + 1;
+	} catch {
+		return undefined;
+	} finally {
+		if (fd !== undefined) fs.closeSync(fd);
+	}
+}
+
+export function getRunState(
+	runDir: string,
+	filterIds?: string[],
+	options: AgentStateReadOptions = {},
+): RunState {
+	const agents: AgentState[] = [];
+	const launchedIds = new Set<string>();
+
+	if (!isDir(runDir)) return { runDir, agents };
+
+	// Read launched agent dirs
+	for (const entry of fs.readdirSync(runDir, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		if (!fs.existsSync(path.join(runDir, entry.name, "prompt.md"))) continue;
+		if (filterIds && !filterIds.includes(entry.name)) continue;
+		const state = getAgentState(runDir, entry.name, options);
+		if (state) {
+			agents.push(state);
+			launchedIds.add(entry.name);
+		}
+	}
+
+	// Check for planned agents (prompts without launched agent dirs)
+	const promptsDir = path.join(runDir, "prompts");
+	if (isDir(promptsDir)) {
+		for (const pf of fs.readdirSync(promptsDir)) {
+			if (!pf.endsWith(".md")) continue;
+			const id = pf.slice(0, -3);
+			if (launchedIds.has(id)) continue;
+			if (filterIds && !filterIds.includes(id)) continue;
+			agents.push({ id, status: "planned" });
+		}
+	}
+
+	return { runDir, agents };
+}
+
+export function readResult(
+	runDir: string,
+	agentId: string,
+): AgentResult | null {
+	const state = getAgentState(runDir, agentId);
+	if (!state) return null;
+
+	const agentDir = path.join(runDir, agentId);
+	let result: string | undefined;
+	let stderr: string | undefined;
+
+	const resultFile = path.join(agentDir, "result.md");
+	if (fs.existsSync(resultFile)) {
+		result = fs.readFileSync(resultFile, "utf-8");
+	}
+
+	const stderrFile = path.join(agentDir, "stderr.log");
+	if (fs.existsSync(stderrFile)) {
+		const content = fs.readFileSync(stderrFile, "utf-8");
+		if (content.trim()) stderr = content;
+	}
+
+	const structured = readStructuredResult(agentDir);
+
+	return { result, stderr, exitCode: state.exitCode, state, structured };
+}
+
+export async function waitForAgents(
+	runDir: string,
+	agentIds: string[] | undefined,
+	options: {
+		timeout?: number;
+		interval?: number;
+		failFast?: boolean;
+		signal?: AbortSignal;
+	} = {},
+): Promise<RunState> {
+	const timeout = options.timeout ?? 300;
+	const interval = options.interval ?? 3;
+	const failFast = options.failFast ?? false;
+
+	const start = Date.now();
+
+	while (true) {
+		const state = getRunState(runDir, agentIds);
+		const terminal = state.agents.filter(
+			(a) =>
+				a.status === "done" || a.status === "failed" || a.status === "stopped",
+		);
+
+		if (
+			failFast &&
+			terminal.some((a) => a.status === "failed" || a.status === "stopped")
+		) {
+			return state;
+		}
+
+		if (state.agents.length === 0 || terminal.length === state.agents.length) {
+			return state;
+		}
+
+		if (Date.now() - start >= timeout * 1000) {
+			return state;
+		}
+
+		if (options.signal?.aborted) {
+			return state;
+		}
+
+		await new Promise((resolve) => setTimeout(resolve, interval * 1000));
+	}
+}

package/external/pi-tools-suite/src/async-subagents/core/stop.ts

@@ -0,0 +1,131 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentState, getRunState } from "./state.js";
+import { terminateProcess } from "./process.js";
+import { writeStructuredResult } from "./structured-result.js";
+import type { AgentState } from "./types.js";
+import { isoNow } from "./utils.js";
+
+export type StopSignal = "SIGTERM" | "SIGINT" | "SIGKILL";
+
+export interface StopAgentResult {
+	id: string;
+	previousStatus: AgentState["status"];
+	pid?: number;
+	stopped: boolean;
+	signal?: StopSignal;
+	message?: string;
+	error?: string;
+}
+
+const stopSignals = new Set<StopSignal>(["SIGTERM", "SIGINT", "SIGKILL"]);
+
+export function validateStopSignal(signal: string): StopSignal {
+	if (stopSignals.has(signal as StopSignal)) return signal as StopSignal;
+	throw new Error(`Unsupported stop signal "${signal}". Use SIGTERM, SIGINT, or SIGKILL.`);
+}
+
+export function stopAgents(
+	runDir: string,
+	agentIds?: string[],
+	options: { signal?: StopSignal } = {},
+): StopAgentResult[] {
+	const signal = options.signal ?? "SIGTERM";
+	const state = getRunState(runDir, agentIds);
+
+	return state.agents.map((agent) => stopAgent(runDir, agent, signal));
+}
+
+function stopAgent(runDir: string, agent: AgentState, signal: StopSignal): StopAgentResult {
+	const result: StopAgentResult = {
+		id: agent.id,
+		previousStatus: agent.status,
+		pid: agent.pid,
+		stopped: false,
+	};
+
+	if (agent.status === "planned" || agent.status === "retrying") {
+		markStopped(runDir, agent.id, signal, agent.status === "planned" ? "Sub-agent stopped before launch." : "Sub-agent retry cancelled before relaunch.");
+		return {
+			...result,
+			stopped: true,
+			signal,
+			message: `marked ${agent.status} agent stopped`,
+		};
+	}
+
+	if (agent.status !== "running") {
+		result.message = `agent is ${agent.status}`;
+		return result;
+	}
+
+	if (!agent.pid) {
+		markStopped(runDir, agent.id, signal);
+		return {
+			...result,
+			stopped: true,
+			signal,
+			message: "running status had no pid; marked stopped",
+		};
+	}
+
+	try {
+		terminateProcess(agent.pid, signal);
+		markStopped(runDir, agent.id, signal);
+		return {
+			...result,
+			stopped: true,
+			signal,
+			message: "stop signal sent",
+		};
+	} catch (error) {
+		const code = typeof error === "object" && error && "code" in error ? String((error as { code?: unknown }).code) : undefined;
+		if (code === "ESRCH") {
+			markStopped(runDir, agent.id, signal);
+			const refreshed = getAgentState(runDir, agent.id);
+			return {
+				...result,
+				previousStatus: refreshed?.status ?? agent.status,
+				stopped: true,
+				signal,
+				message: "process was already gone; marked stopped",
+			};
+		}
+
+		return {
+			...result,
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+function markStopped(runDir: string, agentId: string, signal: StopSignal, resultText = "Sub-agent stop requested."): void {
+	const agentDir = path.join(runDir, agentId);
+	const now = isoNow();
+	fs.mkdirSync(agentDir, { recursive: true });
+	ensurePromptFile(runDir, agentId, agentDir, resultText);
+	fs.writeFileSync(path.join(agentDir, "stop_requested"), now, "utf-8");
+	fs.writeFileSync(path.join(agentDir, "stop_signal"), signal, "utf-8");
+	fs.rmSync(path.join(agentDir, "retry_pending"), { force: true });
+	fs.rmSync(path.join(agentDir, "next_retry_at"), { force: true });
+	if (!fs.existsSync(path.join(agentDir, "result.md"))) fs.writeFileSync(path.join(agentDir, "result.md"), resultText, "utf-8");
+	fs.writeFileSync(path.join(agentDir, "exit_code"), "stopped", "utf-8");
+	fs.writeFileSync(path.join(agentDir, "finished_at"), now, "utf-8");
+	const state = getAgentState(runDir, agentId, { includeLineCounts: false }) ?? { id: agentId, status: "stopped" as const, finishedAt: now };
+	try {
+		writeStructuredResult({ agentDir, agentId, state });
+	} catch {
+		// Stop is best-effort; failure to write metadata must not hide the stop result.
+	}
+}
+
+function ensurePromptFile(runDir: string, agentId: string, agentDir: string, fallback: string): void {
+	const promptFile = path.join(agentDir, "prompt.md");
+	if (fs.existsSync(promptFile)) return;
+	const queuedPromptFile = path.join(runDir, "prompts", `${agentId}.md`);
+	if (fs.existsSync(queuedPromptFile)) {
+		fs.copyFileSync(queuedPromptFile, promptFile);
+		return;
+	}
+	fs.writeFileSync(promptFile, fallback, "utf-8");
+}

package/external/pi-tools-suite/src/async-subagents/core/structured-result.ts

@@ -0,0 +1,237 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentState, StructuredFileReference, StructuredFinding, StructuredResult, StructuredRisk, StructuredSeverity } from "./types.js";
+
+const DEFAULT_MAX_RESULT_BYTES = 100_000;
+const STDERR_PREVIEW_CHARS = 500;
+
+export interface WriteStructuredResultOptions {
+	agentDir: string;
+	agentId: string;
+	state: AgentState;
+	subagentType?: string;
+	model?: string;
+	maxResultBytes?: number;
+}
+
+/**
+ * Build a StructuredResult from the current agent state and files.
+ * Reads result.md and stderr.log from agentDir.
+ */
+export function buildStructuredResult(opts: WriteStructuredResultOptions): StructuredResult {
+	const { agentDir, agentId, state, subagentType, model, maxResultBytes } = opts;
+	const maxBytes = maxResultBytes ?? DEFAULT_MAX_RESULT_BYTES;
+
+	const structured: StructuredResult = {
+		schemaVersion: 2,
+		agentId,
+		status: state.status,
+	};
+
+	if (state.exitCode !== undefined) structured.exitCode = state.exitCode;
+	if (state.startedAt) structured.startedAt = state.startedAt;
+	if (state.finishedAt) structured.finishedAt = state.finishedAt;
+
+	// Compute duration
+	if (state.startedAt && state.finishedAt) {
+		const start = new Date(state.startedAt).getTime();
+		const end = new Date(state.finishedAt).getTime();
+		if (!isNaN(start) && !isNaN(end) && end >= start) {
+			structured.durationSeconds = Math.round((end - start) / 1000);
+		}
+	}
+
+	if (state.retryCount && state.retryCount > 0) structured.retryCount = state.retryCount;
+	if (subagentType) structured.subagentType = subagentType;
+	if (model) structured.model = model;
+
+	// Read result.md
+	const resultFile = path.join(agentDir, "result.md");
+	if (fs.existsSync(resultFile)) {
+		const fullText = fs.readFileSync(resultFile, "utf-8");
+		const originalBytes = Buffer.byteLength(fullText, "utf-8");
+		const structuredText = maxBytes > 0 && originalBytes > maxBytes
+			? truncateToBytes(fullText, maxBytes)
+			: fullText;
+		if (maxBytes > 0 && originalBytes > maxBytes) {
+			// Truncate result.json's resultText at a character boundary close to the byte limit.
+			structured.resultText = structuredText;
+			structured.resultTruncated = true;
+			structured.resultOriginalBytes = originalBytes;
+		} else {
+			structured.resultText = structuredText;
+		}
+		Object.assign(structured, extractStructuredFields(fullText));
+	}
+
+	// Read stderr preview
+	const stderrFile = path.join(agentDir, "stderr.log");
+	if (fs.existsSync(stderrFile)) {
+		const stderr = fs.readFileSync(stderrFile, "utf-8").trim();
+		if (stderr) {
+			structured.stderrPreview = stderr.length > STDERR_PREVIEW_CHARS
+				? stderr.slice(0, STDERR_PREVIEW_CHARS) + "..."
+				: stderr;
+		}
+	}
+
+	return structured;
+}
+
+function extractStructuredFields(text: string): Pick<StructuredResult, "summary" | "findings" | "files" | "risks" | "nextActions" | "confidence"> {
+	const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	const result: Pick<StructuredResult, "summary" | "findings" | "files" | "risks" | "nextActions" | "confidence"> = {};
+	const summary = firstSummaryLine(lines);
+	if (summary) result.summary = trimMarkdownMarker(summary);
+	const findings = extractFindings(lines);
+	if (findings.length > 0) result.findings = findings;
+	const files = extractFileReferences(text);
+	if (files.length > 0) result.files = files;
+	const risks = extractRisks(lines);
+	if (risks.length > 0) result.risks = risks;
+	const nextActions = extractNextActions(lines);
+	if (nextActions.length > 0) result.nextActions = nextActions;
+	const confidence = extractConfidence(text);
+	if (confidence) result.confidence = confidence;
+	return result;
+}
+
+function firstSummaryLine(lines: string[]): string | undefined {
+	for (const line of lines) {
+		const stripped = trimMarkdownMarker(line);
+		if (!stripped || /^#{1,6}\s/.test(line)) continue;
+		if (/^(summary|итог|вывод)\s*:?$/i.test(stripped)) continue;
+		return stripped.length > 300 ? `${stripped.slice(0, 297)}...` : stripped;
+	}
+	return undefined;
+}
+
+function extractFindings(lines: string[]): StructuredFinding[] {
+	const findings: StructuredFinding[] = [];
+	for (const line of lines) {
+		if (!/^([-*•]|\d+[.)])\s+/.test(line)) continue;
+		const text = trimMarkdownMarker(line);
+		if (!text) continue;
+		const finding: StructuredFinding = { text: text.length > 500 ? `${text.slice(0, 497)}...` : text };
+		const severity = extractSeverity(text);
+		if (severity) finding.severity = severity;
+		const file = extractFirstFileReference(text);
+		if (file) Object.assign(finding, file);
+		findings.push(finding);
+		if (findings.length >= 20) break;
+	}
+	return findings;
+}
+
+function extractRisks(lines: string[]): StructuredRisk[] {
+	const risks: StructuredRisk[] = [];
+	for (const line of lines) {
+		if (!/(risk|risky|danger|unsafe|security|vulnerab|ошиб|риск|опас|уязвим|критич)/i.test(line)) continue;
+		const text = trimMarkdownMarker(line);
+		if (!text) continue;
+		const risk: StructuredRisk = { text: text.length > 500 ? `${text.slice(0, 497)}...` : text };
+		const severity = extractSeverity(text);
+		if (severity) risk.severity = severity;
+		risks.push(risk);
+		if (risks.length >= 10) break;
+	}
+	return risks;
+}
+
+function extractNextActions(lines: string[]): string[] {
+	const actions: string[] = [];
+	for (const line of lines) {
+		if (!/(next|recommend|todo|fix|should|нужно|след|рекоменд|исправ|добав)/i.test(line)) continue;
+		const text = trimMarkdownMarker(line);
+		if (!text) continue;
+		actions.push(text.length > 500 ? `${text.slice(0, 497)}...` : text);
+		if (actions.length >= 10) break;
+	}
+	return actions;
+}
+
+function extractFileReferences(text: string): StructuredFileReference[] {
+	const refs = new Map<string, StructuredFileReference>();
+	const pattern = /(?:^|[\s`'"(])((?:[\w.-]+\/)+(?:[\w.-]+)(?::(\d+))?)/g;
+	let match: RegExpExecArray | null;
+	while ((match = pattern.exec(text))) {
+		const rawPath = match[1];
+		if (!/\.[A-Za-z0-9]+(?::\d+)?$/.test(rawPath)) continue;
+		const filePath = rawPath.replace(/:\d+$/, "");
+		const line = match[2] ? Number.parseInt(match[2], 10) : undefined;
+		const key = `${filePath}:${line ?? ""}`;
+		if (!refs.has(key)) refs.set(key, line ? { path: filePath, line } : { path: filePath });
+		if (refs.size >= 50) break;
+	}
+	return Array.from(refs.values());
+}
+
+function extractFirstFileReference(text: string): { file: string; line?: number } | undefined {
+	const [first] = extractFileReferences(text);
+	return first ? { file: first.path, line: first.line } : undefined;
+}
+
+function extractSeverity(text: string): StructuredSeverity | undefined {
+	if (/\b(critical|blocker|urgent|критич|блокер)\b/i.test(text)) return "critical";
+	if (/\b(high|major|высок)\b/i.test(text)) return "high";
+	if (/\b(medium|moderate|средн)\b/i.test(text)) return "medium";
+	if (/\b(low|minor|низк)\b/i.test(text)) return "low";
+	return undefined;
+}
+
+function extractConfidence(text: string): "low" | "medium" | "high" | undefined {
+	const match = /confidence\s*[:=-]\s*(low|medium|high)/i.exec(text);
+	return match ? match[1].toLowerCase() as "low" | "medium" | "high" : undefined;
+}
+
+function trimMarkdownMarker(line: string): string {
+	let stripped = line
+		.replace(/^#{1,6}\s+/, "")
+		.replace(/^([-*•]|\d+[.)])\s+/, "")
+		.trim();
+	const boldPrefix = /^\*\*(.*?)\*\*:?\s*(.*)$/.exec(stripped);
+	if (boldPrefix) stripped = `${boldPrefix[1].replace(/:$/, "")}: ${boldPrefix[2]}`.trim();
+	return stripped;
+}
+
+/**
+ * Write result.json to the agent directory.
+ */
+export function writeStructuredResult(opts: WriteStructuredResultOptions): StructuredResult {
+	const structured = buildStructuredResult(opts);
+	const jsonPath = path.join(opts.agentDir, "result.json");
+	fs.writeFileSync(jsonPath, JSON.stringify(structured, null, 2), "utf-8");
+	return structured;
+}
+
+/**
+ * Read result.json from agent directory, if it exists.
+ */
+export function readStructuredResult(agentDir: string): StructuredResult | undefined {
+	const jsonPath = path.join(agentDir, "result.json");
+	if (!fs.existsSync(jsonPath)) return undefined;
+	try {
+		return JSON.parse(fs.readFileSync(jsonPath, "utf-8")) as StructuredResult;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Truncate a string so its UTF-8 byte length is at most maxBytes.
+ */
+function truncateToBytes(text: string, maxBytes: number): string {
+	if (Buffer.byteLength(text, "utf-8") <= maxBytes) return text;
+	// Binary search for the right character count
+	let lo = 0;
+	let hi = text.length;
+	while (lo < hi) {
+		const mid = (lo + hi + 1) >> 1;
+		if (Buffer.byteLength(text.slice(0, mid), "utf-8") <= maxBytes) {
+			lo = mid;
+		} else {
+			hi = mid - 1;
+		}
+	}
+	return text.slice(0, lo);
+}

package/external/pi-tools-suite/src/async-subagents/core/tool-guard.ts

@@ -0,0 +1,34 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+export const SUBAGENT_DENIED_TOOLS = new Set([
+	"question",
+	"subagents",
+	"async_subagents_spawn",
+	"async_subagents_status",
+	"async_subagents_wait",
+	"async_subagents_result",
+	"async_subagents_stop",
+	"async_subagents_cleanup",
+]);
+
+export function filterSubagentTools(tools: readonly string[] | undefined): string[] | undefined {
+	if (!tools) return undefined;
+	return tools.filter((tool) => !SUBAGENT_DENIED_TOOLS.has(tool));
+}
+
+export default function subagentToolGuard(pi: ExtensionAPI): void {
+	const toolApi = pi as ExtensionAPI & {
+		getActiveTools?: () => string[];
+		setActiveTools?: (tools: string[]) => void;
+	};
+
+	const applyGuard = () => {
+		const activeTools = toolApi.getActiveTools?.() ?? [];
+		const filtered = filterSubagentTools(activeTools) ?? [];
+		if (filtered.length === activeTools.length) return;
+		toolApi.setActiveTools?.(filtered);
+	};
+
+	pi.on("session_start", applyGuard);
+	pi.on("model_select", applyGuard);
+}