@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/tool-cordis/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-cordis",
   "description": "Self-referential cordis toolset: inspect the live runtime, mount and dispose model-written plugins",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-fs/lib/index.js

@@ -851,15 +851,12 @@ function applyEditTool(ctx, sandbox) {
 //#endregion
 //#region lib/types/read-image.js
 /**
-* The model-facing `read_image` tool: reads a PNG/JPEG/WebP/GIF file, durably
-* commits its bytes through the attachment service (the same lifecycle as a
-* user-uploaded image), and returns an image block so the image enters model
-* context from the next request onward.
+* The model-facing `read_image` tool commits a PNG/JPEG/WebP/GIF file.
 *
-* The route gate is deliberately stricter than the host upload preflight: a
-* tool result enters durable session history, so emitting an image on a route
-* that cannot carry it would break that route's continuation. Unknown
-* capability therefore refuses instead of relying on the adapter guard.
+* The route gate is deliberately stricter than the host upload preflight. An
+* image-reading tool is useful only when the exact calling route can inspect
+* its result, so unknown capability refuses instead of relying on an adapter
+* failure after filesystem and attachment work.
 * @module @nomix-ai/nomix-tool-fs/src/read-image
 */
 /** Extensions `read_image` accepts; magic-byte validation at the attachment service stays authoritative. */
@@ -870,6 +867,54 @@ const IMAGE_EXTENSIONS = {
 	".webp": "image/webp",
 	".gif": "image/gif"
 };
+const IMAGE_VALUE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: true,
+	properties: {
+		attachmentId: {
+			type: "string",
+			required: true
+		},
+		mediaType: {
+			type: "string",
+			enum: [
+				"image/png",
+				"image/jpeg",
+				"image/webp",
+				"image/gif"
+			],
+			required: true
+		},
+		bytes: {
+			type: "integer",
+			required: true
+		},
+		width: {
+			type: "integer",
+			required: true
+		},
+		height: {
+			type: "integer",
+			required: true
+		},
+		name: { type: "string" },
+		originalDimensions: {
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				width: {
+					type: "integer",
+					required: true
+				},
+				height: {
+					type: "integer",
+					required: true
+				}
+			}
+		}
+	}
+};
 /**
 * Map a model-supplied path to its declared image media type by extension.
 * @param filePath - the raw `file_path` argument (not yet resolved).
@@ -896,9 +941,9 @@ async function assertImageCapableRoute(ctx, exec, requestedPath) {
 	if (active.inputModalities === void 0 || !active.inputModalities.includes("image")) throw new Error(`cannot read "${requestedPath}" as an image: model "${model}" does not declare image input; switch to an image-capable model to read images`);
 }
 /**
-* Re-brand a canonical image outcome into the durable attachment reference an
+* Re-brand a structured image outcome into the durable attachment reference an
 * `ImageBlock` carries.
-* @param image - the canonical image metadata from the output schema.
+* @param image - the image metadata from the output schema.
 * @returns the branded attachment reference.
 */
 function imageRefFromValue(image) {
@@ -908,25 +953,35 @@ function imageRefFromValue(image) {
 		bytes: image.bytes,
 		width: image.width,
 		height: image.height,
-		...image.name === void 0 ? {} : { name: image.name }
+		...image.name === void 0 ? {} : { name: image.name },
+		...image.originalDimensions === void 0 ? {} : { originalDimensions: { ...image.originalDimensions } }
 	};
 }
 /**
 * Format an image read as the model-facing envelope beside its image block.
+* A downscaled read names the on-disk dimensions and the multiplier that maps
+* coordinates measured on the attached image back onto the original file.
 * @param displayPath - the backend-resolved path rendered in the envelope's `<path>` element.
-* @param image - the canonical image metadata to summarize.
+* @param image - the image metadata to summarize.
 * @returns the model-facing envelope; the image itself rides the adjacent image block.
 */
 function formatImageReadOutput(displayPath, image) {
+	let scaled = "";
+	if (image.originalDimensions !== void 0) {
+		const x = (image.originalDimensions.width / image.width).toFixed(2);
+		const y = (image.originalDimensions.height / image.height).toFixed(2);
+		const advice = x === y ? `multiply coordinates by ${x}` : `multiply x coordinates by ${x} and y coordinates by ${y}`;
+		scaled = ` (downscaled from ${image.originalDimensions.width}x${image.originalDimensions.height} px; ${advice} to locate features in the original file)`;
+	}
 	return `<path>${displayPath}</path>
 <type>image</type>
 <content>
-${image.mediaType} image, ${image.width}x${image.height} px, ${image.bytes} bytes
+${image.mediaType} image, ${image.width}x${image.height} px, ${image.bytes} bytes${scaled}
 </content>`;
 }
 /**
-* Project one canonical image read into its model-facing envelope and image.
-* @param value - the canonical image-read outcome.
+* Project one structured image read into its model-facing envelope and image.
+* @param value - the image-read outcome.
 * @returns the two content blocks used by native and nested dispatches.
 */
 function imageReadContent(value) {
@@ -950,7 +1005,7 @@ function imageReadContent(value) {
 function applyReadImageTool(ctx) {
 	ctx.tools.register(defineTool({
 		name: "read_image",
-		description: "Read a PNG/JPEG/WebP/GIF file and return the image itself. Requires the current model to accept image input.",
+		description: "Read a PNG/JPEG/WebP/GIF file and return the image itself. Harness validates and downscales large supported images before the next model request, so use this tool directly instead of installing image libraries or creating thumbnails merely to inspect an image. Independent files may be read concurrently in small batches. Requires the current model to accept image input.",
 		parameters: { file_path: {
 			type: "string",
 			required: true,
@@ -965,40 +1020,7 @@ function applyReadImageTool(ctx) {
 						type: "string",
 						required: true
 					},
-					image: {
-						type: "object",
-						additionalProperties: false,
-						required: true,
-						properties: {
-							attachmentId: {
-								type: "string",
-								required: true
-							},
-							mediaType: {
-								type: "string",
-								enum: [
-									"image/png",
-									"image/jpeg",
-									"image/webp",
-									"image/gif"
-								],
-								required: true
-							},
-							bytes: {
-								type: "integer",
-								required: true
-							},
-							width: {
-								type: "integer",
-								required: true
-							},
-							height: {
-								type: "integer",
-								required: true
-							},
-							name: { type: "string" }
-						}
-					}
+					image: IMAGE_VALUE_SCHEMA
 				}
 			},
 			render: (_args, value) => imageReadContent(value)
@@ -1023,7 +1045,12 @@ function applyReadImageTool(ctx) {
 					name: basename(target.displayPath)
 				});
 			} catch (error) {
-				if (!(error instanceof AttachmentError) || error.code !== "IMAGE_TYPE_MISMATCH") throw error;
+				if (!(error instanceof AttachmentError)) throw error;
+				if (error.code === "IMAGE_DIMENSION_TOO_LARGE") throw new Error(`cannot read "${target.displayPath}": at least one image side exceeds the ${attachments.imageLimits.maxImageDimension}px limit; downscale the image and read the smaller copy`, { cause: error });
+				if (error.code === "IMAGE_TOO_MANY_PIXELS") throw new Error(`cannot read "${target.displayPath}": the image exceeds the ${attachments.imageLimits.maxImagePixels}-pixel decoded-size limit; downscale the image and read the smaller copy`, { cause: error });
+				if (error.code === "IMAGE_TOO_LARGE") throw new Error(`cannot read "${target.displayPath}": the image cannot be stored within the deployment's byte limits; downscale the image and read the smaller copy`, { cause: error });
+				if (error.code === "ATTACHMENT_WRITE_FAILED" && /16-bit PNG/iu.test(error.message)) throw new Error(`cannot read "${target.displayPath}": the 16-bit PNG could not be converted to the normalized 8-bit sRGB form; convert it to an 8-bit PNG/JPEG/WebP and retry`, { cause: error });
+				if (error.code !== "IMAGE_TYPE_MISMATCH") throw error;
 				const extension = extname(target.displayPath).toLowerCase();
 				throw new Error(`cannot read "${target.displayPath}": the ${extension} extension declares ${mediaType}, but the bytes use a different image format; rename the file to match its actual format if it is PNG/JPEG/WebP/GIF, or convert it to one of those formats`, { cause: error });
 			}
@@ -1039,7 +1066,8 @@ function applyReadImageTool(ctx) {
 					bytes: ref.bytes,
 					width: ref.width,
 					height: ref.height,
-					...ref.name === void 0 ? {} : { name: ref.name }
+					...ref.name === void 0 ? {} : { name: ref.name },
+					...ref.originalDimensions === void 0 ? {} : { originalDimensions: { ...ref.originalDimensions } }
 				}
 			};
 		},

package/dist/kernel/tool-fs/lib/types/read-image.d.ts

@@ -1,19 +1,16 @@
 /**
- * The model-facing `read_image` tool: reads a PNG/JPEG/WebP/GIF file, durably
- * commits its bytes through the attachment service (the same lifecycle as a
- * user-uploaded image), and returns an image block so the image enters model
- * context from the next request onward.
+ * The model-facing `read_image` tool commits a PNG/JPEG/WebP/GIF file.
  *
- * The route gate is deliberately stricter than the host upload preflight: a
- * tool result enters durable session history, so emitting an image on a route
- * that cannot carry it would break that route's continuation. Unknown
- * capability therefore refuses instead of relying on the adapter guard.
+ * The route gate is deliberately stricter than the host upload preflight. An
+ * image-reading tool is useful only when the exact calling route can inspect
+ * its result, so unknown capability refuses instead of relying on an adapter
+ * failure after filesystem and attachment work.
  * @module @nomix-ai/nomix-tool-fs/src/read-image
  */
 import type { Context } from '../../../cordis/lib/index.js';
 import type { ImageAttachmentRef, ImageMediaType } from '../../../attachment/lib/index.js';
 import type { ToolExecution } from '../../../tools/lib/index.js';
-/** The canonical outcome declared by the `read_image` output schema. */
+/** The structured outcome declared by the `read_image` output schema. */
 export interface ImageReadValue {
     path: string;
     image: {
@@ -23,6 +20,11 @@ export interface ImageReadValue {
         width: number;
         height: number;
         name?: string;
+        /** Orientation-applied file dimensions before normalization; present only when storage reduced it. */
+        originalDimensions?: {
+            width: number;
+            height: number;
+        };
     };
 }
 /**
@@ -41,16 +43,18 @@ export declare function imageMediaTypeForPath(filePath: string): ImageMediaType
  */
 export declare function assertImageCapableRoute(ctx: Context, exec: ToolExecution, requestedPath: string): Promise<void>;
 /**
- * Re-brand a canonical image outcome into the durable attachment reference an
+ * Re-brand a structured image outcome into the durable attachment reference an
  * `ImageBlock` carries.
- * @param image - the canonical image metadata from the output schema.
+ * @param image - the image metadata from the output schema.
  * @returns the branded attachment reference.
  */
 export declare function imageRefFromValue(image: ImageReadValue['image']): ImageAttachmentRef;
 /**
  * Format an image read as the model-facing envelope beside its image block.
+ * A downscaled read names the on-disk dimensions and the multiplier that maps
+ * coordinates measured on the attached image back onto the original file.
  * @param displayPath - the backend-resolved path rendered in the envelope's `<path>` element.
- * @param image - the canonical image metadata to summarize.
+ * @param image - the image metadata to summarize.
  * @returns the model-facing envelope; the image itself rides the adjacent image block.
  */
 export declare function formatImageReadOutput(displayPath: string, image: ImageReadValue['image']): string;

package/dist/kernel/tool-fs/lib/types/read-image.js

@@ -1,13 +1,10 @@
 /**
- * The model-facing `read_image` tool: reads a PNG/JPEG/WebP/GIF file, durably
- * commits its bytes through the attachment service (the same lifecycle as a
- * user-uploaded image), and returns an image block so the image enters model
- * context from the next request onward.
+ * The model-facing `read_image` tool commits a PNG/JPEG/WebP/GIF file.
  *
- * The route gate is deliberately stricter than the host upload preflight: a
- * tool result enters durable session history, so emitting an image on a route
- * that cannot carry it would break that route's continuation. Unknown
- * capability therefore refuses instead of relying on the adapter guard.
+ * The route gate is deliberately stricter than the host upload preflight. An
+ * image-reading tool is useful only when the exact calling route can inspect
+ * its result, so unknown capability refuses instead of relying on an adapter
+ * failure after filesystem and attachment work.
  * @module @nomix-ai/nomix-tool-fs/src/read-image
  */
 import { basename, extname } from 'node:path';
@@ -22,6 +19,27 @@ const IMAGE_EXTENSIONS = {
     '.webp': 'image/webp',
     '.gif': 'image/gif',
 };
+const IMAGE_VALUE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: true,
+    properties: {
+        attachmentId: { type: 'string', required: true },
+        mediaType: { type: 'string', enum: ['image/png', 'image/jpeg', 'image/webp', 'image/gif'], required: true },
+        bytes: { type: 'integer', required: true },
+        width: { type: 'integer', required: true },
+        height: { type: 'integer', required: true },
+        name: { type: 'string' },
+        originalDimensions: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                width: { type: 'integer', required: true },
+                height: { type: 'integer', required: true },
+            },
+        },
+    },
+};
 /**
  * Map a model-supplied path to its declared image media type by extension.
  * @param filePath - the raw `file_path` argument (not yet resolved).
@@ -52,9 +70,9 @@ export async function assertImageCapableRoute(ctx, exec, requestedPath) {
     }
 }
 /**
- * Re-brand a canonical image outcome into the durable attachment reference an
+ * Re-brand a structured image outcome into the durable attachment reference an
  * `ImageBlock` carries.
- * @param image - the canonical image metadata from the output schema.
+ * @param image - the image metadata from the output schema.
  * @returns the branded attachment reference.
  */
 export function imageRefFromValue(image) {
@@ -65,24 +83,40 @@ export function imageRefFromValue(image) {
         width: image.width,
         height: image.height,
         ...image.name === undefined ? {} : { name: image.name },
+        ...image.originalDimensions === undefined ? {} : {
+            originalDimensions: { ...image.originalDimensions },
+        },
     };
 }
 /**
  * Format an image read as the model-facing envelope beside its image block.
+ * A downscaled read names the on-disk dimensions and the multiplier that maps
+ * coordinates measured on the attached image back onto the original file.
  * @param displayPath - the backend-resolved path rendered in the envelope's `<path>` element.
- * @param image - the canonical image metadata to summarize.
+ * @param image - the image metadata to summarize.
  * @returns the model-facing envelope; the image itself rides the adjacent image block.
  */
 export function formatImageReadOutput(displayPath, image) {
+    let scaled = '';
+    if (image.originalDimensions !== undefined) {
+        // Integer rounding can give the two axes slightly different ratios, so the
+        // advice names one multiplier only when both round to the same value.
+        const x = (image.originalDimensions.width / image.width).toFixed(2);
+        const y = (image.originalDimensions.height / image.height).toFixed(2);
+        const advice = x === y
+            ? `multiply coordinates by ${x}`
+            : `multiply x coordinates by ${x} and y coordinates by ${y}`;
+        scaled = ` (downscaled from ${image.originalDimensions.width}x${image.originalDimensions.height} px; ${advice} to locate features in the original file)`;
+    }
     return `<path>${displayPath}</path>
 <type>image</type>
 <content>
-${image.mediaType} image, ${image.width}x${image.height} px, ${image.bytes} bytes
+${image.mediaType} image, ${image.width}x${image.height} px, ${image.bytes} bytes${scaled}
 </content>`;
 }
 /**
- * Project one canonical image read into its model-facing envelope and image.
- * @param value - the canonical image-read outcome.
+ * Project one structured image read into its model-facing envelope and image.
+ * @param value - the image-read outcome.
  * @returns the two content blocks used by native and nested dispatches.
  */
 function imageReadContent(value) {
@@ -103,7 +137,9 @@ function imageReadContent(value) {
 export function applyReadImageTool(ctx) {
     ctx.tools.register(defineTool({
         name: 'read_image',
-        description: 'Read a PNG/JPEG/WebP/GIF file and return the image itself. Requires the current model to accept image input.',
+        description: 'Read a PNG/JPEG/WebP/GIF file and return the image itself. '
+            + 'Harness validates and downscales large supported images before the next model request, so use this tool directly instead of installing image libraries or creating thumbnails merely to inspect an image. '
+            + 'Independent files may be read concurrently in small batches. Requires the current model to accept image input.',
         parameters: {
             file_path: { type: 'string', required: true, description: 'Path to the image file, resolved by the filesystem backend.' },
         },
@@ -113,19 +149,7 @@ export function applyReadImageTool(ctx) {
                 additionalProperties: false,
                 properties: {
                     path: { type: 'string', required: true },
-                    image: {
-                        type: 'object',
-                        additionalProperties: false,
-                        required: true,
-                        properties: {
-                            attachmentId: { type: 'string', required: true },
-                            mediaType: { type: 'string', enum: ['image/png', 'image/jpeg', 'image/webp', 'image/gif'], required: true },
-                            bytes: { type: 'integer', required: true },
-                            width: { type: 'integer', required: true },
-                            height: { type: 'integer', required: true },
-                            name: { type: 'string' },
-                        },
-                    },
+                    image: IMAGE_VALUE_SCHEMA,
                 },
             },
             render: (_args, value) => imageReadContent(value),
@@ -162,7 +186,24 @@ export function applyReadImageTool(ctx) {
                 ref = await attachments.saveImage({ data, mediaType, name: basename(target.displayPath) });
             }
             catch (error) {
-                if (!(error instanceof AttachmentError) || error.code !== 'IMAGE_TYPE_MISMATCH')
+                if (!(error instanceof AttachmentError))
+                    throw error;
+                // Dimension refusals stay recoverable tool errors: an oversized image
+                // must never enter durable history, where it would ride every later
+                // model request past provider-side dimension rejections.
+                if (error.code === 'IMAGE_DIMENSION_TOO_LARGE') {
+                    throw new Error(`cannot read "${target.displayPath}": at least one image side exceeds the ${attachments.imageLimits.maxImageDimension}px limit; downscale the image and read the smaller copy`, { cause: error });
+                }
+                if (error.code === 'IMAGE_TOO_MANY_PIXELS') {
+                    throw new Error(`cannot read "${target.displayPath}": the image exceeds the ${attachments.imageLimits.maxImagePixels}-pixel decoded-size limit; downscale the image and read the smaller copy`, { cause: error });
+                }
+                if (error.code === 'IMAGE_TOO_LARGE') {
+                    throw new Error(`cannot read "${target.displayPath}": the image cannot be stored within the deployment's byte limits; downscale the image and read the smaller copy`, { cause: error });
+                }
+                if (error.code === 'ATTACHMENT_WRITE_FAILED' && /16-bit PNG/iu.test(error.message)) {
+                    throw new Error(`cannot read "${target.displayPath}": the 16-bit PNG could not be converted to the normalized 8-bit sRGB form; convert it to an 8-bit PNG/JPEG/WebP and retry`, { cause: error });
+                }
+                if (error.code !== 'IMAGE_TYPE_MISMATCH')
                     throw error;
                 const extension = extname(target.displayPath).toLowerCase();
                 throw new Error(`cannot read "${target.displayPath}": the ${extension} extension declares ${mediaType}, but the bytes use a different image format; rename the file to match its actual format if it is PNG/JPEG/WebP/GIF, or convert it to one of those formats`, { cause: error });
@@ -177,6 +218,9 @@ export function applyReadImageTool(ctx) {
                     width: ref.width,
                     height: ref.height,
                     ...ref.name === undefined ? {} : { name: ref.name },
+                    ...ref.originalDimensions === undefined ? {} : {
+                        originalDimensions: { ...ref.originalDimensions },
+                    },
                 },
             };
             return value;

package/dist/kernel/tool-fs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-fs",
   "description": "Model-facing filesystem tools (read, write, edit) over the Nomix Harness filesystem seam (ctx.fs)",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-fs-search/lib/index.js

@@ -2,6 +2,7 @@ import z from "../../schemastery/lib/index.mjs";
 import { MAX_TIMER_DELAY_MS } from "../../timeout/lib/index.js";
 import { isAbsolute, relative, sep } from "node:path";
 import { defineTool } from "../../tools/lib/index.js";
+import { existsSync } from "node:fs";
 import { HarnessError } from "../../llm/lib/index.js";
 import { ItemRetainer, TextRetainer } from "../../output-retention/lib/index.js";
 //#region lib/types/search-core.js
@@ -107,18 +108,21 @@ let rgPathPromise;
 /**
 * The packaged ripgrep binary path, resolved lazily once per process.
 *
-* `@vscode/ripgrep` resolves its platform package (`@vscode/ripgrep-<platform>
-* -<arch>`) at module evaluation, so a static import would turn a missing or
-* corrupt platform package (`pnpm install --omit=optional`, partial install)
-* into a failure of the whole Loader composition. Resolving at the call
-* boundary keeps that failure at the first search call as `SEARCH_FAILED` —
-* the package's documented no-load-time-probe contract.
+* A single-file runtime uses the executable's `-rg` sidecar because a native
+* helper cannot be spawned from pkg's virtual filesystem. Node-mode builds
+* fall back to the platform package selected by `@vscode/ripgrep`. Resolving
+* at the call boundary keeps a missing or corrupt binary at the first search
+* call as `SEARCH_FAILED`, rather than failing the Loader composition.
 *
 * @returns the packaged binary's absolute path; the memoized promise rejects
 *   when the platform package cannot be resolved.
 */
 function resolveRgPath() {
-	rgPathPromise ??= import("@vscode/ripgrep").then((module) => module.rgPath);
+	rgPathPromise ??= Promise.resolve().then(async () => {
+		const executableSidecar = `${process.execPath}-rg`;
+		if ("pkg" in process && existsSync(executableSidecar)) return executableSidecar;
+		return (await import("@vscode/ripgrep")).rgPath;
+	});
 	return rgPathPromise;
 }
 /**

package/dist/kernel/tool-fs-search/lib/types/search-core.d.ts

@@ -87,12 +87,11 @@ export interface RipgrepRun {
 /**
  * The packaged ripgrep binary path, resolved lazily once per process.
  *
- * `@vscode/ripgrep` resolves its platform package (`@vscode/ripgrep-<platform>
- * -<arch>`) at module evaluation, so a static import would turn a missing or
- * corrupt platform package (`pnpm install --omit=optional`, partial install)
- * into a failure of the whole Loader composition. Resolving at the call
- * boundary keeps that failure at the first search call as `SEARCH_FAILED` —
- * the package's documented no-load-time-probe contract.
+ * A single-file runtime uses the executable's `-rg` sidecar because a native
+ * helper cannot be spawned from pkg's virtual filesystem. Node-mode builds
+ * fall back to the platform package selected by `@vscode/ripgrep`. Resolving
+ * at the call boundary keeps a missing or corrupt binary at the first search
+ * call as `SEARCH_FAILED`, rather than failing the Loader composition.
  *
  * @returns the packaged binary's absolute path; the memoized promise rejects
  *   when the platform package cannot be resolved.

package/dist/kernel/tool-fs-search/lib/types/search-core.js

@@ -18,6 +18,7 @@
  *
  * @module @nomix-ai/nomix-tool-fs-search/search-core
  */
+import { existsSync } from 'node:fs';
 import { isAbsolute, relative, sep } from 'node:path';
 import { HarnessError } from '../../../llm/lib/index.js';
 import { ItemRetainer, TextRetainer } from '../../../output-retention/lib/index.js';
@@ -108,18 +109,22 @@ let rgPathPromise;
 /**
  * The packaged ripgrep binary path, resolved lazily once per process.
  *
- * `@vscode/ripgrep` resolves its platform package (`@vscode/ripgrep-<platform>
- * -<arch>`) at module evaluation, so a static import would turn a missing or
- * corrupt platform package (`pnpm install --omit=optional`, partial install)
- * into a failure of the whole Loader composition. Resolving at the call
- * boundary keeps that failure at the first search call as `SEARCH_FAILED` —
- * the package's documented no-load-time-probe contract.
+ * A single-file runtime uses the executable's `-rg` sidecar because a native
+ * helper cannot be spawned from pkg's virtual filesystem. Node-mode builds
+ * fall back to the platform package selected by `@vscode/ripgrep`. Resolving
+ * at the call boundary keeps a missing or corrupt binary at the first search
+ * call as `SEARCH_FAILED`, rather than failing the Loader composition.
  *
  * @returns the packaged binary's absolute path; the memoized promise rejects
  *   when the platform package cannot be resolved.
  */
 export function resolveRgPath() {
-    rgPathPromise ??= import('@vscode/ripgrep').then(module => module.rgPath);
+    rgPathPromise ??= Promise.resolve().then(async () => {
+        const executableSidecar = `${process.execPath}-rg`;
+        if ('pkg' in process && existsSync(executableSidecar))
+            return executableSidecar;
+        return (await import('@vscode/ripgrep')).rgPath;
+    });
     return rgPathPromise;
 }
 /**

package/dist/kernel/tool-fs-search/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-fs-search",
   "description": "Model-facing filesystem discovery tools (glob, grep) backed by the packaged ripgrep binary (@vscode/ripgrep)",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-goal/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-goal",
   "description": "Model-facing same-session goal tools with execution-time authority checks",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-jobs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-jobs",
   "description": "Model-facing background job control tools (job_output, job_list, job_kill) over the ctx.jobs registry",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-lsp/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-lsp",
   "description": "Model-facing lsp tool over the Nomix Harness LSP capability seam (ctx.lsp) — one read-only tool with goToDefinition/findReferences/goToImplementation/hover operations, one-based UTF-16 cursor coordinates, bounded location rendering, and hover normalization",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-pwsh/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-pwsh",
   "description": "Model-facing pwsh tool over the bash executor seam",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },