@oh-my-pi/pi-coding-agent 16.2.8 → 16.2.11

package/src/task/index.ts

@@ -243,8 +243,11 @@ function validateShapeParams(batchEnabled: boolean, params: TaskParams): string
 }
 
 /**
- * Validate the spawn parameter contract against the wire shapes. `agent` is
- * always required. With `task.batch` the model-facing shape is
+ * Validate the spawn parameter contract against the wire shapes. `agent`
+ * defaults to `task` (the schema default; `execute` normalizes the same way for
+ * direct callers), so the missing-`agent` guard only fires for callers that
+ * invoke this validator with an unnormalized blank agent. With `task.batch` the
+ * model-facing shape is
  * `{ agent, context, tasks[] }` — `tasks` non-empty with per-item assignments
  * and unique ids, `context` non-empty, no top-level `assignment` alongside.
  * The flat `{ agent, ...item }` form stays accepted at runtime under either
@@ -328,14 +331,17 @@ function spawnParamsFor(params: TaskParams, item: TaskItem): TaskParams {
 	return spawn;
 }
 
+/** Agent type spawned when a `task` call omits `agent`; mirrors the schema default in `getTaskSchema`. */
+const DEFAULT_TASK_AGENT = "task";
+
 /** Generic worker agents whose output sharpens with a tailored `role` rather than the bare type. */
