@oh-my-pi/pi-coding-agent 16.3.0 → 16.3.3

package/src/edit/hashline/diff.ts

@@ -180,8 +180,7 @@ function resolvePreviewEdits(args: {
 }): readonly Edit[] {
 	const { section, absolutePath, normalized, snapshots, expected, liveMatches, edits } = args;
 	if (!hasBlockEdit(edits)) return edits;
-	const baseText =
-		expected === undefined || liveMatches ? normalized : snapshots.byHashExact(absolutePath, expected)?.text;
+	const baseText = expected === undefined || liveMatches ? normalized : snapshots.byHash(absolutePath, expected)?.text;
 	if (baseText === undefined) {
 		throw createMismatchError(section, absolutePath, normalized, snapshots, expected ?? "");
 	}
@@ -200,17 +199,9 @@ function applyPreviewEdits(args: {
 	if (!options.skipHashValidation && expected === undefined) {
 		throw new Error(missingSnapshotTagMessage(section.path));
 	}
-	// A 16-bit tag can collide across two different file states, so hash
-	// equality alone does not prove the live text IS the snapshot the model's
-	// anchors were minted against (mirrors Patcher's apply-time guard). When
-	// the store retains text for the tag, require it to be unambiguous and
-	// byte-identical to live; otherwise fall through to recovery/reject below
-	// exactly as if the hash had not matched.
-	const liveMatches =
-		expected !== undefined &&
-		computeFileHash(normalized) === expected &&
-		(snapshots.byHash(absolutePath, expected) === null ||
-			snapshots.byHashExact(absolutePath, expected)?.text === normalized);
+	// The 4-hex tag is content-derived: when the live text hashes to it, trust
+	// the match and preview directly (mirrors Patcher's apply-time behavior).
+	const liveMatches = expected !== undefined && computeFileHash(normalized) === expected;
 	const edits = parsePreviewEdits(section, options.streaming);
 	const resolved = resolvePreviewEdits({ section, absolutePath, normalized, snapshots, expected, liveMatches, edits });
 	if (options.skipHashValidation || expected === undefined || liveMatches) return applyEdits(normalized, resolved);

package/src/edit/hashline/execute.ts

@@ -1,6 +1,6 @@
 /**
  * Coding-agent runner that drives the hashline {@link Patcher} on behalf of
- * the `edit` tool. Converts a `{input}` tool-call payload into a
+ * 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 LSP diagnostics + `outputMeta`
  * for the renderer.

package/src/edit/hashline/params.ts

@@ -1,19 +1,12 @@
 /**
  * Arktype schema for the `edit` tool's hashline mode payload. The schema is
  * deliberately permissive (allows extra keys) so providers can attach extra
- * keys without rejection; only `input` is required. `_input` is accepted as a
- * provider-emitted alias for `input`.
+ * keys without rejection; only `input` is required.
  */
 import { type } from "arktype";
 
-const requiredInputSchema = type({ input: "string" });
-const inputAliasSchema = type({ "input?": "string", "_input?": "string" });
+export const hashlineEditParamsSchema = type({
+	input: "string",
+});
 
-export const hashlineEditParamsSchema = inputAliasSchema
-	.pipe(raw => {
-		if (raw.input !== undefined || raw._input === undefined) return raw;
-		return { ...raw, input: raw._input };
-	})
-	.pipe(requiredInputSchema);
-
-export type HashlineParams = Parameters<typeof hashlineEditParamsSchema.assert>[0];
+export type HashlineParams = typeof hashlineEditParamsSchema.infer;

package/src/edit/renderer.ts

@@ -114,6 +114,7 @@ interface EditRenderArgs {
 	newText?: string;
 	patch?: string;
 	input?: string;
+	_input?: string;
 	all?: boolean;
 	// Patch mode fields
 	op?: Operation;
@@ -600,10 +601,11 @@ function getHashlineInputRenderSummary(
 	args: EditRenderArgs,
 	editMode: EditMode | undefined,
 ): HashlineInputRenderSummary | undefined {
-	if (editMode !== "hashline" || typeof args.input !== "string") {
+	const input = args.input ?? args._input;
+	if (editMode !== "hashline" || typeof input !== "string") {
 		return undefined;
 	}
-	return { entries: getHashlineInputSections(args.input) };
+	return { entries: getHashlineInputSections(input) };
 }
 
 function getApplyPatchRenderSummary(

package/src/edit/streaming.ts

@@ -429,9 +429,19 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 
 interface HashlineArgs {
 	input?: string;
+	_input?: string;
 	__partialJson?: string;
 }
 
+/**
+ * Text payload of a hashline edit call. The public schema declares `input`, but
+ * streaming sees the raw model output before validation coerces aliases, so a
+ * provider that emits the legacy `_input` key still previews correctly.
+ */
+function hashlineEditText(args: HashlineArgs | undefined): string | undefined {
+	return args?.input ?? args?._input;
+}
+
 /**
  * While streaming a free-form text payload (apply_patch envelope, hashline
  * input), trim the trailing partial line so per-character growth of an
@@ -513,7 +523,8 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		return args;
 	},
 	async computeDiffPreview(args, ctx) {
-		if (typeof args.input !== "string" || args.input.length === 0) return null;
+		const input = hashlineEditText(args);
+		if (typeof input !== "string" || input.length === 0) return null;
 		// Unlike apply_patch, hashline previews flow through `applyPartialTo`,
 		// whose streaming-tolerant parser (`parsePatchStreaming` → `endStreaming`)
 		// drops a payload-less trailing op and projects a partially-typed payload
@@ -521,7 +532,6 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		// would instead strip the sole payload of a single-op `replace`/`insert`
 		// for almost the entire stream, collapsing the preview to "No changes" and
 		// rendering a blank box. Feed the raw in-flight text straight through.
-		const input = args.input;
 		ctx.signal.throwIfAborted();
 
 		let sections: readonly HashlineInputSection[];
@@ -579,19 +589,19 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		return "";
 	},
 	matcherDigest(args) {
-		const input = args?.input;
+		const input = hashlineEditText(args);
 		if (typeof input !== "string") return undefined;
 		// Body rows are `+TEXT`; headers and op lines are grammar, never content.
 		return extractAddedLines(input, false);
 	},
 	matcherPaths(args) {
-		const input = args?.input;
+		const input = hashlineEditText(args);
 		if (typeof input !== "string" || input.length === 0) return undefined;
 		const paths = extractHashlineHeaderPaths(input);
 		return paths.length > 0 ? paths : undefined;
 	},
 	matcherEntries(args) {
-		const input = args?.input;
+		const input = hashlineEditText(args);
 		if (typeof input !== "string" || input.length === 0) return undefined;
 		const entries = splitHashlinePerFile(input);
 		return entries.length > 0 ? entries : undefined;