@selesai/code 0.13.0 → 0.13.1

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

@@ -1,18 +1,11 @@
-/**
- * General utility functions for the subagent extension
- */
-
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { Message } from "@earendil-works/pi-ai";
+import type { Message, Usage as PiUsage } from "@earendil-works/pi-ai";
 import { previewDisplayText, sanitizeDisplayText, truncateDisplayText } from "./display-text.ts";
 import { formatToolCall } from "./formatters.ts";
 import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, NestedRunSummary, SingleResult, ToolCallSummary, Usage } from "./types.ts";
-
-// ============================================================================
-// File System Utilities
-// ============================================================================
+import { validateAsyncStatusLaneMetadata } from "../runs/shared/lane-metadata.ts";
 
 const DEFAULT_CONFIG_DIR_NAME = ".selesai";
 const SELESAI_CODING_AGENT_PACKAGE_NAME = "@selesai/code";
@@ -96,9 +89,10 @@ export function getProjectConfigDir(projectRoot: string): string {
 
 export function getAgentDir(): string {
 	const configured = process.env.SELESAI_CODING_AGENT_DIR;
-	if (configured === "~") return os.homedir();
-	if (configured?.startsWith("~/")) return path.join(os.homedir(), configured.slice(2));
-	return configured || path.join(os.homedir(), getConfigDirName(), "agent");
+	const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+	if (configured === "~") return home;
+	if (configured?.startsWith("~/") || configured?.startsWith("~\\")) return path.join(home, configured.slice(2));
+	return configured || path.join(home, getConfigDirName(), "agent");
 }
 
 const statusCache = new Map<string, { mtime: number; ctime: number; size: number; ino: number; status: AsyncStatus }>();
@@ -190,6 +184,13 @@ export function readStatus(asyncDir: string): AsyncStatus | null {
 			cause: error instanceof Error ? error : undefined,
 		});
 	}
