xcoder-dna 0.0.0-stage → 1.3.1

package/dist/tools/index-freshness.d.ts

@@ -0,0 +1,58 @@
+import { type WorkspaceIndex } from "./workspace-index.js";
+/** The stat-only subset of an index entry that staleness detection needs. */
+export interface ManifestEntry {
+    relPath: string;
+    sizeBytes: number;
+    mtimeMs: number;
+}
+export interface WorkspaceManifest {
+    root: string;
+    scannedAt: string;
+    entries: ManifestEntry[];
+}
+/** Stat-only walk of the tree. Never throws; unreadable paths are skipped. */
+export declare function scanManifest(root: string): Promise<WorkspaceManifest>;
+export interface FreshnessCounts {
+    added: number;
+    removed: number;
+    changed: number;
+}
+export interface FreshnessVerdict {
+    fresh: boolean;
+    /** Machine-readable cause; `ok` when nothing differs. */
+    reason: "ok" | "added" | "removed" | "changed" | "empty-index";
+    added: string[];
+    removed: string[];
+    changed: string[];
+    /** Totals, regardless of how many paths the arrays carry. */
+    counts: FreshnessCounts;
+}
+/**
+ * Pure comparison of a stored index against a freshly scanned manifest.
+ *
+ * Free of I/O so the comparator is directly unit-testable and reusable
+ * without accidentally triggering a rebuild.
+ */
+export declare function diffIndexAgainstManifest(index: WorkspaceIndex, manifest: WorkspaceManifest, maxReportedPaths?: number): FreshnessVerdict;
+export type EnsureFreshAction = "reused" | "rebuilt" | "degraded";
+export interface EnsureFreshResult {
+    /** Always usable — an empty-but-valid index if the tree could not be read. */
+    index: WorkspaceIndex;
+    action: EnsureFreshAction;
+    reason: string;
+    counts: FreshnessCounts;
+    durationMs: number;
+}
+export interface EnsureFreshOptions {
+    /** Rebuild regardless of the probe result — backs `--reindex`. */
+    force?: boolean;
+    /** Set false to skip the manifest scan and rebuild immediately. */
+    probe?: boolean;
+    /** How many differing paths to carry in the result. */
+    maxReportedPaths?: number;
+}
+/**
+ * Gate the index before a task runs: reuse it when it still describes the
+ * tree, otherwise rebuild exactly once. Never throws.
+ */
+export declare function ensureFreshIndex(root: string, opts?: EnsureFreshOptions): Promise<EnsureFreshResult>;

package/dist/tools/index-freshness.js

