@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/memory/retrieval.ts

@@ -1,28 +1,33 @@
 /**
- * 3-layer progressive disclosure retrieval with token-budgeted context building.
+ * Provenance-first memory retrieval.
  *
- * Layer 1 (always): Observation summaries grouped by type (up to 5 per group)
- * Layer 2 (if budget allows): Recent Activity timeline
- * Layer 3 (if budget allows): Full content for top 1-2 observations
+ * Injects bounded memory context from explicit, inspectable sources:
+ * - confirmed project and global preferences
+ * - recent project lessons
+ * - recent failure-avoidance notes from error observations
  *
- * Token budget enforcement: never exceeds CHARS_PER_TOKEN * tokenBudget characters.
- * Same approach as buildMultiSkillContext in src/skills/adaptive-injector.ts.
+ * Generic observations remain queryable for inspection, but are no longer the
+ * primary injected memory contract.
  *
  * @module
  */
 
 import type { Database } from "bun:sqlite";
+import { getLogger } from "../logging/domains";
 import { CHARS_PER_TOKEN, DEFAULT_INJECTION_BUDGET } from "./constants";
 import { getMemoryDb } from "./database";
 import { computeRelevanceScore } from "./decay";
 import {
-	getAllPreferences,
-	getObservationsByProject,
+	getConfirmedPreferencesForProject,
 	getProjectByPath,
+	getRecentFailureObservations,
+	listRelevantLessons,
 	updateAccessCount,
 } from "./repository";
 import type { Observation, Preference } from "./types";
 
+const logger = getLogger("memory", "retrieval");
+
 /**
  * An observation with its computed relevance score.
  */
@@ -48,200 +53,113 @@ export function scoreAndRankObservations(
 		.sort((a, b) => b.relevanceScore - a.relevanceScore);
 }
 
-/**
- * Type-to-section header mapping for Layer 1 grouping.
- */
-const SECTION_HEADERS: Readonly<Record<string, string>> = Object.freeze({
-	decision: "### Key Decisions",
-	pattern: "### Patterns",
-	error: "### Recent Errors",
-	preference: "### Learned Preferences",
-	context: "### Context Notes",
-	tool_usage: "### Tool Usage Patterns",
-});
-
-/** Section display order (most valuable first). */
-const SECTION_ORDER = ["decision", "pattern", "error", "preference", "context", "tool_usage"];
-
-/** Max observations per group in Layer 1. */
-const MAX_PER_GROUP = 5;
-
-/** Minimum chars remaining to include Layer 2. */
-const LAYER_2_THRESHOLD = 500;
-
-/** Minimum chars remaining to include Layer 3. */
-const LAYER_3_THRESHOLD = 1000;
-
-/**
- * Options for building memory context.
- */
 interface BuildMemoryContextOptions {
 	readonly projectName: string;
 	readonly lastSessionDate: string | null;
-	readonly observations: readonly ScoredObservation[];
 	readonly preferences: readonly Preference[];
+	readonly lessons: readonly {
+		readonly content: string;
+		readonly domain: string;
+		readonly extractedAt: string;
+		readonly sourcePhase: string;
+	}[];
+	readonly recentFailures: readonly ScoredObservation[];
 	readonly tokenBudget?: number;
 }
 
