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

package/src/prompts/tools/task.md

@@ -7,11 +7,10 @@ Execution blocks your turn: the call only returns once the work is completely fi
 - **Sequence only when necessary:** The only reason to run A before B is if B strictly requires A's output to function (e.g., a core API contract or schema migration). {{#if ircEnabled}}If the missing piece is small, run them in parallel and have B ask A via `irc`!{{/if}}
 - **Role matching:** Assign each subagent a specific `role` (e.g. "Security Reviewer", "DB Migrator"). Do not spawn generic workers.
 - **No overhead:** Each assignment MUST instruct its agent to skip formatters, linters, and project-wide test suites. You will run those once at the end.
-- **Do your own thinking:** NEVER assign reasoning, architecture, or design to `quick_task` or `explore`. They are for mechanical lookups only. Keep hard decisions in your own context or use `task`, `plan`, or `oracle`.
 - **One-pass agents:** Prefer agents that investigate **and** edit in a single pass; only spin a read-only discovery step (e.g. `explore`) when the affected files are genuinely unknown.
 
 # Inputs
-- `agent`: The base agent type to use (e.g., `task`, `explore`).
+- `agent` (optional): The base agent type to use (e.g., `explore`, `reviewer`). Defaults to `task` (the general-purpose worker) — omit it for the default worker instead of passing `agent: "task"`.
 {{#if batchEnabled}}
 - `context`: Shared project state, constraints, and contracts. Applies to the entire batch; do not duplicate this background into individual tasks.
 - `tasks[]`: Array of subagents to spawn.
@@ -37,13 +36,7 @@ Subagents start blank. They have no access to your conversation history.
 {{#if batchEnabled}}
 - Pass large payloads using `local://<path>` URIs, never inline text.
 {{else}}
-- *Note: The single-spawn shape has no `context` field.* Write shared project state ONCE to a `local://` file (e.g., `local://ctx.md`) and reference that URL in your assignments. Pass large payloads using `local://<path>` URIs, never inline text.
-{{/if}}
-{{#if ircEnabled}}
-- Once spawned, coordinate with live agents via `irc` using their IDs. If task B depends on task A, B SHOULD message A directly.
-{{/if}}
-{{#if asyncEnabled}}
-- If you run out of things to do and are genuinely blocked waiting for a subagent, use `job poll`. Use `job cancel` only for stalled work.
+- Write shared project state ONCE to a `local://` file (e.g., `local://ctx.md`) and reference that URL in your assignments.
 {{/if}}
 
 # Format Contracts

package/src/session/agent-session.ts

@@ -250,6 +250,7 @@ import planModeToolDecisionReminderPrompt from "../prompts/system/plan-mode-tool
 	type: "text",
 };
 import sideChannelNoToolsReminder from "../prompts/system/side-channel-no-tools.md" with { type: "text" };
+import thinkingLoopRedirectTemplate from "../prompts/system/thinking-loop-redirect.md" with { type: "text" };
 import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
 import ttsrToolReminderTemplate from "../prompts/system/ttsr-tool-reminder.md" with { type: "text" };
 import unexpectedStopRetryTemplate from "../prompts/system/unexpected-stop-retry.md" with { type: "text" };
@@ -346,6 +347,9 @@ const SESSION_STOP_CONTINUATION_CAP = 8;
 const GEMINI_HEADER_INTERRUPT_REASON = "Interrupted: emit a tool call instead of more planning";
 /** `customType` for the hidden tool-call reminder injected after the interrupt. */
 const GEMINI_TOOL_REMINDER_TYPE = "gemini-tool-call-reminder";
+/** `customType` for the hidden redirect notice injected into a turn retried after a
+ *  thinking/response loop. Steers the model off the repeated content; never displayed. */
+const THINKING_LOOP_REDIRECT_TYPE = "thinking-loop-redirect";
 
 // A side-channel assistant response is signed for the hidden prompt/history that
 // produced it. If we persist that response under a different user turn, native
@@ -2882,10 +2886,10 @@ export class AgentSession {
 	 * the mid-run-compaction planner can ask "is this turn message already on
 	 * the branch?" in O(1) instead of re-walking the branch per check.
 	 *
-	 * The Map's value is the list of branch messages that share a key — almost
-	 * always one. We only need the LIST when content equality matters (rare
-	 * collision tiebreaker via {@link sameMessageContent}); the empty/single-
-	 * entry common case lets the caller's lookup short-circuit at presence.
+	 * The mid-run ordering check uses key identity alone: same-key content
+	 * variants are one logical message at this boundary, because otherwise a
+	 * display-side rewrite can make the assistant look missing after its tool
+	 * results have already persisted.
 	 *
 	 * Pre-#3629 the equivalent was `sessionManager.getBranch()` called twice
 	 * per turn message, each call rebuilding the path via O(n²) `unshift` and
@@ -2893,17 +2897,14 @@ export class AgentSession {
 	 * per `onTurnEnd` on a long session and the load-bearing source of the
 	 * `ui.loop-blocked` warnings in the bug report.
 	 */
-	#indexPersistedMessagesByKey(): Map<string, AgentMessage[]> {
-		const index = new Map<string, AgentMessage[]>();
+	#indexPersistedMessageKeys(): Set<string> {
+		const keys = new Set<string>();
 		for (const entry of this.sessionManager.getBranch()) {
 			if (entry.type !== "message") continue;
 			const key = sessionMessagePersistenceKey(entry.message);
-			if (key === undefined) continue;
-			const existing = index.get(key);
-			if (existing) existing.push(entry.message);
-			else index.set(key, [entry.message]);
+			if (key !== undefined) keys.add(key);
 		}
-		return index;
+		return keys;
 	}
 
 	/**
@@ -3003,17 +3004,17 @@ export class AgentSession {
 		// JSON-compared every entry per turn message, which on long sessions
 		// turned each `onTurnEnd` into a seconds-long sync block (the
 		// `ui.loop-blocked` warnings tagged `subagent:*` in the bug report).
-		const branchIndex = this.#indexPersistedMessagesByKey();
+		const branchKeys = this.#indexPersistedMessageKeys();
 		const turnKeys = turnMessages.map(sessionMessagePersistenceKey);
 		const persistedKeys = new Set<string>();
 		for (let index = 0; index < turnMessages.length; index++) {
 			const key = turnKeys[index];
 			if (key === undefined) continue;
-			const candidates = branchIndex.get(key);
-			if (!candidates) continue;
-			// Key match only counts when content also matches — two distinct
-			// messages that collided on the cheap key must STILL be persisted.
-			if (candidates.some(persisted => sameMessageContent(persisted, turnMessages[index]))) {
+			// Mid-run ordering is keyed by logical identity. A persisted display
+			// variant (for example, redacted/deobfuscated content) must still count;
+			// otherwise the assistant can look missing while later tool results are
+			// present, producing a false out-of-order skip.
+			if (branchKeys.has(key)) {
 				persistedKeys.add(key);
 			}
 		}
@@ -8087,7 +8088,7 @@ export class AgentSession {
 	 */
 	async setModelTemporary(
 		model: Model,
-		thinkingLevel?: ThinkingLevel,
+		thinkingLevel?: ConfiguredThinkingLevel,
 		options?: { ephemeral?: boolean },
 	): Promise<void> {
 		const previousEditMode = this.#resolveActiveEditMode();
@@ -12582,6 +12583,11 @@ export class AgentSession {
 		// Remove the failed assistant message from active context before retrying.
 		this.#removeAssistantMessageFromActiveContext(message);
 
+		// A thinking/response loop retried into identical context loops again. Inject a
+		// hidden redirect so the retried turn sees a directive to break the repeated
+		// pattern instead of re-sampling the same stalled reasoning.
+		this.#maybeInjectThinkingLoopRedirect(id);
+
 		// Wait with exponential backoff (abortable).
 		const retryAbortController = new AbortController();
 		this.#retryAbortController?.abort();
@@ -12615,6 +12621,35 @@ export class AgentSession {
 		return true;
 	}
 
+	/**
+	 * Inject a hidden redirect notice when a thinking/response loop is being retried, so
+	 * the retried turn carries an instruction to break the repeated pattern instead of
+	 * re-sampling the same stalled context. Injected on every {@link AIError.Flag.ThinkingLoop}
+	 * retry (the failed assistant is dropped each attempt, so the notice does not accumulate
+	 * unboundedly). No-op unless `id` carries the ThinkingLoop flag and the loop guard is
+	 * enabled. The notice is generic on purpose — the detector's detail can quote raw model
+	 * text, which must not be interpolated into a higher-priority developer message.
+	 */
+	#maybeInjectThinkingLoopRedirect(id: number): void {
+		if (!AIError.is(id, AIError.Flag.ThinkingLoop)) return;
+		if (this.settings.get("model.loopGuard.enabled") !== true) return;
+		this.agent.appendMessage({
+			role: "custom",
+			customType: THINKING_LOOP_REDIRECT_TYPE,
+			content: thinkingLoopRedirectTemplate,
+			display: false,
+			attribution: "agent",
+			timestamp: Date.now(),
+		});
+		this.sessionManager.appendCustomMessageEntry(
+			THINKING_LOOP_REDIRECT_TYPE,
+			thinkingLoopRedirectTemplate,
+			false,
+			undefined,
+			"agent",
+		);
+	}
+
 	/**
 	 * Cancel in-progress retry.
 	 */

package/src/stt/index.ts

@@ -3,5 +3,6 @@ export * from "./asr-protocol";
 export * from "./downloader";
 export * from "./models";
 export * from "./stt-controller";
+export * from "./submit-trigger";
 export * from "./transcriber";
 export * from "./wav";

package/src/stt/stt-controller.ts

@@ -15,6 +15,7 @@ import {
 	startStreamingRecording,
 	verifyRecordingFile,
 } from "./recorder";
+import { evaluateSubmitTrigger } from "./submit-trigger";
 import { transcribe } from "./transcriber";
 
 export type SttState = "idle" | "recording" | "transcribing";
@@ -33,6 +34,8 @@ interface Editor {
 	setVolatileText(text: string): void;
 	clearVolatileText(): void;
 	commitVolatileText(text: string): void;
+	submit(): void;
+	deleteBeforeCursor(count: number): void;
 }
 
 export class STTController {
@@ -53,6 +56,7 @@ export class STTController {
 	#streamEditor: Editor | null = null;
 	#streamCommitted = false;
 	#streamAbort: AbortController | null = null;
+	#streamUtterance = "";
 
 	get state(): SttState {
 		return this.#state;
@@ -190,6 +194,7 @@ export class STTController {
 		const language = settings.get("stt.language") as string | undefined;
 		this.#streamEditor = editor;
 		this.#streamCommitted = false;
+		this.#streamUtterance = "";
 		this.#streamAbort = new AbortController();
 		const stream = sttClient.startStream(modelKey, {
 			language: language || undefined,
@@ -205,6 +210,7 @@ export class STTController {
 				if (prefixed) {
 					this.#streamEditor?.commitVolatileText(prefixed);
 					this.#streamCommitted = true;
+					this.#streamUtterance += prefixed;
 				} else {
 					this.#streamEditor?.clearVolatileText();
 				}
@@ -266,13 +272,27 @@ export class STTController {
 			return;
 		}
 		if (!this.#streamCommitted && finalText) {
-			this.#streamEditor?.commitVolatileText(this.#prefixed(finalText));
+			const prefixed = this.#prefixed(finalText);
+			this.#streamEditor?.commitVolatileText(prefixed);
 			this.#streamCommitted = true;
+			this.#streamUtterance = prefixed;
 		} else {
 			this.#streamEditor?.clearVolatileText();
 		}
 		options.requestRender?.();
 		if (!failed) options.showStatus(this.#streamCommitted ? "" : "No speech detected.");
+
+		if (this.#streamCommitted && !failed && this.#streamEditor) {
+			const trigger = settings.get("stt.submitTrigger");
+			const { submit, trimTrailing } = evaluateSubmitTrigger(this.#streamUtterance, trigger);
+			if (trimTrailing > 0) {
+				this.#streamEditor.deleteBeforeCursor(trimTrailing);
+			}
+			if (submit) {
+				this.#streamEditor.submit();
+			}
+		}
+
 		this.#cleanupStream();
 		this.#setState("idle", options);
 	}
@@ -283,6 +303,7 @@ export class STTController {
 		this.#streamEditor = null;
 		this.#streamCommitted = false;
 		this.#streamAbort = null;
+		this.#streamUtterance = "";
 	}
 
 	// ── Batch (single-shot) ─────────────────────────────────────────
@@ -327,8 +348,16 @@ export class STTController {
 			this.#transcriptionAbort = null;
 			if (this.#disposed) return;
 			if (text.length > 0) {
-				editor.insertText(text);
+				const trigger = settings.get("stt.submitTrigger");
+				const { submit, trimTrailing } = evaluateSubmitTrigger(text, trigger);
+				const textToInsert = trimTrailing > 0 ? text.slice(0, -trimTrailing) : text;
+				if (textToInsert.length > 0) {
+					editor.insertText(textToInsert);
+				}
 				options.showStatus("");
+				if (submit) {
+					editor.submit();
+				}
 			} else {
 				options.showStatus("No speech detected.");
 			}

package/src/stt/submit-trigger.ts

@@ -0,0 +1,74 @@
+/**
+ * TTS/STT Submit Trigger options and evaluation logic.
+ */
+
+export const STT_SUBMIT_TRIGGER_VALUES = ["never", "release", "release-complete", "say-submit"] as const;
+
+export type SttSubmitTrigger = (typeof STT_SUBMIT_TRIGGER_VALUES)[number];
+
+export const STT_SUBMIT_TRIGGER_OPTIONS = [
+	{
+		value: "never",
+		label: "Never",
+		description: "Never automatically submit; insert dictation and remain in editor.",
+	},
+	{
+		value: "release",
+		label: "Release",
+		description: "Submit on release if the utterance has 2+ words to avoid accidental sends.",
+	},
+	{
+		value: "release-complete",
+		label: "Release with complete sentence",
+		description: "Submit on release if the utterance ends with sentence-terminal punctuation (. ? ! etc.).",
+	},
+	{
+		value: "say-submit",
+		label: "When I Say Submit",
+		description: "Submit if the utterance ends with a word containing 'submit' (strips that word before submitting).",
+	},
+] satisfies ReadonlyArray<{ value: SttSubmitTrigger; label: string; description: string }>;
+
+/**
+ * Evaluate the submit trigger against a transcribed utterance.
+ * Returns whether to submit, and the number of characters to trim from the end of the utterance.
+ */
+export function evaluateSubmitTrigger(
+	utterance: string,
+	trigger: SttSubmitTrigger,
+): { submit: boolean; trimTrailing: number } {
+	const trimmed = utterance.trim();
+	if (!trimmed) {
+		return { submit: false, trimTrailing: 0 };
+	}
+
+	if (trigger === "never") {
+		return { submit: false, trimTrailing: 0 };
+	}
+
+	if (trigger === "release") {
+		// Split by whitespace and count words
+		const words = trimmed.split(/\s+/).filter(Boolean);
+		const submit = words.length >= 2;
+		return { submit, trimTrailing: 0 };
+	}
+
+	if (trigger === "release-complete") {
+		// Matches typical sentence terminators: . ? ! ... or full-width equivalents, optionally followed by space
+		const hasTerminalPunctuation = /[.?!…。？！]\s*$/.test(trimmed);
+		return { submit: hasTerminalPunctuation, trimTrailing: 0 };
+	}
+
+	if (trigger === "say-submit") {
+		// Matches space followed by any word containing "submit" (case-insensitive), optionally followed by punctuation/spaces
+		// Also handles the case where "submit" is the only word in the utterance (no leading space)
+		const match = utterance.match(/(?:^|\s+)(\S*submit\S*)[.?!…。？！]*\s*$/i);
+		if (match && match.index !== undefined) {
+			const trimTrailing = utterance.length - match.index;
+			return { submit: true, trimTrailing };
+		}
+		return { submit: false, trimTrailing: 0 };
+	}
+
+	return { submit: false, trimTrailing: 0 };
+}

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/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>