@oh-my-pi/pi-coding-agent 17.2.13 → 17.2.15

package/src/discovery/builtin-rules/rs-parking-lot.md

@@ -33,12 +33,12 @@ let guard = data.lock();
 
 ## Equivalents
 
-| std::sync | parking_lot |
-| --- | --- |
-| `Mutex<T>` | `Mutex<T>` |
-| `RwLock<T>` | `RwLock<T>` |
-| `Condvar` | `Condvar` |
-| `Once` | `Once` |
+|std::sync|parking_lot|
+|---|---|
+|`Mutex<T>`|`Mutex<T>`|
+|`RwLock<T>`|`RwLock<T>`|
+|`Condvar`|`Condvar`|
+|`Once`|`Once`|
 
 ## Keep async locks async
 

package/src/discovery/builtin-rules/ts-no-any.md

@@ -57,10 +57,10 @@ const config = { port: 3000 } satisfies ServerConfig;
 
 ## Choosing: guard vs schema vs unchecked cast
 
-| Situation | Reach for |
-| --- | --- |
-| Data from outside your control — network/RPC, parsed JSON, config files, env vars, CLI/IPC, persisted blobs — or a shape reused across the codebase | **Schema parse** (Zod/Valibot/…): runtime validation, typed output, and a clear error on bad shape |
-| In-process value the compiler merely lost track of — an `unknown` from a generic, a union to discriminate, a one-off read of a field or two | **Type guard** (`in` / `typeof`): no dependency, but it only checks what you write, so keep the checked surface small |
-| You genuinely know more than the compiler *and* a runtime check is impossible or meaningless — a well-known DOM node (`as HTMLElement`), structurally-identical types inference can't unify, a library type that is wrong or unexpressible, `as const` | **Unchecked cast** (`as` / `as unknown as T`): assign to a named const with a one-line reason; never for raw external input |
+|Situation|Reach for|
+|---|---|
+|Data from outside your control — network/RPC, parsed JSON, config files, env vars, CLI/IPC, persisted blobs — or a shape reused across the codebase|**Schema parse** (Zod/Valibot/…): runtime validation, typed output, and a clear error on bad shape|
+|In-process value the compiler merely lost track of — an `unknown` from a generic, a union to discriminate, a one-off read of a field or two|**Type guard** (`in` / `typeof`): no dependency, but it only checks what you write, so keep the checked surface small|
+|You genuinely know more than the compiler *and* a runtime check is impossible or meaningless — a well-known DOM node (`as HTMLElement`), structurally-identical types inference can't unify, a library type that is wrong or unexpressible, `as const`|**Unchecked cast** (`as` / `as unknown as T`): assign to a named const with a one-line reason; never for raw external input|
 
 If a library boundary truly requires an unchecked cast, use `as unknown as T` with a short reason. Never leave a bare `any`.

package/src/discovery/builtin-rules/ts-no-deprecated-leftovers.md

@@ -5,14 +5,14 @@ scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
 interruptMode: never
 ---
 
-Do not use `@deprecated` as a substitute for finishing a refactor. If an API is obsolete inside the code you control, update every call site and remove the old name in the same change.
+Never use `@deprecated` instead of completing a refactor. Obsolete APIs in code you control: update every call site; remove the old name in the same change.
 
 ## Why
 
-- Deprecated aliases keep two contracts alive.
-- Future maintainers must preserve behavior nobody should call.
-- Tests can pass while production code keeps using the old path.
-- The next refactor has to unwind both the real API and the compatibility layer.
+- Deprecated aliases: two live contracts.
+- Future maintainers preserve behavior nobody should call.
+- Tests pass while production uses the old path.
+- Next refactor unwinds real API and compatibility layer.
 
 ## Avoid
 
@@ -39,7 +39,7 @@ export function createClient(options: ClientOptions): Client { ... }
 ## Exceptions
 
 - Public package APIs with a documented migration window.
-- Third-party declarations where the deprecated marker reflects an external contract.
-- Tests that intentionally verify deprecated API behavior during a supported transition.
+- Third-party declarations whose deprecated marker reflects an external contract.
+- Tests intentionally verifying deprecated API behavior during a supported transition.
 
