@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/src/workflows/workflow-receipt.ts

@@ -0,0 +1,140 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "../shared/atomic-json.ts";
+import type { WorkflowReceipt, WorkflowReceiptEntry, WorkflowReceiptState } from "../shared/types.ts";
+import type { WorkflowReceiptResumeReference, WorkflowScriptChildResult } from "./scripted-workflow.ts";
+
+export type { WorkflowReceipt, WorkflowReceiptEntry, WorkflowReceiptState } from "../shared/types.ts";
+
+export const WORKFLOW_RECEIPT_VERSION = 1;
+export const WORKFLOW_RECEIPT_FILE = "workflow-receipt.json";
+
+const KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+
+function assertSafeRunId(value: string, label: string): string {
+	const normalized = value.trim();
+	if (!normalized || path.basename(normalized) !== normalized || normalized === "." || normalized === "..") {
+		throw new Error(`${label} must be an exact workflow run id, not a path or prefix.`);
+	}
+	return normalized;
+}
+
+function assertKey(value: string, label: string): string {
+	if (!KEY_PATTERN.test(value)) throw new Error(`${label} is invalid.`);
+	return value;
+}
+
+export function workflowReceiptPath(asyncDirRoot: string, workflowRunId: string): string {
+	return path.join(asyncDirRoot, assertSafeRunId(workflowRunId, "workflowRunId"), WORKFLOW_RECEIPT_FILE);
+}
+
+export function buildWorkflowReceipt(input: {
+	workflowRunId: string;
+	state: WorkflowReceiptState;
+	children: WorkflowScriptChildResult[];
+	createdAt?: number;
+}): WorkflowReceipt {
+	const workflowRunId = assertSafeRunId(input.workflowRunId, "workflowRunId");
+	const entries: Record<string, WorkflowReceiptEntry> = Object.create(null) as Record<string, WorkflowReceiptEntry>;
+	for (const child of input.children) {
+		const key = assertKey(child.key, "workflow receipt child key");
+		if (entries[key]) throw new Error(`Workflow receipt has duplicate child key '${key}'.`);
+		const runIds = [...new Set((child.continuation?.runIds ?? (child.runId ? [child.runId] : [])).filter((runId) => typeof runId === "string" && runId.trim()).map((runId) => runId.trim()))];
+		const latestRunId = runIds.at(-1);
+		const resumability = child.resumability ?? { state: "not-resumable", reason: child.runId ? "resumability was not recorded" : "child produced no run id" };
+		if (resumability.state === "resumable" && !latestRunId) throw new Error(`Workflow receipt child '${key}' is resumable but has no retained run id.`);
+		const base = {
+			key,
+			...(child.agent ? { agent: child.agent } : {}),
+			...(child.requestedContext ? { requestedContext: child.requestedContext } : {}),
+			...(child.resolvedContext ? { resolvedContext: child.resolvedContext } : {}),
+			...(child.outputReference ? { outputReference: child.outputReference } : {}),
+			continuation: { runIds },
+		};
+		entries[key] = resumability.state === "resumable"
+			? { ...base, latestRunId: latestRunId!, resumability }
+			: { ...base, ...(latestRunId ? { latestRunId } : {}), resumability };
+	}
+	return { version: WORKFLOW_RECEIPT_VERSION, workflowRunId, state: input.state, createdAt: input.createdAt ?? Date.now(), entries };
+}
+
+export function writeWorkflowReceipt(asyncDir: string, receipt: WorkflowReceipt): string {
+	const receiptPath = path.join(asyncDir, WORKFLOW_RECEIPT_FILE);
+	writePrivateAtomicJson(receiptPath, receipt);
+	return receiptPath;
+}
+
+function parseEntry(value: unknown, key: string, source: string): WorkflowReceiptEntry {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid workflow receipt '${source}': entry '${key}' must be an object.`);
+	const entry = value as Record<string, unknown>;
+	if (entry.key !== key) throw new Error(`Invalid workflow receipt '${source}': entry '${key}' has a mismatched key.`);
+	const latestRunId = entry.latestRunId;
+	if (latestRunId !== undefined && (typeof latestRunId !== "string" || !latestRunId.trim())) throw new Error(`Invalid workflow receipt '${source}': entry '${key}' latestRunId must be non-empty.`);
+	const continuation = entry.continuation;
+	if (!continuation || typeof continuation !== "object" || Array.isArray(continuation) || !Array.isArray((continuation as Record<string, unknown>).runIds)) {
+		throw new Error(`Invalid workflow receipt '${source}': entry '${key}' continuation is missing.`);
+	}
+	const runIds = (continuation as { runIds: unknown[] }).runIds;
+	if (runIds.some((runId) => typeof runId !== "string" || !runId.trim())) throw new Error(`Invalid workflow receipt '${source}': entry '${key}' continuation contains an invalid run id.`);
+	if (latestRunId !== undefined && runIds.at(-1) !== latestRunId) throw new Error(`Workflow receipt '${source}' entry '${key}' is stale: latestRunId does not match its continuation lineage.`);
+	const resumability = entry.resumability;
+	if (!resumability || typeof resumability !== "object" || Array.isArray(resumability)) throw new Error(`Invalid workflow receipt '${source}': entry '${key}' resumability is missing.`);
+	const state = (resumability as Record<string, unknown>).state;
+	if (state !== "resumable" && state !== "not-resumable") throw new Error(`Invalid workflow receipt '${source}': entry '${key}' resumability state is invalid.`);
+	const reason = (resumability as Record<string, unknown>).reason;
+	if (state === "resumable" && latestRunId === undefined) throw new Error(`Invalid workflow receipt '${source}': entry '${key}' resumable entry has no retained run id.`);
+	if (state === "not-resumable" && (typeof reason !== "string" || !reason.trim())) throw new Error(`Invalid workflow receipt '${source}': entry '${key}' non-resumable reason is missing.`);
+	return value as WorkflowReceiptEntry;
+}
+
+export function readWorkflowReceipt(asyncDirRoot: string, workflowRunId: string): WorkflowReceipt {
+	const receiptPath = workflowReceiptPath(asyncDirRoot, workflowRunId);
+	let value: unknown;
+	try {
+		value = JSON.parse(fs.readFileSync(receiptPath, "utf-8")) as unknown;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") throw new Error(`Workflow receipt '${workflowRunId}' was not found.`);
+		throw new Error(`Workflow receipt '${workflowRunId}' could not be read: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : undefined });
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid workflow receipt '${receiptPath}': expected an object.`);
+	const receipt = value as Record<string, unknown>;
+	if (receipt.version !== WORKFLOW_RECEIPT_VERSION) throw new Error(`Invalid workflow receipt '${receiptPath}': unsupported version.`);
+	if (receipt.workflowRunId !== workflowRunId) throw new Error(`Workflow receipt '${receiptPath}' is stale: workflowRunId does not match.`);
+	if (receipt.state !== "complete" && receipt.state !== "failed" && receipt.state !== "paused" && receipt.state !== "stopped") {
+		throw new Error(`Workflow receipt '${receiptPath}' is stale: workflow is not terminal.`);
+	}
+	if (typeof receipt.createdAt !== "number" || !Number.isFinite(receipt.createdAt)) throw new Error(`Invalid workflow receipt '${receiptPath}': createdAt is invalid.`);
+	if (!receipt.entries || typeof receipt.entries !== "object" || Array.isArray(receipt.entries)) throw new Error(`Invalid workflow receipt '${receiptPath}': entries must be an object.`);
+	const entries: Record<string, WorkflowReceiptEntry> = Object.create(null) as Record<string, WorkflowReceiptEntry>;
+	for (const [key, entry] of Object.entries(receipt.entries as Record<string, unknown>)) entries[assertKey(key, "workflow receipt key")] = parseEntry(entry, key, receiptPath);
+	return { version: 1, workflowRunId, state: receipt.state, createdAt: receipt.createdAt, entries };
+}
+
+export function resolveWorkflowReceiptResumeEntry(input: {
+	reference: WorkflowReceiptResumeReference;
+	asyncDirRoot: string;
+	assertResumable?: (runId: string) => void;
+}): WorkflowReceiptEntry & { latestRunId: string; resumability: { state: "resumable" } } {
+	if (input.reference.latest !== true) throw new Error("Keyed workflow receipt resume requires latest: true.");
+	const key = assertKey(input.reference.key, "keyed resume key");
+	const receipt = readWorkflowReceipt(input.asyncDirRoot, input.reference.workflowRunId.trim());
+	const entry = receipt.entries[key];
+	if (!entry) throw new Error(`Workflow receipt '${receipt.workflowRunId}' has no child key '${key}'.`);
+	assertResumableEntry(entry, receipt.workflowRunId, key);
+	input.assertResumable?.(entry.latestRunId);
+	return entry;
+}
+
+function assertResumableEntry(entry: WorkflowReceiptEntry, workflowRunId: string, key: string): asserts entry is WorkflowReceiptEntry & { latestRunId: string; resumability: { state: "resumable" } } {
+	if (entry.resumability.state !== "resumable") throw new Error(`Workflow receipt '${workflowRunId}' child '${key}' is not resumable: ${entry.resumability.reason}.`);
+	if (!entry.latestRunId) throw new Error(`Workflow receipt '${workflowRunId}' child '${key}' has no retained run id.`);
+}
+
+export function resolveWorkflowReceiptResume(input: {
+	reference: WorkflowReceiptResumeReference;
+	asyncDirRoot: string;
+	assertResumable?: (runId: string) => void;
+}): string {
+	const entry = resolveWorkflowReceiptResumeEntry(input);
+	return entry.latestRunId;
+}

package/dist/extensions/pi-subagents/test/e2e/real-session-subagent.test.ts

@@ -37,7 +37,7 @@ const ISOLATED_ENV_KEYS = [
 	"SELESAI_SUBAGENT_EXTRA_AGENT_DIRS",
 	"SELESAI_SUBAGENT_PARENT_SESSION",
 	"SELESAI_SUBAGENT_PI_BINARY",
-	"SELESAI_SUBAGENTS_SELESAI_PACKAGE_ROOT",
+	"SELESAI_SUBAGENTS_CODING_AGENT_PACKAGE_ROOT",
 ] as const;
 
 describe("real Pi-session subagent E2E", { skip: !available ? "pi runtime packages not available" : undefined }, () => {
@@ -187,7 +187,7 @@ Report active tools.`;
 		process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS = BOGUS_EXTRA_DIRS;
 		process.env.SELESAI_SUBAGENT_PARENT_SESSION = "polluted-parent";
 		process.env.SELESAI_SUBAGENT_PI_BINARY = BOGUS_PI_BINARY;
