@oh-my-pi/pi-coding-agent 16.3.13 → 16.3.15

package/dist/types/utils/thinking-display.d.ts

@@ -1,5 +1,10 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 export declare function canonicalizeMessage(text: string | null | undefined): string;
+/**
+ * Thinking text prepared for display. Both modes drop empty `<!-- -->`
+ * sentinel lines outside code fences (see {@link isCommentNoise}); prose-only
+ * mode additionally elides fenced code down to a trailing ellipsis.
+ */
 export declare function formatThinkingForDisplay(text: string, proseOnly: boolean): string;
 /** Whether a formatted thinking block has non-placeholder content worth rendering. */
 export declare function hasDisplayableThinking(text: string | null | undefined, formattedText: string | null | undefined): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.3.13",
+	"version": "16.3.15",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -56,17 +56,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.3.13",
-		"@oh-my-pi/omp-stats": "16.3.13",
-		"@oh-my-pi/pi-agent-core": "16.3.13",
-		"@oh-my-pi/pi-ai": "16.3.13",
-		"@oh-my-pi/pi-catalog": "16.3.13",
-		"@oh-my-pi/pi-mnemopi": "16.3.13",
-		"@oh-my-pi/pi-natives": "16.3.13",
-		"@oh-my-pi/pi-tui": "16.3.13",
-		"@oh-my-pi/pi-utils": "16.3.13",
-		"@oh-my-pi/pi-wire": "16.3.13",
-		"@oh-my-pi/snapcompact": "16.3.13",
+		"@oh-my-pi/hashline": "16.3.15",
+		"@oh-my-pi/omp-stats": "16.3.15",
+		"@oh-my-pi/pi-agent-core": "16.3.15",
+		"@oh-my-pi/pi-ai": "16.3.15",
+		"@oh-my-pi/pi-catalog": "16.3.15",
+		"@oh-my-pi/pi-mnemopi": "16.3.15",
+		"@oh-my-pi/pi-natives": "16.3.15",
+		"@oh-my-pi/pi-tui": "16.3.15",
+		"@oh-my-pi/pi-utils": "16.3.15",
+		"@oh-my-pi/pi-wire": "16.3.15",
+		"@oh-my-pi/snapcompact": "16.3.15",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/modes/components/transcript-container.ts

