@kodrunhq/opencode-autopilot 1.15.1 → 1.16.0

package/src/tools/doctor.ts

@@ -6,6 +6,12 @@ import { runHealthChecks } from "../health/runner";
 import type { HealthResult } from "../health/types";
 import { getProjectArtifactDir } from "../utils/paths";
 
+let openCodeConfig: Config | null = null;
+
+export function setOpenCodeConfig(config: Config | null): void {
+	openCodeConfig = config;
+}
+
 /**
  * A single check in the doctor report, with an optional fix suggestion.
  */
@@ -33,9 +39,33 @@ async function detectContractHealth(projectRoot?: string): Promise<ContractHealt
 		const artifactDir = getProjectArtifactDir(projectRoot);
 		const logPath = join(artifactDir, "orchestration.jsonl");
 		const content = await readFile(logPath, "utf-8");
+		const entries = content
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean)
+			.map((line) => {
+				try {
+					return JSON.parse(line) as Record<string, unknown>;
+				} catch {
+					return null;
+				}
+			})
+			.filter((entry): entry is Record<string, unknown> => entry !== null);
+		const legacyTasksFallbackSeen =
+			entries.some(
+				(entry) =>
+					typeof entry.message === "string" &&
+					entry.message.includes("PLAN fallback: parsed legacy tasks.md"),
+			) || content.includes("PLAN fallback: parsed legacy tasks.md");
+		const legacyResultParserSeen =
+			entries.some(
+				(entry) =>
+					typeof entry.message === "string" &&
+					entry.message.includes("Legacy result parser path used"),
+			) || content.includes("Legacy result parser path used");
 		return {
-			legacyTasksFallbackSeen: content.includes("PLAN fallback: parsed legacy tasks.md"),
-			legacyResultParserSeen: content.includes("Legacy result parser path used"),
+			legacyTasksFallbackSeen,
+			legacyResultParserSeen,
 		};
 	} catch {
 		return {
@@ -63,6 +93,8 @@ const FIX_SUGGESTIONS: Readonly<Record<string, string>> = Object.freeze({
 	"config-validity":
 		"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",
+	"native-agent-suppression":
+		"Restart OpenCode and verify plugin config hook runs. If issue persists, check for conflicting OpenCode config or another plugin overriding agent entries",
 	"asset-directories": "Restart OpenCode to trigger asset reinstallation",
 	"skill-loading": "Ensure skills directory exists in ~/.config/opencode/skills/",
 	"memory-db":
@@ -143,9 +175,12 @@ export async function doctorCore(options?: DoctorOptions): Promise<string> {
 export const ocDoctor = tool({
 	description:
 		"Run plugin health diagnostics. Reports pass/fail status for config, agents, " +
-		"assets, and hooks. Like `brew doctor` for opencode-autopilot.",
+		"native suppression, assets, and hooks. Like `brew doctor` for opencode-autopilot.",
 	args: {},
-	async execute() {
-		return doctorCore();
+	async execute(_args, context) {
+		return doctorCore({
+			openCodeConfig,
+			projectRoot: context.directory,
+		});
 	},
 });

package/src/tools/forensics.ts

@@ -1,6 +1,5 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 import { tool } from "@opencode-ai/plugin";
+import { readForensicEvents } from "../observability/forensic-log";
 import { loadState } from "../orchestrator/state";
 import { getProjectArtifactDir } from "../utils/paths";
 
@@ -23,16 +22,12 @@ function getSuggestedAction(failedPhase: string, recoverable: boolean): "resume"
 	return "resume";
 }
 
-async function readRecentContractEvents(artifactDir: string): Promise<readonly string[]> {
+async function readRecentContractEvents(projectRoot: string): Promise<readonly string[]> {
 	try {
-		const raw = await readFile(join(artifactDir, "orchestration.jsonl"), "utf-8");
-		const lines = raw
-			.split("\n")
-			.map((line) => line.trim())
-			.filter(Boolean)
-			.slice(-120);
+		const events = (await readForensicEvents(projectRoot)).slice(-120);
 		const codes = new Set<string>();
-		for (const line of lines) {
+		for (const event of events) {
+			const searchable = `${String(event.code ?? "")} ${String(event.message ?? "")} ${JSON.stringify(event.payload ?? {})}`;
 			for (const code of [
 				"E_INVALID_RESULT",
 				"E_STALE_RESULT",
@@ -42,7 +37,7 @@ async function readRecentContractEvents(artifactDir: string): Promise<readonly s
 				"E_BUILD_TASK_ID_REQUIRED",
 				"E_BUILD_UNKNOWN_TASK",
 			]) {
-				if (line.includes(code)) {
+				if (searchable.includes(code)) {
 					codes.add(code);
 				}
 			}
@@ -98,7 +93,7 @@ export async function forensicsCore(
 	const recoverable = isRecoverable(failureContext.failedPhase);
 	const suggestedAction = getSuggestedAction(failureContext.failedPhase, recoverable);
 	const phasesCompleted = state.phases.filter((p) => p.status === "DONE").map((p) => p.name);
-	const deterministicErrorCodes = await readRecentContractEvents(artifactDir);
+	const deterministicErrorCodes = await readRecentContractEvents(projectRoot);
 
 	return JSON.stringify({
 		failedPhase: failureContext.failedPhase,

package/src/tools/logs.ts

@@ -79,9 +79,10 @@ export async function logsCore(
 	options?: LogsOptions,
 	logsDir?: string,
 ): Promise<string> {
+	const logsRoot = logsDir ?? process.cwd();
 	switch (mode) {
 		case "list": {
-			const sessions = await listSessionLogs(logsDir);
+			const sessions = await listSessionLogs(logsRoot);
 
 			return JSON.stringify({
 				action: "logs_list",
@@ -92,8 +93,8 @@ export async function logsCore(
 
 		case "detail": {
 			const log = options?.sessionID
-				? await readSessionLog(options.sessionID, logsDir)
-				: await readLatestSessionLog(logsDir);
+				? await readSessionLog(options.sessionID, logsRoot)
+				: await readLatestSessionLog(logsRoot);
 
 			if (!log) {
 				const target = options?.sessionID
@@ -117,8 +118,8 @@ export async function logsCore(
 
 		case "search": {
 			const log = options?.sessionID
-				? await readSessionLog(options.sessionID, logsDir)
-				: await readLatestSessionLog(logsDir);
+				? await readSessionLog(options.sessionID, logsRoot)
+				: await readLatestSessionLog(logsRoot);
 
 			if (!log) {
 				const target = options?.sessionID

package/src/tools/memory-preferences.ts

@@ -0,0 +1,157 @@
+import type { Database } from "bun:sqlite";
+import { tool } from "@opencode-ai/plugin";
+import {
+	deletePreferenceRecord,
+	deletePreferencesByKey,
+	getMemoryDb,
+	prunePreferenceEvidence,
+	prunePreferences,
+} from "../memory";
+import { resolveProjectIdentitySync } from "../projects/resolve";
+
+type PreferenceScopeArg = "global" | "project";
+type PreferenceStatusArg = "candidate" | "confirmed" | "rejected" | "unconfirmed" | "any";
+
+interface MemoryPreferencesArgs {
+	readonly subcommand: "delete" | "prune" | "prune-evidence";
+	readonly id?: string;
+	readonly key?: string;
+	readonly scope?: PreferenceScopeArg;
+	readonly olderThanDays?: number;
+	readonly status?: PreferenceStatusArg;
+	readonly keepLatestPerPreference?: number;
+}
+
+function resolveProjectId(projectRoot: string, db: Database): string | null {
+	const resolved = resolveProjectIdentitySync(projectRoot, {
+		db,
+		allowCreate: false,
+	});
+	return resolved.id.startsWith("project:") ? null : resolved.id;
+}
+
+export function memoryPreferencesCore(
+	args: MemoryPreferencesArgs,
+	projectRoot: string,
+	db?: Database,
+): string {
+	try {
+		const resolvedDb = db ?? getMemoryDb();
+		const scope = args.scope ?? "global";
+		const projectId = scope === "project" ? resolveProjectId(projectRoot, resolvedDb) : null;
+
+		if (scope === "project" && projectId === null) {
+			return JSON.stringify({
+				error: "no_project_preferences",
+				message: "No known project identity for current directory.",
+			});
+		}
+
+		switch (args.subcommand) {
+			case "delete": {
+				if (typeof args.id === "string" && args.id.trim().length > 0) {
+					return JSON.stringify({
+						ok: true,
+						subcommand: "delete",
+						result: deletePreferenceRecord(args.id, resolvedDb),
+					});
+				}
+				if (typeof args.key === "string" && args.key.trim().length > 0) {
+					return JSON.stringify({
+						ok: true,
+						subcommand: "delete",
+						result: deletePreferencesByKey(args.key, { scope, projectId }, resolvedDb),
+					});
+				}
+				return JSON.stringify({
+					error: "id_or_key_required",
+					message: "delete requires either id or key.",
+				});
+			}
+
+			case "prune": {
+				if (typeof args.olderThanDays !== "number" || args.olderThanDays <= 0) {
+					return JSON.stringify({
+						error: "older_than_days_required",
+						message: "prune requires olderThanDays > 0.",
+					});
+				}
+				return JSON.stringify({
+					ok: true,
+					subcommand: "prune",
+					result: prunePreferences(
+						{
+							olderThanDays: args.olderThanDays,
+							scope,
+							projectId,
+							status: args.status ?? "unconfirmed",
+						},
+						resolvedDb,
+					),
+				});
+			}
+
+			case "prune-evidence": {
+				if (typeof args.olderThanDays !== "number" || args.olderThanDays <= 0) {
+					return JSON.stringify({
+						error: "older_than_days_required",
+						message: "prune-evidence requires olderThanDays > 0.",
+					});
+				}
+				return JSON.stringify({
+					ok: true,
+					subcommand: "prune-evidence",
+					result: prunePreferenceEvidence(
+						{
+							olderThanDays: args.olderThanDays,
+							keepLatestPerPreference: args.keepLatestPerPreference,
+							scope,
+							projectId,
+							status: args.status ?? "any",
+						},
+						resolvedDb,
+					),
+				});
+			}
+		}
+	} catch (error: unknown) {
+		return JSON.stringify({
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
+}
+
+export const ocMemoryPreferences = tool({
+	description:
+		"Manage learned preferences. Supports delete by id/key and pruning stale preference records or evidence.",
+	args: {
+		subcommand: tool.schema
+			.enum(["delete", "prune", "prune-evidence"])
+			.describe("Preference maintenance operation"),
+		id: tool.schema.string().optional().describe("Preference record id for delete"),
+		key: tool.schema.string().optional().describe("Preference key for delete"),
+		scope: tool.schema
+			.enum(["global", "project"])
+			.default("global")
+			.describe("Preference scope filter"),
+		olderThanDays: tool.schema
+			.number()
+			.int()
+			.positive()
+			.optional()
+			.describe("Delete records/evidence older than this many days"),
+		status: tool.schema
+			.enum(["candidate", "confirmed", "rejected", "unconfirmed", "any"])
+			.optional()
+			.describe("Preference status filter for prune operations"),
+		keepLatestPerPreference: tool.schema
+			.number()
+			.int()
+			.min(0)
+			.optional()
+			.describe("For prune-evidence, keep this many newest evidence rows per preference"),
+	},
+	async execute(args) {
+		return memoryPreferencesCore(args, process.cwd());
+	},
+});

package/src/tools/memory-status.ts

@@ -2,20 +2,15 @@
  * oc_memory_status tool — inspect memory system state.
  *
  * Shows observation counts, storage size, recent observations,
- * preferences, and per-type breakdowns. Follows the *Core + tool()
- * pattern from create-agent.ts.
+ * preferences, and per-type breakdowns through the shared inspection
+ * query layer.
  *
  * @module
  */
 
-import { Database } from "bun:sqlite";
-import { statSync } from "node:fs";
-import { join } from "node:path";
+import type { Database } from "bun:sqlite";
 import { tool } from "@opencode-ai/plugin";
-import { DB_FILE, MEMORY_DIR, OBSERVATION_TYPES } from "../memory/constants";
-import { getMemoryDb } from "../memory/database";
-import { getAllPreferences } from "../memory/repository";
-import { getGlobalConfigDir } from "../utils/paths";
+import { getMemoryOverview } from "../inspect/repository";
 
 interface MemoryStatusResult {
 	readonly stats: {
@@ -47,94 +42,22 @@ export function memoryStatusCore(
 	_args: { readonly detail?: "summary" | "full" },
 	dbOrPath?: Database | string,
 ): MemoryStatusResult {
-	let ownedDb: Database | null = null;
 	try {
-		if (typeof dbOrPath === "string") {
-			ownedDb = new Database(dbOrPath);
-		}
-		const db = dbOrPath instanceof Database ? dbOrPath : (ownedDb ?? getMemoryDb());
-
-		// Count observations
-		const obsCountRow = db.query("SELECT COUNT(*) as cnt FROM observations").get() as {
-			cnt: number;
-		};
-		const totalObservations = obsCountRow.cnt;
-
-		// Count by type
-		const typeRows = db
-			.query("SELECT type, COUNT(*) as cnt FROM observations GROUP BY type")
-			.all() as Array<{ type: string; cnt: number }>;
-
-		const observationsByType: Record<string, number> = {};
-		for (const t of OBSERVATION_TYPES) {
-			observationsByType[t] = 0;
-		}
-		for (const row of typeRows) {
-			observationsByType[row.type] = row.cnt;
-		}
-
-		// Count projects
-		const projCountRow = db.query("SELECT COUNT(*) as cnt FROM projects").get() as {
-			cnt: number;
-		};
-		const totalProjects = projCountRow.cnt;
-
-		// Count preferences
-		const prefCountRow = db.query("SELECT COUNT(*) as cnt FROM preferences").get() as {
-			cnt: number;
-		};
-		const totalPreferences = prefCountRow.cnt;
-
-		// Storage size — derive from actual DB path, not always the global default
-		let storageSizeKb = 0;
-		try {
-			const statPath =
-				typeof dbOrPath === "string" && dbOrPath !== ":memory:"
-					? dbOrPath
-					: join(getGlobalConfigDir(), MEMORY_DIR, DB_FILE);
-			const stat = statSync(statPath);
-			storageSizeKb = Math.round(stat.size / 1024);
-		} catch {
-			// DB might be in-memory or path doesn't exist
-		}
-
-		// Recent observations (last 10)
-		const recentRows = db
-			.query(
-				"SELECT type, summary, created_at, confidence FROM observations ORDER BY created_at DESC LIMIT 10",
-			)
-			.all() as Array<{
-			type: string;
-			summary: string;
-			created_at: string;
-			confidence: number;
-		}>;
-
-		const recentObservations = recentRows.map((row) => ({
-			type: row.type,
-			summary: row.summary,
-			createdAt: row.created_at,
-			confidence: row.confidence,
-		}));
-
-		// All preferences
-		const allPrefs = getAllPreferences(db);
-		const preferences = allPrefs.map((p) => ({
-			key: p.key,
-			value: p.value,
-			confidence: p.confidence,
-		}));
+		const overview = getMemoryOverview(dbOrPath);
 
 		return {
-			stats: {
-				totalObservations,
-				totalProjects,
-				totalPreferences,
-				storageSizeKb,
-				observationsByType,
-			},
-			recentObservations,
-			preferences,
+			stats: overview.stats,
+			recentObservations: overview.recentObservations.map((row) => ({
+				type: row.type,
+				summary: row.summary,
+				createdAt: row.createdAt,
+				confidence: row.confidence,
+			})),
+			preferences: overview.preferences.map((row) => ({
+				key: row.key,
+				value: row.value,
+				confidence: row.confidence,
+			})),
 		};
 	} catch (err) {
 		const detail = err instanceof Error ? err.message : String(err);
@@ -144,8 +67,6 @@ export function memoryStatusCore(
 			preferences: [],
 			error: `Memory system error: ${detail}`,
 		};
-	} finally {
-		ownedDb?.close();
 	}
 }