@oh-my-pi/pi-coding-agent 14.7.7 → 14.7.8

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [14.7.8] - 2026-05-08
+
+### Fixed
+
+- Fixed indefinite startup hang on large repos introduced in 14.7.6 ([#975](https://github.com/can1357/oh-my-pi/issues/975)) on two fronts: (1) `createAgentSession` was awaiting `buildAgentsMdSearch` and `buildWorkspaceTree` directly in its blocking `Promise.all`, bypassing the existing 5s preparation deadline that previously protected startup — both scans are now raced against a 5s deadline and fall back to the system-prompt fallback path on timeout; (2) `buildWorkspaceTree` now derives its listing from `git ls-files --cached --others --exclude-standard` when the workspace is a git worktree, which is O(index size) and avoids the per-call full-tree gitignore-aware native scan that the previous implementation triggered. Repos without git, or where the call fails / times out, transparently fall back to the previous native-glob path.
+
 ## [14.7.6] - 2026-05-07
 ### Changed
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.7.7",
+	"version": "14.7.8",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.7.7",
-		"@oh-my-pi/pi-agent-core": "14.7.7",
-		"@oh-my-pi/pi-ai": "14.7.7",
-		"@oh-my-pi/pi-natives": "14.7.7",
-		"@oh-my-pi/pi-tui": "14.7.7",
-		"@oh-my-pi/pi-utils": "14.7.7",
+		"@oh-my-pi/omp-stats": "14.7.8",
+		"@oh-my-pi/pi-agent-core": "14.7.8",
+		"@oh-my-pi/pi-ai": "14.7.8",
+		"@oh-my-pi/pi-natives": "14.7.8",
+		"@oh-my-pi/pi-tui": "14.7.8",
+		"@oh-my-pi/pi-utils": "14.7.8",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@types/turndown": "5.0.6",

package/src/prompts/system/subagent-system-prompt.md

@@ -25,7 +25,9 @@ Use `irc` only when you need a quick answer from a peer; do not use it for long-
 {{SECTION_SEPARATOR "Closure"}}
 No TODO tracking, no progress updates. Execute, call `yield`, done.
 
-When finished, you **MUST** call `yield` exactly once. This is like writing to a ticket, provide what is required, and close it.
+Every turn **MUST** end with a tool call. A turn whose final block is plain text (or thinking only) is treated as a stop and you will be reminded to yield. While work remains, always continue with another tool call — investigate, edit, run, verify. Save narrative for the final `yield` payload.
+
+When finished, you **MUST** call `yield` exactly once. This is like writing to a ticket: provide what is required and close it.
 
 This is your only way to return a result. You **MUST NOT** put JSON in plain text, and you **MUST NOT** substitute a text summary for the structured `result.data` parameter.
 

package/src/prompts/system/subagent-yield-reminder.md

@@ -1,11 +1,12 @@
 <system-reminder>
-You stopped without calling yield. This is reminder {{retryCount}} of {{maxRetries}}.
+Your last turn ended without a tool call, so the session went idle. This is reminder {{retryCount}} of {{maxRetries}}.
 
-You **MUST** call yield as your only action now. Choose one:
-- If task is complete: call yield with your result in `result.data`
-- If task failed: call yield with `result.error` describing what happened
+Every turn **MUST** end with a tool call. Pick exactly one of:
+1. **Resume the work** — if the assignment is not finished, call the next tool you would have called (edit, write, bash, search, etc.). Do **NOT** yield. Do **NOT** treat this reminder as a forced stop.
+2. **Yield with success** — only if the assignment is genuinely complete: call `yield` with the structured payload in `result.data`.
+3. **Yield with error** — only if you hit a real, concrete blocker you can name (missing file, unavailable API, contradictory spec). Describe what you tried and the exact blocker. Do **NOT** fabricate a "forced immediate-yield" or "system reminder required termination" reason — this reminder is not a blocker.
 
-You **MUST NOT** give up if you can still complete the task through exploration (using available tools or repo context). If you submit an error, you **MUST** include what you tried and the exact blocker.
+Default to option 1 unless the work is actually done or actually blocked.
 
-You **MUST NOT** output text without a tool call. You **MUST** call yield to finish.
+You **MUST NOT** end this turn with text only.
 </system-reminder>

package/src/sdk.ts

@@ -898,10 +898,28 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		return { ttsrManager, rulebookRules, alwaysApplyRules };
 	});
 
