@kodrunhq/opencode-autopilot 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kodrunhq/opencode-autopilot",
-	"version": "1.6.0",
+	"version": "1.7.0",
 	"description": "Curated agents, skills, and commands for the OpenCode AI coding CLI — autonomous orchestrator, multi-agent code review, model fallback, and in-session asset creation tools.",
 	"main": "src/index.ts",
 	"keywords": [

package/src/orchestrator/arena.ts

@@ -1,3 +1,5 @@
+import type { Database } from "bun:sqlite";
+import { getObservationsByProject, getProjectByPath } from "../memory/repository";
 import { summarizeConfidence } from "./confidence";
 import type { ConfidenceEntry } from "./types";
 
@@ -39,3 +41,32 @@ export function shouldTriggerExplorer(
 	const thresholdOrder = LEVEL_ORDER[threshold];
 	return entries.some((entry) => LEVEL_ORDER[entry.level] < thresholdOrder);
 }
+
+/** Minimum error observations to trigger deeper review. */
+const ERROR_DEPTH_THRESHOLD = 3;
+
+/**
+ * Memory-tuned debate depth: adjusts arena depth based on project error history.
+ * Scans the 50 most-recent observations (recency window) — older errors are not counted.
+ * Projects with 3+ error observations in the window get deeper review (+1, capped at 3).
+ * Best-effort: memory errors never affect pipeline (falls back to standard depth).
+ */
+export function getMemoryTunedDepth(
+	entries: readonly ConfidenceEntry[],
+	projectPath: string,
+	db?: Database,
+): number {
+	const baseDepth = getDebateDepth(entries);
+	try {
+		const project = getProjectByPath(projectPath, db);
+		if (!project) return baseDepth;
+		const observations = getObservationsByProject(project.id, 50, db);
+		const errorCount = observations.filter((o) => o.type === "error").length;
+		if (errorCount >= ERROR_DEPTH_THRESHOLD) {
+			return Math.min(baseDepth + 1, 3);
+		}
+	} catch (err) {
+		console.warn("[opencode-autopilot] memory-tuned depth failed, using base:", err);
+	}
+	return baseDepth;
+}

package/src/orchestrator/handlers/architect.ts

@@ -2,7 +2,7 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { sanitizeTemplateContent } from "../../review/sanitize";
 import { fileExists } from "../../utils/fs-helpers";
-import { getDebateDepth } from "../arena";
+import { getMemoryTunedDepth } from "../arena";
 import { ensurePhaseDir, getArtifactRef, getPhaseDir } from "../artifacts";
 import { filterByPhase } from "../confidence";
 import type { PipelineState } from "../types";
@@ -62,7 +62,7 @@ export async function handleArchitect(
 	// Step 1: Dispatch architect(s) based on confidence depth
 	await ensurePhaseDir(artifactDir, "ARCHITECT");
 	const reconEntries = filterByPhase(state.confidence, "RECON");
-	const depth = getDebateDepth(reconEntries);
+	const depth = getMemoryTunedDepth(reconEntries, join(artifactDir, ".."));
 	const reconRef = getArtifactRef("RECON", "report.md");
 	const challengeRef = getArtifactRef("CHALLENGE", "brief.md");
 	const safeIdea = sanitizeTemplateContent(state.idea).replace(/[\r\n]+/g, " ");

package/src/orchestrator/skill-injection.ts

@@ -82,9 +82,9 @@ export async function loadAdaptiveSkillContext(
 
 		const matchingSkills = filterSkillsByStack(allSkills, projectTags);
 		return buildMultiSkillContext(matchingSkills, tokenBudget);
-	} catch (error: unknown) {
-		// Best-effort for I/O errors; re-throw programmer errors
-		if (error instanceof TypeError || error instanceof RangeError) throw error;
+	} catch {
+		// Best-effort: all errors return empty string. Caller (injectSkillContext)
+		// logs the error — no need to re-throw since the call site is also best-effort.
 		return "";
 	}
 }

package/src/tools/orchestrate.ts

@@ -5,7 +5,7 @@ import type { DispatchResult } from "../orchestrator/handlers/types";
 import { buildLessonContext } from "../orchestrator/lesson-injection";
 import { loadLessonMemory } from "../orchestrator/lesson-memory";
 import { completePhase, getNextPhase } from "../orchestrator/phase";
-import { buildSkillContext, loadSkillContent } from "../orchestrator/skill-injection";
+import { loadAdaptiveSkillContext } from "../orchestrator/skill-injection";
 import { createInitialState, loadState, patchState, saveState } from "../orchestrator/state";
 import type { Phase } from "../orchestrator/types";
 import { isEnoentError } from "../utils/fs-helpers";
@@ -96,17 +96,16 @@ async function injectLessonContext(
 }
 
 /**
- * Attempt to inject coding-standards skill context into a dispatch prompt.
+ * Attempt to inject stack-filtered adaptive skill context into a dispatch prompt.
  * Best-effort: failures are silently swallowed to avoid breaking dispatch.
  */
-async function injectSkillContext(prompt: string): Promise<string> {
+async function injectSkillContext(prompt: string, projectRoot?: string): Promise<string> {
 	try {
 		const baseDir = getGlobalConfigDir();
-		const content = await loadSkillContent(baseDir);
-		const ctx = buildSkillContext(content);
+		const ctx = await loadAdaptiveSkillContext(baseDir, projectRoot ?? process.cwd());
 		if (ctx) return prompt + ctx;
-	} catch {
-		// Best-effort: swallow all errors (same as lesson injection)
+	} catch (err) {
+		console.warn("[opencode-autopilot] skill injection failed:", err);
 	}
 	return prompt;
 }
@@ -146,7 +145,7 @@ async function processHandlerResult(
 					handlerResult.phase,
 					artifactDir,
 				);
-				const withSkills = await injectSkillContext(enrichedPrompt);
+				const withSkills = await injectSkillContext(enrichedPrompt, join(artifactDir, ".."));
 				if (withSkills !== handlerResult.prompt) {
 					return JSON.stringify({ ...handlerResult, prompt: withSkills });
 				}
@@ -163,7 +162,7 @@ async function processHandlerResult(
 					handlerResult.phase as string,
 					artifactDir,
 				);
-				const skillSuffix = await injectSkillContext("");
+				const skillSuffix = await injectSkillContext("", join(artifactDir, ".."));
 				const combinedSuffix = lessonSuffix + (skillSuffix || "");
 				if (combinedSuffix) {
 					const enrichedAgents = handlerResult.agents.map((entry) => ({