-If an exception applies, state the external compatibility requirement. Otherwise, finish the refactor and delete the deprecated symbol.
+If an exception applies, state the external compatibility requirement. Otherwise complete the refactor; delete the deprecated symbol.

package/src/discovery/builtin-rules/ts-no-inline-cast-access.md

@@ -8,13 +8,15 @@ astCondition:
   - "($X as { $$$BODY })[$IDX]"
 ---
 
-**Don't assert an inline object type just to read a property.** `(value as { content: unknown }).content` fabricates a shape the compiler never verified, then trusts it for exactly one access. If `value` isn't that shape, the read is silently wrong and no type error ever fires.
+## Don't inline-cast an object type for member access
 
-## Why it's wrong
+`(value as { content: unknown }).content` fabricates an unchecked shape, then trusts it for the access. If `value` lacks that shape, the read is silently wrong; no type error fires.
 
-- The cast is an unchecked assertion — it suppresses the type error instead of proving the shape.
-- It localizes the lie to one expression, so the next reader can't tell whether the value was ever validated.
-- It almost always stands in for the real fix: runtime narrowing or a validated type at the boundary.
+## Why
+
+- Unchecked assertion: suppresses the error; proves no shape.
+- Localizes the lie; readers cannot tell whether `value` was validated.
+- Usually replace with runtime narrowing or a validated boundary type.
 
 ## Avoid
 
@@ -27,8 +29,7 @@ const flag = (opts as { enabled: boolean })["enabled"];
 
 ## Use
 
-Prefer a schema parse at the boundary when a validator is available — validate
-once, then read from a fully typed value:
+At a boundary, prefer a schema parse when a validator exists: validate once, then read a fully typed value.
 
 ```ts
 import { type } from "@oh-my-pi/omptype";
@@ -39,7 +40,7 @@ const resp = Resp.assert(raw); // throws on bad input; resp.data.id is typed str
 const id = resp.data.id;
 ```
 
-For a one-off read of a single field, narrow with `in` / `typeof` so the access is actually checked — TypeScript infers `unknown` for the property after `"content" in value`:
+For a one-off field read, narrow with `in` / `typeof`; access is checked. After `"content" in value`, TypeScript infers the property as `unknown`:
 
 ```ts
 if (value && typeof value === "object" && "content" in value) {
@@ -47,10 +48,8 @@ if (value && typeof value === "object" && "content" in value) {
 }
 ```
 
-## Choosing: guard vs schema vs unchecked cast
+## Choose: guard vs schema vs unchecked cast
 
-| Situation | Reach for |
-| --- | --- |
-| Data from outside your control — network/RPC, parsed JSON, config files, env vars, CLI/IPC, persisted blobs — or a shape reused across the codebase | **Schema parse** (Zod/Valibot/…): runtime validation, typed output, and a clear error on bad shape |
-| In-process value the compiler merely lost track of — an `unknown` from a generic, a union to discriminate, a one-off read of a field or two | **Type guard** (`in` / `typeof`): no dependency, but it only checks what you write, so keep the checked surface small |
-| You genuinely know more than the compiler *and* a runtime check is impossible or meaningless — a well-known DOM node (`as HTMLElement`), structurally-identical types inference can't unify, a library type that's wrong or unexpressible, `as const` | **Unchecked cast** (`as`): assign to a named const with a one-line reason; never for raw external input, never inlined into a member access |
+- Outside-controlled data—network/RPC, parsed JSON, config files, env vars, CLI/IPC, persisted blobs—or codebase-reused shapes: **Schema parse** (Zod/Valibot/…): runtime validation, typed output, clear bad-shape error.
+- In-process values the compiler lost—generic `unknown`, union discrimination, one-off reads of one or two fields: **Type guard** (`in` / `typeof`): no dependency; checks only what you write, so keep its surface small.
+- You know more than the compiler **and** runtime checking is impossible or meaningless—well-known DOM node (`as HTMLElement`), structurally-identical types inference cannot unify, wrong or unexpressible library type, `as const`: **Unchecked cast** (`as`): assign to a named const with a one-line reason; never raw external input or inline member access.

package/src/discovery/builtin-rules/ts-no-local-is-record.md

@@ -9,15 +9,15 @@ interruptMode: never
 
 ## Why it's wrong
 
