dsh-hashline-edit 0.2.2 → 0.3.0

package/lib/types/src/file-content/preview.d.ts

@@ -1,4 +1,4 @@
-import { type TruncationResult } from "@earendil-works/pi-coding-agent";
+import { type TruncationResult } from "../host-utils.js";
 import { type AnchorWalk } from "../hashline/hash-identity.js";
 import type { ServedRow } from "../served-session/serve-render.js";
 /** The lines one page actually rendered, 1-based and inclusive. */

package/lib/types/src/fs-lifecycle.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Filesystem primitives for apply_patch's file lifecycle: classify, create directories, delete a
+ * regular file and rename one. Every entry point resolves through {@link resolveTarget}, the same
+ * symlink-resolving boundary every read/write uses, so a lifecycle action can never escape it.
+ *
+ * These are primitives, not a second write engine: file CONTENTS still go through writeAtomic;
+ * this module only owns namespace operations that writeAtomic deliberately does not express.
+ *
+ * @module dsh-hashline-edit/fs-lifecycle
+ */
+/** The physical kind of a path as the file layer sees it (symlinks resolved first). */
+export type PathKind = "file" | "directory" | "other" | "absent";
+/** Classify one path through the file layer's symlink-resolving boundary. */
+export declare function pathKind(path: string): Promise<PathKind>;
+/**
+ * True when `path` resolves inside `root` once every existing symlink/junction component is
+ * followed. A missing tail is checked against its nearest existing ancestor: an Add File under a
+ * junction ancestor therefore fails before mkdir can create anything outside the workspace.
+ */
+export declare function isPathWithinWorkspace(root: string, path: string): Promise<boolean>;
+/** Throw the E_PATCH_SYNTAX boundary refusal for one escaping lifecycle path. */
+export declare function assertPathWithinWorkspace(root: string, path: string): Promise<void>;
+/** Create one directory (and missing parents), through the symlink-resolving boundary. */
+export declare function mkdirp(path: string, workspaceRoot?: string): Promise<void>;
+/**
+ * Delete one regular file. Deliberately NOT recursive: a lifecycle delete targets a file, and a
+ * directory at the same path is a caller bug that must surface, never be removed wholesale.
+ */
+export declare function removeFile(path: string, signal?: AbortSignal): Promise<void>;
+/**
+ * Rename one regular file, creating the destination parent first. The destination must not exist:
+ * a move never clobbers another file (spec §6: target-exists is a rejection, not an overwrite).
+ */
+export declare function renameFile(from: string, to: string, signal?: AbortSignal, workspaceRoot?: string): Promise<void>;
+/**
+ * The directories on the way to `path` that do not exist yet, OUTERMOST FIRST. Captured before a
+ * lifecycle add writes, so an undo removes exactly the directories the add created and no others.
+ */
+export declare function missingAncestorDirs(path: string): Promise<string[]>;
+/**
+ * Best-effort removal of directories a lifecycle add created, deepest first. Returns the removed
+ * paths. A directory that is no longer empty (an outside writer put something there) is kept.
+ */
+export declare function pruneEmptyDirs(dirs: readonly string[]): Promise<string[]>;

package/lib/types/src/hashline/alphabet.d.ts

@@ -3,9 +3,10 @@
  *
  * WHY an environment variable rather than a settings-file key: `alphabet.ts` is a zero-import leaf
  * and every shape, regex, bitset and capacity constant below is derived at module load, so the
- * width can only be a process-wide, load-time value. Switching it changes every served anchor; the
- * persisted store stays safe because the anchor generation (`hash-identity.ts`) folds the width in,
- * so a switch is a hard generation miss (re-read), never a cross-width hit.
+ * width can only be a process-wide, load-time value. The build bakes it via esbuild `define`
+ * (`__ANCHOR_WIDTH__`), so a shipped bundle carries a literal and never reads the environment; the
+ * anchor generation (`hash-identity.ts`) folds the width in, so a width switch is a hard generation
+ * miss (re-read), never a cross-width hit.
  */
 export declare const ANCHOR_WIDTH_ENV_VAR = "PI_BETTER_EDIT_ANCHOR_WIDTH";
 /**

package/lib/types/src/hashline/hash-identity.d.ts

@@ -61,23 +61,28 @@ export declare const HASH_PROBE_STRIDE: number;
  */
 export declare const CANON_VERSION = 3;
 /**
- * The file-scoped anchor-derivation generation (issue #20, ADR-0031; ADR-0020 for the width axis).
+ * ANCHOR_GENERATION 1 (issue #20, ADR-0031): the file-scoped anchor-derivation generation.
  * It covers exactly: (1) the width (`HASH_LEN`, `ALPHA`, `HASH_SPACE`/`USABLE_HASH_SPACE`);
  * (2) the (path, content) seeding (`fileBaseIndex` seeds xxh32 with the canonical absolute path,
  * `contentBaseIndex` is the explicit content-only fallback); (3) the all-digit reservation
  * (`DIGIT_CHARS`/`RESERVED_HASH_SPELLINGS`/`RESERVED_BITS` pre-marked in allocation); (4) the probe
  * stride (`HASH_PROBE_STRIDE`, coprime with both spaces). Bump it whenever any of those change.
  *
- * WHY it is a function of the width now: the width is a runtime switch (default 4, optional 3), so a
- * width change MUST flip the generation or a store written at one width could be read at another.
- * Width 4 stays generation 1 — the original persisted generation — so existing stores keep their
- * anchors across this change; width 3 gets generation 2, and any future width gets `100 + width`.
- *
- * WHY: single owner of the anchor-generation value — anchor-bearing artifacts (the undo/snapshot
+ * WHY: single owner of the anchor-generation literal — anchor-bearing artifacts (the undo/snapshot
  * generation gate and the open-time sweep) read this axis only, never `CANON_VERSION`; the snapshot
  * cache key carries both (`${CANON_VERSION}:${ANCHOR_GENERATION}:${checksum}`), so a canon-only change
  * misses the cache without invalidating anchor state while a generation change invalidates both.
  */
