@oh-my-pi/pi-coding-agent 16.1.13 → 16.1.15

package/dist/types/web/parallel.d.ts

@@ -1,5 +1,7 @@
 import { type FetchImpl } from "@oh-my-pi/pi-ai";
 import type { AgentStorage } from "../session/agent-storage";
+export declare const PARALLEL_SEARCH_URL = "https://api.parallel.ai/v1beta/search";
+export declare const PARALLEL_BETA_HEADER = "search-extract-2025-10-10";
 export interface ParallelUsageItem {
     name?: string;
     count?: number;
@@ -55,6 +57,10 @@ export declare class ParallelApiError extends Error {
     readonly statusCode?: number;
     constructor(message: string, statusCode?: number);
 }
+export declare function parseParallelErrorResponse(statusCode: number, responseText: string): ParallelApiError;
+export declare function parseParallelSearchPayload(payload: unknown, options?: {
+    parseMetadata?: boolean;
+}): ParallelSearchResult;
 export declare function findParallelApiKey(storage: AgentStorage | null | undefined): string | null;
 export declare function getParallelExtractContent(document: ParallelExtractDocument): string;
 export declare function searchWithParallel(objective: string, queries: string[], options: ParallelSearchOptions, storage: AgentStorage | null | undefined): Promise<ParallelSearchResult>;

package/dist/types/web/search/providers/perplexity.d.ts

@@ -33,11 +33,25 @@ export declare function searchPerplexity(params: PerplexitySearchParams): Promis
 export declare class PerplexityProvider extends SearchProvider {
     readonly id = "perplexity";
     readonly label = "Perplexity";
+    /**
+     * Auto-chain admission. Requires a direct Perplexity credential
+     * (`PERPLEXITY_COOKIES`, OAuth session, or `PERPLEXITY_API_KEY`).
+     *
+     * OpenRouter auth is intentionally NOT accepted here: silently using
+     * OpenRouter's `perplexity/sonar-pro` whenever any OpenRouter key is
+     * configured surprises users (and bills them) for a path they never
+     * asked for. The auto chain skips Perplexity in that case and falls
+     * through to the next configured provider. Users who DO want the
+     * OpenRouter-backed Perplexity path can still opt in by setting
+     * `webSearch: perplexity` explicitly — see {@link isExplicitlyAvailable}.
+     */
     isAvailable(authStorage: AuthStorage): boolean;
     /**
-     * Perplexity accepts anonymous browser-style ask requests, but keep auto
-     * provider selection credential-gated so a configured provider keeps priority
-     * over the anonymous fallback.
+     * Perplexity accepts anonymous browser-style ask requests, and the
+     * OpenRouter-backed `perplexity/sonar-pro` path is opt-in through
+     * explicit selection. Keep auto-chain admission credential-gated so a
+     * configured provider keeps priority over the anonymous/OpenRouter
+     * fallbacks.
      */
     isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
     search(params: SearchParams): Promise<SearchResponse>;

package/package.json

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

package/src/advisor/__tests__/advisor.test.ts

@@ -3,6 +3,7 @@ import type { AgentMessage, AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core
 import { type } from "arktype";
 import { createAdvisorMessageCard } from "../../modes/components/advisor-message";
 import { getThemeByName } from "../../modes/theme/theme";
+import { SecretObfuscator } from "../../secrets/obfuscator";
 import { formatSessionHistoryMarkdown } from "../../session/session-history-format";
 import { YieldQueue } from "../../session/yield-queue";
 import {
@@ -447,6 +448,119 @@ describe("advisor", () => {
 			expect(promptInputs[0]).not.toContain("note");
 		});
 
+		it("obfuscates session updates before prompting the advisor", async () => {
+			const secret = "ADVISOR_SECRET_TOKEN_123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [{ role: "user", content: `token ${secret}`, timestamp: 1 } as AgentMessage];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+		});
+
+		it("redacts expanded primary context before XML escaping", async () => {
+			const secret = "ADVISOR&SECRET<TOKEN>123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [
+				{
+					role: "custom",
+					customType: "plan-mode-context",
+					content: `Plan mode carries ${secret}`,
+					display: false,
+					timestamp: 1,
+				} as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+			expect(promptInputs[0]).not.toContain("ADVISOR&amp;SECRET&lt;TOKEN&gt;123");
+		});
+
+		it("redacts file-mention paths before formatting", async () => {
+			const secret = "MENTION_SECRET_TOKEN_123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [
+				{
+					role: "fileMention",
+					files: [{ path: `notes/${secret}.txt`, content: "ignored" }],
+					timestamp: 1,
+				} as unknown as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+		});
+
+		it("redacts nested async-result job labels before formatting", async () => {
+			const secret = "JOB_LABEL_SECRET_TOKEN_123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [
+				{
+					role: "custom",
+					customType: "async-result",
+					content: "",
+					details: { jobs: [{ label: `bash: echo ${secret}`, jobId: "j1" }] },
+					display: true,
+					attribution: "agent",
+					timestamp: 1,
+				} as unknown as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+		});
+
 		it("expands plan-mode context once, then collapses an unchanged re-injection", async () => {
 			const promptInputs: string[] = [];
 			const agent = makeAgent(promptInputs);

package/src/advisor/runtime.ts

@@ -1,6 +1,8 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
+import type { AssistantMessage, ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
+import { obfuscateToolArguments, type SecretObfuscator } from "../secrets/obfuscator";
 import { formatSessionHistoryMarkdown, PRIMARY_CONTEXT_CUSTOM_TYPES } from "../session/session-history-format";
 
 /** Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core `Agent`. */
@@ -16,6 +18,8 @@ export interface AdvisorRuntimeHost {
 	snapshotMessages(): AgentMessage[];
 	/** Surface one advice note to the primary (enqueues into the session YieldQueue). */
 	enqueueAdvice(note: string, severity?: "nit" | "concern" | "blocker"): void;
+	/** Redact primary transcript bytes before they reach the advisor model. */
+	obfuscator?: SecretObfuscator;
 	/**
 	 * Pre-prompt context maintenance for the advisor's own append-only context.
 	 * Promotes the advisor model to a larger sibling when its context nears the
@@ -174,7 +178,9 @@ export class AdvisorRuntime {
 			.map(m => this.#dedupContextMessage(m));
 		this.#lastCount = all.length;
 		if (delta.length === 0) return null;
-		const md = formatSessionHistoryMarkdown(delta, {
+		const obfuscator = this.host.obfuscator;
+		const formattedDelta = obfuscator?.hasSecrets() ? obfuscateAdvisorDelta(obfuscator, delta) : delta;
+		const md = formatSessionHistoryMarkdown(formattedDelta, {
 			includeThinking: true,
 			includeToolIntent: true,
 			watchedRoles: true,
@@ -304,3 +310,125 @@ export class AdvisorRuntime {
 		}
 	}
 }
+
+type TextualContent = string | readonly (TextContent | ImageContent)[];
+
+function obfuscateTextualContent(obfuscator: SecretObfuscator, content: TextualContent): TextualContent {
+	if (typeof content === "string") return obfuscator.obfuscate(content);
+	let changed = false;
+	const result = content.map((block): TextContent | ImageContent => {
+		if (block.type !== "text") return block;
+		const text = obfuscator.obfuscate(block.text);
+		if (text === block.text) return block;
+		changed = true;
+		return { ...block, text };
+	});
+	return changed ? result : content;
+}
+
+function obfuscateAssistantMessage(obfuscator: SecretObfuscator, message: AssistantMessage): AssistantMessage {
+	let changed = false;
+	const content = message.content.map((block): AssistantMessage["content"][number] => {
+		if (block.type === "text") {
+			const text = obfuscator.obfuscate(block.text);
+			if (text === block.text) return block;
+			changed = true;
+			return { ...block, text };
+		}
+		if (block.type === "toolCall") {
+			const args = obfuscateToolArguments(obfuscator, block.arguments);
+			if (args === block.arguments) return block;
+			changed = true;
+			return { ...block, arguments: args };
+		}
+		return block;
+	});
+	return changed ? { ...message, content } : message;
+}
+
+function obfuscateDetails(
+	obfuscator: SecretObfuscator,
+	details: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+	if (!details) return details;
+	// Walk strings at every depth: `customOneLiner` renders nested fields
+	// (e.g. `async-result` reads `details.jobs[].label`/`jobId`), so a shallow
+	// pass leaks any secret a background job's label happens to contain.
+	return obfuscateToolArguments(obfuscator, details);
+}
+
+function obfuscateAdvisorMessage(obfuscator: SecretObfuscator, message: AgentMessage): AgentMessage {
+	switch (message.role) {
+		case "user":
+		case "developer":
+		case "toolResult": {
+			const content = obfuscateTextualContent(obfuscator, message.content as TextualContent);
+			return content === message.content ? message : ({ ...(message as object), content } as AgentMessage);
+		}
+		case "assistant":
+			return obfuscateAssistantMessage(obfuscator, message as AssistantMessage) as AgentMessage;
+		case "custom":
+		case "hookMessage": {
+			const msg = message as AgentMessage & {
+				content: TextualContent;
+				details?: Record<string, unknown>;
+			};
+			const content = obfuscateTextualContent(obfuscator, msg.content);
+			const details = obfuscateDetails(obfuscator, msg.details);
+			if (content === msg.content && details === msg.details) return message;
+			return { ...(message as object), content, details } as AgentMessage;
+		}
+		case "bashExecution": {
+			const msg = message as AgentMessage & { command: string; output: string };
+			const command = obfuscator.obfuscate(msg.command);
+			const output = obfuscator.obfuscate(msg.output);
+			return command === msg.command && output === msg.output
+				? message
+				: ({ ...(message as object), command, output } as AgentMessage);
+		}
+		case "pythonExecution": {
+			const msg = message as AgentMessage & { code: string; output: string };
+			const code = obfuscator.obfuscate(msg.code);
+			const output = obfuscator.obfuscate(msg.output);
+			return code === msg.code && output === msg.output
+				? message
+				: ({ ...(message as object), code, output } as AgentMessage);
+		}
+		case "branchSummary": {
+			const msg = message as AgentMessage & { summary: string };
+			const summary = obfuscator.obfuscate(msg.summary);
+			return summary === msg.summary ? message : ({ ...(message as object), summary } as AgentMessage);
+		}
+		case "compactionSummary": {
+			const msg = message as AgentMessage & { summary: string };
+			const summary = obfuscator.obfuscate(msg.summary);
+			return summary === msg.summary ? message : ({ ...(message as object), summary } as AgentMessage);
+		}
+		case "fileMention": {
+			const msg = message as AgentMessage & {
+				files: Array<{ path: string; content: string; image?: unknown }>;
+			};
+			let changed = false;
+			const files = msg.files.map(file => {
+				const path = obfuscator.obfuscate(file.path);
+				const content = obfuscator.obfuscate(file.content);
+				if (path === file.path && content === file.content) return file;
+				changed = true;
+				return { ...file, path, content };
+			});
+			return changed ? ({ ...(message as object), files } as AgentMessage) : message;
+		}
+		default:
+			return message;
+	}
+}
+
+function obfuscateAdvisorDelta(obfuscator: SecretObfuscator, messages: AgentMessage[]): AgentMessage[] {
+	let changed = false;
+	const result = messages.map(message => {
+		const next = obfuscateAdvisorMessage(obfuscator, message);
+		if (next !== message) changed = true;
+		return next;
+	});
+	return changed ? result : messages;
+}

package/src/config/model-registry.ts

@@ -992,6 +992,7 @@ export class ModelRegistry {
 				});
 				continue;
 			}
+			const configStale = this.#isDiscoveryCacheOlderThanModelsConfig(cache.updatedAt);
 			const models = this.#applyProviderModelOverrides(
 				providerConfig.provider,
 				this.#normalizeDiscoverableModels(
@@ -1007,7 +1008,7 @@ export class ModelRegistry {
 				provider: providerConfig.provider,
 				status: "cached",
 				optional: providerConfig.optional ?? false,
-				stale: !cache.fresh || !cache.authoritative,
+				stale: !cache.fresh || !cache.authoritative || configStale,
 				fetchedAt: cache.updatedAt,
 				models: models.map(model => model.id),
 			});
@@ -1259,12 +1260,19 @@ export class ModelRegistry {
 		return providerConfig.provider;
 	}
 
+	#isDiscoveryCacheOlderThanModelsConfig(cacheUpdatedAt: number): boolean {
+		const configMtime = this.#modelsConfigFile.getMtimeMs();
+		return configMtime !== null && cacheUpdatedAt < Math.floor(configMtime);
+	}
+
 	async #discoverProviderModels(
 		providerConfig: DiscoveryProviderConfig,
 		strategy: ModelRefreshStrategy,
 	): Promise<Model<Api>[]> {
 		const cacheProviderId = this.#configuredDiscoveryCacheProviderId(providerConfig);
 		const cached = readModelCache<Api>(cacheProviderId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
+		const cacheOlderThanConfig = cached !== null && this.#isDiscoveryCacheOlderThanModelsConfig(cached.updatedAt);
+		const effectiveStrategy = strategy === "online-if-uncached" && cacheOlderThanConfig ? "online" : strategy;
 		const requiresAuth = !this.#keylessProviders.has(providerConfig.provider);
 		if (requiresAuth) {
 			const apiKey = await this.#peekApiKeyForProvider(providerConfig.provider);
@@ -1311,12 +1319,12 @@ export class ModelRegistry {
 			cacheTtlMs: 24 * 60 * 60 * 1000,
 			fetchDynamicModels,
 		});
-		const result = await manager.refresh(strategy);
+		const result = await manager.refresh(effectiveStrategy);
 		const status = discoveryError
 			? result.models.length > 0
 				? "cached"
 				: "unavailable"
-			: strategy === "offline"
+			: effectiveStrategy === "offline"
 				? cached
 					? "cached"
 					: "idle"
@@ -1327,7 +1335,7 @@ export class ModelRegistry {
 			provider: providerId,
 			status,
 			optional: providerConfig.optional ?? false,
-			stale: result.stale || status === "cached",
+			stale: result.stale || status === "cached" || (cacheOlderThanConfig && status !== "ok"),
 			fetchedAt: discoveryError ? cached?.updatedAt : Date.now(),
 			models: result.models.map(model => model.id),
 			error: discoveryError,

package/src/config/settings-schema.ts

@@ -122,7 +122,7 @@ export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 	context: ["General", "Compaction", "Rules (TTSR)", "Experimental"],
 	memory: ["General", "Auto-Learn", "Mnemopi", "Hindsight"],
 	files: ["Editing", "Reading", "Read Summaries", "LSP"],
-	shell: ["Bash", "Eval & Python"],
+	shell: ["Bash", "Eval & Runtimes"],
 	tools: [
 		"Available Tools",
 		"Todos",
@@ -1592,6 +1592,30 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"share.store": {
+		type: "enum",
+		values: ["blob", "gist"] as const,
+		default: "blob",
+		ui: {
+			tab: "interaction",
+			group: "Collab",
+			label: "Share Store",
+			description: "Where /share uploads the encrypted session blob",
+			options: [
+				{
+					value: "blob",
+					label: "Encrypted Blob",
+					description: "Upload to the share server (no GitHub account needed; avoids gist API rate limits)",
+				},
+				{
+					value: "gist",
+					label: "GitHub Gist",
+					description: "Push to a secret gist (needs authenticated gh), falling back to the share server",
+				},
+			],
+		},
+	},
+
 	"share.redactSecrets": {
 		type: "boolean",
 		default: true,
@@ -2703,18 +2727,6 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	readHashLines: {
-		type: "boolean",
-		default: true,
-		ui: {
-			tab: "files",
-			group: "Reading",
-			label: "Hash Lines",
-			description:
-				"Include snapshot-tag headers and line numbers in read output for hashline edit mode ([PATH#TAG] plus LINE:content)",
-		},
-	},
-
 	"read.defaultLimit": {
 		type: "number",
 		default: 300,
@@ -2981,7 +2993,7 @@ export const SETTINGS_SCHEMA = {
 		default: true,
 		ui: {
 			tab: "shell",
-			group: "Eval & Python",
+			group: "Eval & Runtimes",
 			label: "Python Eval Backend",
 			description: "Allow the eval tool to dispatch Python cells to the IPython kernel",
 		},
@@ -2992,20 +3004,42 @@ export const SETTINGS_SCHEMA = {
 		default: true,
 		ui: {
 			tab: "shell",
-			group: "Eval & Python",
+			group: "Eval & Runtimes",
 			label: "JavaScript Eval Backend",
 			description: "Allow the eval tool to dispatch JavaScript cells to the in-process runtime",
 		},
 	},
 
-	// Python kernel knobs (consumed by the eval py backend and the /python slash command)
+	"eval.rb": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "shell",
+			group: "Eval & Runtimes",
+			label: "Ruby Eval Backend",
+			description: "Allow the eval tool to dispatch Ruby cells to the persistent Ruby kernel",
+		},
+	},
+
+	"eval.jl": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "shell",
+			group: "Eval & Runtimes",
+			label: "Julia Eval Backend",
+			description: "Allow the eval tool to dispatch Julia cells to the persistent Julia kernel",
+		},
+	},
+
+	// Runtime knobs (consumed by eval backends and the /python slash command)
 	"python.kernelMode": {
 		type: "enum",
 		values: ["session", "per-call"] as const,
 		default: "session",
 		ui: {
 			tab: "shell",
-			group: "Eval & Python",
+			group: "Eval & Runtimes",
 			label: "Python Kernel Mode",
 			description: "Keep the IPython kernel alive across eval calls or start fresh each time",
 		},
@@ -3015,12 +3049,34 @@ export const SETTINGS_SCHEMA = {
 		default: "",
 		ui: {
 			tab: "shell",
-			group: "Eval & Python",
+			group: "Eval & Runtimes",
 			label: "Python Interpreter",
 			description:
 				"Optional path to an exact Python executable. When set, automatic Python runtime discovery is skipped.",
 		},
 	},
+	"ruby.interpreter": {
+		type: "string",
+		default: "",
+		ui: {
+			tab: "shell",
+			group: "Eval & Runtimes",
+			label: "Ruby Interpreter",
+			description:
+				"Optional path to an exact Ruby executable. When set, automatic Ruby runtime discovery is skipped.",
+		},
+	},
+	"julia.interpreter": {
+		type: "string",
+		default: "",
+		ui: {
+			tab: "shell",
+			group: "Eval & Runtimes",
+			label: "Julia Interpreter",
+			description:
+				"Optional path to an exact Julia executable. When set, automatic Julia runtime discovery is skipped.",
+		},
+	},
 
 	// ────────────────────────────────────────────────────────────────────────
 	// Tools

package/src/config/settings.ts

@@ -949,6 +949,11 @@ export class Settings {
 			delete raw["power.preventDisplaySleep"];
 		}
 
+		// readHashLines: removed. Hashline anchors are now driven solely by
+		// edit.mode === "hashline"; the separate read toggle only ever produced
+		// the incoherent "hashline edits without addressable anchors" state.
+		delete raw.readHashLines;
+
 		return raw;
 	}