@agentuity/opencode 1.0.15 → 1.0.16

package/src/plugin/hooks/compaction-utils.ts

@@ -0,0 +1,291 @@
+import type { OpenCodeDBReader } from '../../sqlite/reader';
+import type { CompactionStats, DBNonTextPart, PreCompactionSnapshot } from '../../sqlite/types';
+
+/**
+ * Get the current git branch name.
+ * Moved here from cadence.ts and session-memory.ts to deduplicate.
+ */
+export 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';
+	}
+}
+
+/**
+ * Access Agentuity KV storage via CLI.
+ * All calls are wrapped in try/catch — returns null on failure.
+ */
+async function kvGet(namespace: string, key: string): Promise<unknown | null> {
+	try {
+		const proc = Bun.spawn(['agentuity', 'cloud', 'kv', 'get', namespace, key, '--json'], {
+			stdout: 'pipe',
+			stderr: 'pipe',
+		});
+		const output = await new Response(proc.stdout).text();
+		const exitCode = await proc.exited;
+		if (exitCode !== 0) return null;
+		return JSON.parse(output);
+	} catch {
+		return null;
+	}
+}
+
+async function kvSet(namespace: string, key: string, value: unknown): Promise<boolean> {
+	try {
+		const proc = Bun.spawn(
+			['agentuity', 'cloud', 'kv', 'set', namespace, key, JSON.stringify(value)],
+			{ stdout: 'pipe', stderr: 'pipe' }
+		);
+		const exitCode = await proc.exited;
+		return exitCode === 0;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Build the custom compaction prompt for our agent system.
+ * This REPLACES the default OpenCode compaction prompt via output.prompt.
+ */
+export function buildCustomCompactionPrompt(mode: 'cadence' | 'regular'): string {
+	const cadenceSection =
+		mode === 'cadence'
+			? `
+
+## Cadence Loop State
+- Loop ID, iteration number, max iterations
+- Current phase and what's in progress
+- Whether this is a Lead-of-Leads session with child tasks`
+			: '';
+
+	return `You are generating a continuation context for a multi-agent coding system (Agentuity Coder). Your summary will be the ONLY context the orchestrating Lead agent has after this compaction. Preserve everything needed for seamless continuation.
+
+## CRITICAL — Preserve These Verbatim
+1. The current task/objective (quote the user's original request exactly)
+2. All background task IDs (bg_xxx) with status, purpose, and session IDs
+3. Active planning state: current phase, completed phases, next steps, blockers
+4. ALL file paths being actively worked on (with role: created/modified/read)
+5. Key decisions made and their rationale
+6. Any corrections or gotchas discovered during the session
+7. Todo list state (what's done, in progress, pending)
+8. Descriptions of any images or attachments that appeared in conversation${cadenceSection}
+
+## Structure Your Summary As:
+
+### Active Task
+[Verbatim objective + what the agent was doing when compaction fired]
+
+### Planning State
+[Phases with status. Include phase notes, not just titles.]
+
+### Background Tasks
+[bg_xxx: description → status (running/completed/errored). Include session IDs.]
+
+### Key Context
+[Decisions, constraints, user preferences, corrections discovered]
+
+### Active Files
+[filepath → role (creating/modifying/reading) + what's being done to it]
+
+### Images & Attachments
+[Describe any images/screenshots: what they showed, when they appeared, why they mattered]
+
+### Next Steps
+[What should happen immediately after compaction resumes]
+
+## Rules
+- Use specific file paths, task IDs, phase names — NOT vague references.
+- State what tools returned, not just that they were called.
+- NEVER drop background task references — the agent MUST know what's still running.
+- Prefer completeness over brevity — this is the agent's entire working memory.`;
+}
+
+/**
+ * Fetch planning state from KV and format as markdown.
+ * Returns null if KV is unavailable or no planning state exists.
+ */
+export async function fetchAndFormatPlanningState(sessionId: string): Promise<string | null> {
+	try {
+		const record = await kvGet('agentuity-opencode-memory', `session:${sessionId}`);
+		if (!record || typeof record !== 'object') return null;
+
+		const data = (record as Record<string, unknown>).data ?? record;
+		const planning = (data as Record<string, unknown>).planning as
+			| Record<string, unknown>
+			| undefined;
+		if (!planning) return null;
+
+		const lines: string[] = ['## Planning State (from KV)'];
+		if (planning.objective) lines.push(`**Objective:** ${planning.objective}`);
+		if (planning.current) lines.push(`**Current:** ${planning.current}`);
+		if (planning.next) lines.push(`**Next:** ${planning.next}`);
+
+		const phases = planning.phases as Array<Record<string, unknown>> | undefined;
+		if (phases?.length) {
+			lines.push('', '### Phases:');
+			for (const p of phases) {
+				const status = p.status ?? 'unknown';
+				const title = p.title ?? p.content ?? 'untitled';
+				const notes = p.notes ? ` — ${String(p.notes).slice(0, 100)}` : '';
+				lines.push(`- [${status}] ${title}${notes}`);
+			}
+		}
+
+		const findings = planning.findings as string[] | undefined;
+		if (findings?.length) {
+			lines.push('', '### Key Findings:');
+			for (const f of findings.slice(0, 5)) {
+				lines.push(`- ${String(f).slice(0, 150)}`);
+			}
+		}
+
+		const errors = planning.errors as string[] | undefined;
+		if (errors?.length) {
+			lines.push('', '### Errors to Avoid:');
+			for (const e of errors.slice(0, 3)) {
+				lines.push(`- ${String(e).slice(0, 150)}`);
+			}
+		}
+
+		return lines.join('\n');
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get image/attachment descriptions from SQLite for compaction context.
+ * Returns brief metadata about non-text parts in the conversation.
+ */
+export function getImageDescriptions(
+	dbReader: OpenCodeDBReader | null,
+	sessionId: string
+): string | null {
+	if (!dbReader?.isAvailable()) return null;
+
+	try {
+		const parts = dbReader.getNonTextParts(sessionId);
+		if (!parts.length) return null;
+
+		// Filter to image-like parts (not tool calls — those are separate)
+		const imageParts = parts.filter(
+			(p: DBNonTextPart) => !['tool-invocation', 'tool-result', 'text'].includes(p.type)
+		);
+		if (!imageParts.length) return null;
+
+		const lines: string[] = ['## Images & Attachments'];
+		for (const part of imageParts.slice(0, 10)) {
+			const when = part.timestamp ? ` at ${part.timestamp}` : '';
+			lines.push(`- [${part.type}]${when}: message ${part.messageId}`);
+		}
+		return lines.join('\n');
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get recent tool call summaries for compaction context.
+ * CONCISE — capped at limit calls, brief descriptions only.
+ */
+export function getRecentToolCallSummaries(
+	dbReader: OpenCodeDBReader | null,
+	sessionId: string,
+	limit: number = 5
+): string | null {
+	if (!dbReader?.isAvailable() || limit <= 0) return null;
+
+	try {
+		const calls = dbReader.getRecentToolCalls(sessionId, limit);
+		if (!calls.length) return null;
+
+		const lines: string[] = ['## Recent Tool Activity'];
+		for (const call of calls) {
+			const inputBrief = call.input ? ` — ${String(call.input).slice(0, 80)}` : '';
+			const outputBrief = call.output ? ` → ${String(call.output).slice(0, 80)}` : '';
+			lines.push(`- ${call.toolName}${inputBrief}${outputBrief}`);
+		}
+		return lines.join('\n');
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Store a pre-compaction snapshot to KV as a recovery mechanism.
+ */
+export async function storePreCompactionSnapshot(
+	sessionId: string,
+	snapshot: PreCompactionSnapshot
+): Promise<void> {
+	try {
+		await kvSet('agentuity-opencode-memory', `compaction:snapshot:${sessionId}`, snapshot);
+	} catch {
+		// Silently fail — this is a best-effort recovery mechanism
+	}
+}
+
+/**
+ * Persist Cadence session state to KV for recovery after plugin restart.
+ */
+export async function persistCadenceStateToKV(
+	sessionId: string,
+	state: Record<string, unknown>
+): Promise<void> {
+	try {
+		await kvSet('agentuity-opencode-memory', `cadence:active:${sessionId}`, state);
+	} catch {
+		// Silently fail
+	}
+}
+
+/**
+ * Restore Cadence session state from KV.
+ */
+export async function restoreCadenceStateFromKV(
+	sessionId: string
+): Promise<Record<string, unknown> | null> {
+	try {
+		const state = await kvGet('agentuity-opencode-memory', `cadence:active:${sessionId}`);
+		return state as Record<string, unknown> | null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Format compaction diagnostics — brief summary of what was preserved.
+ */
+export function formatCompactionDiagnostics(stats: CompactionStats): string {
+	const parts: string[] = [];
+	if (stats.planningPhasesCount > 0) parts.push(`${stats.planningPhasesCount} planning phases`);
+	if (stats.backgroundTasksCount > 0) parts.push(`${stats.backgroundTasksCount} background tasks`);
+	if (stats.imageDescriptionsCount > 0) parts.push(`${stats.imageDescriptionsCount} image refs`);
+	if (stats.toolCallSummariesCount > 0) parts.push(`${stats.toolCallSummariesCount} tool calls`);
+
+	if (!parts.length) return '';
+	return `> **Compaction preserved:** ${parts.join(', ')} (~${stats.estimatedTokens} tokens injected)`;
+}
+
+/** Count markdown list items in a string */
+export function countListItems(s: string | null): number {
+	if (!s) return 0;
+	return (s.match(/^- /gm) ?? []).length;
+}
+
+// Re-export types used by consumers of this module
+export type { CompactionConfig } from '../../types';
+export type {
+	CompactionStats,
+	DBNonTextPart,
+	DBToolCallSummary,
+	PreCompactionSnapshot,
+} from '../../sqlite/types';

package/src/plugin/hooks/params.ts

@@ -95,7 +95,11 @@ function detectMode(
 	return null;
 }
 
-export function createParamsHooks(ctx: PluginInput, _config: CoderConfig): ParamsHooks {
+export function createParamsHooks(
+	ctx: PluginInput,
+	_config: CoderConfig,
+	lastUserMessages?: Map<string, string>
+): ParamsHooks {
 	return {
 		async onParams(input: unknown, output: unknown): Promise<void> {
 			// Input contains: sessionID, agent, model, provider, message
@@ -117,6 +121,11 @@ export function createParamsHooks(ctx: PluginInput, _config: CoderConfig): Param
 			const messageContent = inputObj.message?.content || '';
 			if (!messageContent) return;
 
+			// Store user message text for downstream hooks (e.g. cadence trigger detection)
+			if (lastUserMessages && inputObj.sessionID) {
+				lastUserMessages.set(inputObj.sessionID, messageContent);
+			}
+
 			// Check for dynamic mode triggers
 			const detected = detectMode(messageContent);
 			if (!detected) return;

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;