@arnilo/prism-coding-agent 0.2.9 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.3.1] - 2026-08-29
+
+### Changed
+- Plan 035-039 changed-package cut: additive runtime performance, tooling, and documentation deltas; peer window refresh.
+
+## [0.3.0] - 2026-08-20
+
+### Added
+
+- `read.findText` performs bounded literal/case-insensitive paging without extending `ReadOperations`.
+- Edit misses include bounded nearby line context; Unicode-normalized fuzzy matches are reported in confirmation text and `metadata.fuzzy`.
+- `createAcpFilesystemOperations` adapts ACP text-file methods to read/write/edit without touching host disk; image/document paths fail closed.
+
 ## [0.2.6] - unreleased
 
 ### Added

package/dist/acp-operations.d.ts

@@ -0,0 +1,22 @@
+import type { EditOperations } from "./edit.js";
+import type { ReadOperations } from "./read.js";
+import type { WriteOperations } from "./write.js";
+/** Duck-typed subset of the ACP client filesystem adapter. */
+export interface TextFileClient {
+    readTextFile(input: {
+        path: string;
+        line?: number;
+        limit?: number;
+    }): Promise<{
+        text: string;
+    }>;
+    writeTextFile(input: {
+        path: string;
+        content: string;
+    }): Promise<void>;
+}
+export declare function createAcpFilesystemOperations(client: TextFileClient): {
+    read: ReadOperations;
+    write: WriteOperations;
+    edit: EditOperations;
+};

package/dist/acp-operations.js

