feat(coding-agent): adapt upstream edit and GitHub search improvements

Author: durch

.oh/skills/oh-ship/SKILL.md

@@ -94,6 +94,8 @@ Reviewed upstream commit: `<sha>`
 
 If the selected list is empty, explicitly say `Selected: none` and explain why every high-level upstream theme was excluded. A shallow log/stat dump is not a review.
 
+Do not exclude an entire high-level theme merely because some commits are incompatible. If a theme contains potentially useful harness improvements, split it into: selected now, deferred for a focused follow-up batch, and excluded. Useful-but-risky candidates should become explicit follow-up phases rather than disappearing into `Excluded`.
+
 ### 3. Incorporate selected changes
 
 Preferred methods, in order:
@@ -108,6 +110,8 @@ git cherry-pick -n <commit>
 
 Do not use a full merge to pick up upstream work. If a change cannot be isolated with these methods, leave it upstream until it can be understood and adapted safely.
 
+Use phased incorporation for large upstream themes. Prefer small batches such as: edit/hashline reliability, provider compatibility, browser/tool reliability, GitHub/release tooling, read/fetch ergonomics, async jobs, then high-authority tools such as SQLite. Each phase must preserve fork-specific contracts and avoid importing upstream's obsolete architecture.
+
 ### 4. Fork-specific removals remain removed
 
 **The fork intentionally removes these upstream subsystems:**
@@ -128,6 +132,7 @@ These are replaced by the assembler pipeline (ADR 0003).
 | Upstream modifies code the fork deleted | Leave it upstream; the deletion stands |
 | Upstream adds a useful feature unrelated to removed subsystems | Incorporate the feature selectively |
 | Upstream mixes useful behavior with removed subsystem wiring | Adapt only the useful behavior without the removed wiring |
+| Upstream improves edit/tool reliability but changes wire/display contracts | Adapt the behavior while preserving fork contracts such as `LINE#ID` anchors and assembler-aware tool outputs |
 | Upstream adds tests for removed settings/events | Do not copy those tests unless rewritten for fork behavior |
 | `bun.lock` changes from selected dependency updates | Apply the dependency update, then run `bun install` |
 | `CHANGELOG.md` has upstream release notes | Preserve useful reference sections only when they help fork users |

packages/coding-agent/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+### Added
+
+- Adapted upstream GitHub code and commit search tools as standalone `gh_search_code` and `gh_search_commits` tools for source/release archaeology without adopting the broader upstream GitHub op-tool refactor.
+
+### Changed
+
+- Adapted upstream hashline duplicate-boundary handling to auto-absorb repeated multiline replacement boundaries while preserving the fork's structured `LINE#ID` edit contract.
+
+
 ## [0.8.1] - 2026-05-03
 
 ### Added

packages/coding-agent/src/patch/hashline.ts

@@ -454,6 +454,128 @@ function maybeWarnSuspiciousUnicodeEscapePlaceholder(edits: HashlineEdit[], warn
 		);
 	}
 }
