@oh-my-pi/pi-coding-agent 16.1.16 → 16.1.17

package/src/hindsight/content.ts

@@ -189,6 +189,22 @@ export interface RetentionTranscript {
  * Messages are tag-stripped before framing to break the recall→retain loop.
  * Returns `{ transcript: null }` when nothing meaningful survives.
  */
+function formatRetentionMessages(messages: HindsightMessage[]): RetentionTranscript {
+	const parts: string[] = [];
+	for (const msg of messages) {
+		const content = stripMemoryTags(msg.content).trim();
+		if (!hasSubstantiveContent(content)) continue;
+		parts.push(`[role: ${msg.role}]\n${content}\n[${msg.role}:end]`);
+	}
+
+	if (parts.length === 0) return { transcript: null, messageCount: 0 };
+
+	const transcript = parts.join("\n\n");
+	if (transcript.trim().length < 10) return { transcript: null, messageCount: 0 };
+
+	return { transcript, messageCount: parts.length };
+}
+
 export function prepareRetentionTranscript(
 	messages: HindsightMessage[],
 	retainFullWindow = false,
@@ -210,17 +226,10 @@ export function prepareRetentionTranscript(
 		targetMessages = messages.slice(lastUserIdx);
 	}
 
-	const parts: string[] = [];
-	for (const msg of targetMessages) {
-		const content = stripMemoryTags(msg.content).trim();
-		if (!hasSubstantiveContent(content)) continue;
-		parts.push(`[role: ${msg.role}]\n${content}\n[${msg.role}:end]`);
-	}
-
-	if (parts.length === 0) return { transcript: null, messageCount: 0 };
-
-	const transcript = parts.join("\n\n");
-	if (transcript.trim().length < 10) return { transcript: null, messageCount: 0 };
+	return formatRetentionMessages(targetMessages);
+}
 
-	return { transcript, messageCount: parts.length };
+/** Format only user-authored messages for memory fact/entity extraction. */
+export function prepareUserRetentionTranscript(messages: HindsightMessage[]): RetentionTranscript {
+	return formatRetentionMessages(messages.filter(message => message.role === "user"));
 }

package/src/mcp/tool-bridge.ts

@@ -58,6 +58,31 @@ function normalizeToolArgs(value: unknown): MCPToolArgs {
 	return value as MCPToolArgs;
 }
 
+function isUnusedOptionalPlaceholder(value: unknown): boolean {
+	return (
+		value === undefined ||
+		value === "" ||
+		(typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0)
+	);
+}
+
+function omitUnusedOptionalArgs(args: MCPToolArgs, inputSchema: MCPToolDefinition["inputSchema"]): MCPToolArgs {
+	const properties = inputSchema.properties;
+	if (!properties) return args;
+
+	let cleaned: MCPToolArgs | undefined;
+	const required = new Set(inputSchema.required ?? []);
+	for (const [key, value] of Object.entries(args)) {
+		if (required.has(key) || !Object.hasOwn(properties, key) || !isUnusedOptionalPlaceholder(value)) {
+			continue;
+		}
+		cleaned ??= { ...args };
+		delete cleaned[key];
+	}
+
+	return cleaned ?? args;
+}
+
 /** Details included in MCP tool results for rendering */
 export interface MCPToolDetails {
 	/** Server name */
@@ -261,7 +286,7 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		signal?: AbortSignal,
 	): Promise<CustomToolResult<MCPToolDetails>> {
 		throwIfAborted(signal);
-		const args = normalizeToolArgs(params);
+		const args = omitUnusedOptionalArgs(normalizeToolArgs(params), this.tool.inputSchema);
 		const provider = this.connection._source?.provider;
 		const providerName = this.connection._source?.providerName;
 
@@ -360,7 +385,7 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		signal?: AbortSignal,
 	): Promise<CustomToolResult<MCPToolDetails>> {
 		throwIfAborted(signal);
-		const args = normalizeToolArgs(params);
+		const args = omitUnusedOptionalArgs(normalizeToolArgs(params), this.tool.inputSchema);
 		const provider = this.#fallbackProvider;
 		const providerName = this.#fallbackProviderName;
 

package/src/mnemopi/state.ts

@@ -9,6 +9,7 @@ import {
 	composeRecallQuery,
 	formatCurrentTime,
 	prepareRetentionTranscript,
+	prepareUserRetentionTranscript,
 	truncateRecallQuery,
 } from "../hindsight/content";
 import { extractMessages } from "../hindsight/transcript";
@@ -352,6 +353,7 @@ export class MnemopiSessionState {
 	async retainMessages(messages: Array<{ role: string; content: string }>, sourceId: string): Promise<void> {
 		const { transcript, messageCount } = prepareRetentionTranscript(messages, true);
 		if (!transcript) return;
+		const { transcript: extractText } = prepareUserRetentionTranscript(messages);
 		this.rememberInScope(transcript, {
 			source: "coding-agent-transcript",
 			importance: 0.65,
@@ -362,8 +364,9 @@ export class MnemopiSessionState {
 				cwd: this.session.sessionManager.getCwd(),
 			},
 			scope: "bank",
-			extract: true,
-			extractEntities: true,
+			extract: extractText !== null,
+			extractEntities: extractText !== null,
+			extractText,
 			veracity: "unknown",
 			memoryType: "episode",
 		});

package/src/modes/components/agent-transcript-viewer.ts

@@ -7,16 +7,11 @@
  * compositing into the live transcript's scrollback. It renders a parked
  * subagent / advisor / collab-guest transcript that has no live in-view session.
  *
- * The transcript is rebuilt from scratch on every refresh ({@link ChatTranscriptBuilder.rebuild})
- * rather than synced incrementally, so a growing file-backed transcript (the
- * advisor appends while you watch) can never duplicate or misorder rows. Scroll
- * is owned end-to-end by a single {@link ScrollView}; the viewer follows the tail
- * until the reader scrolls up.
- *
- * Local agents re-read the whole session file whenever its size or mtime changes
- * (covering SessionManager's in-place rewrites, not just appends). Collab guests
- * keep the incremental byte cursor the host's capped `readTranscript` requires
- * and rebuild components from the accumulated entries.
+ * Local transcripts tail append-only growth: unchanged file identity plus stable
+ * sentinels means only newly appended JSONL is parsed and rendered. Rewrites,
+ * truncation, rotation, or sentinel drift fall back to a full rebuild so changed
+ * historical entries cannot leave stale components behind. Collab guests use the
+ * same append path over the host's byte-capped transcript reads.
  */
 import * as fs from "node:fs";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
@@ -64,6 +59,56 @@ export interface AgentTranscriptViewerDeps {
 /** How often to re-stat a file-backed transcript for growth (advisor/live tail). */
 const POLL_MS = 250;
 
+const SENTINEL_BYTES = 4096;
+
+interface LocalTranscriptSentinel {
+	offset: number;
+	bytes: Buffer;
+}
+
+interface LocalTranscriptState {
+	path: string;
+	dev: number;
+	ino: number;
+	size: number;
+	mtimeMs: number;
+	offset: number;
+	pending: string;
+	sentinels: LocalTranscriptSentinel[];
+}
+
+function readFileRangeSync(file: string, offset: number, length: number): Buffer {
+	if (length <= 0) return Buffer.alloc(0);
+	const fd = fs.openSync(file, "r");
+	try {
+		const buffer = Buffer.alloc(length);
+		const bytesRead = fs.readSync(fd, buffer, 0, length, offset);
+		return bytesRead === length ? buffer : buffer.subarray(0, bytesRead);
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+
+function sentinelOffsets(size: number): number[] {
+	if (size <= 0) return [];
+	const length = Math.min(SENTINEL_BYTES, size);
+	return [...new Set([0, Math.max(0, Math.floor((size - length) / 2)), Math.max(0, size - length)])];
+}
+
+function sentinelsFromBuffer(buffer: Buffer): LocalTranscriptSentinel[] {
+	const size = buffer.byteLength;
+	const length = Math.min(SENTINEL_BYTES, size);
+	return sentinelOffsets(size).map(offset => ({
+		offset,
+		bytes: Buffer.from(buffer.subarray(offset, offset + length)),
+	}));
+}
+
+function sentinelsFromFile(file: string, size: number): LocalTranscriptSentinel[] {
+	const length = Math.min(SENTINEL_BYTES, size);
+	return sentinelOffsets(size).map(offset => ({ offset, bytes: readFileRangeSync(file, offset, length) }));
+}
+
 function statusBadge(status: AgentStatus): string {
 	switch (status) {
 		case "running":
@@ -85,10 +130,9 @@ export class AgentTranscriptViewer implements Component {
 	#notice: string | undefined;
 	#expanded = false;
 
-	// Local file transcript state: re-read when the file size or mtime changes.
-	#lastSignature = "";
+	#localState: LocalTranscriptState | undefined;
+	#localUnavailable = "";
 	// Remote transcript state (incremental; the host caps each read).
-	#remoteEntries: SessionMessageEntry[] = [];
 	#remoteBytes = 0;
 	#remoteFetchInFlight = false;
 	#remoteToken = 0;
@@ -145,7 +189,7 @@ export class AgentTranscriptViewer implements Component {
 	// Transcript loading
 	// ========================================================================
 
-	/** Re-read the transcript and rebuild components when it changed. */
+	/** Refresh the transcript from a local file or remote host. */
 	#refresh(): void {
 		if (this.#disposed) return;
 		if (this.deps.remote) {
@@ -154,39 +198,132 @@ export class AgentTranscriptViewer implements Component {
 		}
 		const sessionFile = this.deps.registry.get(this.deps.agentId)?.sessionFile;
 		if (!sessionFile) {
-			if (this.#lastSignature !== "none") {
-				this.#lastSignature = "none";
-				this.#rebuild([]);
-			}
+			this.#clearLocal("none");
 			return;
 		}
-		let signature: string;
+		let stat: fs.Stats;
 		try {
-			const stat = fs.statSync(sessionFile);
-			// Include the path: a different file with the same size/mtime must not alias.
-			signature = `${sessionFile}:${stat.size}:${stat.mtimeMs}`;
+			stat = fs.statSync(sessionFile);
 		} catch {
-			// File deleted/rotated while open (e.g. the owning session was dropped):
-			// clear stale content once instead of freezing on it forever.
-			if (this.#lastSignature !== "missing") {
-				this.#lastSignature = "missing";
-				this.#model = undefined;
-				this.#rebuild([]);
-			}
+			this.#clearLocal("missing");
 			return;
 		}
-		if (signature === this.#lastSignature) return;
-		let text: string;
+		const state = this.#localState;
+		if (state && this.#canAppendLocal(sessionFile, stat, state)) {
+			if (stat.size === state.size && stat.mtimeMs === state.mtimeMs) return;
+			if (stat.size > state.size) {
+				this.#appendLocal(sessionFile, stat, state);
+				return;
+			}
+		}
+		this.#loadLocalFull(sessionFile, stat);
+	}
+
+	#clearLocal(reason: string): void {
+		if (!this.#localState && this.#localUnavailable === reason) return;
+		this.#localState = undefined;
+		this.#localUnavailable = reason;
+		this.#model = undefined;
+		this.#rebuild([]);
+	}
+
+	#canAppendLocal(sessionFile: string, stat: fs.Stats, state: LocalTranscriptState): boolean {
+		if (state.path !== sessionFile || state.dev !== stat.dev || state.ino !== stat.ino || stat.size < state.size)
+			return false;
+		for (const sentinel of state.sentinels) {
+			let current: Buffer;
+			try {
+				current = readFileRangeSync(sessionFile, sentinel.offset, sentinel.bytes.byteLength);
+			} catch (err) {
+				// The file can be unlinked/rotated between statSync and this read.
+				// Treat as not-appendable so #refresh falls back to a guarded full load.
+				logger.debug("transcript viewer: sentinel read failed", { err: String(err) });
+				return false;
+			}
+			if (!current.equals(sentinel.bytes)) return false;
+		}
+		return true;
+	}
+
+	#loadLocalFull(sessionFile: string, stat: fs.Stats): void {
+		let data: Buffer;
 		try {
-			text = fs.readFileSync(sessionFile, "utf-8");
+			data = fs.readFileSync(sessionFile);
 		} catch (err) {
-			// Leave #lastSignature unchanged so a transient read error retries next poll.
+			// Leave #localState unchanged so a transient read error retries next poll.
 			logger.debug("transcript viewer: read failed", { err: String(err) });
 			return;
 		}
-		this.#lastSignature = signature;
+		// The file may have grown between the earlier `statSync` and this read.
+		// Anchor the tail cursor to what we actually consumed so the next poll's
+		// `#appendLocal` never re-renders bytes already in the rebuilt transcript;
+		// re-stat for mtime/identity so the post-read clock matches what's on disk.
+		let post: fs.Stats;
+		try {
+			post = fs.statSync(sessionFile);
+		} catch {
+			post = stat;
+		}
+		// A reader that opens the file mid-append sees a trailing partial line
+		// (no terminating newline). Carry those bytes as `pending` so the next
+		// poll's `#appendLocal` joins them with the completion bytes instead of
+		// parsing a headless line fragment and dropping the entry.
+		const text = data.toString("utf-8");
+		const lastNewline = text.lastIndexOf("\n");
+		const complete = lastNewline >= 0 ? text.slice(0, lastNewline + 1) : "";
+		const pending = lastNewline >= 0 ? text.slice(lastNewline + 1) : text;
+		this.#localUnavailable = "";
+		this.#localState = {
+			path: sessionFile,
+			dev: post.dev,
+			ino: post.ino,
+			size: data.byteLength,
+			mtimeMs: post.mtimeMs,
+			offset: data.byteLength,
+			pending,
+			sentinels: sentinelsFromBuffer(data),
+		};
 		this.#model = undefined;
-		this.#rebuild(this.#extractMessages(parseSessionEntries(text)));
+		this.#rebuild(this.#extractMessages(parseSessionEntries(complete)));
+	}
+
+	#appendLocal(sessionFile: string, stat: fs.Stats, state: LocalTranscriptState): void {
+		let chunk: string;
+		try {
+			chunk = readFileRangeSync(sessionFile, state.offset, stat.size - state.offset).toString("utf-8");
+		} catch (err) {
+			logger.debug("transcript viewer: tail read failed", { err: String(err) });
+			this.#loadLocalFull(sessionFile, stat);
+			return;
+		}
+		const combined = state.pending + chunk;
+		const lastNewline = combined.lastIndexOf("\n");
+		const complete = lastNewline >= 0 ? combined.slice(0, lastNewline + 1) : "";
+		const previousModel = this.#model;
+		const parsed = complete ? this.#extractMessages(parseSessionEntries(complete)) : [];
+		let sentinels: LocalTranscriptSentinel[];
+		try {
+			sentinels = sentinelsFromFile(sessionFile, stat.size);
+		} catch (err) {
+			// File unlinked/rotated mid-poll: fall back to a guarded full reload
+			// instead of letting the open escape the poll timer.
+			logger.debug("transcript viewer: sentinel recompute failed", { err: String(err) });
+			this.#loadLocalFull(sessionFile, stat);
+			return;
+		}
+		this.#localState = {
+			...state,
+			size: stat.size,
+			mtimeMs: stat.mtimeMs,
+			offset: stat.size,
+			pending: lastNewline >= 0 ? combined.slice(lastNewline + 1) : combined,
+			sentinels,
+		};
+		if (parsed.length > 0) {
+			this.#append(parsed);
+		} else if (this.#model !== previousModel) {
+			this.deps.requestRender();
+		}
 	}
 
 	#fetchRemote(): void {
@@ -209,9 +346,13 @@ export class AgentTranscriptViewer implements Component {
 					return;
 				}
 				if (result.newSize < fromByte) {
-					// Host transcript rotated/truncated — restart from 0.
+					// Host transcript rotated/truncated — drop the stale rendered rows
+					// before restarting; otherwise the post-rotation fetch would stack
+					// new content under the pre-rotation history.
 					this.#remoteBytes = 0;
-					this.#remoteEntries = [];
+					this.#hasRemoteData = false;
+					this.#model = undefined;
+					this.#rebuild([]);
 					this.#fetchRemote();
 					return;
 				}
@@ -222,10 +363,14 @@ export class AgentTranscriptViewer implements Component {
 				if (lastNewline >= 0) {
 					const completeChunk = result.text.slice(0, lastNewline + 1);
 					this.#remoteBytes = fromByte + Buffer.byteLength(completeChunk, "utf-8");
+					const previousModel = this.#model;
 					const parsed = this.#extractMessages(parseSessionEntries(completeChunk));
 					if (parsed.length > 0) {
-						this.#remoteEntries.push(...parsed);
-						this.#rebuild(this.#remoteEntries);
+						this.#append(parsed);
+						return;
+					}
+					if (this.#model !== previousModel) {
+						this.deps.requestRender();
 						return;
 					}
 				}
@@ -257,6 +402,11 @@ export class AgentTranscriptViewer implements Component {
 		this.deps.requestRender();
 	}
 
+	#append(entries: SessionMessageEntry[]): void {
+		this.#builder.append(entries);
+		this.deps.requestRender();
+	}
+
 	// ========================================================================
 	// Input
 	// ========================================================================
@@ -455,8 +605,10 @@ export class AgentTranscriptViewer implements Component {
 	}
 
 	#placeholder(): string {
-		if (this.deps.remote && this.#remoteUnavailable) return "Transcript lives on the host — not available.";
-		if (this.deps.remote && !this.#hasRemoteData) return "Loading transcript from host…";
+		if (this.deps.remote) {
+			if (this.#remoteUnavailable) return "Transcript lives on the host — not available.";
+			return this.#hasRemoteData ? "No messages yet." : "Loading transcript from host…";
+		}
 		if (!this.deps.registry.get(this.deps.agentId)?.sessionFile) return "No session file available yet.";
 		return "No messages yet.";
 	}

package/src/modes/components/chat-transcript-builder.ts

@@ -103,6 +103,12 @@ export class ChatTranscriptBuilder {
 		if (this.#readArgs.size === 0 && this.#pendingTools.size === 0) this.#flushPendingUsage();
 	}
 
+	/** Append newly persisted entries without rebuilding already rendered rows. */
+	append(entries: SessionMessageEntry[]): void {
+		for (const entry of entries) this.#appendChatMessage(entry.message);
+		if (this.#readArgs.size === 0 && this.#pendingTools.size === 0) this.#flushPendingUsage();
+	}
+
 	/** Toggle tool-output expansion across every expandable component. */
 	setExpanded(expanded: boolean): void {
 		this.#expanded = expanded;

package/src/modes/components/custom-editor.test.ts

@@ -4,6 +4,7 @@ import { getEditorTheme, initTheme } from "../theme/theme";
 import {
 	CustomEditor,
 	extractBracketedImagePastePaths,
+	extractBracketedPastePaths,
 	SPACE_HOLD_MECHANICAL_RUN,
 	SPACE_HOLD_RELEASE_MS,
 	SPACE_REPEAT_MAX_GAP_MS,
@@ -73,7 +74,7 @@ describe("CustomEditor placeholder decoration", () => {
 	});
 });
 
-describe("CustomEditor bracketed image-path paste", () => {
+describe("CustomEditor bracketed path paste", () => {
 	it("leaves a pasted bare .png filename on the normal text path", () => {
 		expect(extractBracketedImagePastePaths(bracketedPaste("icon-photo-default.png"))).toBeUndefined();
 	});
@@ -86,6 +87,22 @@ describe("CustomEditor bracketed image-path paste", () => {
 			"C:\\Users\\me\\icon-photo-default.png",
 		]);
 	});
+
+	it("extracts explicit non-image paths without classifying them as image paths", () => {
+		expect(extractBracketedPastePaths(bracketedPaste("/tmp/report.csv"))).toEqual(["/tmp/report.csv"]);
+		expect(extractBracketedImagePastePaths(bracketedPaste("/tmp/report.csv"))).toBeUndefined();
+	});
+
+	it("routes non-image path pastes through the file-path hook", async () => {
+		const { editor } = makeEditor();
+		const pasted = Promise.withResolvers<string>();
+		editor.onPasteFilePath = path => pasted.resolve(path);
+
+		editor.handleInput(bracketedPaste("/tmp/report.csv"));
+
+		expect(await pasted.promise).toBe("/tmp/report.csv");
+		expect(editor.getText()).toBe("");
+	});
 });
 
 describe("CustomEditor space-hold push-to-talk", () => {

package/src/modes/components/custom-editor.ts

@@ -62,7 +62,6 @@ function buildMatchKeys(keys: readonly KeyId[]): Set<string> {
 const BRACKETED_PASTE_START = "\x1b[200~";
 const BRACKETED_PASTE_END = "\x1b[201~";
 const BRACKETED_IMAGE_PATH_REGEX = /\.(?:png|jpe?g|gif|webp)$/i;
-const BRACKETED_IMAGE_PATH_BOUNDARY_REGEX = /\.(?:png|jpe?g|gif|webp)(?=$|["']?\s)/gi;
 const SHELL_ESCAPED_PATH_CHAR_REGEX = /\\([\\\s'"()[\]{}&;<>|?*!$`])/g;
 const URI_SCHEME_REGEX = /^[a-z][a-z0-9+.-]*:/i;
 const FILE_URI_REGEX = /^file:\/\//i;
@@ -100,19 +99,7 @@ function isPastedPathSeparator(char: string | undefined): boolean {
 	return char === undefined || char === " " || char === "\t" || char === "\r" || char === "\n";
 }
 
-function imagePathBoundaryEnd(payload: string, segmentStart: number, extensionEnd: number): number | undefined {
-	const quote = payload[segmentStart];
-	const afterExtension = payload[extensionEnd];
-	if (quote === '"' || quote === "'") {
-		return afterExtension === quote && isPastedPathSeparator(payload[extensionEnd + 1])
-			? extensionEnd + 1
-			: undefined;
-	}
-	if (isPastedPathSeparator(afterExtension)) return extensionEnd;
-	return undefined;
-}
-
-function normalizePastedImagePath(path: string): string {
+function normalizePastedPath(path: string): string {
 	const trimmed = path.trim();
 	const first = trimmed[0];
 	const last = trimmed[trimmed.length - 1];
@@ -121,13 +108,60 @@ function normalizePastedImagePath(path: string): string {
 	return unquoted.replace(SHELL_ESCAPED_PATH_CHAR_REGEX, "$1");
 }
 
-function isExplicitPastedImagePath(path: string): boolean {
+function isExplicitPastedPath(path: string): boolean {
 	if (WINDOWS_DRIVE_PATH_REGEX.test(path) || FILE_URI_REGEX.test(path)) return true;
 	if (URI_SCHEME_REGEX.test(path)) return false;
 	return path.includes("/") || path.includes("\\");
 }
 
-export function extractBracketedImagePastePaths(data: string): string[] | undefined {
+function isImagePath(path: string): boolean {
+	return BRACKETED_IMAGE_PATH_REGEX.test(path);
+}
+
+function splitPastedPathSegments(payload: string): string[] | undefined {
+	const segments: string[] = [];
+	let segment = "";
+	let quote: string | undefined;
+	let escaped = false;
+
+	for (let i = 0; i < payload.length; i++) {
+		const char = payload[i];
+		if (escaped) {
+			segment += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			segment += char;
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			segment += char;
+			if (char === quote) quote = undefined;
+			continue;
+		}
+		if (char === '"' || char === "'") {
+			segment += char;
+			quote = char;
+			continue;
+		}
+		if (isPastedPathSeparator(char)) {
+			if (segment) {
+				segments.push(segment);
+				segment = "";
+			}
+			continue;
+		}
+		segment += char;
+	}
+
+	if (escaped || quote) return undefined;
+	if (segment) segments.push(segment);
+	return segments.length > 0 ? segments : undefined;
+}
+
+export function extractBracketedPastePaths(data: string): string[] | undefined {
 	if (!data.startsWith(BRACKETED_PASTE_START)) return undefined;
 	const endIndex = data.indexOf(BRACKETED_PASTE_END, BRACKETED_PASTE_START.length);
 	if (endIndex === -1 || endIndex + BRACKETED_PASTE_END.length !== data.length) return undefined;
@@ -135,33 +169,23 @@ export function extractBracketedImagePastePaths(data: string): string[] | undefi
 	const pasted = data.slice(BRACKETED_PASTE_START.length, endIndex).trim();
 	if (!pasted) return undefined;
 
+	const segments = splitPastedPathSegments(pasted);
+	if (!segments) return undefined;
+
 	const paths: string[] = [];
-	let segmentStart = 0;
-	BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.lastIndex = 0;
-	for (
-		let match = BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.exec(pasted);
-		match;
-		match = BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.exec(pasted)
-	) {
-		const extensionEnd = match.index + match[0].length;
-		const boundaryEnd = imagePathBoundaryEnd(pasted, segmentStart, extensionEnd);
-		if (boundaryEnd === undefined) continue;
-
-		const path = normalizePastedImagePath(pasted.slice(segmentStart, boundaryEnd));
-		if (!path || !BRACKETED_IMAGE_PATH_REGEX.test(path) || !isExplicitPastedImagePath(path)) return undefined;
+	for (const segment of segments) {
+		const path = normalizePastedPath(segment);
+		if (!path || !isExplicitPastedPath(path)) return undefined;
 		paths.push(path);
-
-		segmentStart = boundaryEnd;
-		while (segmentStart < pasted.length && isPastedPathSeparator(pasted[segmentStart])) {
-			segmentStart++;
-		}
-		BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.lastIndex = segmentStart;
 	}
-
-	if (paths.length === 0 || segmentStart !== pasted.length) return undefined;
 	return paths;
 }
 
+export function extractBracketedImagePastePaths(data: string): string[] | undefined {
+	const paths = extractBracketedPastePaths(data);
+	return paths?.every(isImagePath) ? paths : undefined;
+}
+
 export function extractBracketedImagePastePath(data: string): string | undefined {
 	const paths = extractBracketedImagePastePaths(data);
 	return paths?.length === 1 ? paths[0] : undefined;
@@ -294,6 +318,8 @@ export class CustomEditor extends Editor {
 	onPasteImage?: () => Promise<boolean>;
 	/** Called when a bracketed paste contains one or more image-file paths. */
 	onPasteImagePath?: (path: string) => void | Promise<void>;
+	/** Called when a bracketed paste contains one or more non-image file paths. */
+	onPasteFilePath?: (path: string) => void | Promise<void>;
 	/** Called when the configured raw text-paste shortcut is pressed. */
 	onPasteTextRaw?: () => void;
 	/** Called when the configured dequeue shortcut is pressed. */
@@ -479,14 +505,20 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		const pastedImagePaths = extractBracketedImagePastePaths(data);
-		if (pastedImagePaths && this.onPasteImagePath) {
-			void (async () => {
-				for (const path of pastedImagePaths) {
-					await this.onPasteImagePath?.(path);
-				}
-			})();
-			return;
+		const pastedPaths = extractBracketedPastePaths(data);
+		if (pastedPaths) {
+			const canHandlePaths = pastedPaths.every(path =>
+				isImagePath(path) ? this.onPasteImagePath !== undefined : this.onPasteFilePath !== undefined,
+			);
+			if (canHandlePaths) {
+				void (async () => {
+					for (const path of pastedPaths) {
+						if (isImagePath(path)) await this.onPasteImagePath?.(path);
+						else await this.onPasteFilePath?.(path);
+					}
+				})();
+				return;
+			}
 		}
 
 		const parsedKey = parseKey(data);