@kodrunhq/opencode-autopilot 1.11.0 → 1.12.1

package/assets/commands/oc-brainstorm.md

@@ -4,4 +4,6 @@ description: Start a brainstorming session with Socratic design refinement
 
 Use the brainstorming skill to explore the topic through Socratic questioning. Ask clarifying questions, explore alternatives, generate at least 3 distinct approaches, and present a structured design recommendation.
 
+Detect the project language from manifest files (package.json, tsconfig.json, go.mod, Cargo.toml, pom.xml, *.csproj, pyproject.toml) and tailor code examples, library suggestions, and architectural patterns to that language ecosystem.
+
 $ARGUMENTS

package/assets/commands/oc-review-pr.md

@@ -14,6 +14,8 @@ First, gather the PR context:
 
 Then analyze the PR against these dimensions:
 
+Detect the project language from manifest files (package.json, tsconfig.json, go.mod, Cargo.toml, pom.xml, *.csproj, pyproject.toml) and apply language-specific idioms, framework conventions, and ecosystem best practices when reviewing.
+
 - **Correctness:** Does the code do what the PR description claims? Are there logic errors, off-by-one bugs, or missing edge cases?
 - **Security:** Are there hardcoded secrets, unsanitized inputs, missing auth checks, or injection vulnerabilities?
 - **Code quality:** Does the code follow the coding-standards skill? Check naming, file size, function size, error handling, immutability, and separation of concerns.

package/assets/commands/oc-tdd.md

@@ -4,4 +4,6 @@ description: Implement a feature using strict RED-GREEN-REFACTOR TDD methodology
 
 Use the tdd-workflow skill to implement the feature following strict RED-GREEN-REFACTOR. Write the failing test first (RED), implement minimally to pass (GREEN), then clean up (REFACTOR).
 
+Detect the project language from manifest files (package.json, tsconfig.json, go.mod, Cargo.toml, pom.xml, *.csproj, pyproject.toml) and adapt test framework recommendations, assertion styles, and code examples to that language.
+
 $ARGUMENTS

package/assets/commands/oc-write-plan.md

@@ -4,4 +4,6 @@ description: Decompose a feature into a structured implementation plan with task
 
 Use the plan-writing skill to decompose the feature into bite-sized tasks with exact file paths, dependency waves, and verification criteria for each task.
 
+Detect the project language from manifest files (package.json, tsconfig.json, go.mod, Cargo.toml, pom.xml, *.csproj, pyproject.toml) and reference language-specific tooling, test frameworks, and build commands in the plan.
+
 $ARGUMENTS

package/bin/cli.ts