+/**
+ * The file-scoped anchor-derivation generation. It covers the width (`HASH_LEN`, `ALPHA`,
+ * `HASH_SPACE`/`USABLE_HASH_SPACE`), the (path, content) seeding, the all-digit reservation and the
+ * probe stride. Bump it whenever any of those change.
+ *
+ * WHY it is a function of the width: the width is a build-time switch (ADR-0020: default 4, optional
+ * 3), so a width change MUST flip the generation or a store written at one width could be read at
+ * another. Width 4 stays generation 1 — the original persisted generation — so existing stores keep
+ * their anchors; width 3 gets generation 2, and any future width gets `100 + width`.
+ */
 export declare function anchorGenerationFor(width: number): number;
 export declare const ANCHOR_GENERATION: number;
 export declare function canon(line: string): string;

package/lib/types/src/host-utils.d.ts

@@ -0,0 +1,63 @@
+/** Retained line budget, matching pi's `DEFAULT_MAX_LINES`. */
+export declare const DEFAULT_MAX_LINES = 2000;
+/** Retained byte budget, matching pi's `DEFAULT_MAX_BYTES` (50KB). */
+export declare const DEFAULT_MAX_BYTES: number;
+/** The truncation report the core's read page renders. */
+export interface TruncationResult {
+    /** The truncated content. */
+    content: string;
+    /** Whether truncation occurred. */
+    truncated: boolean;
+    /** Which limit was hit: `"lines"`, `"bytes"`, or `null` when nothing was cut. */
+    truncatedBy: "lines" | "bytes" | null;
+    /** Total number of lines in the original content. */
+    totalLines: number;
+    /** Total number of bytes in the original content. */
+    totalBytes: number;
+    /** Number of complete lines in the truncated output. */
+    outputLines: number;
+    /** Number of bytes in the truncated output. */
+    outputBytes: number;
+    /** Whether the last line was partially truncated (tail truncation only). */
+    lastLinePartial: boolean;
+    /** Whether the first line exceeded the byte limit (head truncation only). */
+    firstLineExceedsLimit: boolean;
+    /** The line limit that was applied. */
+    maxLines: number;
+    /** The byte limit that was applied. */
+    maxBytes: number;
+}
+/** The two independent limits a truncation call applies. */
+export interface TruncationOptions {
+    /** Maximum number of lines; defaults to {@link DEFAULT_MAX_LINES}. */
+    maxLines?: number;
+    /** Maximum number of bytes; defaults to {@link DEFAULT_MAX_BYTES}. */
+    maxBytes?: number;
+}
+/**
+ * Format bytes as a human-readable size (`512B`, `1.5KB`, `2.0MB`).
+ * @param bytes - the byte count to render.
+ * @returns the pi-compatible size label.
+ */
+export declare function formatSize(bytes: number): string;
+/**
+ * Truncate content from the head (keep the first N lines / bytes).
+ *
+ * WHY: the read page's oversize and truncation warnings must agree with the pi
+ * implementation the rest of the contract was written against, so this is a
+ * faithful port including its two edge rules: complete lines only, and an
+ * over-long first line yields empty content with `firstLineExceedsLimit`.
+ * @param content - the text to truncate.
+ * @param options - the line and byte limits.
+ * @returns the truncation report.
+ */
+export declare function truncateHead(content: string, options?: TruncationOptions): TruncationResult;
+/**
+ * Serialize file mutation operations that target the same file; different files still run
+ * in parallel. A faithful port of pi's queue so the core's cut transaction keeps its
+ * lock ordering guarantees under the dsh host.
+ * @param filePath - the file the mutation targets.
+ * @param run - the critical section to run once the path is free.
+ * @returns the critical section's result.
+ */
+export declare function withFileMutationQueue<T>(filePath: string, run: () => Promise<T>): Promise<T>;

package/lib/types/src/mutation-engine/edit-request.d.ts

