pi-subagents 0.68.0 → 0.70.0

package/src/shared/accessible-dir.ts

@@ -1,47 +0,0 @@
-import * as fs from "node:fs";
-import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, runFileSystemOperationWithRetry, waitForFileSystemRetry } from "./file-system-retry.ts";
-
-type AccessibleDirFs = Pick<typeof fs, "accessSync" | "mkdirSync">;
-
-type AccessibleDirOptions = {
-	fs?: AccessibleDirFs;
-	retryDirectoryErrors?: boolean;
-	retryDelaysMs?: readonly number[];
-	wait?: (delayMs: number) => void;
-	pid?: number;
-};
-
-export function ensureAccessibleDir(dirPath: string, options: AccessibleDirOptions = {}): string {
-	const fsImpl = options.fs ?? fs;
-	const pid = options.pid ?? process.pid;
-	const retryDirectoryErrors = options.retryDirectoryErrors ?? process.platform === "win32";
-	const retryDelaysMs = retryDirectoryErrors ? options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS : [];
-	const wait = options.wait ?? waitForFileSystemRetry;
-
-	const mkdirWithRetry = (target: string): void => {
-		runFileSystemOperationWithRetry(() => {
-			fsImpl.mkdirSync(target, { recursive: true });
-		}, { retryDelaysMs, wait });
-	};
-	const accessWithRetry = (target: string): void => {
-		runFileSystemOperationWithRetry(() => {
-			fsImpl.accessSync(target, fs.constants.R_OK | fs.constants.W_OK);
-		}, { retryDelaysMs, wait });
-	};
-	const fallbackPath = (): string => {
-		const fallback = `${dirPath}-${pid}`;
-		mkdirWithRetry(fallback);
-		accessWithRetry(fallback);
-		return fallback;
-	};
-
-	try {
-		mkdirWithRetry(dirPath);
-		accessWithRetry(dirPath);
-		return dirPath;
-	} catch (error) {
-		const code = (error as NodeJS.ErrnoException | undefined)?.code;
-		if (code !== "EPERM" && code !== "EACCES") throw error;
-		return fallbackPath();
-	}
-}

package/src/shared/agent-stream-options.ts

@@ -1,5 +0,0 @@
-import type { StreamFn } from "@earendil-works/pi-agent-core";
-
-export function agentStreamOptions(streamFn: StreamFn): { streamFunction: StreamFn; streamFn: StreamFn } {
-	return { streamFunction: streamFn, streamFn };
-}

package/src/shared/artifacts.ts