@@ -0,0 +1,190 @@
+// xcoder:version 1 | xcoder:task task-e16f85 | xcoder:updated 2026-10-30T18:14:02.928Z | xcoder:subtask code-st-791be4
+// Freshness gate for the workspace index.
+//
+// The index is the source of truth for *which files exist*, so it must be
+// trustworthy before a task starts. `getOrBuildIndex()` returns any index it
+// can parse no matter how old, so a task could run its whole lifetime against
+// a snapshot that no longer describes the tree.
+//
+// Rebuilding unconditionally fixes staleness but reintroduces the exact cost
+// the index exists to avoid: `buildIndex` reads and SHA-1s every file. The
+// probe here is deliberately cheaper — it walks the tree collecting only
+// (relPath, sizeBytes, mtimeMs) and diffs that against the stored entries. No
+// file contents are read. A same-size edit inside the filesystem's mtime
+// granularity is the residual blind spot; it is bounded and self-healing via
+// `upsertEntry` on write plus the next run's probe.
+//
+// This module never throws: the index is a cache of the filesystem, not an
+// authorization artifact. The real boundary is `resolveInWorkspace()`'s escape
+// guard, which is untouched and still fails closed. Aborting a task because a
+// cache refresh hiccuped would be a denial of service for no security gain, so
+// the failure mode is `degraded`.
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { buildIndex, IGNORE_DIRS, loadIndex, MAX_INDEXED_FILE_BYTES, toPosixPath, } from "./workspace-index.js";
+/** How many differing paths a verdict carries before its arrays stop growing. */
+const DEFAULT_MAX_REPORTED_PATHS = 20;
+async function scanDir(dir, root, acc) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return; // unreadable directory — nothing to report from it
+    }
+    for (const entry of entries) {
+        // Mirrors `walk()` in workspace-index.ts exactly. Divergence here would
+        // surface as permanent false staleness (or permanent blindness).
+        if (entry.name.startsWith(".") && entry.name !== ".env.example")
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            await scanDir(full, root, acc);
+        }
+        else if (entry.isFile()) {
+            try {
+                const stat = await fs.stat(full);
+                if (stat.size > MAX_INDEXED_FILE_BYTES)
+                    continue;
+                acc.push({
+                    relPath: toPosixPath(path.relative(root, full)),
+                    sizeBytes: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                });
+            }
+            catch {
+                // raced with a delete, or unreadable — next probe reconciles
+            }
+        }
+    }
+}
+/** Stat-only walk of the tree. Never throws; unreadable paths are skipped. */
+export async function scanManifest(root) {
+    const entries = [];
+    await scanDir(root, root, entries);
+    entries.sort((a, b) => (a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0));
+    return { root, scannedAt: new Date().toISOString(), entries };
+}
+/**
+ * Pure comparison of a stored index against a freshly scanned manifest.
+ *
+ * Free of I/O so the comparator is directly unit-testable and reusable
+ * without accidentally triggering a rebuild.
+ */
+export function diffIndexAgainstManifest(index, manifest, maxReportedPaths = DEFAULT_MAX_REPORTED_PATHS) {
+    const cap = Math.max(0, maxReportedPaths);
+    const added = [];
+    const removed = [];
+    const changed = [];
+    let addedCount = 0;
+    let removedCount = 0;
+    let changedCount = 0;
+    const byPath = new Map();
+    for (const e of index.entries) {
+        byPath.set(toPosixPath(e.relPath), { sizeBytes: e.sizeBytes, mtimeMs: e.mtimeMs });
+    }
+    const builtAtMs = Date.parse(index.builtAt);
+    const builtAtKnown = Number.isFinite(builtAtMs);
+    for (const m of manifest.entries) {
+        const prior = byPath.get(m.relPath);
+        if (!prior) {
+            addedCount++;
+            if (added.length < cap)
+                added.push(m.relPath);
+            continue;
+        }
+        // A manifest entry newer than the index build is conclusive even when the
+        // size happens to match — belt and braces against same-size edits.
+        const newerThanBuild = builtAtKnown && m.mtimeMs > builtAtMs;
+        if (prior.sizeBytes !== m.sizeBytes || prior.mtimeMs !== m.mtimeMs || newerThanBuild) {
+            changedCount++;
+            if (changed.length < cap)
+                changed.push(m.relPath);
+        }
+        byPath.delete(m.relPath);
+    }
+    // Whatever is left in the map no longer exists on disk.
+    for (const stalePath of byPath.keys()) {
+        removedCount++;
+        if (removed.length < cap)
+            removed.push(stalePath);
+    }
+    const counts = { added: addedCount, removed: removedCount, changed: changedCount };
+    if (index.entries.length === 0 && manifest.entries.length > 0) {
+        return { fresh: false, reason: "empty-index", added, removed, changed, counts };
+    }
+    if (addedCount > 0)
+        return { fresh: false, reason: "added", added, removed, changed, counts };
+    if (removedCount > 0)
+        return { fresh: false, reason: "removed", added, removed, changed, counts };
+    if (changedCount > 0)
+        return { fresh: false, reason: "changed", added, removed, changed, counts };
+    return { fresh: true, reason: "ok", added, removed, changed, counts };
+}
+function emptyIndex(root) {
+    return { root, builtAt: new Date().toISOString(), entries: [] };
+}
+/**
+ * Gate the index before a task runs: reuse it when it still describes the
+ * tree, otherwise rebuild exactly once. Never throws.
+ */
+export async function ensureFreshIndex(root, opts = {}) {
+    const startedAt = Date.now();
+    const elapsed = () => Math.max(0, Date.now() - startedAt);
+    const existing = await loadIndex(root);
+    if (!opts.force && opts.probe !== false && existing) {
+        try {
+            const manifest = await scanManifest(root);
+            const verdict = diffIndexAgainstManifest(existing, manifest, opts.maxReportedPaths);
+            if (verdict.fresh) {
+                return {
+                    index: existing,
+                    action: "reused",
+                    reason: "ok",
+                    counts: verdict.counts,
+                    durationMs: elapsed(),
+                };
+            }
+            const rebuilt = await buildIndex(root);
+            return {
+                index: rebuilt,
+                action: "rebuilt",
+                reason: verdict.reason,
+                counts: verdict.counts,
+                durationMs: elapsed(),
+            };
+        }
+        catch {
+            // Probe or rebuild blew up — degrade rather than fail the task over a
+            // cache refresh.
+            return {
+                index: existing ?? (await loadIndex(root)) ?? emptyIndex(root),
+                action: "degraded",
+                reason: "probe-failed",
+                counts: { added: 0, removed: 0, changed: 0 },
+                durationMs: elapsed(),
+            };
+        }
+    }
+    try {
+        const rebuilt = await buildIndex(root);
+        return {
+            index: rebuilt,
+            action: "rebuilt",
+            reason: existing ? (opts.force ? "forced" : "probe-skipped") : "missing",
+            counts: { added: 0, removed: 0, changed: 0 },
+            durationMs: elapsed(),
+        };
+    }
+    catch {
+        return {
+            index: existing ?? (await loadIndex(root)) ?? emptyIndex(root),
+            action: "degraded",
+            reason: "build-failed",
+            counts: { added: 0, removed: 0, changed: 0 },
+            durationMs: elapsed(),
+        };
+    }
+}