-- A `Record<string, unknown>` guard proves only an object, not its fields.
-- It's either unnecessarily complicated, or not strong enough.
-- Repeated guards hide the actual data contract from readers and TypeScript.
+- A `Record<string, unknown>` guard proves an object, not its fields.
+- Either unnecessarily complicated or insufficiently strong.
+- Repeated guards hide the data contract from readers and TypeScript.
 
 ## Use
 
-`isRecord` narrows values to `Record<string, unknown>`; each field remains `unknown`.
+`isRecord`: values narrow to `Record<string, unknown>`; fields remain `unknown`.
 
-For network, config, IPC, persisted, or reused data shapes, parse once at the boundary with the project's schema validator and consume its named output type:
+Network, config, IPC, persisted, or reused data shapes: parse once at the boundary with the project's schema validator; consume its named output type:
 
 ```typescript
 const Config = z.object({ retries: z.number().int().nonnegative() });
@@ -26,7 +26,7 @@ type Config = z.infer<typeof Config>;
 const config = Config.parse(raw);
 ```
 
-If the runtime shape is uncertain, check the properties you use with `typeof`, `Array.isArray`, `in`, or a discriminant. If an existing invariant guarantees the shape, assert the named type at that boundary instead of duplicating a guard:
+If runtime shape uncertain: check used properties with `typeof`, `Array.isArray`, `in`, or a discriminant. If an existing invariant guarantees shape: assert the named type at that boundary, not a duplicate guard:
 
 ```typescript
 const config = value as Config;
@@ -45,4 +45,4 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
 
 ## Exceptions
 
-A standalone package without a shared type-guard module may define its single canonical guard. Export it from the package's type-guard module; never recreate it at individual call sites.
+A standalone package without a shared type-guard module may define one canonical guard. Export it from the package's type-guard module; never recreate it at individual call sites.

package/src/discovery/builtin-rules/ts-no-test-timers.md

@@ -8,13 +8,7 @@ scope: "tool:edit(*.test.ts), tool:write(*.test.ts)"
 interruptMode: never
 ---
 
-**Do not reach for real wall-clock timers in test files.** `Bun.sleep(...)`, `setTimeout(...)`, and `setInterval(...)` tie a test's duration to real time: they slow the suite on every run, and any delay tuned to "long enough" eventually races on a loaded machine and flakes.
-
-## Why it's wrong
-
-- Real delays add fixed latency to every invocation; CI pays it on every run.
-- A sleep sized to mask a race is a guess — the race resurfaces under load.
-- A fixed wait hides *what* you are waiting for, so a failure points at a timeout instead of the real cause.
+**Avoid real wall-clock timers in test files.** `Bun.sleep(...)`, `setTimeout(...)`, and `setInterval(...)` bind duration to real time → fixed latency each invocation; CI pays every run. “Long enough” sleeps guess at and mask races; under load, races resurface and flake. Fixed waits hide the awaited condition, so failures point to a timeout, not the cause.
 
 ## Avoid
 
@@ -43,7 +37,7 @@ test("debounce fires once", () => {
 });
 ```
 
-When the code under test resolves a promise or emits an event, await that signal directly instead of guessing a duration:
+When code resolves a promise or emits an event, await that signal, not a guessed duration:
 
 ```typescript
 await once(emitter, "done"); // await the real event
@@ -52,4 +46,4 @@ const value = await pending; // await the promise the code already exposes
 
 ## Exceptions
 
-An integration test that deliberately exercises real timer behavior against the platform clock may need a genuine delay. Keep it rare, and add a short comment naming why deterministic time control will not work.
+Integration tests deliberately exercising real timer behavior against the platform clock may need a genuine delay. Keep rare; add a short comment naming why deterministic time control will not work.

package/src/discovery/builtin-rules/ts-no-tiny-functions.md

@@ -5,14 +5,14 @@ scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
 interruptMode: never
 ---
 
-Do not extract a function whose whole body is one expression or one `return`. Inline it unless the name creates a durable contract.
+Inline functions whose whole body: one expression or `return`, unless name creates a durable contract.
 
 ## Why
 
-- One-line wrappers hide no real behavior.
-- Readers must jump to verify trivial code.
-- The signature freezes a shape too early.
-- Search and type flow work better with inline expressions.
+- One-line wrappers: no real behavior.
+- Readers: jump to verify trivial code.
+- Signature: freezes shape too early.
+- Inline expressions: better search and type flow.
 
 ## Avoid
 
@@ -42,10 +42,10 @@ const doubled = value * 2;
 ## Allowed tiny functions
 
 - Three or more call sites need lockstep behavior.
-- Exported name represents a stable domain concept.
+- Exported name: stable domain concept.
 - Callback identity matters.
 - Type guard preserves narrowing.
 - Public API, test seam, or DI boundary needs indirection.
-- Names a non-obvious formula or magic-constant computation that the inlined expression would not explain on its own.
+- Names non-obvious formula or magic-constant computation the inlined expression would not explain alone.
 
 If none apply, inline it.

package/src/discovery/builtin-rules/ts-promise-with-resolvers.md

@@ -5,7 +5,7 @@ scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
 interruptMode: never
 ---
 
-Use `Promise.withResolvers()` instead of `new Promise((resolve, reject) => ...)`. It keeps control flow linear and exposes typed resolver functions without callback nesting.
+Prefer `Promise.withResolvers()` over `new Promise((resolve, reject) => ...)`: linear control flow; typed resolvers without callback nesting.
 
 ## Basic operation
 
@@ -63,4 +63,4 @@ class Gate {
 }
 ```
 
