@xiaoso/dsh-tool-plus 0.1.6 → 0.1.7-beta.1

package/lib/types/tools/hashline/native/policy.d.ts

@@ -0,0 +1,98 @@
+import type { ToolSession } from "../../omp/sdk.ts";
+import type { EditPolicy } from "./index.ts";
+/** Optional overrides for {@link buildHashlineEditPolicy}. */
+export interface HashlinePolicyOptions {
+    /**
+     * The payload is a verbatim custom-format string rather than JSON
+     * (upstream sets this when the call arrived through the custom-tool wire).
+     * DSH never opens an argument stream — it hands `executeHashlineSingle` the
+     * parsed `{ input }` arguments — so this stays `false`.
+     */
+    rawInput?: boolean;
+}
+/**
+ * Canonicalize `cwd` for the engine policy.
+ *
+ * The Rust engine canonicalizes the paths it stores (`recordSnapshot`), but it
+ * uses `policy.cwd` verbatim for path resolution and for its containment check,
+ * and that check compares byte-wise (`path_policy.rs:429-431`). On Windows a
+ * workspace under `%TEMP%` reaches JS in 8.3 short form
+ * (`C:\Users\XIAOSO~1\...`) while the engine's canonical snapshot key is the
+ * long form (`C:\Users\xiaoso456\...`), so an un-normalized `cwd` makes
+ * `is_within` fail and tag path recovery silently skip — verified with
+ * `D:/tmp/hashline-probes/probe-d3-recovery.mts` (raw cwd →
+ * `File not found: a.ts`; canonical cwd → recovered onto `nested/a.ts`).
+ *
+ * `.native` is required: the JS `realpathSync` does NOT expand short names.
+ * A failure (missing directory, permissions) falls back to the input, matching
+ * `canonicalSnapshotKey`'s behaviour so both sides of the store agree on one
+ * spelling.
+ *
+ * The same byte-wise check also drives the plan-sandbox / vault-root
+ * decisions, so normalizing here is what keeps those from silently
+ * mis-evaluating on a short-name cwd. Parity measured this normalization as
+ * neutral for every other policy behaviour (7 scenarios, raw vs canonical).
+ */
+export declare function canonicalCwd(cwd: string): string;
+/**
+ * Build the engine policy for one `hashline` tool call.
+ *
+ * Field sources (all reads go through the DSH settings facade, which maps the
+ * OMP dotted keys onto the tool-plus config — `src/config/omp-settings.ts`):
+ *
+ * - `cwd`               — `session.cwd` through {@link canonicalCwd}: the
+ *                         engine resolves every authored path against it and
+ *                         runs its byte-wise containment check on it
+ *                         (upstream :563 passes the cwd verbatim; the
+ *                         normalization is a DSH-required fix for Windows
+ *                         short names — see {@link canonicalCwd}).
+ * - `mode`              — constant `"hashline"`: this adapter only serves the
+ *                         hashline entry point.
+ * - `allowFuzzy`        — `edit.fuzzyMatch`, default true
+ *                         (`edit/adapter/index.ts:210`).
+ * - `fuzzyThreshold`    — `edit.fuzzyThreshold`, default 0.95 (S-13 above).
+ * - `enforceSeenLines`  — `edit.enforceSeenLines`, schema default false
+ *                         (`src/config/omp-settings.ts:24/72`). **Passed
+ *                         explicitly and never left to a default**: the
+ *                         vendored TS `Patcher` defaulted this to `true`,
+ *                         while upstream/native resolve it from settings
+ *                         (default `false`). The old engine's stricter
+ *                         default therefore deliberately does not survive
+ *                         the migration; DSH follows the settings value
+ *                         (strict boolean, so a missing key reads as "off").
+ * - `blockAutoGenerated`— `edit.blockAutoGenerated`, schema default true
+ *                         (`omp-settings.ts:21/69`); `!== false` mirrors
+ *                         `shouldBlockAutoGeneratedFiles`'s default-on
+ *                         semantics in `omp/tools/auto-generated-guard.ts:297`.
+ * - `planActive`        — upstream reads `session.getPlanModeState()?.enabled`.
+ *                         DSH's plan mode is a hint layer with **no hard
+ *                         gate** (`edit/adapter/tools/plan-mode-guard.ts`
+ *                         documents `enforcePlanModeWrite` as a deliberate
+ *                         no-op), and no DSH session installs
+ *                         `getPlanModeState`, so this resolves to `false`.
+ * - `localSandboxRoot`  — upstream resolves the `local://` root. DSH has no
+ *                         `local://` write sandbox: the edit-path guard
+ *                         (`edit/adapter/tools/plan-mode-guard.ts`) hardcodes
+ *                         `targetsLocalSandbox → false` and documents plan
+ *                         mode as a hint layer, so `undefined` reproduces the
+ *                         old engine's `allowTagPathRecovery` exactly (cwd
+ *                         only). **If DSH ever wires a real sandbox root, it
+ *                         must go through {@link canonicalCwd} too** — the
+ *                         engine's containment check is byte-wise on
+ *                         `localSandboxRoot` just like on `cwd`.
+ *                         Consequence (D-3, awaiting the Lead's ruling): the
+ *                         vendored engine's `allowTagPathRecovery` override —
+ *                         which let a bare/mis-typed authored path rebind onto
+ *                         the file its snapshot tag uniquely names — has no
+ *                         counterpart here. The native engine now decides tag
+ *                         path recovery from `cwd` / `localSandboxRoot` /
+ *                         `vaultRoots` / `homeDir` alone, so a bare filename
+ *                         that needs rebinding fails with native's own error
+ *                         rather than silently landing on a recovered path.
+ * - `vaultRoots`        — upstream `isVaultEnabled() ? cachedVaultRoots() : …`.
+ *                         DSH has no `vault://` protocol → `undefined`.
+ * - `homeDir`           — `os.homedir()` (upstream :571); the engine uses it
+ *                         to recognise and refuse home-directory escapes.
+ * - `rawInput`          — see {@link HashlinePolicyOptions.rawInput}.
+ */
+export declare function buildHashlineEditPolicy(session: ToolSession, options?: HashlinePolicyOptions): EditPolicy;