-const GENERIC_SPAWN_AGENTS: ReadonlySet<string> = new Set(["task", "quick_task"]);
+const GENERIC_SPAWN_AGENTS: ReadonlySet<string> = new Set(["task", "sonic"]);
 
 /**
  * Advisory — never a rejection — nudging the spawner toward tailored
  * specialists when it spawns generic role-less workers and still holds spawn
  * capacity (DepthCapacity: it currently has the `task` tool). Fires when a
- * generic `task`/`quick_task` spawn carries no `role`, or when one call clones
+ * generic `task`/`sonic` spawn carries no `role`, or when one call clones
  * the same agent ≥2× all without roles. Returns undefined when no nudge applies.
  */
 export function buildSpecializationAdvisory(
@@ -559,7 +565,14 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<TaskToolDetails>,
 	): Promise<AgentToolResult<TaskToolDetails>> {
-		const params = repairTaskParams(rawParams as TaskParams);
+		const repaired = repairTaskParams(rawParams as TaskParams);
+		// The schema defaults `agent` to `task` for model calls, but internal
+		// callers and stale transcripts build params directly and bypass arktype.
+		// Normalize once here so every downstream path sees the resolved agent.
+		const params =
+			typeof repaired.agent === "string" && repaired.agent.trim() !== ""
+				? repaired
+				: { ...repaired, agent: DEFAULT_TASK_AGENT };
 		const batchEnabled = this.#isBatchEnabled();
 		const validationError = validateShapeParams(batchEnabled, params) ?? validateSpawnParams(params, batchEnabled);
 		if (validationError) {
@@ -790,10 +803,19 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			async ({ jobId: ownJobId, signal: runSignal, reportProgress, markRunning }) => {
 				const startedAt = Date.now();
 				const semaphore = this.#getSpawnSemaphore();
-				await semaphore.acquire();
+				let semaphoreHeld = false;
+				try {
+					await semaphore.acquire(runSignal);
+					semaphoreHeld = true;
+				} catch {
+					// Fall through so an acquire-time abort goes through the same
+					// path as the post-acquire race below: progress + onSettled
+					// have to fire even when the spawn never reached the executor,
+					// otherwise the batch aggregate state stays "running" forever.
+				}
 				const acquiredAt = Date.now();
-				if (runSignal.aborted) {
-					semaphore.release();
+				if (!semaphoreHeld || runSignal.aborted) {
+					if (semaphoreHeld) semaphore.release();
 					progress.status = "aborted";
 					onSettled?.(true);
 					throw new Error("Aborted before execution");
@@ -896,7 +918,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		const semaphore = this.#getSpawnSemaphore();
 		if (spawnItems.length === 1) {
 			const invokedAt = Date.now();
-			await semaphore.acquire();
+			await semaphore.acquire(signal);
 			const acquiredAt = Date.now();
 			try {
 				return await this.#executeSync(
@@ -935,7 +957,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			spawnItems.length,
 			async (item, index, workerSignal) => {
 				const invokedAt = Date.now();
-				await semaphore.acquire();
+				await semaphore.acquire(workerSignal);
 				const acquiredAt = Date.now();
 				try {
 					const itemOnUpdate: AgentToolUpdateCallback<TaskToolDetails> | undefined = onUpdate

package/src/task/types.ts

@@ -111,7 +111,7 @@ export interface TaskItem {
 }
 
 export const taskSchema = type({
-	agent: "string",
+	agent: "string = 'task'",
 	"id?": "string",
 	"description?": "string",
 	"role?": ROLE_INPUT_SCHEMA,
@@ -120,7 +120,7 @@ export const taskSchema = type({
 	"+": "delete",
 });
 const taskSchemaNoIsolation = type({
-	agent: "string",
+	agent: "string = 'task'",
 	"id?": "string",
 	"description?": "string",
 	"role?": ROLE_INPUT_SCHEMA,
@@ -128,13 +128,13 @@ const taskSchemaNoIsolation = type({
 	"+": "delete",
 });
 const taskSchemaBatch = type({
-	agent: "string",
+	agent: "string = 'task'",
 	context: "string",
 	tasks: taskItemSchemaIsolated.array(),
 	"+": "delete",
 });
 const taskSchemaBatchNoIsolation = type({
-	agent: "string",
+	agent: "string = 'task'",
 	context: "string",
 	tasks: taskItemSchema.array(),
 	"+": "delete",
@@ -160,7 +160,7 @@ export function getTaskSchema(options: { isolationEnabled: boolean; batchEnabled
  * transcripts using the flat form keep working under either setting.
  */
 export interface TaskParams {
-	/** Agent type; required. */
+	/** Agent type to spawn; defaults to `"task"` (the general-purpose worker) when omitted. */
 	agent?: string;
 	/** Stable agent id (flat form); default = generated AdjectiveNoun. */
 	id?: string;

package/src/tiny/models.ts

@@ -132,6 +132,15 @@ export const TINY_MEMORY_LOCAL_MODELS = [
 		unsupportedReason:
 			"onnxruntime-node does not support Qwen3 RotaryEmbedding cache updates in onnx-community/Qwen3-1.7B-ONNX",
 	},
+	{
+		key: "llama3.2:3b",
+		repo: "onnx-community/Llama-3.2-3B-Instruct-ONNX",
+		dtype: "q4",
+		label: "Llama 3.2 3B",
+		description:
+			"Larger Llama 3.2 option for local memory/classifier tasks; higher quality potential at higher disk/RAM/latency cost.",
+		contextNote: "Use when larger model capacity is preferred over faster load times.",
+	},
 	{
 		key: "gemma-3-1b",
 		repo: "onnx-community/gemma-3-1b-it-ONNX",
@@ -161,6 +170,7 @@ export const TINY_MEMORY_LOCAL_MODELS = [
 export const TINY_MEMORY_MODEL_VALUES = [
 	ONLINE_MEMORY_MODEL_KEY,
 	"qwen3-1.7b",
+	"llama3.2:3b",
 	"gemma-3-1b",
 	"qwen2.5-1.5b",
 	"lfm2-1.2b",

package/src/tools/ast-grep.ts

@@ -44,6 +44,33 @@ const astGrepSchema = type({
 	"skip?": type("number").describe("matches to skip"),
 });
 
+function compareAstFindMatch(left: AstFindMatch, right: AstFindMatch): number {
+	const pathCmp = left.path.localeCompare(right.path);
+	if (pathCmp !== 0) return pathCmp;
+	if (left.startLine !== right.startLine) return left.startLine - right.startLine;
+	if (left.startColumn !== right.startColumn) return left.startColumn - right.startColumn;
+	if (left.endLine !== right.endLine) return left.endLine - right.endLine;
+	if (left.endColumn !== right.endColumn) return left.endColumn - right.endColumn;
+	if (left.byteStart !== right.byteStart) return left.byteStart - right.byteStart;
+	return left.byteEnd - right.byteEnd;
+}
+
+function retainAstFindMatch(matches: AstFindMatch[], capacity: number, candidate: AstFindMatch): void {
+	if (matches.length < capacity) {
+		matches.push(candidate);
+		return;
+	}
+	let worstIndex = 0;
+	for (let index = 1; index < matches.length; index++) {
+		if (compareAstFindMatch(matches[index]!, matches[worstIndex]!) > 0) {
+			worstIndex = index;
+		}
+	}
+	if (compareAstFindMatch(candidate, matches[worstIndex]!) < 0) {
+		matches[worstIndex] = candidate;
+	}
+}
+
 async function runMultiTargetAstGrep(
 	targets: Array<{ basePath: string; glob?: string }>,
 	options: { patterns: string[]; commonBasePath: string; skip: number; limit: number; signal?: AbortSignal },
@@ -55,9 +82,11 @@ async function runMultiTargetAstGrep(
 	limitReached: boolean;
 	parseErrors?: string[];
 }> {
-	const aggregatedMatches: AstFindMatch[] = [];
+	const retainedMatches: AstFindMatch[] = [];
+	const retainedCapacity = options.skip + options.limit + 1;
 	const parseErrors: string[] = [];
 	let totalMatches = 0;
+	let filesWithMatches = 0;
 	let filesSearched = 0;
 	let limitReached = false;
 	for (const target of targets) {
@@ -71,26 +100,19 @@ async function runMultiTargetAstGrep(
 			signal: options.signal,
 		});
 		totalMatches += targetResult.totalMatches;
+		filesWithMatches += targetResult.filesWithMatches;
 		filesSearched += targetResult.filesSearched;
 		limitReached = limitReached || targetResult.limitReached;
 		if (targetResult.parseErrors) parseErrors.push(...targetResult.parseErrors);
 		for (const match of targetResult.matches) {
 			const absolute = path.resolve(target.basePath, match.path);
 			const rebased = path.relative(options.commonBasePath, absolute).replace(/\\/g, "/");
-			aggregatedMatches.push({ ...match, path: rebased });
+			retainAstFindMatch(retainedMatches, retainedCapacity, { ...match, path: rebased });
 		}
 	}
-	aggregatedMatches.sort((left, right) => {
-		const pathCmp = left.path.localeCompare(right.path);
-		if (pathCmp !== 0) return pathCmp;
-		if (left.startLine !== right.startLine) return left.startLine - right.startLine;
-		if (left.startColumn !== right.startColumn) return left.startColumn - right.startColumn;
-		if (left.byteStart !== right.byteStart) return left.byteStart - right.byteStart;
-		return left.byteEnd - right.byteEnd;
-	});
-	const visible = aggregatedMatches.slice(options.skip);
+	retainedMatches.sort(compareAstFindMatch);
+	const visible = retainedMatches.slice(options.skip);
 	const paged = visible.slice(0, options.limit);
-	const filesWithMatches = new Set(aggregatedMatches.map(match => match.path)).size;
 	return {
 		matches: paged,
 		totalMatches,

package/src/tools/grep.ts

@@ -122,8 +122,10 @@ export const SINGLE_FILE_MATCHES = 200;
  * pagination headroom so the caller can see total file count. */
 const INTERNAL_TOTAL_CAP = 2000;
 /** Mirrors `MAX_FILE_BYTES` in `crates/pi-natives/src/grep.rs`. Native grep
- * silently returns no matches for files larger than this; surface a warning
- * when the caller explicitly targeted such a file so they know to chunk it. */
+ * searches only the first `MAX_FILE_BYTES` of a larger file (a leading mmap
+ * window) and drops the rest; matches beyond the window are not returned. We
+ * surface a partial-coverage note when the caller explicitly targeted such a
+ * file so they know matches past the window are not shown. */
 const NATIVE_GREP_MAX_FILE_BYTES = 4 * 1024 * 1024;
 /** Wall-clock budget for a single native grep invocation. Without it, an
  * aborted or runaway search (huge tree, network mount) keeps burning CPU on
@@ -1260,8 +1262,9 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 				const { record: recordFile, list: fileList } = createFileRecorder();
 				const fileMatchCounts = new Map<string, number>();
 				// Detect explicit file targets that exceed the native grep size cap.
-				// Native silently returns no matches above the cap; without this note the
-				// caller sees "no matches" for a literal pattern that visibly exists.
+				// Native searches only their first NATIVE_GREP_MAX_FILE_BYTES; without
+				// this note the caller might miss that matches beyond the window
+				// (or "no matches") reflect partial coverage, not the whole file.
 				const oversizedNote = await (async (): Promise<string | undefined> => {
 					const explicitFileTargets: string[] = [];
 					if (exactFilePaths) {
@@ -1285,13 +1288,13 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 					);
 					if (oversized.length === 0) return undefined;
 					const limitMb = Math.floor(NATIVE_GREP_MAX_FILE_BYTES / (1024 * 1024));
-					return `Skipped oversized files (>${limitMb}MB grep limit; split the file or narrow with \`read\`): ${oversized.join(", ")}`;
+					return `Searched only the first ${limitMb}MB of large files (matches past the ${limitMb}MB window are not shown; use \`read\` for the rest): ${oversized.join(", ")}`;
 				})();
-				// Directory/multi-target scopes: native grep counts oversized skips but
-				// cannot name them; explicit-file scopes are covered (with names) above.
+				// Directory/multi-target scopes: native counts files it could not map
+				// even a prefix of (rare mmap failures), but cannot name them.
 				const oversizedScanNote =
 					!oversizedNote && skippedOversizedCount > 0
-						? `Skipped ${skippedOversizedCount} oversized file(s) (>${Math.floor(NATIVE_GREP_MAX_FILE_BYTES / (1024 * 1024))}MB grep limit); target them directly with \`read\``
+						? `Skipped ${skippedOversizedCount} unreadable large file(s); target them directly with \`read\``
 						: undefined;
 				const archiveNote =
 					archiveUnreadable.length > 0

package/src/utils/git.ts

@@ -175,6 +175,14 @@ const SHORT_LIVED_GIT_CONFIG: readonly (readonly [key: string, value: string])[]
 	["core.untrackedCache", "false"],
 ];
 const REMOTE_ALREADY_EXISTS = /remote .* already exists/i;
+const AMBIENT_GIT_ENV = {
+	GIT_DIR: undefined,
+	GIT_COMMON_DIR: undefined,
+	GIT_WORK_TREE: undefined,
+	GIT_INDEX_FILE: undefined,
+	GIT_OBJECT_DIRECTORY: undefined,
+	GIT_ALTERNATE_OBJECT_DIRECTORIES: undefined,
+} satisfies Record<string, undefined>;
 
 interface CommandOptions {
 	readonly env?: Record<string, string | undefined>;
@@ -190,6 +198,15 @@ function normalizeStdin(input: CommandOptions["stdin"]): "ignore" | Uint8Array {
 	return new Uint8Array(input);
 }
 
+function buildGitEnv(overrides?: Record<string, string | undefined>): Record<string, string | undefined> {
+	return {
+		...process.env,
+		GIT_OPTIONAL_LOCKS: "0",
+		...AMBIENT_GIT_ENV,
+		...overrides,
+	};
+}
+
 function ensureAvailable(): void {
 	if (!$which("git")) {
 		throw new Error("git is not installed.");
@@ -211,7 +228,7 @@ async function git(cwd: string, args: readonly string[], options: CommandOptions
 	const commandArgs = withShortLivedGitConfig(options.readOnly ? withNoOptionalLocks(args) : [...args]);
 	const child = Bun.spawn(["git", ...commandArgs], {
 		cwd,
-		env: options.env ? { ...process.env, GIT_OPTIONAL_LOCKS: "0", ...options.env } : undefined,
+		env: buildGitEnv(options.env),
 		signal: options.signal,
 		stdin: normalizeStdin(options.stdin),
 		stdout: "pipe",
@@ -707,6 +724,7 @@ function resolveHeadStateReftableSync(repository: GitRepository): GitHeadState |
 	const symArgs = withShortLivedGitConfig(withNoOptionalLocks(["symbolic-ref", "HEAD"]));
 	const symResult = Bun.spawnSync(["git", ...symArgs], {
 		cwd: repository.repoRoot,
+		env: buildGitEnv(),
 		stdout: "pipe",
 		stderr: "pipe",
 		windowsHide: true,
@@ -715,6 +733,7 @@ function resolveHeadStateReftableSync(repository: GitRepository): GitHeadState |
 	const revArgs = withShortLivedGitConfig(withNoOptionalLocks(["rev-parse", "--verify", "HEAD"]));
 	const revResult = Bun.spawnSync(["git", ...revArgs], {
 		cwd: repository.repoRoot,
+		env: buildGitEnv(),
 		stdout: "pipe",
 		stderr: "pipe",
 		windowsHide: true,
@@ -748,6 +767,7 @@ function readRefSync(repository: GitRepository, targetRef: string): string | nul
 		const symArgs = withShortLivedGitConfig(withNoOptionalLocks(["symbolic-ref", targetRef]));
 		const symResult = Bun.spawnSync(["git", ...symArgs], {
 			cwd: repository.repoRoot,
+			env: buildGitEnv(),
 			stdout: "pipe",
 			stderr: "pipe",
 			windowsHide: true,
@@ -759,6 +779,7 @@ function readRefSync(repository: GitRepository, targetRef: string): string | nul
 		const revArgs = withShortLivedGitConfig(withNoOptionalLocks(["rev-parse", "--verify", targetRef]));
 		const revResult = Bun.spawnSync(["git", ...revArgs], {
 			cwd: repository.repoRoot,
+			env: buildGitEnv(),
 			stdout: "pipe",
 			stderr: "pipe",
 			windowsHide: true,

package/src/prompts/agents/oracle.md

@@ -1,54 +0,0 @@
----
-name: oracle
-description: Wise senior engineer to consult or delegate work to — debugging, architecture, second opinions, and hands-on implementation when asked.
-spawns: explore
-model: pi/slow
-thinking-level: xhigh
----
-
-You are the wise guy on the team — a senior engineer with deep judgment that other agents consult when they are stuck, uncertain, or need a second opinion. You also take direct delegation: if the caller hands you work, you do it, including reads, writes, edits, and running commands.
-
-You diagnose, decide, and execute. You match the mode to the ask:
-- **Consult**: explain the root cause, lay out tradeoffs, recommend a path.
-- **Delegate**: carry the work to completion — modify files, run verification, deliver a finished change.
-
-<directives>
-- You MUST reason from first principles. The caller already tried the obvious.
-- You MUST use tools to verify claims. You NEVER speculate about code behavior — read it.
-- You MUST identify root causes, not symptoms. If the caller says "X is broken", determine *why* X is broken.
-- You MUST surface hidden assumptions — in the code, in the caller's framing, in the environment.
-- You SHOULD consider at least two hypotheses before converging on one.
-- You SHOULD invoke tools in parallel when investigating multiple hypotheses.
-- When the problem is architectural, you MUST weigh tradeoffs explicitly: what does each option cost, what does it buy, what does it foreclose.
-- When delegated implementation work, you MUST finish it: edit the files, run the relevant tests/checks, and report exactly what changed.
-</directives>
-
-<decision-framework>
-Apply pragmatic minimalism:
-- **Bias toward simplicity**: The right solution is the least complex one that fulfills actual requirements. Resist hypothetical future needs.
-- **Leverage what exists**: Favor modifications to current code and established patterns over introducing new components. New dependencies or infrastructure require explicit justification.
-- **One clear path**: Present a single primary recommendation. Mention alternatives only when they offer substantially different tradeoffs worth considering.
-- **Match depth to complexity**: Quick questions get quick answers. Reserve thorough analysis for genuinely complex problems.
-- **Signal the investment**: Tag recommendations with estimated effort — Quick (<1h), Short (1-4h), Medium (1-2d), Large (3d+).
-</decision-framework>
-
-<procedure>
-1. Read the problem statement carefully. Identify what was already tried, what failed, and whether the caller wants advice or execution.
-2. Form 2-3 hypotheses for the root cause (for diagnosis) or 2-3 viable approaches (for design).
-3. Use tools to gather evidence — read relevant code, trace data flow, check types, search for related patterns. Parallelize independent reads.
-4. Eliminate hypotheses based on evidence. Narrow to the most likely cause or best approach.
-5. If consulting: deliver verdict with supporting evidence and a concrete recommendation.
-6. If implementing: make the changes, verify them, and report the diff and verification result.
-</procedure>
-
-<scope-discipline>
-- Do ONLY what was asked. No unsolicited refactors or improvements.
-- If you notice other issues, list at most 2 as "Optional future considerations" at the end.
-- You NEVER expand the problem surface beyond the original request.
-- Exhaust provided context before reaching for tools. External lookups fill genuine gaps, not curiosity.
-</scope-discipline>
-
-<critical>
-You MUST keep going until the problem is solved or the work is finished. Before finalizing: re-scan for unstated assumptions, verify claims are grounded in code not invented, check for overly strong language not justified by evidence.
-The caller came to you because they trust your judgment. Get it right.
-</critical>