package/dist/tools/index-glob.d.ts

@@ -0,0 +1,48 @@
+import type { WorkspaceIndex } from "./workspace-index.js";
+/** Hard ceiling on results so a broad pattern cannot flood a model's context. */
+export declare const MAX_GLOB_RESULTS = 5000;
+/** Hard ceiling on pattern length — model-supplied input hits a regex. */
+export declare const MAX_PATTERN_LENGTH = 512;
+/**
+ * Expand one level of `{a,b,c}` alternation into separate patterns.
+ * Nested braces are expanded recursively; an unbalanced brace is treated
+ * as a literal character. Exported for tests.
+ */
+export declare function expandBraces(pattern: string): string[];
+/**
+ * Compile a brace-free glob into an anchored RegExp.
+ *
+ * Supports `**` (any depth, `**\/` also matches zero directories), `*`
+ * (within one segment) and `?` (one character within a segment).
+ */
+export declare function globToRegExp(pattern: string): RegExp;
+export interface CompiledGlob {
+    /** True when `relPath` matches any expanded alternative. */
+    test(relPath: string): boolean;
+}
+/** Compile a (possibly brace-containing) glob once, for repeated matching. */
+export declare function compileGlob(pattern: string): CompiledGlob;
+/** Convenience: does a single relPath match this glob pattern? */
+export declare function matchesGlob(relPath: string, pattern: string): boolean;
+/**
+ * Decide whether a workspace-relative path is excluded by a set of ignore
+ * rules (as produced by `loadIgnoreRules`).
+ *
+ * Rules are matched with the same compiled-glob engine, so ignore semantics
+ * and glob semantics cannot drift apart.
+ */
+export declare function isIgnoredByRules(relPath: string, rules: readonly string[]): boolean;
+export interface GlobIndexOptions {
+    /** Ignore rules to subtract from the result set. */
+    ignore?: readonly string[];
+    /** Maximum number of results (defaults to MAX_GLOB_RESULTS). */
+    limit?: number;
+}
+/**
+ * Glob the index with zero filesystem access.
+ *
+ * Results are sorted for deterministic output and are always a subset of
+ * `index.entries[].relPath` — that containment is the property the
+ * index-only-discovery contract test asserts.
+ */
+export declare function globIndex(index: WorkspaceIndex, pattern: string, opts?: GlobIndexOptions): string[];

package/dist/tools/index-glob.js