package/lib/types/tools/hashline/native/writer.d.ts

@@ -0,0 +1,42 @@
+import type { ToolSession } from "../../omp/sdk.ts";
+import type { WritethroughCallback } from "../../omp/tools/writethrough.ts";
+import type { EditWriteRequest, EditWriteResponse } from "./index.ts";
+/** Wiring for {@link createHashlineWriter}. */
+export interface HashlineWriterOptions {
+    session: ToolSession;
+    /** DSH's sandbox-routed file-write channel. */
+    writethrough: WritethroughCallback;
+    signal?: AbortSignal;
+}
+/**
+ * The `writer` argument for `EditSession.apply`, carrying the landed-file
+ * record alongside the callback.
+ *
+ * The native callback signature carries a leading `error` (used by the
+ * streaming *preview* channel, never by write requests) — upstream ignores it
+ * the same way (`refs/.../edit/index.ts:576`).
+ */
+export interface HashlineWriter {
+    /** The error-first callback the engine invokes for every landed change. */
+    (error: Error | null, request: EditWriteRequest): Promise<EditWriteResponse>;
+    /**
+     * DSH display paths (`EditWriteRequest.displayPath` — the authored form,
+     * e.g. `a.ts`; for a move the *source*, which is the section that landed) of
+     * every file this apply actually wrote, in write order.
+     *
+     * The engine calls the writer once per file and aborts on the first throw,
+     * so after a rejected payload this holds exactly the sections that are on
+     * disk — the breadcrumb `executeHashlineSingle` re-attaches to the
+     * model-facing error (the old TS engine reported the same list from its
+     * prepared batch, `engine/patcher.ts:287-296` at v17.3.5).
+     */
+    readonly landedPaths: readonly string[];
+}
+/**
+ * Build the `writer` argument for `EditSession.apply`.
+ *
+ * The returned callable also exposes {@link HashlineWriter.landedPaths}; only a
+ * *successful* write is recorded, so a channel refusal on file #2 leaves just
+ * file #1 in the list.
+ */
+export declare function createHashlineWriter(options: HashlineWriterOptions): HashlineWriter;