-		process.env.SELESAI_SUBAGENTS_SELESAI_PACKAGE_ROOT = BOGUS_PI_PACKAGE_ROOT;
+		process.env.SELESAI_SUBAGENTS_CODING_AGENT_PACKAGE_ROOT = BOGUS_PI_PACKAGE_ROOT;
 
 		try {
 			run = await runRealSubagentSession({

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/bun/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/bun/register-bedrock.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register-bedrock.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/bun/restore-sandbox-env.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Workaround for https://github.com/oven-sh/bun/issues/27802
+ *
+ * Bun compiled binaries have an empty `process.env` when running inside
+ * sandbox environments (e.g. nono on Linux/macOS). On Linux we can recover
+ * the environment from `/proc/self/environ`.
+ *
+ * Keep this in sync with getBunSandboxEnvValue() in
+ * packages/ai/src/utils/provider-env.ts. The ai package duplicates the lookup
+ * for direct consumers that do not go through this coding-agent entrypoint.
+ */
+/**
+ * Restore environment variables from `/proc/self/environ` when running
+ * inside a sandbox where Bun's `process.env` is empty.
+ */
+export declare function restoreSandboxEnv(): void;
+//# sourceMappingURL=restore-sandbox-env.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli/args.d.ts

@@ -0,0 +1,57 @@
+/**
+ * CLI argument parsing and help display
+ */
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { ExtensionFlag } from "../core/extensions/types.ts";
+export type Mode = "text" | "json" | "rpc";
+export interface Args {
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    systemPrompt?: string;
+    appendSystemPrompt?: string[];
+    thinking?: ThinkingLevel;
+    continue?: boolean;
+    resume?: boolean;
+    help?: boolean;
+    version?: boolean;
+    mode?: Mode;
+    name?: string;
+    noSession?: boolean;
+    session?: string;
+    sessionId?: string;
+    fork?: string;
+    sessionDir?: string;
+    models?: string[];
+    tools?: string[];
+    excludeTools?: string[];
+    noTools?: boolean;
+    noBuiltinTools?: boolean;
+    extensions?: string[];
+    noExtensions?: boolean;
+    print?: boolean;
+    export?: string;
+    noSkills?: boolean;
+    skills?: string[];
+    promptTemplates?: string[];
+    noPromptTemplates?: boolean;
+    themes?: string[];
+    noThemes?: boolean;
+    noContextFiles?: boolean;
+    listModels?: string | true;
+    offline?: boolean;
+    verbose?: boolean;
+    projectTrustOverride?: boolean;
+    messages: string[];
+    fileArgs: string[];
+    /** Unknown flags (potentially extension flags) - map of flag name to value */
+    unknownFlags: Map<string, boolean | string>;
+    diagnostics: Array<{
+        type: "warning" | "error";
+        message: string;
+    }>;
+}
+export declare function isValidThinkingLevel(level: string): level is ThinkingLevel;
+export declare function parseArgs(args: string[]): Args;
+export declare function printHelp(extensionFlags?: ExtensionFlag[]): void;
+//# sourceMappingURL=args.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli/config-selector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * TUI config selector for `pi config` command
+ */
+import type { SettingsManager } from "../core/settings-manager.ts";
+import { type ScopedResolvedPaths } from "../modes/interactive/components/config-selector.ts";
+export interface ConfigSelectorOptions {
+    resolvedPaths: ScopedResolvedPaths;
+    settingsManager: SettingsManager;
+    cwd: string;
+    agentDir: string;
+    writeScope: "global" | "project";
+    projectModeAvailable: boolean;
+}
+/** Show TUI config selector and return when closed */
+export declare function selectConfig(options: ConfigSelectorOptions): Promise<void>;
+//# sourceMappingURL=config-selector.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli/file-processor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+import type { ImageContent } from "@earendil-works/pi-ai";
+export interface ProcessedFiles {
+    text: string;
+    images: ImageContent[];
+}
+export interface ProcessFileOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+}
+/** Process @file arguments into text content and image attachments */
+export declare function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles>;
+//# sourceMappingURL=file-processor.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli/initial-message.d.ts

@@ -0,0 +1,18 @@
+import type { ImageContent } from "@earendil-works/pi-ai";
+import type { Args } from "./args.ts";
+export interface InitialMessageInput {
+    parsed: Args;
+    fileText?: string;
+    fileImages?: ImageContent[];
+    stdinContent?: string;
+}
+export interface InitialMessageResult {
+    initialMessage?: string;
+    initialImages?: ImageContent[];
+}
+/**
+ * Combine stdin content, @file text, and the first CLI message into a single
+ * initial prompt for non-interactive mode.
+ */
+export declare function buildInitialMessage({ parsed, fileText, fileImages, stdinContent }: InitialMessageInput): InitialMessageResult;
+//# sourceMappingURL=initial-message.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli/list-models.d.ts

@@ -0,0 +1,9 @@
+/**
+ * List available models with optional fuzzy search
+ */
+import type { ModelRuntime } from "../core/model-runtime.ts";
+/**
+ * List available models, optionally filtered by search pattern
+ */
+export declare function listModels(modelRuntime: ModelRuntime, searchPattern?: string): Promise<void>;
+//# sourceMappingURL=list-models.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli/project-trust.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectTrustContext } from "../core/extensions/types.ts";
+import type { AppMode } from "../core/project-trust.ts";
+import type { SettingsManager } from "../core/settings-manager.ts";
+export declare function createProjectTrustContext(options: {
+    cwd: string;
+    mode: AppMode;
+    settingsManager: SettingsManager;
+    hasUI: boolean;
+}): ProjectTrustContext;
+//# sourceMappingURL=project-trust.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli/session-picker.d.ts

@@ -0,0 +1,10 @@
+/**
+ * TUI session selector for --resume flag
+ */
+import type { SessionInfo, SessionListProgress } from "../core/session-manager.ts";
+import type { SettingsManager } from "../core/settings-manager.ts";
+type SessionsLoader = (onProgress?: SessionListProgress) => Promise<SessionInfo[]>;
+/** Show TUI session selector and return selected session path or null if cancelled */
+export declare function selectSession(currentSessionsLoader: SessionsLoader, allSessionsLoader: SessionsLoader, settingsManager: SettingsManager): Promise<string | null>;
+export {};
+//# sourceMappingURL=session-picker.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli/startup-ui.d.ts

@@ -0,0 +1,20 @@
+import { TUI } from "@earendil-works/pi-tui";
+import { SettingsManager } from "../core/settings-manager.ts";
+export declare function createStartupTui(settingsManager: SettingsManager): Promise<TUI>;
+export declare function startStartupTui(ui: TUI, settingsManager: SettingsManager): void;
+/**
+ * First-time setup runs when all of these hold:
+ * - this is the official Pi distribution (not a fork/rebrand)
+ * - experimental features are enabled (PI_EXPERIMENTAL=1)
+ * - the default agent directory is used (no custom agent dir override)
+ * - setup was not completed before (settings.json does not exist)
+ */
+export declare function shouldRunFirstTimeSetup(settingsPath?: string): boolean;
+export declare function showStartupSelector<T>(settingsManager: SettingsManager, title: string, options: Array<{
+    label: string;
+    value: T;
+}>): Promise<T | undefined>;
+/** Show the first-time setup dialog and persist the result */
+export declare function showFirstTimeSetup(settingsManager: SettingsManager): Promise<void>;
+export declare function showStartupInput(settingsManager: SettingsManager, title: string, placeholder?: string): Promise<string | undefined>;
+//# sourceMappingURL=startup-ui.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/config.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Detect if we're running as a Bun compiled binary.
+ * Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
+ */
+export declare const isBunBinary: boolean;
+/** Detect if Bun is the runtime (compiled binary or bun run) */
+export declare const isBunRuntime: boolean;
+export type InstallMethod = "bun-binary" | "npm" | "pnpm" | "yarn" | "bun" | "unknown";
+interface SelfUpdateCommandStep {
+    command: string;
+    args: string[];
+    display: string;
+}
+export interface SelfUpdateCommand extends SelfUpdateCommandStep {
+    steps?: SelfUpdateCommandStep[];
+}
+export type SelfUpdatePackageTarget = string | {
+    packageName: string;
+    installSpec?: string;
+};
+export declare function detectInstallMethod(): InstallMethod;
+export declare function getSelfUpdateCommand(packageName: string, npmCommand?: string[], updatePackageTarget?: SelfUpdatePackageTarget): SelfUpdateCommand | undefined;
+export declare function getSelfUpdateUnavailableInstruction(packageName: string, npmCommand?: string[], updatePackageTarget?: SelfUpdatePackageTarget): string;
+export declare function getUpdateInstruction(packageName: string): string;
+/**
+ * Get the base directory for resolving package assets (themes, package.json, README.md, CHANGELOG.md).
+ * - For Bun binary: returns the directory containing the executable
+ * - For Node.js (dist/): returns __dirname (the dist/ directory)
+ * - For tsx (src/): returns parent directory (the package root)
+ */
+export declare function getPackageDir(): string;
+/**
+ * Get path to built-in themes directory (shipped with package)
+ * - For Bun binary: theme/ next to executable
+ * - For Node.js (dist/): dist/modes/interactive/theme/
+ * - For tsx (src/): src/modes/interactive/theme/
+ */
+export declare function getThemesDir(): string;
+/**
+ * Get path to HTML export template directory (shipped with package)
+ * - For Bun binary: export-html/ next to executable
+ * - For Node.js (dist/): dist/core/export-html/
+ * - For tsx (src/): src/core/export-html/
+ */
+export declare function getExportTemplateDir(): string;
+/** Get path to package.json */
+export declare function getPackageJsonPath(): string;
+/** Get path to README.md */
+export declare function getReadmePath(): string;
+/** Get path to docs directory */
+export declare function getDocsPath(): string;
+/** Get path to examples directory */
+export declare function getExamplesPath(): string;
+/** Get path to CHANGELOG.md */
+export declare function getChangelogPath(): string;
+/**
+ * Get path to built-in interactive assets directory.
+ * - For Bun binary: assets/ next to executable
+ * - For Node.js (dist/): dist/modes/interactive/assets/
+ * - For tsx (src/): src/modes/interactive/assets/
+ */
+export declare function getInteractiveAssetsDir(): string;
+/** Get path to a bundled interactive asset */
+export declare function getBundledInteractiveAssetPath(name: string): string;
+export declare const PACKAGE_NAME: string;
+export declare const APP_NAME: string;
+export declare const APP_TITLE: string;
+export declare const CONFIG_DIR_NAME: string;
+export declare const VERSION: string;
+export declare const ENV_AGENT_DIR: string;
+export declare const ENV_SESSION_DIR: string;
+export declare function expandTildePath(path: string): string;
+/** Get the share viewer URL for a gist ID */
+export declare function getShareViewerUrl(gistId: string): string;
+/** Get the agent config directory (e.g., ~/.selesai/agent/) */
+export declare function getAgentDir(): string;
+/** Get path to user's custom themes directory */
+export declare function getCustomThemesDir(): string;
+/** Get path to models.json */
+export declare function getModelsPath(): string;
+/** Get path to auth.json */
+export declare function getAuthPath(): string;
+/** Get path to settings.json */
+export declare function getSettingsPath(): string;
+/** Get path to tools directory */
+export declare function getToolsDir(): string;
+/** Get path to managed binaries directory (fd, rg) */
+export declare function getBinDir(): string;
+/** Get path to prompt templates directory */
+export declare function getPromptsDir(): string;
+/** Get path to sessions directory */
+export declare function getSessionsDir(): string;
+/** Get path to debug log file */
+export declare function getDebugLogPath(): string;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/agent-session-runtime.d.ts

@@ -0,0 +1,119 @@
+import type { AgentSession } from "./agent-session.ts";
+import type { AgentSessionRuntimeDiagnostic, AgentSessionServices } from "./agent-session-services.ts";
+import type { ProjectTrustContext, ReplacedSessionContext, SessionStartEvent } from "./extensions/index.ts";
+import type { CreateAgentSessionResult } from "./sdk.ts";
+import { SessionManager } from "./session-manager.ts";
+/**
+ * Result returned by runtime creation.
+ *
+ * The caller gets the created session, its cwd-bound services, and all
+ * diagnostics collected during setup.
+ */
+export interface CreateAgentSessionRuntimeResult extends CreateAgentSessionResult {
+    services: AgentSessionServices;
+    diagnostics: AgentSessionRuntimeDiagnostic[];
+}
+/**
+ * Creates a full runtime for a target cwd and session manager.
+ *
+ * The factory closes over process-global fixed inputs, recreates cwd-bound
+ * services for the effective cwd, resolves session options against those
+ * services, and finally creates the AgentSession.
+ */
+export type CreateAgentSessionRuntimeFactory = (options: {
+    cwd: string;
+    agentDir: string;
+    sessionManager: SessionManager;
+    sessionStartEvent?: SessionStartEvent;
+    projectTrustContext?: ProjectTrustContext;
+}) => Promise<CreateAgentSessionRuntimeResult>;
+/**
+ * Thrown when /import references a JSONL file path that does not exist.
+ */
+export declare class SessionImportFileNotFoundError extends Error {
+    readonly filePath: string;
+    constructor(filePath: string);
+}
+/**
+ * Owns the current AgentSession plus its cwd-bound services.
+ *
+ * Session replacement methods tear down the current runtime first, then create
+ * and apply the next runtime. If creation fails, the error is propagated to the
+ * caller. The caller is responsible for user-facing error handling.
+ */
+export declare class AgentSessionRuntime {
+    private rebindSession?;
+    private beforeSessionInvalidate?;
+    private _session;
+    private _services;
+    private readonly createRuntime;
+    private _diagnostics;
+    private _modelFallbackMessage?;
+    constructor(_session: AgentSession, _services: AgentSessionServices, createRuntime: CreateAgentSessionRuntimeFactory, _diagnostics?: AgentSessionRuntimeDiagnostic[], _modelFallbackMessage?: string);
+    get services(): AgentSessionServices;
+    get session(): AgentSession;
+    get cwd(): string;
+    get diagnostics(): readonly AgentSessionRuntimeDiagnostic[];
+    get modelFallbackMessage(): string | undefined;
+    setRebindSession(rebindSession?: (session: AgentSession) => Promise<void>): void;
+    /**
+     * Set a synchronous callback that runs after `session_shutdown` handlers finish
+     * but before the current session is invalidated.
+     *
+     * This is for host-owned UI teardown that must not yield to the event loop,
+     * such as detaching extension-provided TUI components before the old extension
+     * context becomes stale.
+     */
+    setBeforeSessionInvalidate(beforeSessionInvalidate?: () => void): void;
+    private emitBeforeSwitch;
+    private emitBeforeFork;
+    private teardownCurrent;
+    private apply;
+    private finishSessionReplacement;
+    switchSession(sessionPath: string, options?: {
+        cwdOverride?: string;
+        withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+        projectTrustContextFactory?: (cwd: string) => ProjectTrustContext;
+    }): Promise<{
+        cancelled: boolean;
+    }>;
+    newSession(options?: {
+        parentSession?: string;
+        setup?: (sessionManager: SessionManager) => Promise<void>;
+        withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+    }): Promise<{
+        cancelled: boolean;
+    }>;
+    fork(entryId: string, options?: {
+        position?: "before" | "at";
+        withSession?: (ctx: ReplacedSessionContext) => Promise<void>;
+    }): Promise<{
+        cancelled: boolean;
+        selectedText?: string;
+    }>;
+    /**
+     * Import a session JSONL file and switch runtime state to the imported session.
+     *
+     * @returns `{ cancelled: true }` when cancelled by `session_before_switch`, otherwise `{ cancelled: false }`.
+     * @throws {SessionImportFileNotFoundError} When the input path does not exist.
+     * @throws {MissingSessionCwdError} When the imported session cwd cannot be resolved and no override is provided.
+     */
+    importFromJsonl(inputPath: string, cwdOverride?: string): Promise<{
+        cancelled: boolean;
+    }>;
+    dispose(): Promise<void>;
+}
+/**
+ * Create the initial runtime from a runtime factory and initial session target.
+ *
+ * The same factory is stored on the returned AgentSessionRuntime and reused for
+ * later /new, /resume, /fork, and import flows.
+ */
+export declare function createAgentSessionRuntime(createRuntime: CreateAgentSessionRuntimeFactory, options: {
+    cwd: string;
+    agentDir: string;
+    sessionManager: SessionManager;
+    sessionStartEvent?: SessionStartEvent;
+}): Promise<AgentSessionRuntime>;
+export { type AgentSessionRuntimeDiagnostic, type AgentSessionServices, type CreateAgentSessionFromServicesOptions, type CreateAgentSessionServicesOptions, createAgentSessionFromServices, createAgentSessionServices, } from "./agent-session-services.ts";
+//# sourceMappingURL=agent-session-runtime.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/agent-session-services.d.ts

@@ -0,0 +1,85 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Model } from "@earendil-works/pi-ai";
+import type { SessionStartEvent, ToolDefinition } from "./extensions/index.ts";
+import { ModelRuntime } from "./model-runtime.ts";
+import { type DefaultResourceLoaderOptions, type ResourceLoader, type ResourceLoaderReloadOptions } from "./resource-loader.ts";
+import { type CreateAgentSessionOptions, type CreateAgentSessionResult } from "./sdk.ts";
+import type { SessionManager } from "./session-manager.ts";
+import { SettingsManager } from "./settings-manager.ts";
+/**
+ * Non-fatal issues collected while creating services or sessions.
+ *
+ * Runtime creation returns diagnostics to the caller instead of printing or
+ * exiting. The app layer decides whether warnings should be shown and whether
+ * errors should abort startup.
+ */
+export interface AgentSessionRuntimeDiagnostic {
+    type: "info" | "warning" | "error";
+    message: string;
+}
+/**
+ * Inputs for creating cwd-bound runtime services.
+ *
+ * These services are recreated whenever the effective session cwd changes.
+ * CLI-provided resource paths should be resolved to absolute paths before they
+ * reach this function, so later cwd switches do not reinterpret them.
+ */
+export interface CreateAgentSessionServicesOptions {
+    cwd: string;
+    agentDir?: string;
+    settingsManager?: SettingsManager;
+    modelRuntime?: ModelRuntime;
+    extensionFlagValues?: Map<string, boolean | string>;
+    resourceLoaderOptions?: Omit<DefaultResourceLoaderOptions, "cwd" | "agentDir" | "settingsManager">;
+    resourceLoaderReloadOptions?: ResourceLoaderReloadOptions;
+}
+/**
+ * Inputs for creating an AgentSession from already-created services.
+ *
+ * Use this after services exist and any cwd-bound model/tool/session options
+ * have been resolved against those services.
+ */
+export interface CreateAgentSessionFromServicesOptions {
+    services: AgentSessionServices;
+    sessionManager: SessionManager;
+    sessionStartEvent?: SessionStartEvent;
+    model?: Model<any>;
+    thinkingLevel?: ThinkingLevel;
+    scopedModels?: Array<{
+        model: Model<any>;
+        thinkingLevel?: ThinkingLevel;
+    }>;
+    tools?: string[];
+    excludeTools?: CreateAgentSessionOptions["excludeTools"];
+    noTools?: CreateAgentSessionOptions["noTools"];
+    customTools?: ToolDefinition[];
+}
+/**
+ * Coherent cwd-bound runtime services for one effective session cwd.
+ *
+ * This is infrastructure only. The AgentSession itself is created separately so
+ * session options can be resolved against these services first.
+ */
+export interface AgentSessionServices {
+    cwd: string;
+    agentDir: string;
+    modelRuntime: ModelRuntime;
+    settingsManager: SettingsManager;
+    resourceLoader: ResourceLoader;
+    diagnostics: AgentSessionRuntimeDiagnostic[];
+}
+/**
+ * Create cwd-bound runtime services.
+ *
+ * Returns services plus diagnostics. It does not create an AgentSession.
+ */
+export declare function createAgentSessionServices(options: CreateAgentSessionServicesOptions): Promise<AgentSessionServices>;
+/**
+ * Create an AgentSession from previously created services.
+ *
+ * This keeps session creation separate from service creation so callers can
+ * resolve model, thinking, tools, and other session inputs against the target
+ * cwd before constructing the session.
+ */
+export declare function createAgentSessionFromServices(options: CreateAgentSessionFromServicesOptions): Promise<CreateAgentSessionResult>;
+//# sourceMappingURL=agent-session-services.d.ts.map