@@ -308,7 +308,7 @@ export async function runDoctor(options: CliOptions = {}): Promise<void> {
 
 function printUsage(): void {
 	console.log("");
-	console.log(bold("Usage:") + " opencode-autopilot <command>");
+	console.log(`${bold("Usage:")} opencode-autopilot <command>`);
 	console.log("");
 	console.log("Commands:");
 	console.log("  install     Register the plugin and create starter config");

package/bin/configure-tui.ts

@@ -307,7 +307,7 @@ export async function runConfigure(configPath: string = CONFIG_PATH): Promise<vo
 
 	const newConfig = {
 		...baseConfig,
-		version: 5 as const,
+		version: 6 as const,
 		configured: true,
 		groups: groupsRecord,
 		overrides: baseConfig.overrides ?? {},

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kodrunhq/opencode-autopilot",
-	"version": "1.11.0",
+	"version": "1.12.1",
 	"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/agents/index.ts

@@ -42,11 +42,13 @@ function registerAgents(
 	groups: Readonly<Record<string, GroupModelAssignment>>,
 	overrides: Readonly<Record<string, AgentOverride>>,
 ): void {
+	const agentRef = config.agent;
+	if (!agentRef) return;
 	for (const [name, agentConfig] of Object.entries(agentMap)) {
-		if (config.agent![name] === undefined) {
+		if (agentRef[name] === undefined) {
 			// Deep-copy agent config including nested permission to avoid shared references.
 			const resolved = resolveModelForAgent(name, groups, overrides);
-			config.agent![name] = {
+			agentRef[name] = {
 				...agentConfig,
 				...(agentConfig.permission && { permission: { ...agentConfig.permission } }),
 				...(resolved && { model: resolved.primary }),

package/src/config.ts

@@ -2,7 +2,13 @@ import { randomBytes } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { z } from "zod";
-import { fallbackConfigSchema, fallbackDefaults } from "./orchestrator/fallback/fallback-config";
+import {
+	fallbackConfigSchema,
+	fallbackConfigSchemaV6,
+	fallbackDefaults,
+	fallbackDefaultsV6,
+	testModeDefaults,
+} from "./orchestrator/fallback/fallback-config";
 import { AGENT_REGISTRY, ALL_GROUP_IDS } from "./registry/model-groups";
 import { ensureDir, isEnoentError } from "./utils/fs-helpers";
 import { getGlobalConfigDir } from "./utils/paths";
@@ -149,10 +155,37 @@ const pluginConfigSchemaV5 = z
 		}
 	});
 
-// Export aliases updated to v5
-export const pluginConfigSchema = pluginConfigSchemaV5;
+type PluginConfigV5 = z.infer<typeof pluginConfigSchemaV5>;
 
-export type PluginConfig = z.infer<typeof pluginConfigSchemaV5>;
+// --- V6 schema ---
+
+const pluginConfigSchemaV6 = z
+	.object({
+		version: z.literal(6),
+		configured: z.boolean(),
+		groups: z.record(z.string(), groupModelAssignmentSchema).default({}),
+		overrides: z.record(z.string(), agentOverrideSchema).default({}),
+		orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+		confidence: confidenceConfigSchema.default(confidenceDefaults),
+		fallback: fallbackConfigSchemaV6.default(fallbackDefaultsV6),
+		memory: memoryConfigSchema.default(memoryDefaults),
+	})
+	.superRefine((config, ctx) => {
+		for (const groupId of Object.keys(config.groups)) {
+			if (!ALL_GROUP_IDS.includes(groupId as (typeof ALL_GROUP_IDS)[number])) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					path: ["groups", groupId],
+					message: `Unknown group id "${groupId}". Expected one of: ${ALL_GROUP_IDS.join(", ")}`,
+				});
+			}
+		}
+	});
+
+// Export aliases updated to v6
+export const pluginConfigSchema = pluginConfigSchemaV6;
+
+export type PluginConfig = z.infer<typeof pluginConfigSchemaV6>;
 
 export const CONFIG_PATH = join(getGlobalConfigDir(), "opencode-autopilot.json");
 
@@ -228,7 +261,7 @@ function migrateV3toV4(v3Config: PluginConfigV3): PluginConfigV4 {
 	};
 }
 
-function migrateV4toV5(v4Config: PluginConfigV4): PluginConfig {
+function migrateV4toV5(v4Config: PluginConfigV4): PluginConfigV5 {
 	return {
 		version: 5 as const,
 		configured: v4Config.configured,
@@ -241,6 +274,19 @@ function migrateV4toV5(v4Config: PluginConfigV4): PluginConfig {
 	};
 }
 
+function migrateV5toV6(v5Config: PluginConfigV5): PluginConfig {
+	return {
+		version: 6 as const,
+		configured: v5Config.configured,
+		groups: v5Config.groups,
+		overrides: v5Config.overrides,
+		orchestrator: v5Config.orchestrator,
+		confidence: v5Config.confidence,
+		fallback: { ...v5Config.fallback, testMode: testModeDefaults },
+		memory: v5Config.memory,
+	};
+}
+
 // --- Public API ---
 
 export async function loadConfig(configPath: string = CONFIG_PATH): Promise<PluginConfig | null> {
@@ -248,49 +294,61 @@ export async function loadConfig(configPath: string = CONFIG_PATH): Promise<Plug
 		const raw = await readFile(configPath, "utf-8");
 		const parsed = JSON.parse(raw);
 
-		// Try v5 first
+		// Try v6 first
+		const v6Result = pluginConfigSchemaV6.safeParse(parsed);
+		if (v6Result.success) return v6Result.data;
+
+		// Try v5 and migrate to v6
 		const v5Result = pluginConfigSchemaV5.safeParse(parsed);
-		if (v5Result.success) return v5Result.data;
+		if (v5Result.success) {
+			const migrated = migrateV5toV6(v5Result.data);
+			await saveConfig(migrated, configPath);
+			return migrated;
+		}
 
-		// Try v4 and migrate to v5
+		// Try v4 → v5 → v6
 		const v4Result = pluginConfigSchemaV4.safeParse(parsed);
 		if (v4Result.success) {
-			const migrated = migrateV4toV5(v4Result.data);
+			const v5 = migrateV4toV5(v4Result.data);
+			const migrated = migrateV5toV6(v5);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// Try v3 → v4 → v5
+		// Try v3 → v4 → v5 → v6
 		const v3Result = pluginConfigSchemaV3.safeParse(parsed);
 		if (v3Result.success) {
 			const v4 = migrateV3toV4(v3Result.data);
-			const migrated = migrateV4toV5(v4);
+			const v5 = migrateV4toV5(v4);
+			const migrated = migrateV5toV6(v5);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// Try v2 → v3 → v4 → v5
+		// Try v2 → v3 → v4 → v5 → v6
 		const v2Result = pluginConfigSchemaV2.safeParse(parsed);
 		if (v2Result.success) {
 			const v3 = migrateV2toV3(v2Result.data);
 			const v4 = migrateV3toV4(v3);
-			const migrated = migrateV4toV5(v4);
+			const v5 = migrateV4toV5(v4);
+			const migrated = migrateV5toV6(v5);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		// Try v1 → v2 → v3 → v4 → v5
+		// Try v1 → v2 → v3 → v4 → v5 → v6
 		const v1Result = pluginConfigSchemaV1.safeParse(parsed);
 		if (v1Result.success) {
 			const v2 = migrateV1toV2(v1Result.data);
 			const v3 = migrateV2toV3(v2);
 			const v4 = migrateV3toV4(v3);
-			const migrated = migrateV4toV5(v4);
+			const v5 = migrateV4toV5(v4);
+			const migrated = migrateV5toV6(v5);
 			await saveConfig(migrated, configPath);
 			return migrated;
 		}
 
-		return pluginConfigSchemaV5.parse(parsed); // throw with proper error
+		return pluginConfigSchemaV6.parse(parsed); // throw with proper error
 	} catch (error: unknown) {
 		if (isEnoentError(error)) return null;
 		throw error;
@@ -313,13 +371,13 @@ export function isFirstLoad(config: PluginConfig | null): boolean {
 
 export function createDefaultConfig(): PluginConfig {
 	return {
-		version: 5 as const,
+		version: 6 as const,
 		configured: false,
 		groups: {},
 		overrides: {},
 		orchestrator: orchestratorDefaults,
 		confidence: confidenceDefaults,
-		fallback: fallbackDefaults,
+		fallback: fallbackDefaultsV6,
 		memory: memoryDefaults,
 	};
 }

package/src/health/checks.ts

@@ -1,7 +1,13 @@
-import { access } from "node:fs/promises";
+import { Database } from "bun:sqlite";
+import { access, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
 import type { Config } from "@opencode-ai/plugin";
+import { parse } from "yaml";
 import { loadConfig } from "../config";
+import { DB_FILE, MEMORY_DIR } from "../memory/constants";
 import { AGENT_NAMES } from "../orchestrator/handlers/types";
+import { detectProjectStackTags, filterSkillsByStack } from "../skills/adaptive-injector";
+import { loadAllSkills } from "../skills/loader";
 import { getAssetsDir, getGlobalConfigDir } from "../utils/paths";
 import type { HealthResult } from "./types";
 
@@ -123,3 +129,178 @@ export async function assetHealthCheck(
 		});
 	}
 }
+
+/**
+ * Check skill loading status per detected project stack.
+ * Reports which stacks are detected and how many skills match.
+ * Accepts optional skillsDir for testability (defaults to global config skills dir).
+ */
+export async function skillHealthCheck(
+	projectRoot: string,
+	skillsDir?: string,
+): Promise<HealthResult> {
+	try {
+		const tags = await detectProjectStackTags(projectRoot);
+		const resolvedSkillsDir = skillsDir ?? join(getGlobalConfigDir(), "skills");
+		const allSkills = await loadAllSkills(resolvedSkillsDir);
+		const filtered = filterSkillsByStack(allSkills, tags);
+
+		const stackLabel = tags.length > 0 ? tags.join(", ") : "none";
+		return Object.freeze({
+			name: "skill-loading",
+			status: "pass" as const,
+			message: `Detected stacks: [${stackLabel}], ${filtered.size}/${allSkills.size} skills matched`,
+			details: Object.freeze([...filtered.keys()]),
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "skill-loading",
+			status: "fail" as const,
+			message: `Skill check failed: ${msg}`,
+		});
+	}
+}
+
+/**
+ * Check memory DB health: existence, readability, observation count.
+ * Does NOT call getMemoryDb() to avoid creating an empty DB as a side effect.
+ * Uses readonly DB access for safe inspection.
+ * Accepts optional baseDir for testability (defaults to global config dir).
+ */
+export async function memoryHealthCheck(baseDir?: string): Promise<HealthResult> {
+	const resolvedBase = baseDir ?? getGlobalConfigDir();
+	const dbPath = join(resolvedBase, MEMORY_DIR, DB_FILE);
+
+	try {
+		await access(dbPath);
+	} catch (error: unknown) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT") {
+			return Object.freeze({
+				name: "memory-db",
+				status: "pass" as const,
+				message: `Memory DB not yet initialized -- will be created on first memory capture`,
+			});
+		}
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "memory-db",
+			status: "fail" as const,
+			message: `Memory DB inaccessible: ${msg}`,
+		});
+	}
+
+	try {
+		const fileStat = await stat(dbPath);
+		const sizeKB = (fileStat.size / 1024).toFixed(1);
+
+		if (fileStat.size === 0) {
+			return Object.freeze({
+				name: "memory-db",
+				status: "fail" as const,
+				message: `Memory DB exists but is empty (0 bytes)`,
+			});
+		}
+
+		const db = new Database(dbPath, { readonly: true });
+		try {
+			const row = db.query("SELECT COUNT(*) as count FROM observations").get() as {
+				count: number;
+			} | null;
+			const count = row?.count ?? 0;
+			return Object.freeze({
+				name: "memory-db",
+				status: "pass" as const,
+				message: `Memory DB exists (${count} observation${count !== 1 ? "s" : ""}, ${sizeKB}KB)`,
+			});
+		} finally {
+			db.close();
+		}
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "memory-db",
+			status: "fail" as const,
+			message: `Memory DB read error: ${msg}`,
+		});
+	}
+}
+
+/** Expected command files that should exist in the commands directory. */
+const EXPECTED_COMMANDS: readonly string[] = Object.freeze([
+	"oc-tdd",
+	"oc-review-pr",
+	"oc-brainstorm",
+	"oc-write-plan",
+	"oc-stocktake",
+	"oc-update-docs",
+	"oc-new-agent",
+	"oc-new-skill",
+	"oc-new-command",
+	"oc-quick",
+	"oc-review-agents",
+]);
+
+/**
+ * Check command accessibility: file existence and valid YAML frontmatter.
+ * Verifies each expected command file exists and has a non-empty description.
+ */
+export async function commandHealthCheck(targetDir?: string): Promise<HealthResult> {
+	const dir = targetDir ?? getGlobalConfigDir();
+	const missing: string[] = [];
+	const invalid: string[] = [];
+
+	await Promise.all(
+		EXPECTED_COMMANDS.map(async (name) => {
+			const filePath = join(dir, "commands", `${name}.md`);
+			try {
+				const content = await readFile(filePath, "utf-8");
+				const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+				if (!fmMatch) {
+					invalid.push(`${name}: no frontmatter`);
+					return;
+				}
+				try {
+					const parsed = parse(fmMatch[1]);
+					if (
+						parsed === null ||
+						typeof parsed !== "object" ||
+						typeof parsed.description !== "string" ||
+						parsed.description.trim().length === 0
+					) {
+						invalid.push(`${name}: missing or empty description`);
+					}
+				} catch {
+					invalid.push(`${name}: invalid YAML frontmatter`);
+				}
+			} catch (error: unknown) {
+				const code = (error as NodeJS.ErrnoException).code;
+				if (code === "ENOENT") {
+					missing.push(name);
+				} else {
+					invalid.push(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			}
+		}),
+	);
+
+	missing.sort();
+	invalid.sort();
+	const issues = [...missing.map((n) => `missing: ${n}`), ...invalid];
+
+	if (issues.length === 0) {
+		return Object.freeze({
+			name: "command-accessibility",
+			status: "pass" as const,
+			message: `All ${EXPECTED_COMMANDS.length} commands accessible`,
+		});
+	}
+
+	return Object.freeze({
+		name: "command-accessibility",
+		status: "fail" as const,
+		message: `${issues.length} command issue(s) found`,
+		details: Object.freeze(issues),
+	});
+}

package/src/health/runner.ts

@@ -1,5 +1,12 @@
 import type { Config } from "@opencode-ai/plugin";
-import { agentHealthCheck, assetHealthCheck, configHealthCheck } from "./checks";
+import {
+	agentHealthCheck,
+	assetHealthCheck,
+	commandHealthCheck,
+	configHealthCheck,
+	memoryHealthCheck,
+	skillHealthCheck,
+} from "./checks";
 import type { HealthReport, HealthResult } from "./types";
 
 /**
@@ -31,6 +38,7 @@ export async function runHealthChecks(options?: {
 	openCodeConfig?: Config | null;
 	assetsDir?: string;
 	targetDir?: string;
+	projectRoot?: string;
 }): Promise<HealthReport> {
 	const start = Date.now();
 
@@ -38,9 +46,19 @@ export async function runHealthChecks(options?: {
 		configHealthCheck(options?.configPath),
 		agentHealthCheck(options?.openCodeConfig ?? null),
 		assetHealthCheck(options?.assetsDir, options?.targetDir),
+		skillHealthCheck(options?.projectRoot ?? process.cwd()),
+		memoryHealthCheck(options?.targetDir),
+		commandHealthCheck(options?.targetDir),
 	]);
 
-	const fallbackNames = ["config-validity", "agent-injection", "asset-directories"];
+	const fallbackNames = [
+		"config-validity",
+		"agent-injection",
+		"asset-directories",
+		"skill-loading",
+		"memory-db",
+		"command-accessibility",
+	];
 	const results: readonly HealthResult[] = Object.freeze(
 		settled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),
 	);

package/src/hooks/anti-slop.ts

@@ -0,0 +1,132 @@
+/**
+ * Anti-slop hook: detects AI-generated comment bloat in code files.
+ * Warn-only (non-blocking) -- fires as PostToolUse after file-writing tools.
+ */
+import { readFile } from "node:fs/promises";
+import { extname, isAbsolute, resolve } from "node:path";
+import {
+	CODE_EXTENSIONS,
+	COMMENT_PATTERNS,
+	EXT_COMMENT_STYLE,
+	SLOP_PATTERNS,
+} from "./slop-patterns";
+
+/** A single detected slop comment occurrence. */
+export interface SlopFinding {
+	readonly line: number;
+	readonly text: string;
+	readonly pattern: string;
+}
+
+/** Returns true if the file path has a code extension eligible for scanning. */
+export function isCodeFile(filePath: string): boolean {
+	return CODE_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+
+/**
+ * Scans content for slop comments matching curated patterns.
+ * Only examines comment text (not raw code) to avoid false positives.
+ */
+export function scanForSlopComments(content: string, ext: string): readonly SlopFinding[] {
+	const commentStyle = EXT_COMMENT_STYLE[ext];
+	if (!commentStyle) return Object.freeze([]);
+
+	const commentRegex = COMMENT_PATTERNS[commentStyle];
+	if (!commentRegex) return Object.freeze([]);
+
+	const lines = content.split("\n");
+	const findings: SlopFinding[] = [];
+
+	for (let i = 0; i < lines.length; i++) {
+		const match = commentRegex.exec(lines[i]);
+		if (!match?.[1]) continue;
+
+		const commentText = match[1].trim();
+
+		for (const pattern of SLOP_PATTERNS) {
+			if (pattern.test(commentText)) {
+				findings.push(
+					Object.freeze({
+						line: i + 1,
+						text: commentText,
+						pattern: pattern.source,
+					}),
+				);
+				break; // one finding per line
+			}
+		}
+	}
+
+	return Object.freeze(findings);
+}
+
+/** Tools that write files and should be scanned for slop. */
+const FILE_WRITING_TOOLS: ReadonlySet<string> = Object.freeze(
+	new Set(["write_file", "edit_file", "write", "edit", "create_file"]),
+);
+
+/**
+ * Creates a tool.execute.after handler that scans for slop comments.
+ * Best-effort: never throws, never blocks the pipeline.
+ */
+export function createAntiSlopHandler(options: {
+	readonly showToast: (
+		title: string,
+		message: string,
+		variant: "info" | "warning" | "error",
+	) => Promise<void>;
+}) {
+	return async (
+		hookInput: {
+			readonly tool: string;
+			readonly sessionID: string;
+			readonly callID: string;
+			readonly args: unknown;
+		},
+		_output: { title: string; output: string; metadata: unknown },
+	): Promise<void> => {
+		if (!FILE_WRITING_TOOLS.has(hookInput.tool)) return;
+
+		// Extract file path from args with type-safe narrowing
+		const args = hookInput.args;
+		if (args === null || typeof args !== "object") return;
+		const record = args as Record<string, unknown>;
+		const rawPath = record.file_path ?? record.filePath ?? record.path ?? record.file;
+		if (typeof rawPath !== "string" || rawPath.length === 0) return;
+
+		// Validate path is absolute and within cwd (prevent path traversal)
+		if (!isAbsolute(rawPath)) return;
+		const resolved = resolve(rawPath);
+		const cwd = process.cwd();
+		if (!resolved.startsWith(`${cwd}/`) && resolved !== cwd) return;
+
+		if (!isCodeFile(resolved)) return;
+		const ext = extname(resolved).toLowerCase();
+
+		// Read the actual file content — output.output is the tool's result message, not file content
+		let fileContent: string;
+		try {
+			fileContent = await readFile(resolved, "utf-8");
+		} catch {
+			return; // file unreadable — best-effort, skip
+		}
+
+		const findings = scanForSlopComments(fileContent, ext);
+		if (findings.length === 0) return;
+
+		const preview = findings
+			.slice(0, 5)
+			.map((f) => `L${f.line}: ${f.text}`)
+			.join("\n");
+
+		try {
+			await options.showToast(
+				"Anti-Slop Warning",
+				`${findings.length} AI comment(s) detected:\n${preview}`,
+				"warning",
+			);
+		} catch {
+			// best-effort -- toast failure is non-fatal
+		}
+	};
+}

package/src/hooks/slop-patterns.ts

@@ -0,0 +1,71 @@
+/**
+ * Curated regex patterns for detecting AI-generated comment bloat ("slop").
+ * All exports are frozen for immutability.
+ */
+
+/** Code file extensions eligible for anti-slop scanning. */
+export const CODE_EXTENSIONS: ReadonlySet<string> = Object.freeze(
+	new Set([
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".py",
+		".go",
+		".rs",
+		".java",
+		".cs",
+		".rb",
+		".cpp",
+		".c",
+		".h",
+	]),
+);
+
+/** Maps file extension to its single-line comment prefix. */
+export const EXT_COMMENT_STYLE: Readonly<Record<string, string>> = Object.freeze({
+	".ts": "//",
+	".tsx": "//",
+	".js": "//",
+	".jsx": "//",
+	".java": "//",
+	".cs": "//",
+	".go": "//",
+	".rs": "//",
+	".c": "//",
+	".cpp": "//",
+	".h": "//",
+	".py": "#",
+	".rb": "#",
+});
+
+/** Regex to extract comment text from a line given its comment prefix.
+ * Matches both full-line comments and inline trailing comments.
+ * Negative lookbehind (?<!:) prevents matching :// in URLs. */
+export const COMMENT_PATTERNS: Readonly<Record<string, RegExp>> = Object.freeze({
+	"//": /(?<!:)\/\/\s*(.+)/,
+	"#": /#\s*(.+)/,
+});
+
+/**
+ * Patterns matching obvious/sycophantic AI comment text.
+ * Tested against extracted comment body only (not raw code lines).
+ */
+export const SLOP_PATTERNS: readonly RegExp[] = Object.freeze([
+	/^increment\s+.*\s+by\s+\d+$/i,
+	/^decrement\s+.*\s+by\s+\d+$/i,
+	/^return\s+the\s+(result|value|data)\s*$/i,
+	/^(?:this|the)\s+(?:function|method|class)\s+(?:does|will|is used to|handles)/i,
+	/^(?:initialize|init)\s+(?:the\s+)?(?:variable|value|state)/i,
+	/^import\s+(?:the\s+)?(?:necessary|required|needed)/i,
+	/^define\s+(?:the\s+)?(?:interface|type|class|function)/i,
+	/\belegantly?\b/i,
+	/\brobust(?:ly|ness)?\b/i,
+	/\bcomprehensive(?:ly)?\b/i,
+	/\bseamless(?:ly)?\b/i,
+	/\blever(?:age|aging)\b/i,
+	/\bpowerful\b/i,
+	/\bsophisticated\b/i,
+	/\bstate[\s-]of[\s-]the[\s-]art\b/i,
+	/\bcutting[\s-]edge\b/i,
+]);

package/src/index.ts

@@ -2,6 +2,7 @@ import type { Config, Plugin } from "@opencode-ai/plugin";
 import { configHook } from "./agents";
 import { isFirstLoad, loadConfig } from "./config";
 import { runHealthChecks } from "./health/runner";
+import { createAntiSlopHandler } from "./hooks/anti-slop";
 import { installAssets } from "./installer";
 import { createMemoryCaptureHandler, createMemoryInjector, getMemoryDb } from "./memory";
 import { ContextMonitor } from "./observability/context-monitor";
@@ -150,6 +151,9 @@ const plugin: Plugin = async (input) => {
 	const chatMessageHandler = createChatMessageHandler(manager);
 	const toolExecuteAfterHandler = createToolExecuteAfterHandler(manager);
 
+	// --- Anti-slop hook initialization ---
+	const antiSlopHandler = createAntiSlopHandler({ showToast: sdkOps.showToast });
+
 	// --- Memory subsystem initialization ---
 	const memoryConfig = config?.memory ?? {
 		enabled: true,
@@ -288,6 +292,13 @@ const plugin: Plugin = async (input) => {
 			if (fallbackConfig.enabled) {
 				await toolExecuteAfterHandler(hookInput, output);
 			}
+
+			// Anti-slop comment detection (best-effort, non-blocking)
+			try {
+				await antiSlopHandler(hookInput, output);
+			} catch {
+				// best-effort
+			}
 		},
 		"experimental.chat.system.transform": async (input, output) => {
 			if (memoryInjector) {

package/src/orchestrator/fallback/fallback-config.ts

@@ -14,3 +14,24 @@ export type FallbackConfig = z.infer<typeof fallbackConfigSchema>;
 
 // Pre-compute defaults for Zod v4 nested default compatibility
 export const fallbackDefaults = fallbackConfigSchema.parse({});
+
+// --- Test mode sub-schema (v6) ---
+
+export const testModeSchema = z.object({
+	enabled: z.boolean().default(false),
+	sequence: z
+		.array(z.enum(["rate_limit", "quota_exceeded", "service_unavailable", "malformed", "timeout"]))
+		.default([]),
+});
+
+export type TestModeConfig = z.infer<typeof testModeSchema>;
+export const testModeDefaults = testModeSchema.parse({});
+
+// --- V6 fallback schema (extends base with testMode) ---
+
+export const fallbackConfigSchemaV6 = fallbackConfigSchema.extend({
+	testMode: testModeSchema.default(testModeDefaults),
+});
+
+export type FallbackConfigV6 = z.infer<typeof fallbackConfigSchemaV6>;
+export const fallbackDefaultsV6 = fallbackConfigSchemaV6.parse({});

package/src/orchestrator/fallback/mock-interceptor.ts

@@ -0,0 +1,51 @@
+import { createMockError } from "../../observability/mock/mock-provider";
+import type { MockFailureMode } from "../../observability/mock/types";
+import type { TestModeConfig } from "./fallback-config";
+
+/**
+ * Deterministic sequence interceptor for fallback chain testing.
+ * Cycles through a configured sequence of failure modes, generating
+ * mock error objects compatible with the error classifier.
+ */
+export class MockInterceptor {
+	private index = 0;
+	private readonly sequence: readonly MockFailureMode[];
+
+	constructor(sequence: readonly MockFailureMode[]) {
+		this.sequence = sequence;
+	}
+
+	/** Get the next failure mode in the sequence (cycles). */
+	nextMode(): MockFailureMode {
+		if (this.sequence.length === 0) {
+			throw new Error("MockInterceptor: cannot call nextMode() on an empty sequence");
+		}
+		const mode = this.sequence[this.index % this.sequence.length];
+		this.index = (this.index + 1) % this.sequence.length;
+		return mode;
+	}
+
+	/** Get the next mock error object (frozen, matches error-classifier shapes). */
+	nextError(): unknown {
+		return createMockError(this.nextMode());
+	}
+
+	/** Reset the cycle index to 0. */
+	reset(): void {
+		this.index = 0;
+	}
+
+	/** Current position in the sequence. */
+	get position(): number {
+		return this.index;
+	}
+}
+
+/**
+ * Factory: returns MockInterceptor if testMode is enabled and has a
+ * non-empty sequence, null otherwise.
+ */
+export function createMockInterceptor(config: TestModeConfig): MockInterceptor | null {
+	if (!config.enabled || config.sequence.length === 0) return null;
+	return new MockInterceptor(config.sequence as readonly MockFailureMode[]);
+}

package/src/tools/configure.ts

@@ -314,7 +314,7 @@ async function handleCommit(configPath?: string): Promise<string> {
 	}
 	const newConfig = {
 		...currentConfig,
-		version: 5 as const,
+		version: 6 as const,
 		configured: true,
 		groups: groupsRecord,
 		overrides: currentConfig.overrides ?? {},

package/src/tools/doctor.ts

@@ -21,6 +21,7 @@ interface DoctorOptions {
 	readonly openCodeConfig?: Config | null;
 	readonly assetsDir?: string;
 	readonly targetDir?: string;
+	readonly projectRoot?: string;
 }
 
 /**
@@ -31,6 +32,10 @@ const FIX_SUGGESTIONS: Readonly<Record<string, string>> = Object.freeze({
 		"Run `bunx @kodrunhq/opencode-autopilot configure` to reconfigure, or delete ~/.config/opencode/opencode-autopilot.json to reset",
 	"agent-injection": "Restart OpenCode to trigger agent re-injection via config hook",
 	"asset-directories": "Restart OpenCode to trigger asset reinstallation",
+	"skill-loading": "Ensure skills directory exists in ~/.config/opencode/skills/",
+	"memory-db":
+		"Memory DB is created automatically on first memory capture -- use the plugin normally to initialize",
+	"command-accessibility": "Restart OpenCode to trigger command reinstallation from bundled assets",
 });
 
 function getFixSuggestion(checkName: string): string {
@@ -72,6 +77,7 @@ export async function doctorCore(options?: DoctorOptions): Promise<string> {
 		openCodeConfig: options?.openCodeConfig,
 		assetsDir: options?.assetsDir,
 		targetDir: options?.targetDir,
+		projectRoot: options?.projectRoot,
 	});
 
 	// Map health results to doctor checks with fix suggestions

package/src/utils/language-resolver.ts

@@ -0,0 +1,34 @@
+import { detectProjectStackTags } from "../skills/adaptive-injector";
+
+/** Cache: projectRoot -> resolved language string. */
+const cache = new Map<string, string>();
+
+/**
+ * Resolve project language tags as a human-readable string.
+ * Caches per projectRoot to avoid repeated filesystem access.
+ */
+export async function resolveLanguageTag(projectRoot: string): Promise<string> {
+	const cached = cache.get(projectRoot);
+	if (cached !== undefined) return cached;
+
+	try {
+		const tags = await detectProjectStackTags(projectRoot);
+		const result = tags.length > 0 ? [...tags].sort().join(", ") : "unknown";
+		cache.set(projectRoot, result);
+		return result;
+	} catch {
+		return "unknown";
+	}
+}
+
+/**
+ * Substitute $LANGUAGE in a text string with the resolved language tag.
+ */
+export function substituteLanguageVar(text: string, language: string): string {
+	return text.replaceAll("$LANGUAGE", language);
+}
+
+/** Clear the language cache (for testing). */
+export function clearLanguageCache(): void {
+	cache.clear();
+}