@arnilo/prism-coding-agent 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.6] - 2026-08-11
+
+### Changed
+- **Bounded PDF/Office document reader** (plan 018 closeout `doc-reader`): additive `documentReader` slot on `createReadTool` — `DocumentReader.extract` runs after image sniffing, magic-byte format gating (never extension sniffing), null fall-through to the 0.1.5 text path, input/page/text caps re-checked in the read flow; the optional peer package `@arnilo/prism-document-reader` supplies the concrete parsers.
+- **Recursive delete + brace-expanding glob** (plan 018 closeout `delete-glob`): `delete` gains per-call opt-in `recursive: true` (iterative post-order walk, symlink children unlinked never followed, fan-out cap 10,000 default / 100,000 hard, partial deletion reported never silent, `maxEntries` bound); `glob` gains host-selected and per-call `braceExpansion` (`{a,b}` textual expansion, max 128 alternatives / 4096 expanded bytes, unbalanced/nested/empty braces and overflow fail closed; default matcher semantics unchanged).
+- **Checkpoint persistence for loaded-skill bodies** (plan 018 closeout `checkpoint-bodies`): durable runs may set `includeSkillBodies: true` on BOTH run and resume options — the exact loaded-skill instructions ride the checkpoint so resume re-renders them registry-independently (no `load_skill` round-trip); names-only stays the default, 0.1.3 checkpoint shapes byte-identical, `maxStateBytes` refuses oversize bodies.
+
 ## [0.1.5] - 2026-08-11
 
 ### Changed

package/dist/delete.js

@@ -3,6 +3,11 @@ import { CODING_LOCAL_EFFECT } from "./effects.js";
 import { enforceExecutionPolicy } from "./execution-policy.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveContainedMutationPath } from "./mutation-path.js";