package/lib/types/tools/omp/browser/launch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Per-CDP-message timeout applied to every puppeteer launch/connect. Set above
+ * the fetch tool timeout (30s) so the tool wall-clock is the canonical limit;
+ * this constant only catches genuinely stuck CDP sockets.
+ */
+export declare const BROWSER_PROTOCOL_TIMEOUT_MS = 60000;
+/**
+ * Resolve the Chromium executable the browser renderer will launch.
+ * `PUPPETEER_EXECUTABLE_PATH` always wins, then the system
+ * Chrome/Edge/Chromium candidate table (Windows and macOS check mere file
+ * existence; Linux additionally version-probes, see {@link isChromiumExecutable}).
+ * Returns undefined when nothing is found — puppeteer-core would fall back to
+ * its own bundled-Chromium search, which for this package means failure, so
+ * callers should treat undefined as "browser rendering unavailable".
+ *
+ * Unlike OMP upstream there is no Chrome-for-Testing download fallback: this
+ * plugin ships no browser installer, and the detection button only reports
+ * what is already on the machine.
+ */
+export declare function ensureChromiumExecutable(): Promise<string | undefined>;
+/** Reset the cached executable resolution (test seam). */
+export declare function resetChromiumExecutableForTest(): void;
+/** Exposes executable candidates for detection tests (OMP parity export). */
+export declare function systemChromiumCandidatesForTest(platform?: NodeJS.Platform, home?: string, which?: (name: string) => string | null | undefined): string[];
+/** Expose the Linux probe for tests (OMP parity export). */
+export declare function chromiumExecutableProbeForTest(executablePath: string): Promise<boolean>;
+/** Expose the executable-file check for tests. */
+export declare function isExecutableFileForTest(p: string): boolean;

package/lib/types/tools/omp/browser/readable.d.ts

@@ -0,0 +1,17 @@
+export type ReadableFormat = "text" | "markdown";
+export interface ReadableResult {
+    url: string;
+    title?: string;
+    byline?: string;
+    excerpt?: string;
+    contentLength: number;
+    text?: string;
+    markdown?: string;
+}
+/**
+ * Extract readable content from raw HTML.
+ * Tries Readability (article-isolation scoring) first, then falls back to a
+ * CSS selector chain over the same pre-parsed DOM. Returns null if neither
+ * path yields usable content.
+ */
+export declare function extractReadableFromHtml(html: string, url: string, format: ReadableFormat): Promise<ReadableResult | null>;

package/lib/types/tools/omp/config/settings-schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * DSH adapter for OMP's `config/settings-schema.ts`.
+ *
+ * The OMP schema is a ~5900-line settings registry. The edit engine only
+ * needs `getDefault(path)` for a handful of keys; defaults are taken from the
+ * OMP schema values (verbatim) so engine behavior matches upstream. Full
+ * schema metadata (tabs, UI descriptors) is DSH-side and not replicated.
+ */
+export type SettingPath = string;
+export type SettingValue<P extends string = string> = unknown;
+/** Schema default for a setting path (verbatim OMP values; unknown -> undefined). */
+export declare function getDefault<P extends SettingPath>(path: P): any;

package/lib/types/tools/omp/config/settings.d.ts