+	try {
+		validateAsyncStatusLaneMetadata(status, `Invalid async status '${statusPath}'`);
+	} catch (error) {
+		throw new Error(`Failed to validate async status file '${statusPath}': ${getErrorMessage(error)}`, {
+			cause: error instanceof Error ? error : undefined,
+		});
+	}
 
 	statusCache.set(statusPath, {
 		mtime: stat.mtimeMs,
@@ -206,57 +207,7 @@ export function readStatus(asyncDir: string): AsyncStatus | null {
 	return status;
 }
 
-const outputTailCache = new Map<string, { mtime: number; size: number; lines: string[] }>();
-
-/**
- * Get the last N lines from an output file (with mtime/size-based caching)
- */
-function getOutputTail(outputFile: string | undefined, maxLines: number = 3): string[] {
-	if (!outputFile) return [];
-	let fd: number | null = null;
-	try {
-		const stat = fs.statSync(outputFile);
-		if (stat.size === 0) return [];
-
-		const cached = outputTailCache.get(outputFile);
-		if (cached && cached.mtime === stat.mtimeMs && cached.size === stat.size) {
-			return cached.lines;
-		}
-
-		const tailBytes = 4096;
-		const start = Math.max(0, stat.size - tailBytes);
-		fd = fs.openSync(outputFile, "r");
-		const buffer = Buffer.alloc(Math.min(tailBytes, stat.size));
-		fs.readSync(fd, buffer, 0, buffer.length, start);
-		const content = buffer.toString("utf-8");
-		const allLines = content.split("\n").filter((l) => l.trim());
-		const lines = allLines.slice(-maxLines).map((l) => l.slice(0, 120) + (l.length > 120 ? "..." : ""));
-
-		outputTailCache.set(outputFile, { mtime: stat.mtimeMs, size: stat.size, lines });
-		if (outputTailCache.size > 20) {
-			const firstKey = outputTailCache.keys().next().value;
-			if (firstKey) outputTailCache.delete(firstKey);
-		}
-
-		return lines;
-	} catch {
-		// Output tails are UI-only hints; unreadable or missing files should render as no tail.
-		return [];
-	} finally {
-		if (fd !== null) {
-			try {
-				fs.closeSync(fd);
-			} catch {
-				// Closing the best-effort tail file handle should not surface over the main status view.
-			}
-		}
-	}
-}
-
-/**
- * Get human-readable last activity time for a file
- */
-	export function getLastActivity(outputFile: string | undefined): string {
+export function getLastActivity(outputFile: string | undefined): string {
 	if (!outputFile) return "";
 	try {
 		const stat = fs.statSync(outputFile);
@@ -265,14 +216,11 @@ function getOutputTail(outputFile: string | undefined, maxLines: number = 3): st
 		if (ago < 60000) return `active ${Math.floor(ago / 1000)}s ago`;
 		return `active ${Math.floor(ago / 60000)}m ago`;
 	} catch {
-		// Last-activity text is best effort; missing files should simply omit the hint.
+		// Last-activity text is best effort; missing files should omit the hint.
 		return "";
 	}
 }
 
-/**
- * Find the latest session file in a directory
- */
 export function findLatestSessionFile(sessionDir: string): string | null {
 	if (!fs.existsSync(sessionDir)) return null;
 	const files = fs.readdirSync(sessionDir)
@@ -289,23 +237,6 @@ export function findLatestSessionFile(sessionDir: string): string | null {
 	return latest ? latest.path : null;
 }
 
-/**
- * Write a prompt to a temporary file
- */
-function writePrompt(agent: string, prompt: string): { dir: string; path: string } {
-	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
-	const p = path.join(dir, `${agent.replace(/[^\w.-]/g, "_")}.md`);
-	fs.writeFileSync(p, prompt, { mode: 0o600 });
-	return { dir, path: p };
-}
-
-// ============================================================================
-// Message Parsing Utilities
-// ============================================================================
-
-/**
- * Get the final text output from a list of messages
- */
 export function getFinalOutput(messages: Message[]): string {
 	const validTextParts: string[] = [];
 	for (let i = messages.length - 1; i >= 0; i--) {
@@ -361,6 +292,7 @@ function compactCompletedProgress(progress: AgentProgress): AgentProgress {
 	return {
 		index: progress.index,
 		agent: progress.agent,
+		...(progress.sessionName ? { sessionName: progress.sessionName } : {}),
 		status: progress.status,
 		activityState: progress.activityState,
 		task: "[prompt redacted]",
@@ -407,6 +339,17 @@ export function sumResultsUsage(results: SingleResult[]): Usage {
 	return usage;
 }
 
+export function toAgentToolUsage(usage: Usage): PiUsage {
+	return {
+		input: usage.input,
+		output: usage.output,
+		cacheRead: usage.cacheRead,
+		cacheWrite: usage.cacheWrite,
+		totalTokens: usage.input + usage.output + usage.cacheRead + usage.cacheWrite,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: usage.cost },
+	};
+}
+
 function addNestedCost(total: NonNullable<Details["totalCost"]>, children: NestedRunSummary[] | undefined): void {
 	for (const child of children ?? []) {
 		if (child.totalCost) {
@@ -505,6 +448,20 @@ export function hasEmptyTerminalAssistantResponse(messages: Message[]): boolean
 		&& lastAssistant.usage.output === 0;
 }
 
+export function formatEmptyTerminalAssistantResponseError(messages: Message[]): string {
+	const lastAssistant = messages.findLast((message) => message.role === "assistant");
+	const errorMessage = lastAssistant && "errorMessage" in lastAssistant && typeof lastAssistant.errorMessage === "string" && lastAssistant.errorMessage.trim()
+		? lastAssistant.errorMessage.trim()
+		: undefined;
+	if (errorMessage) return errorMessage;
+	const stopReason = lastAssistant && "stopReason" in lastAssistant && typeof lastAssistant.stopReason === "string" && lastAssistant.stopReason.trim()
+		? lastAssistant.stopReason.trim()
+		: undefined;
+	return stopReason && stopReason !== "stop"
+		? `Subagent produced no output after terminal assistant stopReason "${stopReason}".`
+		: "Subagent produced no output (possible model cold-start or empty response).";
+}
+
 /**
  * Detect errors in subagent execution from messages (only errors with no subsequent success)
  */

package/dist/extensions/pi-subagents/src/shared/workflow-child-permit.ts

@@ -0,0 +1,116 @@
+import { stableJsonDigest } from "./launch-contract.ts";
+
+export interface WorkflowChildPermitInput {
+	issuerPackage: string;
+	workflowRunId: string;
+	childKey: string;
+	agent: string;
+	launchContractDigest: string;
+	context: "fresh" | "fork";
+}
+
+export interface WorkflowChildPermitLaunch {
+	workflowRunId: string;
+	childKey: string;
+	agent: string;
+	launchContractDigest: string;
+	context: "fresh" | "fork";
+	runner: "pi";
+}
+
+export interface WorkflowChildPermitContext {
+	permit: WorkflowChildPermit;
+	workflowRunId: string;
+	childKey: string;
+}
+
+export interface WorkflowChildPermit {
+	readonly __workflowChildPermit: unique symbol;
+}
+
+interface WorkflowChildPermitRecord {
+	issuerPackage: string;
+	workflowRunId: string;
+	childKey: string;
+	agent: string;
+	expectedProjectionDigest: string;
+	state: "available" | "claimed" | "consumed";
+}
+
+const records = new WeakMap<object, WorkflowChildPermitRecord>();
+
+function projectionDigest(input: Omit<WorkflowChildPermitLaunch, "workflowRunId">): string {
+	return stableJsonDigest({
+		version: 1,
+		childKey: input.childKey,
+		agent: input.agent,
+		launchContractDigest: input.launchContractDigest,
+		context: input.context,
+		runner: input.runner,
+	});
+}
+
+function required(value: string, label: string): string {
+	if (!value.trim() || value !== value.trim()) throw new Error(`${label} must be a non-empty trimmed string.`);
+	return value;
+}
+
+/** Package-internal first-slice permit. It is opaque, in-memory, and not serializable. */
+export function createWorkflowChildPermit(input: WorkflowChildPermitInput): WorkflowChildPermit {
+	const permit = Object.freeze(Object.create(null)) as WorkflowChildPermit;
+	const record: WorkflowChildPermitRecord = {
+		issuerPackage: required(input.issuerPackage, "issuerPackage"),
+		workflowRunId: required(input.workflowRunId, "workflowRunId"),
+		childKey: required(input.childKey, "childKey"),
+		agent: required(input.agent, "agent"),
+		expectedProjectionDigest: projectionDigest({
+			childKey: input.childKey,
+			agent: input.agent,
+			launchContractDigest: required(input.launchContractDigest, "launchContractDigest"),
+			context: input.context,
+			runner: "pi",
+		}),
+		state: "available",
+	};
+	records.set(permit as object, record);
+	return permit;
+}
+
+export function validateWorkflowChildPermitRoot(permit: WorkflowChildPermit, workflowRunId: string): string | undefined {
+	const record = records.get(permit as object);
+	if (!record) return "Workflow child permit is invalid.";
+	if (record.state !== "available") return "Workflow child permit is already consumed.";
+	if (record.workflowRunId !== workflowRunId) return "Workflow child permit does not match this workflow root.";
+	return undefined;
+}
+
+/** Claim the first distinct launch attempt before validating its model-authored shape. */
+export function claimWorkflowChildPermit(permit: WorkflowChildPermit, workflowRunId: string, childKey: string): string | undefined {
+	const record = records.get(permit as object);
+	if (!record) return "Workflow child permit is invalid.";
+	if (record.state !== "available") return "Workflow child permit is already consumed.";
+	if (record.workflowRunId !== workflowRunId) return "Workflow child permit does not match this workflow root.";
+	record.state = record.childKey === childKey ? "claimed" : "consumed";
+	if (record.childKey !== childKey) return "Workflow child permit child key mismatch.";
+	return undefined;
+}
+
+/** Verify and permanently consume the permit before the one native process spawn. */
+export function consumeWorkflowChildPermit(permit: WorkflowChildPermit, launch: WorkflowChildPermitLaunch): string | undefined {
+	const record = records.get(permit as object);
+	if (!record) return "Workflow child permit is invalid.";
+	if (record.state === "available") return "Workflow child permit launch was not claimed.";
+	if (record.state === "consumed") return "Workflow child permit is already consumed.";
+	if (record.workflowRunId !== launch.workflowRunId) return "Workflow child permit does not match this workflow root.";
+	record.state = "consumed";
+	if (record.childKey !== launch.childKey) return "Workflow child permit child key mismatch.";
+	if (record.agent !== launch.agent) return "Workflow child permit agent mismatch.";
+	if (launch.runner !== "pi") return "Workflow child permit supports native Pi children only.";
+	if (record.expectedProjectionDigest !== projectionDigest(launch)) return "Workflow child permit does not match the final launch projection.";
+	return undefined;
+}
+
+export function workflowChildPermitConsumed(permit: WorkflowChildPermit): boolean {
+	const state = records.get(permit as object)?.state;
+	return state === "claimed" || state === "consumed";
+}

package/dist/extensions/pi-subagents/src/slash/delegation-adapters.ts

@@ -6,7 +6,7 @@ import {
 	type SubagentDelegationUpdate,
 	type SubagentDelegationValue,
 } from "../api/delegation.ts";
-import type { AcceptanceInput, AgentContract, EffectsProjection, ExecutionProjection, JsonSchemaObject, ReviewProjection, ToolBudgetConfig, TurnBudgetConfig, Usage } from "../shared/types.ts";
+import type { AcceptanceInput, AgentContract, EffectsProjection, ExecutionProjection, JsonSchemaObject, ReviewProjection, ToolBudgetConfig, Usage } from "../shared/types.ts";
 import { cloneJsonWithinByteLimit } from "./delegation-json.ts";
 
 export interface PromptTemplateDelegationRequest {
@@ -82,7 +82,6 @@ export interface PromptTemplateBridgeResult {
 			interrupted?: boolean;
 			timedOut?: boolean;
 			stopped?: boolean;
-			turnBudgetExceeded?: boolean;
 			toolBudgetBlocked?: boolean;
 			structuredOutputFailed?: boolean;
 			savedOutputPath?: string;
@@ -120,9 +119,6 @@ export interface DelegatedSubagentExecutionParams {
 	model?: string;
 	cwd: string;
 	timeoutMs?: number;
-	turnBudget?: TurnBudgetConfig;
-	/** Internal-only strict turn-boundary enforcement for structured foreground delegation. */
-	enforceHardTurnLimit?: boolean;
 	toolBudget?: ToolBudgetConfig;
 	skill?: string | string[] | boolean;
 	output?: string | boolean;
@@ -294,11 +290,8 @@ export function toSubagentDelegationExecutionParams(request: SubagentDelegationR
 		cwd: request.cwd,
 		model: request.model,
 		timeoutMs: request.timeoutMs,
-		turnBudget: request.turnBudget,
-		enforceHardTurnLimit: true,
 		toolBudget: request.toolBudget,
 		skill: request.skill,
-		output: false,
 		...(request.result.kind === "structured" ? { outputSchema: request.result.schema } : {}),
 		acceptance: false,
 		artifacts: request.artifacts,
@@ -342,7 +335,6 @@ function resolveSubagentDelegationStatus(
 	if (!child) return "failed";
 	if (result.details?.timedOut || child.timedOut) return "timed_out";
 	if (child?.structuredOutputFailed) return "structured_output_failed";
-	if (child?.turnBudgetExceeded) return "turn_budget_exhausted";
 	if (child?.toolBudgetBlocked) return "tool_budget_exhausted";
 	if (child?.acceptance?.status === "rejected" && child.acceptance.explicit) return "acceptance_failed";
 	if (result.details?.stopped || child?.stopped || child?.interrupted) return "interrupted";

package/dist/extensions/pi-subagents/src/slash/delegation-request.ts

@@ -2,7 +2,6 @@ import {
 	type SubagentDelegationRequest,
 } from "../api/delegation.ts";
 import { validateToolBudgetConfig } from "../runs/shared/tool-budget.ts";
-import { resolveTurnBudgetConfig } from "../runs/shared/turn-budget.ts";
 import { cloneJsonWithinByteLimit } from "./delegation-json.ts";
 
 export type SubagentDelegationParseResult =
@@ -20,7 +19,6 @@ const supportedFields = new Set([
 	"model",
 	"thinking",
 	"timeoutMs",
-	"turnBudget",
 	"toolBudget",
 	"skill",
 	"artifacts",
@@ -80,8 +78,6 @@ export function parseSubagentDelegationRequest(data: unknown): SubagentDelegatio
 	if (timeoutMs !== undefined && timeoutMs > 2_147_483_647) {
 		return { ok: false, ...identity, error: "timeoutMs must be <= 2147483647." };
 	}
-	const turnBudget = resolveTurnBudgetConfig(value.turnBudget);
-	if (turnBudget.error) return { ok: false, ...identity, error: turnBudget.error };
 	if (value.toolBudget && typeof value.toolBudget === "object" && !Array.isArray(value.toolBudget)) {
 		const unsupportedToolBudgetField = Object.keys(value.toolBudget).find((key) => key !== "soft" && key !== "hard" && key !== "block");
 		if (unsupportedToolBudgetField) {

package/dist/extensions/pi-subagents/src/slash/slash-bridge.ts

@@ -39,7 +39,6 @@ interface EventBus {
 
 interface SlashBridgeOptions {
 	events: EventBus;
-	asyncByDefault: boolean;
 	getContext: () => ExtensionContext | null;
 	execute: (
 		id: string,
@@ -80,7 +79,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 		const request = data as Partial<SlashSubagentRequest>;
 		if (typeof request.requestId !== "string" || !request.params) return;
 		const { requestId } = request as SlashSubagentRequest;
-		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params, { asyncByDefault: options.asyncByDefault });
+		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params);
 		if (!normalized.ok) {
 			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
 				requestId,