opencodekit 0.18.3 → 0.18.5

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from "node:module";
 import { cac } from "cac";
 import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import * as p from "@clack/prompts";
 import color from "picocolors";
 import { z } from "zod";
@@ -18,7 +18,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.18.3";
+var version = "0.18.5";
 
 //#endregion
 //#region src/utils/errors.ts
@@ -153,6 +153,15 @@ const ToolActionSchema = z.enum([
 	"delete"
 ]);
 const ToolOptionsSchema = z.object({ json: z.boolean().optional().default(false) });
+const PatchActionSchema = z.enum([
+	"list",
+	"create",
+	"apply",
+	"diff",
+	"remove",
+	"disable",
+	"enable"
+]);
 const CompletionShellSchema = z.enum([
 	"bash",
 	"zsh",
@@ -2515,6 +2524,22 @@ function getPatchesDir(opencodeDir) {
 	return join(opencodeDir, PATCHES_DIR);
 }
 /**
+* Get the template root directory (from dist/template or dev mode).
+*/
+function getTemplateRoot$2() {
+	const __dirname = dirname(fileURLToPath(import.meta.url));
+	const possiblePaths = [
+		join(__dirname, "template"),
+		join(__dirname, "..", "..", ".opencode"),
+		join(__dirname, "..", "template")
+	];
+	for (const path of possiblePaths) {
+		if (existsSync(join(path, ".opencode"))) return path;
+		if (existsSync(join(path, "opencode.json"))) return dirname(path);
+	}
+	return null;
+}
+/**
 * Load patch metadata from .patches.json.
 */
 function loadPatchMetadata(opencodeDir) {
@@ -2581,6 +2606,22 @@ function savePatch(opencodeDir, relativePath, templateContent, userContent) {
 	return entry;
 }
 /**
+* Remove a patch for a file.
+*/
+function removePatch(opencodeDir, relativePath) {
+	const metadata = loadPatchMetadata(opencodeDir);
+	const entry = metadata.patches[relativePath];
+	if (!entry) return false;
+	const patchPath = join(getPatchesDir(opencodeDir), entry.patchFile);
+	if (existsSync(patchPath)) {
+		const { rmSync } = __require("node:fs");
+		rmSync(patchPath);
+	}
+	delete metadata.patches[relativePath];
+	savePatchMetadata(opencodeDir, metadata);
+	return true;
+}
+/**
 * Apply a patch to file content.
 * @returns The patched content, or null if patch failed.
 */
@@ -2595,6 +2636,14 @@ function applyAllPatches(opencodeDir) {
 	const patchesDir = getPatchesDir(opencodeDir);
 	const results = [];
 	for (const [relativePath, entry] of Object.entries(metadata.patches)) {
+		if (entry.disabled) {
+			results.push({
+				success: true,
+				file: relativePath,
+				message: "Skipped (disabled)"
+			});
+			continue;
+		}
 		const filePath = join(opencodeDir, relativePath);
 		const patchPath = join(patchesDir, entry.patchFile);
 		if (!existsSync(filePath)) {
@@ -2637,6 +2686,59 @@ function applyAllPatches(opencodeDir) {
 	}
 	return results;
 }
+/**
+* Check the status of all patches.
+*/
+function checkPatchStatus(opencodeDir, templateRoot) {
+	const metadata = loadPatchMetadata(opencodeDir);
+	const statuses = [];
+	for (const [relativePath, entry] of Object.entries(metadata.patches)) {
+		if (!existsSync(join(opencodeDir, relativePath))) {
+			statuses.push({
+				relativePath,
+				entry,
+				status: "missing",
+				message: "User file no longer exists"
+			});
+			continue;
+		}
+		if (templateRoot) {
+			const templateFilePath = join(templateRoot, ".opencode", relativePath);
+			if (existsSync(templateFilePath)) {
+				const templateContent = readFileSync(templateFilePath, "utf-8");
+				if (calculateHash(templateContent) !== entry.originalHash) {
+					const patchPath = join(getPatchesDir(opencodeDir), entry.patchFile);
+					if (existsSync(patchPath)) if (applyPatch$1(templateContent, readFileSync(patchPath, "utf-8")) === false) statuses.push({
+						relativePath,
+						entry,
+						status: "conflict",
+						message: "Template changed and patch cannot apply cleanly"
+					});
+					else statuses.push({
+						relativePath,
+						entry,
+						status: "stale",
+						message: "Template changed but patch can still apply"
+					});
+					else statuses.push({
+						relativePath,
+						entry,
+						status: "missing",
+						message: "Patch file missing"
+					});
+					continue;
+				}
+			}
+		}
+		statuses.push({
+			relativePath,
+			entry,
+			status: "clean",
+			message: "Patch is up to date"
+		});
+	}
+	return statuses;
+}
 
 //#endregion
 //#region src/commands/init.ts
@@ -2721,15 +2823,15 @@ const MODEL_PRESETS = {
 		}
 	},
 	recommend: {
-		model: "opencode/minimax-m2.5-free",
+		model: "github-copilot/gpt-5.4",
 		agents: {
 			build: "github-copilot/claude-opus-4.6",
-			plan: "openai/gpt-5.3-codex",
-			review: "openai/gpt-5.3-codex",
-			explore: "opencode/minimax-m2.5-free",
-			general: "github-copilot/claude-sonnet-4.6",
-			vision: "proxypal/gemini-3.1-pro-high",
-			scout: "proxypal/claude-sonnet-4-6",
+			plan: "github-copilot/gpt-5.4",
+			review: "github-copilot/claude-opus-4.6",
+			explore: "github-copilot/claude-haiku-4.5",
+			general: "github-copilot/gpt-5.3-codex",
+			vision: "github-copilot/gemini-3.1-pro-preview",
+			scout: "github-copilot/claude-sonnet-4.6",
 			painter: "proxypal/gemini-3.1-flash-image"
 		}
 	}
@@ -2751,7 +2853,7 @@ const AGENT_DESCRIPTIONS = {
 	review: "Code review and debugging",
 	explore: "Fast codebase search",
 	general: "Quick, simple tasks",
-	looker: "Image/PDF extraction (cheap)",
+	painter: "Image generation and editing",
 	vision: "Visual analysis (quality)",
 	scout: "External research/docs",
 	compaction: "Context summarization"
@@ -2760,11 +2862,11 @@ async function promptCustomModels(targetDir) {
 	const configPath = join(targetDir, ".opencode", "opencode.json");
 	if (!existsSync(configPath)) return;
 	const config = JSON.parse(readFileSync(configPath, "utf-8"));
-	p.log.info(color.dim("Enter model IDs (e.g., opencode/grok-code, proxypal/gemini-3-pro-preview)"));
+	p.log.info(color.dim("Enter model IDs (e.g., github-copilot/gpt-5.4, proxypal/gemini-3.1-flash-image)"));
 	p.log.info(color.dim("Press Enter to keep current value\n"));
 	const mainModel = await p.text({
 		message: "Main session model",
-		placeholder: config.model || "opencode/minimax-m2.1-free",
+		placeholder: config.model || "github-copilot/gpt-5.4",
 		defaultValue: config.model
 	});
 	if (p.isCancel(mainModel)) {
@@ -3033,7 +3135,7 @@ async function initCommand(rawOptions = {}) {
 				{
 					value: "recommend",
 					label: "Recommended models",
-					hint: "claude-opus, gemini-pro (best quality)"
+					hint: "gpt-5.4, opus-4.6, sonnet-4.6, gemini-3.1"
 				},
 				{
 					value: "custom",
@@ -3498,7 +3600,7 @@ function copyDirWithPreserve(src, dest, preserveFiles, preserveDirs, manifest, b
 		const destPath = join(dest, entry.name);
 		if (entry.isDirectory()) if (preserveDirs.includes(entry.name)) {
 			if (!existsSync(destPath)) mkdirSync(destPath, { recursive: true });
-			const subResult = copyDirPreserveExisting(srcPath, destPath, manifest, entry.name);
+			const subResult = copyDirPreserveExisting(srcPath, destPath, manifest, dest, entry.name);
 			added.push(...subResult.added);
 			updated.push(...subResult.updated);
 			preserved.push(...subResult.preserved);
@@ -3524,7 +3626,7 @@ function copyDirWithPreserve(src, dest, preserveFiles, preserveDirs, manifest, b
 		preserved
 	};
 }
-function copyDirPreserveExisting(src, dest, manifest, basePath = "") {
+function copyDirPreserveExisting(src, dest, manifest, opencodeDir, basePath = "") {
 	const added = [];
 	const updated = [];
 	const preserved = [];
@@ -3534,7 +3636,7 @@ function copyDirPreserveExisting(src, dest, manifest, basePath = "") {
 		const destPath = join(dest, entry.name);
 		if (entry.isDirectory()) {
 			if (!existsSync(destPath)) mkdirSync(destPath, { recursive: true });
-			const subResult = copyDirPreserveExisting(srcPath, destPath, manifest, join(basePath, entry.name));
+			const subResult = copyDirPreserveExisting(srcPath, destPath, manifest, opencodeDir, join(basePath, entry.name));
 			added.push(...subResult.added);
 			updated.push(...subResult.updated);
 			preserved.push(...subResult.preserved);
@@ -3546,6 +3648,9 @@ function copyDirPreserveExisting(src, dest, manifest, basePath = "") {
 			} else if (fileModificationStatus(destPath, relativePath, manifest) === "unmodified") {
 				copyFileSync(srcPath, destPath);
 				updated.push(relativePath);
+			} else if (loadPatchMetadata(opencodeDir).patches[relativePath]) {
+				copyFileSync(srcPath, destPath);
+				updated.push(relativePath);
 			} else preserved.push(relativePath);
 		}
 	}
@@ -3646,7 +3751,10 @@ async function upgradeCommand(rawOptions = {}) {
 	}
 	if (result.updated.length > 0) p.log.success(`Updated ${result.updated.length} files`);
 	if (result.added.length > 0) p.log.success(`Added ${result.added.length} files`);
-	if (result.preserved.length > 0) p.log.info(`Preserved ${result.preserved.length} user files`);
+	if (result.preserved.length > 0) {
+		p.log.info(`Preserved ${result.preserved.length} user files`);
+		p.log.info(color.dim("  Tip: Run 'ock patch create <file>' to save customizations as reapplyable patches"));
+	}
 	if (patchResults.success > 0) p.log.success(`Reapplied ${patchResults.success} patches`);
 	const orphans = findUpgradeOrphans(getAllFiles(opencodeDir), getAllFiles(templateOpencode));
 	if (orphans.length > 0) {
@@ -4053,6 +4161,285 @@ async function statusCommand() {
 	p.outro(color.dim(".opencode/"));
 }
 
+//#endregion
+//#region src/commands/patch.ts
+function getOpencodeDir() {
+	const opencodeDir = join(resolve("."), ".opencode");
+	if (!existsSync(opencodeDir)) {
+		notInitialized();
+		return null;
+	}
+	return opencodeDir;
+}
+function listPatches(opencodeDir) {
+	const metadata = loadPatchMetadata(opencodeDir);
+	const entries = Object.entries(metadata.patches);
+	if (entries.length === 0) {
+		showEmpty("patches", "ock patch create <file>");
+		return;
+	}
+	const statuses = checkPatchStatus(opencodeDir, getTemplateRoot$2());
+	const statusMap = new Map(statuses.map((s) => [s.relativePath, s]));
+	p.intro(color.bgCyan(color.black(` ${entries.length} patch${entries.length === 1 ? "" : "es"} `)));
+	for (const [relativePath, entry] of entries) {
+		const ps = statusMap.get(relativePath);
+		const statusLabel = ps ? formatStatus(ps.status) : color.dim("unknown");
+		const disabledLabel = entry.disabled ? color.yellow(" [disabled]") : "";
+		const descLabel = entry.description ? color.dim(` — ${entry.description}`) : "";
+		p.log.info(`${color.cyan(relativePath)}${disabledLabel}${descLabel}\n  Status: ${statusLabel}  Created: ${color.dim(entry.createdAt.slice(0, 10))}  Version: ${color.dim(entry.templateVersion)}`);
+	}
+	p.outro(color.dim("Use 'ock patch diff <file>' to view changes"));
+}
+function formatStatus(status) {
+	switch (status) {
+		case "clean": return color.green("clean");
+		case "stale": return color.yellow("stale");
+		case "conflict": return color.red("conflict");
+		case "missing": return color.red("missing");
+		default: return color.dim(status);
+	}
+}
+async function createPatch$1(opencodeDir) {
+	const fileArg = process.argv[4];
+	if (!fileArg) {
+		p.log.error("Usage: ock patch create <file>");
+		p.log.info(color.dim("File path is relative to .opencode/ (e.g., skill/beads/SKILL.md)"));
+		return;
+	}
+	const relativePath = fileArg;
+	const userFilePath = join(opencodeDir, relativePath);
+	if (!existsSync(userFilePath)) {
+		notFound("file", relativePath);
+		return;
+	}
+	const templateRoot = getTemplateRoot$2();
+	if (!templateRoot) {
+		p.log.error("Cannot find template root — unable to compute diff");
+		p.log.info(color.dim("Make sure ock is installed correctly"));
+		return;
+	}
+	const templateFilePath = join(templateRoot, ".opencode", relativePath);
+	if (!existsSync(templateFilePath)) {
+		p.log.error(`No template file for ${color.cyan(relativePath)}`);
+		p.log.info(color.dim("Only template-originated files can be patched"));
+		return;
+	}
+	const templateContent = readFileSync(templateFilePath, "utf-8");
+	const userContent = readFileSync(userFilePath, "utf-8");
+	if (calculateHash(templateContent) === calculateHash(userContent)) {
+		p.log.warn(`${color.cyan(relativePath)} is identical to template — nothing to patch`);
+		return;
+	}
+	if (loadPatchMetadata(opencodeDir).patches[relativePath]) {
+		const overwrite = await p.confirm({
+			message: `Patch already exists for ${color.cyan(relativePath)}. Overwrite?`,
+			initialValue: false
+		});
+		if (p.isCancel(overwrite) || !overwrite) {
+			p.cancel("Cancelled");
+			return;
+		}
+	}
+	const description = await p.text({
+		message: "Description (optional)",
+		placeholder: "e.g., Custom agent prompt for our team"
+	});
+	if (p.isCancel(description)) {
+		p.cancel("Cancelled");
+		return;
+	}
+	const entry = savePatch(opencodeDir, relativePath, templateContent, userContent);
+	if (description && typeof description === "string" && description.trim()) {
+		entry.description = description.trim();
+		const updatedMetadata = loadPatchMetadata(opencodeDir);
+		updatedMetadata.patches[relativePath] = entry;
+		savePatchMetadata(opencodeDir, updatedMetadata);
+	}
+	p.log.success(`Created patch for ${color.cyan(relativePath)}`);
+	p.log.info(color.dim(`Patch file: ${entry.patchFile}`));
+}
+function applyPatches(opencodeDir) {
+	const fileArg = process.argv[4];
+	const metadata = loadPatchMetadata(opencodeDir);
+	if (Object.entries(metadata.patches).length === 0) {
+		showEmpty("patches", "ock patch create <file>");
+		return;
+	}
+	if (fileArg) {
+		const entry = metadata.patches[fileArg];
+		if (!entry) {
+			notFound("patch", fileArg);
+			return;
+		}
+		if (entry.disabled) {
+			p.log.warn(`Patch for ${color.cyan(fileArg)} is disabled — enable it first`);
+			return;
+		}
+		applySinglePatch(opencodeDir, fileArg, entry);
+		return;
+	}
+	const results = applyAllPatches(opencodeDir);
+	const success = results.filter((r) => r.success && r.message !== "Skipped (disabled)").length;
+	const skipped = results.filter((r) => r.message === "Skipped (disabled)").length;
+	const conflicts = results.filter((r) => r.conflict).length;
+	if (success > 0) p.log.success(`Applied ${success} patch${success === 1 ? "" : "es"}`);
+	if (skipped > 0) p.log.info(color.dim(`Skipped ${skipped} disabled patch${skipped === 1 ? "" : "es"}`));
+	if (conflicts > 0) p.log.warn(`${conflicts} conflict${conflicts === 1 ? "" : "s"} — see .rej files in ${color.cyan(".opencode/patches/")}`);
+	if (success === 0 && conflicts === 0 && skipped === 0) p.log.info("No patches to apply");
+}
+function applySinglePatch(opencodeDir, relativePath, entry) {
+	const filePath = join(opencodeDir, relativePath);
+	const patchPath = join(getPatchesDir(opencodeDir), entry.patchFile);
+	if (!existsSync(filePath)) {
+		p.log.error(`Target file missing: ${color.cyan(relativePath)}`);
+		return;
+	}
+	if (!existsSync(patchPath)) {
+		p.log.error(`Patch file missing: ${color.cyan(entry.patchFile)}`);
+		return;
+	}
+	const result = applyPatch$1(readFileSync(filePath, "utf-8"), readFileSync(patchPath, "utf-8"));
+	if (result === false) {
+		p.log.error(`Conflict applying patch to ${color.cyan(relativePath)}`);
+		p.log.info(color.dim("Template may have changed — try 'ock patch create' to recreate"));
+		return;
+	}
+	writeFileSync(filePath, result, "utf-8");
+	p.log.success(`Applied patch to ${color.cyan(relativePath)}`);
+}
+function showDiff(opencodeDir) {
+	const fileArg = process.argv[4];
+	if (!fileArg) {
+		const metadata = loadPatchMetadata(opencodeDir);
+		const entries = Object.entries(metadata.patches);
+		if (entries.length === 0) {
+			showEmpty("patches", "ock patch create <file>");
+			return;
+		}
+		for (const [relativePath, entry] of entries) showSingleDiff(opencodeDir, relativePath, entry);
+		return;
+	}
+	const entry = loadPatchMetadata(opencodeDir).patches[fileArg];
+	if (!entry) {
+		notFound("patch", fileArg);
+		return;
+	}
+	showSingleDiff(opencodeDir, fileArg, entry);
+}
+function showSingleDiff(opencodeDir, relativePath, entry) {
+	const patchPath = join(getPatchesDir(opencodeDir), entry.patchFile);
+	if (!existsSync(patchPath)) {
+		p.log.error(`Patch file missing: ${color.cyan(entry.patchFile)}`);
+		return;
+	}
+	const patchContent = readFileSync(patchPath, "utf-8");
+	const disabledLabel = entry.disabled ? color.yellow(" [disabled]") : "";
+	console.log(`\n${color.bold(color.cyan(relativePath))}${disabledLabel}`);
+	if (entry.description) console.log(color.dim(`  ${entry.description}`));
+	console.log(color.dim("─".repeat(60)));
+	for (const line of patchContent.split("\n")) if (line.startsWith("+++") || line.startsWith("---")) console.log(color.bold(line));
+	else if (line.startsWith("+")) console.log(color.green(line));
+	else if (line.startsWith("-")) console.log(color.red(line));
+	else if (line.startsWith("@@")) console.log(color.cyan(line));
+	else console.log(color.dim(line));
+	console.log();
+}
+async function removePatchCmd(opencodeDir) {
+	const fileArg = process.argv[4];
+	if (!fileArg) {
+		p.log.error("Usage: ock patch remove <file>");
+		p.log.info(color.dim("Use 'ock patch list' to see available patches"));
+		return;
+	}
+	if (!loadPatchMetadata(opencodeDir).patches[fileArg]) {
+		notFound("patch", fileArg);
+		return;
+	}
+	const confirm = await p.confirm({
+		message: `Remove patch for ${color.cyan(fileArg)}?`,
+		initialValue: false
+	});
+	if (p.isCancel(confirm) || !confirm) {
+		p.cancel("Cancelled");
+		return;
+	}
+	if (removePatch(opencodeDir, fileArg)) p.log.success(`Removed patch for ${color.cyan(fileArg)}`);
+	else p.log.error(`Failed to remove patch for ${color.cyan(fileArg)}`);
+}
+function togglePatch(opencodeDir, disable) {
+	const fileArg = process.argv[4];
+	if (!fileArg) {
+		p.log.error(`Usage: ock patch ${disable ? "disable" : "enable"} <file>`);
+		p.log.info(color.dim("Use 'ock patch list' to see available patches"));
+		return;
+	}
+	const metadata = loadPatchMetadata(opencodeDir);
+	const entry = metadata.patches[fileArg];
+	if (!entry) {
+		notFound("patch", fileArg);
+		return;
+	}
+	if (disable && entry.disabled) {
+		p.log.warn(`Patch for ${color.cyan(fileArg)} is already disabled`);
+		return;
+	}
+	if (!disable && !entry.disabled) {
+		p.log.warn(`Patch for ${color.cyan(fileArg)} is already enabled`);
+		return;
+	}
+	entry.disabled = disable || void 0;
+	metadata.patches[fileArg] = entry;
+	savePatchMetadata(opencodeDir, metadata);
+	if (disable) {
+		p.log.success(`Disabled patch for ${color.cyan(fileArg)}`);
+		p.log.info(color.dim("This patch will be skipped during upgrades"));
+	} else {
+		p.log.success(`Enabled patch for ${color.cyan(fileArg)}`);
+		p.log.info(color.dim("This patch will be applied during upgrades"));
+	}
+}
+async function patchCommand(action) {
+	const opencodeDir = getOpencodeDir();
+	if (!opencodeDir) return;
+	const validatedAction = parseAction(PatchActionSchema, action);
+	if (!validatedAction) {
+		listPatches(opencodeDir);
+		return;
+	}
+	switch (validatedAction) {
+		case "list":
+			listPatches(opencodeDir);
+			break;
+		case "create":
+			await createPatch$1(opencodeDir);
+			break;
+		case "apply":
+			applyPatches(opencodeDir);
+			break;
+		case "diff":
+			showDiff(opencodeDir);
+			break;
+		case "remove":
+			await removePatchCmd(opencodeDir);
+			break;
+		case "disable":
+			togglePatch(opencodeDir, true);
+			break;
+		case "enable":
+			togglePatch(opencodeDir, false);
+			break;
+		default: unknownAction(action ?? "", [
+			"list",
+			"create",
+			"apply",
+			"diff",
+			"remove",
+			"disable",
+			"enable"
+		]);
+	}
+}
+
 //#endregion
 //#region src/tui/utils/keyboard.ts
 /**
@@ -5218,6 +5605,9 @@ cli.command("config [action]", "Edit opencode.json (model, mcp, permission, vali
 cli.command("upgrade", "Update .opencode/ templates to latest version").option("--force", "Force upgrade even if already up to date").option("--check", "Check for updates without upgrading").option("--prune", "Manually select orphan files to delete").option("--prune-all", "Auto-delete all orphan files").action(async (options) => {
 	await upgradeCommand(options);
 });
+cli.command("patch [action]", "Manage template patches (list, create, apply, diff, remove, disable, enable)").action(async (action) => {
+	await patchCommand(action);
+});
 cli.command("completion [shell]", "Generate shell completion script (bash, zsh, fish)").action(async (shell) => {
 	await completionCommand(shell);
 });

package/dist/template/.opencode/.version

@@ -1 +1 @@
-0.18.3
+0.18.4

package/dist/template/.opencode/AGENTS.md

@@ -220,7 +220,7 @@ For major tracked work:
 
 ## Edit Protocol
 
-`str_replace` failures are the #1 source of LLM coding failures. Use structured edits:
+`str_replace` failures are the #1 source of LLM coding failures. When tilth MCP is available with `--edit`, prefer hash-anchored edits (see below). Otherwise, use structured edits:
 
 1. **LOCATE** — Use LSP tools (goToDefinition, findReferences) to find exact positions
 2. **READ** — Get fresh file content around target (offset: line-10, limit: 30)
@@ -241,6 +241,18 @@ Files over ~500 lines become hard to maintain and review. Extract helpers, split
 
 **Use the `structured-edit` skill for complex edits.**
 
+### Hash-Anchored Edits (MCP)
+
+When tilth MCP is available with `--edit` mode, use hash-anchored edits for higher reliability:
+
+1. **READ** via `tilth_read` — output includes `line:hash|content` format per line
+2. **EDIT** via `tilth_edit` — reference lines by their `line:hash` anchor
+3. **REJECT** — if file changed since last read, hashes won't match; re-read and retry
+
+**Benefits**: Eliminates `str_replace` failures entirely. If the file changed between read and edit, the operation fails safely (no silent corruption).
+
+**Fallback**: Without tilth, use the standard LOCATE→READ→VERIFY→EDIT→CONFIRM flow above.
+
 ---
 
 ## Output Style

package/dist/template/.opencode/agent/build.md

@@ -79,7 +79,9 @@ Implement requested work, verify with fresh evidence, and coordinate subagents o
 
 - No success claims without fresh verification output
 - Verification failures are **signals, not condemnations** — adjust and proceed
-- Re-run typecheck/lint/tests after meaningful edits
+- Re-run typecheck/lint/tests after meaningful edits (use incremental mode — changed files only)
+- Run typecheck + lint in parallel, then tests sequentially
+- Check `.beads/verify.log` cache before re-running — skip if no changes since last PASS
 - If verification fails twice on the same approach, **escalate with learnings**, not frustration
 
 ## Ritual Structure
@@ -170,6 +172,7 @@ Load contextually when needed:
 | UI work                | `frontend-design`, `react-best-practices`                  |
 | Parallel orchestration | `swarm-coordination`, `beads-bridge`                       |
 | Before completion      | `requesting-code-review`, `finishing-a-development-branch` |
+| Codebase exploration   | `code-navigation`                                          |
 
 ## Execution Mode
 

package/dist/template/.opencode/agent/explore.md

@@ -29,43 +29,13 @@ You are a read-only codebase explorer. You output concise, evidence-backed findi
 
 Find relevant files, symbols, and usage paths quickly for the caller.
 
-## Rules
-
-- Never modify files — read-only is a hard constraint
-- Return absolute paths in final output
-- Cite `file:line` evidence whenever possible
-- Prefer semantic lookup (LSP) before broad text search when it improves precision
-- Stop when you can answer with concrete evidence or when additional search only repeats confirmed paths
-
-## Workflow
+## Skills
 
-1. Discover candidate files with `glob` or `workspaceSymbol`
-2. Validate symbol flow with LSP (`goToDefinition`, `findReferences`)
-3. Use `grep` for targeted pattern checks
-4. Read only relevant sections
-5. Return findings + next steps
+Always load:
 
-## Thoroughness Levels
-
-| Level           | Scope                         | Use When                                   |
-| --------------- | ----------------------------- | ------------------------------------------ |
-| `quick`         | 1-3 files, direct answer      | Simple lookups, known symbol names         |
-| `medium`        | 3-6 files, include call paths | Understanding feature flow                 |
-| `very thorough` | Dependency map + edge cases   | Complex refactor prep, architecture review |
-
-## Output
-
-- **Files**: absolute paths with line refs
-- **Findings**: concise, evidence-backed
-- **Next Steps** (optional): recommended actions for the caller
-
-## Identity
-
-You are a read-only codebase explorer. You output concise, evidence-backed findings with absolute paths only.
-
-## Task
-
-Find relevant files, symbols, and usage paths quickly for the caller.
+```typescript
+skill({ name: "code-navigation" });
+```
 
 ## Rules