@@ -0,0 +1,59 @@
+/**
+ * DSH adapter for OMP's `config/settings.ts` Settings surface.
+ *
+ * OMP edit engine reads session settings through `settings.get("edit.*")`,
+ * `settings.get("lsp.*")`, etc. DSH has its own configuration (fields.ts +
+ * dsh settings); this adapter maps the OMP dotted keys onto the resolved
+ * tool-plus config, so the verbatim OMP engine code compiles and runs
+ * without modification.
+ *
+ * Only the surface the edit engine actually touches is provided:
+ * - `Settings` class with `get(path)` and `getEditVariantForModel(model)`
+ * - `settings` singleton (uninitialized until `installGlobalSettings` runs)
+ * - `isSettingsInitialized()`
+ *
+ * LSP keys are not wired: the LSP integration was cut from the DSH port
+ * (plan.md §3), so those reads fall back to the schema default (their
+ * `enableLsp` gate is `false` at the call sites), never to a degraded
+ * edit path.
+ */
+import type { RuntimeConfig } from '../../../config/settings.ts';
+export type SettingPath = string;
+/** Raw settings document shape (verbatim OMP). */
+export interface RawSettings {
+    [key: string]: unknown;
+}
+export interface SettingsOptions {
+    cwd?: string;
+    agentDir?: string;
+    inMemory?: boolean;
+    readOnly?: boolean;
+    overrides?: Partial<Record<string, unknown>>;
+    configFiles?: string[];
+}
+export type SettingValue<P extends string = string> = unknown;
+/**
+ * Session-scoped settings adapter. `get(path)` resolves the OMP dotted key
+ * against the live tool-plus config; unknown keys return the schema default
+ * or undefined.
+ */
+export declare class Settings {
+    #private;
+    constructor(config: RuntimeConfig, getDefault: (path: string) => unknown);
+    get(path: string): any;
+    /** OMP storage accessor (DSH: no agent storage — null). */
+    getStorage(): null;
+    /** Whether a path is explicitly configured (DSH config is always resolved). */
+    isConfigured(_path: string): boolean;
+    /** Persist a setting (DSH: config is static at tool time — no-op). */
+    set(_path: string, _value: unknown): void;
+    /** OMP edit-variant override hook; DSH resolves the mode from config directly. */
+    getEditVariantForModel(_model: string | undefined): 'replace' | 'patch' | 'hashline' | 'apply_patch' | null;
+}
+/** Install the resolved tool-plus config into the global settings singleton. */
+export declare function installGlobalSettings(config: RuntimeConfig, getDefault: (path: string) => unknown): void;
+export declare function isSettingsInitialized(): boolean;
+/** Global settings singleton (read-only facade over the installed config). */
+export declare const settings: Settings;
+/** Re-exported schema default lookup (OMP settings.ts re-exports it too). */
+export { getDefault } from './settings-schema.ts';

package/lib/types/tools/omp/edit/apply-patch/parser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parser for the Codex `apply_patch` envelope format.
+ *
+ *     *** Begin Patch
+ *     *** Add File: <path>
+ *     +<line>
+ *     *** Delete File: <path>
+ *     *** Update File: <path>
+ *     *** Move to: <newpath>
+ *     @@ <optional context>
+ *     -old
+ *     +new
+ *      context
+ *     *** End of File
+ *     *** End Patch
+ *
+ * Input is the full envelope text (optionally heredoc-wrapped). Output is a
+ * list of `PatchInput` records, each ready to hand to the existing
+ * single-file `applyPatch()` in `../modes/patch.ts`.
+ *
+ * Per spec §4.3 Lenient mode: a `<<EOF` / `<<'EOF'` / `<<"EOF"` heredoc
+ * wrapper around the whole envelope is stripped before parsing.
+ */
+import type { PatchInput } from "../modes/patch";
+/**
+ * Parse a Codex `*** Begin Patch` envelope into a list of single-file
+ * patch inputs.
+ */
+export declare function parseApplyPatch(patchText: string): PatchInput[];
+/**
+ * Best-effort parser for in-progress TUI previews. It tolerates missing
+ * envelope markers and incomplete trailing hunks; do not use it to apply edits.
+ */
+export declare function parseApplyPatchStreaming(patchText: string): PatchInput[];

