@oh-my-pi/pi-coding-agent 16.2.7 → 16.2.9

package/src/task/agents.ts

@@ -11,11 +11,11 @@ import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
 // Embed agent markdown files at build time
 import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
 import librarianMd from "../prompts/agents/librarian.md" with { type: "text" };
-import oracleMd from "../prompts/agents/oracle.md" with { type: "text" };
 
 import planMd from "../prompts/agents/plan.md" with { type: "text" };
 import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
 import taskMd from "../prompts/agents/task.md" with { type: "text" };
+import testerMd from "../prompts/agents/tester.md" with { type: "text" };
 
 import type { AgentDefinition, AgentSource } from "./types";
 
@@ -47,7 +47,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "designer.md", template: designerMd },
 	{ fileName: "reviewer.md", template: reviewerMd },
 	{ fileName: "librarian.md", template: librarianMd },
-	{ fileName: "oracle.md", template: oracleMd },
+	{ fileName: "tester.md", template: testerMd },
 	{
 		fileName: "task.md",
 		frontmatter: {
@@ -59,9 +59,9 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 		template: taskMd,
 	},
 	{
-		fileName: "quick_task.md",
+		fileName: "sonic.md",
 		frontmatter: {
-			name: "quick_task",
+			name: "sonic",
 			description: "Low-reasoning agent for strictly mechanical updates or data collection only",
 			model: "pi/smol",
 			thinkingLevel: Effort.Medium,

package/src/task/executor.ts

@@ -87,7 +87,7 @@ const MCP_CALL_TIMEOUT_MS = 60_000;
  */
 export const SOFT_REQUEST_BUDGET: Record<string, number> = {
 	explore: 40,
-	quick_task: 40,
+	sonic: 40,
 	default: 90,
 };
 

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) {

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/grep.ts

@@ -85,8 +85,26 @@ const searchSchema = type({
 });
 
 export type GrepToolInput = typeof searchSchema.infer;
+function parseStringEncodedPathArray(input: string): string[] | null {
+	const trimmed = input.trim();
+	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return null;
+
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		return null;
+	}
+
+	if (!Array.isArray(parsed) || parsed.some(entry => typeof entry !== "string")) {
+		return null;
+	}
+	return parsed;
+}
+
 export function toPathList(input: string | string[] | undefined): string[] {
-	return typeof input === "string" ? [input] : (input ?? []);
+	if (typeof input === "string") return parseStringEncodedPathArray(input) ?? [input];
+	return input ?? [];
 }
 
 /** Maximum number of distinct files surfaced in a single response. The

package/src/tools/output-schema-validator.ts

@@ -21,6 +21,16 @@ export interface OutputValidator {
 	validate(value: unknown): JsonSchemaValidationResult;
 	/** Top-level required property names. Empty if the schema has no `required` array at root. */
 	readonly requiredFields: readonly string[];
+	/**
+	 * Per-label validators for incremental yields (`type: ["<label>"]`). Each entry validates the
+	 * `data` payload of a single section against the matching top-level property's sub-schema —
+	 * array-typed properties (e.g. `findings`) use the items schema since each yield contributes
+	 * one element, while scalar properties use the property schema directly. Unknown labels (not
+	 * top-level properties) have no entry and skip per-call validation. Lets the yield tool give
+	 * the model retry feedback on a section as soon as it arrives, instead of deferring every
+	 * mismatch to the parent's post-mortem `schema_violation`.
+	 */
+	readonly validateSection: ReadonlyMap<string, (value: unknown) => JsonSchemaValidationResult>;
 }
 
 export interface BuildOutputValidatorResult {
@@ -72,10 +82,38 @@ export function buildOutputValidator(schema: unknown): BuildOutputValidatorResul
 		validator: {
 			requiredFields: required,
 			validate: value => validateJsonSchemaValue(jsonSchemaRecord, value),
+			validateSection: buildSectionValidators(jsonSchemaRecord),
 		},
 	};
 }
 