+	// Resolve contextFiles up-front (it's needed before tool creation). The agentsMd / workspace tree
+	// scans are slowest on large repos and we MUST NOT block startup on them — race them against a
+	// short deadline. On timeout we forward `undefined` to ToolSession; buildSystemPromptInternal will
+	// re-race them through its own withDeadline path, and subagents will scan independently (still
+	// cheaper than an unbounded parent hang). Background work continues so caches still warm.
+	const STARTUP_SCAN_DEADLINE_MS = 5000;
+	const raceWithDeadline = <T>(name: string, work: Promise<T>): Promise<T | undefined> =>
+		Promise.race([
+			work,
+			Bun.sleep(STARTUP_SCAN_DEADLINE_MS).then(() => {
+				logger.warn("Startup scan exceeded deadline; deferring to system prompt fallback", {
+					name,
+					timeoutMs: STARTUP_SCAN_DEADLINE_MS,
+					cwd,
+				});
+				return undefined;
+			}),
+		]);
 	const [contextFiles, resolvedAgentsMdSearch, resolvedWorkspaceTree] = await Promise.all([
 		contextFilesPromise,
-		agentsMdSearchPromise,
-		workspaceTreePromise,
+		raceWithDeadline("buildAgentsMdSearch", agentsMdSearchPromise),
+		raceWithDeadline("buildWorkspaceTree", workspaceTreePromise),
 	]);
 
 	let agent: Agent;

package/src/task/executor.ts

@@ -1119,9 +1119,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						maxRetries: MAX_YIELD_RETRIES,
 					});
 