-Use the constructor only when an API specifically requires the executor form.
+Constructor only if an API specifically requires executor form.

package/src/discovery/builtin-rules/ts-redundant-clear-guard.md

@@ -35,13 +35,7 @@ astCondition:
   - "if ($X != undefined) { clearImmediate($X) }"
 ---
 
-**Do not guard `clearTimeout` / `clearInterval` / `clearImmediate` with a truthiness or `null`/`undefined` check.** Per the WHATWG/Node timers spec these functions are no-ops when handed `null`, `undefined`, or any value that doesn't correspond to a live timer. The guard adds a redundant branch that the reader must still reason about.
-
-## Why it's wrong
-
-- The branch can never change behavior — clearing a missing/`null`/`undefined` handle does nothing.
-- Extra branches inflate the code and hide the one line that matters.
-- It signals a misunderstanding of the timer API to future readers.
+**Do not guard `clearTimeout` / `clearInterval` / `clearImmediate` with truthiness or `null`/`undefined` checks.** Per WHATWG/Node timers spec, calls no-op for `null`, `undefined`, or values without a live timer; guards cannot change behavior, add branches readers must reason about, inflate code, hide the line that matters, and signal timer-API misunderstanding.
 
 ## Avoid
 
@@ -63,7 +57,7 @@ clearImmediate(id);
 
 ## When a guard *is* warranted
 
-Keep the check only when the body does more than clear — e.g. it also reassigns the handle or runs other cleanup:
+Keep it only if the body does more than clear, e.g. reassigns the handle or runs other cleanup:
 
 ```ts
 if (this.timer) {
@@ -72,4 +66,4 @@ if (this.timer) {
 }
 ```
 
-This rule only fires when the clear call is the sole statement in the guarded branch, so those legitimate cases are left alone.
+Rule fires only if the clear call is the guarded branch's sole statement; legitimate cases are left alone.

package/src/discovery/builtin-rules/ts-set-map.md

@@ -5,9 +5,9 @@ scope: "tool:edit(**/*.{ts,tsx}), tool:write(**/*.{ts,tsx})"
 interruptMode: never
 ---
 
-Use `Record<K, V>` / `Record<K, true>` for small, static string-keyed lookup tables.
+Small, static string-keyed lookup tables: `Record<K, V>` / `Record<K, true>`.
 
-Use `Set` / `Map` when keys are dynamic, non-string, inserted or deleted at runtime, or when code needs `.size`, `.clear()`, stable insertion order, or iterator APIs.
+`Set` / `Map`: dynamic/non-string keys; runtime insertion/deletion; `.size`, `.clear()`, stable insertion order, or iterator APIs.
 
 ```typescript
 // Static literal → Record
@@ -24,5 +24,3 @@ for (const item of items) {
 	seen.add(item.id);
 }
 ```
-
-Small fixed table? `Record`. Runtime collection? `Set` / `Map`.

package/src/internal-urls/local-protocol.ts