+function appendSection(
+	parts: string[],
+	totalChars: number,
+	charBudget: number,
+	section: string,
+): number {
+	if (totalChars + section.length > charBudget) {
+		return totalChars;
+	}
+	parts.push(section);
+	return totalChars + section.length;
+}
+
 /**
  * Build a markdown memory context string within token budget.
- *
- * Uses 3-layer progressive disclosure:
- * - Layer 1: Summaries grouped by type (always included if budget allows)
- * - Layer 2: Recent Activity timeline (if remaining budget > 500 chars)
- * - Layer 3: Full content for top observations (if remaining budget > 1000 chars)
  */
 export function buildMemoryContext(options: BuildMemoryContextOptions): string {
 	const {
 		projectName,
 		lastSessionDate,
-		observations,
 		preferences,
+		lessons,
+		recentFailures,
 		tokenBudget = DEFAULT_INJECTION_BUDGET,
 	} = options;
 
-	if (observations.length === 0 && preferences.length === 0) return "";
+	if (preferences.length === 0 && lessons.length === 0 && recentFailures.length === 0) {
+		return "";
+	}
 
 	const charBudget = tokenBudget * CHARS_PER_TOKEN;
 	let totalChars = 0;
 	const parts: string[] = [];
 
-	// Header
 	const header = `## Project Memory (auto-injected)\n**Project:** ${projectName}\n**Last session:** ${lastSessionDate ?? "first session"}\n`;
-	if (totalChars + header.length > charBudget) {
+	if (header.length > charBudget) {
 		return header.slice(0, charBudget);
 	}
 	parts.push(header);
 	totalChars += header.length;
 
-	// --- Layer 1: Grouped summaries ---
-	// Sort by relevance within the function to ensure highest-first in each group
-	const sorted = [...observations].sort((a, b) => b.relevanceScore - a.relevanceScore);
-	const grouped = groupByType(sorted);
-
-	for (const type of SECTION_ORDER) {
-		const group = grouped.get(type);
-		if (!group || group.length === 0) continue;
-
-		const sectionHeader = SECTION_HEADERS[type] ?? `### ${type}`;
-		const items = group.slice(0, MAX_PER_GROUP);
-		const lines = items.map((obs) => `- ${obs.summary} (confidence: ${obs.confidence})`);
-		const section = `\n${sectionHeader}\n${lines.join("\n")}\n`;
-
-		if (totalChars + section.length > charBudget) break;
-		parts.push(section);
-		totalChars += section.length;
-	}
-
-	// Preferences section
 	if (preferences.length > 0) {
-		const prefLines = preferences.map((p) => `- **${p.key}:** ${p.value}`);
-		const prefSection = `\n### Preferences\n${prefLines.join("\n")}\n`;
-
-		if (totalChars + prefSection.length <= charBudget) {
-			parts.push(prefSection);
-			totalChars += prefSection.length;
+		const projectPreferences = preferences.filter((preference) => preference.scope === "project");
+		const globalPreferences = preferences.filter((preference) => preference.scope === "global");
+
+		if (projectPreferences.length > 0) {
+			const section = `\n### Confirmed Project Preferences\n${projectPreferences
+				.map(
+					(preference) =>
+						`- **${preference.key}:** ${preference.value} (confidence: ${preference.confidence}, evidence: ${preference.evidenceCount})`,
+				)
+				.join("\n")}\n`;
+			totalChars = appendSection(parts, totalChars, charBudget, section);
 		}
-	}
 
-	// --- Layer 2: Recent Activity timeline (if budget allows) ---
-	const remainingAfterL1 = charBudget - totalChars;
-	if (remainingAfterL1 > LAYER_2_THRESHOLD && observations.length > 0) {
-		const timeline = buildTimeline(observations);
-		if (timeline.length > 0) {
-			const timelineSection = `\n### Recent Activity\n${timeline}\n`;
-			if (totalChars + timelineSection.length <= charBudget) {
-				parts.push(timelineSection);
-				totalChars += timelineSection.length;
-			}
+		if (globalPreferences.length > 0) {
+			const section = `\n### Confirmed User Preferences\n${globalPreferences
+				.map(
+					(preference) =>
+						`- **${preference.key}:** ${preference.value} (confidence: ${preference.confidence}, evidence: ${preference.evidenceCount})`,
+				)
+				.join("\n")}\n`;
+			totalChars = appendSection(parts, totalChars, charBudget, section);
 		}
 	}
 
-	// --- Layer 3: Full content for top observations (if budget allows) ---
-	const remainingAfterL2 = charBudget - totalChars;
-	if (remainingAfterL2 > LAYER_3_THRESHOLD && observations.length > 0) {
-		const topObs = observations.slice(0, 2);
-		const detailLines: string[] = [];
-		const headerOverhead = "\n### Details\n\n".length;
-		let linesBudget = remainingAfterL2 - headerOverhead;
-
-		for (const obs of topObs) {
-			const detail = `**${obs.type}:** ${obs.content}`;
-			const cost = detail.length + 1;
-			if (cost > linesBudget) break;
-			detailLines.push(detail);
-			linesBudget -= cost;
-		}
+	if (lessons.length > 0) {
+		const section = `\n### Recent Lessons\n${lessons
+			.map(
+				(lesson) =>
+					`- ${lesson.content} (${lesson.domain}, ${lesson.sourcePhase.toLowerCase()}, ${lesson.extractedAt.split("T")[0]})`,
+			)
+			.join("\n")}\n`;
+		totalChars = appendSection(parts, totalChars, charBudget, section);
+	}
 
-		if (detailLines.length > 0) {
-			const detailSection = `\n### Details\n${detailLines.join("\n")}\n`;
-			if (totalChars + detailSection.length <= charBudget) {
-				parts.push(detailSection);
-				totalChars += detailSection.length;
-			}
-		}
+	if (recentFailures.length > 0) {
+		const sortedFailures = [...recentFailures].sort((a, b) => b.relevanceScore - a.relevanceScore);
+		const section = `\n### Failure Avoidance Notes\n${sortedFailures
+			.map(
+				(observation) =>
+					`- ${observation.summary} (confidence: ${observation.confidence}, ${observation.createdAt.split("T")[0]})`,
+			)
+			.join("\n")}\n`;
+		totalChars = appendSection(parts, totalChars, charBudget, section);
 	}
 
 	const result = parts.join("");
-	// Final safety truncation
 	return result.length > charBudget ? result.slice(0, charBudget) : result;
 }
 
-/**
- * Group scored observations by type, preserving relevance order within groups.
- */
-function groupByType(
-	observations: readonly ScoredObservation[],
-): ReadonlyMap<string, readonly ScoredObservation[]> {
-	const groups = new Map<string, ScoredObservation[]>();
-
-	for (const obs of observations) {
-		const existing = groups.get(obs.type);
-		if (existing) {
-			existing.push(obs);
-		} else {
-			groups.set(obs.type, [obs]);
-		}
-	}
-
-	return groups;
-}
-
-/**
- * Build a brief timeline of recent sessions from observations.
- */
-function buildTimeline(observations: readonly ScoredObservation[]): string {
-	// Group by session, take last 5 sessions
-	const sessions = new Map<string, { date: string; count: number }>();
-
-	for (const obs of observations) {
-		const existing = sessions.get(obs.sessionId);
-		if (existing) {
-			existing.count++;
-			if (new Date(obs.createdAt).getTime() > new Date(existing.date).getTime()) {
-				existing.date = obs.createdAt;
-			}
-		} else {
-			sessions.set(obs.sessionId, { date: obs.createdAt, count: 1 });
-		}
-	}
-
-	const sorted = [...sessions.values()]
-		.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
-		.slice(0, 5);
-
-	return sorted
-		.map((s) => {
-			const dateStr = s.date.split("T")[0];
-			return `- ${dateStr}: ${s.count} observation${s.count !== 1 ? "s" : ""}`;
-		})
-		.join("\n");
-}
-
 /**
  * Convenience function: retrieve memory context for a project path.
- *
- * Ties together: project lookup, observation retrieval, scoring, preferences, and context building.
  */
 export function retrieveMemoryContext(
 	projectPath: string,
@@ -252,25 +170,24 @@ export function retrieveMemoryContext(
 	const project = getProjectByPath(projectPath, db);
 	if (!project) return "";
 
-	const observations = getObservationsByProject(project.id, 100, db);
-	const scored = scoreAndRankObservations(observations, halfLifeDays);
-	const preferences = getAllPreferences(db);
+	const preferences = getConfirmedPreferencesForProject(project.id, db);
+	const lessons = listRelevantLessons(project.id, 5, db);
+	const failures = scoreAndRankObservations(
+		getRecentFailureObservations(project.id, 5, db),
+		halfLifeDays,
+	);
 
 	const context = buildMemoryContext({
 		projectName: project.name,
 		lastSessionDate: project.lastUpdated,
-		observations: scored,
 		preferences,
+		lessons,
+		recentFailures: failures,
 		tokenBudget,
 	});
 
-	// Batch-update access counts in a single transaction to avoid N+1 writes.
-	// Only observations that could plausibly fit in context are updated.
-	// Best-effort: failures are swallowed to avoid blocking retrieval.
-	const maxInContext = MAX_PER_GROUP * SECTION_ORDER.length;
-	const idsToUpdate = scored
-		.slice(0, maxInContext)
-		.map((obs) => obs.id)
+	const idsToUpdate = failures
+		.map((observation) => observation.id)
 		.filter((id): id is number => id !== undefined);
 	if (idsToUpdate.length > 0) {
 		try {
@@ -280,8 +197,9 @@ export function retrieveMemoryContext(
 				updateAccessCount(id, db);
 			}
 			resolvedDb.run("COMMIT");
-		} catch {
+		} catch (err) {
 			// best-effort — access count update is non-critical
+			logger.warn("access count update failed", { error: String(err) });
 		}
 	}
 

package/src/memory/schemas.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { projectRecordSchema } from "../projects/schemas";
 import { OBSERVATION_TYPES } from "./constants";
 
 export const observationTypeSchema = z.enum(OBSERVATION_TYPES);
@@ -16,19 +17,50 @@ export const observationSchema = z.object({
 	lastAccessed: z.string(),
 });
 
-export const projectSchema = z.object({
-	id: z.string(),
-	path: z.string(),
-	name: z.string(),
-	lastUpdated: z.string(),
-});
+export const projectSchema = projectRecordSchema;
 
-export const preferenceSchema = z.object({
+const preferenceBaseSchema = z.object({
 	id: z.string(),
 	key: z.string().min(1).max(200),
 	value: z.string().min(1).max(2000),
 	confidence: z.number().min(0).max(1).default(0.5),
+	scope: z.enum(["global", "project"]).default("global"),
+	projectId: z.string().nullable().default(null),
+	status: z.enum(["candidate", "confirmed", "rejected"]).default("confirmed"),
+	evidenceCount: z.number().int().min(0).default(0),
 	sourceSession: z.string().nullable().default(null),
 	createdAt: z.string(),
 	lastUpdated: z.string(),
 });
+
+function validatePreferenceScope(value: {
+	scope: "global" | "project";
+	projectId: string | null;
+}): boolean {
+	return (
+		(value.scope === "global" && value.projectId === null) ||
+		(value.scope === "project" && value.projectId !== null)
+	);
+}
+
+export const preferenceSchema = preferenceBaseSchema.refine(validatePreferenceScope, {
+	message: "projectId must be set for project scope and null for global scope",
+	path: ["projectId"],
+});
+
+export const preferenceRecordSchema = preferenceBaseSchema.refine(validatePreferenceScope, {
+	message: "projectId must be set for project scope and null for global scope",
+	path: ["projectId"],
+});
+
+export const preferenceEvidenceSchema = z.object({
+	id: z.string(),
+	preferenceId: z.string().min(1),
+	sessionId: z.string().nullable().default(null),
+	runId: z.string().nullable().default(null),
+	statement: z.string().min(1).max(4000),
+	statementHash: z.string().min(1).max(128),
+	confidence: z.number().min(0).max(1).default(0.5),
+	confirmed: z.boolean().default(false),
+	createdAt: z.string(),
+});

package/src/memory/types.ts

@@ -2,6 +2,8 @@ import type { z } from "zod";
 import type {
 	observationSchema,
 	observationTypeSchema,
+	preferenceEvidenceSchema,
+	preferenceRecordSchema,
 	preferenceSchema,
 	projectSchema,
 } from "./schemas";
@@ -10,3 +12,5 @@ export type ObservationType = z.infer<typeof observationTypeSchema>;
 export type Observation = z.infer<typeof observationSchema>;
 export type Project = z.infer<typeof projectSchema>;
 export type Preference = z.infer<typeof preferenceSchema>;
+export type PreferenceRecord = z.infer<typeof preferenceRecordSchema>;
+export type PreferenceEvidence = z.infer<typeof preferenceEvidenceSchema>;

package/src/observability/context-display.ts

@@ -0,0 +1,8 @@
+export function getContextUtilizationString(usedTokens: number, maxTokens: number): string {
+	const safeMaxTokens = Math.max(0, maxTokens);
+	const safeUsedTokens = Math.max(0, usedTokens);
+	const utilization =
+		safeMaxTokens > 0 ? Math.min(100, Math.round((safeUsedTokens / safeMaxTokens) * 100)) : 0;
+
+	return `[${utilization}% used] ${safeUsedTokens} / ${safeMaxTokens} tokens`;
+}

package/src/observability/event-handlers.ts

@@ -12,12 +12,17 @@
  * @module
  */
 
+import { getLogger } from "../logging/domains";
 import { classifyErrorType, getErrorMessage } from "../orchestrator/fallback/error-classifier";
+import { generateSessionSummary } from "../ux/session-summary";
+import { getContextUtilizationString } from "./context-display";
 import type { ContextMonitor } from "./context-monitor";
 import { emitErrorEvent, emitToolCompleteEvent } from "./event-emitter";
 import type { ObservabilityEvent, SessionEventStore, SessionEvents } from "./event-store";
 import { accumulateTokensFromMessage, createEmptyTokenAggregate } from "./token-tracker";
 
+const logger = getLogger("session", "event-handlers");
+
 /**
  * Dependencies for the observability event handler.
  */
@@ -161,7 +166,6 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 					// Check context utilization
 					const utilResult = contextMonitor.processMessage(sessionId, info.tokens.input);
 					if (utilResult.shouldWarn) {
-						const pct = Math.round(utilResult.utilization * 100);
 						// Append context_warning event
 						const warningEvent: ObservabilityEvent = Object.freeze({
 							type: "context_warning" as const,
@@ -176,10 +180,14 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 						// Fire toast (per D-35)
 						showToast(
 							"Context Warning",
-							`Context at ${pct}% -- consider compacting`,
+							getContextUtilizationString(info.tokens.input, 200000),
 							"warning",
 						).catch((err) => {
-							console.error("[opencode-autopilot]", err);
+							logger.error("showToast failed for context warning", {
+								operation: "context_warning",
+								sessionId,
+								error: String(err),
+							});
 						});
 					}
 				}
@@ -190,11 +198,17 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 				const sessionId = extractSessionId(properties);
 				if (!sessionId) return;
 
-				// Snapshot to disk (fire-and-forget per Pitfall 2) — session continues
-				const sessionData = eventStore.getSession(sessionId);
-				writeSessionLog(sessionData).catch((err) => {
-					console.error("[opencode-autopilot]", err);
-				});
+				// Persist only new events since the last flush.
+				const sessionData = eventStore.getUnpersistedSession(sessionId);
+				if (sessionData && sessionData.events.length > 0) {
+					writeSessionLog(sessionData).catch((err) => {
+						logger.error("writeSessionLog failed on session.idle", {
+							operation: "session_end",
+							sessionId,
+							error: String(err),
+						});
+					});
+				}
 				return;
 			}
 
@@ -202,11 +216,43 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 				const sessionId = extractSessionId(properties);
 				if (!sessionId) return;
 
+				eventStore.appendEvent(sessionId, {
+					type: "session_end",
+					timestamp: new Date().toISOString(),
+					sessionId,
+					durationMs: 0,
+					totalCost: 0,
+				});
+
+				const summary = generateSessionSummary(eventStore.getSession(sessionId), null);
+				logger.info(`Session ended summary:\n${summary}`, {
+					operation: "session_end",
+					sessionId,
+				});
+
+				void showToast(
+					"Session ended",
+					"Run /oc_summary to view the session summary.",
+					"info",
+				).catch((err) => {
+					logger.error("showToast failed for session end", {
+						operation: "session_end",
+						sessionId,
+						error: String(err),
+					});
+				});
+
 				// Final flush — session is done, remove from store
 				const sessionData = eventStore.flush(sessionId);
-				writeSessionLog(sessionData).catch((err) => {
-					console.error("[opencode-autopilot]", err);
-				});
+				if (sessionData && sessionData.events.length > 0) {
+					writeSessionLog(sessionData).catch((err) => {
+						logger.error("writeSessionLog failed on session.deleted", {
+							operation: "session_end",
+							sessionId,
+							error: String(err),
+						});
+					});
+				}
 
 				// Clean up context monitor
 				contextMonitor.cleanup(sessionId);
@@ -219,21 +265,24 @@ export function createObservabilityEventHandler(deps: ObservabilityHandlerDeps)
 
 				// Append compaction decision event (not session_start)
 				const compactEvent: ObservabilityEvent = Object.freeze({
-					type: "decision" as const,
+					type: "compacted" as const,
 					timestamp: new Date().toISOString(),
 					sessionId,
-					phase: "COMPACT",
-					agent: "system",
-					decision: "Session compacted",
-					rationale: "Context window compaction triggered",
+					trigger: "context_window",
 				});
 				eventStore.appendEvent(sessionId, compactEvent);
 
 				// Snapshot to disk — session continues after compaction
-				const sessionData = eventStore.getSession(sessionId);
-				writeSessionLog(sessionData).catch((err) => {
-					console.error("[opencode-autopilot]", err);
-				});
+				const sessionData = eventStore.getUnpersistedSession(sessionId);
+				if (sessionData && sessionData.events.length > 0) {
+					writeSessionLog(sessionData).catch((err) => {
+						logger.error("writeSessionLog failed on session.compacted", {
+							operation: "compacted",
+							sessionId,
+							error: String(err),
+						});
+					});
+				}
 				return;
 			}
 

package/src/observability/event-store.ts

@@ -81,6 +81,12 @@ export type ObservabilityEvent =
 			readonly fromPhase: string;
 			readonly toPhase: string;
 	  }
+	| {
+			readonly type: "compacted";
+			readonly timestamp: string;
+			readonly sessionId: string;
+			readonly trigger: string;
+	  }
 	| { readonly type: "session_start"; readonly timestamp: string; readonly sessionId: string }
 	| {
 			readonly type: "session_end";
@@ -118,6 +124,7 @@ export interface SessionEvents {
 interface MutableSessionData {
 	sessionId: string;
 	events: ObservabilityEvent[];
+	persistedEventCount: number;
 	tokens: TokenAggregate;
 	toolMetrics: Map<string, ToolMetrics>;
 	currentPhase: string | null;
@@ -138,6 +145,7 @@ export class SessionEventStore {
 		this.sessions.set(sessionId, {
 			sessionId,
 			events: [],
+			persistedEventCount: 0,
 			tokens: createEmptyTokenAggregate(),
 			toolMetrics: new Map(),
 			currentPhase: null,
@@ -213,11 +221,31 @@ export class SessionEventStore {
 		};
 	}
 
+	/**
+	 * Returns only events not yet persisted and marks them as persisted.
+	 */
+	getUnpersistedSession(sessionId: string): SessionEvents | undefined {
+		const session = this.sessions.get(sessionId);
+		if (!session) return undefined;
+
+		const events = session.events.slice(session.persistedEventCount);
+		session.persistedEventCount = session.events.length;
+
+		return {
+			sessionId: session.sessionId,
+			events,
+			tokens: session.tokens,
+			toolMetrics: new Map(session.toolMetrics),
+			currentPhase: session.currentPhase,
+			startedAt: session.startedAt,
+		};
+	}
+
 	/**
 	 * Returns session data and removes it from the store (for disk flush).
 	 */
 	flush(sessionId: string): SessionEvents | undefined {
-		const session = this.getSession(sessionId);
+		const session = this.getUnpersistedSession(sessionId);
 		if (session) {
 			this.sessions.delete(sessionId);
 		}