@agentuity/opencode 1.0.14 → 1.0.16

package/src/plugin/hooks/session-memory.ts

@@ -1,23 +1,18 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import type { CoderConfig } from '../../types';
 import type { BackgroundManager } from '../../background';
-
-/**
- * Get the current git branch name.
- */
-async function getCurrentBranch(): Promise<string> {
-	try {
-		const proc = Bun.spawn(['git', 'branch', '--show-current'], {
-			stdout: 'pipe',
-			stderr: 'pipe',
-		});
-		const stdout = await new Response(proc.stdout).text();
-		await proc.exited;
-		return stdout.trim() || 'unknown';
-	} catch {
-		return 'unknown';
-	}
-}
+import type { OpenCodeDBReader } from '../../sqlite';
+import type { CompactionStats } from '../../sqlite/types';
+import {
+	getCurrentBranch,
+	buildCustomCompactionPrompt,
+	fetchAndFormatPlanningState,
+	getImageDescriptions,
+	getRecentToolCallSummaries,
+	storePreCompactionSnapshot,
+	formatCompactionDiagnostics,
+	countListItems,
+} from './compaction-utils';
 
 export interface SessionMemoryHooks {
 	onEvent: (input: {
@@ -38,8 +33,9 @@ export interface SessionMemoryHooks {
  */
 export function createSessionMemoryHooks(
 	ctx: PluginInput,
-	_config: CoderConfig,
-	backgroundManager?: BackgroundManager
+	config: CoderConfig,
+	backgroundManager?: BackgroundManager,
+	dbReader?: OpenCodeDBReader
 ): SessionMemoryHooks {
 	const log = (msg: string) => {
 		ctx.client.app.log({
@@ -144,7 +140,8 @@ Then continue with the current task if there is one.`,
 
 		/**
 		 * Inject Memory system info during compaction.
-		 * This gets included in OpenCode's generated summary.
+		 * Uses output.prompt to REPLACE the default compaction prompt with
+		 * enriched context (planning state, images, tool calls, diagnostics).
 		 */
 		async onCompacting(
 			input: { sessionID: string },
@@ -153,12 +150,43 @@ Then continue with the current task if there is one.`,
 			const sessionId = input.sessionID;
 			log(`Compacting session ${sessionId}`);
 
-			// Get current git branch
-			const branch = await getCurrentBranch();
+			// Config flags for compaction behavior
+			const compactionCfg = config?.compaction ?? {};
+			const useCustomPrompt = compactionCfg.customPrompt !== false;
+			const useInlinePlanning = compactionCfg.inlinePlanning !== false;
+			const useImageAwareness = compactionCfg.imageAwareness !== false;
+			const useSnapshotToKV = compactionCfg.snapshotToKV !== false;
+			const maxTokens = compactionCfg.maxContextTokens ?? 4000;
+
+			// 1. Build custom compaction instructions
+			const instructions = useCustomPrompt ? buildCustomCompactionPrompt('regular') : null;
+
+			// 2. Gather enrichment data in parallel
+			const toolCallLimit = config?.compaction?.toolCallSummaryLimit ?? 5;
+			const [branch, planningState, imageDescs, toolSummaries] = await Promise.all([
+				getCurrentBranch(),
+				useInlinePlanning ? fetchAndFormatPlanningState(sessionId) : Promise.resolve(null),
+				useImageAwareness
+					? Promise.resolve(getImageDescriptions(dbReader ?? null, sessionId))
+					: Promise.resolve(null),
+				Promise.resolve(getRecentToolCallSummaries(dbReader ?? null, sessionId, toolCallLimit)),
+			]);
+
+			// 3. Build session state section
+			const sessionStateSection = `## Session Memory
+
+This session's context is being saved to persistent memory.
+Session record location: \`session:${sessionId}\` in agentuity-opencode-memory
+Current branch: ${branch}
 
-			// Get active background tasks for this session
+After compaction:
+1. Memory will save this summary to the session record
+2. If planning is active, Memory should update planning.progress with this compaction
+3. Memory will apply inline reasoning if significant patterns/corrections emerged`;
+
+			// 4. Build background tasks section
 			const tasks = backgroundManager?.getTasksByParent(sessionId) ?? [];
-			let backgroundTaskContext = '';
+			let backgroundSection: string | null = null;
 
 			if (tasks.length > 0) {
 				const taskList = tasks
@@ -168,38 +196,72 @@ Then continue with the current task if there is one.`,
 					)
 					.join('\n');
 
-				backgroundTaskContext = `
-
-## Active Background Tasks
+				backgroundSection = `## Active Background Tasks
 
 This session has ${tasks.length} background task(s) running in separate sessions:
 ${taskList}
 
 **CRITICAL:** Task IDs and session IDs persist across compaction - these tasks are still running.
-Use \`agentuity_background_output({ task_id: "..." })\` to check their status.
-`;
+Use \`agentuity_background_output({ task_id: "..." })\` to check their status.`;
 			}
 
-			output.context.push(`
-## Session Memory
+			// 5. Combine everything into the full prompt
+			const sections: string[] = [];
+			if (instructions) sections.push(instructions);
+			sections.push(sessionStateSection);
+			if (backgroundSection) sections.push(backgroundSection);
+			if (planningState) sections.push(planningState);
+			if (imageDescs) sections.push(imageDescs);
+			if (toolSummaries) sections.push(toolSummaries);
+
+			// 6. Add diagnostics
+			const stats: CompactionStats = {
+				planningPhasesCount: countListItems(planningState),
+				backgroundTasksCount: tasks.length,
+				imageDescriptionsCount: countListItems(imageDescs),
+				toolCallSummariesCount: countListItems(toolSummaries),
+				estimatedTokens: Math.ceil(sections.join('\n\n').length / 4),
+			};
+			const diagnostics = formatCompactionDiagnostics(stats);
+			if (diagnostics) sections.push(diagnostics);
+
+			// 7. Enforce token budget
+			let fullPrompt = sections.join('\n\n');
+			const estimatedTokens = Math.ceil(fullPrompt.length / 4);
+			if (maxTokens > 0 && estimatedTokens > maxTokens) {
+				// Trim least-critical sections first
+				const trimOrder = [diagnostics, toolSummaries, imageDescs, planningState].filter(
+					Boolean
+				);
+				let trimmed = [...sections];
+				for (const candidate of trimOrder) {
+					if (Math.ceil(trimmed.join('\n\n').length / 4) <= maxTokens) break;
+					trimmed = trimmed.filter((s) => s !== candidate);
+				}
+				fullPrompt = trimmed.join('\n\n');
+			}
 
-This session's context is being saved to persistent memory.
-Session record location: \`session:${sessionId}\` in agentuity-opencode-memory
-Current branch: ${branch}
+			// 8. Set the full prompt or push to context
+			if (useCustomPrompt) {
+				output.prompt = fullPrompt;
+			} else {
+				output.context.push(fullPrompt);
+			}
 
-**Planning State (if active):**
-If this session has planning active (user requested "track progress" or similar), the session record contains:
-- \`planning.prdKey\` - Link to PRD if one exists
-- \`planning.objective\` - What we're trying to accomplish
-- \`planning.phases\` - Current phases with status and notes
-- \`planning.findings\` - Discoveries made during work
-- \`planning.errors\` - Failures to avoid repeating
-${backgroundTaskContext}
-After compaction:
-1. Memory will save this summary to the session record
-2. If planning is active, Memory should update planning.progress with this compaction
-3. Memory will apply inline reasoning if significant patterns/corrections emerged
-`);
+			// 9. Store pre-compaction snapshot to KV (fire-and-forget)
+			if (useSnapshotToKV) {
+				storePreCompactionSnapshot(sessionId, {
+					timestamp: new Date().toISOString(),
+					sessionId,
+					planningState: planningState ? { raw: planningState } : undefined,
+					backgroundTasks: tasks.map((t) => ({
+						id: t.id,
+						description: t.description || 'No description',
+						status: t.status,
+					})),
+					branch,
+				}).catch(() => {}); // Fire and forget
+			}
 		},
 	};
 }

package/src/plugin/plugin.ts

@@ -92,10 +92,14 @@ export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 	const resolvedDbPath = resolveOpenCodeDBPath();
 	const dbReader = new OpenCodeDBReader(resolvedDbPath ? { dbPath: resolvedDbPath } : undefined);
 
+	// Shared Map: chat.params stores the user's message text per session,
+	// chat.message reads it for trigger detection (avoids scanning model output).
+	const lastUserMessages = new Map<string, string>();
+
 	const sessionHooks = createSessionHooks(ctx, coderConfig);
 	const toolHooks = createToolHooks(ctx, coderConfig);
 	const keywordHooks = createKeywordHooks(ctx, coderConfig);
-	const paramsHooks = createParamsHooks(ctx, coderConfig);
+	const paramsHooks = createParamsHooks(ctx, coderConfig, lastUserMessages);
 	const tmuxManager = coderConfig.tmux?.enabled
 		? new TmuxSessionManager(ctx, coderConfig.tmux, {
 				onLog: (message) =>
@@ -157,11 +161,22 @@ export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 		});
 
 	// Create hooks that need backgroundManager for task reference injection during compaction
-	const cadenceHooks = createCadenceHooks(ctx, coderConfig, backgroundManager, dbReader);
+	const cadenceHooks = createCadenceHooks(
+		ctx,
+		coderConfig,
+		backgroundManager,
+		dbReader,
+		lastUserMessages
+	);
 
 	// Session memory hooks handle checkpointing and compaction for non-Cadence sessions
 	// Orchestration (deciding which module handles which session) happens below in the hooks
-	const sessionMemoryHooks = createSessionMemoryHooks(ctx, coderConfig, backgroundManager);
+	const sessionMemoryHooks = createSessionMemoryHooks(
+		ctx,
+		coderConfig,
+		backgroundManager,
+		dbReader
+	);
 
 	const configHandler = createConfigHandler(coderConfig);
 
@@ -230,16 +245,28 @@ export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 			}
 			// Orchestrate: route to appropriate module based on session type
 			const sessionId = extractSessionIdFromEvent(input);
-			if (sessionId && cadenceHooks.isActiveCadenceSession(sessionId)) {
-				await cadenceHooks.onEvent(input);
-			} else if (sessionId) {
-				// Non-Cadence sessions - handle session.compacted for checkpointing
-				await sessionMemoryHooks.onEvent(
-					input as { event: { type: string; properties?: Record<string, unknown> } }
-				);
+			if (sessionId) {
+				// Try lazy restore from KV if not in memory (survives plugin restarts)
+				if (!cadenceHooks.isActiveCadenceSession(sessionId)) {
+					await cadenceHooks.tryRestoreFromKV(sessionId);
+				}
+
+				if (cadenceHooks.isActiveCadenceSession(sessionId)) {
+					await cadenceHooks.onEvent(input);
+				} else {
+					// Non-Cadence sessions - handle session.compacted for checkpointing
+					await sessionMemoryHooks.onEvent(
+						input as { event: { type: string; properties?: Record<string, unknown> } }
+					);
+				}
 			}
 		},
 		'experimental.session.compacting': async (input, output) => {
+			// Try lazy restore from KV if not in memory (survives plugin restarts)
+			if (!cadenceHooks.isActiveCadenceSession(input.sessionID)) {
+				await cadenceHooks.tryRestoreFromKV(input.sessionID);
+			}
+
 			// Orchestrate: route to appropriate module based on session type
 			if (cadenceHooks.isActiveCadenceSession(input.sessionID)) {
 				await cadenceHooks.onCompacting(input, output);
@@ -318,6 +345,16 @@ function createConfigHandler(
 			};
 		}
 
+		// Compaction config: increase reserved token buffer to accommodate our enriched
+		// compaction prompts (planning state, image descriptions, tool summaries, diagnostics).
+		// Default OpenCode reserved buffer is too small for the context we inject.
+		const existingCompaction = (config.compaction ?? {}) as Record<string, unknown>;
+		const existingReserved = existingCompaction.reserved;
+		config.compaction = {
+			...existingCompaction,
+			reserved: typeof existingReserved === 'number' ? existingReserved : 40_000,
+		};
+
 		config.command = {
 			...(config.command as Record<string, CommandDefinition> | undefined),
 			...commands,

package/src/sqlite/index.ts

@@ -1,13 +1,17 @@
 export { OpenCodeDBReader } from './reader';
 export type {
+	CompactionStats,
 	DBMessage,
+	DBNonTextPart,
 	DBPart,
 	DBSession,
 	DBTextPart,
 	DBTodo,
 	DBToolCall,
+	DBToolCallSummary,
 	MessageTokens,
 	OpenCodeDBConfig,
+	PreCompactionSnapshot,
 	SessionCostSummary,
 	SessionStatus,
 	SessionSummary,

package/src/sqlite/queries.ts

@@ -47,4 +47,9 @@ export const QUERIES = {
 	SEARCH_SESSIONS: `SELECT id, project_id, parent_id, slug, directory, title, version, share_url, summary_additions, summary_deletions, summary_files, summary_diffs, time_created, time_updated, time_compacting, time_archived FROM session WHERE title LIKE ? COLLATE NOCASE ORDER BY time_updated DESC`,
 
 	SEARCH_SESSIONS_LIMITED: `SELECT id, project_id, parent_id, slug, directory, title, version, share_url, summary_additions, summary_deletions, summary_files, summary_diffs, time_created, time_updated, time_compacting, time_archived FROM session WHERE title LIKE ? COLLATE NOCASE ORDER BY time_updated DESC LIMIT ?`,
+
+	GET_NON_TEXT_PARTS: `SELECT * FROM part WHERE session_id = ?
+		AND json_valid(data)
+		AND json_extract(data, '$.type') != 'text'
+		ORDER BY time_created DESC LIMIT ?`,
 } as const;

package/src/sqlite/reader.ts

@@ -5,10 +5,12 @@ import { join } from 'node:path';
 import { QUERIES } from './queries';
 import type {
 	DBMessage,
+	DBNonTextPart,
 	DBSession,
 	DBTextPart,
 	DBTodo,
 	DBToolCall,
+	DBToolCallSummary,
 	MessageTokens,
 	OpenCodeDBConfig,
 	SessionCostSummary,
@@ -226,6 +228,39 @@ function mapTextPart(row: PartRow): DBTextPart | null {
 	};
 }
 
+function mapNonTextPart(row: PartRow): DBNonTextPart | null {
+	const payload = safeParseJSON<PartData>(row.data);
+	if (!payload || !payload.type || payload.type === 'text') return null;
+
+	return {
+		id: row.id,
+		messageId: row.message_id,
+		type: payload.type,
+		toolName: payload.tool,
+		timestamp: new Date(row.time_created).toISOString(),
+	};
+}
+
+function mapToolCallSummary(row: PartRow): DBToolCallSummary | null {
+	const payload = safeParseJSON<PartData>(row.data);
+	if (!payload || (payload.type !== 'tool' && payload.type !== 'tool-invocation')) return null;
+
+	const state = payload.state ?? {};
+	const inputStr =
+		state.input !== undefined ? String(JSON.stringify(state.input)).slice(0, 200) : undefined;
+	const outputStr =
+		state.output !== undefined ? String(JSON.stringify(state.output)).slice(0, 200) : undefined;
+
+	return {
+		id: row.id,
+		messageId: row.message_id,
+		toolName: payload.tool ?? 'unknown',
+		input: inputStr,
+		output: outputStr,
+		timestamp: new Date(row.time_created).toISOString(),
+	};
+}
+
 function isNotNull<T>(value: T | null): value is T {
 	return value !== null;
 }
@@ -475,6 +510,40 @@ export class OpenCodeDBReader {
 		}
 	}
 
+	/**
+	 * Get non-text parts (images, files, tool calls) for a session.
+	 * Useful for describing attachments during compaction.
+	 */
+	getNonTextParts(sessionId: string): DBNonTextPart[] {
+		if (!this.ensureOpen()) return [];
+
+		try {
+			const statement = this.getStatement('GET_NON_TEXT_PARTS');
+			const rows = statement?.all(sessionId, DEFAULT_LIMIT) as PartRow[] | null;
+			return rows ? rows.map(mapNonTextPart).filter(isNotNull) : [];
+		} catch (error) {
+			console.warn('[OpenCodeDBReader] Failed to get non-text parts', error);
+			return [];
+		}
+	}
+
+	/**
+	 * Get recent tool calls for a session (newest first).
+	 * Returns concise summaries for compaction context.
+	 */
+	getRecentToolCalls(sessionId: string, limit: number = 5): DBToolCallSummary[] {
+		if (!this.ensureOpen()) return [];
+
+		try {
+			const statement = this.getStatement('GET_TOOL_HISTORY');
+			const rows = statement?.all(sessionId, limit) as PartRow[] | null;
+			return rows ? rows.map(mapToolCallSummary).filter(isNotNull) : [];
+		} catch (error) {
+			console.warn('[OpenCodeDBReader] Failed to get recent tool calls', error);
+			return [];
+		}
+	}
+
 	getTodos(sessionId: string): DBTodo[] {
 		if (!this.ensureOpen()) return [];
 

package/src/sqlite/types.ts

@@ -119,3 +119,43 @@ export interface OpenCodeDBConfig {
 	dbPath?: string;
 	enableSchemaValidation?: boolean;
 }
+
+/** Non-text message part (image, file attachment, etc.) */
+export interface DBNonTextPart {
+	id: string;
+	messageId: string;
+	type: string;
+	toolName?: string;
+	timestamp?: string;
+}
+
+/** Tool call summary for compaction context */
+export interface DBToolCallSummary {
+	id: string;
+	messageId: string;
+	toolName: string;
+	input?: string;
+	output?: string;
+	timestamp: string;
+}
+
+/** Stats about what compaction preserved */
+export interface CompactionStats {
+	planningPhasesCount: number;
+	backgroundTasksCount: number;
+	imageDescriptionsCount: number;
+	toolCallSummariesCount: number;
+	estimatedTokens: number;
+}
+
+/** Pre-compaction state snapshot stored to KV */
+export interface PreCompactionSnapshot {
+	timestamp: string;
+	sessionId: string;
+	planningState?: Record<string, unknown>;
+	backgroundTasks?: Array<{ id: string; description: string; status: string }>;
+	imageDescriptions?: string[];
+	toolCallSummaries?: string[];
+	cadenceState?: Record<string, unknown>;
+	branch?: string;
+}

package/src/tools/background.ts

@@ -33,6 +33,7 @@ export function createBackgroundTools(manager: BackgroundManager): {
 			context: ToolContext
 		) => Promise<{
 			taskId: string;
+			sessionId?: string;
 			status: string;
 			message: string;
 		}>;
@@ -43,6 +44,7 @@ export function createBackgroundTools(manager: BackgroundManager): {
 		args: typeof BackgroundOutputArgsSchema;
 		execute: (args: BackgroundOutputArgs) => Promise<{
 			taskId: string;
+			sessionId?: string;
 			status: string;
 			result?: string;
 			error?: string;
@@ -68,6 +70,7 @@ export function createBackgroundTools(manager: BackgroundManager): {
 			context: ToolContext
 		): Promise<{
 			taskId: string;
+			sessionId?: string;
 			status: string;
 			message: string;
 		}> {
@@ -82,6 +85,7 @@ export function createBackgroundTools(manager: BackgroundManager): {
 
 			return {
 				taskId: task.id,
+				sessionId: task.sessionId,
 				status: task.status,
 				message:
 					task.status === 'error'
@@ -97,6 +101,7 @@ export function createBackgroundTools(manager: BackgroundManager): {
 		args: BackgroundOutputArgsSchema,
 		async execute(args: BackgroundOutputArgs): Promise<{
 			taskId: string;
+			sessionId?: string;
 			status: string;
 			result?: string;
 			error?: string;
@@ -111,6 +116,7 @@ export function createBackgroundTools(manager: BackgroundManager): {
 			}
 			return {
 				taskId: task.id,
+				sessionId: task.sessionId,
 				status: task.status,
 				result: task.result,
 				error: task.error,

package/src/types.ts

@@ -151,6 +151,24 @@ export const AgentModelConfigSchema = z.object({
 	maxSteps: z.number().optional(),
 });
 
+/** Configuration for compaction behavior */
+export interface CompactionConfig {
+	/** Use custom compaction prompt tailored to our agent system (default: true) */
+	customPrompt?: boolean;
+	/** Inline planning state from KV into compaction context (default: true) */
+	inlinePlanning?: boolean;
+	/** Detect and describe images/attachments (default: true) */
+	imageAwareness?: boolean;
+	/** Number of recent tool calls to summarize (default: 5, 0 to disable) */
+	toolCallSummaryLimit?: number;
+	/** Store pre-compaction snapshot to KV for recovery (default: true) */
+	snapshotToKV?: boolean;
+	/** Max tokens budget for ALL injected compaction context combined (default: 4000) */
+	maxContextTokens?: number;
+	/** Reserved token buffer for compaction prompts (default: 40000). Must not exceed OpenCode's max context window. */
+	reserved?: number;
+}
+
 export interface CoderConfig {
 	org?: string;
 	disabledMcps?: string[];
@@ -159,6 +177,7 @@ export interface CoderConfig {
 	background?: BackgroundTaskConfig;
 	skills?: SkillsConfig;
 	tmux?: TmuxConfig;
+	compaction?: CompactionConfig;
 }
 
 export const BackgroundTaskConfigSchema = z.object({
@@ -182,6 +201,16 @@ export const TmuxConfigSchema = z.object({
 	agentPaneMinWidth: z.number(),
 });
 
+export const CompactionConfigSchema = z.object({
+	customPrompt: z.boolean().optional(),
+	inlinePlanning: z.boolean().optional(),
+	imageAwareness: z.boolean().optional(),
+	toolCallSummaryLimit: z.number().optional(),
+	snapshotToKV: z.boolean().optional(),
+	maxContextTokens: z.number().optional(),
+	reserved: z.number().optional(),
+});
+
 export const CoderConfigSchema = z.object({
 	org: z.string().optional(),
 	disabledMcps: z.array(z.string()).optional(),
@@ -189,6 +218,7 @@ export const CoderConfigSchema = z.object({
 	background: BackgroundTaskConfigSchema.optional(),
 	skills: SkillsConfigSchema.optional(),
 	tmux: TmuxConfigSchema.optional(),
+	compaction: CompactionConfigSchema.optional(),
 });
 
 export interface McpConfig {