@agentuity/opencode 1.0.15 → 1.0.16

package/src/agents/expert-ops.ts

@@ -369,7 +369,7 @@ export const expertOpsAgent: AgentDefinition = {
 	id: 'ag-expert-ops',
 	displayName: 'Agentuity Coder Expert Ops',
 	description: 'Agentuity operations specialist - CLI, cloud services, deployments, sandboxes',
-	defaultModel: 'anthropic/claude-sonnet-4-5-20250929',
+	defaultModel: 'anthropic/claude-sonnet-4-6',
 	systemPrompt: EXPERT_OPS_SYSTEM_PROMPT,
 	mode: 'subagent',
 	hidden: true, // Only invoked by Expert orchestrator

package/src/agents/expert.ts

@@ -214,7 +214,7 @@ export const expertAgent: AgentDefinition = {
 	id: 'ag-expert',
 	displayName: 'Agentuity Coder Expert',
 	description: 'Agentuity Coder Agentuity specialist - knows CLI, SDK, cloud services deeply',
-	defaultModel: 'anthropic/claude-sonnet-4-5-20250929',
+	defaultModel: 'anthropic/claude-sonnet-4-6',
 	systemPrompt: EXPERT_SYSTEM_PROMPT,
 	variant: 'high', // Careful thinking for technical guidance
 	temperature: 0.1, // Accurate, consistent technical answers

package/src/agents/monitor.ts

@@ -4,10 +4,17 @@ export const MONITOR_SYSTEM_PROMPT = `# BackgroundMonitor Agent
 
 You are a background task monitor. Your ONLY job is to watch background tasks and report when they complete.
 
+## Primary Notification Channel
+
+Background tasks automatically notify Lead with messages like:
+\`[BACKGROUND TASK COMPLETED]\`
+
+Those event-driven notifications are the primary mechanism. You are a fallback for Lead-of-Leads scenarios where multiple child Leads are running and a summary pass is needed.
+
 ## How You Work
 
 1. You receive a list of task IDs to monitor
-2. You poll their status using agentuity_background_output
+2. You check their status using agentuity_background_output
 3. When ALL tasks complete (or error), you report back to Lead
 4. You do NOT interpret results - just report completion status
 
@@ -20,36 +27,36 @@ When you need deeper insight into a task, use \`agentuity_background_inspect\` w
 - Cost summary (total cost + tokens)
 - Child session count (for nested Lead-of-Leads)
 
-Use inspect when a task has been running for many poll cycles without completing — it can reveal what the agent is stuck on.
+Use inspect when a task has been running for many check cycles without completing — it can reveal what the agent is stuck on.
 
 For a full session tree with all child sessions, costs, and health summary, use \`agentuity_session_dashboard({ session_id: "..." })\`. This is especially useful when monitoring Lead-of-Leads scenarios with multiple parallel workstreams.
 
-## Polling Behavior
+## Bounded Check Cycles
 
-- Poll every 10 seconds (wait between checks)
-- Continue until ALL tasks are complete or errored
-- No timeout - watch indefinitely
+- Run a short, bounded series of check cycles (e.g., 3–5 passes)
+- If tasks are still pending/running after the final pass, report the current status and highlight which tasks appear stuck
+- If tasks appear stuck, use \`agentuity_background_inspect\` for those tasks before reporting
 
-## Polling Process
+## Check Process
 
-For each poll cycle:
+For each check cycle:
 1. Check each task ID with \`agentuity_background_output({ task_id: "bg_xxx" })\`
 2. Track the status of each task
-3. If any task is still "pending" or "running", wait 10 seconds and poll again
-4. When all tasks are "completed" or "error", generate the final report
+3. If all tasks are "completed" or "error", generate the final report
+4. Otherwise, repeat for the next cycle (bounded)
 
 ## Report Format
 
-When all tasks complete, output:
+When all tasks complete (or when you finish the bounded cycles), output:
 
 \`\`\`markdown
-## Background Tasks Complete
+## Background Tasks Status
 
 | Task ID | Status | Summary |
 |---------|--------|---------|
 | bg_xxx | completed | [first 100 chars of result] |
 | bg_yyy | error | [error message] |
-| bg_zzz | completed | [first 100 chars of result] |
+| bg_zzz | running | [last known status] |
 
 ### Detailed Results
 
@@ -59,7 +66,7 @@ When all tasks complete, output:
 **bg_yyy (error):**
 [error message]
 
-All monitored tasks have finished. Lead can now proceed with integration.
+If any tasks are still running/pending after the final pass, list them under a short "Still Running" section and mention that Lead should wait for event-driven notifications or re-check later.
 \`\`\`
 
 ## What You Do NOT Do
@@ -69,27 +76,9 @@ All monitored tasks have finished. Lead can now proceed with integration.
 - ❌ Interact with the user
 - ❌ Modify any files
 - ❌ Call other agents
-- ❌ Use tools other than agentuity_background_output
+- ❌ Use tools other than agentuity_background_output, agentuity_background_inspect, and agentuity_session_dashboard
 
 You are a simple, focused watcher. Report completions, nothing more.
-
-## Example Workflow
-
-Given task: "Monitor these tasks: bg_abc123, bg_def456"
-
-1. Call agentuity_background_output for bg_abc123
-2. Call agentuity_background_output for bg_def456
-3. If any status is "pending" or "running", wait 10 seconds
-4. Repeat steps 1-3 until all complete
-5. Output final report
-
-## Waiting Between Polls
-
-Since you cannot use setTimeout, after checking all tasks and finding some still running, respond with something like:
-
-"Polling cycle complete. Tasks still running: [list]. Waiting 10 seconds before next poll..."
-
-Then immediately poll again. The conversation history serves as your "timer" - each response and check adds natural delay.
 `;
 
 export const monitorAgent: AgentDefinition = {

package/src/agents/reviewer.ts

@@ -363,7 +363,7 @@ export const reviewerAgent: AgentDefinition = {
 	id: 'ag-reviewer',
 	displayName: 'Agentuity Coder Reviewer',
 	description: 'Agentuity Coder reviewer - reviews code, catches issues, applies fixes',
-	defaultModel: 'anthropic/claude-sonnet-4-5-20250929',
+	defaultModel: 'anthropic/claude-sonnet-4-6',
 	systemPrompt: REVIEWER_SYSTEM_PROMPT,
 	variant: 'high', // Careful thinking for thorough review
 	temperature: 0.1, // Consistent, deterministic reviews

package/src/agents/scout.ts

@@ -316,7 +316,7 @@ export const scoutAgent: AgentDefinition = {
 	displayName: 'Agentuity Coder Scout',
 	description:
 		'Agentuity Coder explorer - analyzes codebases, finds patterns, researches docs (read-only)',
-	defaultModel: 'anthropic/claude-haiku-4-5-20251001',
+	defaultModel: 'anthropic/claude-sonnet-4-6',
 	systemPrompt: SCOUT_SYSTEM_PROMPT,
 	tools: {
 		exclude: ['write', 'edit', 'apply_patch'],

package/src/background/manager.ts

@@ -14,7 +14,7 @@ import { ConcurrencyManager } from './concurrency';
 
 const DEFAULT_BACKGROUND_CONFIG: BackgroundTaskConfig = {
 	enabled: true,
-	defaultConcurrency: 1,
+	defaultConcurrency: 5,
 	staleTimeoutMs: 30 * 60 * 1000,
 };
 
@@ -56,6 +56,7 @@ export class BackgroundManager {
 	private notifications = new Map<string, Set<string>>();
 	private toolCallIds = new Map<string, Set<string>>();
 	private shuttingDown = false;
+	private refreshIntervalId: ReturnType<typeof setInterval> | undefined;
 
 	constructor(
 		ctx: PluginInput,
@@ -73,6 +74,17 @@ export class BackgroundManager {
 		this.dbReader = dbReader;
 		this.serverUrl = this.resolveServerUrl();
 		this.authHeaders = this.resolveAuthHeaders();
+
+		// Periodic safety net: refresh task statuses every 30s in case events are missed
+		this.refreshIntervalId = setInterval(() => {
+			if (this.shuttingDown) return;
+			const hasActive = Array.from(this.tasks.values()).some(
+				(t) => t.status === 'pending' || t.status === 'running'
+			);
+			if (hasActive) {
+				void this.refreshStatuses();
+			}
+		}, 30_000);
 	}
 
 	/**
@@ -135,6 +147,7 @@ export class BackgroundManager {
 			status: 'pending',
 			queuedAt: new Date(),
 			concurrencyGroup: this.getConcurrencyGroup(input.agent),
+			notifiedStatuses: new Set(),
 		};
 
 		this.tasks.set(task.id, task);
@@ -390,6 +403,15 @@ export class BackgroundManager {
 								},
 							};
 
+							// Mark recovered terminal tasks as already notified
+							if (
+								task.status === 'completed' ||
+								task.status === 'error' ||
+								task.status === 'cancelled'
+							) {
+								task.notifiedStatuses = new Set([task.status]);
+							}
+
 							this.tasks.set(task.id, task);
 							this.tasksBySession.set(sess.id, task.id);
 
@@ -466,6 +488,15 @@ export class BackgroundManager {
 						},
 					};
 
+					// Mark recovered terminal tasks as already notified
+					if (
+						task.status === 'completed' ||
+						task.status === 'error' ||
+						task.status === 'cancelled'
+					) {
+						task.notifiedStatuses = new Set([task.status]);
+					}
+
 					// Add to our tracking maps
 					this.tasks.set(task.id, task);
 					this.tasksBySession.set(sess.id, task.id);
@@ -583,6 +614,10 @@ export class BackgroundManager {
 
 	shutdown(): void {
 		this.shuttingDown = true;
+		if (this.refreshIntervalId) {
+			clearInterval(this.refreshIntervalId);
+			this.refreshIntervalId = undefined;
+		}
 		this.concurrency.clear();
 		this.notifications.clear();
 		try {
@@ -758,29 +793,15 @@ export class BackgroundManager {
 
 	private async notifyParent(task: BackgroundTask): Promise<void> {
 		if (!task.parentSessionId) return;
+		if (this.shuttingDown) return;
 
 		// Prevent duplicate notifications for the same task+status combination
 		// This guards against OpenCode firing multiple events for the same status transition
 		const notifiedStatuses = task.notifiedStatuses ?? new Set();
 
-		// Self-healing for tasks created before deduplication was added:
-		// If a task is already in a terminal state but has no notification history,
-		// assume it was already notified and skip to prevent duplicate notifications.
-		if (
-			notifiedStatuses.size === 0 &&
-			(task.status === 'completed' || task.status === 'error' || task.status === 'cancelled')
-		) {
-			notifiedStatuses.add(task.status);
-			task.notifiedStatuses = notifiedStatuses;
-			return;
-		}
-
 		if (notifiedStatuses.has(task.status)) {
 			return; // Already notified for this status, skip duplicate
 		}
-		// Mark as notified BEFORE sending to prevent race conditions
-		notifiedStatuses.add(task.status);
-		task.notifiedStatuses = notifiedStatuses;
 
 		const statusLine = task.status === 'completed' ? 'completed' : task.status;
 		const message = `[BACKGROUND TASK ${statusLine.toUpperCase()}]
@@ -792,21 +813,36 @@ Task ID: ${task.id}
 
 Use the agentuity_background_output tool with task_id "${task.id}" to view the result.`;
 
-		try {
-			await this.ctx.client.session.prompt({
-				path: { id: task.parentSessionId },
-				body: {
-					parts: [{ type: 'text', text: message }],
-				},
-				throwOnError: true,
-				responseStyle: 'data',
-				...this.getClientOverrides(),
-			});
-		} catch (error) {
-			console.error(
-				`[BackgroundManager] Failed to notify parent for task ${task.id}:`,
-				extractErrorMessage(error, 'notification failed')
-			);
+		const maxRetries = 3;
+		for (let attempt = 0; attempt < maxRetries; attempt++) {
+			try {
+				await this.ctx.client.session.prompt({
+					path: { id: task.parentSessionId },
+					body: {
+						parts: [{ type: 'text', text: message }],
+					},
+					throwOnError: true,
+					responseStyle: 'data',
+					...this.getClientOverrides(),
+				});
+				// Mark as notified only AFTER confirmed delivery
+				notifiedStatuses.add(task.status);
+				task.notifiedStatuses = notifiedStatuses;
+				return; // Success
+			} catch (error) {
+				const errorMsg = extractErrorMessage(error, 'notification failed');
+				if (attempt < maxRetries - 1) {
+					// Exponential backoff: 1s, 2s, 4s
+					await new Promise((r) => setTimeout(r, 1000 * Math.pow(2, attempt)));
+					if (this.shuttingDown) return;
+				} else {
+					console.error(
+						`[BackgroundManager] Failed to notify parent for task ${task.id} after ${maxRetries} attempts:`,
+						errorMsg
+					);
+					// Don't mark as notified — allow future retry via refreshStatuses or Monitor
+				}
+			}
 		}
 	}
 

package/src/plugin/hooks/cadence.ts

@@ -2,6 +2,19 @@ import type { PluginInput } from '@opencode-ai/plugin';
 import type { CoderConfig } from '../../types';
 import type { BackgroundManager } from '../../background';
 import type { OpenCodeDBReader, SessionTreeNode } from '../../sqlite';
+import type { CompactionStats } from '../../sqlite/types';
+import {
+	getCurrentBranch,
+	buildCustomCompactionPrompt,
+	fetchAndFormatPlanningState,
+	getImageDescriptions,
+	getRecentToolCallSummaries,
+	storePreCompactionSnapshot,
+	persistCadenceStateToKV,
+	restoreCadenceStateFromKV,
+	formatCompactionDiagnostics,
+	countListItems,
+} from './compaction-utils';
 
 /** Compacting hook input/output types */
 type CompactingInput = { sessionID: string };
@@ -13,27 +26,12 @@ export interface CadenceHooks {
 	onCompacting: (input: CompactingInput, output: CompactingOutput) => Promise<void>;
 	/** Check if a session is currently in Cadence mode */
 	isActiveCadenceSession: (sessionId: string) => boolean;
+	/** Lazy restore: check KV for persisted Cadence state and populate in-memory Map */
+	tryRestoreFromKV: (sessionId: string) => Promise<boolean>;
 }
 
 const COMPLETION_PATTERN = /<promise>\s*DONE\s*<\/promise>/i;
 
-/**
- * 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';
-	}
-}
-
 // Ultrawork trigger keywords - case insensitive matching
 const ULTRAWORK_TRIGGERS = [
 	'ultrawork',
@@ -69,11 +67,14 @@ interface CadenceSessionState {
  */
 export function createCadenceHooks(
 	ctx: PluginInput,
-	_config: CoderConfig,
+	config: CoderConfig,
 	backgroundManager?: BackgroundManager,
-	dbReader?: OpenCodeDBReader
+	dbReader?: OpenCodeDBReader,
+	lastUserMessages?: Map<string, string>
 ): CadenceHooks {
 	const activeCadenceSessions = new Map<string, CadenceSessionState>();
+	const nonCadenceSessions = new Set<string>();
+	const NON_CADENCE_CACHE_MAX = 500;
 
 	const log = (msg: string) => {
 		ctx.client.app.log({
@@ -90,11 +91,14 @@ export function createCadenceHooks(
 			const sessionId = extractSessionId(input);
 			if (!sessionId) return;
 
-			const messageText = extractMessageText(output);
-			if (!messageText) return;
-
-			// Check if this is a Cadence start command or ultrawork trigger
-			const cadenceType = getCadenceTriggerType(messageText);
+			// Use the USER's message (from chat.params) for trigger detection,
+			// not the model's output — avoids false positives when the model
+			// uses phrases like "go deep" or "be thorough" in its response.
+			// Delete after read — entries are transient (set in chat.params,
+			// consumed here in chat.message) so no unbounded Map growth.
+			const userText = lastUserMessages?.get(sessionId) ?? '';
+			lastUserMessages?.delete(sessionId);
+			const cadenceType = getCadenceTriggerType(userText);
 			if (cadenceType && !activeCadenceSessions.has(sessionId)) {
 				log(`Cadence started for session ${sessionId} via ${cadenceType}`);
 				const now = new Date().toISOString();
@@ -105,6 +109,8 @@ export function createCadenceHooks(
 					lastActivity: now,
 				};
 				activeCadenceSessions.set(sessionId, state);
+				nonCadenceSessions.delete(sessionId);
+				persistCadenceStateToKV(sessionId, { ...state }).catch(() => {});
 
 				// If triggered by ultrawork keywords, inject [CADENCE MODE] tag
 				if (cadenceType === 'ultrawork') {
@@ -115,6 +121,12 @@ export function createCadenceHooks(
 				return;
 			}
 
+			// Everything below parses the MODEL's output for structured tags
+			// (CADENCE_STATUS, iteration counts, completion signals) that the
+			// model intentionally emits — these are NOT false-positive-prone.
+			const messageText = extractMessageText(output);
+			if (!messageText) return;
+
 			// Check if this session is in Cadence mode
 			const state = activeCadenceSessions.get(sessionId);
 			if (!state) {
@@ -146,6 +158,7 @@ export function createCadenceHooks(
 				if (changed) {
 					const loopInfo = state.loopId ? ` · ${state.loopId}` : '';
 					showToast(ctx, `⚡ Cadence · ${state.iteration}/${state.maxIterations}${loopInfo}`);
+					persistCadenceStateToKV(sessionId, { ...state }).catch(() => {});
 				}
 				return;
 			}
@@ -158,6 +171,7 @@ export function createCadenceHooks(
 					state.iteration = newIteration;
 					const loopInfo = state.loopId ? ` · ${state.loopId}` : '';
 					showToast(ctx, `⚡ Cadence · ${state.iteration}/${state.maxIterations}${loopInfo}`);
+					persistCadenceStateToKV(sessionId, { ...state }).catch(() => {});
 				}
 			}
 
@@ -285,6 +299,8 @@ Continue Cadence iteration ${state.iteration} of ${state.maxIterations}
 		/**
 		 * Called during context compaction to inject Cadence state.
 		 * This ensures the compaction summary includes critical loop state.
+		 * Uses output.prompt to REPLACE the default compaction prompt with
+		 * enriched context (planning state, images, tool calls, diagnostics).
 		 */
 		async onCompacting(input: CompactingInput, output: CompactingOutput): Promise<void> {
 			const sessionId = input.sessionID;
@@ -298,12 +314,53 @@ Continue Cadence iteration ${state.iteration} of ${state.maxIterations}
 			log(`Injecting Cadence context during compaction for session ${sessionId}`);
 			showToast(ctx, '💾 Compacting Cadence context...');
 
-			// 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('cadence') : 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 Cadence state section
+			const cadenceStateSection = `## CADENCE MODE ACTIVE
+
+This session is running in Cadence mode (long-running autonomous loop).
 
-			// Get active background tasks for this session
+**Cadence State:**
+- Session ID: ${sessionId}
+- Loop ID: ${state.loopId ?? 'unknown'}
+- Branch: ${branch}
+- Started: ${state.startedAt}
+- Iteration: ${state.iteration} / ${state.maxIterations}
+- Last activity: ${state.lastActivity}
+
+**Session Record Location:**
+\`session:${sessionId}\` in agentuity-opencode-memory
+
+After compaction:
+1. Memory will save this summary and update the session record
+2. Memory should update planning.progress with this compaction
+3. Lead will continue the loop from iteration ${state.iteration}
+4. Use 5-Question Reboot to re-orient: Where am I? Where going? Goal? Learned? Done?`;
+
+			// 4. Build background tasks section
 			const tasks = backgroundManager?.getTasksByParent(sessionId) ?? [];
-			let backgroundTaskContext = '';
+			let backgroundSection: string | null = null;
 
 			if (tasks.length > 0) {
 				const taskList = tasks
@@ -313,9 +370,7 @@ Continue Cadence iteration ${state.iteration} of ${state.maxIterations}
 					)
 					.join('\n');
 
-				backgroundTaskContext = `
-
-## Active Background Tasks
+				backgroundSection = `## Active Background Tasks
 
 This session has ${tasks.length} background task(s) running in separate sessions:
 ${taskList}
@@ -331,45 +386,70 @@ agentuity_background_task({
   task: "Monitor these background tasks and report when all complete:\\n${tasks.map((t) => `- ${t.id}`).join('\\n')}",
   description: "Monitor child tasks"
 })
-\`\`\`
-`;
+\`\`\``;
 			}
 
-			output.context.push(`
-## CADENCE MODE ACTIVE
-
-This session is running in Cadence mode (long-running autonomous loop).
-
-**Cadence State:**
-- Session ID: ${sessionId}
-- Loop ID: ${state.loopId ?? 'unknown'}
-- Branch: ${branch}
-- Started: ${state.startedAt}
-- Iteration: ${state.iteration} / ${state.maxIterations}
-- Last activity: ${state.lastActivity}
-
-**Session Record Location:**
-\`session:${sessionId}\` in agentuity-opencode-memory
+			// 5. Build SQLite dashboard section
+			const dashboardSection = buildSqliteDashboardSummary(dbReader, sessionId);
+
+			// 6. Combine everything into the full prompt
+			const sections: string[] = [];
+			if (instructions) sections.push(instructions);
+			sections.push(cadenceStateSection);
+			if (backgroundSection) sections.push(backgroundSection);
+			if (planningState) sections.push(planningState);
+			if (imageDescs) sections.push(imageDescs);
+			if (toolSummaries) sections.push(toolSummaries);
+			if (dashboardSection) sections.push(dashboardSection);
+
+			// 7. 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);
+
+			// 8. 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');
+			}
 
-**Planning State:**
-If this session has planning active, the session record contains:
-- \`planning.prdKey\` - Link to the PRD being executed
-- \`planning.objective\` - What we're trying to accomplish
-- \`planning.phases\` - Current phases with status and notes
-- \`planning.current\` - Current phase
-- \`planning.findings\` - Discoveries made during work
-- \`planning.errors\` - Failures to avoid repeating
-${backgroundTaskContext}
-After compaction:
-1. Memory will save this summary and update the session record
-2. Memory should update planning.progress with this compaction
-3. Lead will continue the loop from iteration ${state.iteration}
-4. Use 5-Question Reboot to re-orient: Where am I? Where going? Goal? Learned? Done?
-`);
+			// 9. Set the full prompt or push to context
+			if (useCustomPrompt) {
+				output.prompt = fullPrompt;
+			} else {
+				output.context.push(fullPrompt);
+			}
 
-			const dashboardSummary = buildSqliteDashboardSummary(dbReader, sessionId);
-			if (dashboardSummary) {
-				output.context.push(dashboardSummary);
+			// 10. 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,
+					})),
+					cadenceState: state ? { ...state } : undefined,
+					branch,
+				}).catch(() => {}); // Fire and forget
 			}
 		},
 
@@ -380,6 +460,44 @@ After compaction:
 		isActiveCadenceSession(sessionId: string): boolean {
 			return activeCadenceSessions.has(sessionId);
 		},
+
+		/**
+		 * Lazy restore: check KV for persisted Cadence state and populate in-memory Map.
+		 * Called before routing decisions to recover state after plugin restarts.
+		 * Returns true if state was found and restored.
+		 */
+		async tryRestoreFromKV(sessionId: string): Promise<boolean> {
+			// Already in memory — nothing to restore
+			if (activeCadenceSessions.has(sessionId)) return true;
+			// Known non-Cadence session — skip KV lookup
+			if (nonCadenceSessions.has(sessionId)) return false;
+
+			try {
+				const kvState = await restoreCadenceStateFromKV(sessionId);
+				if (!kvState) {
+					if (nonCadenceSessions.size >= NON_CADENCE_CACHE_MAX) {
+						nonCadenceSessions.clear();
+					}
+					nonCadenceSessions.add(sessionId);
+					return false;
+				}
+
+				const state: CadenceSessionState = {
+					startedAt: (kvState.startedAt as string) ?? new Date().toISOString(),
+					loopId: kvState.loopId as string | undefined,
+					iteration: (kvState.iteration as number) ?? 1,
+					maxIterations: (kvState.maxIterations as number) ?? 50,
+					lastActivity: (kvState.lastActivity as string) ?? new Date().toISOString(),
+				};
+				activeCadenceSessions.set(sessionId, state);
+				log(
+					`Restored Cadence state from KV for session ${sessionId} (iteration ${state.iteration}/${state.maxIterations})`
+				);
+				return true;
+			} catch {
+				return false;
+			}
+		},
 	};
 }