@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/review/selection.ts

@@ -5,6 +5,8 @@
  * agents with non-empty relevantStacks require at least one match.
  */
 
+import { createSeededRandom, deterministicShuffle } from "../utils/random";
+
 /** Minimal agent shape needed for selection (compatible with ReviewAgent from agents/). */
 interface SelectableAgent {
 	readonly name: string;
@@ -21,6 +23,13 @@ export interface DiffAnalysisInput {
 	readonly fileCount: number;
 }
 
+export interface SelectionOptions {
+	/** Seed for reproducible agent ordering. If omitted, uses a fixed default. */
+	readonly seed?: string;
+	/** Maximum number of gated agents to select. Universal agents are always included. */
+	readonly limit?: number;
+}
+
 export interface SelectionResult {
 	readonly selected: readonly SelectableAgent[];
 	readonly excluded: readonly { readonly agent: string; readonly reason: string }[];
@@ -32,25 +41,28 @@ export interface SelectionResult {
  * @param detectedStacks - Stack tags detected in the project (e.g., ["node", "typescript"])
  * @param diffAnalysis - Analysis of changed files
  * @param agents - All candidate agents
+ * @param options - Options for seeding and limiting the number of agents
  * @returns Frozen SelectionResult with selected and excluded lists
  */
 export function selectAgents(
 	detectedStacks: readonly string[],
 	_diffAnalysis: DiffAnalysisInput,
 	agents: readonly SelectableAgent[],
+	options: SelectionOptions = {},
 ): SelectionResult {
 	const stackSet = new Set(detectedStacks);
-	const selected: SelectableAgent[] = [];
+	const universal: SelectableAgent[] = [];
+	const gatedCandidates: SelectableAgent[] = [];
 	const excluded: { readonly agent: string; readonly reason: string }[] = [];
 
 	for (const agent of agents) {
 		// Pass 1: Stack gate
 		if (agent.relevantStacks.length === 0) {
 			// Universal agent -- always passes
-			selected.push(agent);
+			universal.push(agent);
 		} else if (agent.relevantStacks.some((s) => stackSet.has(s))) {
 			// Gated agent with at least one matching stack
-			selected.push(agent);
+			gatedCandidates.push(agent);
 		} else {
 			// Gated agent with no matching stack
 			const stackList = detectedStacks.length > 0 ? detectedStacks.join(", ") : "none";
@@ -63,8 +75,30 @@ export function selectAgents(
 		}
 	}
 
+	const seed = options.seed ?? "default-selection-seed";
+	const rng = createSeededRandom(seed);
+
+	const shuffledGated = deterministicShuffle([...gatedCandidates], rng);
+	const finalGated =
+		options.limit !== undefined ? shuffledGated.slice(0, options.limit) : shuffledGated;
+
+	if (options.limit !== undefined && finalGated.length < shuffledGated.length) {
+		const dropped = shuffledGated.slice(options.limit);
+		for (const agent of dropped) {
+			excluded.push(
+				Object.freeze({
+					agent: agent.name,
+					reason: `Diversity limit: dropped to meet limit of ${options.limit}`,
+				}),
+			);
+		}
+	}
+
+	const combined = [...universal, ...finalGated];
+	deterministicShuffle(combined, rng);
+
 	return Object.freeze({
-		selected: Object.freeze(selected),
+		selected: Object.freeze(combined),
 		excluded: Object.freeze(excluded),
 	});
 }

package/src/scoring/time-provider.ts

@@ -0,0 +1,23 @@
+export interface TimeProvider {
+	readonly now: () => number;
+}
+
+export const systemTimeProvider: TimeProvider = Object.freeze({
+	now: () => Date.now(),
+});
+
+export function createFixedTimeProvider(
+	initialTimeMs: number,
+): TimeProvider & { advance: (ms: number) => void; set: (ms: number) => void } {
+	let currentTime = initialTimeMs;
+
+	return Object.freeze({
+		now: () => currentTime,
+		advance: (ms: number) => {
+			currentTime += ms;
+		},
+		set: (ms: number) => {
+			currentTime = ms;
+		},
+	});
+}

package/src/tools/doctor.ts

@@ -17,7 +17,7 @@ export function setOpenCodeConfig(config: Config | null): void {
  */
 interface DoctorCheck {
 	readonly name: string;
-	readonly status: "pass" | "fail";
+	readonly status: "pass" | "warn" | "fail";
 	readonly message: string;
 	readonly fixSuggestion: string | null;
 }
@@ -39,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 {
@@ -96,7 +120,7 @@ function formatCheck(result: HealthResult): DoctorCheck {
  */
 function buildDisplayText(checks: readonly DoctorCheck[], duration: number): string {
 	const lines = checks.map((c) => {
-		const icon = c.status === "pass" ? "OK" : "FAIL";
+		const icon = c.status === "pass" ? "OK" : c.status === "warn" ? "WARN" : "FAIL";
 		const line = `[${icon}] ${c.name}: ${c.message}`;
 		return c.fixSuggestion ? `${line}\n     Fix: ${c.fixSuggestion}` : line;
 	});

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

@@ -22,14 +22,14 @@ import {
 } from "../observability/log-reader";
 import { generateSessionSummary } from "../observability/summary-generator";
 
-/**
- * Options for logsCore search/detail modes.
- */
 interface LogsOptions {
 	readonly sessionID?: string;
 	readonly eventType?: string;
 	readonly after?: string;
 	readonly before?: string;
+	readonly domain?: string;
+	readonly subsystem?: string;
+	readonly severity?: string;
 }
 
 /**
@@ -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
@@ -134,6 +135,9 @@ export async function logsCore(
 				type: options?.eventType,
 				after: options?.after,
 				before: options?.before,
+				domain: options?.domain,
+				subsystem: options?.subsystem,
+				severity: options?.severity,
 			});
 
 			const displayLines = [
@@ -145,6 +149,15 @@ export async function logsCore(
 			return JSON.stringify({
 				action: "logs_search",
 				sessionId: log.sessionId,
+				filters: {
+					eventType: options?.eventType,
+					after: options?.after,
+					before: options?.before,
+					domain: options?.domain,
+					subsystem: options?.subsystem,
+					severity: options?.severity,
+				},
+				matchCount: filtered.length,
 				events: filtered,
 				displayText: displayLines.join("\n"),
 			});
@@ -157,7 +170,7 @@ export async function logsCore(
 export const ocLogs = tool({
 	description:
 		"View session logs. Modes: 'list' shows all sessions, 'detail' shows full log with " +
-		"summary, 'search' filters events by type/time. Use to inspect session history and errors.",
+		"summary, 'search' filters events by type/time/domain/subsystem/severity. Use to inspect session history and errors.",
 	args: {
 		mode: z.enum(["list", "detail", "search"]).describe("View mode: list, detail, or search"),
 		sessionID: z
@@ -171,8 +184,22 @@ export const ocLogs = tool({
 			.string()
 			.optional()
 			.describe("Only events before this ISO timestamp (for search mode)"),
+		domain: z
+			.string()
+			.optional()
+			.describe("Filter events by domain (e.g. 'session', 'orchestrator') (for search mode)"),
+		subsystem: z
+			.string()
+			.optional()
+			.describe("Filter events by payload.subsystem field (for search mode)"),
+		severity: z
+			.string()
+			.optional()
+			.describe(
+				"Filter by severity: matches event.type (e.g. 'error', 'warning') or payload.severity/payload.level (for search mode)",
+			),
 	},
-	async execute({ mode, sessionID, eventType, after, before }) {
-		return logsCore(mode, { sessionID, eventType, after, before });
+	async execute({ mode, sessionID, eventType, after, before, domain, subsystem, severity }) {
+		return logsCore(mode, { sessionID, eventType, after, before, domain, subsystem, severity });
 	},
 });

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();
 	}
 }