+// Per-call recursive-delete fan-out cap: default 10,000 entries, hard 100,000.
+// ponytail: single global constants (not tunable options) — the recursive flag is
+// per-call opt-in; hosts that need a different ceiling can deny via executionPolicy.
+const DEFAULT_MAX_RECURSIVE_DELETE_ENTRIES = 10_000;
+const HARD_MAX_RECURSIVE_DELETE_ENTRIES = 100_000;
 const defaultDeleteOperations = {
     lstat: async (path) => {
         const st = await lstat(path);
@@ -30,11 +35,22 @@ export function createDeleteTool(cwd, options) {
     return {
         name: "delete",
         effect: CODING_LOCAL_EFFECT,
-        description: "High-risk: permanently delete a single file or empty directory in the workspace. Non-empty directories are rejected (no recursive delete). No trash/recycle — host undo is not automatic. Prefer edit/write when content can be fixed in place.",
+        description: "High-risk: permanently delete a single file or empty directory in the workspace. Non-empty directories are rejected unless recursive: true (opt-in per call; recursive refuses symlinked-directory traversal and enforces a per-call fan-out cap, default 10,000 entries). No trash/recycle — host undo is not automatic. Prefer edit/write when content can be fixed in place.",
         parameters: {
             type: "object",
             properties: {
-                path: { type: "string", description: "Path to the file or empty directory to delete (relative or absolute)" },
+                path: {
+                    type: "string",
+                    description: "Path to the file, empty directory, or (with recursive: true) directory tree to delete (relative or absolute)",
+                },
+                recursive: {
+                    type: "boolean",
+                    description: "Opt-in per-call recursive directory delete (default false). Symlink children are unlinked as links, never followed; fan-out capped.",
+                },
+                maxEntries: {
+                    type: "number",
+                    description: `Per-call recursive fan-out cap (default ${DEFAULT_MAX_RECURSIVE_DELETE_ENTRIES}, hard ${HARD_MAX_RECURSIVE_DELETE_ENTRIES})`,
+                },
             },
             required: ["path"],
             additionalProperties: false,
@@ -42,6 +58,15 @@ export function createDeleteTool(cwd, options) {
         async execute(args, context) {
             const toolCallId = context.toolCallId;
             const path = typeof args.path === "string" ? args.path : "";
+            const recursive = args.recursive === true;
+            let maxEntries = DEFAULT_MAX_RECURSIVE_DELETE_ENTRIES;
+            if (args.maxEntries !== undefined) {
+                const raw = args.maxEntries;
+                if (!Number.isInteger(raw) || raw < 1 || raw > HARD_MAX_RECURSIVE_DELETE_ENTRIES) {
+                    return errorResult(toolCallId, `maxEntries must be an integer between 1 and ${HARD_MAX_RECURSIVE_DELETE_ENTRIES}`);
+                }
+                maxEntries = raw;
+            }
             if (path.length === 0) {
                 return errorResult(toolCallId, "path is required and must be a non-empty string.");
             }
@@ -94,16 +119,63 @@ export function createDeleteTool(cwd, options) {
                     }
                     if (st.isDirectory()) {
                         const entries = await ops.readdir(allowedPath, { signal: context.signal });
-                        if (entries.length > 0) {
-                            return errorResult(toolCallId, `Directory is not empty: ${path}. Recursive delete is not supported.`);
+                        if (entries.length > 0 && !recursive) {
+                            return errorResult(toolCallId, `Directory is not empty: ${path}. Recursive delete is not supported (set recursive: true to opt in per call).`);
+                        }
+                        if (entries.length === 0) {
+                            await ops.rmdir(allowedPath, { signal: context.signal });
+                            options?.onEvent?.({ type: "file_changed", path: allowedPath, op: "delete", toolCallId });
+                            return {
+                                toolCallId,
+                                name: "delete",
+                                content: [{ type: "text", text: `Successfully deleted empty directory ${allowedPath}` }],
+                                metadata: { path: allowedPath, kind: "directory" },
+                            };
+                        }
+                        // Recursive delete: iterative post-order walk. Symlink children are
+                        // UNLINKED as links and never followed — a symlinked directory can
+                        // never drag the deletion outside the workspace root. The walk counts
+                        // every entry against the per-call fan-out cap and checks the abort
+                        // signal per entry; exceeding the cap stops with an error naming it.
+                        const stack = [{ dir: allowedPath }];
+                        const dirs = [allowedPath];
+                        let count = 0;
+                        while (stack.length > 0) {
+                            if (context.signal?.aborted) {
+                                return errorResult(toolCallId, `Operation aborted after deleting ${count} entries`);
+                            }
+                            const { dir } = stack.pop();
+                            const children = await ops.readdir(dir, { signal: context.signal });
+                            for (const child of children) {
+                                count++;
+                                if (count > maxEntries) {
+                                    return errorResult(toolCallId, `Recursive delete exceeded the per-call fan-out cap of ${maxEntries} entries after deleting ${count - 1} entries; nothing beyond the cap was touched.`);
+                                }
+                                const childPath = `${dir}/${child}`;
+                                const childStat = await ops.lstat(childPath, { signal: context.signal });
+                                if (childStat.isDirectory()) {
+                                    dirs.push(childPath);
+                                    stack.push({ dir: childPath });
+                                }
+                                else {
+                                    await ops.unlink(childPath, { signal: context.signal });
+                                    options?.onEvent?.({ type: "file_changed", path: childPath, op: "delete", toolCallId });
+                                }
+                            }
+                        }
+                        // Remove directories deepest-first, then the root directory itself.
+                        for (let i = dirs.length - 1; i >= 0; i--) {
+                            if (context.signal?.aborted) {
+                                return errorResult(toolCallId, `Operation aborted after deleting ${count} entries`);
+                            }
+                            await ops.rmdir(dirs[i], { signal: context.signal });
+                            options?.onEvent?.({ type: "file_changed", path: dirs[i], op: "delete", toolCallId });
                         }
-                        await ops.rmdir(allowedPath, { signal: context.signal });
-                        options?.onEvent?.({ type: "file_changed", path: allowedPath, op: "delete", toolCallId });
                         return {
                             toolCallId,
                             name: "delete",
-                            content: [{ type: "text", text: `Successfully deleted empty directory ${allowedPath}` }],
-                            metadata: { path: allowedPath, kind: "directory" },
+                            content: [{ type: "text", text: `Successfully deleted ${allowedPath} (${count} entries)` }],
+                            metadata: { path: allowedPath, kind: "directory", recursive: true, entriesDeleted: count },
                         };
                     }
                     return errorResult(toolCallId, `Unsupported file type: ${path}`);

package/dist/glob-match.d.ts

@@ -1,6 +1,21 @@
 /**
- * Minimal glob matcher: `*`, `?`, and `**` only. No brace expansion, no regex.
+ * Minimal glob matcher: `*`, `?`, and `**` only. Brace expansion is an opt-in,
+ * bounded extension (see `expandGlobBraces`). No regex, no dependency.
  */
-export declare function validateGlobPattern(pattern: string, maxPatternBytes: number): void;
+export interface BraceExpansionOptions {
+    /** Max alternatives produced by expansion (default 128). */
+    maxAlternatives?: number;
+    /** Max total bytes across all expanded alternatives (default 4096). */
+    maxExpandedBytes?: number;
+}
+/**
+ * Expand `{a,b}` groups in a pattern (cartesian across multiple groups).
+ * Bounded: max alternatives and max total expanded bytes; unbalanced or nested
+ * braces fail closed. With no braces (or empty text), returns `[pattern]`.
+ */
+export declare function expandGlobBraces(pattern: string, options?: BraceExpansionOptions): string[];
+export declare function validateGlobPattern(pattern: string, maxPatternBytes: number, options?: {
+    braceExpansion?: boolean;
+}): void;
 /** Match a workspace-relative path against a glob pattern using `/` separators. */
 export declare function matchGlobPattern(pattern: string, path: string): boolean;

package/dist/glob-match.js

@@ -1,7 +1,63 @@
 /**
- * Minimal glob matcher: `*`, `?`, and `**` only. No brace expansion, no regex.
+ * Minimal glob matcher: `*`, `?`, and `**` only. Brace expansion is an opt-in,
+ * bounded extension (see `expandGlobBraces`). No regex, no dependency.
  */
-export function validateGlobPattern(pattern, maxPatternBytes) {
+const DEFAULT_MAX_BRACE_ALTERNATIVES = 128;
+const DEFAULT_MAX_BRACE_EXPANDED_BYTES = 4_096;
+/**
+ * Expand `{a,b}` groups in a pattern (cartesian across multiple groups).
+ * Bounded: max alternatives and max total expanded bytes; unbalanced or nested
+ * braces fail closed. With no braces (or empty text), returns `[pattern]`.
+ */
+export function expandGlobBraces(pattern, options) {
+    const maxAlternatives = options?.maxAlternatives ?? DEFAULT_MAX_BRACE_ALTERNATIVES;
+    const maxExpandedBytes = options?.maxExpandedBytes ?? DEFAULT_MAX_BRACE_EXPANDED_BYTES;
+    const results = [];
+    const go = (start, prefix) => {
+        if (results.length >= maxAlternatives) {
+            throw new Error(`brace expansion exceeds ${maxAlternatives} alternative limit`);
+        }
+        const open = pattern.indexOf("{", start);
+        if (open === -1) {
+            const out = prefix + pattern.slice(start);
+            if (Buffer.byteLength(out, "utf8") > maxExpandedBytes) {
+                throw new Error(`brace expansion exceeds ${maxExpandedBytes} byte limit`);
+            }
+            results.push(out);
+            return;
+        }
+        let depth = 1;
+        let close = -1;
+        for (let i = open + 1; i < pattern.length; i++) {
+            const ch = pattern[i];
+            if (ch === "{")
+                depth++;
+            else if (ch === "}") {
+                depth--;
+                if (depth === 0) {
+                    close = i;
+                    break;
+                }
+            }
+        }
+        if (close === -1)
+            throw new Error(`unbalanced brace expansion in pattern: ${pattern}`);
+        if (depth !== 0)
+            throw new Error(`unbalanced brace expansion in pattern: ${pattern}`);
+        const body = pattern.slice(open + 1, close);
+        if (body.includes("{") || body.includes("}")) {
+            throw new Error(`nested brace expansion is not supported in pattern: ${pattern}`);
+        }
+        if (body.length === 0)
+            throw new Error(`empty brace expansion in pattern: ${pattern}`);
+        for (const alt of body.split(",")) {
+            go(close + 1, prefix + pattern.slice(start, open) + alt);
+        }
+    };
+    go(0, "");
+    return results;
+}
+export function validateGlobPattern(pattern, maxPatternBytes, options) {
     const patternBytes = Buffer.byteLength(pattern, "utf8");
     if (patternBytes < 1)
         throw new Error("pattern must be non-empty");
@@ -9,7 +65,12 @@ export function validateGlobPattern(pattern, maxPatternBytes) {
         throw new Error(`pattern exceeds ${maxPatternBytes} byte pattern limit`);
     }
     if (pattern.includes("{") || pattern.includes("}")) {
-        throw new Error("brace expansion is not supported in glob patterns");
+        if (options?.braceExpansion === true) {
+            // Bounded expansion is validated by expandGlobBraces (alternatives + byte caps).
+            expandGlobBraces(pattern);
+            return;
+        }
+        throw new Error("brace expansion is not supported in glob patterns (set braceExpansion: true to enable the bounded expansion)");
     }
 }
 function matchSegment(pattern, segment) {

package/dist/glob.d.ts

@@ -10,5 +10,7 @@ export interface GlobToolOptions {
     maxDepth?: number;
     maxResults?: number;
     exclude?: readonly string[];
+    /** Host-selected default for bounded `{a,b}` brace expansion (default false). */
+    braceExpansion?: boolean;
 }
 export declare function createGlobTool(cwd: string, options?: GlobToolOptions): ToolDefinition;

package/dist/glob.js

@@ -32,7 +32,7 @@ export function createGlobTool(cwd, options) {
     return {
         name: "glob",
         effect: CODING_OBSERVATION_EFFECT,
-        description: `Find workspace files by glob pattern without shell find. Supports * (segment), ? (one char), and ** (directories). Brace expansion is rejected. Skips hidden names and excluded basenames (default: ${limits.exclude.join(", ")}) unless overridden. Does not follow symlinks. Results paginate with offset/maxResults (default ${limits.maxResults}). Depth default ${limits.maxDepth}. Prefer repo_list to enumerate directories and repo_search to find text inside files.`,
+        description: `Find workspace files by glob pattern without shell find. Supports * (segment), ? (one char), and ** (directories). Brace expansion is rejected unless braceExpansion: true (bounded: max 128 alternatives / 4096 expanded bytes; unbalanced or nested braces are errors). Skips hidden names and excluded basenames (default: ${limits.exclude.join(", ")}) unless overridden. Does not follow symlinks. Results paginate with offset/maxResults (default ${limits.maxResults}). Depth default ${limits.maxDepth}. Prefer repo_list to enumerate directories and repo_search to find text inside files.`,
         parameters: {
             type: "object",
             properties: {
@@ -48,6 +48,10 @@ export function createGlobTool(cwd, options) {
                     type: "boolean",
                     description: "Include dotfile/dotdir names (default false). Excluded basenames still apply.",
                 },
+                braceExpansion: {
+                    type: "boolean",
+                    description: "Opt-in bounded {a,b} brace expansion (default: host option, else false)",
+                },
                 maxDepth: {
                     type: "number",
                     description: `Maximum directory depth to descend (default ${limits.maxDepth}, hard ${HARD_MAX_REPO_DEPTH})`,
@@ -73,6 +77,7 @@ export function createGlobTool(cwd, options) {
                 return errorResult(toolCallId, "pattern must be a non-empty string");
             const path = typeof args.path === "string" ? args.path : undefined;
             const includeHidden = args.includeHidden === true;
+            const braceExpansion = args.braceExpansion === true || (args.braceExpansion === undefined && options?.braceExpansion === true);
             let maxDepth;
             let maxResults;
             let offset = 0;
@@ -98,6 +103,7 @@ export function createGlobTool(cwd, options) {
                 metadata: {
                     pattern,
                     includeHidden,
+                    braceExpansion,
                     maxDepth,
                     maxResults,
                     offset,
@@ -114,6 +120,7 @@ export function createGlobTool(cwd, options) {
                     pattern,
                     path,
                     includeHidden,
+                    braceExpansion,
                     exclude: limits.exclude,
                     maxDepth: maxDepth ?? limits.maxDepth,
                     maxResults: maxResults ?? limits.maxResults,

package/dist/index.d.ts

@@ -26,7 +26,7 @@ export type { ListToolOptions } from "./list.js";
 export { createRepoListTool } from "./list.js";
 export type { MoveOperations, MoveToolOptions } from "./move.js";
 export { createMoveTool } from "./move.js";
-export type { ReadOperations, ReadTextOptions, ReadTextResult, ReadToolOptions, TransformImage, TransformImageInput, } from "./read.js";
+export type { ReadOperations, ReadTextOptions, ReadTextResult, ReadToolOptions, TransformImage, TransformImageInput, DocumentReader, DocumentReaderResult, } from "./read.js";
 export { createReadTool, DEFAULT_MAX_IMAGE_BYTES, detectSupportedImageMimeType, detectSupportedImageMimeTypeFromFile, } from "./read.js";
 export type { ReadPathSet } from "./read-path-set.js";
 export { createReadPathSet, createReadPathSetPersistence, DEFAULT_MAX_PERSISTED_READ_PATHS, DEFAULT_MAX_PERSISTED_READ_PATH_CHARS, READ_PATH_SET_NAMESPACE, } from "./read-path-set.js";

package/dist/read.d.ts

@@ -59,6 +59,34 @@ export interface ReadTextResult {
     readonly totalLines?: number;
     readonly totalBytes?: number;
 }
+/**
+ * Optional host-selected document parser adapter (plan 018 closeout `doc-reader`).
+ *
+ * When wired into {@link ReadToolOptions.documentReader}, the read tool tries
+ * the reader after the image sniff and before the text page. The reader owns
+ * its bounds (input bytes, pages, output text); the read tool re-checks the
+ * output cap before returning. An unsupported buffer must return `null` so
+ * reads fall through to the 0.1.5 text path. No file-extension sniffing ever
+ * activates parsing — activation is explicit via this option.
+ */
+export interface DocumentReader {
+    /** Hard input size cap; reads refuse larger files before loading them. */
+    readonly maxInputBytes: number;
+    /** Hard cap on extracted literal text; the read tool refuses results beyond it. */
+    readonly maxTextBytes: number;
+    /** Extract literal text; return null when the buffer is not a supported document format. */
+    extract(input: {
+        readonly buffer: Buffer;
+        readonly path: string;
+        readonly signal?: AbortSignal;
+    }): Promise<DocumentReaderResult | null>;
+}
+export interface DocumentReaderResult {
+    readonly text: string;
+    readonly format: string;
+    readonly pages: number;
+    readonly truncatedBy: "pages" | "bytes" | null;
+}
 export interface ReadOperations {
     /** Read a bounded binary file. Backends must honor `maxBytes` before retaining more data. */
     readFile: (absolutePath: string, options: {
@@ -97,6 +125,11 @@ export interface ReadToolOptions {
     maxBytes?: number;
     /** When set, successful reads record the resolved absolute path for read-before-write guards. */
     readPathSet?: ReadPathSet;
+    /**
+     * Optional host-selected document reader (PDF/Office literal-text extraction).
+     * Additive: absent reader means exactly the 0.1.5 text/image behavior.
+     */
+    documentReader?: DocumentReader;
 }
 export declare function createReadTool(cwd: string, options?: ReadToolOptions): ToolDefinition;
 /** Re-exported for hosts building custom read tools or analyzing truncation metadata. */

package/dist/read.js

@@ -363,6 +363,35 @@ export function createReadTool(cwd, options) {
                         metadata: { image: { mimeType, resized, bytes: buffer.length } },
                     };
                 }
+                const documentReader = options?.documentReader;
+                if (documentReader) {
+                    const { size } = await ops.statFile(allowedPath, { signal: context.signal });
+                    if (size > documentReader.maxInputBytes) {
+                        return errorResult(toolCallId, `Document is ${formatSize(size)}, exceeds ${formatSize(documentReader.maxInputBytes)} limit.`);
+                    }
+                    const buffer = await ops.readFile(allowedPath, {
+                        maxBytes: documentReader.maxInputBytes,
+                        signal: context.signal,
+                    });
+                    if (buffer.length > documentReader.maxInputBytes) {
+                        return errorResult(toolCallId, `Document is ${formatSize(buffer.length)}, exceeds ${formatSize(documentReader.maxInputBytes)} limit.`);
+                    }
+                    const extracted = await documentReader.extract({ buffer, path: allowedPath, signal: context.signal });
+                    if (extracted) {
+                        if (Buffer.byteLength(extracted.text, "utf8") > documentReader.maxTextBytes) {
+                            throw new Error("DocumentReader.extract returned text beyond its maxTextBytes cap");
+                        }
+                        options?.readPathSet?.add(allowedPath);
+                        return {
+                            toolCallId,
+                            name: "read",
+                            content: [{ type: "text", text: extracted.text }],
+                            metadata: {
+                                document: { format: extracted.format, pages: extracted.pages, truncatedBy: extracted.truncatedBy },
+                            },
+                        };
+                    }
+                }
                 const page = await ops.readText(allowedPath, {
                     offset: startLine,
                     limit: requestedLines,

package/dist/repository.d.ts

@@ -114,6 +114,8 @@ export interface RepositoryGlobRequest {
     readonly maxDepth?: number;
     readonly maxResults?: number;
     readonly offset?: number;
+    /** Opt-in bounded `{a,b}` expansion (default false; expansion bounds in glob-match.ts). */
+    readonly braceExpansion?: boolean;
     readonly signal?: AbortSignal;
     readonly deadlineMs?: number;
 }

package/dist/repository.js

@@ -8,7 +8,7 @@
 import { lstat, open, opendir, realpath } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { DEFAULT_BINARY_SNIFF_BYTES, DEFAULT_MAX_REPO_CONCURRENCY, DEFAULT_MAX_REPO_DEPTH, DEFAULT_MAX_REPO_ENTRIES, DEFAULT_MAX_REPO_FILES, DEFAULT_MAX_REPO_RESULTS, DEFAULT_MAX_SEARCH_CONTEXT_LINES, DEFAULT_MAX_SEARCH_FILE_BYTES, DEFAULT_MAX_SEARCH_LINE_BYTES, DEFAULT_MAX_SEARCH_MATCHES, DEFAULT_MAX_SEARCH_PATTERN_BYTES, DEFAULT_MAX_SEARCH_SCAN_BYTES, DEFAULT_MAX_SEARCH_TIME_MS, HARD_MAX_REPO_CONCURRENCY, HARD_MAX_REPO_DEPTH, HARD_MAX_REPO_ENTRIES, HARD_MAX_REPO_FILES, HARD_MAX_REPO_RESULTS, HARD_MAX_SEARCH_CONTEXT_LINES, HARD_MAX_SEARCH_FILE_BYTES, HARD_MAX_SEARCH_LINE_BYTES, HARD_MAX_SEARCH_MATCHES, HARD_MAX_SEARCH_PATTERN_BYTES, HARD_MAX_SEARCH_SCAN_BYTES, HARD_MAX_SEARCH_TIME_MS, validateCodingLimit, validateCodingLimitAllowZero, } from "./limits.js";
-import { matchGlobPattern, validateGlobPattern } from "./glob-match.js";
+import { expandGlobBraces, matchGlobPattern, validateGlobPattern } from "./glob-match.js";
 import { resolveToCwd } from "./path-utils.js";
 export const DEFAULT_REPO_EXCLUDE = Object.freeze([".git", "node_modules", "dist"]);
 export class RepositoryError extends Error {
@@ -605,11 +605,14 @@ async function searchLocal(request, defaults, walk) {
 }
 async function globLocal(request, defaults, walk) {
     try {
-        validateGlobPattern(request.pattern, defaults.maxPatternBytes);
+        validateGlobPattern(request.pattern, defaults.maxPatternBytes, { braceExpansion: request.braceExpansion === true });
     }
     catch (error) {
         throw new RepositoryError(error instanceof Error ? error.message : String(error));
     }
+    // Opt-in bounded brace expansion: textual alternatives only (never touches the
+    // filesystem); bounds enforced by expandGlobBraces (max alternatives / bytes).
+    const patterns = request.braceExpansion === true ? expandGlobBraces(request.pattern) : [request.pattern];
     const resolved = await resolveRepoPath(request.root, request.path);
     const maxResults = validateCodingLimit("maxResults", request.maxResults ?? defaults.maxResults, HARD_MAX_REPO_RESULTS);
     const offset = validateCodingLimitAllowZero("offset", request.offset ?? 0, HARD_MAX_REPO_ENTRIES);
@@ -622,8 +625,15 @@ async function globLocal(request, defaults, walk) {
     let seen = 0;
     let truncated = false;
     let truncatedBy = null;
+    const matchesAnyPattern = (relativePath) => {
+        for (const p of patterns) {
+            if (matchGlobPattern(p, relativePath))
+                return true;
+        }
+        return false;
+    };
     const maybeCollect = (relativePath) => {
-        if (!matchGlobPattern(request.pattern, relativePath))
+        if (!matchesAnyPattern(relativePath))
             return false;
         if (seen < offset) {
             seen++;
@@ -644,7 +654,7 @@ async function globLocal(request, defaults, walk) {
             scannedEntries = 1;
             if (startStat.isFile()) {
                 scannedFiles = 1;
-                if (matchGlobPattern(request.pattern, resolved.relative)) {
+                if (matchesAnyPattern(resolved.relative)) {
                     if (offset === 0 && maxResults > 0)
                         collected.push(resolved.relative);
                     else if (offset === 0 && maxResults === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arnilo/prism-coding-agent",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "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.1.5",
-    "@arnilo/prism-workflows": "0.1.5"
+    "@arnilo/prism": "0.1.6",
+    "@arnilo/prism-workflows": "0.1.6"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../..",