package/lib/types/tools/omp/edit/details.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Edit tool result detail shapes (shared by the replace / patch / hashline
+ * engines and the snapshot pruner). The TUI renderer that consumed these was
+ * cut with the TUI layer (plan.md 拍板#17); the shapes remain because the
+ * engines assemble them as their `AgentToolResult.details`.
+ */
+export type Operation = "create" | "delete" | "update";
+export interface EditToolPerFileResult {
+    path: string;
+    diff: string;
+    firstChangedLine?: number;
+    op?: Operation;
+    move?: string;
+    isError?: boolean;
+    errorText?: string;
+    /** TUI-friendly error text. When present, rendered to the user instead of `errorText`.
+     * Set when the underlying error carries a `displayMessage` (e.g. {@link HashlineMismatchError}). */
+    displayErrorText?: string;
+    meta?: OutputMeta;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
+    /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+    sourcePath?: string;
+}
+export interface EditToolDetails {
+    /** Unified diff of the changes made */
+    diff: string;
+    /** Line number of the first change in the new file (for editor navigation) */
+    firstChangedLine?: number;
+    /** Operation type (patch mode only) */
+    op?: Operation;
+    /** New path after move/rename (patch mode only) */
+    move?: string;
+    /** Structured output metadata */
+    meta?: OutputMeta;
+    /** Per-file results (multi-file edits) */
+    perFileResults?: EditToolPerFileResult[];
+    /** Absolute file path for single-file edit results. Required by ACP diff metadata consumers. */
+    path?: string;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
+    /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+    sourcePath?: string;
+}
+type OutputMeta = import("../../edit/adapter/tools/output-meta").OutputMeta;
+export {};

package/lib/types/tools/omp/edit/diff.d.ts

@@ -0,0 +1,60 @@
+import { type BlockContextSource } from "../../omp/utils/block-context.ts";
+export interface DiffResult {
+    diff: string;
+    firstChangedLine: number | undefined;
+}
+export interface DiffError {
+    error: string;
+}
+export interface DiffHunk {
+    changeContext?: string;
+    oldStartLine?: number;
+    newStartLine?: number;
+    hasContextLines: boolean;
+    oldLines: string[];
+    newLines: string[];
+    isEndOfFile: boolean;
+}
+export declare class ParseError extends Error {
+    readonly lineNumber?: number | undefined;
+    constructor(message: string, lineNumber?: number | undefined);
+}
+export declare class ApplyPatchError extends Error {
+    constructor(message: string);
+}
+/**
+ * Generate a unified diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number, source?: BlockContextSource): DiffResult;
+export interface ReplaceOptions {
+    /** Allow fuzzy matching */
+    fuzzy: boolean;
+    /** Replace all occurrences */
+    all: boolean;
+    /** Similarity threshold for fuzzy matching */
+    threshold?: number;
+}
+export interface ReplaceResult {
+    /** The new content after replacements */
+    content: string;
+    /** Number of replacements made */
+    count: number;
+}
+/**
+ * Generate a unified diff string without file headers.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export declare function generateUnifiedDiffString(oldContent: string, newContent: string, contextLines?: number, source?: BlockContextSource): DiffResult;
+export declare function normalizeDiff(diff: string): string;
+export declare function normalizeCreateContent(content: string): string;
+export declare function parseDiffHunks(diff: string): DiffHunk[];
+/**
+ * Find and replace text in content using fuzzy matching.
+ */
+export declare function replaceText(content: string, oldText: string, newText: string, options: ReplaceOptions): ReplaceResult;
+/**
+ * Compute the diff for an edit operation without applying it.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export declare function computeEditDiff(path: string, oldText: string, newText: string, cwd: string, fuzzy?: boolean, all?: boolean, threshold?: number): Promise<DiffResult | DiffError>;

package/lib/types/tools/omp/edit/dispatch.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Edit dispatch layer — path resolution + multi-entry/multi-file aggregation.
+ *
+ * Ported verbatim from upstream `packages/coding-agent/src/edit/index.ts`
+ * (refs/oh-my-pi, 17.3.5): `resolveEditPath` (:77-93), `executeApplyPatchPerFile`
+ * (:139-256) and `executeSinglePathEntries` (:258-365). Algorithm and user-facing
+ * copy are byte-for-byte upstream; only the import surface was redirected to the
+ * DSH-resident modules and the LSP-only surface was cut, per the established
+ * omp/ adaptation conventions:
+ *   - `renderer` → `./details` (TUI renderer cut, plan.md 拍板#17): the
+ *     `EditToolDetails` / `EditToolPerFileResult` shapes live in `./details.ts`;
+ *     the upstream per-file `diagnostics` field went with the LSP layer.
+ *   - `resolvePlanPath` → DSH adapter shim (`edit/adapter/tools/plan-mode-guard`,
+ *     verbatim resolution minus local:// schemes) — same redirection the local
+ *     engines (modes/replace.ts, modes/patch.ts) already use.
+ *   - `LspBatchRequest` / `flushLspWritethroughBatch` → local type + no-op below.
+ *     DSH never constructs an outer batch request, so every `batchRequest` inside
+ *     the aggregators resolves to `undefined` and the flush branches stay
+ *     unreachable; the flow is kept verbatim so this file stays diffable
+ *     against refs.
+ */
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../tools/index.ts";
+import type { EditToolDetails } from "./details";
+/**
+ * LSP write-batch handle (upstream `tools/render-utils.ts`, surfaced through the
+ * edit renderer). Shape verbatim; DSH cuts the LSP layer (plan.md 拍板#5), so no
+ * caller ever constructs one — see {@link flushLspWritethroughBatch}.
+ */
+export interface LspBatchRequest {
+    id: string;
+    flush: boolean;
+}
+export declare function resolveEditPath(session: ToolSession, authoredPath: string, options: {
+    mustExist: boolean;
+    signal?: AbortSignal;
+}): Promise<string>;
+/** Run apply_patch file operations and aggregate their multi-file result. */
+export declare function executeApplyPatchPerFile(fileEntries: {
+    path: string;
+    run: (batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails>>;
+}[], outerBatchRequest: LspBatchRequest | undefined, cwd: string, signal: AbortSignal | undefined, onUpdate?: (partialResult: AgentToolResult<EditToolDetails>) => void): Promise<AgentToolResult<EditToolDetails>>;
+export declare function executeSinglePathEntries(path: string, runs: ((batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails>>)[], outerBatchRequest: LspBatchRequest | undefined, onUpdate: ((partialResult: AgentToolResult<EditToolDetails>) => void) | undefined, cwd: string, signal: AbortSignal | undefined): Promise<AgentToolResult<EditToolDetails>>;

package/lib/types/tools/omp/edit/file-snapshot-store.d.ts

@@ -0,0 +1,81 @@
+import { type EditStore, type EditStoreOwner } from "../../hashline/native/index.ts";
+/**
+ * Upper bound on the file size we snapshot.
+ *
+ * A section tag is a content hash of the *whole* file, so minting one means
+ * holding the full normalized text in the store. Files above this cap emit no
+ * `[path#tag]` header — line-anchored editing of multi-megabyte files is out
+ * of scope under the full-content model.
+ *
+ * The value mirrors the native store's own cap (`EditStore.recordSnapshotFile`
+ * returns `null` for "unreadable or larger than 4 MiB",
+ * `@oh-my-pi/pi-natives` index.d.ts:132-136); `read` also uses it to decide
+ * whether to stream a whole file into memory.
+ */
+export declare const SNAPSHOT_MAX_BYTES: number;
+/**
+ * Look up (or lazily create) the file snapshot store attached to a session.
+ *
+ * One-line forward to the adapter's `getEditStore` so there is exactly one
+ * store per session; the DSH name is kept because this module owns the
+ * DSH-side concerns listed in the file header.
+ */
+export declare function getFileSnapshotStore(session: EditStoreOwner): EditStore;
+/**
+ * Canonicalize an absolute path into the stable key the snapshot store uses.
+ *
+ * Different code paths reach the snapshot store via different path forms:
+ * `read local://foo.md` records under the file's `fs.realpath` (the local
+ * protocol handler resolves symlinks); a subsequent `edit` may address the
+ * same artifact via `local://foo.md`, whose resolver does NOT realpath, or
+ * via the absolute path returned in the `[path#tag]` header. macOS adds the
+ * same hazard at the working-tree level (`/tmp/...` vs `/private/tmp/...`).
+ * Collapsing every key through `realpath` makes those forms fuse onto one
+ * snapshot entry, so a freshly-minted tag is never rejected as stale just
+ * because the lookup spelled the same file differently.
+ *
+ * Non-existent paths (new-file writes) fall back to a realpath of the parent
+ * directory + basename, then to the input. This keeps creates and updates on
+ * the same canonical key.
+ *
+ * Parity note (native migration): the Rust engine keys its own lookups by
+ * `policy.cwd` + the authored path, i.e. the unresolved spelling. For a path
+ * with no symlink component the two spellings are identical; for a symlinked
+ * subpath they are not, and a tag minted here would not be found by the
+ * engine. Listed for the parity doc (T-parity) rather than papered over —
+ * native exposes no path-canonicalization hook.
+ */
+export declare function canonicalSnapshotKey(absolutePath: string): string;
+/**
+ * Read the full text of `absolutePath` (within {@link SNAPSHOT_MAX_BYTES}),
+ * record it as a version snapshot, and return its content-hash tag. Returns
+ * `undefined` when the file exceeds the cap or cannot be read — callers then
+ * omit the section header so the model never sees a tag it can't anchor against.
+ *
+ * Producers that only displayed a slice of the file (range reads, search hits)
+ * use this to mint a whole-file tag: the displayed lines stay partial, but the
+ * tag fingerprints the entire file so a follow-up edit anchored at any line
+ * validates whenever the live file is byte-identical to what was read. Raw
+ * reads pass `seenLines` even though they do not emit a header, letting a prior
+ * or later same-content hashline tag inherit the raw range's provenance.
+ *
+ * `async` for call-site compatibility (`read`/`grep`/`ast-grep` await it); the
+ * native `recordSnapshotFile` performs the read, LF normalization and the
+ * 4 MiB cap synchronously, and returns `null` instead of `undefined`.
+ */
+export declare function recordFileSnapshot(session: EditStoreOwner, absolutePath: string, seenLines?: Iterable<number>): Promise<string | undefined>;
+/** Merge explicit 1-indexed displayed lines into a recorded hashline snapshot. */
+export declare function recordSeenLines(session: EditStoreOwner, absolutePath: string, tag: string, lines: readonly number[]): void;
+/**
+ * Attach the lines a read displayed to the snapshot it minted, so the engine's
+ * (opt-in) seen-line guard can reject edits anchored on lines the model never
+ * saw. Best-effort: a no-op when the body has no numbered rows or the snapshot
+ * already aged out. `tag` must be the tag returned when this exact content was
+ * recorded. Every displayed `NN:` row counts as seen, including column-clipped
+ * rows — the guard no longer distinguishes full-width from truncated display.
+ *
+ * The `N:` / `NN-MM:` row parsing lives in Rust now
+ * (`EditStore.recordSeenLinesFromBody`, including the collapsed-summary
+ * boundary-line rule), so this is a straight forward with key canonicalization.
+ */
+export declare function recordSeenLinesFromBody(session: EditStoreOwner, absolutePath: string, tag: string, body: string): void;

package/lib/types/tools/omp/edit/hashline/execute.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Coding-agent runner that drives the native hashline engine on behalf of the
+ * `edit` tool. Converts an `{input}` tool-call payload into a fully-applied
+ * patch, wraps the result in the agent's {@link AgentToolResult} shape, and
+ * attaches `outputMeta` for the renderer.
+ *
+ * Before the native migration this file drove the vendored TS engine
+ * (`Patch`/`Patcher`/`HashlineFilesystem`/`BlockResolver`/clipboard) and
+ * hand-assembled the model-facing text from per-section fields. Upstream 18.x
+ * moved all of that into Rust (`crates/pi-edit`), so the host side is now:
+ *
+ * 1. build the `EditPolicy` (`native/policy.ts`) and the writer
+ *    (`native/writer.ts`),
+ * 2. hand `EditSession.apply` the payload,
+ * 3. shape the returned {@link EditApplyOutcome} into DSH's
+ *    `EditToolDetails`.
+ *
+ * What the native engine now owns (and this file therefore no longer
+ * implements — each was verified byte-for-byte against the old DSH output):
+ * the parsed/aggregated model-facing text including the compact numbered
+ * preview and `PUT N*:` block-resolution lines, mismatch / unseen-anchor /
+ * missing-file diagnostics, the byte-identical no-op hint **and** its
+ * 3-strike escalation (the old `noop-loop-guard.ts`), tag validation with
+ * in-session recovery, `N*` block resolution, the `CUT`/`PUT` clipboard
+ * registers, and the multi-section merge for sections naming one file.
+ */
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { MismatchError } from "../../../hashline/native/index.ts";
+import type { ToolSession } from "../../../omp/tools/index.ts";
+import type { WritethroughCallback } from "../../../omp/tools/writethrough.ts";
+import type { EditToolDetails } from "../details";
+import { type HashlineParams, hashlineEditParamsSchema } from "./params";
+export interface ExecuteHashlineSingleOptions {
+    session: ToolSession;
+    input: string;
+    signal?: AbortSignal;
+    writethrough: WritethroughCallback;
+}
+export declare function executeHashlineSingle(options: ExecuteHashlineSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>>;
+export { MismatchError as HashlineMismatchError, type HashlineParams, hashlineEditParamsSchema };

package/lib/types/tools/omp/edit/hashline/params.d.ts

@@ -0,0 +1,6 @@
+export declare const hashlineEditParamsSchema: import("@oh-my-pi/omptype").FluentType<{
+    input: string;
+}, {
+    input: string;
+}>;
+export type HashlineParams = typeof hashlineEditParamsSchema.infer;

package/lib/types/tools/omp/edit/modes/apply-patch.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Edit mode wrapper for the Codex `apply_patch` envelope format.
+ *
+ * The mode accepts a single `input` string containing a full
+ * `*** Begin Patch ... *** End Patch` block, parses it, and fans out to
+ * the existing `executePatchSingle` — so all the machinery (plan mode,
+ * LSP writethrough, fs-cache invalidation, diagnostics) is shared with
+ * the `patch` mode.
+ */
+import type { PatchEditEntry } from "./patch";
+export declare const applyPatchSchema: import("@oh-my-pi/omptype").FluentType<{
+    input: string;
+}, {
+    input: string;
+}>;
+export type ApplyPatchParams = typeof applyPatchSchema.infer;
+export type ApplyPatchEntry = PatchEditEntry & {
+    path: string;
+};
+/**
+ * Parse the envelope and lower each hunk to a `PatchEditEntry` so it can
+ * be routed through `executePatchSingle`.
+ */
+export declare function expandApplyPatchToEntries(params: ApplyPatchParams): ApplyPatchEntry[];
+export declare function expandApplyPatchToPreviewEntries(params: ApplyPatchParams): ApplyPatchEntry[];