@@ -0,0 +1,122 @@
+/**
+ * ACP text-file client adapter for the coding read/write/edit operations.
+ *
+ * ACP exposes text reads and writes, not stat, mkdir, binary reads, or image sniffing. This adapter
+ * keeps those limits explicit: all reads go through the client, mkdir is inert, and binary/image
+ * handling is unavailable rather than falling back to the host filesystem.
+ */
+import { Buffer } from "node:buffer";
+function checkAbort(signal) {
+    if (signal?.aborted)
+        throw new Error("Operation aborted");
+}
+async function readTextFile(client, path, input, signal) {
+    checkAbort(signal);
+    const request = input === undefined ? { path } : { path, line: input.line, limit: input.limit };
+    const response = await client.readTextFile(request);
+    checkAbort(signal);
+    if (!response || typeof response.text !== "string") {
+        throw new Error("TextFileClient.readTextFile must return { text: string }");
+    }
+    return response.text;
+}
+function splitTextLines(text) {
+    const lines = text.split("\n");
+    if (lines.length > 1 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+function readPage(text, options) {
+    const requestedLines = options.limit ?? options.maxLines;
+    const lines = splitTextLines(text);
+    const totalBytes = Buffer.byteLength(text, "utf8");
+    if (totalBytes > options.maxScanBytes) {
+        throw new Error(`Text read exceeded ${options.maxScanBytes} byte scan limit`);
+    }
+    const output = [];
+    let outputBytes = 0;
+    let truncatedBy = null;
+    let firstLineExceedsLimit = false;
+    for (const line of lines) {
+        if (output.length >= requestedLines) {
+            truncatedBy = "lines";
+            break;
+        }
+        const lineBytes = Buffer.byteLength(line, "utf8");
+        if (output.length === 0 && lineBytes > options.maxBytes) {
+            firstLineExceedsLimit = true;
+            truncatedBy = "bytes";
+            break;
+        }
+        const withSeparator = output.length === 0 ? lineBytes : lineBytes + 1;
+        if (outputBytes + withSeparator > options.maxBytes) {
+            truncatedBy = "bytes";
+            break;
+        }
+        output.push(line);
+        outputBytes += withSeparator;
+    }
+    const clientReturnedPage = lines.length >= requestedLines && requestedLines > 0;
+    const hasMore = !firstLineExceedsLimit && (output.length < lines.length || clientReturnedPage);
+    const nextOffset = hasMore && output.length > 0 ? options.offset + output.length : undefined;
+    const totalLines = clientReturnedPage ? undefined : lines.length;
+    return {
+        content: firstLineExceedsLimit ? "" : output.join("\n"),
+        startLine: options.offset,
+        outputLines: firstLineExceedsLimit ? 0 : output.length,
+        hasMore,
+        nextOffset,
+        truncatedBy,
+        firstLineExceedsLimit,
+        scannedBytes: totalBytes,
+        totalLines,
+        totalBytes,
+    };
+}
+export function createAcpFilesystemOperations(client) {
+    const readFile = async (path, options) => {
+        const text = await readTextFile(client, path, undefined, options.signal);
+        const buffer = Buffer.from(text, "utf8");
+        if (buffer.byteLength > options.maxBytes) {
+            throw new Error(`File is ${buffer.byteLength} bytes, exceeds ${options.maxBytes} byte limit`);
+        }
+        return buffer;
+    };
+    const writeFile = async (path, content, options) => {
+        checkAbort(options?.signal);
+        const bytes = Buffer.byteLength(content, "utf8");
+        if (options?.maxBytes !== undefined && bytes > options.maxBytes) {
+            throw new Error(`Write input is ${bytes} bytes, exceeds ${options.maxBytes} byte limit`);
+        }
+        await client.writeTextFile({ path, content });
+    };
+    const access = (path, options) => readTextFile(client, path, { line: 1, limit: 1 }, options?.signal).then(() => undefined);
+    const statFile = async (path, options) => ({
+        size: Buffer.byteLength(await readTextFile(client, path, undefined, options?.signal), "utf8"),
+    });
+    return {
+        read: {
+            readFile,
+            readText: async (path, options) => {
+                const text = await readTextFile(client, path, { line: options.offset, limit: options.limit ?? options.maxLines }, options.signal);
+                return readPage(text, options);
+            },
+            access,
+            statFile,
+            detectImageMimeType: async () => null,
+        },
+        write: {
+            writeFile,
+            mkdir: async (_path, options) => {
+                checkAbort(options?.signal);
+            },
+        },
+        edit: {
+            readFile,
+            writeFile,
+            access,
+            statFile,
+        },
+    };
+}
+//# sourceMappingURL=acp-operations.js.map

package/dist/coding-checkpoint.js

@@ -16,7 +16,35 @@ export const CODING_STATE_KEY = "coding";
 const SHA256_HEX = /^[a-f0-9]{64}$/;
 const TASK_ID = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,127}$/;
 const BRANCH = /^[^\s]{1,255}$/;
-const TODO_LINE = /^\s*[-*]\s+\[([ xX])\]\s+(.+?)\s*$/;
+// Linear todo-line scanner replaces `/^\s*[-*]\s+\[([ xX])\]\s+(.+?)\s*$/` (CodeQL js/polynomial-redos, alert 4)
+function parseTodoLine(line) {
+    let i = 0;
+    while (i < line.length && /\s/.test(line[i]))
+        i += 1;
+    if (line[i] !== "-" && line[i] !== "*")
+        return undefined;
+    i += 1;
+    while (i < line.length && /\s/.test(line[i]))
+        i += 1;
+    if (line[i] !== "[")
+        return undefined;
+    i += 1;
+    const doneChar = line[i];
+    if (doneChar !== "x" && doneChar !== "X" && doneChar !== " ")
+        return undefined;
+    i += 1;
+    if (line[i] !== "]")
+        return undefined;
+    i += 1;
+    while (i < line.length && /\s/.test(line[i]))
+        i += 1;
+    let end = line.length;
+    while (end > i && /\s/.test(line[end - 1]))
+        end -= 1;
+    if (end <= i)
+        return undefined;
+    return { done: doneChar.toLowerCase() === "x", raw: line.slice(i, end) };
+}
 const FORBIDDEN_METADATA_KEYS = new Set([
     "credentials",
     "credential",
@@ -123,17 +151,32 @@ export function parseCodingPlanTodos(markdown, limits) {
     assertByteLimit("plan", markdown, resolved.maxPlanBytes);
     const todos = [];
     for (const line of markdown.split(/\r?\n/)) {
-        const match = TODO_LINE.exec(line);
+        const match = parseTodoLine(line);
         if (!match)
             continue;
-        const done = match[1].toLowerCase() === "x";
-        const raw = match[2].trim();
+        const done = match.done;
+        const raw = match.raw;
         assertTodoText(raw, resolved.maxTodoTextBytes);
-        const idMatch = /^\[([A-Za-z0-9._-]{1,64})\]\s+(.+)$/.exec(raw);
-        const id = idMatch?.[1] ?? `todo-${todos.length + 1}`;
-        const text = idMatch?.[2] ?? raw;
+        // Linear id-prefix parse replaces `/^\[([A-Za-z0-9._-]{1,64})\]\s+(.+)$/` (CodeQL js/polynomial-redos, alert 5)
+        let id;
+        let text = raw;
+        if (raw.startsWith("[")) {
+            const close = raw.indexOf("]", 1);
+            if (close !== -1) {
+                const candidate = raw.slice(1, close);
+                const after = raw.slice(close + 1);
+                if (candidate.length >= 1 &&
+                    candidate.length <= 64 &&
+                    /^[A-Za-z0-9._-]+$/u.test(candidate) &&
+                    /^\s/u.test(after) &&
+                    after.trim().length > 0) {
+                    id = candidate;
+                    text = after.trim();
+                }
+            }
+        }
         assertTodoText(text, resolved.maxTodoTextBytes);
-        todos.push({ id, text, done });
+        todos.push({ id: id ?? `todo-${todos.length + 1}`, text, done });
         if (todos.length > resolved.maxTodos) {
             throw new CodingCheckpointError(`Plan exceeds ${resolved.maxTodos} todo limit`);
         }

package/dist/edit-diff.d.ts

@@ -58,6 +58,7 @@ export declare function stripBom(content: string): {
 export interface AppliedEditsResult {
     baseContent: string;
     newContent: string;
+    usedFuzzyMatch: boolean;
 }
 /**
  * Apply one or more exact-text replacements to LF-normalized content.

package/dist/edit-diff.js

@@ -179,11 +179,37 @@ function countOccurrences(content, oldText) {
     const fuzzyOldText = normalizeForFuzzyMatch(oldText);
     return fuzzyContent.split(fuzzyOldText).length - 1;
 }
-function getNotFoundError(path, editIndex, totalEdits) {
-    if (totalEdits === 1) {
-        return new Error(`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`);
+function getNotFoundError(path, content, oldText, editIndex, totalEdits) {
+    const base = totalEdits === 1
+        ? `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`
+        : `Could not find edits[${editIndex}] in ${path}. The oldText must match exactly including all whitespace and newlines.`;
+    // Cheap first-line substring scan: collect up to 3 unique nearby lines so the model can correct
+    // its oldText. No extra file read — `content` is the already-loaded target. Needle is clipped to
+    // 16 chars (min 4) to avoid noise from tiny/short oldText.
+    const firstLine = oldText
+        .split("\n")
+        .map((l) => l.trim())
+        .find((l) => l.length > 0);
+    if (!firstLine)
+        return new Error(base);
+    const needle = firstLine.slice(0, 16);
+    if (needle.length < 4)
+        return new Error(base);
+    const lines = content.split("\n");
+    const seen = new Set();
+    const nearby = [];
+    for (let i = 0; i < lines.length && nearby.length < 3; i++) {
+        if (lines[i].includes(needle)) {
+            const snippet = lines[i].slice(0, 120);
+            if (seen.has(snippet))
+                continue;
+            seen.add(snippet);
+            nearby.push(`  L${i + 1}: ${snippet}`);
+        }
     }
-    return new Error(`Could not find edits[${editIndex}] in ${path}. The oldText must match exactly including all whitespace and newlines.`);
+    if (nearby.length === 0)
+        return new Error(base);
+    return new Error(`${base}\nNearby:\n${nearby.join("\n")}`);
 }
 function getDuplicateError(path, editIndex, totalEdits, occurrences) {
     if (totalEdits === 1) {
@@ -230,7 +256,7 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
         const edit = normalizedEdits[i];
         const matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);
         if (!matchResult.found) {
-            throw getNotFoundError(path, i, normalizedEdits.length);
+            throw getNotFoundError(path, normalizedContent, edit.oldText, i, normalizedEdits.length);
         }
         const occurrences = countOccurrences(replacementBaseContent, edit.oldText);
         if (occurrences > 1) {
@@ -258,7 +284,7 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
     if (baseContent === newContent) {
         throw getNoChangeError(path, normalizedEdits.length);
     }
-    return { baseContent, newContent };
+    return { baseContent, newContent, usedFuzzyMatch };
 }
 /** Generate a standard unified patch. */
 export function generateUnifiedPatch(path, oldContent, newContent, contextLines = 4) {

package/dist/edit.d.ts

@@ -37,6 +37,8 @@ export interface EditToolDetails {
     patch: string;
     /** Line number of the first change in the new file (for editor navigation). */
     firstChangedLine?: number;
+    /** `true` when the replacement applied via fuzzy (not exact) matching. Absent for exact. */
+    fuzzy?: boolean;
 }
 /**
  * Pluggable operations for the edit tool. Override to delegate file editing to remote systems

package/dist/edit.js

@@ -98,7 +98,7 @@ export function createEditTool(cwd, options) {
         name: "edit",
         kind: "edit",
         effect: CODING_LOCAL_EFFECT,
-        description: "Edit a single file using exact-then-fuzzy text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. Exact match is tried first; if it fails, fuzzy match (unicode normalize + whitespace collapse) may still succeed silently — prefer exact oldText to avoid wrong-region edits. Duplicate/ambiguous matches fail closed and leave the file unchanged. If two changes affect the same block or nearby lines, merge them into one edit. Do not include large unchanged regions just to connect distant changes. When the host enabled requireReadBeforeWrite, read the path first or pass force=true.",
+        description: "Edit a single file using exact-then-fuzzy text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. Exact match is tried first; if it fails, fuzzy match (unicode normalize + whitespace collapse) may still succeed and is reported as `(fuzzy match)` — prefer exact `oldText` copied from a fresh `read` to avoid wrong-region edits. Duplicate/ambiguous matches fail closed and leave the file unchanged. If two changes affect the same block or nearby lines, merge them into one edit. Do not include large unchanged regions just to connect distant changes. When the host enabled requireReadBeforeWrite, read the path first or pass force=true.",
         parameters: {
             type: "object",
             properties: {
@@ -193,8 +193,9 @@ export function createEditTool(cwd, options) {
                     // Apply exact-then-fuzzy matching. Throws on no-match / duplicate / overlap / empty / no-change.
                     let baseContent;
                     let newContent;
+                    let usedFuzzyMatch = false;
                     try {
-                        ({ baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, prepared.path));
+                        ({ baseContent, newContent, usedFuzzyMatch } = applyEditsToNormalizedContent(normalizedContent, edits, prepared.path));
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
@@ -207,15 +208,17 @@ export function createEditTool(cwd, options) {
                     options?.onEvent?.({ type: "file_changed", path: allowedPath, op: "edit", toolCallId });
                     const diffResult = generateDiffString(baseContent, newContent);
                     const patch = generateUnifiedPatch(prepared.path, baseContent, newContent);
+                    const confirmation = `Successfully replaced ${edits.length} block(s) in ${prepared.path}${usedFuzzyMatch ? " (fuzzy match)" : ""}.`;
                     return {
                         toolCallId,
                         name: "edit",
-                        content: [{ type: "text", text: `Successfully replaced ${edits.length} block(s) in ${prepared.path}.` }],
+                        content: [{ type: "text", text: confirmation }],
                         metadata: {
                             path: allowedPath,
                             diff: diffResult.diff,
                             patch,
                             firstChangedLine: diffResult.firstChangedLine,
+                            ...(usedFuzzyMatch ? { fuzzy: true } : {}),
                         },
                     };
                 });

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export type { TextFileClient } from "./acp-operations.js";
+export { createAcpFilesystemOperations } from "./acp-operations.js";
 export { createDirectoryArtifactWriter, createTempArtifactWriter, sha256Hex } from "./artifacts.js";
 export type { AskUserDecisionAnswer, AskUserDecisionHandler, AskUserDecisionOption, AskUserDecisionRequest, AskUserDecisionSelectionMode, AskUserDecisionSuspendData, AskUserDecisionToolOptions, ResolvedAskUserDecisionAnswer, ResolvedAskUserDecisionLimits, SuspendAskUserDecisionOptions, } from "./ask-user-decision.js";
 export { ASK_USER_DECISION_RATIONALE_COUNT, ASK_USER_DECISION_SUSPEND_REASON, ASK_USER_DECISION_TOOL_NAME, askUserDecisionResumeSchema, createAskUserDecisionResumeValidator, createAskUserDecisionTool, DEFAULT_MAX_ASK_USER_DECISION_BULLET_BYTES, DEFAULT_MAX_ASK_USER_DECISION_CUSTOM_BYTES, DEFAULT_MAX_ASK_USER_DECISION_LABEL_BYTES, DEFAULT_MAX_ASK_USER_DECISION_OPTIONS, DEFAULT_MAX_ASK_USER_DECISION_QUESTION_BYTES, HARD_MAX_ASK_USER_DECISION_BULLET_BYTES, HARD_MAX_ASK_USER_DECISION_CUSTOM_BYTES, HARD_MAX_ASK_USER_DECISION_LABEL_BYTES, HARD_MAX_ASK_USER_DECISION_OPTIONS, HARD_MAX_ASK_USER_DECISION_QUESTION_BYTES, parseAskUserDecisionArgs, resolveAskUserDecisionAnswer, resolveAskUserDecisionLimits, suspendAskUserDecision, toAskUserDecisionSuspendData, validateAskUserDecisionAgentResume, validateAskUserDecisionResume, } from "./ask-user-decision.js";

package/dist/index.js

@@ -3,7 +3,7 @@
 // First-party coding tools for the Prism agent harness. Factory functions return Prism
 // `ToolDefinition`s that hosts register into a `ToolRegistry` (e.g.
 // `createToolRegistry(createCodingTools(cwd))`). No tools are auto-registered — import what you need.
-// --- per-tool factories & types ---
+export { createAcpFilesystemOperations } from "./acp-operations.js";
 export { createDirectoryArtifactWriter, createTempArtifactWriter, sha256Hex } from "./artifacts.js";
 export { ASK_USER_DECISION_RATIONALE_COUNT, ASK_USER_DECISION_SUSPEND_REASON, ASK_USER_DECISION_TOOL_NAME, askUserDecisionResumeSchema, createAskUserDecisionResumeValidator, createAskUserDecisionTool, DEFAULT_MAX_ASK_USER_DECISION_BULLET_BYTES, DEFAULT_MAX_ASK_USER_DECISION_CUSTOM_BYTES, DEFAULT_MAX_ASK_USER_DECISION_LABEL_BYTES, DEFAULT_MAX_ASK_USER_DECISION_OPTIONS, DEFAULT_MAX_ASK_USER_DECISION_QUESTION_BYTES, HARD_MAX_ASK_USER_DECISION_BULLET_BYTES, HARD_MAX_ASK_USER_DECISION_CUSTOM_BYTES, HARD_MAX_ASK_USER_DECISION_LABEL_BYTES, HARD_MAX_ASK_USER_DECISION_OPTIONS, HARD_MAX_ASK_USER_DECISION_QUESTION_BYTES, parseAskUserDecisionArgs, resolveAskUserDecisionAnswer, resolveAskUserDecisionLimits, suspendAskUserDecision, toAskUserDecisionSuspendData, validateAskUserDecisionAgentResume, validateAskUserDecisionResume, } from "./ask-user-decision.js";
 export { createCodingCheckTool } from "./checks.js";

package/dist/read.js

@@ -25,7 +25,7 @@ import { readFileBounded } from "./bounded-file.js";
 import { CODING_OBSERVATION_EFFECT } from "./effects.js";
 import { enforceExecutionPolicy } from "./execution-policy.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_IMAGE_BYTES, DEFAULT_MAX_LINES, DEFAULT_MAX_TEXT_SCAN_BYTES, HARD_MAX_BYTES, HARD_MAX_IMAGE_BYTES, HARD_MAX_LINES, HARD_MAX_TEXT_SCAN_BYTES, validateCodingLimit, } from "./limits.js";
-import { resolveReadPathAsync } from "./path-utils.js";
+import { resolveReadPathAsync, resolveToCwd } from "./path-utils.js";
 import { formatSize } from "./truncate.js";
 // --- magic-byte image MIME detection (faithful port of pi utils/mime.js, pure JS, no deps) ---
 const IMAGE_TYPE_SNIFF_BYTES = 4100;
@@ -296,6 +296,41 @@ function errorResult(toolCallId, message) {
         error: { message },
     };
 }
+/**
+ * Scan paginated `readText` output for the first line containing `findText` (literal substring,
+ * no regex). Starts at `startLine` and advances via `nextOffset` until a hit, EOF, or the scan
+ * cap. Returns the 1-indexed hit line, or `undefined` when the needle is not found before EOF.
+ * Throws on scan-limit / abort / no-progress so the caller's error path surfaces a clean result.
+ * Pages with `limit` unset so each backend page is `maxLines`-sized (fewer round trips).
+ */
+async function findMatchLine(ops, absolutePath, findText, findMode, startLine, maxLines, maxBytes, maxScanBytes, signal) {
+    const caseInsensitive = findMode === "case-insensitive";
+    const needle = caseInsensitive ? findText.toLowerCase() : findText;
+    let offset = startLine;
+    let guard = 0; // ponytail: safety cap for backends that report hasMore without advancing
+    while (true) {
+        if (signal?.aborted)
+            throw new Error("Operation aborted");
+        const page = await ops.readText(absolutePath, { offset, maxLines, maxBytes, maxScanBytes, signal });
+        if (!page.firstLineExceedsLimit && page.content.length > 0) {
+            const lines = page.content.split("\n");
+            for (let index = 0; index < lines.length; index++) {
+                const line = caseInsensitive ? lines[index].toLowerCase() : lines[index];
+                if (line.includes(needle))
+                    return page.startLine + index;
+            }
+        }
+        if (!page.hasMore || page.nextOffset === undefined)
+            return undefined;
+        if (page.scannedBytes >= maxScanBytes)
+            throw new Error(`findText did not match within ${formatSize(maxScanBytes)} scan limit`);
+        if (page.nextOffset <= offset)
+            throw new Error(`findText could not advance past line ${offset}`);
+        offset = page.nextOffset;
+        if (++guard > 100_000)
+            throw new Error("findText exceeded iteration guard");
+    }
+}
 export function createReadTool(cwd, options) {
     if (options && "autoResizeImages" in options) {
         throw new TypeError('Read tool: "autoResizeImages" was removed in 0.1.5; use "transformImage" instead.');
@@ -316,6 +351,11 @@ export function createReadTool(cwd, options) {
                 path: { type: "string", description: "Path to the file to read (relative or absolute)" },
                 offset: { type: "number", description: "Line number to start reading from (1-indexed)" },
                 limit: { type: "number", description: "Maximum number of lines to read" },
+                findText: {
+                    type: "string",
+                    description: "Literal substring to search for (no regex). Returns the page starting at the first matching line at/after offset. No match is an error result.",
+                },
+                findMode: { type: "string", enum: ["exact", "case-insensitive"], description: "Match mode for findText (default 'exact')." },
             },
             required: ["path"],
             additionalProperties: false,
@@ -328,13 +368,23 @@ export function createReadTool(cwd, options) {
             const path = typeof args.path === "string" ? args.path : "";
             const offset = typeof args.offset === "number" ? args.offset : undefined;
             const limit = typeof args.limit === "number" ? args.limit : undefined;
+            const findText = typeof args.findText === "string" ? args.findText : undefined;
+            const findModeRaw = typeof args.findMode === "string" ? args.findMode : "exact";
             if (path.length === 0) {
                 return errorResult(toolCallId, "path is required and must be a non-empty string.");
             }
+            if (findText !== undefined) {
+                if (findText.length === 0) {
+                    return errorResult(toolCallId, "findText must be a non-empty string.");
+                }
+                if (findModeRaw !== "exact" && findModeRaw !== "case-insensitive") {
+                    return errorResult(toolCallId, "findMode must be 'exact' or 'case-insensitive'.");
+                }
+            }
             try {
-                const startLine = validateCodingLimit("offset", offset ?? 1, Number.MAX_SAFE_INTEGER);
+                let startLine = validateCodingLimit("offset", offset ?? 1, Number.MAX_SAFE_INTEGER);
                 const requestedLines = limit === undefined ? undefined : validateCodingLimit("limit", limit, HARD_MAX_LINES);
-                const absolutePath = await resolveReadPathAsync(path, cwd);
+                const absolutePath = options?.operations ? resolveToCwd(path, cwd) : await resolveReadPathAsync(path, cwd);
                 const policyCheck = await enforceExecutionPolicy(options?.executionPolicy, {
                     kind: "read",
                     operation: "read",
@@ -393,6 +443,13 @@ export function createReadTool(cwd, options) {
                         };
                     }
                 }
+                if (findText !== undefined) {
+                    const hit = await findMatchLine(ops, allowedPath, findText, findModeRaw, startLine, maxLines, maxBytes, maxScanBytes, context.signal);
+                    if (hit === undefined) {
+                        return errorResult(toolCallId, `Could not find ${JSON.stringify(findText)} in ${path}.`);
+                    }
+                    startLine = hit;
+                }
                 const page = await ops.readText(allowedPath, {
                     offset: startLine,
                     limit: requestedLines,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arnilo/prism-coding-agent",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Optional coding-agent tools (shell, read, write, edit, repo_list, repo_search, glob, delete, move, opt-in Git/check/ask-user-decision, and durable plan/checkpoint helpers) package for Prism.",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,8 +28,8 @@
     "diff": "^9.0.0"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.2.9",
-    "@arnilo/prism-workflows": "0.2.9"
+    "@arnilo/prism": "^0.3.1",
+    "@arnilo/prism-workflows": "^0.3.0"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../..",