@oh-my-pi/pi-coding-agent 17.3.7 → 17.3.8

package/src/tiny/completion-prompt.ts

@@ -0,0 +1,16 @@
+import type { TextGenerationPipeline } from "@huggingface/transformers";
+
+export function buildCompletionPrompt(
+	tokenizer: TextGenerationPipeline["tokenizer"],
+	promptText: string,
+	systemPrompt?: string,
+): string {
+	const userMessage = { role: "user", content: promptText };
+	const chat = systemPrompt?.trim() ? [{ role: "system", content: systemPrompt.trim() }, userMessage] : [userMessage];
+	const chatTemplateOptions = {
+		add_generation_prompt: true,
+		tokenize: false,
+		enable_thinking: false,
+	};
+	return `${tokenizer.apply_chat_template(chat, chatTemplateOptions)}`;
+}

package/src/tiny/title-client.ts

@@ -52,6 +52,12 @@ export interface TinyTitleGenerateOptions {
 	systemPrompt?: string;
 }
 
+export interface TinyModelCompletionOptions {
+	maxTokens?: number;
+	signal?: AbortSignal;
+	systemPrompt?: string;
+}
+
 function normalizeTinyTitleGenerateOptions(
 	options: AbortSignal | TinyTitleGenerateOptions | undefined,
 ): TinyTitleGenerateOptions {
@@ -260,11 +266,7 @@ export class TinyTitleClient {
 		}
 	}
 
-	async complete(
-		modelKey: string,
-		prompt: string,
-		options: { maxTokens?: number; signal?: AbortSignal } = {},
-	): Promise<string | null> {
+	async complete(modelKey: string, prompt: string, options: TinyModelCompletionOptions = {}): Promise<string | null> {
 		if (!isTinyMemoryLocalModelKey(modelKey)) return null;
 		if (options.signal?.aborted || this.#failedModels.has(modelKey)) return null;
 
@@ -281,7 +283,14 @@ export class TinyTitleClient {
 			};
 			options.signal?.addEventListener("abort", abort, { once: true });
 			try {
-				worker.send({ type: "complete", id, modelKey, prompt, maxTokens: options.maxTokens });
+				worker.send({
+					type: "complete",
+					id,
+					modelKey,
+					prompt,
+					maxTokens: options.maxTokens,
+					systemPrompt: options.systemPrompt,
+				});
 				return await promise;
 			} finally {
 				options.signal?.removeEventListener("abort", abort);

package/src/tiny/title-protocol.ts

@@ -30,7 +30,14 @@ export interface TinyTitleProgressEvent {
 export type TinyTitleWorkerInbound =
 	| { type: "ping"; id: string }
 	| { type: "generate"; id: string; modelKey: TinyTitleLocalModelKey; message: string; systemPrompt?: string }
-	| { type: "complete"; id: string; modelKey: TinyLocalModelKey; prompt: string; maxTokens?: number }
+	| {
+			type: "complete";
+			id: string;
+			modelKey: TinyLocalModelKey;
+			prompt: string;
+			maxTokens?: number;
+			systemPrompt?: string;
+	  }
 	| { type: "download"; id: string; modelKey: TinyLocalModelKey };
 
 export type TinyTitleWorkerOutbound =

package/src/tiny/worker.ts

@@ -19,6 +19,7 @@ import {
 	sendProgress,
 	type TransformersRuntimeMetadata,
 } from "../subprocess/worker-runtime";
+import { buildCompletionPrompt } from "./completion-prompt";
 import { resolveTinyModelDevicePreference, type TinyModelDevice, tinyModelDeviceLoadOrder } from "./device";
 import { resolveTinyModelDtypeOverride, type TinyModelDtype } from "./dtype";
 import { formatTitleUserMessage } from "./message-preproc";
@@ -42,7 +43,7 @@ const TINY_TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 const tinyModelDevicePreference = resolveTinyModelDevicePreference();
 const tinyModelDtypeOverride = resolveTinyModelDtypeOverride();
 
-interface TransformersRuntime extends TransformersRuntimeMetadata {
+export interface TransformersRuntime extends TransformersRuntimeMetadata {
 	env: {
 		cacheDir?: string;
 		allowLocalModels?: boolean;
@@ -79,7 +80,13 @@ function getTinyTitleRuntimeDir(): string {
 	);
 }
 
-function createStopOnTextCriteria(
+/** Stops generation at the first occurrence of `text` in the *generated* tokens.
+ *
+ *  The window must be anchored to the generation boundary, not to the end of the
+ *  whole sequence: a prompt that itself contains the stop string (chat-level
+ *  few-shot examples ending in `</title>`, for instance) would otherwise match on
+ *  prompt tokens and stop before the model emits anything. */
+export function createStopOnTextCriteria(
 	transformers: TransformersRuntime,
 	tokenizer: TextGenerationPipeline["tokenizer"],
 	text: string,
@@ -87,6 +94,8 @@ function createStopOnTextCriteria(
 	class StopOnTextCriteria extends transformers.StoppingCriteria {
 		#tokenizer: TextGenerationPipeline["tokenizer"];
 		#text: string;
+		/** First generated index per batch entry, captured on the first call. */
+		#generatedStarts: number[] = [];
 
 		constructor() {
 			super();
@@ -95,8 +104,10 @@ function createStopOnTextCriteria(
 		}
 
 		override _call(inputIds: number[][]): boolean[] {
-			return inputIds.map(ids => {
-				const tail = ids.slice(-STOP_DECODE_WINDOW_TOKENS);
+			return inputIds.map((ids, index) => {
+				const generatedStart = this.#generatedStarts[index] ?? Math.max(0, ids.length - 1);
+				this.#generatedStarts[index] = generatedStart;
+				const tail = ids.slice(Math.max(generatedStart, ids.length - STOP_DECODE_WINDOW_TOKENS));
 				const decoded = this.#tokenizer.decode(tail, {
 					skip_special_tokens: false,
 					clean_up_tokenization_spaces: false,
@@ -265,21 +276,10 @@ async function generateTitle(
 	return extractTinyTitle(output[0]?.generated_text ?? "", message);
 }
 
-function buildCompletionPrompt(generator: TextGenerationPipeline, promptText: string): string {
-	const chat = [{ role: "user", content: promptText }];
-	const chatTemplateOptions = {
-		add_generation_prompt: true,
-		tokenize: false,
-		enable_thinking: false,
-	};
-	return `${generator.tokenizer.apply_chat_template(chat, chatTemplateOptions)}`;
-}
-
 /**
- * Generic single-turn completion used by Mnemopi memory tasks (fact extraction
- * and consolidation). The caller (Mnemopi) supplies the full task prompt; we
- * wrap it as the user turn, decode greedily, and return the raw text for the
- * caller's own parser. Output is capped to keep local inference latency bounded.
+ * Completion path for Mnemopi memory tasks. Extraction can carry a dedicated
+ * system prompt and user payload; consolidation retains the generic user-only
+ * prompt. Output is capped to keep local inference latency bounded.
  */
 async function generateCompletion(
 	transport: TinyTitleTransport,
@@ -287,9 +287,10 @@ async function generateCompletion(
 	modelKey: TinyLocalModelKey,
 	promptText: string,
 	maxTokens: number | undefined,
+	systemPrompt: string | undefined,
 ): Promise<string | null> {
 	const generator = await loadPipeline(modelKey, transport, requestId);
-	const text = buildCompletionPrompt(generator, promptText);
+	const text = buildCompletionPrompt(generator.tokenizer, promptText, systemPrompt);
 	const requested = maxTokens ?? MEMORY_COMPLETION_DEFAULT_MAX_NEW_TOKENS;
 	const maxNewTokens = Math.min(Math.max(1, requested), COMPLETION_MAX_NEW_TOKENS);
 	const output = (await generator(text, {
@@ -332,6 +333,7 @@ async function handleQueuedRequest(
 				request.modelKey,
 				request.prompt,
 				request.maxTokens,
+				request.systemPrompt,
 			);
 			transport.send({ type: "completion", id: request.id, text });
 			return;

package/src/tools/bash.ts

@@ -166,7 +166,13 @@ function shellBuiltinsDisabled(settings: Settings): boolean {
  */
 export const CRITICAL_BASH_PATTERNS = [
 	// Recursive destruction.
-	/\brm\s+-[a-z]*[rRfF][a-z]*\s+\//i, // rm -rf /, rm -fr /, rm -r /, rm -f /…
+	// Options may sit on either side of the recursive/force flag, so only that flag is pinned and
+	// any other options are skipped: `rm -rf /`, `rm -rf -- /`, `rm --recursive --force /`,
+	// `rm -rf -v /`, `rm -v -rf /`. An absolute target is still required.
+	/\brm\s+(?:-\S+\s+)*(?:-[a-z]*[rRfF][a-z]*|--recursive|--force)\s+(?:-\S+\s+)*\//i,
+	// `--no-preserve-root` defeats coreutils' own refusal to recurse on `/`, so it is critical
+	// wherever it appears — including forms this list would otherwise reach only via the target.
+	/\brm\s+(?:-\S+\s+)*--no-preserve-root\b/i,
 	/\bsudo\s+rm\b/i, // any `sudo rm`.
 	/\bchmod\s+-R\s+[0-7]+\s+\//i, // `chmod -R 777 /`.
 	/\bchmod\s+-R\s+[ugoa+\-=rwxXst,]+\s+\//, // `chmod -R u+x /`, `chmod -R u+rwx,o+w /etc` (symbolic mode, root target).

package/src/tools/read-format.ts

@@ -72,7 +72,20 @@ export async function readHashlineHeaderContext(
 	absolutePath: string,
 	cwd: string,
 ): Promise<HashlineHeaderContext> {
-	const fullText = await Bun.file(absolutePath).text();
+	return hashlineHeaderContextForText(session, absolutePath, cwd, await Bun.file(absolutePath).text());
+}
+
+/**
+ * {@link readHashlineHeaderContext} for a caller that already holds the file's
+ * full text, so the file is not reopened just to hash it. Line endings are
+ * normalized here, exactly as the reading variant does.
+ */
+export function hashlineHeaderContextForText(
+	session: ToolSession,
+	absolutePath: string,
+	cwd: string,
+	fullText: string,
+): HashlineHeaderContext {
 	const context = recordFullHashlineContext(
 		session,
 		absolutePath,
@@ -392,6 +405,7 @@ export function buildInMemoryTextResult(
 	const buildLineEntries = (endLineDisplay: number): LineEntry[] =>
 		buildLineEntriesWithBlockContext(allLines, [{ startLine: startLineDisplay, endLine: endLineDisplay }], {
 			path: options.sourcePath,
+			text,
 		});
 
 	let outputText: string;
@@ -534,7 +548,7 @@ export function buildInMemoryMultiRangeResult(
 	if (options.raw === true) {
 		outputText = rawParts.length > 0 ? rawParts.join("\n\n…\n\n") : "";
 	} else if (visibleSpans.length > 0) {
-		const entries = buildLineEntriesWithBlockContext(allLines, visibleSpans, { path: options.sourcePath });
+		const entries = buildLineEntriesWithBlockContext(allLines, visibleSpans, { path: options.sourcePath, text });
 		if (shouldAddHashLines) seenLines = lineNumbersFromEntries(entries);
 		const firstLine = entries.find(entry => entry.kind === "line");
 		if (firstLine?.kind === "line") {

package/src/tools/read-summary.ts

@@ -52,21 +52,26 @@ export function routeReadThroughBridge(
 	if (!bridge?.capabilities.readTextFile || !bridge.readTextFile) return undefined;
 	return bridge.readTextFile({ path: absolutePath, ...options });
 }
+/**
+ * Structural summary of `absolutePath`, or `null` when the file is too large,
+ * too short, or unparseable. `diskText` lets a caller that already read the file
+ * hand those bytes over instead of forcing a second read; an ACP bridge still
+ * wins, since the editor's buffer is the source of truth.
+ */
 export async function trySummarize(
 	session: ToolSession,
 	absolutePath: string,
 	fileSize: number,
 	signal?: AbortSignal,
+	diskText?: string,
 ): Promise<SummaryResult | null> {
 	if (fileSize > MAX_SUMMARY_BYTES) return null;
 
 	try {
 		throwIfAborted(signal);
 		const bridgePromise = routeReadThroughBridge(session, absolutePath);
-		const code =
-			bridgePromise !== undefined
-				? await bridgePromise.catch(() => Bun.file(absolutePath).text())
-				: await Bun.file(absolutePath).text();
+		const readDisk = async () => diskText ?? (await Bun.file(absolutePath).text());
+		const code = bridgePromise !== undefined ? await bridgePromise.catch(readDisk) : await readDisk();
 		throwIfAborted(signal);
 		const lineCount = countTextLines(code);
 		if (lineCount > MAX_SUMMARY_LINES) return null;