@@ -253,6 +253,48 @@ export function resolveLocalRoot(options: LocalProtocolOptions, platform: NodeJS
 	return path.join(os.tmpdir(), "omp-local", safeSessionId(options));
 }
 
+/**
+ * Recursively copy every local:// artifact from one session-scoped root to
+ * another. Used when a session transition mints a fresh local root (plan
+ * approve-and-execute, handoff) so plans, scratch files, and research notes the
+ * carried-forward context references stay readable in the replacement session.
+ * No-op when the roots match or the source root is absent.
+ */
+export async function copyLocalArtifacts(sourceRoot: string, destinationRoot: string): Promise<void> {
+	if (sourceRoot === destinationRoot) return;
+
+	let sourceRootStat: { isDirectory(): boolean };
+	try {
+		sourceRootStat = await fs.lstat(sourceRoot);
+	} catch (error) {
+		if (isEnoent(error)) return;
+		throw error;
+	}
+	if (!sourceRootStat.isDirectory()) return;
+
+	await fs.mkdir(destinationRoot, { recursive: true });
+	await copyLocalArtifactEntries(sourceRoot, destinationRoot);
+}
+
+async function copyLocalArtifactEntries(sourceDir: string, destinationDir: string): Promise<void> {
+	const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const sourcePath = path.join(sourceDir, entry.name);
+		const destinationPath = path.join(destinationDir, entry.name);
+
+		if (entry.isDirectory()) {
+			await fs.mkdir(destinationPath, { recursive: true });
+			await copyLocalArtifactEntries(sourcePath, destinationPath);
+			continue;
+		}
+
+		if (entry.isFile()) {
+			await fs.mkdir(path.dirname(destinationPath), { recursive: true });
+			await fs.copyFile(sourcePath, destinationPath);
+		}
+	}
+}
+
 /** Resolve a local:// URL to an on-disk path under the active session's local root. */
 export function resolveLocalUrlToPath(
 	input: string | InternalUrl,

package/src/live/prompts/live-instructions.md

@@ -1,23 +1,23 @@
-You are omp Live, the realtime voice surface of one unified coding assistant for {{firstName}} (OS account: {{username}}).
+You: omp Live, realtime voice surface of one unified coding assistant for {{firstName}} (OS account: {{username}}).
 
 <system-conventions>
-RFC 2119 applies to MUST, REQUIRED, SHOULD, RECOMMENDED, MAY, and OPTIONAL. `NEVER` means `MUST NOT`.
+RFC 2119: MUST, REQUIRED, SHOULD, RECOMMENDED, MAY, OPTIONAL. `NEVER` = `MUST NOT`.
 </system-conventions>
 
 <critical>
-- You and the omp coding agent are one assistant, not separate agents.
-- You MUST delegate repository work, coding, tool use, and verification to the client backend.
-- You MUST keep conversation natural while the client backend works.
+- You + omp coding agent: one assistant, not separate agents.
+- MUST delegate repository work, coding, tool use, verification to client backend.
+- MUST keep conversation natural while client backend works.
 </critical>
 
-The user is speaking to you. You MUST respond directly, briefly, and conversationally. You MUST use speech-friendly phrasing. NEVER use markdown, code blocks, or long lists. NEVER read implementation detail aloud unless requested.
+User speaks to you. MUST respond directly, briefly, conversationally, with speech-friendly phrasing. NEVER use markdown, code blocks, long lists, or read implementation detail aloud unless requested.
 
-The client backend is the same assistant's execution surface. It has the repository context, normal omp AgentSession, coding model, and tools. Coding, investigation, repository changes, commands, or verification? You MUST create a client delegation containing the complete plain-language request and all relevant conversational context. You MUST delegate promptly instead of attempting tool work yourself. A new request during active work MUST create a new delegation so it steers the same backend session.
+Client backend: same assistant's execution surface; repository context, normal omp AgentSession, coding model, tools. Coding, investigation, repository changes, commands, or verification → MUST promptly create client delegation with complete plain-language request and all relevant conversational context; NEVER attempt tool work. New request during active work MUST create new delegation, steering same backend session.
 
-You MUST treat delegation context as your own internal progress and result. NEVER describe the backend as another assistant. You MAY briefly acknowledge active work, but NEVER claim changes, findings, or verification before the backend reports them. Commentary context is silent progress for conversational continuity; NEVER recite it. Context beginning with `"Agent Final Message":` is the backend's final visible answer. You MUST present its useful result naturally as your own without mentioning the label, protocol, delegation, or backend.
+Treat delegation context as own internal progress/results. NEVER describe backend as another assistant. MAY briefly acknowledge active work; NEVER claim changes, findings, or verification before backend reports. Commentary context: silent progress for conversational continuity; NEVER recite. Context beginning with `"Agent Final Message":`: backend's final visible answer; MUST present useful result naturally as own, NEVER mention label, protocol, delegation, or backend.
 
-Greetings, clarification, or ordinary conversation requiring no repository or tools? You MUST answer directly without delegation. You MUST ask a concise clarifying question only when the execution request is genuinely underspecified.
+Greetings, clarification, ordinary conversation needing no repository/tools: MUST answer directly without delegation. MUST ask concise clarifying question only when execution request genuinely underspecified.
 
 <critical>
-You MUST preserve one-assistant continuity: converse here, delegate execution, then communicate the returned result as your own.
+MUST preserve one-assistant continuity: converse here, delegate execution, communicate returned result as own.
 </critical>

package/src/main.ts

@@ -1333,6 +1333,10 @@ export async function runRootCommand(
 	if (parsedArgs.advisor) {
 		settingsInstance.override("advisor.enabled", true);
 	}
+	// Apply --external-thinking CLI flag (ephemeral, not persisted)
+	if (parsedArgs.externalThinking) {
+		settingsInstance.override("externalThinking", true);
+	}
 
 	await logger.time(
 		"initTheme:final",

package/src/mcp/client.ts

@@ -38,8 +38,7 @@ import type {
 	MCPTransport,
 } from "./types";
 
-/** MCP protocol version we support */
-const PROTOCOL_VERSION = "2025-03-26";
+import { MCP_PROTOCOL_VERSION } from "./types";
 
 /** Client info sent during initialization */
 const CLIENT_INFO = {
@@ -98,7 +97,7 @@ async function initializeConnection(
 	},
 ): Promise<MCPInitializeResult> {
 	const params: MCPInitializeParams = {
-		protocolVersion: PROTOCOL_VERSION,
+		protocolVersion: MCP_PROTOCOL_VERSION,
 		capabilities: {
 			roots: { listChanged: false },
 		},
@@ -115,6 +114,11 @@ async function initializeConnection(
 		throw options.signal.reason instanceof Error ? options.signal.reason : new Error("Aborted");
 	}
 
+	// Echo the negotiated protocol version on every subsequent request. The MCP
+	// Streamable HTTP spec requires the MCP-Protocol-Version header after
+	// initialize; transports that don't need it ignore this.
+	transport.setProtocolVersion?.(result.protocolVersion);
+
 	// Hook point: the transport now has the session ID from the initialize response.
 	// For HTTP, this is the moment to open the SSE stream so server-to-client requests
 	// triggered by notifications/initialized (e.g. roots/list) can be delivered.

package/src/mcp/transports/header-policy.ts

@@ -48,6 +48,34 @@ export function setGeneratedHeader(headers: Record<string, string>, name: string
 	headers[name] = value;
 }
 
+/**
+ * Return `headers` without any entry whose name case-insensitively matches
+ * `name`. Used to keep transport-reserved protocol headers (e.g.
+ * `MCP-Protocol-Version`) out of user-configured headers so config can never
+ * inject them. Returns the original reference when there is nothing to strip,
+ * so the common (no-match) path allocates nothing.
+ */
+export function withoutHeader(
+	headers: Record<string, string> | undefined,
+	name: string,
+): Record<string, string> | undefined {
+	if (!headers) return headers;
+	const lower = name.toLowerCase();
+	let hasMatch = false;
+	for (const key in headers) {
+		if (key.toLowerCase() === lower) {
+			hasMatch = true;
+			break;
+		}
+	}
+	if (!hasMatch) return headers;
+	const result: Record<string, string> = {};
+	for (const key in headers) {
+		if (key.toLowerCase() !== lower) result[key] = headers[key];
+	}
+	return result;
+}
+
 const REDIRECT_STATUSES: Record<number, true> = { 301: true, 302: true, 303: true, 307: true, 308: true };
 const MAX_REDIRECT_HOPS = 5;