@inflexa-ai/harness 0.33.1 → 0.35.0

package/dist/tools/sandbox/list-available-packages.d.ts

@@ -9,12 +9,10 @@
  * planning surface reads the pool-scope inventory (`readPoolInventory`) —
  * everything the store holds, whether or not a farm links it yet — because
  * the ask flow marks the packages the POOL does not hold, and the farm of a
- * new analysis is empty. The baked image inventory fragment
- * (`image-packages.txt`, at `/opt/inflexa` in the image) merges into either
- * report when the host can read one. The fragment keeps the section format:
- *
- *     ## System tools (CLI)
- *     samtools, bcftools, ...
+ * new analysis is empty. The image inventory record (`image-packages.json`,
+ * at the root of the package store) merges into either report when the host
+ * can read one: it carries the conda tools and the Node packages the image
+ * owns, which the content-addressed store cannot hold.
  *
  * Each entry renders as `name==version` where the source pins a version, and
  * a targeted `names` lookup also carries the store directory and the full
@@ -23,6 +21,7 @@
  */
 import type { EnvironmentStorePaths, PoolInventoryPackage, PoolInventorySection } from "../../config/environment-stores.js";
 import { type FarmLock } from "../../sandbox/farm.js";
+import { type ImagePackages } from "../../sandbox/image-packages.js";
 /**
  * Group the lock packages into sections, one per track, in a stable order:
  * the known tracks first, then an unknown track at its first occurrence.
@@ -30,9 +29,19 @@ import { type FarmLock } from "../../sandbox/farm.js";
  * targeted `names` path can report the exact store identity.
  */
 export declare function lockSections(lock: FarmLock): Section[];
+/**
+ * Group the image record into its two sections, in the order of the record.
+ * An empty track yields no section, so the report never carries a heading
+ * with nothing under it.
+ *
+ * A `system_tools` row renders its `executable` name where the record gives
+ * one, because an agent invokes the binary rather than the conda package
+ * (the manifest `binaries:` map holds the pairs that differ).
+ */
+export declare function imageSections(record: ImagePackages): Section[];
 /** One package entry of a section, with the store identity where the source records it. */
 export type SectionPackage = PoolInventoryPackage;