+					const isFinalRetry = retryCount >= MAX_YIELD_RETRIES;
 					await session.prompt(reminder, {
 						attribution: "agent",
-						...(reminderToolChoice ? { toolChoice: reminderToolChoice } : {}),
+						...(isFinalRetry && reminderToolChoice ? { toolChoice: reminderToolChoice } : {}),
 					});
 					await session.waitForIdle();
 				} catch (err) {

package/src/workspace-tree.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { glob } from "@oh-my-pi/pi-natives";
-import { formatAge, formatBytes } from "@oh-my-pi/pi-utils";
+import { $which, formatAge, formatBytes, logger } from "@oh-my-pi/pi-utils";
 
 export interface DirectoryTree {
 	rootPath: string;
@@ -35,6 +35,13 @@ export interface DirectoryTreeOptions {
 	cache?: boolean;
 	/** Rendered label for the root line. */
 	rootLabel?: string;
+	/**
+	 * Pre-built map of `parentRelativePath` → child name set used in place of
+	 * native directory listing. When provided, the tree builder consults this
+	 * map for child enumeration instead of `glob` / `readdir`. Stat calls per
+	 * displayed node are still performed for mtime/size/dir-ness.
+	 */
+	childIndex?: ReadonlyMap<string, ReadonlySet<string>>;
 }
 
 const WORKSPACE_TREE_MAX_DEPTH = 3;
@@ -81,6 +88,7 @@ interface ResolvedDirectoryTreeOptions {
 	gitignore: boolean;
 	cache: boolean;
 	rootLabel: string;
+	childIndex: ReadonlyMap<string, ReadonlySet<string>> | null;
 }
 
 interface RenderLine {
@@ -122,6 +130,7 @@ function resolveDirectoryTreeOptions(options: DirectoryTreeOptions): ResolvedDir
 		gitignore: options.gitignore ?? false,
 		cache: options.cache ?? true,
 		rootLabel: options.rootLabel ?? ".",
+		childIndex: options.childIndex ?? null,
 	};
 }
 
@@ -157,6 +166,10 @@ async function listDirectChildNames(
 	parent: DirectoryTreeNode,
 	options: ResolvedDirectoryTreeOptions,
 ): Promise<string[]> {
+	if (options.childIndex) {
+		const names = options.childIndex.get(parent.relativePath);
+		return names ? Array.from(names) : [];
+	}
 	if (!options.gitignore) {
 		const directoryPath = parent.relativePath ? path.join(rootPath, parent.relativePath) : rootPath;
 		return await fs.readdir(directoryPath);
@@ -377,19 +390,96 @@ export async function buildDirectoryTree(rootPath: string, options: DirectoryTre
 	};
 }
 
+/**
+ * Build a `parentRelativePath` → child name index from a flat list of POSIX
+ * paths. Intermediate directory components are inferred from path segments;
+ * the index covers every ancestor directory implied by the input.
+ */
+function buildChildIndexFromPaths(paths: readonly string[]): Map<string, Set<string>> {
+	const index = new Map<string, Set<string>>();
+	const ensure = (parent: string): Set<string> => {
+		let bucket = index.get(parent);
+		if (!bucket) {
+			bucket = new Set<string>();
+			index.set(parent, bucket);
+		}
+		return bucket;
+	};
+	for (const raw of paths) {
+		if (!raw) continue;
+		const normalized = raw.replace(/\\/g, "/");
+		const parts = normalized.split("/").filter(segment => segment.length > 0);
+		if (parts.length === 0) continue;
+		for (let i = 0; i < parts.length; i += 1) {
+			const parent = parts.slice(0, i).join("/");
+			const segment = parts[i];
+			if (segment !== undefined) ensure(parent).add(segment);
+		}
+	}
+	return index;
+}
+
+const GIT_LS_FILES_TIMEOUT_MS = 3000;
+
+/**
+ * List tracked + untracked-not-ignored files at `rootPath` via `git ls-files`.
+ * Returns `null` when git is unavailable, the directory is not inside a
+ * worktree, or the call fails / times out — caller falls back to native
+ * directory listing.
+ */
+async function tryListGitFiles(rootPath: string): Promise<string[] | null> {
+	const gitPath = $which("git");
+	if (!gitPath) return null;
+	const signal = AbortSignal.timeout(GIT_LS_FILES_TIMEOUT_MS);
+	try {
+		const child = Bun.spawn([gitPath, "ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
+			cwd: rootPath,
+			stdout: "pipe",
+			stderr: "pipe",
+			stdin: "ignore",
+			signal,
+		});
+		const [stdout, exitCode] = await Promise.all([
+			new Response(child.stdout as ReadableStream<Uint8Array>).text(),
+			child.exited,
+		]);
+		if (exitCode !== 0) return null;
+		if (!stdout) return [];
+		// `-z` separates entries with NUL; trailing NUL after final entry.
+		return stdout.split("\0").filter(entry => entry.length > 0);
+	} catch (error) {
+		logger.debug("git ls-files failed; falling back to native directory listing", {
+			rootPath,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return null;
+	}
+}
+
 export async function buildWorkspaceTree(cwd: string): Promise<WorkspaceTree> {
 	const rootPath = path.resolve(cwd);
+	const baseOptions = {
+		maxDepth: WORKSPACE_TREE_MAX_DEPTH,
+		directoryEntryLimit: WORKSPACE_TREE_DIR_LIMIT,
+		lineCap: WORKSPACE_TREE_LINE_CAP,
+		excludedDirectoryNames: WORKSPACE_TREE_EXCLUDED_DIRS,
+		hidden: false,
+		cache: true,
+		rootLabel: ".",
+	} satisfies DirectoryTreeOptions;
+
 	try {
-		return await buildDirectoryTree(rootPath, {
-			maxDepth: WORKSPACE_TREE_MAX_DEPTH,
-			directoryEntryLimit: WORKSPACE_TREE_DIR_LIMIT,
-			lineCap: WORKSPACE_TREE_LINE_CAP,
-			excludedDirectoryNames: WORKSPACE_TREE_EXCLUDED_DIRS,
-			hidden: false,
-			gitignore: true,
-			cache: true,
-			rootLabel: ".",
-		});
+		const gitFiles = await tryListGitFiles(rootPath);
+		if (gitFiles !== null) {
+			// Git already applied gitignore + tracking semantics: bypass native
+			// recursive scan and feed the index directly to the tree builder.
+			return await buildDirectoryTree(rootPath, {
+				...baseOptions,
+				gitignore: false,
+				childIndex: buildChildIndexFromPaths(gitFiles),
+			});
+		}
+		return await buildDirectoryTree(rootPath, { ...baseOptions, gitignore: true });
 	} catch {
 		return emptyWorkspaceTree(rootPath);
 	}