@@ -0,0 +1,34 @@
+/** The internal payload vocabulary the mutation engine consumes; no wire schema lives here. */
+type SpanRef = {
+    anchor_from: string;
+    anchor_to: string;
+    file?: string;
+    mode: "copy" | "cut";
+};
+type EditMode = "general" | "literal";
+type Placement = "in-place" | "before" | "after";
+export type DesiredContent = {
+    kind: "literal";
+    text: string;
+} | {
+    kind: "reference";
+    span: SpanRef;
+    mode: "copy" | "cut";
+} | {
+    kind: "empty";
+};
+export type NormalizedEditItem = {
+    target: {
+        anchor_from: string;
+        anchor_to: string;
+    };
+    at: Placement;
+    payload: DesiredContent;
+    file?: string;
+};
+export type NormalizedEditRequest = {
+    file: string;
+    edits: NormalizedEditItem[];
+    mode?: EditMode;
+};
+export {};

package/lib/types/src/mutation-engine/pipeline.d.ts

@@ -1,8 +1,9 @@
-import type { NormalizedEditRequest } from "../payload-contract.js";
+import type { NormalizedEditRequest } from "./edit-request.js";
 import { buildBatchResult } from "../edit-response.js";
 import type { PipelineOptions, ProcessedEditFile } from "./types.js";
 export type { PipelineOptions, ProcessedEditFile };
 export declare function previewEdits(request: NormalizedEditRequest, cwd: string, options?: Omit<PipelineOptions, "noPersist">): Promise<ProcessedEditFile>;
