pi-subagents 0.69.0 → 0.70.1

package/src/runs/shared/task-intent.ts

@@ -1,244 +0,0 @@
-/**
- * Shared task mutation-intent classifier.
- *
- * Single authority for reading a task's wording, answering two different
- * questions from one prohibition analysis:
- *
- * - `classifyTaskMutationIntent` / `expectsImplementationMutation`: does the
- *   task REQUIRE file changes? Consumed by the completion mutation guard,
- *   which blocks completion, so its vocabulary is deliberately narrow.
- *   Verbs inside filenames and path-like tokens do not count.
- * - `taskMayMutate`: COULD the task plausibly change files? Consumed by
- *   acceptance level inference, which only raises evidence gates, so its
- *   vocabulary is deliberately broad (any bare write verb).
- *
- * Explicit read-only wording ("do not modify", "review only") is a task-level
- * intent only when no write imperative survives outside those phrases. A task
- * like "Do not modify tests; implement the fix" is an implementation task with
- * a scoped constraint, not a read-only task.
- */
-
-const REVIEW_ONLY_PATTERNS = [
-	/\b(?:review|read)[- ]only\b/i,
-	/\bno\s+(?:source\s+)?edits?\b/i,
-	/\bwithout\s+edits?\b/i,
-	/\bsuggest fixes only\b/i,
-	/\bonly return findings\b/i,
-	/\breturn findings only\b/i,
-];
-
-const NO_EDIT_BOUNDARY_ASSERTION_PATTERN = /\bno\s+(?:source\s+)?edits?\s*,\s*(?:commits?|pushes?|merges?|installs?|changes?|writes?)\b/i;
-
-const REVIEWER_REQUIRED_EDIT_PATTERNS = [
-	/\bmust\s+(?:edit|modify|change|fix|patch|apply|implement)\b/i,
-	/\brequired\s+to\s+(?:edit|modify|change|fix|patch|apply|implement)\b/i,
-	/(?:^|[.!?:;,\n]\s*)implement\s+(?:the\s+)?(?:approved|requested|specified|file|code|source|fix(?:es)?|changes?)\b/i,
-	/\bregardless\s+of\s+findings\b/i,
-	/\balways\s+(?:edit|modify|change|fix|patch|apply|implement)\b/i,
-	/\bapply\s+(?:the\s+)?fix(?:es)?\s+directly\b/i,
-	/\bmake\s+(?:the\s+)?code\s+changes\b/i,
-];
-
-// The prohibition's object ends at punctuation, a serialized line separator,
-// or a coordinating word (but/and/then), so a follow-on clause like "but
-// implement the fix" stays in the text for write-intent testing instead of
-// being swallowed as the object.
-// Accept serialized line separators too: workflow prompts can carry literal
-// `\\n`/`\\r\\n` between clauses instead of decoded newlines.
-const NO_EDIT_PROHIBITION_PATTERN = /(?:\b|\\(?:r\\n|n))(?:do not|don't|must not)\s+(?:edit|modify|write(?:\s+to)?|touch|change|implement)\b((?:(?!\b(?:but|and|then)\b|\\(?:r\\n|n))[^.;,:!?\n–—-])*)/gi;
-const COORDINATED_NO_EDIT_PROHIBITION_PATTERN = /(?:\b|\\(?:r\\n|n))(?:do not|don't|must not)\s+((?=(?:(?!\\(?:r\\n|n))[^.;:!?\n–—-])*\b(?:and|or)\s+(?:edit|modify|write(?:\s+to)?|touch|change)\b)(?:(?!\\(?:r\\n|n))[^.;:!?\n–—-])*?\b(?:and|or)\s+(?:edit|modify|write(?:\s+to)?|touch|change)\b(?:(?!\b(?:but|and|then)\b|\\(?:r\\n|n))[^.;,:!?\n–—-])*)/gi;
-
-/** Objects of a no-edit prohibition that mean "the codebase in general" rather than a named scope. */
-const GENERIC_PROHIBITION_OBJECT = /^\s*(?:(?:any|all|the|these|those|your|our|existing|project|product|source|sources|config|configs|repo|repository)[\s/,-]*)*(?:files?|code|codebase|sources?|anything|repo(?:sitory)?)?\s*$/i;
-const SCOPED_PROHIBITION_CONTINUATION = /^(?:\\(?:r\\n|n)|\r?\n)\s*(?:in|inside|under|within|outside|except|other\s+than|besides)\b/i;
-const OUTPUT_INSTRUCTION_CONTINUATION = /^(?:\\(?:r\\n|n)|\r?\n)\s*(?:in|inside|within)\s+(?:(?:(?:your|the)\s+)(?:final\s+)?|final\s+)(?:output|response|report|answer|reply|message|summary|findings?|analysis|recommendations?)(?:\s*\/\s*(?:output|response|report|answer|reply|message|summary|findings?|analysis|recommendations?))*\b(?![\\/])/i;
-
-function hasScopedProhibitionContinuation(text: string): boolean {
-	return SCOPED_PROHIBITION_CONTINUATION.test(text) && !OUTPUT_INSTRUCTION_CONTINUATION.test(text);
-}
-
-const SCOPED_NO_EDIT_CONSTRAINT_PATTERNS = [
-	/\bdo not edit files?\s+outside\b/i,
-	/\bdo not edit\s+outside\b/i,
-	/\bdo not edit\s+unrelated files?\b/i,
-	/\bdo not change\s+unrelated files?\b/i,
-	/\bdo not modify\s+unrelated files?\b/i,
-];
-
-const NO_TOOL_INTENT_PATTERNS = [
-	/\bno tools? needed\b/i,
-	/\bno tools? required\b/i,
-	/\bwithout using tools\b/i,
-	/\bdo not use tools\b/i,
-	/\bdon't use tools\b/i,
-];
-
-const READ_ONLY_DELIVERABLE_PATTERNS = [
-	/\b(?:draft|write|compose|prepare|produce)\s+(?:(?:a|an|the)\s+)?(?:github\s+)?(?:issue|bug report|issue draft|issue body|proposal|plan|report|summary|findings?|analysis|recommendations?)\b/i,
-	/\b(?:issue|bug report)\s+(?:draft|body|template)\b/i,
-	/\b(?:return|provide|produce)\s+(?:text|markdown|answer|findings?|recommendations?)\s+only\b/i,
-];
-
-const RESEARCH_AGENT_PATTERNS = [
-	/\binvestigate\b/i,
-	/\bscout\b/i,
-	/\bresearch(?:er)?\b/i,
-];
-
-// Review/severity vocabulary like "must-fix items" or "should-fix tests" is not
-// the verb. Rather than dash-guarding every pattern (which would also suppress
-// CLI flags like "--fix" and genuine clause-level dashes like "branch—fix it"),
-// strip the known severity compounds (must|should|needs + dash + verb) from the
-// task text before matching. Dash coverage: ASCII hyphen + U+2010..U+2015.
-const SEVERITY_COMPOUND_PATTERN = /\b(?:must|should|needs)[-\u2010-\u2015](?:fix|edit|update|add|remove|replace|create|apply|make|do|implement|modify|delete|patch)\b/gi;
-
-function stripSeverityCompounds(task: string): string {
-	return task.replace(SEVERITY_COMPOUND_PATTERN, " ");
-}
-export { stripSeverityCompounds };
-
-// Quoted categories in a finding-classification request describe fixes, not
-// instructions to perform them. Strip only that request, leaving sibling
-// imperatives (including another "must fix") subject to the normal guards.
-const FINDING_CLASSIFICATION_PATTERN = /\b(?:classify|categorize|weigh)\s+(?:(?:the|remaining)\s+)*(?:findings?|items?|issues?)\s+as\s+["“]must\s+fix\s+before\s+[^"”\n]+["”]\s+(?:vs\.?|versus)\s+["“]must\s+fix\s+before\s+[^"”\n]+["”]/gi;
-
-const PATH_LIKE_TOKEN_PATTERN = /[^\s]+[/\\][^\s]+|[^\s/\\]+\.[A-Za-z][A-Za-z0-9]{0,9}\b/g;
-const PATH_INTERNAL_IMPLEMENTATION_VERB = /\b(?:implement|edit|modify|refactor|delete|update|add|remove|replace|create)\b/i;
-
-function stripPathLikeTokens(task: string): string {
-	return task.replace(PATH_LIKE_TOKEN_PATTERN, (token) => (PATH_INTERNAL_IMPLEMENTATION_VERB.test(token) ? " " : token));
-}
-
-const FIX_OR_PATCH_IMPLEMENTATION_PATTERN = /\b(?:fix|patch)\s+(?:(?:it|this|that|them|each|any|all|these|those)\b|(?:(?:a|an|the|any|all)\s+)?(?:(?:failing|failed|broken|flaky|red|cold|start|current|existing|reported|approved|known|regression|unit|integration|e2e|source|typescript|type-?script|ts|type-?check|compiler)\s+)*(?:bug|defect|issues?|problems?|failures?|regressions?|tests?|errors?|items?|typos?|code|source|implementation|component|function|module|class|method|logic|file|files|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command|lint(?:ing)?|build|ci|type-?check|type\s+checking)\b)/i;
-
-const WORKER_IMPLEMENTATION_PATTERNS = [
-	/\b(?:implement|edit|modify|refactor|delete)\b/i,
-	FIX_OR_PATCH_IMPLEMENTATION_PATTERN,
-	/\b(?:update|add|remove|replace|create)\b(?!\s+(?:(?:a|an|the)\s+)?(?:report|summary|findings?)(?:\b|$))/i,
-	/\bapply\s+(?:the\s+)?(?:(?:suggested|proposed|recommended)\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
-	/\bmake\s+(?:the\s+)?changes\b/i,
-	/\bdo those fixes\b/i,
-];
-
-const FOLLOW_ON_IMPLEMENTATION_PATTERN = /(?:^|[.!?:;,\n])\s*(?:fix|patch|update|add|remove|replace|create|delete)\s+(?:(?:the|a|an|this|that|these|those|requested|specified|current|existing|approved|your|our)\s+)(?!(?:report|summary|findings?|analysis|recommendations?|answer|response|proposal|plan|issue|bug report)\b)[a-z][\w./-]*/i;
-const ADVISORY_INFINITIVE_PATTERN = /\b(?:explain|recommend|describe)\s+how\s+to\s+(?:fix|patch|update|add|remove|replace|create|delete|implement|edit|modify|refactor)\b/i;
-const EXPLICIT_IMPLEMENTATION_PATTERNS = [
-	/\b(?:implement|edit|modify|refactor)\b/i,
-	/\bapply\s+(?:the\s+)?(?:(?:suggested|proposed|recommended)\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
-	/\bmake\s+(?:the\s+)?changes\b/i,
-	/\bdo those fixes\b/i,
-];
-
-const GENERAL_IMPLEMENTATION_PATTERNS = [
-	...EXPLICIT_IMPLEMENTATION_PATTERNS,
-	FIX_OR_PATCH_IMPLEMENTATION_PATTERN,
-	/\b(?:update|add|remove|replace|delete|create)\s+(?:the\s+)?(?:file|files|code|source|implementation|test|tests|component|function|module|class|method|logic|import|imports|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command)\b/i,
-];
-
-export type TaskMutationIntent = { kind: "implementation" } | { kind: "read-only" } | { kind: "unknown" };
-
-function stripFrameworkInstructions(task: string): string {
-	return task
-		.split("\n")
-		.filter((line) => !/^\s*\[(?:Write to|Read from):/i.test(line))
-		.filter((line) => !/^\s*(?:Create and maintain progress at:|Update progress at:|\*\*Output:\*\*|Write your findings to(?: exactly this path)?:|Return the complete artifact in your final response\.|The runtime will persist it to exactly this path:|Do not call contact_supervisor merely because no write-capable tool is available\.|This path is authoritative for this run\.|Ignore any other output filename or output path mentioned elsewhere)/i.test(line))
-		.join("\n");
-}
-
-function stripPatterns(task: string, patterns: RegExp[]): string {
-	let stripped = task;
-	for (const pattern of patterns) {
-		const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
-		stripped = stripped.replace(new RegExp(pattern.source, flags), " ");
-	}
-	return stripped;
-}
-
-interface NoEditProhibitionAnalysis {
-	/** True when any prohibition (or review-only/no-tool wording) is present. */
-	present: boolean;
-	/** True when a prohibition covers files/code in general; such wording wins over write verbs. */
-	blanket: boolean;
-	/** Task text with prohibition phrases and their objects removed, for write-intent testing. */
-	strippedText: string;
-}
-
-function analyzeNoEditProhibitions(taskText: string): NoEditProhibitionAnalysis {
-	const readOnlyBoundary = NO_EDIT_BOUNDARY_ASSERTION_PATTERN.test(taskText);
-	let present = REVIEW_ONLY_PATTERNS.some((pattern) => pattern.test(taskText))
-		|| NO_TOOL_INTENT_PATTERNS.some((pattern) => pattern.test(taskText))
-		|| readOnlyBoundary;
-	let blanket = false;
-	let strippedText = stripPatterns(taskText, [...REVIEW_ONLY_PATTERNS, ...NO_TOOL_INTENT_PATTERNS, ADVISORY_INFINITIVE_PATTERN]);
-	if (readOnlyBoundary) strippedText = stripPatterns(strippedText, [NO_EDIT_BOUNDARY_ASSERTION_PATTERN]);
-	const stripNoEditProhibition = (match: string, object: string, offset: number, source: string): string => {
-		present = true;
-		if (GENERIC_PROHIBITION_OBJECT.test(object) && !hasScopedProhibitionContinuation(source.slice(offset + match.length))) blanket = true;
-		return " ";
-	};
-	strippedText = strippedText.replace(new RegExp(COORDINATED_NO_EDIT_PROHIBITION_PATTERN.source, COORDINATED_NO_EDIT_PROHIBITION_PATTERN.flags), stripNoEditProhibition);
-	strippedText = strippedText.replace(new RegExp(NO_EDIT_PROHIBITION_PATTERN.source, NO_EDIT_PROHIBITION_PATTERN.flags), stripNoEditProhibition);
-	// Restore boundaries after stripping a prohibition from serialized prompts.
-	strippedText = strippedText.replace(/\\(?:r\\n|n)/g, "\n");
-	return { present, blanket, strippedText };
-}
-
-function taskHasReadOnlyDeliverable(taskText: string): boolean {
-	return READ_ONLY_DELIVERABLE_PATTERNS.some((pattern) => pattern.test(taskText));
-}
-
-function isReviewerStyleAgent(agent: string): boolean {
-	return /\b(?:advisor|reviewer|oracle)\b/i.test(agent);
-}
-
-function hasImplementationIntent(agent: string, taskText: string): boolean {
-	if (isReviewerStyleAgent(agent)) return REVIEWER_REQUIRED_EDIT_PATTERNS.some((pattern) => pattern.test(taskText));
-	if (agent === "worker") return WORKER_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
-	return GENERAL_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
-}
-
-export function classifyTaskMutationIntent(agent: string, task: string): TaskMutationIntent {
-	const taskText = stripPatterns(stripSeverityCompounds(stripFrameworkInstructions(task)), [FINDING_CLASSIFICATION_PATTERN]);
-	const taskTextWithoutScopedConstraints = stripPatterns(taskText, SCOPED_NO_EDIT_CONSTRAINT_PATTERNS);
-	const prohibitions = analyzeNoEditProhibitions(taskTextWithoutScopedConstraints);
-	if (prohibitions.present) {
-		if (prohibitions.blanket) return { kind: "read-only" };
-		const remaining = stripPathLikeTokens(prohibitions.strippedText);
-		if (isReviewerStyleAgent(agent)) {
-			return hasImplementationIntent(agent, remaining) ? { kind: "implementation" } : { kind: "read-only" };
-		}
-		return EXPLICIT_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(remaining))
-			|| FOLLOW_ON_IMPLEMENTATION_PATTERN.test(remaining)
-			? { kind: "implementation" }
-			: { kind: "read-only" };
-	}
-
-	if (RESEARCH_AGENT_PATTERNS.some((pattern) => pattern.test(agent))) return { kind: "read-only" };
-	if (hasImplementationIntent(agent, stripPathLikeTokens(taskText))) return { kind: "implementation" };
-	if (isReviewerStyleAgent(agent)) return { kind: "read-only" };
-	return taskHasReadOnlyDeliverable(taskTextWithoutScopedConstraints) ? { kind: "read-only" } : { kind: "unknown" };
-}
-
-export function expectsImplementationMutation(agent: string, task: string): boolean {
-	return classifyTaskMutationIntent(agent, task).kind === "implementation";
-}
-
-/** Bare write verbs that make a task write-capable for acceptance inference.
- * Severity compounds ("must-fix items") are stripped before matching, so they
- * are not write imperatives, while CLI flags ("--fix", "-w"), clause-level
- * dashes ("branch—fix it"), and hyphenated imperatives ("hot-fix the bug")
- * all stay write-capable. */
-const MAY_MUTATE_VERB_PATTERN = /\b(?:fix|implement|update|write|edit|modify|migrate|delete|remove|refactor|commit)\b/i;
-
-/**
- * Whether the task could plausibly change files. Blanket prohibitions win;
- * write verbs inside a scoped prohibition's object or a read-only deliverable
- * phrase ("write a summary report") do not count; any other bare write verb
- * does.
- */
-export function taskMayMutate(task: string): boolean {
-	const taskText = stripPatterns(stripSeverityCompounds(stripFrameworkInstructions(task)), [FINDING_CLASSIFICATION_PATTERN, ...SCOPED_NO_EDIT_CONSTRAINT_PATTERNS]);
-	const prohibitions = analyzeNoEditProhibitions(taskText);
-	if (prohibitions.blanket) return false;
-	return MAY_MUTATE_VERB_PATTERN.test(stripPatterns(prohibitions.strippedText, READ_ONLY_DELIVERABLE_PATTERNS));
-}

package/src/runs/shared/tool-availability.ts

@@ -1,37 +0,0 @@
-export interface ChildToolDiagnostic {
-	agent?: string;
-	required: string[];
-	available: string[];
-	missing: string[];
-	missingMcpDirectTools?: string[];
-}
-
-/**
- * Explain missing child tools. Foreground children run inside the parent
- * process and never load the parent's ambient extensions, so tools an ambient
- * extension registers (MCP tools, provider tools) only exist for background
- * children; the diagnostic says so instead of reporting a generic gap.
- */
-export function formatChildToolDiagnostic(diagnostic: ChildToolDiagnostic, options: { host?: "parent" | "runner" } = {}): string {
-	const subject = diagnostic.agent ? `Agent '${diagnostic.agent}'` : "Subagent";
-	if (options.host === "parent") {
-		return [
-			`${subject} ran as a foreground child, which never loads the parent's ambient extensions, and these child tools were unavailable: ${diagnostic.missing.join(", ")}.`,
-			"The `tools` field is a strict allowlist; it does not load extension code.",
-			...(diagnostic.missingMcpDirectTools?.length
-				? [`MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}.`]
-				: []),
-			"Agents that need MCP tools (`mcpDirectTools`, or MCP tools from an ambient adapter such as pi-mcp-adapter) or models from a provider extension must run as background children (`async: true`), which load the ambient extensions.",
-			"For extension tools a foreground child can load, add the provider path to `subagentOnlyExtensions` (child-only), `extensions`, or as a path-like entry in `tools`, while keeping each registered tool name in `tools`.",
-		].join("\n");
-	}
-	return [
-		`${subject} requested unavailable child tools: ${diagnostic.missing.join(", ")}.`,
-		"The `tools` field is a strict allowlist; it does not load extension code.",
-		...(diagnostic.missingMcpDirectTools?.length
-			? [`Resolved MCP direct tools missing from the child registry: ${diagnostic.missingMcpDirectTools.join(", ")}. This indicates a host/pi-mcp-adapter registration problem, not a tool-call failure.`]
-			: []),
-		"For extension tools, add the provider path to `subagentOnlyExtensions` (child-only), `extensions`, or as a path-like entry in `tools`, while keeping each registered tool name in `tools`.",
-		"For MCP tools, verify the MCP adapter configuration and selected tool names. For builtin tools, verify the name against the installed Pi version.",
-	].join("\n");
-}

package/src/runs/shared/tool-budget.ts

@@ -1,66 +0,0 @@
-import type { ResolvedToolBudget, ToolBudgetConfig, ToolBudgetState } from "../../shared/types.ts";
-
-export const DEFAULT_TOOL_BUDGET_BLOCK = ["read", "grep", "find", "ls"] as const;
-
-export function normalizeToolBudgetBlock(block: ToolBudgetConfig["block"] | undefined): "*" | string[] {
-	if (block === "*") return "*";
-	if (block === undefined) return [...DEFAULT_TOOL_BUDGET_BLOCK];
-	return [...new Set(block.map((tool) => tool.trim()).filter(Boolean))];
-}
-
-export function validateToolBudgetConfig(
-	raw: unknown,
-	label = "toolBudget",
-	options: { minimumHard?: 0 | 1 } = {},
-): { budget?: ResolvedToolBudget; error?: string } {
-	if (raw === undefined) return {};
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { error: `${label} must be an object with hard and optional soft/block.` };
-	const value = raw as ToolBudgetConfig;
-	const minimumHard = options.minimumHard ?? 1;
-	if (typeof value.hard !== "number" || !Number.isInteger(value.hard) || value.hard < minimumHard) {
-		return { error: `${label}.hard must be an integer >= ${minimumHard}.` };
-	}
-	if (value.soft !== undefined && (typeof value.soft !== "number" || !Number.isInteger(value.soft) || value.soft < 1)) {
-		return { error: `${label}.soft must be an integer >= 1 when provided.` };
-	}
-	if (value.soft !== undefined && value.soft > value.hard) {
-		return { error: `${label}.soft must be <= ${label}.hard.` };
-	}
-	if (value.block !== undefined && value.block !== "*") {
-		if (!Array.isArray(value.block)) return { error: `${label}.block must be "*" or an array of tool names.` };
-		if (value.block.length === 0) return { error: `${label}.block must contain at least one tool name.` };
-		for (const item of value.block) {
-			if (typeof item !== "string" || !item.trim()) return { error: `${label}.block must contain non-empty tool names.` };
-		}
-	}
-	return { budget: { hard: value.hard, ...(value.soft !== undefined ? { soft: value.soft } : {}), block: normalizeToolBudgetBlock(value.block) } };
-}
-
-export function initialToolBudgetState(budget: ResolvedToolBudget): ToolBudgetState {
-	return { ...budget, toolCount: 0, outcome: "within-budget" };
-}
-
-export function toolBudgetState(budget: ResolvedToolBudget, toolCount: number, blockedTool?: string): ToolBudgetState {
-	const overHard = toolCount > budget.hard;
-	const overSoft = budget.soft !== undefined && toolCount >= budget.soft;
-	return {
-		...budget,
-		toolCount,
-		outcome: overHard ? "hard-blocked" : overSoft ? "soft-reached" : "within-budget",
-		...(overSoft ? { softReachedAt: budget.soft } : {}),
-		...(overHard ? { hardReachedAt: budget.hard, blockedTool } : {}),
-	};
-}
-
-export function shouldBlockToolForBudget(budget: ResolvedToolBudget, toolName: string, nextToolCount: number): boolean {
-	if (nextToolCount <= budget.hard) return false;
-	return budget.block === "*" || budget.block.includes(toolName);
-}
-
-export function toolBudgetSoftNudge(budget: ResolvedToolBudget, toolCount: number): string {
-	return `Tool budget soft limit reached after ${toolCount} tool call${toolCount === 1 ? "" : "s"} (soft ${budget.soft}, hard ${budget.hard}). Stop starting new browsing/search work and finalize from the context you already have.`;
-}
-
-export function toolBudgetBlockedMessage(budget: ResolvedToolBudget, toolName: string, toolCount: number): string {
-	return `Tool budget hard limit reached after ${toolCount} tool call${toolCount === 1 ? "" : "s"} (hard ${budget.hard}). The '${toolName}' tool is blocked so you can finalize from the context you already have.`;
-}

package/src/runs/shared/tool-timeout.ts

@@ -1,93 +0,0 @@
-export const TOOL_TIMEOUT_ENV = "PI_SUBAGENT_TOOL_TIMEOUT_MS";
-
-/** Maximum delay a Node.js timer accepts without overflow. */
-const MAX_TIMER_DELAY_MS = 2_147_483_647;
-
-export const DEFAULT_FAST_TOOL_TIMEOUT_MS = 300_000;
-
-export const DEFAULT_FAST_TOOL_TIMEOUT_TOOLS = new Set([
-	"read",
-	"grep",
-	"find",
-	"ls",
-	"edit",
-	"write",
-	"structured_output",
-]);
-
-/** Tools whose normal job can be to wait for a person or another run. */
-export const TOOL_TIMEOUT_EXEMPT_TOOLS = new Set(["contact_supervisor", "intercom", "bg_wait"]);
-
-// Backward-compatible export name for existing callers/tests.
-export const TOOL_TIMEOUT_ALLOWLIST = TOOL_TIMEOUT_EXEMPT_TOOLS;
-
-export function isToolTimeoutExempt(toolName: string | undefined): boolean {
-	return toolName !== undefined && TOOL_TIMEOUT_EXEMPT_TOOLS.has(toolName);
-}
-
-export function defaultToolTimeoutMs(toolName: string | undefined): number | undefined {
-	return toolName !== undefined && DEFAULT_FAST_TOOL_TIMEOUT_TOOLS.has(toolName)
-		? DEFAULT_FAST_TOOL_TIMEOUT_MS
-		: undefined;
-}
-
-export function effectiveToolTimeoutMs(toolName: string | undefined, configuredToolTimeoutMs: number | undefined): number | undefined {
-	if (isToolTimeoutExempt(toolName)) return undefined;
-	return configuredToolTimeoutMs ?? defaultToolTimeoutMs(toolName);
-}
-
-export function formatToolTimeoutMessage(toolName: string, timeoutMs: number): string {
-	return `Tool '${toolName}' exceeded its timeout of ${timeoutMs}ms.`;
-}
-
-export function toolTimeoutCallKey(event: { toolCallId?: unknown; toolName?: unknown }, fallbackId: number): string {
-	return typeof event.toolCallId === "string" && event.toolCallId.length > 0
-		? `id:${event.toolCallId}`
-		: `anon:${String(event.toolName ?? "tool")}:${fallbackId}`;
-}
-
-export interface ToolTimeoutResolutionInput {
-	/** Per-call value from the subagent tool params (highest precedence). */
-	callValue?: unknown;
-	/** Agent frontmatter default (second precedence). */
-	agentValue?: number;
-	/** Global extension config.toolTimeoutMs (third precedence). */
-	configValue?: unknown;
-	/** PI_SUBAGENT_TOOL_TIMEOUT_MS environment override (lowest precedence). */
-	envValue?: string | undefined;
-}
-
-/** Resolve the configured hard timeout. Default fast-tool timeouts apply later per tool name. */
-export function resolveToolTimeoutMs(input: ToolTimeoutResolutionInput): { toolTimeoutMs?: number; error?: string } {
-	const candidates: Array<{ label: string; value: unknown }> = [
-		{ label: "toolTimeoutMs", value: input.callValue },
-		{ label: "agent.toolTimeoutMs", value: input.agentValue },
-		{ label: "config.toolTimeoutMs", value: input.configValue },
-	];
-	let winner: { label: string; value: unknown } | undefined;
-	for (const candidate of candidates) {
-		if (candidate.value === undefined) continue;
-		winner = candidate;
-		break;
-	}
-	if (winner === undefined && input.envValue !== undefined && input.envValue.trim() !== "") {
-		winner = { label: TOOL_TIMEOUT_ENV, value: input.envValue };
-	}
-	if (winner === undefined) return {};
-
-	let raw: unknown = winner.value;
-	let parsed: number;
-	if (winner.label === TOOL_TIMEOUT_ENV && typeof raw === "string") {
-		parsed = Number(raw);
-		if (raw.trim() !== "" && !Number.isNaN(parsed)) raw = parsed;
-	}
-	if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0 || raw > MAX_TIMER_DELAY_MS) {
-		return { error: `${winner.label} must be a positive integer no larger than ${MAX_TIMER_DELAY_MS}.` };
-	}
-	return { toolTimeoutMs: raw };
-}
-
-/** Read the environment override without requiring callers to know the name. */
-export function toolTimeoutFromEnv(env: NodeJS.ProcessEnv = process.env): string | undefined {
-	return env[TOOL_TIMEOUT_ENV];
-}

package/src/runs/shared/usage-budget.ts

@@ -1,65 +0,0 @@
-import type { CostSummary, UsageBudgetConfig, UsageBudgetLimitConfig, UsageBudgetState } from "../../shared/types.ts";
-
-function validateLimit(value: unknown, label: string): { limit?: UsageBudgetLimitConfig; error?: string } {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return { error: `${label} must be an object.` };
-	const raw = value as Record<string, unknown>;
-	const unknown = Object.keys(raw).find((key) => key !== "soft" && key !== "hard");
-	if (unknown) return { error: `${label}.${unknown} is not supported.` };
-	if (typeof raw.hard !== "number" || !Number.isFinite(raw.hard) || raw.hard <= 0) return { error: `${label}.hard must be a positive number.` };
-	if (raw.soft !== undefined && (typeof raw.soft !== "number" || !Number.isFinite(raw.soft) || raw.soft <= 0)) return { error: `${label}.soft must be a positive number.` };
-	if (typeof raw.soft === "number" && raw.soft > raw.hard) return { error: `${label}.soft must be less than or equal to ${label}.hard.` };
-	return { limit: { ...(typeof raw.soft === "number" ? { soft: raw.soft } : {}), hard: raw.hard } };
-}
-
-export function validateUsageBudgetConfig(value: unknown, label = "usageBudget"): { budget?: UsageBudgetConfig; error?: string } {
-	if (value === undefined) return {};
-	if (!value || typeof value !== "object" || Array.isArray(value)) return { error: `${label} must be an object.` };
-	const raw = value as Record<string, unknown>;
-	const unknown = Object.keys(raw).find((key) => key !== "tokens" && key !== "costUsd");
-	if (unknown) return { error: `${label}.${unknown} is not supported.` };
-	const budget: UsageBudgetConfig = {};
-	if (raw.tokens !== undefined) {
-		const tokens = validateLimit(raw.tokens, `${label}.tokens`);
-		if (tokens.error) return { error: tokens.error };
-		budget.tokens = tokens.limit;
-	}
-	if (raw.costUsd !== undefined) {
-		const costUsd = validateLimit(raw.costUsd, `${label}.costUsd`);
-		if (costUsd.error) return { error: costUsd.error };
-		budget.costUsd = costUsd.limit;
-	}
-	if (!budget.tokens && !budget.costUsd) return { error: `${label} must include tokens or costUsd.` };
-	return { budget };
-}
-
-function metricState(limit: UsageBudgetLimitConfig | undefined, used: number): UsageBudgetState["tokens"] {
-	if (!limit) return undefined;
-	return {
-		...limit,
-		used,
-		outcome: used >= limit.hard ? "hard-exceeded" : limit.soft !== undefined && used >= limit.soft ? "soft-exceeded" : "within-budget",
-	};
-}
-
-export function usageBudgetState(config: UsageBudgetConfig | undefined, totals: CostSummary | undefined): UsageBudgetState | undefined {
-	if (!config) return undefined;
-	const inputTokens = totals?.inputTokens ?? 0;
-	const outputTokens = totals?.outputTokens ?? 0;
-	const tokens = metricState(config.tokens, inputTokens + outputTokens);
-	const costUsd = metricState(config.costUsd, totals?.costUsd ?? 0);
-	const reason = tokens?.outcome === "hard-exceeded" ? "tokens" : costUsd?.outcome === "hard-exceeded" ? "costUsd" : undefined;
-	return {
-		version: 1,
-		source: "reported",
-		...(tokens ? { tokens } : {}),
-		...(costUsd ? { costUsd } : {}),
-		exhausted: reason !== undefined,
-		...(reason ? { reason } : {}),
-	};
-}
-
-export function usageBudgetExceededMessage(state: UsageBudgetState): string {
-	if (state.reason === "tokens" && state.tokens) return `Usage budget exhausted: reported tokens ${state.tokens.used} reached hard limit ${state.tokens.hard}.`;
-	if (state.reason === "costUsd" && state.costUsd) return `Usage budget exhausted: reported cost $${state.costUsd.used.toFixed(6)} reached hard limit $${state.costUsd.hard.toFixed(6)}.`;
-	return "Usage budget exhausted.";
-}

package/src/runs/shared/workflow-async-child-guidance.ts

@@ -1,18 +0,0 @@
-import type { AsyncStatus, SubagentState } from "../../shared/types.ts";
-
-/** Projection-only guidance, not a control route or proof of current child liveness. */
-export function workflowAsyncChildSteeringGuidance(status: AsyncStatus, state?: SubagentState): string[] {
-	if (status.mode !== "workflow" || (status.state !== "running" && status.state !== "queued")
-		|| !state?.currentSessionId || status.sessionId !== state.currentSessionId
-		|| !state.workflowControllers?.has(status.runId)) return [];
-	const ids = new Set((status.steps ?? []).flatMap((step) =>
-		step.async === true && step.status === "running"
-		&& step.runner?.type !== "external-cli" && step.runner?.type !== "external-job"
-		&& typeof step.runId === "string" && /^[A-Za-z0-9_-]+$/.test(step.runId) && step.runId !== status.runId
-			? [step.runId] : []));
-	if (ids.size === 0) return [];
-	return [
-		"Async children recorded as running; direct steering rechecks controls. Choose an exact child ID (queued does not mean consumed):",
-		...[...ids].map((id) => `  subagent({ action: "steer", id: "${id}", mode: "follow_up", message: "..." })`),
-	];
-}