@selesai/code 0.9.11 → 0.9.12

package/dist/extensions/pi-subagents/src/runs/shared/tool-availability.ts

@@ -13,8 +13,6 @@ export interface ChildToolDiagnostic {
 	missingMcpDirectTools?: string[];
 }
 
-const PI_CORE_CHILD_TOOLS = new Set(["bash", "edit", "find", "grep", "ls", "read", "write"]);
-
 export function writeChildToolDiagnostic(
 	filePath: string,
 	required: string[],
@@ -22,7 +20,7 @@ export function writeChildToolDiagnostic(
 	agent?: string,
 	mcpDirectTools?: string[],
 ): ChildToolDiagnostic | undefined {
-	const availableNames = new Set([...available, ...PI_CORE_CHILD_TOOLS]);
+	const availableNames = new Set(available);
 	const missing = required.filter((name) => !availableNames.has(name));
 	if (missing.length === 0) {
 		fs.rmSync(filePath, { force: true });

package/dist/extensions/pi-subagents/src/runs/shared/tool-timeout.ts

@@ -1,5 +1,3 @@
-import { readSubagentEnv } from "../../shared/env.ts";
-
 export const TOOL_TIMEOUT_ENV = "SELESAI_SUBAGENT_TOOL_TIMEOUT_MS";
 
 /** Maximum delay a Node.js timer accepts without overflow. */
@@ -91,5 +89,5 @@ export function resolveToolTimeoutMs(input: ToolTimeoutResolutionInput): { toolT
 
 /** Read the environment override without requiring callers to know the name. */
 export function toolTimeoutFromEnv(env: NodeJS.ProcessEnv = process.env): string | undefined {
-	return readSubagentEnv(env, TOOL_TIMEOUT_ENV);
+	return env[TOOL_TIMEOUT_ENV];
 }

package/dist/extensions/pi-subagents/src/runs/shared/workflow-graph.ts

@@ -1,4 +1,4 @@
-import { isCheckpointStep, isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
+import { isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
 import type { SingleResult, SubagentRunMode, WorkflowGraphNode, WorkflowGraphSnapshot, WorkflowNodeStatus } from "../../shared/types.ts";
 
 export interface WorkflowGraphBuildInput {
@@ -81,28 +81,6 @@ export function buildWorkflowGraphSnapshot(input: WorkflowGraphBuildInput): Work
 
 	for (let stepIndex = 0; stepIndex < input.steps.length; stepIndex++) {
 		const step = input.steps[stepIndex]!;
-		if (isCheckpointStep(step)) {
-			const status = normalizeStatus(input.stepStatuses?.[flatIndex]?.status)
-				?? (input.currentStepIndex === stepIndex ? "paused" : "pending");
-			const checkpoint = { name: step.checkpoint, ...(step.message ? { message: step.message } : {}), status: status === "rejected" ? "rejected" as const : status === "completed" ? "approved" as const : "pending" as const, stepIndex };
-			const id = `step-${stepIndex}`;
-			nodes.push({
-				id,
-				kind: "checkpoint",
-				phase: step.phase,
-				label: step.label?.trim() || step.checkpoint,
-				status,
-				flatIndex,
-				stepIndex,
-				checkpoint,
-				error: input.stepStatuses?.[flatIndex]?.error,
-			});
-			pushPhase(phases, step.phase, id);
-			if (status === "paused" || input.currentStepIndex === stepIndex) currentNodeId = id;
-			flatIndex++;
-			continue;
-		}
-
 		if (isParallelStep(step)) {
 			const groupId = `step-${stepIndex}`;
 			const children: WorkflowGraphNode[] = [];

package/dist/extensions/pi-subagents/src/runs/shared/worktree.ts

@@ -46,7 +46,7 @@ export interface WorktreeCleanupTask {
 }
 
 export type WorktreeCleanupIntent =
-	| { kind: "preserve"; capturedDiffs?: WorktreeDiff[]; handoffManifestPath?: string }
+	| { kind: "preserve"; capturedDiffs?: WorktreeDiff[]; handoffManifestPath?: string; cleanupBlocker?: string }
 	| {
 		kind: "discard";
 		authorization:
@@ -115,7 +115,7 @@ interface RepoState {
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
 
 function runGit(cwd: string, args: string[]): GitResult {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", windowsHide: true });
 	return {
 		stdout: result.stdout ?? "",
 		stderr: result.stderr ?? "",
@@ -338,6 +338,7 @@ function runWorktreeSetupHook(
 	input: WorktreeSetupHookInput,
 ): string[] {
 	const result = spawnSync(hook.hookPath, [], {
+		windowsHide: true,
 		cwd: input.worktreePath,
 		encoding: "utf-8",
 		input: JSON.stringify(input),
@@ -571,6 +572,17 @@ function cleanupSingleWorktree(
 	const errors: string[] = [];
 	let worktreeRemoved = false;
 	let branchRemoved = false;
+	if (intent.kind === "preserve" && intent.cleanupBlocker) {
+		return {
+			index: worktree.index,
+			path: worktree.path,
+			branch: worktree.branch,
+			worktreeRemoved: false,
+			branchRemoved: false,
+			preserved: true,
+			reason: intent.cleanupBlocker,
+		};
+	}
 	if (intent.kind !== "setup-rollback") {
 		try {
 			removeSyntheticPathsBeforeDiff(worktree);

package/dist/extensions/pi-subagents/src/shared/artifacts.ts

@@ -140,7 +140,7 @@ export function getProjectChainRunsDir(cwd: string): string {
 
 export function getChainRunsDir(
 	projectCwd: string,
-	dirPreference: ArtifactDirPreference = "project",
+	dirPreference: ArtifactDirPreference = "session",
 ): string {
 	switch (dirPreference) {
 		case "project":
@@ -156,7 +156,7 @@ export function getChainRunsDir(
 export function getArtifactsDir(
 	sessionFile: string | null,
 	projectCwd?: string,
-	dirPreference: ArtifactDirPreference = "project",
+	dirPreference: ArtifactDirPreference = "session",
 ): string {
 	switch (dirPreference) {
 		case "session":

package/dist/extensions/pi-subagents/src/shared/atomic-json.ts

@@ -1,9 +1,12 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, runFileSystemOperationWithRetry, waitForFileSystemRetry } from "./file-system-retry.ts";
 
 type AtomicJsonFs = Pick<typeof fs, "mkdirSync" | "writeFileSync" | "renameSync" | "rmSync">;
 
+const MAX_PATH_COMPONENT_BYTES = 255;
+
 type AtomicJsonWriterOptions = {
 	fs?: AtomicJsonFs;
 	now?: () => number;
@@ -28,6 +31,13 @@ function renameWithRetry(
 	}, { retryDelaysMs, wait });
 }
 
+function tempBaseName(filePath: string, pid: number, nowMs: number, randomId: string): string {
+	const suffix = `.${pid}.${nowMs}.${randomId}.tmp`;
+	const preferred = `.${path.basename(filePath)}${suffix}`;
+	if (Buffer.byteLength(preferred, "utf-8") <= MAX_PATH_COMPONENT_BYTES) return preferred;
+	return `.${createHash("sha256").update(path.basename(filePath)).digest("hex")}${suffix}`;
+}
+
 export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (filePath: string, payload: object) => void {
 	const fsImpl = options.fs ?? fs;
 	const now = options.now ?? Date.now;
@@ -46,13 +56,23 @@ export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (
 		}, { retryDelaysMs: directoryRetryDelaysMs, wait });
 		const tempPath = path.join(
 			path.dirname(filePath),
-			`.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`,
+			tempBaseName(filePath, pid, now(), random().toString(36).slice(2)),
 		);
+		let writeError: unknown;
 		try {
 			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), mode === undefined ? "utf-8" : { encoding: "utf-8", mode });
 			renameWithRetry(fsImpl, tempPath, filePath, renameRetryDelaysMs, wait);
+		} catch (error) {
+			writeError = error;
+			throw error;
 		} finally {
-			fsImpl.rmSync(tempPath, { force: true });
+			try {
+				fsImpl.rmSync(tempPath, { force: true });
+			} catch (cleanupError) {
+				// Preserve the write/rename failure: cleanup is best effort and must
+				// not hide the error callers need to classify or report.
+				if (writeError === undefined) throw cleanupError;
+			}
 		}
 	};
 }

package/dist/extensions/pi-subagents/src/shared/capacity-resilient-json.ts

@@ -0,0 +1,102 @@
+import { isStorageCapacityError } from "./file-system-retry.ts";
+import { writeAtomicJson } from "./atomic-json.ts";
+
+type TimerApi = {
+	setTimeout(handler: () => void, delayMs: number): unknown;
+	clearTimeout(handle: unknown): void;
+};
+
+const defaultTimerApi: TimerApi = {
+	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+};
+
+export type CapacityResilientJsonWriterOptions = {
+	/** The underlying write operation. It must be atomic for each target path. */
+	write?: (filePath: string, payload: object) => void;
+	/** Keep retry timers referenced by the event loop (needed by child runners). */
+	keepAlive?: boolean;
+	retryDelayMs?: number;
+	timerApi?: TimerApi;
+	onError?: (error: unknown, filePath: string) => void;
+	onSuccess?: (filePath: string, payload: object) => void;
+};
+
+export type CapacityResilientJsonWriter = {
+	write(filePath: string, payload: object, writeOperation?: (filePath: string, payload: object) => void): void;
+	pendingCount(): number;
+	dispose(): void;
+};
+
+/**
+ * Defers only storage-capacity failures, retaining the newest payload per path.
+ * Initial/ordinary writes remain synchronous and preserve their throwing contract;
+ * only ENOSPC-like failures enter the guarded retry loop.
+ */
+export function createCapacityResilientJsonWriter(options: CapacityResilientJsonWriterOptions = {}): CapacityResilientJsonWriter {
+	const defaultWrite = options.write ?? writeAtomicJson;
+	const keepAlive = options.keepAlive ?? false;
+	const retryDelayMs = options.retryDelayMs ?? 1_000;
+	const timerApi = options.timerApi ?? defaultTimerApi;
+	const onError = options.onError ?? ((error, filePath) => console.error(`Failed to persist JSON '${filePath}':`, error));
+	const onSuccess = options.onSuccess;
+	const reportError = (error: unknown, filePath: string): void => {
+		try {
+			onError(error, filePath);
+		} catch (callbackError) {
+			console.error(`Failed to report JSON persistence error for '${filePath}':`, callbackError);
+		}
+	};
+	const notifySuccess = (filePath: string, payload: object): void => {
+		if (!onSuccess) return;
+		try {
+			onSuccess(filePath, payload);
+		} catch (error) {
+			reportError(error, filePath);
+		}
+	};
+	const pending = new Map<string, { payload: object; write: (filePath: string, payload: object) => void }>();
+	let retryTimer: unknown;
+
+	const scheduleRetry = (): void => {
+		if (retryTimer !== undefined) return;
+		retryTimer = timerApi.setTimeout(() => {
+			retryTimer = undefined;
+			for (const [filePath, entry] of pending) {
+				try {
+					entry.write(filePath, entry.payload);
+					pending.delete(filePath);
+					notifySuccess(filePath, entry.payload);
+				} catch (error) {
+					if (isStorageCapacityError(error)) continue;
+					pending.delete(filePath);
+					reportError(error, filePath);
+				}
+			}
+			if (pending.size > 0) scheduleRetry();
+		}, retryDelayMs);
+		if (!keepAlive && typeof retryTimer === "object" && retryTimer !== null && "unref" in retryTimer && typeof retryTimer.unref === "function") {
+			retryTimer.unref();
+		}
+	};
+
+	return {
+		write(filePath, payload, writeOperation = defaultWrite): void {
+			try {
+				writeOperation(filePath, payload);
+				pending.delete(filePath);
+				notifySuccess(filePath, payload);
+			} catch (error) {
+				if (!isStorageCapacityError(error)) throw error;
+				pending.set(filePath, { payload, write: writeOperation });
+				scheduleRetry();
+			}
+		},
+		pendingCount: () => pending.size,
+		dispose: (): void => {
+			if (retryTimer !== undefined) timerApi.clearTimeout(retryTimer);
+			retryTimer = undefined;
+			pending.clear();
+		},
+	};
+}

package/dist/extensions/pi-subagents/src/shared/completion-owner.ts

@@ -0,0 +1,14 @@
+import { randomUUID } from "node:crypto";
+
+const COMPLETION_OWNER_KEY = Symbol.for("pi-subagents.completion-owner-id");
+
+type CompletionOwnerGlobal = typeof globalThis & {
+	[COMPLETION_OWNER_KEY]?: string;
+};
+
+/** Stable for one parent Pi process across extension reloads. */
+export function currentCompletionOwnerId(): string {
+	const runtime = globalThis as CompletionOwnerGlobal;
+	runtime[COMPLETION_OWNER_KEY] ??= randomUUID();
+	return runtime[COMPLETION_OWNER_KEY];
+}

package/dist/extensions/pi-subagents/src/shared/file-system-retry.ts

@@ -1,8 +1,51 @@
 const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
 const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;
 const RETRYABLE_FILE_SYSTEM_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
+const STORAGE_CAPACITY_ERROR_CODES = new Set(["EDQUOT", "EMFILE", "ENFILE", "ENOSPC"]);
 
-export const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;
+export const FS_RETRY_MAX_TOTAL_MS_ENV = "SELESAI_SUBAGENT_FS_RETRY_MAX_TOTAL_MS";
+
+const BASE_FILE_SYSTEM_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;
+
+/**
+ * Clamp the retry ladder to a total sleep budget, preserving its length.
+ *
+ * waitForFileSystemRetry blocks the calling thread, so the ladder above is also
+ * a ceiling on how long a single contended rename can stall that thread: about
+ * 7.9s. That is fine for a short-lived CLI. A long-lived host that loads this
+ * extension in-process runs the same writers on its event loop, where an 8s
+ * stall stops it serving anything at all -- and because Atomics.wait parks
+ * rather than spins, it presents as an unresponsive process at 0% CPU.
+ *
+ * The length is preserved deliberately: run-fanout-budget.ts and
+ * workflow-state.ts index this array by attempt number and treat running off
+ * the end as "timed out acquiring lock". Shortening it would quietly shrink
+ * those attempt budgets too, so only the sleeps shrink here.
+ *
+ * Unset by default, so behaviour is unchanged unless a host opts in. Opting in
+ * trades lock-wait tolerance for responsiveness: entries clamped to 0 return
+ * immediately, so contention that would previously have been waited out is
+ * surfaced as an error sooner.
+ */
+export function resolveFileSystemRetryDelays(
+	env: NodeJS.ProcessEnv = process.env,
+	base: readonly number[] = BASE_FILE_SYSTEM_RETRY_DELAYS_MS,
+): readonly number[] {
+	const raw = env[FS_RETRY_MAX_TOTAL_MS_ENV];
+	if (raw === undefined || raw.trim() === "") return base;
+	const budget = Number(raw);
+	if (!Number.isInteger(budget) || budget < 0) {
+		throw new Error(`${FS_RETRY_MAX_TOTAL_MS_ENV} must be a non-negative integer number of milliseconds.`);
+	}
+	let spent = 0;
+	return base.map((delayMs) => {
+		const allowed = Math.max(0, Math.min(delayMs, budget - spent));
+		spent += allowed;
+		return allowed;
+	});
+}
+
+export const DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS = resolveFileSystemRetryDelays();
 
 export type FileSystemRetryOptions = {
 	retryDelaysMs?: readonly number[];
@@ -32,6 +75,11 @@ export function isRetryableFileSystemError(error: unknown): boolean {
 	return typeof code === "string" && RETRYABLE_FILE_SYSTEM_ERROR_CODES.has(code);
 }
 
+export function isStorageCapacityError(error: unknown): boolean {
+	const code = (error as NodeJS.ErrnoException | undefined)?.code;
+	return typeof code === "string" && STORAGE_CAPACITY_ERROR_CODES.has(code);
+}
+
 export function runFileSystemOperationWithRetry<T>(operation: () => T, options: FileSystemRetryOptions = {}): T {
 	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
 	const wait = options.wait ?? waitForFileSystemRetry;

package/dist/extensions/pi-subagents/src/shared/fork-context.ts

@@ -56,6 +56,48 @@ export function resolveSubagentContext(value: unknown): SubagentExecutionContext
 	return value === "fork" ? "fork" : "fresh";
 }
 
+export interface PreferredForkAvailability {
+	getSessionFile(): string | undefined;
+	getLeafId?: () => string | null;
+}
+
+export interface PreferredForkSnapshot {
+	parentSessionFile?: string | null;
+	leafId?: string | null;
+}
+
+export interface SubagentLaunchContextInput {
+	explicitContext?: SubagentExecutionContext;
+	agentDefaultContext?: SubagentExecutionContext;
+	defaultSubagentContext?: SubagentExecutionContext;
+	canUseImplicitFork: boolean;
+}
+
+/** Resolve the actual launch context from explicit, global, and agent preferences. */
+export function resolveSubagentLaunchContext(input: SubagentLaunchContextInput): SubagentExecutionContext {
+	if (input.explicitContext !== undefined) return input.explicitContext;
+	const preferredContext = input.defaultSubagentContext ?? input.agentDefaultContext ?? "fresh";
+	return preferredContext === "fork" && input.canUseImplicitFork ? "fork" : "fresh";
+}
+
+/** True when an implicit `defaultContext: fork` can create a real branch now.
+ * Explicit `context: "fork"` stays strict and does not use this preference. */
+export function canPreferFork(sessionManager: PreferredForkAvailability): boolean {
+	return canPreferForkFromSnapshot({
+		parentSessionFile: sessionManager.getSessionFile(),
+		leafId: sessionManager.getLeafId?.() ?? null,
+	});
+}
+
+export function canPreferForkFromSnapshot(input: PreferredForkSnapshot): boolean {
+	if (!input.parentSessionFile || !input.leafId) return false;
+	try {
+		return fs.existsSync(input.parentSessionFile);
+	} catch {
+		return false;
+	}
+}
+
 /** Decide whether a resolved child model uses Anthropic's provider or message API, which
  * requires the sanitized fork to disable thinking. Unknown models stay conservative. */
 export function forkedChildRequiresThinkingOff(
@@ -166,7 +208,23 @@ export function createForkContextResolver(
 	const openSession = options.openSession
 		?? sessionManager.openSession
 		?? ((file: string, dir?: string) => SessionManager.open(file, dir));
-	const sessionDir = sessionManager.getSessionDir?.();
+	// Fork files must not land in the parent's top-level session directory.
+	// Pi's recent-session discovery (`pi -c` → findMostRecentSession) is
+	// non-recursive and picks the largest-mtime *.jsonl in that directory, so
+	// a still-running forked subagent — which keeps appending after the parent
+	// went idle — would hijack the next `pi -c` away from the conversation the
+	// user actually left. Nesting fork sessions in a per-parent directory keeps
+	// them invisible to that discovery; the `parentSession` header still
+	// records the tree relationship. The directory mirrors
+	// getSubagentSessionRoot() plus a "forks" level so fork files never sit
+	// loose next to run-N/ result directories. Derived from the file path
+	// rather than getSessionDir() so it also works when the manager cannot
+	// report its directory.
+	const sessionDir = path.join(
+		path.dirname(parentSessionFile),
+		path.basename(parentSessionFile, ".jsonl"),
+		"forks",
+	);
 	const cachedResolutions = new Map<number, ForkContextResolution>();
 
 	const resolveFork = (index = 0): ForkContextResolution => {

package/dist/extensions/pi-subagents/src/shared/launch-contract.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import type { AgentConfig } from "../agents/agents.ts";
+import type { ExtensionBindings } from "../runs/shared/extension-bindings.ts";
 
 export const AGENT_DEFINITION_PROJECTION_VERSION = 1 as const;
 export const LAUNCH_BINDING_PROJECTION_VERSION = 1 as const;
@@ -17,7 +18,7 @@ function stableJson(value: unknown): string {
 	return JSON.stringify(value);
 }
 
-function sha256(value: unknown): string {
+export function stableJsonDigest(value: unknown): string {
 	return createHash("sha256").update(stableJson(value)).digest("hex");
 }
 
@@ -44,7 +45,9 @@ export function projectAgentDefinition(agent: AgentConfig): Record<string, unkno
 		inheritProjectContext: agent.inheritProjectContext,
 		inheritSkills: agent.inheritSkills,
 		model: agent.model,
+		modelProvider: agent.modelProvider,
 		fallbackModels: agent.fallbackModels,
+		fast: agent.fast,
 		thinking: agent.thinking,
 		tools: agent.tools,
 		mcpDirectTools: agent.mcpDirectTools,
@@ -70,7 +73,7 @@ export function projectAgentDefinition(agent: AgentConfig): Record<string, unkno
 }
 
 export function agentDefinitionDigest(agent: AgentConfig): string {
-	return sha256(projectAgentDefinition(agent));
+	return stableJsonDigest(projectAgentDefinition(agent));
 }
 
 export interface LaunchBindingInput {
@@ -79,6 +82,7 @@ export interface LaunchBindingInput {
 	task?: string;
 	model?: string;
 	modelCandidates?: string[];
+	fast?: boolean;
 	thinking?: string;
 	systemPrompt?: string | null;
 	systemPromptMode?: AgentConfig["systemPromptMode"];
@@ -92,6 +96,7 @@ export interface LaunchBindingInput {
 	outputPath?: string;
 	outputMode?: string;
 	structuredOutputSchema?: unknown;
+	extensionBindings?: ExtensionBindings;
 }
 
 /** Canonical projection of the resolved inputs handed to the child. */
@@ -99,12 +104,13 @@ export function projectLaunchBinding(input: LaunchBindingInput): Record<string,
 	return {
 		version: LAUNCH_BINDING_PROJECTION_VERSION,
 		definitionDigest: input.definitionDigest,
-		taskDigest: input.task === undefined ? undefined : sha256(input.task),
+		taskDigest: input.task === undefined ? undefined : stableJsonDigest(input.task),
 		// The ordered candidate set already contains each attempted model; keeping only
 		// this set makes retries correlate to the same preflight binding.
 		modelCandidates: input.modelCandidates,
+		fast: input.fast,
 		thinking: input.thinking,
-		systemPromptDigest: input.systemPrompt === undefined || input.systemPrompt === null ? undefined : sha256(input.systemPrompt),
+		systemPromptDigest: input.systemPrompt === undefined || input.systemPrompt === null ? undefined : stableJsonDigest(input.systemPrompt),
 		systemPromptMode: input.systemPromptMode,
 		inheritProjectContext: input.inheritProjectContext,
 		inheritSkills: input.inheritSkills,
@@ -116,9 +122,10 @@ export function projectLaunchBinding(input: LaunchBindingInput): Record<string,
 		outputPath: input.outputPath,
 		outputMode: input.outputMode,
 		structuredOutputSchema: input.structuredOutputSchema,
+		extensionBindings: input.extensionBindings,
 	};
 }
 
 export function launchBindingDigest(input: LaunchBindingInput): string {
-	return sha256(projectLaunchBinding(input));
+	return stableJsonDigest(projectLaunchBinding(input));
 }

package/dist/extensions/pi-subagents/src/shared/model-info.ts

@@ -1,3 +1,5 @@
+import type { ModelCost } from "@earendil-works/pi-ai";
+
 export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 export type ThinkingLevel = typeof THINKING_LEVELS[number];
 export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
@@ -9,6 +11,14 @@ export interface ModelInfo {
 	api?: string;
 	reasoning?: boolean;
 	thinkingLevelMap?: ThinkingLevelMap;
+	/** Context window in tokens, when the host model registry reports one. */
+	contextWindow?: number;
+	/** Maximum output tokens, when the host model registry reports one. */
+	maxTokens?: number;
+	/** Input modalities reported by the registry, e.g. ["text", "image"]. */
+	input?: string[];
+	/** Per-token pricing from the registry (USD per 1M tokens). */
+	cost?: ModelCost;
 }
 
 interface RegistryModelLike {
@@ -17,6 +27,10 @@ interface RegistryModelLike {
 	api?: string;
 	reasoning?: boolean;
 	thinkingLevelMap?: ThinkingLevelMap;
+	contextWindow?: number;
+	maxTokens?: number;
+	input?: string[];
+	cost?: ModelCost;
 }
 
 export function toModelInfo(model: RegistryModelLike): ModelInfo {
@@ -27,6 +41,12 @@ export function toModelInfo(model: RegistryModelLike): ModelInfo {
 		api: model.api,
 		reasoning: model.reasoning,
 		thinkingLevelMap: model.thinkingLevelMap,
+		...(typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {}),
+		...(typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? { maxTokens: model.maxTokens } : {}),
+		...(Array.isArray(model.input) && model.input.length > 0 ? { input: [...model.input] } : {}),
+		...(model.cost && Number.isFinite(model.cost.input) && Number.isFinite(model.cost.output)
+			? { cost: { ...model.cost, ...(model.cost.tiers ? { tiers: model.cost.tiers.map((tier) => ({ ...tier })) } : {}) } }
+			: {}),
 	};
 }
 

package/dist/extensions/pi-subagents/src/shared/prompt-resources.ts

@@ -1,14 +1,7 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseFrontmatter } from "../agents/frontmatter.ts";
 import { getAgentDir, getProjectConfigDir } from "./utils.ts";
 
-const PROMPT_REF_PATTERN = /^(package|user|project):([A-Za-z0-9][A-Za-z0-9._-]{0,127})$/;
-const PROMPT_VARIABLE_PATTERN = /\{\{(\w+)\}\}/g;
-
-type PromptVariable = string | number | boolean;
-
 export function getPromptDirectories(cwd: string) {
 	return {
 		package: path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "prompts"),
@@ -16,36 +9,3 @@ export function getPromptDirectories(cwd: string) {
 		project: path.join(getProjectConfigDir(cwd), "prompts"),
 	};
 }
-
-function promptVariables(vars: unknown): Record<string, PromptVariable> {
-	if (vars === undefined) return {};
-	if (!vars || typeof vars !== "object" || Array.isArray(vars)) throw new Error("prompts.render vars must be a plain object.");
-	const prototype = Object.getPrototypeOf(vars);
-	if (prototype !== null && prototype !== Object.prototype) throw new Error("prompts.render vars must be a plain object.");
-	for (const [name, value] of Object.entries(vars)) {
-		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
-			throw new Error(`prompts.render variable '${name}' must be a string, number, or boolean.`);
-		}
-	}
-	return vars as Record<string, PromptVariable>;
-}
-
-export function renderWorkflowPrompt(ref: string, vars: unknown, cwd: string): string {
-	const match = ref.match(PROMPT_REF_PATTERN);
-	if (!match) throw new Error("prompts.render ref must use package:<name>, user:<name>, or project:<name>.");
-	const scope = match[1] as keyof ReturnType<typeof getPromptDirectories>;
-	const name = match[2]!;
-	const filePath = path.join(getPromptDirectories(cwd)[scope], `${name}.md`);
-	let content: string;
-	try {
-		if (!fs.lstatSync(filePath).isFile()) throw new Error("not a regular file");
-		content = fs.readFileSync(filePath, "utf-8");
-	} catch (error) {
-		const detail = error instanceof Error ? error.message : String(error);
-		throw new Error(`Could not read prompt fragment '${ref}': ${detail}`);
-	}
-	const variables = promptVariables(vars);
-	return parseFrontmatter(content).body.trim().replace(PROMPT_VARIABLE_PATTERN, (placeholder, variable: string) => {
-		return Object.hasOwn(variables, variable) ? String(variables[variable]) : placeholder;
-	});
-}