@@ -1,281 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { CHAIN_RUNS_DIR, TEMP_ARTIFACTS_DIR, type ArtifactPaths, type ArtifactDirPreference } from "./types.ts";
-import { getAgentDir } from "./utils.ts";
-const CLEANUP_MARKER_FILE = ".last-cleanup";
-export const PROJECT_SUBAGENTS_RELATIVE_DIR = ".pi/subagents";
-
-const PROJECT_ARTIFACT_PATHS = [
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/output.md`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_input.md`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_output.md`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker.jsonl`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_transcript.jsonl`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_meta.json`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/progress/run/progress.md`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/outputs/output.md`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/outputs/run/output.md`,
-	`${PROJECT_SUBAGENTS_RELATIVE_DIR}/chain-runs/run.json`,
-];
-
-function globMatchesPath(pattern: string, filePath: string): boolean {
-	let expression = "^";
-	for (let index = 0; index < pattern.length; index += 1) {
-		const character = pattern[index];
-		if (character === undefined) break;
-		if (character === "*" && pattern[index + 1] === "*") {
-			index += 1;
-			if (pattern[index + 1] === "/") {
-				index += 1;
-				expression += "(?:.*/)?";
-			} else {
-				expression += ".*";
-			}
-		} else if (character === "*") {
-			expression += "[^/]*";
-		} else if (character === "?") {
-			expression += "[^/]";
-		} else if (character === "[") {
-			const end = pattern.indexOf("]", index + 1);
-			if (end === -1) expression += "\\[";
-			else {
-				expression += pattern.slice(index, end + 1);
-				index = end;
-			}
-		} else {
-			expression += character.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-		}
-	}
-	try {
-		return new RegExp(`${expression}$`).test(filePath);
-	} catch {
-		return false;
-	}
-}
-
-function normalizePattern(pattern: string): string {
-	return pattern.replace(/^\.\//, "").replace(/^\//, "").replace(/\/+$/, "");
-}
-
-function patternMatchesArtifactPath(pattern: string, artifactPath: string): boolean {
-	const normalized = normalizePattern(pattern);
-	return normalized === PROJECT_SUBAGENTS_RELATIVE_DIR
-		|| normalized === "*"
-		|| artifactPath.startsWith(`${normalized}/`)
-		|| globMatchesPath(normalized, artifactPath);
-}
-
-function ignoreFileExcludesProjectArtifacts(filePath: string): boolean {
-	if (!fs.existsSync(filePath)) return false;
-	try {
-		const excluded = new Set<string>();
-		for (const rawLine of fs.readFileSync(filePath, "utf-8").split(/\r?\n/)) {
-			const line = rawLine.trim();
-			if (!line || line.startsWith("#")) continue;
-			const negated = line.startsWith("!");
-			const pattern = negated ? line.slice(1) : line;
-			for (const artifactPath of PROJECT_ARTIFACT_PATHS) {
-				if (!patternMatchesArtifactPath(pattern, artifactPath)) continue;
-				if (negated) excluded.delete(artifactPath);
-				else excluded.add(artifactPath);
-			}
-		}
-		return excluded.size === PROJECT_ARTIFACT_PATHS.length;
-	} catch {
-		return false;
-	}
-}
-
-function filesIncludeProjectArtifacts(files: unknown): boolean | undefined {
-	if (!Array.isArray(files)) return undefined;
-	const included = new Set<string>();
-	for (const entry of files) {
-		if (typeof entry !== "string") continue;
-		const negated = entry.startsWith("!");
-		const pattern = negated ? entry.slice(1) : entry;
-		for (const artifactPath of PROJECT_ARTIFACT_PATHS) {
-			if (!patternMatchesArtifactPath(pattern, artifactPath)) continue;
-			if (negated) included.delete(artifactPath);
-			else included.add(artifactPath);
-		}
-	}
-	return included.size > 0;
-}
-
-/** Returns a package-publishing warning when project artifacts can enter npm packages. */
-export function getProjectArtifactPackagingWarning(cwd: string): string | undefined {
-	const packagePath = path.join(cwd, "package.json");
-	if (!fs.existsSync(packagePath)) return undefined;
-
-	let packageJson: Record<string, unknown>;
-	try {
-		const parsed: unknown = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
-		packageJson = parsed as Record<string, unknown>;
-	} catch {
-		return undefined;
-	}
-
-	const filesIncludeArtifacts = filesIncludeProjectArtifacts(packageJson.files);
-	if (filesIncludeArtifacts === false) return undefined;
-
-	const npmIgnorePath = path.join(cwd, ".npmignore");
-	const ignorePath = fs.existsSync(npmIgnorePath) ? npmIgnorePath : path.join(cwd, ".gitignore");
-	if (filesIncludeArtifacts === undefined && ignoreFileExcludesProjectArtifacts(ignorePath)) return undefined;
-
-	return "Project-scoped subagent artifacts can be included when this package is published. Add '.pi/subagents/' to .npmignore, restrict package.json files, or set artifactDir to 'session' or 'temp'.";
-}
-
-export function getProjectSubagentsDir(cwd: string): string {
-	return path.join(cwd, PROJECT_SUBAGENTS_RELATIVE_DIR);
-}
-
-export function getProjectArtifactsDir(cwd: string): string {
-	return path.join(getProjectSubagentsDir(cwd), "artifacts");
-}
-
-export function getProjectChainRunsDir(cwd: string): string {
-	return path.join(getProjectSubagentsDir(cwd), "chain-runs");
-}
-
-export function getChainRunsDir(
-	projectCwd: string,
-	dirPreference: ArtifactDirPreference = "session",
-): string {
-	switch (dirPreference) {
-		case "project":
-			return getProjectChainRunsDir(projectCwd);
-		case "session":
-		case "temp":
-			return CHAIN_RUNS_DIR;
-		default:
-			throw new Error(`Unsupported artifactDir ${JSON.stringify(dirPreference)}; expected "project", "session", or "temp".`);
-	}
-}
-
-export function getArtifactsDir(
-	sessionFile: string | null,
-	projectCwd?: string,
-	dirPreference: ArtifactDirPreference = "session",
-): string {
-	switch (dirPreference) {
-		case "session":
-			if (sessionFile) {
-				const sessionDir = path.dirname(sessionFile);
-				return path.join(sessionDir, "subagent-artifacts");
-			}
-			return TEMP_ARTIFACTS_DIR;
-		case "temp":
-			return TEMP_ARTIFACTS_DIR;
-		case "project":
-			if (projectCwd) return getProjectArtifactsDir(projectCwd);
-			if (sessionFile) {
-				const sessionDir = path.dirname(sessionFile);
-				return path.join(sessionDir, "subagent-artifacts");
-			}
-			return TEMP_ARTIFACTS_DIR;
-		default:
-			throw new Error(`Unsupported artifactDir ${JSON.stringify(dirPreference)}; expected "project", "session", or "temp".`);
-	}
-}
-
-export function getArtifactPaths(artifactsDir: string, runId: string, agent: string, index?: number): ArtifactPaths {
-	const suffix = index !== undefined ? `_${index}` : "";
-	const safeAgent = agent.replace(/[^\w.-]/g, "_");
-	const base = `${runId}_${safeAgent}${suffix}`;
-	return {
-		inputPath: path.join(artifactsDir, `${base}_input.md`),
-		outputPath: path.join(artifactsDir, `${base}_output.md`),
-		jsonlPath: path.join(artifactsDir, `${base}.jsonl`),
-		transcriptPath: path.join(artifactsDir, `${base}_transcript.jsonl`),
-		metadataPath: path.join(artifactsDir, `${base}_meta.json`),
-	};
-}
-
-export function ensureArtifactsDir(dir: string): void {
-	fs.mkdirSync(dir, { recursive: true });
-}
-
-export function writeArtifact(filePath: string, content: string): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.writeFileSync(filePath, content, "utf-8");
-}
-
-export function formatOutputArtifactContent(input: {
-	output: string;
-	error?: string;
-	transcriptPath?: string;
-	metadataPath?: string;
-}): string {
-	if (input.output.trim() || !input.error) return input.output;
-	const lines = ["Subagent run failed before producing output.", "", "Error:", input.error];
-	if (input.transcriptPath) lines.push("", `Transcript: ${input.transcriptPath}`);
-	if (input.metadataPath) lines.push(`Metadata: ${input.metadataPath}`);
-	return lines.join("\n");
-}
-
-export function writeMetadata(filePath: string, metadata: object): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2), "utf-8");
-}
-
-export function appendJsonl(filePath: string, line: string): void {
-	fs.appendFileSync(filePath, `${line}\n`);
-}
-
-export function cleanupOldArtifacts(dir: string, maxAgeDays: number): void {
-	if (maxAgeDays <= 0 || !fs.existsSync(dir)) return;
-
-	const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
-	const now = Date.now();
-
-	if (fs.existsSync(markerPath)) {
-		const stat = fs.statSync(markerPath);
-		if (now - stat.mtimeMs < 24 * 60 * 60 * 1000) return;
-	}
-
-	const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
-	const cutoff = now - maxAgeMs;
-
-	for (const file of fs.readdirSync(dir)) {
-		if (file === CLEANUP_MARKER_FILE) continue;
-		const filePath = path.join(dir, file);
-		try {
-			const stat = fs.statSync(filePath);
-			if (stat.mtimeMs < cutoff) {
-				fs.unlinkSync(filePath);
-			}
-		} catch {
-			// Artifact cleanup is best-effort housekeeping. Skip files that disappear
-			// or become unreadable while scanning so one bad entry does not block the rest.
-		}
-	}
-
-	fs.writeFileSync(markerPath, String(now));
-}
-
-export function cleanupAllArtifactDirs(maxAgeDays: number): void {
-	cleanupOldArtifacts(TEMP_ARTIFACTS_DIR, maxAgeDays);
-
-	const sessionsBase = path.join(getAgentDir(), "sessions");
-	if (!fs.existsSync(sessionsBase)) return;
-
-	let dirs: string[];
-	try {
-		dirs = fs.readdirSync(sessionsBase);
-	} catch {
-		// Session artifact cleanup is best-effort. If the sessions root cannot be read,
-		// skip cleanup instead of failing extension startup.
-		return;
-	}
-
-	for (const dir of dirs) {
-		const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
-		try {
-			cleanupOldArtifacts(artifactsDir, maxAgeDays);
-		} catch {
-			// Session cleanup is best-effort. Keep going so one unreadable session dir
-			// does not block cleanup for the rest.
-		}
-	}
-}

package/src/shared/atomic-json.ts

@@ -1,83 +0,0 @@
-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;
-	pid?: number;
-	random?: () => number;
-	mode?: number;
-	retryRenameErrors?: boolean;
-	retryDirectoryErrors?: boolean;
-	ignoreCleanupErrorAfterSuccess?: boolean;
-	retryDelaysMs?: readonly number[];
-	wait?: (delayMs: number) => void;
-};
-
-function renameWithRetry(
-	fsImpl: AtomicJsonFs,
-	sourcePath: string,
-	targetPath: string,
-	retryDelaysMs: readonly number[],
-	wait: (delayMs: number) => void,
-): void {
-	runFileSystemOperationWithRetry(() => {
-		fsImpl.renameSync(sourcePath, targetPath);
-	}, { 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;
-	const pid = options.pid ?? process.pid;
-	const random = options.random ?? Math.random;
-	const mode = options.mode;
-	const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
-	const retryDirectoryErrors = options.retryDirectoryErrors ?? retryRenameErrors;
-	const ignoreCleanupErrorAfterSuccess = options.ignoreCleanupErrorAfterSuccess ?? false;
-	const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS;
-	const renameRetryDelaysMs = retryRenameErrors ? retryDelaysMs : [];
-	const directoryRetryDelaysMs = retryDirectoryErrors ? retryDelaysMs : [];
-	const wait = options.wait ?? waitForFileSystemRetry;
-	return (filePath: string, payload: object): void => {
-		runFileSystemOperationWithRetry(() => {
-			fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
-		}, { retryDelaysMs: directoryRetryDelaysMs, wait });
-		const tempPath = path.join(
-			path.dirname(filePath),
-			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 {
-			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 && !ignoreCleanupErrorAfterSuccess) throw cleanupError;
-			}
-		}
-	};
-}
-
-export const writeAtomicJson = createAtomicJsonWriter();
-export const writePrivateAtomicJson = createAtomicJsonWriter({ mode: 0o600 });

package/src/shared/capacity-resilient-json.ts

@@ -1,102 +0,0 @@
-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/src/shared/child-cache-retention.ts

@@ -1,43 +0,0 @@
-import type { StreamFn } from "@earendil-works/pi-agent-core";
-
-/**
- * Anthropic prices a cache write by the TTL it is asked for: 1.25x base input
- * for the 5m window, 2x for the 1h one. Child sessions are short-lived and
- * rarely idle, so a 1h window they never claim is a flat surcharge on every
- * write. Setting this to `short` keeps that surcharge off children while the
- * parent keeps `long`, the same split Claude Code makes between its main
- * conversation and its subagents.
- *
- * Unset means children inherit the parent's retention, which is the behaviour
- * before this setting existed.
- */
-export function childCacheRetention(env: NodeJS.ProcessEnv = process.env): string | undefined {
-	return env.PI_SUBAGENT_CACHE_RETENTION || undefined;
-}
-
-/**
- * Launch-environment form for spawned children. Empty when unset, so the child
- * inherits the parent's `PI_CACHE_RETENTION` rather than having it cleared.
- */
-export function childCacheRetentionEnv(env?: NodeJS.ProcessEnv): { PI_CACHE_RETENTION?: string } {
-	const retention = childCacheRetention(env);
-	return retention ? { PI_CACHE_RETENTION: retention } : {};
-}
-
-/**
- * Pi resolves retention per request as `options.env?.[name] || process.env[name]`,
- * so a per-call env beats the process-wide one. Wrapping the session's own
- * stream function keeps this scoped to one child, with no shared-state race
- * against a parent turn streaming concurrently.
- */
-export function pinChildCacheRetention(agent: { streamFunction: StreamFn } | undefined, env?: NodeJS.ProcessEnv): void {
-	if (!agent?.streamFunction) return;
-	const retention = childCacheRetention(env);
-	if (!retention) return;
-	const base = agent.streamFunction;
-	agent.streamFunction = (model, context, options) =>
-		base(model, context, {
-			...options,
-			env: { ...(options?.env ?? {}), PI_CACHE_RETENTION: retention },
-		});
-}

package/src/shared/child-session-name.ts

@@ -1,46 +0,0 @@
-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's runtime config as `sessionName`, 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);
-}