@@ -40,6 +40,18 @@ interface FinalizableBlock {
 	 * commits until the block finalizes.
 	 */
 	getTranscriptBlockSettledRows?(): number;
+	/**
+	 * Whether the block is a displaceable snapshot (todo/poll card) kept
+	 * unfinalized only so a follow-up matching call can retract it. Paired
+	 * with {@link seal}: once any of its rows enters native scrollback the
+	 * container seals it — rows on the tape are immutable, so retraction is
+	 * no longer possible, and an unfinalized block would otherwise pin the
+	 * live-region seam open for the rest of the turn (every row committed
+	 * below it audit-exempt, mass-recommitted when it finally finalizes).
+	 */
+	isDisplaceableBlock?(): boolean;
+	/** Finalize a displaceable snapshot in place (settle animation, freeze bytes). */
+	seal?(): void;
 }
 
 function isBlockFinalized(child: Component): boolean {
@@ -60,6 +72,12 @@ function getBlockSettledRows(child: Component): number {
 	return Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
 }
 
+/** Seal a displaceable snapshot whose rows entered native scrollback (see {@link FinalizableBlock.isDisplaceableBlock}). */
+function sealCommittedSnapshot(child: Component): void {
+	const block = child as Component & FinalizableBlock;
+	if (block.isDisplaceableBlock?.()) block.seal?.();
+}
+
 // A "plain blank" row is empty or whitespace-only with no ANSI bytes. It marks
 // separation padding (a `Spacer`, or a no-background `paddingY` row) as opposed
 // to a background-colored padding row, whose escape sequences contain `\S` and
@@ -275,6 +293,21 @@ export class TranscriptContainer
 
 		const count = this.children.length;
 
+		// Seal displaceable snapshots whose rows are already on the tape (per the
+		// previous frame's segments — the geometry the committed count was
+		// computed against): immutable history can no longer be retracted, and
+		// left unfinalized such a block would pin the live-region seam open below
+		// it. Runs before the live-block scan so the seam unpins in this same
+		// frame, and every frame so a block that BECAME displaceable after its
+		// pending-preview rows committed (late result on a scrolled-off call) is
+		// caught too.
+		for (let i = 0; i < count && i < this.#segments.length; i++) {
+			const previous = this.#segments[i]!;
+			if (previous.startRow >= this.#committedRows) break;
+			if (previous.rowCount === 0 || previous.component !== this.children[i]) continue;
+			sealCommittedSnapshot(previous.component);
+		}
+
 		// The commit boundary stops at the earliest still-mutating block. A
 		// block that has not finalized must gate it: out-of-band inserts
 		// (TTSR/todo cards) can append a finalized block *below* a tool that is

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

@@ -182,9 +182,11 @@ EXECUTION WORKFLOW
 {{#has tools "ask"}}- Ask before destructive commands or deleting code you didn't write.{{else}}- Don't run destructive git commands or delete code you didn't write.{{/has}}
 
 # 5. Verify
-- NEVER yield non-trivial work without proof: tests, E2E, browsing, or QA. Run only tests you added or modified unless asked otherwise.
-- Test behavior, using tester agent where available. Assert logical behavior, not current state.
-- Aim at conditional branches, edge values, invariants across fields, and error handling versus silent broken results.
+- NEVER yield non-trivial work without proof: tests, E2E, browsing, or QA.
+- Every test MUST defend an observable contract and fail on a plausible bug.
+- Test behavior, boundaries, invariants, transitions, precedence, and real errors—not plumbing, source text, or incidental defaults.
+- Match existing conventions; keep tests deterministic, isolated, and full-suite safe.
+- Run only touched tests; small/no-test changes still REQUIRE a focused behavioral smoke test.
 
 # 6. Cleanup
 Changelog, tests, docs, and removing scaffolding are the LAST phase—NEVER skipped, but gated on the request demonstrably working.

package/src/prompts/system/workflow-notice.md

@@ -51,20 +51,20 @@ Decompose first, then {{#if taskBatch}}batch the independent leaves{{else}}issue
 
 {{#if taskBatch}}
     task(
-      context: "# Goal\nReview the auth diff...\n# Constraints\nRead-only...\n# Contract\nReturn findings as severity/file/line/fix...",
+      context: "# Goal\nReview the auth diff…\n# Constraints\nRead-only…\n# Contract\nReturn findings as severity/file/line/fix…",
       tasks: [
-        { id: "AuthOwner", role: "Auth Storage Reviewer", assignment: "# Target\npackages/ai/src/auth-storage.ts\n# Change\nTrace credential selection...\n# Acceptance\nReturn confirmed findings only..." },
-        { id: "PromptOwner", role: "Prompt Contract Reviewer", assignment: "# Target\npackages/coding-agent/src/prompts/**\n# Change\nCheck active-tool guidance...\n# Acceptance\nReturn mismatches and exact prompt lines..." },
+        { id: "AuthOwner", role: "Auth Storage Reviewer", assignment: "# Target\npackages/ai/src/auth-storage.ts\n# Change\nTrace credential selection…\n# Acceptance\nReturn confirmed findings only…" },
+        { id: "PromptOwner", role: "Prompt Contract Reviewer", assignment: "# Target\npackages/coding-agent/src/prompts/**\n# Change\nCheck active-tool guidance…\n# Acceptance\nReturn mismatches and exact prompt lines…" },
       ]
     )
 {{else}}
     task(
       role: "Auth Storage Reviewer",
-      assignment: "# Target\npackages/ai/src/auth-storage.ts\n# Change\nReview the auth diff. Shared contract: read-only; return findings as severity/file/line/fix.\n# Acceptance\nReturn confirmed findings only..."
+      assignment: "# Target\npackages/ai/src/auth-storage.ts\n# Change\nReview the auth diff. Shared contract: read-only; return findings as severity/file/line/fix.\n# Acceptance\nReturn confirmed findings only…"
     )
     task(
       role: "Prompt Contract Reviewer",
-      assignment: "# Target\npackages/coding-agent/src/prompts/**\n# Change\nCheck active-tool guidance. Shared contract: read-only; return mismatches and exact prompt lines.\n# Acceptance\nReturn confirmed findings only..."
+      assignment: "# Target\npackages/coding-agent/src/prompts/**\n# Change\nCheck active-tool guidance. Shared contract: read-only; return mismatches and exact prompt lines.\n# Acceptance\nReturn confirmed findings only…"
     )
 {{/if}}
 

package/src/task/agents.ts

@@ -15,7 +15,6 @@ import librarianMd from "../prompts/agents/librarian.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 +46,6 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "designer.md", template: designerMd },
 	{ fileName: "reviewer.md", template: reviewerMd },
 	{ fileName: "librarian.md", template: librarianMd },
-	{ fileName: "tester.md", template: testerMd },
 	{
 		fileName: "task.md",
 		frontmatter: {

package/src/utils/thinking-display.ts

@@ -1,14 +1,16 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 
-// Single-entry memo for the proseOnly formatting path. During a streaming tick
-// the same growing thinking text is formatted up to three times (reveal count,
-// reveal slice, component render); this collapses them to one computation. The
-// `proseOnly === false` branch is a passthrough and never consults the cache, so
-// the key can be the text alone. A single entry is enough for the common case of
-// one active thinking block and never regresses (a miss recomputes exactly as
-// before).
-let formatCacheKey = "";
-let formatCacheValue = "";
+// Single-slot-per-mode memo for formatThinkingForDisplay. During a streaming
+// tick the same growing thinking text is formatted up to three times (reveal
+// count, reveal slice, component render); this collapses them to one
+// computation. Prose and raw modes produce different output for the same text,
+// so each mode keeps its own slot. One entry per mode is enough for the common
+// case of one active thinking block and never regresses (a miss recomputes
+// exactly as before).
+let proseCacheKey = "";
+let proseCacheValue = "";
+let rawCacheKey = "";
+let rawCacheValue = "";
 
 export function canonicalizeMessage(text: string | null | undefined): string {
 	if (!text) return "";
@@ -22,9 +24,35 @@ export function canonicalizeMessage(text: string | null | undefined): string {
 	return "";
 }
 
+// gpt-5.x reasoning summaries pad every summary part with an empty HTML
+// comment (`**Headline**\n\n<!-- -->`), streamed as a `<!--` delta followed by
+// ` -->`. Comments with actual content are left untouched.
+const EMPTY_COMMENT_RE = /^<!--\s*-->$/;
+const OPEN_COMMENT_RE = /^<!--\s*$/;
+
+/**
+ * Whether `line` is reasoning-summary comment noise: an empty HTML comment,
+ * or its still-unterminated `<!--` prefix on the last line while streaming.
+ */
+function isCommentNoise(line: string, isLastLine: boolean): boolean {
+	const trimmed = line.trim();
+	return EMPTY_COMMENT_RE.test(trimmed) || (isLastLine && OPEN_COMMENT_RE.test(trimmed));
+}
+
+/**
+ * Thinking text prepared for display. Both modes drop empty `<!-- -->`
+ * sentinel lines outside code fences (see {@link isCommentNoise}); prose-only
+ * mode additionally elides fenced code down to a trailing ellipsis.
+ */
 export function formatThinkingForDisplay(text: string, proseOnly: boolean): string {
-	if (!proseOnly || !text) return text;
-	if (text === formatCacheKey) return formatCacheValue;
+	if (!text) return text;
+	const hasComment = text.includes("<!--");
+	if (proseOnly) {
+		if (text === proseCacheKey) return proseCacheValue;
+	} else {
+		if (!hasComment) return text;
+		if (text === rawCacheKey) return rawCacheValue;
+	}
 
 	const lines = text.split("\n");
 	const resultLines: string[] = [];
@@ -56,22 +84,31 @@ export function formatThinkingForDisplay(text: string, proseOnly: boolean): stri
 
 	for (let i = 0; i < lines.length; i++) {
 		const line = lines[i]!;
-		const open = FENCE.exec(line);
 
 		if (inFence) {
+			const close = FENCE.exec(line);
 			// A closing fence is the same char, at least as long, with nothing else on the line.
 			if (
-				open &&
-				open[2]![0] === fenceChar &&
-				open[2]!.length >= fenceLen &&
-				line.slice(open[1]!.length + open[2]!.length).trim() === ""
+				close &&
+				close[2]![0] === fenceChar &&
+				close[2]!.length >= fenceLen &&
+				line.slice(close[1]!.length + close[2]!.length).trim() === ""
 			) {
 				inFence = false;
 				fenceChar = "";
 				fenceLen = 0;
 			}
-			// We skip all internal lines of a code fence.
-		} else if (open) {
+			// Prose mode skips all fence lines; raw mode keeps them verbatim
+			// (comment markers inside fences are code, not noise).
+			if (!proseOnly) resultLines.push(line);
+			continue;
+		}
+
+		// Drop the whole line so `**Headline**\n\n<!-- -->` leaves no blank tail.
+		if (hasComment && isCommentNoise(line, i === lines.length - 1)) continue;
+
+		const open = FENCE.exec(line);
+		if (open) {
 			const marker = open[2]!;
 			const ch = marker[0]!;
 			// A backtick fence's info string may not contain a backtick.
@@ -79,18 +116,25 @@ export function formatThinkingForDisplay(text: string, proseOnly: boolean): stri
 				inFence = true;
 				fenceChar = ch;
 				fenceLen = marker.length;
-				appendEllipsis();
-			} else {
-				resultLines.push(line);
+				if (proseOnly) {
+					appendEllipsis();
+				} else {
+					resultLines.push(line);
+				}
+				continue;
 			}
-		} else {
-			resultLines.push(line);
 		}
+		resultLines.push(line);
 	}
 
 	const formatted = resultLines.join("\n");
-	formatCacheKey = text;
-	formatCacheValue = formatted;
+	if (proseOnly) {
+		proseCacheKey = text;
+		proseCacheValue = formatted;
+	} else {
+		rawCacheKey = text;
+		rawCacheValue = formatted;
+	}
 	return formatted;
 }
 
@@ -99,9 +143,11 @@ export function hasDisplayableThinking(
 	text: string | null | undefined,
 	formattedText: string | null | undefined,
 ): boolean {
-	if (!text) return false;
-	if (!formattedText) return false;
-	return formattedText.length > 0 && canonicalizeMessage(text).length > 0;
+	if (!text || !formattedText) return false;
+	// Visibility keys off the formatted text: a block whose raw text is only
+	// comment noise (`<!-- -->\n`) formats to whitespace and stays hidden. The
+	// raw canonicalize check still hides dot/ellipsis-only placeholder blocks.
+	return formattedText.trim().length > 0 && canonicalizeMessage(text).length > 0;
 }
 
 /** Whether an assistant message contains thinking content the TUI can reveal. */

package/src/prompts/agents/tester.md

@@ -1,111 +0,0 @@
----
-name: Tester
-description: Authoritative test writer. ALWAYS delegate test authoring to this agent — NEVER write tests yourself. Writes high-signal tests defending real contracts (behavior, invariants, edge cases) and refuses worthless tests that assert plumbing or restate the code.
-tools: read, grep, glob, bash, edit, write, lsp, ast_grep, ast_edit
-spawns: explore
-model: pi/task
-thinking-level: high
----
-
-<system-conventions>
-RFC 2119 applies to MUST, REQUIRED, SHOULD, RECOMMENDED, MAY, OPTIONAL. `NEVER` and `AVOID` MUST be interpreted as aliases for `MUST NOT` and `SHOULD NOT` respectively.
-</system-conventions>
-
-You are a staff test engineer with taste. You write tests that earn their place in the suite and you delete — or refuse to write — tests that don't. You have agency: when asked for coverage that proves nothing, you write the test that would actually catch the bug instead.
-
-<stakes>
-A test suite is a liability until it pays for itself. Every worthless test is negative value: it costs CI time, blocks honest refactors, and lulls the team into false confidence while the real bug ships. A test's only job is to FAIL when behavior breaks and PASS otherwise. A test that cannot fail for any real defect is noise wearing a green check. You are here because models flood codebases with exactly that noise. You write the opposite.
-</stakes>
-
-<critical>
-- The litmus for every test: **name the concrete, externally observable contract it defends** — a behavior, output shape, state transition, error mapping, invariant, or a regression-prone parsing boundary. Cannot name it in one sentence? NEVER write the test.
-- Mutation test in your head: if a plausible bug — a flipped condition, an off-by-one, a wrong return value, a dropped case — would still let the test PASS, the test is worthless. Discard it.
-- You NEVER write tests that assert plumbing or restate the implementation. The forbidden classes are enumerated in `<worthless-tests>` and are hard prohibitions.
-- You MUST match the repo's existing test conventions — framework, file layout, naming, assertion style. A second convention beside an existing one is PROHIBITED.
-- NEVER test defaults (configurations, fallback values, or default environment values). If you are updating/refactoring existing tests that test defaults, you MUST delete those assertions or delete the entire default-testing tests instead.
-- You are explicitly ALLOWED to write **no tests at all** if you were spawned for a stupid reason (meaning: the change is trivial—such as docs, comments, types, exports, or simple config; the behavior is already fully covered; or any tests you would write would be worthless, restate plumbing, or test defaults). If so, state this clearly and exit.
-</critical>
-
-<anti-patterns name="worthless-tests">
-NEVER write any of these. Each is a green check that survives real bugs:
-- **Config/setter echo.** Setting a value then asserting it reads back (`set(x, 30); expect(get(x)).toBe(30)`) tests the language's assignment, not your code.
-- **Source-grep.** Reading an implementation/build file and asserting on its TEXT — `expect(src).toContain("newFn()")`, `.toMatch(/import …/)`, `.not.toContain("oldName")`, "comment says X". Tests how code LOOKS, breaks on rename/reflow, passes while behavior is broken. Enforce structural facts with a type test or lint rule; enforce behavior by running the code.
-- **Tautologies.** `expect(true).toBe(true)`, `expect(x).toBe(x)`, asserting a constant equals its literal.
-- **Bare no-throw.** `expect(() => f()).not.toThrow()` with no assertion on the result. "It ran" is not a contract.
-- **Construction smoke.** "Constructs without error", "package boots", "command starts" — unless that wiring genuinely can't be exercised in-process AND a real failure mode hides there.
-- **Mock round-trips.** Asserting a mock was called with the args you just passed it. You tested the mock, not the system.
-- **Existence/shape-only.** Non-empty string, length-grew, "field is defined", "returns an object with key Y" — without asserting the VALUE that matters.
-- **Default values.** NEVER assert that default configurations, fallback properties, or default environment values match specific literals. A harmless change to a default setting must never break the tests. If you are touching or refactoring existing tests that assert defaults, **delete those assertions or the entire test instead**.
-- **Field-wiring.** Asserting an option passed in lands on a property, or that a getter returns the value the constructor stored. Test the downstream BEHAVIOR that depends on it, not the assignment.
-- **Duplicate-layer coverage.** Re-proving through mocks what an integration test already proves. Drop the narrower restatement.
-
-When asked for coverage that would only produce the above, you write the test that actually exercises the behavior, and you state in your result why the requested shape was worthless.
-</anti-patterns>
-
-<what-to-test>
-Aim every test at something that can actually break:
-- **Behavior & outputs** — given input, the observable result (return value, emitted event, written file, error surfaced).
-- **State transitions** — the legal and illegal moves of a stateful component; one test per invariant or transition, not one per field touched.
-- **Invariants across fields** — relationships that MUST hold (sorted output stays sorted, sum of parts equals total, encode∘decode is identity).
-- **Edge & boundary values** — zero, empty, one, max, negative, off-by-one, overflow, unicode, the value just inside and just outside a limit.
-- **Precedence & resolution** — arg beats env beats default; later override wins; first-match-wins.
-- **Error paths** — trigger the REAL failure (bad input, missing dep, denied permission) and assert the surfaced contract (error type, message mapping, exit code). NEVER instantiate the error class directly or inspect internal metadata.
-- **Regression-prone parsing boundaries** — the exact bytes where a parser/serializer historically broke; pin past regressions with a named case.
-</what-to-test>
-
-<techniques>
-Reach for the right shape; do not reinvent what the repo's framework already gives you.
-- **Table-driven tests.** One body, many `{ name, input, expected }` rows covering boundaries and equivalence classes plus error cases. Name every row so a failure points at the case. The default shape for any function with a clear input→output mapping.
-- **Subtests.** Group related cases under one parent with isolated setup and independent failure reporting. Prefer over many tiny near-duplicate test functions.
-- **Property-based tests.** Assert invariants over generated inputs — round-trip identity, idempotence (`f(f(x)) == f(x)`), commutativity, monotonicity, "never panics and output stays well-formed". Catches cases you wouldn't enumerate by hand.
-- **Deterministic randomness.** Seed every generator and PRINT the seed on failure so a red run reproduces exactly. NEVER use an unseeded clock-derived source — flaky tests are worse than no tests.
-- **Fuzz tests.** For parsers, decoders, deserializers, anything eating untrusted bytes: feed mutated/random input, assert no crash and that invariants hold. Seed the corpus from known-tricky inputs and every past regression.
-- **Benchmarks.** ONLY when performance is part of the contract. Measure the operation, not setup; consume the result so it isn't optimized away; compare against a baseline or threshold. A benchmark that asserts nothing is documentation, not a test.
-- **Golden/snapshot.** Only for genuinely stable, human-reviewed output where exact bytes are the contract (codegen, serialized formats). NEVER snapshot volatile or incidental output — it becomes a rubber stamp nobody reads.
-</techniques>
-
-<black-box>
-- **Test through the public API**, the way a real consumer calls it. Place tests in an EXTERNAL test package/module (separate namespace, no access to internals) so the compiler forbids reaching past the contract. This is the default and it forces you to test what callers depend on.
-- **Internal (white-box) tests only for private invariants with no observable surface** — e.g. a balancing property of an internal tree, a cache eviction order. Justify each one; if the invariant has an observable effect, test that effect from outside instead.
-- NEVER reach into private state to assert what you could observe through the public surface. Coupling tests to internals is what makes refactors painful and tempts people to delete the suite.
-</black-box>
-
-<fakes>
-- **Prefer real implementations.** If the dependency is cheap and deterministic, use the real thing.
-- **Prefer hand-written fakes over mocking frameworks.** A small in-memory implementation of an interface is type-checked, readable, survives refactors, and tests behavior. Mocking frameworks pull you toward asserting call counts and argument sequences — that is plumbing, and it breaks on every harmless internal change.
-- **Mock only true external boundaries** — network, wall clock, filesystem, system randomness, third-party services — and even there a fake beats a mock. Inject the boundary; never patch globals.
-- NEVER use module-registry mocking that leaks across test files. Spy on the imported object and restore in teardown.
-</fakes>
-
-<isolation>
-Tests MUST be full-suite safe and order-independent, not merely file-local safe.
-- **No timing dependence.** NEVER `sleep`/`setTimeout`-race to "let it settle". Inject a controllable clock and advance it; wait on a condition, signal, or promise, never a wall-clock duration. Real-time waits are the #1 source of flake.
-- **No environment pollution.** NEVER leak env vars, temp files, global singletons, `process.env`/`process.platform`/`Bun.*` mutations, or monkeypatches past the test. Use per-test setup with restore in teardown. A test that passes alone but poisons a later file is broken.
-- **Deterministic.** No dependence on map/iteration order, filesystem ordering, locale, timezone, or concurrency interleaving unless that ordering IS the contract under test.
-- **Hermetic.** No real network or real time. Each test creates and tears down its own fixtures.
-</isolation>
-
-<workflow>
-1. **Study the code under test.** Read exact signatures, return types, and error paths with `lsp`/`read` — NEVER guess an API. Spawn `explore` for unfamiliar areas.
-2. **Study existing tests.** Find the framework, file layout, naming, fake/fixture helpers, and assertion style. You MUST reuse them. `grep`/`glob` for sibling test files.
-3. **Enumerate contracts.** List the observable behaviors, invariants, edge cases, and error mappings worth defending. Drop anything that fails the `<critical>` litmus.
-4. **Pick the shape** per `<techniques>` — table, property, fuzz, benchmark, or a focused unit/integration test.
-5. **Write the tests**, matching repo conventions exactly. Assert semantic content; assert exact bytes ONLY where downstream parses them.
-6. **Run them and verify they have teeth.** Execute the suite with the repo's runner; confirm green. Then confirm each test can FAIL: mentally (or by a throwaway mutation) check that a real defect reddens it. A test you never saw fail is unproven.
-</workflow>
-
-<verify>
-- You MUST run the tests you wrote with the project's test command and confirm they pass.
-- You MUST confirm they are not vacuous: a test that passes against broken code is a defect you authored. When cheap, perturb the implementation to watch the test fail, then revert.
-- Run ONLY the tests you added or touched unless asked for the full suite.
-- Report each test by the contract it defends — not "added N tests", but "covers <behavior/invariant/edge>".
-</verify>
-
-<critical>
-- A test exists to FAIL on a real bug. No nameable contract, or no plausible bug would redden it → NEVER write it.
-- NEVER assert plumbing, restate the implementation, or grep the source. Test observable behavior through the public surface.
-- No timing races, no environment pollution, deterministic and order-independent — full-suite safe.
-- NEVER test defaults. If updating tests that do, delete them instead.
-- You are explicitly ALLOWED to write **no tests at all** if you were spawned for a stupid reason (trivial changes, already covered, or if any possible test would be worthless/test defaults).
-- You MUST keep going until the tests are written, passing, and proven to have teeth (unless skipped per above).
-</critical>