@@ -0,0 +1,175 @@
+// xcoder:version 1 | xcoder:task task-e16f85 | xcoder:updated 2026-10-30T18:13:01.840Z | xcoder:subtask code-st-791be4
+// Pure, in-memory glob matching over `WorkspaceIndex.entries`.
+//
+// This module never touches the filesystem. It exists so that *which files
+// exist* is answered by the workspace index alone — the single source of
+// truth — instead of by an independent directory walk that can disagree
+// with it.
+//
+// The matcher was promoted from `search-tools.ts` (which had its own copy)
+// and extended with brace alternation `{a,b}`, because delegating pattern
+// matching to a second implementation is precisely the inconsistency this
+// change removes. No external dependency: `picomatch` is present on disk
+// only as a transitive hoist of `tinyglobby` and ships no type declarations,
+// so importing it would add a supply-chain edge for no behavioural gain.
+import { toPosixPath } from "./workspace-index.js";
+/** Hard ceiling on results so a broad pattern cannot flood a model's context. */
+export const MAX_GLOB_RESULTS = 5000;
+/** Hard ceiling on pattern length — model-supplied input hits a regex. */
+export const MAX_PATTERN_LENGTH = 512;
+/**
+ * Expand one level of `{a,b,c}` alternation into separate patterns.
+ * Nested braces are expanded recursively; an unbalanced brace is treated
+ * as a literal character. Exported for tests.
+ */
+export function expandBraces(pattern) {
+    const open = pattern.indexOf("{");
+    if (open === -1)
+        return [pattern];
+    let depth = 0;
+    let close = -1;
+    for (let i = open; i < pattern.length; i++) {
+        if (pattern[i] === "{")
+            depth++;
+        else if (pattern[i] === "}") {
+            depth--;
+            if (depth === 0) {
+                close = i;
+                break;
+            }
+        }
+    }
+    if (close === -1)
+        return [pattern];
+    const prefix = pattern.slice(0, open);
+    const body = pattern.slice(open + 1, close);
+    const suffix = pattern.slice(close + 1);
+    // Split the body on top-level commas only (so `{a,{b,c}}` splits correctly).
+    const parts = [];
+    let partStart = 0;
+    let innerDepth = 0;
+    for (let i = 0; i < body.length; i++) {
+        if (body[i] === "{")
+            innerDepth++;
+        else if (body[i] === "}")
+            innerDepth--;
+        else if (body[i] === "," && innerDepth === 0) {
+            parts.push(body.slice(partStart, i));
+            partStart = i + 1;
+        }
+    }
+    parts.push(body.slice(partStart));
+    if (parts.length === 1) {
+        // `{single}` is not alternation — treat the braces as literal.
+        return [pattern];
+    }
+    const expanded = [];
+    for (const part of parts) {
+        for (const rest of expandBraces(prefix + part + suffix)) {
+            expanded.push(rest);
+        }
+    }
+    return expanded;
+}
+/**
+ * Compile a brace-free glob into an anchored RegExp.
+ *
+ * Supports `**` (any depth, `**\/` also matches zero directories), `*`
+ * (within one segment) and `?` (one character within a segment).
+ */
+export function globToRegExp(pattern) {
+    const p = toPosixPath(pattern);
+    let re = "";
+    for (let i = 0; i < p.length; i++) {
+        const c = p[i];
+        if (c === "*") {
+            if (p[i + 1] === "*") {
+                // Consume every following `*`, then an optional single `/` so that
+                // `src/**/*.ts` matches `src/app.ts` as well as `src/sub/util.ts`.
+                while (p[i + 1] === "*")
+                    i++;
+                if (p[i + 1] === "/") {
+                    re += "(?:.*/)?";
+                    i++;
+                }
+                else {
+                    re += ".*";
+                }
+            }
+            else {
+                re += "[^/]*";
+            }
+        }
+        else if (c === "?") {
+            re += "[^/]";
+        }
+        else if (".+^${}()|[]\\/".includes(c)) {
+            re += "\\" + c;
+        }
+        else {
+            re += c;
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+/** Compile a (possibly brace-containing) glob once, for repeated matching. */
+export function compileGlob(pattern) {
+    const alternatives = expandBraces(pattern).map(globToRegExp);
+    return {
+        test(relPath) {
+            const normalized = toPosixPath(relPath);
+            return alternatives.some((re) => re.test(normalized));
+        },
+    };
+}
+/** Convenience: does a single relPath match this glob pattern? */
+export function matchesGlob(relPath, pattern) {
+    return compileGlob(pattern).test(relPath);
+}
+/**
+ * Decide whether a workspace-relative path is excluded by a set of ignore
+ * rules (as produced by `loadIgnoreRules`).
+ *
+ * Rules are matched with the same compiled-glob engine, so ignore semantics
+ * and glob semantics cannot drift apart.
+ */
+export function isIgnoredByRules(relPath, rules) {
+    const normalized = toPosixPath(relPath);
+    for (const rule of rules) {
+        const raw = rule.trim();
+        if (!raw)
+            continue;
+        // A rule that names a directory at any depth — `**/dist/**` — also
+        // excludes anything beneath it, which `compileGlob` already handles.
+        if (compileGlob(raw).test(normalized))
+            return true;
+    }
+    return false;
+}
+/**
+ * Glob the index with zero filesystem access.
+ *
+ * Results are sorted for deterministic output and are always a subset of
+ * `index.entries[].relPath` — that containment is the property the
+ * index-only-discovery contract test asserts.
+ */
+export function globIndex(index, pattern, opts = {}) {
+    const limit = Math.max(0, opts.limit ?? MAX_GLOB_RESULTS);
+    if (limit === 0)
+        return [];
+    if (pattern.length > MAX_PATTERN_LENGTH)
+        return [];
+    const compiled = compileGlob(pattern);
+    const ignore = opts.ignore ?? [];
+    const out = [];
+    for (const entry of index.entries) {
+        if (out.length >= limit)
+            break;
+        if (!compiled.test(entry.relPath))
+            continue;
+        if (ignore.length && isIgnoredByRules(entry.relPath, ignore))
+            continue;
+        out.push(entry.relPath);
+    }
+    return out.sort();
+}

package/dist/tools/load-skill-tool.d.ts

@@ -0,0 +1,15 @@
+import type { ToolCallResult } from "./tool-registry.js";
+export interface LoadSkillInput {
+    role?: string;
+    keyword?: string;
+}
+/**
+ * Load the full bodies of external skill files (SKILL.md) by role or keyword.
+ *
+ * Modes (mutually exclusive):
+ *  - role: looks up ROLE_SKILL_ALLOWLIST[role] and loads each allowed skill.
+ *  - keyword: calls registry.route(keyword) and returns top 5 matches.
+ */
+export declare function loadSkillTool(input: LoadSkillInput, opts: {
+    skillDir?: string;
+}): Promise<ToolCallResult>;

package/dist/tools/load-skill-tool.js

@@ -0,0 +1,114 @@
+import { SkillRegistry } from "../skills/externalSkillRegistry.js";
+import { isExternalSkillsEnabled } from "../skills/externalSkillLoader.js";
+import { ROLE_SKILL_ALLOWLIST } from "../skills/skillRouter.js";
+/**
+ * Load the full bodies of external skill files (SKILL.md) by role or keyword.
+ *
+ * Modes (mutually exclusive):
+ *  - role: looks up ROLE_SKILL_ALLOWLIST[role] and loads each allowed skill.
+ *  - keyword: calls registry.route(keyword) and returns top 5 matches.
+ */
+export async function loadSkillTool(input, opts) {
+    // ── Flag gate ──────────────────────────────────────────────────────
+    if (!isExternalSkillsEnabled()) {
+        return {
+            tool: "load_skill",
+            ok: true, // valid response, not an error
+            output: { skills: [], reason: "external skills disabled" },
+        };
+    }
+    const { role, keyword } = input;
+    // ── Modal validation: role XOR keyword must be a non-empty string ──
+    const hasRole = typeof role === "string" && role.trim().length > 0;
+    const hasKeyword = typeof keyword === "string" && keyword.trim().length > 0;
+    if (!hasRole && !hasKeyword) {
+        return {
+            tool: "load_skill",
+            ok: false,
+            output: {
+                error: '"load_skill" requires exactly one of "role" or "keyword" to be a non-empty string. ' +
+                    'Provide either { "role": "tester" } or { "keyword": "penetration testing" } — not both and not neither.',
+            },
+        };
+    }
+    if (hasRole && hasKeyword) {
+        return {
+            tool: "load_skill",
+            ok: false,
+            output: {
+                error: '"load_skill" received both "role" and "keyword". Choose one mode — ' +
+                    'role-based lookup OR keyword-based search — not both at once.',
+            },
+        };
+    }
+    // ── Fresh registry per call (see tradeoff #1 in design) ─────────────
+    const registry = new SkillRegistry(opts.skillDir);
+    registry.loadHeaders();
+    try {
+        if (hasRole) {
+            const skills = getSkillsForRole(registry, role.trim());
+            return {
+                tool: "load_skill",
+                ok: true,
+                output: {
+                    skills: skills.map(formatLoadedSkillForOutput),
+                    mode: "role",
+                    role: role.trim(),
+                },
+            };
+        }
+        // hasKeyword branch
+        const skills = getSkillsForKeyword(registry, keyword.trim(), 5);
+        return {
+            tool: "load_skill",
+            ok: true,
+            output: {
+                skills: skills.map(formatLoadedSkillForOutput),
+                mode: "keyword",
+                keyword: keyword.trim(),
+            },
+        };
+    }
+    catch (e) {
+        return {
+            tool: "load_skill",
+            ok: false,
+            output: { error: `load_skill unexpected error: ${e.message}` },
+        };
+    }
+}
+// ── Private helpers ────────────────────────────────────────────────────────
+function getSkillsForRole(registry, role) {
+    const allowedNames = ROLE_SKILL_ALLOWLIST[role];
+    if (!allowedNames || allowedNames.length === 0) {
+        return [];
+    }
+    const skills = [];
+    for (const name of allowedNames) {
+        const skill = registry.loadSkill(name);
+        if (skill) {
+            skills.push(skill);
+        }
+    }
+    return skills;
+}
+function getSkillsForKeyword(registry, keyword, maxResults) {
+    const headers = registry.route(keyword);
+    const top = headers.slice(0, maxResults);
+    const skills = [];
+    for (const header of top) {
+        const skill = registry.loadSkill(header.name);
+        if (skill) {
+            skills.push(skill);
+        }
+    }
+    return skills;
+}
+function formatLoadedSkillForOutput(skill) {
+    return {
+        name: skill.header.name,
+        description: skill.header.description,
+        body: skill.body,
+        path: skill.path,
+    };
+}

package/dist/tools/patch-tools.d.ts

@@ -0,0 +1,58 @@
+export declare class WorkspaceEscapeError extends Error {
+}
+/**
+ * Every path a tool touches is resolved and pinned inside the workspace root.
+ * No `..` escapes — the same 8-line guard every other path-taking tool uses.
+ */
+export declare function resolveInWorkspace(root: string, relPath: string): string;
+/**
+ * Full-file sha1, byte-for-byte identical to the one `workspace-index.ts`
+ * stores per entry — so a sha1 taken here is directly comparable with the
+ * index's value and with the `readSha1` returned by range reads.
+ */
+export declare function hashFile(fullPath: string): Promise<string>;
+/**
+ * The reusable staleness core behind every stale-enforced write tool.
+ * Compares the file's CURRENT sha1 against the sha1 the caller observed
+ * earlier (via read_file's `readSha1`). A mismatch means the file changed
+ * under the caller — the write MUST NOT proceed.
+ */
+export declare function assertFileUnchanged(fullPath: string, expectedSha1: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    actualSha1: string;
+}>;
+export interface LinePatchInput {
+    path: string;
+    startLine: number;
+    endLine: number;
+    newContent: string;
+    expectedSha1: string;
+}
+export type LinePatchResult = {
+    ok: true;
+    relPath: string;
+    replacedLines: [number, number];
+    newContentChars: number;
+    linesAfter: number;
+    sha1After: string;
+} | {
+    ok: false;
+    error: string;
+    code: "stale" | "stale_field_missing" | "file_not_found" | "workspace_escape" | "invalid_range" | "io_error";
+    actualSha1?: string;
+};
+/**
+ * Replace lines [startLine..endLine] (1-indexed, inclusive) with newContent.
+ *
+ * Staleness contract: `expectedSha1` is REQUIRED. It must come from the
+ * `readSha1` field of a prior read_file range call. The file is hashed
+ * immediately before any mutation; a mismatch returns `stale` and performs
+ * ZERO writes — never a blind line splice onto a file that changed under
+ * the agent.
+ */
+export declare function linePatchTool(root: string, input: LinePatchInput, ctx?: {
+    taskId: string;
+    subtaskId: string;
+}): Promise<LinePatchResult>;