@selesai/code 0.13.0 → 0.13.1

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

@@ -77,6 +77,8 @@ interface CreateWorktreesOptions {
 	agents?: string[];
 	setupHook?: WorktreeSetupHookConfig;
 	baseDir?: string;
+	/** Called with deterministic ownership metadata before any worktree is created. */
+	beforeCreate?: (setup: WorktreeSetup) => void;
 }
 
 interface ResolvedWorktreeSetupHook {
@@ -680,6 +682,22 @@ export function createWorktrees(cwd: string, runId: string, count: number, optio
 	const repo = resolveRepoState(cwd);
 	const setupHook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);
 	const baseDir = resolveWorktreeBaseDir(options?.baseDir, repo.toplevel);
+	const plannedSetup: WorktreeSetup = {
+		cwd: repo.toplevel,
+		baseCommit: repo.baseCommit,
+		worktrees: Array.from({ length: count }, (_, index) => {
+			const worktreePath = buildWorktreePath(baseDir, runId, index);
+			return {
+				path: worktreePath,
+				agentCwd: repo.cwdRelative ? path.join(worktreePath, repo.cwdRelative) : worktreePath,
+				branch: buildWorktreeBranch(runId, index),
+				index,
+				nodeModulesLinked: false,
+				syntheticPaths: [],
+			};
+		}),
+	};
+	options?.beforeCreate?.(plannedSetup);
 	const worktrees: WorktreeInfo[] = [];
 
 	try {

package/dist/extensions/pi-subagents/src/shared/child-session-name.ts

@@ -0,0 +1,46 @@
+import { previewDisplayText } from "./display-text.ts";
+import { PROMPT_REDACTED } from "./utils.ts";
+
+/**
+ * Human-readable display name for a child session, derived at launch time from
+ * the agent name and its task (or workflow node label). The parent computes it
+ * once and threads it two ways:
+ *
+ *  1. Into the child process via `PI_SUBAGENT_SESSION_NAME`, where the prompt
+ *     runtime calls `pi.setSessionName(...)` so the child's own session file
+ *     is identifiable in `pi --resume` and host session browsers.
+ *  2. Into the `sessionName` field of result/progress payloads, so hosts
+ *     rendering the parent stream can label each child row.
+ *
+ * The name is display-only metadata. When the intercom bridge is active the
+ * child keeps its machine intercom target as the session name instead — that
+ * name is a routing address and must win (see subagent-prompt-runtime).
+ */
+
+/** Longest task excerpt kept in the name; the full string is capped below. */
+const TASK_EXCERPT_MAX_CHARS = 60;
+/** Hard cap on the final name so host UI rows stay one line. */
+export const CHILD_SESSION_NAME_MAX_CHARS = 80;
+
+export function deriveChildSessionName(input: {
+	agent?: string;
+	task?: string;
+	/** Workflow node label; preferred over the task excerpt when present. */
+	label?: string;
+}): string | undefined {
+	const agent = input.agent?.trim() ?? "";
+	const rawLabel = input.label?.trim() ?? "";
+	const rawTask = input.task?.trim() ?? "";
+	// Never build a name from redacted text — the excerpt would be meaningless
+	// and the redaction marker itself carries no information.
+	const excerptSource =
+		rawLabel && rawLabel !== PROMPT_REDACTED
+			? rawLabel
+			: rawTask && rawTask !== PROMPT_REDACTED
+				? rawTask
+				: "";
+	const excerpt = excerptSource ? previewDisplayText(excerptSource, TASK_EXCERPT_MAX_CHARS) : "";
+	const base = agent && excerpt ? `${agent}: ${excerpt}` : agent || excerpt;
+	if (!base) return undefined;
+	return previewDisplayText(base, CHILD_SESSION_NAME_MAX_CHARS);
+}

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

@@ -0,0 +1,24 @@
+import type { ExtensionContext } from "@selesai/code";
+
+/** Pi exposes replaced extension contexts as ordinary Errors without a stable code. */
+export function isStaleExtensionContextError(error: unknown): boolean {
+	return error instanceof Error
+		&& /extension ctx is stale|extension context no longer active|stale after session replacement or reload/i.test(error.message);
+}
+
+/** Run a synchronous operation against a cached UI context without leaking replacement errors. */
+export function withCachedUiContext<T>(
+	ctx: ExtensionContext | null | undefined,
+	onStale: () => void,
+	run: (ctx: ExtensionContext) => T,
+): T | undefined {
+	if (!ctx) return undefined;
+	try {
+		if (!ctx.hasUI) return undefined;
+		return run(ctx);
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		onStale();
+		return undefined;
+	}
+}

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

@@ -37,6 +37,8 @@ interface ForkableSessionManager {
 
 interface ForkContextResolverOptions {
 	openSession?: (path: string, sessionDir?: string) => BranchSessionManager;
+	/** Rewrite a created fork before its path can be used to spawn a child. */
+	pruneSession?: (sessionFile: string) => Promise<void>;
 	/** Decide per child index whether a sanitized transcript must also disable the child's
 	 * thinking. Defaults to true (the pre-existing conservative behavior) when omitted. */
 	forceThinkingOffForIndex?: (index: number) => boolean;
@@ -48,6 +50,7 @@ interface ForkContextResolution {
 }
 
 interface ForkContextResolver {
+	prepareSessionForIndex(index?: number): Promise<void>;
 	sessionFileForIndex(index?: number): string | undefined;
 	thinkingOverrideForIndex(index?: number): "off" | undefined;
 }
@@ -190,6 +193,7 @@ export function createForkContextResolver(
 ): ForkContextResolver {
 	if (resolveSubagentContext(requestedContext) !== "fork") {
 		return {
+			prepareSessionForIndex: async () => {},
 			sessionFileForIndex: () => undefined,
 			thinkingOverrideForIndex: () => undefined,
 		};
@@ -226,6 +230,8 @@ export function createForkContextResolver(
 		"forks",
 	);
 	const cachedResolutions = new Map<number, ForkContextResolution>();
+	const preparedIndexes = new Set<number>();
+	const preparationPromises = new Map<number, Promise<void>>();
 
 	const resolveFork = (index = 0): ForkContextResolution => {
 		const cached = cachedResolutions.get(index);
@@ -274,7 +280,22 @@ export function createForkContextResolver(
 	};
 
 	return {
+		async prepareSessionForIndex(index = 0): Promise<void> {
+			const resolution = resolveFork(index);
+			if (!options.pruneSession || preparedIndexes.has(index)) return;
+			let preparation = preparationPromises.get(index);
+			if (!preparation) {
+				preparation = options.pruneSession(resolution.sessionFile).then(() => {
+					preparedIndexes.add(index);
+				});
+				preparationPromises.set(index, preparation);
+			}
+			await preparation;
+		},
 		sessionFileForIndex(index = 0): string | undefined {
+			if (options.pruneSession && !preparedIndexes.has(index)) {
+				throw new Error(`Pruned fork session ${index} was used before pruning completed.`);
+			}
 			return resolveFork(index).sessionFile;
 		},
 		thinkingOverrideForIndex(index = 0): "off" | undefined {

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

@@ -4,17 +4,32 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { Usage, SingleResult } from "./types.ts";
+import type { Usage, SingleResult, TokenUsage } from "./types.ts";
 import type { ChainStep } from "./settings.ts";
 import { isDynamicParallelStep, isParallelStep } from "./settings.ts";
 import { previewDisplayText, sanitizeDisplayText } from "./display-text.ts";
 import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
 
 /**
- * Format token count with k suffix for large numbers
+ * Format token count for compact display.
  */
 export function formatTokens(n: number): string {
-	return n < 1000 ? String(n) : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
+	if (n < 1000) return String(n);
+	if (n < 10000) return `${(n / 1000).toFixed(1)}k`;
+	if (n < 999_500) return `${Math.round(n / 1000)}k`;
+	return `${Number((n / 1_000_000).toFixed(1))}M`;
+}
+
+export function formatTokenUsage(usage: TokenUsage, legacyLabel = "tok"): string {
+	return usage.window !== undefined
+		? `${formatTokens(usage.window)} window · ${formatTokens(usage.total)} spent`
+		: `${formatTokens(usage.total)} ${legacyLabel}`;
+}
+export function formatContextUsage(usage: Pick<TokenUsage, "window" | "windowPeak">, contextLimit: number): string | undefined {
+	if (usage.window === undefined || !Number.isFinite(usage.window) || !Number.isFinite(contextLimit) || contextLimit <= 0) return undefined;
+	const peak = usage.windowPeak !== undefined && Number.isFinite(usage.windowPeak) ? usage.windowPeak : usage.window;
+	const used = Math.max(0, usage.window, peak);
+	return `ctx ${formatTokens(used)}/${formatTokens(contextLimit)} (${Math.round((used / contextLimit) * 100)}%)`;
 }
 
 export function formatModelThinking(model?: string, thinking?: string): string {

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

@@ -43,6 +43,7 @@ export function projectAgentDefinition(agent: AgentConfig): Record<string, unkno
 		systemPrompt: agent.systemPrompt,
 		systemPromptMode: agent.systemPromptMode,
 		inheritProjectContext: agent.inheritProjectContext,
+		inheritGlobalContext: agent.inheritGlobalContext,
 		inheritSkills: agent.inheritSkills,
 		model: agent.model,
 		modelProvider: agent.modelProvider,
@@ -50,9 +51,11 @@ export function projectAgentDefinition(agent: AgentConfig): Record<string, unkno
 		fast: agent.fast,
 		thinking: agent.thinking,
 		tools: agent.tools,
+		allowNestedSubagents: agent.allowNestedSubagents,
 		mcpDirectTools: agent.mcpDirectTools,
 		extensions: agent.extensions,
 		subagentOnlyExtensions: agent.subagentOnlyExtensions,
+		mutationTools: agent.mutationTools,
 		skills: agent.skills,
 		skillPath: agent.skillPath,
 		output: agent.output,
@@ -61,7 +64,6 @@ export function projectAgentDefinition(agent: AgentConfig): Record<string, unkno
 		defaultContext: agent.defaultContext,
 		defaultAsync: agent.defaultAsync,
 		defaultTimeoutMs: agent.defaultTimeoutMs,
-		defaultTurnBudget: agent.defaultTurnBudget,
 		defaultAcceptance: agent.defaultAcceptance,
 		acceptanceRole: agent.acceptanceRole,
 		interactive: agent.interactive,
@@ -87,6 +89,7 @@ export interface LaunchBindingInput {
 	systemPrompt?: string | null;
 	systemPromptMode?: AgentConfig["systemPromptMode"];
 	inheritProjectContext: boolean;
+	inheritGlobalContext: boolean;
 	inheritSkills: boolean;
 	skills?: string[];
 	tools?: string[];
@@ -113,6 +116,7 @@ export function projectLaunchBinding(input: LaunchBindingInput): Record<string,
 		systemPromptDigest: input.systemPrompt === undefined || input.systemPrompt === null ? undefined : stableJsonDigest(input.systemPrompt),
 		systemPromptMode: input.systemPromptMode,
 		inheritProjectContext: input.inheritProjectContext,
+		inheritGlobalContext: input.inheritGlobalContext,
 		inheritSkills: input.inheritSkills,
 		skills: input.skills,
 		tools: input.tools,