+declare function runCorrelatedTransaction(writePlans: ProcessedEditFile[], sectionPlans: ProcessedEditFile[], options: PipelineOptions | undefined, sessionKey: string): Promise<BatchOutcome>;
 /** What one plan or committed batch reports: the primary file leads, every section rides the result. */
 interface BatchOutcome {
     result: string;
@@ -20,3 +21,9 @@ interface BatchOutcome {
 export declare function planEditTargets(request: NormalizedEditRequest, cwd: string, options?: PipelineOptions): Promise<ProcessedEditFile[] | undefined>;
 export declare function apply(request: NormalizedEditRequest, cwd: string, options?: PipelineOptions): Promise<BatchOutcome>;
 export declare function execEdits(request: NormalizedEditRequest, cwd: string, options?: PipelineOptions): Promise<ProcessedEditFile>;
+/**
+ * Visibility-only export of the correlated transaction for apply_patch's commit seam. The
+ * function body is the one the cut path already uses; apply_patch members carry an optional
+ * lifecycle action read by that body. No engine semantics change.
+ */
+export { runCorrelatedTransaction as commitTransaction };

package/lib/types/src/mutation-engine/types.d.ts

@@ -7,10 +7,9 @@
 import type { LineEnding } from "../edit-diff.js";
 import type { ResolvedRange } from "../served-session/serve-render.js";
 import type { HashStore } from "../hash-store.js";
-import type { EditDetails, RMetrics } from "../edit-response.js";
-import type { DomainErrorCode, RangeCause } from "../domain-errors.js";
-import type { ServedRow } from "../domain-errors.js";
 export interface PipelineOptions {
+    /** Workspace root used to re-assert lifecycle path boundaries at commit time. */
+    workspaceRoot?: string;
     accessMode?: number;
     signal?: AbortSignal;
     store?: HashStore;
@@ -32,6 +31,21 @@ export interface PipelineOptions {
      * window cannot show that.
      */
     onBeforeFirstCutWrite?: () => void | Promise<void>;
+    /**
+     * TEST-ONLY mid-member fault seam: called after a move's rename is durable and before its
+     * destination content is rewritten, so the rollback of that in-flight member is exercised.
+     */
+    onAfterMoveRename?: (toAbsolutePath: string) => void | Promise<void>;
+}
+/**
+ * The honest outcome of a failed multi-member commit's rollback attempt. `restored` members are
+ * proven back at their pre-images; `remaining` members were not rolled back; `uncertain` members
+ * are those whose rollback attempt itself threw, so neither state can be claimed for them.
+ */
+export interface TransactionRecoveryReport {
+    restored: string[];
+    remaining: string[];
+    uncertain: string[];
 }
 /**
  * (ticket-04b) One foreign `mode: "cut"` item as seen by the pre-pass: the submitted span anchors
@@ -45,6 +59,26 @@ export interface ForeignCutRecord {
     spanFrom: string;
     spanTo: string;
 }
+/**
+ * The file-lifecycle action one transaction member carries.
+ *
+ * This is the engine-local vocabulary: apply_patch's plan IR maps onto it in
+ * `src/apply-patch/commit.ts` so the mutation engine never imports the apply-patch layer.
+ * Absent is an ordinary in-place edit.
+ */
+export type MemberLifecycle = {
+    kind: "keep";
+} | {
+    kind: "add";
+    createdDirs: readonly string[];
+} | {
+    kind: "delete";
+} | {
+    kind: "move";
+    fromAbsolutePath: string;
+    toAbsolutePath: string;
+    createdDirs: readonly string[];
+};
 export interface ProcessedEditFile {
     path: string;
     absolutePath: string;
@@ -88,53 +122,9 @@ export interface ProcessedEditFile {
      * correlated two-file transaction; the in-memory buffer itself never touches these files.
      */
     foreignCuts: ForeignCutRecord[];
-}
-export interface MutationSuccess {
-    ok: true;
-    /** SAFETY: Normalized result content (LF). */
-    result: string;
-    /** SAFETY: Unified diff (hash-anchored) for model consumption. */
-    diff: string;
-    /** SAFETY: User-facing drift notice, if any (details only, not model content). */
-    drift: string | undefined;
-    /** SAFETY: Metrics for telemetry. */
-    metrics: RMetrics;
-    raw: ProcessedEditFile;
-    /** SAFETY: Full tool result (content + details) for pi's tool_result hook. */
-    toolResult: {
-        content: Array<{
-            type: "text";
-            text: string;
-        }>;
-        details: EditDetails;
-    };
-}
-export interface MutationFailure {
-    ok: false;
-    /**
-     * SAFETY: Machine code — a registry member (`DomainErrorCode`). `toFailure` validates every
-     * caught code through the envelope reader (`src/error-envelope.ts`): non-registry strings
-     * (errno pass-through included) route to `E_UNKNOWN`, so the union is honest.
-     */
-    code: DomainErrorCode;
-    /** SAFETY: Human message — model-facing signal when applicable. */
-    message: string;
-    /** SAFETY: Fresh served block for retry when available (reject-and-serve). */
-    servedBlock?: string;
-    servedRows?: ServedRow[];
     /**
-     * SAFETY: the RAW `E_BAD_PAYLOAD` message behind a rendered refusal, when the route is one, so
-     * SAFETY: the tool seam can name the invoking tool instead of falling back to the neutral
-     * SAFETY: wording. Present only for `code: "E_BAD_PAYLOAD"`.
+     * apply_patch lifecycle action for this member; absent is an ordinary edit. The correlated
+     * transaction reads it for pre-image capture, commit ordering, rollback and undo-row shape.
      */
-    payloadMessage?: string;
-    /** SAFETY: User-facing diagnosis, never a model remedy — a GLOSSARY.md glossary term. */
-    cause?: RangeCause;
-    details?: {
-        code: DomainErrorCode;
-        cause: RangeCause;
-    };
+    lifecycle?: MemberLifecycle;
 }
-export type MutationResult = MutationSuccess | MutationFailure;
-export declare function isMutationSuccess(r: MutationResult): r is MutationSuccess;
-export declare function isMutationFailure(r: MutationResult): r is MutationFailure;

package/lib/types/src/served-session/serve-render.d.ts

@@ -14,7 +14,13 @@ export interface FileSnapshotContext {
 export declare function buildRangeServeRows(startLine: number, endLine: number, fileHashes: string[]): ServedRow[];
 export declare function denseServeRows(hashes: readonly string[]): ServedRow[];
 export declare function fmtServedRows(rows: ServedRow[], fileLines: string[]): string;
+export declare function paginationHint(nextOffset: number, more: number): string;
 export declare function servedPositionsOf(served: (string | null)[], hash: string): number[];
+/** Builds the reject-and-serve served rows + rendered block for a current on-disk range. */
+export declare function buildRangeServeBlock(startLine: number, endLine: number, fileHashes: string[], fileLines: string[]): {
+    servedRows: ServedRow[];
+    rendered: string;
+};
 /**
  * Builds an `[E_TARGET_LOST]` rejection for a retired leased identity whose range cannot be
  * identified (spec stale-identity-reject-and-serve D1/D6, ADR-0018 decisions 1-2). The payload

package/lib/types/src/undo-store.d.ts

@@ -25,7 +25,23 @@ export interface UndoRecord {
      * `null` is a row from before this column, or an ordinary single-file edit.
      */
     rawPre?: string | null;
+    /**
+     * The lifecycle action this row reverses. Absent/null is an ordinary edit (back-compatible).
+     * add = the file did not exist before; delete = the file does not exist after; move = a pure
+     * rename with an optional content edit.
+     */
+    lifecycle?: UndoLifecycle | null;
+    /** Move: the absolute path the file had before the transaction. */
+    fromPath?: string | null;
+    /** Move: the absolute path the file has after the transaction. */
+    toPath?: string | null;
+    /** The RAW post-transaction text when the commit wrote non-canonical bytes (pure move). */
+    rawPost?: string | null;
+    /** Add: the directories the add created, outermost first, JSON-encoded in the column. */
+    createdDirs?: readonly string[] | null;
 }
+/** The lifecycle action one undo row reverses. */
+export type UndoLifecycle = "edit" | "add" | "delete" | "move";
 export type CutIntentDirection = "revert" | null;
 export interface CutIntent {
     txnId: string;
@@ -33,7 +49,7 @@ export interface CutIntent {
     direction: CutIntentDirection;
 }
 export interface UndoStmts {
-    undoUpsert: (path: string, content: string, bom: string, ending: string, hashes: string, resultContent: string, snapshotHash: string | null, transactionId: string | null, rawPre: string | null, anchorGeneration: number, updatedAt: number) => void;
+    undoUpsert: (path: string, content: string, bom: string, ending: string, hashes: string, resultContent: string, snapshotHash: string | null, transactionId: string | null, rawPre: string | null, lifecycle: string | null, fromPath: string | null, toPath: string | null, rawPost: string | null, createdDirs: string | null, anchorGeneration: number, updatedAt: number) => void;
     undoGet: (path: string) => Record<string, unknown> | undefined;
     undoDelete: (path: string) => void;
     undoGetTransaction: (transactionId: string) => Record<string, unknown>[];

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "dsh-hashline-edit",
-  "version": "0.2.2",
-  "description": "Hash-anchored read/edit/undo_last_edit tools for DeepSeek Harness (dsh). Every line gets a unique 3- or 4-char hash (A-Za-z0-9, configurable) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
+  "version": "0.3.0",
+  "description": "Hash-anchored read/apply_patch tools for DeepSeek Harness (dsh). Every line gets a unique 3- or 4-char hash (A-Za-z0-9, configurable) that stays stable across edits; apply_patch is the only file-mutation entry point and commits one patch batch per transaction. Undo persists across restarts.",
   "keywords": [
     "anchors",
+    "apply-patch",
     "coding-agent",
     "deepseek-harness",
     "dsh",
     "dsh-plugin",
-    "edit",
     "file-editing",
     "hash",
     "hash-anchored",
@@ -42,6 +42,9 @@
       "types": "./lib/types/dsh/index.d.ts",
       "default": "./lib/index.js"
     },
+    "./client": {
+      "default": "./lib/client.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -49,6 +52,7 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --coverage.thresholds.lines=85 --coverage.thresholds.statements=85 --coverage.thresholds.functions=85 --coverage.thresholds.branches=80",
     "test:win": "vitest run --config vitest.config.windows.ts",
+    "test:win:3": "node scripts/test-width.mjs 3 dsh",
     "test:win:coverage": "vitest run --config vitest.config.windows.ts --coverage --coverage.thresholds.lines=85 --coverage.thresholds.statements=85 --coverage.thresholds.functions=85 --coverage.thresholds.branches=80",
     "lint": "oxlint . && knip --max-issues 0",
     "lint:knip": "knip --max-issues 0",
@@ -56,17 +60,8 @@
     "format:fix": "oxfmt .",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.dsh.json",
     "build": "node scripts/build-dsh.mjs",
-    "build:pi": "node scripts/build-dist.mjs",
     "prepublishOnly": "node scripts/build-dsh.mjs && pnpm run typecheck && pnpm run lint && pnpm run test:win",
     "canon:audit": "node scripts/canon-churn-audit.mjs",
-    "prompts:show": "node scripts/served-prompts.mjs",
-    "replay:read-expansion": "node scripts/read-expansion-replay.mjs",
-    "test:runtime": "node scripts/runtime-edge-test.mjs",
-    "verify:dist": "node scripts/verify-dist.mjs",
-    "verify:dist:mutations": "node scripts/verify-dist-mutations.mjs",
-    "measure:import": "node scripts/measure-import.mjs --max-ratio 0.75",
-    "smoke:install": "node scripts/install-smoke.mjs",
-    "prepare": "node scripts/prepare.mjs",
     "prepack": "node scripts/build-dsh.mjs",
     "audit": "pnpm audit --audit-level high --registry https://registry.npmjs.org/",
     "verify": "pnpm run lint && pnpm run format && pnpm run typecheck && pnpm run test:win:coverage"
@@ -74,7 +69,6 @@
   "dependencies": {
     "diff": "^8.0.2",
     "file-type": "^21.3.0",
-    "typebox": "^1.3.27",
     "unbash": "5.0.0",
     "xxhash-wasm": "^1.1.0"
   },
@@ -82,39 +76,61 @@
     "@babel/parser": "7.29.8",
     "@commitlint/cli": "^21.2.2",
     "@commitlint/config-conventional": "^21.2.2",
-    "@deepseek-ai/cordis": "^4.0.5",
-    "@deepseek-ai/dsh-agent": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-fs": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-home-paths": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-sandbox": "0.2.1-rc.2",
-    "@deepseek-ai/dsh-tools": "0.2.1-rc.2",
-    "@earendil-works/pi-coding-agent": "^0.84.0",
-    "@earendil-works/pi-tui": "*",
+    "@deepseek-ai/cordis": "4.1.0",
+    "@deepseek-ai/dsh-agent": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-fs": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-home-paths": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-sandbox": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-tools": "0.2.2-rc.1",
+    "@deepseek-ai/schemastery": "3.19.0",
     "@semantic-release/git": "^11.0.1",
     "@semantic-release/github": "^12.0.9",
     "@semantic-release/npm": "^13.1.5",
     "@types/node": "^24.0.0",
+    "@types/react": "18.3.1",
     "@vitest/coverage-v8": "^4.1.10",
     "esbuild": "0.28.2",
     "husky": "^9.1.7",
     "knip": "6.40.0",
     "oxfmt": "^0.66.0",
     "oxlint": "^1.81.0",
+    "react": "18.3.1",
     "semantic-release": "^25.0.9",
     "typescript": "^7.0.0",
     "vite": "^8.3.5",
     "vitest": "^4.1.8"
   },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.1.0",
+    "@deepseek-ai/dsh-agent": ">=0.2.2-rc.1 <0.2.3-0",
+    "@deepseek-ai/dsh-fs": ">=0.2.2-rc.1 <0.2.3-0",
+    "@deepseek-ai/dsh-home-paths": ">=0.2.2-rc.1 <0.2.3-0",
+    "@deepseek-ai/dsh-sandbox": ">=0.2.2-rc.1 <0.2.3-0",
+    "@deepseek-ai/dsh-tools": ">=0.2.2-rc.1 <0.2.3-0"
+  },
   "optionalDependencies": {
     "web-tree-sitter": "0.27.1"
   },
   "engines": {
+    "dsh": ">=0.2.2-rc.1 <0.2.3-0",
     "node": ">=24.0.0"
   },
   "packageManager": "pnpm@12.0.0",
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-api-gateway",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-plugin-manager",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-ui-primitives"
+      ],
+      "platform": "web",
+      "immediately": true
     }
   }
 }

package/prompts/apply-patch-guidelines.md

@@ -0,0 +1,4 @@
+- apply_patch: one call = one transaction; batch related changes and split only when an earlier RESULT decides the next.
+- apply_patch: hunks are validated against the pre-call file in order (overlapping ranges reject the batch); a fragment hunk must match exactly once — add context to disambiguate, never guess — while identity hunks target served rows and a stale or unknown anchor is rejected; both serve the current rows back.
+- apply_patch: a rejection writes nothing; retry from the served `HASH│content` rows without another `read`.
+- apply_patch: success returns fresh anchors for changed lines; whole-file replacement is one identity hunk over every served line.

package/prompts/apply-patch.md

@@ -0,0 +1 @@
+Create, update, delete, move, copy, or cut UTF-8 text files with a single transactional patch; prefer it over multiple single-file edits when a change spans files or separated regions. Pass the complete patch as `input`.

package/prompts/read-guidelines.md

@@ -1,6 +1,6 @@
-- read: call it only for information the tool never served you, such as content past the auto-read diff. A bash view or an auto-read already served the file, so edit from those rows.
-- read: when you need several blocks or both boundaries of one replacement, put every range in ONE call. Use `{ file, windows: [{ offset, limit }] }`. Each window is served in that turn, so its anchors work in the same edit. A window can also be `{ around_anchor, radius }` to centre on a line this session already served. An anchor outside this session's served rows is omitted with an inline `[Window warning: ...]`.
-- read: a requested window of 61 lines or fewer can widen to its enclosing block; overlapping or adjacent windows fold before this test. Caps are 80 lines for code and Markdown, 40 for plain text. Widened rows begin with `[widened <requested> -> <served>, <label>]`; above three requested windows the note is `[widened N windows: <ranges>]`. An over-cap Markdown section clamps and names `(section <extent>)`; over-cap code or plain text refuses with no note. `mode: "verbatim"` widens too, with no anchors.
-- read: when you will not edit the file, pass `mode: "verbatim"` for plain content with no anchors. Examples are a config value, docs, a README, or skill content (a SKILL.md or any file in its directory). Omit `mode` when you intend to edit, so the rows carry anchors.
-- read: send one file per call as `{ file, windows?, mode? }`, the same way `edit` does. The single top-level `mode` applies to the file. To read several files, make parallel `read` calls.
-- read: PNG/JPG images return as image attachments for multimodal models. Request one with `file` like any other file.
+- read: call it for content the tool has never served you; a bash view or an auto-read already served the file, so `apply_patch` can use those rows.
+- read: batch several disjoint ranges in ONE call with `windows` — an offset/limit range, or `around_anchor` plus `radius` around a line this session served.
+- read: pass `mode: "verbatim"` when you will not `apply_patch` the file (config, docs, a README, skill files); otherwise omit it so the rows carry anchors.
+- read: a window of 61 lines or fewer may widen to its enclosing block; widened rows carry a `[widened …]` note. Caps are 80 lines for code/Markdown and 40 for plain text.
+- read: read several files with parallel `read` calls, one file per call.
+- read: PNG/JPG/GIF/WebP files return as an image attachment for multimodal models; binary files and directories are refused.

package/prompts/read.md

@@ -1 +1 @@
-Read one text file via `file`, with optional `windows` and top-level `mode`. To read several files, make parallel `read` calls. Served mode (default) returns each line as HASH│content with a {{HASH_LEN}}-char alphanumeric hash. That hash is the `edit` anchor, so copy only the {{HASH_LEN}} chars before `│`. Pass `mode: "verbatim"` for plain text with no anchors when you will not edit. `mode: "verbatim"` is not capped by line budget. Name ranges with `windows`: `[{ offset, limit }]` (offset is 1-indexed, limit is a line count, maximum 16 windows) or `[{ around_anchor: "<anchor>", radius: 10 }]` for a line this session served. When a page stops short, continue from the next unshown line with `windows: [{ offset, limit }]`. A requested window of 61 lines or fewer can widen to its enclosing block before serving; overlapping or adjacent windows fold before this test. Caps are 80 lines for code and Markdown, 40 for plain text. A widened page begins with `[widened <requested> -> <served>, <label>]`; more than three requested windows collapse to `[widened N windows: <ranges>]`. An over-cap Markdown section clamps to a cap-sized window and names `(section <extent>)`; an over-cap code or plain-text block refuses, serving the requested window. `mode: "verbatim"` widens the same way but adds no anchors. Inline `[...]` notices describe the served result, not file content. Empty files return `HASH│` (edit to insert). PNG/JPG/GIF/WebP return as image attachments for multimodal models. Binary and directory files are rejected. Hashes are file-scoped: an anchor is bound to the file it was served from.
+Reads a UTF-8 file as `HASH│content` rows in served mode; each row's anchor is the `apply_patch` identity anchor for that line. Pass `mode: "verbatim"` for plain text with no anchors when you will not apply_patch; verbatim is not capped by line budget. Batch disjoint ranges in one call with `windows` (offset/limit or `around_anchor`).

package/prompts/undo-last-edit-guidelines.md

@@ -1,2 +1,2 @@
-- undo_last_edit: reverts the most recent `edit` call on the file at `path`, and every item of its `edits`. Its scope is the edited file. The exception is an edit that was a foreign `cut`: undo then restores the source file too. The file must still hold the edited bytes. An out-of-band write makes the call fail with `E_UNDO_STALE`, and the file stays byte-identical. Call it as soon as a result is bad.
-- undo_last_edit: a `write` to the file, or a later `edit`, replaces the undo entry. A read, a bash view or an out-of-band write leaves the entry in place. An edit is bad when its post-edit diff shows `-HASH│` rows for lines you meant to keep. Examples are a closing brace, an import, or a declaration.
+- undo_last_edit: reverts the most recent `apply_patch` batch that touched the file at `path`, and every member of that batch: text hunks plus file lifecycle actions (add/delete/move). The exception is a foreign `cut`: undo then restores the source file too. The file must still hold the edited bytes. An out-of-band write makes the call fail with `E_UNDO_STALE`, and the file stays byte-identical. Call it as soon as a result is bad.
+- undo_last_edit: a `write` to the file, or a later `apply_patch` batch, replaces the undo entry. A read, a bash view or an out-of-band write leaves the entry in place. An apply_patch result is bad when its diff shows `-HASH│` rows for lines you meant to keep. Examples are a closing brace, an import, or a declaration.

package/prompts/undo-last-edit-snippet.md

@@ -1 +1 @@
-Undo the last edit on the file at `path`
+Undo the last `apply_patch` batch on the file at `path`

package/prompts/undo-last-edit.md

@@ -1 +1 @@
-Undo the last edit on the file at `path`, reverting it to its previous state. Use when an edit produced incorrect results (e.g., wrong content, duplicated lines, broken syntax). The file must be unchanged since that edit.
+Undo the last `apply_patch` batch that touched the file at `path`, reverting the whole batch — every text hunk plus file lifecycle actions (add/delete/move) — to its previous state. Use when an `apply_patch` produced incorrect results (e.g., wrong content, duplicated lines, broken syntax). The file must be unchanged since that batch.

package/prompts/zh/apply-patch-guidelines.md

@@ -0,0 +1,4 @@
+- apply_patch：一次调用 = 一个事务；把相关改动成批处理，只有当先前的结果决定下一步时才拆分。
+- apply_patch：各 hunk 按顺序针对调用前的文件校验（重叠范围会拒绝整批）；片段 hunk 必须恰好匹配一次——补充上下文以消歧，绝不猜测——身份 hunk 定位已服务的行，陈旧或未知锚点会被拒绝；两者都会回送当前行。
+- apply_patch：拒绝时不写入任何内容；从回送的 `HASH│content` 行重试，无需再次 `read`。
+- apply_patch：成功时返回改动行的新锚点；整文件替换是用一个身份 hunk 覆盖每一行已服务的行。

package/prompts/zh/apply-patch.md

@@ -0,0 +1 @@
+用单个事务补丁创建、更新、删除、移动、复制或剪切 UTF-8 文本文件；当改动跨多个文件或分散区域时，优先于多次单文件编辑。把完整补丁作为 `input` 传入。

package/prompts/zh/read-guidelines.md

@@ -0,0 +1,6 @@
+- read：仅在工具尚未服务给你信息时调用，例如自动读取 diff 之外的内容。bash 视图或自动读取已经服务过该文件，因此直接用那些行 apply_patch。
+- read：当一次替换需要多个块或两端边界时，把每个范围放进同一次调用。用 `{ file, windows: [{ offset, limit }] }`。每个窗口都在当轮被服务，因此其锚点可在同一次 apply_patch 调用中使用。窗口也可以是 `{ around_anchor, radius }`，以本会话已服务的某行为中心。本会话未服务过的锚点会被省略，并内联标注 `[Window warning: ...]`。
+- read：61 行及以内的请求窗口可扩展到其所在块；重叠或相邻窗口在此判定前合并。上限为：代码与 Markdown 80 行，纯文本 40 行。扩展的行以 `[widened <requested> -> <served>, <label>]` 开头；超过三个请求窗口的提示为 `[widened N windows: <ranges>]`。超限的 Markdown 章节会裁剪并标注 `(section <extent>)`；超限的代码或纯文本则拒绝且无提示。`mode: "verbatim"` 也会扩展，但不加锚点。
+- read：当你不打算对该文件 apply_patch 时，用 `mode: "verbatim"` 获取无锚点的纯内容。例如配置值、文档、README 或技能内容（SKILL.md 或其所处目录中的任意文件）。当你打算用锚点配合 apply_patch 时，就不要指定 `mode`，让这些行带上锚点。
+- read：每次调用只发送一个文件，形式为 `{ file, windows?, mode? }`，与 `apply_patch` 相同。单个顶层 `mode` 作用于该文件。要读多个文件就并行发起多次 `read` 调用。
+- read：PNG/JPG 图像以图像附件形式返回，供多模态模型使用。像其他文件一样用 `file` 请求。

package/prompts/zh/read-snippet.md

@@ -0,0 +1 @@
+通过 `file`、`windows?`、`mode?` 读取文件；默认返回可直接编辑的 HASH│content 行，`mode: "verbatim"` 在你不编辑时返回纯文本；用 `windows` 在一次调用中批量读取多个范围

package/prompts/zh/read.md

@@ -0,0 +1 @@
+通过 `file` 读取一个文本文件，可选 `windows` 与顶层 `mode`。要读多个文件就并行发起多次 `read` 调用。服务模式（默认）把每行返回为 HASH│content，带一个 {{HASH_LEN}} 字符的字母数字哈希。该哈希就是 `apply_patch` 的身份锚点，因此只复制 `│` 之前的 {{HASH_LEN}} 个字符。当你不打算 apply_patch 该文件时，用 `mode: "verbatim"` 获取无锚点的纯文本。`mode: "verbatim"` 不受行数上限限制。用 `windows` 指定范围：`[{ offset, limit }]`（offset 从 1 开始，limit 为行数，最多 16 个窗口）或 `[{ around_anchor: "<anchor>", radius: 10 }]`（针对本会话已服务的某行）。当页面未取全时，用 `windows: [{ offset, limit }]` 从下一个未显示行继续。61 行及以内的请求窗口在返回前可能扩展到其所在块；重叠或相邻的窗口在此判定前会合并。上限为：代码与 Markdown 80 行，纯文本 40 行。扩展页以 `[widened <requested> -> <served>, <label>]` 开头；超过三个请求窗口时折叠为 `[widened N windows: <ranges>]`。超限的 Markdown 章节会裁剪为上限大小的窗口并标注 `(section <extent>)`；超限的代码或纯文本块则拒绝，只返回所请求的窗口。`mode: "verbatim"` 同样会扩展，但不加锚点。行内的 `[...]` 提示描述的是返回结果，而非文件内容。空文件返回 `HASH│`（用 apply_patch 身份 hunk 插入）。PNG/JPG/GIF/WebP 以图像附件形式返回，供多模态模型使用。二进制与目录文件会被拒绝。哈希是文件作用域的：一个锚点绑定于它被服务时所在的文件。

package/prompts/zh/undo-last-edit-guidelines.md

@@ -0,0 +1,2 @@
+- undo_last_edit：还原最近一次触及 `path` 处文件的 `apply_patch` 批次及其每个成员：文本 hunk 加文件生命周期操作（增/删/移动）。例外是外来 `cut`：此时撤销也会还原源文件。文件必须仍保有被编辑后的字节。带外写入会让调用以 `E_UNDO_STALE` 失败，且文件保持字节不变。一旦结果不对就立刻调用它。
+- undo_last_edit：对该文件的 `write`，或之后的一次 `apply_patch` 批次，会替换撤销记录。一次读取、bash 视图或带外写入会保留该记录。当一次 apply_patch 的 diff 显示出你本想保留的行的 `-HASH│` 行时，该结果就是错的。例子包括一个收尾花括号、一句 import 或一个声明。

package/prompts/zh/undo-last-edit-snippet.md

@@ -0,0 +1 @@
+撤销对 `path` 处文件最近一次的 `apply_patch` 批次

package/prompts/zh/undo-last-edit.md

@@ -0,0 +1 @@
+撤销最近一次触及 `path` 处文件的 `apply_patch` 批次，把整批——每个文本 hunk 加上文件生命周期操作（增/删/移动）——还原到先前状态。当某次 `apply_patch` 产生了错误结果（例如内容错误、重复行、语法损坏）时使用。该文件自那批之后必须未被改动。