-/** One language track of the store, in `packages.txt` section order. The seam shape and the render shape are one. */
+/** One language track of the store, in the section order of its source. The seam shape and the render shape are one. */
 export type Section = PoolInventorySection;
 /** One `names` lookup: present + canonical spelling + track + store identity, or absent. */
 export type CheckedPackage = {
@@ -65,13 +74,6 @@ export type PackagesResult = {
     readonly hasMore: boolean;
     readonly content: string;
 };
-/**
- * Parse `packages.txt` into its sections. `#` lines are the advisory header,
- * `## X` opens a section, and every other non-empty line contributes
- * comma-separated package names to the open section. Unknown section headings
- * are preserved as-is — a downstream image may add its own track.
- */
-export declare function parsePackagesFile(content: string): Section[];
 /** The tool's input, as parsed from `inputSchema`. */
 export interface PackagesQuery {
     readonly names?: readonly string[];
@@ -83,7 +85,7 @@ export interface PackagesQuery {
  * Answer a packages query against a parsed catalog. Pure — the tool's `execute`
  * is only the file read plus this call.
  */
-export declare function queryPackages(sections: readonly Section[], { names, query, language, limit }: PackagesQuery): PackagesResult;
+export declare function queryPackages(rawSections: readonly Section[], { names, query, language, limit }: PackagesQuery): PackagesResult;
 export type ListAvailablePackagesDeps = Pick<EnvironmentStorePaths, "farmLockFile" | "imagePackagesFile" | "readPoolInventory"> & {
     /**
      * True when the composition also attaches the `link_packages` tool. The
@@ -96,7 +98,7 @@ export type ListAvailablePackagesDeps = Pick<EnvironmentStorePaths, "farmLockFil
  * Create the package inventory over the bound source: the pool-scope reader
  * when the embedder binds one (a conversation or planning surface), the
  * host-readable farm `inflexa.lock` otherwise (a sandbox agent). The image
- * fragment merges into either report.
+ * record merges into either report.
  */
 export declare function createListAvailablePackagesTool(deps?: ListAvailablePackagesDeps): import("../define-tool.js").Tool<{
     names?: string[] | undefined;

package/dist/tools/sandbox/list-available-packages.js

@@ -9,25 +9,23 @@
  * planning surface reads the pool-scope inventory (`readPoolInventory`) —
  * everything the store holds, whether or not a farm links it yet — because
  * the ask flow marks the packages the POOL does not hold, and the farm of a
- * new analysis is empty. The baked image inventory fragment
- * (`image-packages.txt`, at `/opt/inflexa` in the image) merges into either
- * report when the host can read one. The fragment keeps the section format:
- *
- *     ## System tools (CLI)
- *     samtools, bcftools, ...
+ * new analysis is empty. The image inventory record (`image-packages.json`,
+ * at the root of the package store) merges into either report when the host
+ * can read one: it carries the conda tools and the Node packages the image
+ * owns, which the content-addressed store cannot hold.
  *
  * Each entry renders as `name==version` where the source pins a version, and
  * a targeted `names` lookup also carries the store directory and the full
  * content hash where the source records them. A full listing carries no
  * hashes — a thousand rows of sha256 would bury the signal.
  */
-import { readFile } from "node:fs/promises";
 import { ok } from "neverthrow";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
 import { capCodePoints, DETAIL_NEEDLE_MAX_LENGTH } from "../../loop/tool-detail.js";
 import { LIBS_CONTAINER_PATH } from "../../sandbox/mount-plan.js";
 import { readFarmLockFile } from "../../sandbox/farm.js";
+import { IMAGE_PACKAGES_FILE, readImagePackagesFile } from "../../sandbox/image-packages.js";
 /**
  * Where the lock lives when the host mounts the farm at the same path the
  * sandbox does. Both farm container paths are tried, because the path keys on
@@ -36,15 +34,30 @@ import { readFarmLockFile } from "../../sandbox/farm.js";
  * reads the farm somewhere else injects its own path instead.
  */
 const DEFAULT_FARM_LOCK_FILES = [`${LIBS_CONTAINER_PATH}/farm/inflexa.lock`, `${LIBS_CONTAINER_PATH}/current/inflexa.lock`];
-/** Where the baked image inventory fragment lives inside the image. */
-const DEFAULT_IMAGE_PACKAGES_FILE = "/opt/inflexa/image-packages.txt";
+/**
+ * Where the image inventory record lives: at the root of the package store,
+ * which the catalog build copied it into. The default names the container
+ * mountpoint of that store, the same rule as {@link DEFAULT_FARM_LOCK_FILES}
+ * — a host whose own process sees the store the way a sandbox does needs no
+ * configuration. A host that reads the store somewhere else injects
+ * `imagePackagesFile`.
+ */
+const DEFAULT_IMAGE_PACKAGES_FILE = `${LIBS_CONTAINER_PATH}/${IMAGE_PACKAGES_FILE}`;
+/**
+ * The two headings that a lock track and the image record can both carry.
+ * Declared once, because {@link LANGUAGE_MATCHERS} keys the `language` filter
+ * on the heading text, and {@link foldSections} merges two sources by it: a
+ * second spelling of either would split one track into two headings.
+ */
+const CLI_TITLE = "System tools (CLI)";
+const NODE_TITLE = "Node (npm)";
 /** The section title of each known lock track. An unknown track titles itself. */
 const TRACK_TITLES = {
     python: "Python (pip)",
     cran: "R (CRAN)",
     bioconductor: "R (Bioconductor)",
     github: "R (GitHub)",
-    node: "Node (npm)",
+    node: NODE_TITLE,
 };
 /**
  * Group the lock packages into sections, one per track, in a stable order:
@@ -66,6 +79,56 @@ export function lockSections(lock) {
     }
     return [...byTrack.entries()].filter(([, packages]) => packages.length > 0).map(([track, packages]) => ({ title: TRACK_TITLES[track] ?? track, packages }));
 }
+/**
+ * Group the image record into its two sections, in the order of the record.
+ * An empty track yields no section, so the report never carries a heading
+ * with nothing under it.
+ *
+ * A `system_tools` row renders its `executable` name where the record gives
+ * one, because an agent invokes the binary rather than the conda package
+ * (the manifest `binaries:` map holds the pairs that differ).
+ */
+export function imageSections(record) {
+    const sections = [];
+    if (record.system_tools.length > 0) {
+        sections.push({
+            title: CLI_TITLE,
+            packages: record.system_tools.map((tool) => ({ name: tool.executable ?? tool.name, version: tool.version })),
+        });
+    }
+    if (record.node.length > 0) {
+        sections.push({ title: NODE_TITLE, packages: record.node.map((pkg) => ({ name: pkg.name, version: pkg.version })) });
+    }
+    return sections;
+}
+/**
+ * Merge the sections that share a title, in first-occurrence order, and keep
+ * the first entry of each name inside a merged section.
+ *
+ * Two sources can carry one track: the `node` track of a farm lock and the
+ * `node` track of the image record. Rendered as they arrive, a listing would
+ * print one heading twice and read as two tracks. The fold keeps the first
+ * writer, which is the same rule the `names` index applies, thus the listing
+ * and the presence check agree on which entry a colliding name resolves to.
+ */
+function foldSections(sections) {
+    const byTitle = new Map();
+    for (const section of sections) {
+        let open = byTitle.get(section.title);
+        if (!open) {
+            open = { title: section.title, packages: [], seen: new Set() };
+            byTitle.set(section.title, open);
+        }
+        for (const pkg of section.packages) {
+            const key = pkg.name.toLowerCase();
+            if (open.seen.has(key))
+                continue;
+            open.seen.add(key);
+            open.packages.push(pkg);
+        }
+    }
+    return [...byTitle.values()].map(({ title, packages }) => ({ title, packages }));
+}
 /**
  * Default cap on a listing — high enough that the real store is never truncated.
  * The shipped catalog is ~270 packages (~3 KB, well under a thousand tokens), so
@@ -98,39 +161,10 @@ const LANGUAGE_MATCHERS = {
     // The R triple: `R (CRAN)`, `R (Bioconductor)`, `R (GitHub)`.
     r: (t) => /^r\b/i.test(t),
     python: (t) => /^python\b/i.test(t),
-    // `System tools (CLI)` — the conda-installed bioinformatics executables.
+    // `CLI_TITLE` — the conda-installed bioinformatics executables.
     cli: (t) => /system tools|\bcli\b/i.test(t),
     node: (t) => /^node\b/i.test(t),
 };
-/**
- * Parse `packages.txt` into its sections. `#` lines are the advisory header,
- * `## X` opens a section, and every other non-empty line contributes
- * comma-separated package names to the open section. Unknown section headings
- * are preserved as-is — a downstream image may add its own track.
- */
-export function parsePackagesFile(content) {
-    const sections = [];
-    for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        if (trimmed.startsWith("##")) {
-            sections.push({ title: trimmed.slice(2).trim(), packages: [] });
-            continue;
-        }
-        if (trimmed.startsWith("#"))
-            continue;
-        const open = sections.at(-1);
-        if (!open)
-            continue;
-        for (const name of trimmed.split(",")) {
-            const pkg = name.trim();
-            if (pkg)
-                open.packages.push({ name: pkg });
-        }
-    }
-    return sections;
-}
 /** One entry as the listing renders it: `name==version` where the source pins a version, the bare name otherwise. */
 function renderPackage(entry) {
     return entry.version === undefined ? entry.name : `${entry.name}==${entry.version}`;
@@ -160,15 +194,16 @@ function renderListing(sections, limit) {
  * Answer a packages query against a parsed catalog. Pure — the tool's `execute`
  * is only the file read plus this call.
  */
-export function queryPackages(sections, { names, query, language, limit }) {
+export function queryPackages(rawSections, { names, query, language, limit }) {
+    const sections = foldSections(rawSections);
     // Presence check — the cheap, targeted path. Answers "is X available, and in
     // which track" without returning the catalog.
     if (names && names.length > 0) {
         const index = new Map();
         for (const section of sections) {
             for (const pkg of section.packages) {
-                // First writer wins: `packages.txt` sections are ordered, so a name
-                // colliding across tracks resolves to the earliest one.
+                // First writer wins: the sections arrive in a fixed order, so a
+                // name colliding across tracks resolves to the earliest one.
                 if (!index.has(pkg.name.toLowerCase()))
                     index.set(pkg.name.toLowerCase(), { entry: pkg, section: section.title });
             }
@@ -219,7 +254,7 @@ export function queryPackages(sections, { names, query, language, limit }) {
  * Create the package inventory over the bound source: the pool-scope reader
  * when the embedder binds one (a conversation or planning surface), the
  * host-readable farm `inflexa.lock` otherwise (a sandbox agent). The image
- * fragment merges into either report.
+ * record merges into either report.
  */
 export function createListAvailablePackagesTool(deps = {}) {
     const lockCandidates = deps.farmLockFile ? [deps.farmLockFile] : DEFAULT_FARM_LOCK_FILES;
@@ -284,12 +319,15 @@ export function createListAvailablePackagesTool(deps = {}) {
             return "full package list";
         },
         execute: async (input) => {
-            // The baked image fragment merges in when the host can read one; a
-            // missing fragment merges nothing, and that is the normal state for
-            // a host that runs outside the image.
-            const fragmentSections = await readFile(imagePackagesFile, "utf-8")
-                .then(parsePackagesFile)
-                .catch(() => []);
+            // The image record merges in when the host can read a valid one.
+            // An absent record and an invalid record both merge nothing, and
+            // neither is an error: the record is an enrichment, and the farm
+            // or pool inventory stays whole without it. A store packed before
+            // the record existed carries none. The tool holds no logger, thus
+            // an invalid record cannot be reported here — the schema of the
+            // harness refuses it, and the report degrades to the tracks it
+            // could read.
+            const recordSections = readImagePackagesFile(imagePackagesFile).map(imageSections).unwrapOr([]);
             // An unreadable inventory is an expected environment state — model it as an
             // `available: false` data variant telling the caller the set is UNKNOWN,
             // WITH the reason: without it, a structural fault (a damaged dependency
@@ -301,7 +339,7 @@ export function createListAvailablePackagesTool(deps = {}) {
                 }));
                 if (pool.kind === "unavailable")
                     return ok({ available: false, content: `${POOL_UNAVAILABLE_NOTE} The reason: ${pool.reason}.` });
-                return ok(queryPackages([...pool.sections, ...fragmentSections], input));
+                return ok(queryPackages([...pool.sections, ...recordSections], input));
             }
             let lock = null;
             for (const candidate of lockCandidates) {
@@ -312,7 +350,7 @@ export function createListAvailablePackagesTool(deps = {}) {
             if (lock === null) {
                 return ok({ available: false, content: UNAVAILABLE_NOTE });
             }
-            return ok(queryPackages([...lockSections(lock), ...fragmentSections], input));
+            return ok(queryPackages([...lockSections(lock), ...recordSections], input));
         },
     });
 }

package/dist/tools/workspace/edit-file.d.ts

@@ -1,14 +1,17 @@
 /**
- * `edit_file` — sandbox-gated workspace edit, confined to the agent's writable
- * working directory. Composes the read seam (fetch current content) with a
+ * `edit_file` — workspace edit, confined to the agent's writable working
+ * directory. Composes the read seam (fetch current content) with a
  * search/replace and the `WorkspaceMutator` seam (write the result) — same
  * resolution + confinement contract as `write_file`, no path logic of its own
  * (see the harness-workspace-tools spec).
  *
  * Edit semantics: replace `old_string` with `new_string`. `old_string` MUST
  * occur in the file; when `replace_all` is false (default) it MUST occur
- * exactly once. Provenance hashes the post-edit content — recorded by the
- * mutator.
+ * exactly once. With `regex=true`, `old_string` is a JS RegExp pattern
+ * (compiled with the `gm` flags — multiline anchors), `new_string` may use
+ * capture-group references, and exactly one of `replace_all=true` or
+ * `expected_matches` gates the write. Provenance hashes the post-edit
+ * content — recorded by the mutator.
  */
 import type { WorkspaceFilesystem } from "../../workspace/filesystem.js";
 import type { WorkspaceMutator, WriteFileResult } from "./mutator.js";
@@ -23,6 +26,21 @@ export type EditFileResult = {
     readonly status: "not_unique";
     readonly path: string;
     readonly occurrences: number;
+} | {
+    readonly status: "invalid_pattern";
+    readonly path: string;
+    readonly pattern: string;
+    readonly error: string;
+} | {
+    readonly status: "invalid_arguments";
+    readonly path: string;
+    readonly reason: string;
+} | {
+    readonly status: "match_count_mismatch";
+    readonly path: string;
+    readonly expected: number;
+    readonly actual: number;
+    readonly lines: readonly number[];
 } | Exclude<WriteFileResult, {
     status: "ok";
 }> | {
@@ -30,17 +48,25 @@ export type EditFileResult = {
     readonly path: string;
     readonly replacements: number;
     readonly bytesWritten: number;
+    /** Regex mode only: 1-based line numbers where the matches started. */
+    readonly lines?: readonly number[];
 };
 export interface EditFileDeps {
     readonly mutator: WorkspaceMutator;
     /** Read seam used to fetch current file content for search/replace. */
     readonly workspaceFilesystem: WorkspaceFilesystem;
-    /** Absolute host working directory — relative read/write paths resolve here. */
-    readonly workingDir: string;
+    /**
+     * Absolute host working directory — relative read paths resolve here. Omit
+     * for the conversation agent: the read seam then defaults to the analysis
+     * root, matching the session-scoped mutator's write prefix.
+     */
+    readonly workingDir?: string;
 }
 export declare function createEditFileTool(deps: EditFileDeps): import("../define-tool.js").Tool<{
     path: string;
     old_string: string;
     new_string: string;
     replace_all: boolean;
+    regex: boolean;
+    expected_matches?: number | undefined;
 }, EditFileResult>;

package/dist/tools/workspace/edit-file.js

@@ -1,14 +1,17 @@
 /**
- * `edit_file` — sandbox-gated workspace edit, confined to the agent's writable
- * working directory. Composes the read seam (fetch current content) with a
+ * `edit_file` — workspace edit, confined to the agent's writable working
+ * directory. Composes the read seam (fetch current content) with a
  * search/replace and the `WorkspaceMutator` seam (write the result) — same
  * resolution + confinement contract as `write_file`, no path logic of its own
  * (see the harness-workspace-tools spec).
  *
  * Edit semantics: replace `old_string` with `new_string`. `old_string` MUST
  * occur in the file; when `replace_all` is false (default) it MUST occur
- * exactly once. Provenance hashes the post-edit content — recorded by the
- * mutator.
+ * exactly once. With `regex=true`, `old_string` is a JS RegExp pattern
+ * (compiled with the `gm` flags — multiline anchors), `new_string` may use
+ * capture-group references, and exactly one of `replace_all=true` or
+ * `expected_matches` gates the write. Provenance hashes the post-edit
+ * content — recorded by the mutator.
  */
 import { ok } from "neverthrow";
 import { z } from "zod";
@@ -22,15 +25,31 @@ const EditFileInputSchema = z.object({
     old_string: z
         .string()
         .min(1)
-        .describe("The exact text to find and replace. Must occur in the file. When " +
-        "replace_all=false (default), must occur exactly once — include " +
+        .describe("The exact text to find and replace — or, when regex=true, a " +
+        "JavaScript regular expression pattern. In exact mode with " +
+        "replace_all=false (default), it must occur exactly once — include " +
         "enough surrounding context to make it unique."),
-    new_string: z.string().describe("The replacement text."),
+    new_string: z.string().describe("The replacement text. When regex=true it may use capture-group references such as $1."),
     replace_all: z
         .boolean()
         .optional()
         .default(false)
         .describe("If true, replace every occurrence. If false (default), old_string " + "must occur exactly once or the edit returns a `not_unique` data variant."),
+    regex: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("If true, old_string is a JavaScript regular expression compiled with " +
+        "the `gm` flags (^ and $ match line boundaries). Requires exactly one " +
+        "of replace_all=true or expected_matches."),
+    expected_matches: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Regex mode only: the exact number of matches you expect. On a " +
+        "mismatch the edit writes nothing and returns the actual count with " +
+        "the matching line numbers."),
 });
 function replaceString(content, oldString, newString, replaceAll) {
     if (!content.includes(oldString))
@@ -54,48 +73,115 @@ function replaceString(content, oldString, newString, replaceAll) {
         replacements: 1,
     };
 }
+/** 1-based line numbers of the given start offsets (ascending), deduplicated. */
+function lineNumbersAt(content, offsets) {
+    const lines = [];
+    let line = 1;
+    let cursor = 0;
+    for (const offset of offsets) {
+        for (; cursor < offset; cursor++) {
+            if (content.charCodeAt(cursor) === 10)
+                line++;
+        }
+        if (lines[lines.length - 1] !== line)
+            lines.push(line);
+    }
+    return lines;
+}
+function replaceRegex(content, pattern, replacement, expected) {
+    let compiled;
+    try {
+        compiled = new RegExp(pattern, "gm");
+    }
+    catch (err) {
+        return { kind: "invalid_pattern", error: err instanceof Error ? err.message : String(err) };
+    }
+    const matches = [...content.matchAll(compiled)];
+    if (matches.length === 0)
+        return { kind: "not_found" };
+    const lines = lineNumbersAt(content, matches.map((match) => match.index));
+    if (expected !== undefined && matches.length !== expected) {
+        return { kind: "count_mismatch", expected, actual: matches.length, lines };
+    }
+    return { kind: "ok", content: content.replace(compiled, replacement), replacements: matches.length, lines };
+}
 export function createEditFileTool(deps) {
     return defineTool({
         id: "edit_file",
-        // Body-only `awaitExec`-recv → runs unwrapped in the workflow body (see the harness-tools spec).
+        // The mutator wraps the disk mutation in `ctx.runStep` itself, so the
+        // body runs unwrapped in the workflow body (see the harness-tools spec).
         executionMode: "workflow",
         description: "Edit a file in your working directory by replacing specific text. " +
             "Read the file first to get the exact text. When replace_all is false " +
-            "(default), old_string must occur exactly once. Returns `out_of_prefix` " +
-            "/ `out_of_scope` / `file_not_found` / `not_found` / `not_unique` data " +
-            "variants — never throws on expected outcomes.",
+            "(default), old_string must occur exactly once. For a bulk pattern " +
+            "edit set regex=true: old_string is a JS regex, new_string may use $1 " +
+            "references, and exactly one of replace_all=true or expected_matches " +
+            "gates the write. Returns `out_of_prefix` / `out_of_scope` / " +
+            "`file_not_found` / `not_found` / `not_unique` / `match_count_mismatch` " +
+            "data variants — never throws on expected outcomes.",
         inputSchema: EditFileInputSchema,
         // The path only. The replaced text is file content, not a description.
         describeCall: ({ path }) => path,
-        execute: async ({ path, old_string, new_string, replace_all }, ctx) => {
+        execute: async ({ path, old_string, new_string, replace_all, regex, expected_matches }, ctx) => {
+            const replaceAll = replace_all === true;
+            const useRegex = regex === true;
+            if (!useRegex && expected_matches !== undefined) {
+                return ok({ status: "invalid_arguments", path, reason: "expected_matches requires regex=true." });
+            }
+            if (useRegex && (expected_matches !== undefined) === replaceAll) {
+                return ok({
+                    status: "invalid_arguments",
+                    path,
+                    reason: "regex=true requires exactly one of replace_all=true or expected_matches.",
+                });
+            }
             const read = unwrapOrThrow(await deps.workspaceFilesystem.readFile({
                 session: ctx.session,
                 path,
-                workingDir: deps.workingDir,
+                ...(deps.workingDir !== undefined ? { workingDir: deps.workingDir } : {}),
             }));
             if (read.kind === "not_found")
                 return ok({ status: "file_not_found", path });
             if (read.kind === "out_of_scope")
                 return ok({ status: "out_of_scope", path });
-            const replaced = replaceString(read.content.toString("utf8"), old_string, new_string, replace_all);
+            const content = read.content.toString("utf8");
+            const replaced = useRegex
+                ? replaceRegex(content, old_string, new_string, expected_matches)
+                : replaceString(content, old_string, new_string, replaceAll);
             if (replaced.kind === "not_found")
                 return ok({ status: "not_found", path });
             if (replaced.kind === "not_unique") {
                 return ok({ status: "not_unique", path, occurrences: replaced.count });
             }
+            if (replaced.kind === "invalid_pattern") {
+                return ok({ status: "invalid_pattern", path, pattern: old_string, error: replaced.error });
+            }
+            if (replaced.kind === "count_mismatch") {
+                return ok({
+                    status: "match_count_mismatch",
+                    path,
+                    expected: replaced.expected,
+                    actual: replaced.actual,
+                    lines: replaced.lines,
+                });
+            }
             const result = await deps.mutator.writeFile({
                 path,
                 content: replaced.content,
                 toolName: "edit_file",
-                emit: ctx.emit,
+                invocationId: ctx.invocationId,
+                runStep: ctx.runStep,
+                session: ctx.session,
             });
             if (result.status !== "ok")
                 return ok(result);
+            const lines = replaced.lines;
             return ok({
                 status: "ok",
                 path: result.path,
                 replacements: replaced.replacements,
                 bytesWritten: result.bytesWritten,
+                ...(lines === undefined ? {} : { lines }),
             });
         },
     });