+
+type ReplacementHashlineEdit =
+	| { op: "replace_line"; pos: Anchor; lines: string[] }
+	| { op: "replace_range"; pos: Anchor; end: Anchor; lines: string[] };
+
+interface ReplacementBounds {
+	startLine: number;
+	endLine: number;
+}
+
+function replacementBounds(edit: HashlineEdit): ReplacementBounds | undefined {
+	switch (edit.op) {
+		case "replace_line":
+			return { startLine: edit.pos.line, endLine: edit.pos.line };
+		case "replace_range":
+			return { startLine: edit.pos.line, endLine: edit.end.line };
+		default:
+			return undefined;
+	}
+}
+
+function isReplacementEdit(edit: HashlineEdit): edit is ReplacementHashlineEdit {
+	return edit.op === "replace_line" || edit.op === "replace_range";
+}
+
+function collectProtectedAnchorLines(edits: HashlineEdit[]): Set<number> {
+	const protectedLines = new Set<number>();
+	for (const edit of edits) {
+		switch (edit.op) {
+			case "replace_line":
+			case "append_at":
+			case "prepend_at":
+				protectedLines.add(edit.pos.line);
+				break;
+			case "replace_range":
+				protectedLines.add(edit.pos.line);
+				protectedLines.add(edit.end.line);
+				break;
+			case "append_file":
+			case "prepend_file":
+				break;
+		}
+	}
+	return protectedLines;
+}
+
+function hasProtectedAnchorInRange(protectedLines: Set<number>, startLine: number, endLine: number): boolean {
+	for (let line = startLine; line <= endLine; line++) {
+		if (protectedLines.has(line)) return true;
+	}
+	return false;
+}
+
+function countDuplicatePrefix(
+	insertedLines: string[],
+	startLine: number,
+	originalFileLines: string[],
+	protectedLines: Set<number>,
+): number {
+	const maxCount = Math.min(insertedLines.length - 1, startLine - 1);
+	for (let count = maxCount; count >= 2; count--) {
+		const sourceStartLine = startLine - count;
+		const sourceEndLine = startLine - 1;
+		if (hasProtectedAnchorInRange(protectedLines, sourceStartLine, sourceEndLine)) continue;
+		const sourceLines = originalFileLines.slice(sourceStartLine - 1, sourceEndLine);
+		if (sourceLines.every((line, index) => line === insertedLines[index])) return count;
+	}
+	return 0;
+}
+
+function countDuplicateSuffix(
+	insertedLines: string[],
+	endLine: number,
+	originalFileLines: string[],
+	protectedLines: Set<number>,
+): number {
+	const maxCount = Math.min(insertedLines.length - 1, originalFileLines.length - endLine);
+	for (let count = maxCount; count >= 2; count--) {
+		const sourceStartLine = endLine + 1;
+		const sourceEndLine = endLine + count;
+		if (hasProtectedAnchorInRange(protectedLines, sourceStartLine, sourceEndLine)) continue;
+		const sourceLines = originalFileLines.slice(sourceStartLine - 1, sourceEndLine);
+		const insertedStart = insertedLines.length - count;
+		if (sourceLines.every((line, index) => line === insertedLines[insertedStart + index])) return count;
+	}
+	return 0;
+}
+
+function absorbDuplicateReplacementBoundaries(
+	edits: HashlineEdit[],
+	originalFileLines: string[],
+	warnings: string[],
+): void {
+	const protectedLines = collectProtectedAnchorLines(edits);
+	for (const edit of edits) {
+		if (!isReplacementEdit(edit)) continue;
+		const bounds = replacementBounds(edit);
+		if (!bounds || edit.lines.length < 3) continue;
+
+		const prefixCount = countDuplicatePrefix(edit.lines, bounds.startLine, originalFileLines, protectedLines);
+		if (prefixCount >= 2) {
+			edit.lines = edit.lines.slice(prefixCount);
+			const tag = formatLineTag(
+				bounds.startLine - prefixCount,
+				originalFileLines[bounds.startLine - prefixCount - 1],
+			);
+			warnings.push(
+				`Auto-absorbed ${prefixCount} duplicate line(s) above replacement at ${tag}; replacement content repeated unchanged boundary lines immediately before the target.`,
+			);
+		}
+
+		if (edit.lines.length < 3) continue;
+		const suffixCount = countDuplicateSuffix(edit.lines, bounds.endLine, originalFileLines, protectedLines);
+		if (suffixCount >= 2) {
+			edit.lines = edit.lines.slice(0, -suffixCount);
+			const tag = formatLineTag(bounds.endLine + 1, originalFileLines[bounds.endLine]);
+			warnings.push(
+				`Auto-absorbed ${suffixCount} duplicate line(s) below replacement at ${tag}; replacement content repeated unchanged boundary lines immediately after the target.`,
+			);
+		}
+	}
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // Edit Application
 // ═══════════════════════════════════════════════════════════════════════════
@@ -539,6 +661,7 @@ export function applyHashlineEdits(
 	}
 	maybeAutocorrectEscapedTabIndentation(edits, warnings);
 	maybeWarnSuspiciousUnicodeEscapePlaceholder(edits, warnings);
+	absorbDuplicateReplacementBoundaries(edits, originalFileLines, warnings);
 
 	// Warn when a replace_range/replace_line's last inserted line duplicates the next surviving line.
 	// This catches the common boundary-overreach pattern where the agent includes a closing delimiter

packages/coding-agent/src/prompts/tools/gh-search-code.md

@@ -0,0 +1,12 @@
+Searches GitHub code through the local GitHub CLI.
+
+<instruction>
+- `query` supports normal GitHub code search syntax
+- Use `repo` to scope results to a single repository when relevant
+- Prefer small limits and refine the query instead of pulling large result sets
+- Use this for upstream curation, API discovery, and locating implementation examples across GitHub
+</instruction>
+
+<output>
+Returns a concise list of matching files with repository, commit SHA, URL, and the first matched fragment when available.
+</output>

packages/coding-agent/src/prompts/tools/gh-search-commits.md

@@ -0,0 +1,12 @@
+Searches GitHub commits through the local GitHub CLI.
+
+<instruction>
+- `query` supports normal GitHub commit search syntax
+- Use `repo` to scope results to a single repository when relevant
+- Prefer small limits and refine the query instead of pulling large result sets
+- Use this for upstream curation, release archaeology, and finding fixes by topic
+</instruction>
+
+<output>
+Returns a concise list of matching commits with repository, short SHA, subject, author, date, and URL.
+</output>