+/**
+ * Build per-top-level-property validators for incremental yields.
+ *
+ * Each entry validates the `data` payload of one `type: ["<label>"]` section against the
+ * matching property's sub-schema — array-typed properties (e.g. `findings`, derived from JTD
+ * `elements`) use the items schema since each yield contributes one element, while scalar
+ * properties use the property schema directly. Unknown labels (anything not declared as a
+ * top-level property) are deliberately omitted so user-defined section labels still pass.
+ */
+function buildSectionValidators(
+	jsonSchema: Record<string, unknown>,
+): ReadonlyMap<string, (value: unknown) => JsonSchemaValidationResult> {
+	const validators = new Map<string, (value: unknown) => JsonSchemaValidationResult>();
+	const properties = jsonSchema.properties;
+	if (properties === null || typeof properties !== "object") return validators;
+	for (const [label, raw] of Object.entries(properties as Record<string, unknown>)) {
+		if (raw === null || typeof raw !== "object") continue;
+		const propRecord = raw as Record<string, unknown>;
+		const sectionSchema =
+			propRecord.type === "array" && propRecord.items !== undefined && propRecord.items !== null
+				? (propRecord.items as Record<string, unknown>)
+				: propRecord;
+		validators.set(label, value => validateJsonSchemaValue(sectionSchema, value));
+	}
+	return validators;
+}
+
 /** Produce the executor's headline+missing-required summary from a failed validation. */
 export function summarizeValidationFailure(
 	result: JsonSchemaValidationResult,

package/src/tools/yield.ts

@@ -98,6 +98,16 @@ function parseYieldType(value: unknown): string | string[] | undefined {
 	throw new Error("type must be a string or non-empty array of strings");
 }
 
+/**
+ * Render an incremental yield's `type: [...]` labels as a quoted, comma-separated list for
+ * model-facing retry messages — keeps the failed section labelled even when the yield carried
+ * multiple labels at once.
+ */
+function formatYieldLabels(labels: readonly string[]): string {
+	if (labels.length === 0) return '""';
+	return labels.map(label => `"${label}"`).join(", ");
+}
+
 /**
  * Expand a plain-object `data` schema into a strict union that ALSO accepts each
  * top-level section value (and array element) on its own. Agents that yield
@@ -202,10 +212,12 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 	lenientArgValidation = true;
 
 	readonly #validate?: (value: unknown) => JsonSchemaValidationResult;
+	readonly #validateSection?: ReadonlyMap<string, (value: unknown) => JsonSchemaValidationResult>;
 	#schemaValidationFailures = 0;
 
 	constructor(session: ToolSession) {
 		let validate: ((value: unknown) => JsonSchemaValidationResult) | undefined;
+		let validateSection: ReadonlyMap<string, (value: unknown) => JsonSchemaValidationResult> | undefined;
 		let parameters: TSchema;
 
 		try {
@@ -217,6 +229,7 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 			} = buildOutputValidator(session.outputSchema);
 			if (validator) {
 				validate = value => validator.validate(value);
+				validateSection = validator.validateSection;
 			}
 
 			const schemaHint = formatSchema(normalizedSchema ?? session.outputSchema);
@@ -266,6 +279,7 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 		}
 
 		this.#validate = validate;
+		this.#validateSection = validateSection;
 		this.parameters = parameters;
 	}
 
@@ -307,22 +321,25 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 			if (data === null) {
 				throw new Error("data is required when yield indicates success");
 			}
-			if (this.#validate && !isIncremental) {
-				const parsed = this.#validate(data);
-				if (!parsed.success) {
-					this.#schemaValidationFailures++;
-					if (this.#schemaValidationFailures <= MAX_SCHEMA_RETRIES) {
-						const remaining = MAX_SCHEMA_RETRIES - this.#schemaValidationFailures;
-						const retryHint =
-							remaining > 0
-								? ` Call yield again with the corrected shape — ${remaining} retry attempt(s) remain before the schema constraint is dropped.`
-								: " Call yield again with the corrected shape — this is the final retry before the schema constraint is dropped.";
-						throw new Error(
-							`Output does not match schema: ${formatAllValidationIssues(parsed.issues)}.${retryHint}`,
-						);
-					}
-					schemaValidationOverridden = true;
+			const sectionFailure = isIncremental
+				? this.#validateIncrementalSection(yieldType as string[], data)
+				: this.#validate
+					? this.#validate(data)
+					: undefined;
+			if (sectionFailure && !sectionFailure.success) {
+				this.#schemaValidationFailures++;
+				if (this.#schemaValidationFailures <= MAX_SCHEMA_RETRIES) {
+					const remaining = MAX_SCHEMA_RETRIES - this.#schemaValidationFailures;
+					const retryHint =
+						remaining > 0
+							? ` Call yield again with the corrected shape — ${remaining} retry attempt(s) remain before the schema constraint is dropped.`
+							: " Call yield again with the corrected shape — this is the final retry before the schema constraint is dropped.";
+					const scope = isIncremental ? `Section ${formatYieldLabels(yieldType as string[])}` : "Output";
+					throw new Error(
+						`${scope} does not match schema: ${formatAllValidationIssues(sectionFailure.issues)}.${retryHint}`,
+					);
 				}
+				schemaValidationOverridden = true;
 			}
 		}
 
@@ -344,6 +361,26 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 			},
 		};
 	}
+
+	/**
+	 * Validate the `data` payload of an incremental yield (`type: ["<label>", …]`) against
+	 * the matching property's sub-validator. Returns the first failure across all known labels,
+	 * or `undefined` when no label is recognised (user-defined section labels stay loose) or
+	 * when all known labels accept the value. Lets the model see the same retry feedback that
+	 * the terminal-yield path already produces, instead of leaking the mismatch through to
+	 * the parent's post-mortem `schema_violation`.
+	 */
+	#validateIncrementalSection(labels: string[], data: unknown): JsonSchemaValidationResult | undefined {
+		const subValidators = this.#validateSection;
+		if (!subValidators || subValidators.size === 0) return undefined;
+		for (const label of labels) {
+			const sub = subValidators.get(label);
+			if (!sub) continue;
+			const parsed = sub(data);
+			if (!parsed.success) return parsed;
+		}
+		return undefined;
+	}
 }
 
 // Register subprocess tool handler for extraction + termination.

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>