@agentuity/opencode 0.1.36 → 0.1.38

package/src/plugin/hooks/cadence.ts

@@ -1,9 +1,16 @@
-import type { PluginContext, CoderConfig, CompactingInput, CompactingOutput } from '../../types';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { CoderConfig } from '../../types';
+
+/** Compacting hook input/output types */
+type CompactingInput = { sessionID: string };
+type CompactingOutput = { context: string[]; prompt?: string };
 
 export interface CadenceHooks {
 	onMessage: (input: unknown, output: unknown) => Promise<void>;
 	onEvent: (input: unknown) => Promise<void>;
 	onCompacting: (input: CompactingInput, output: CompactingOutput) => Promise<void>;
+	/** Check if a session is currently in Cadence mode */
+	isActiveCadenceSession: (sessionId: string) => boolean;
 }
 
 const COMPLETION_PATTERN = /<promise>\s*DONE\s*<\/promise>/i;
@@ -41,7 +48,7 @@ interface CadenceSessionState {
  * 4. Trigger continuation after compaction (session.compacted)
  * 5. Clean up on session abort/error
  */
-export function createCadenceHooks(ctx: PluginContext, _config: CoderConfig): CadenceHooks {
+export function createCadenceHooks(ctx: PluginInput, _config: CoderConfig): CadenceHooks {
 	const activeCadenceSessions = new Map<string, CadenceSessionState>();
 
 	const log = (msg: string) => {
@@ -151,7 +158,7 @@ export function createCadenceHooks(ctx: PluginContext, _config: CoderConfig): Ca
 
 			log(`Event received: ${event.type}`);
 
-			// Handle session.compacted - trigger continuation after compaction completes
+			// Handle session.compacted - save compaction AND continue loop
 			if (event.type === 'session.compacted') {
 				const sessionId = event.sessionId;
 				if (!sessionId) return;
@@ -159,10 +166,9 @@ export function createCadenceHooks(ctx: PluginContext, _config: CoderConfig): Ca
 				const state = activeCadenceSessions.get(sessionId);
 				if (!state) return;
 
-				log(`Compaction completed for Cadence session ${sessionId} - triggering continuation`);
-				showToast(ctx, '🔄 Context compacted, resuming Cadence...');
+				log(`Compaction completed for Cadence session ${sessionId} - saving and continuing`);
+				showToast(ctx, '🔄 Compaction saved, resuming Cadence...');
 
-				// Inject continuation prompt if session.prompt is available
 				try {
 					await ctx.client.session?.prompt?.({
 						path: { id: sessionId },
@@ -170,24 +176,59 @@ export function createCadenceHooks(ctx: PluginContext, _config: CoderConfig): Ca
 							parts: [
 								{
 									type: 'text',
-									text: `[CADENCE CONTINUATION]
+									text: `[CADENCE COMPACTION COMPLETE]
+
+The compaction summary above contains our Cadence session context.
+
+1. Have @Agentuity Coder Memory save this compaction:
+   - Get existing session: \`agentuity cloud kv get agentuity-opencode-memory "session:${sessionId}" --json --region use\`
+   - Append compaction to \`compactions\` array with timestamp
+   - Ensure \`cadence\` object exists with: loopId="${state.loopId ?? 'unknown'}", iteration=${state.iteration}, maxIterations=${state.maxIterations}, status="active"
+   - Save back to KV and upsert to Vector
+
+After saving the compaction:
+1. Read back the session record from KV
+2. Return to Lead the PREVIOUS compactions only (not the one just saved - Lead already has the current compaction in context)
+3. Format as a readable summary with timestamps
+4. Include "what's next" - the Cadence iteration to continue
+
+Response format:
+\`\`\`
+## Prior Session History: ${sessionId}
+
+### Compaction 1 (timestamp)
+[summary]
+
+### Compaction 2 (timestamp)
+[summary]
+
+(Current compaction already in your context)
 
-Context was just compacted. Resume the Cadence loop:
+## What's Next
+Continue Cadence iteration ${state.iteration} of ${state.maxIterations}
+\`\`\`
 
-1. Ask Memory for the latest checkpoint and any compaction snapshots
-2. Review the current iteration state from KV
-3. Continue with the next step in the iteration workflow
-4. Do NOT restart from the beginning - pick up where you left off
+If no prior compactions exist:
+\`\`\`
+## Prior Session History: ${sessionId}
 
-Continue executing the task.`,
+No prior compactions - this is the first one.
+
+## What's Next
+Continue Cadence iteration ${state.iteration} of ${state.maxIterations}
+\`\`\`
+
+2. Then continue the Cadence loop:
+   - Review the compaction summary above for context
+   - Continue with iteration ${state.iteration}
+   - Do NOT restart from the beginning - pick up where we left off`,
 								},
 							],
 							agent: 'Agentuity Coder Lead',
 						},
 					});
 				} catch (err) {
-					log(`Failed to inject continuation prompt: ${err}`);
-					// Continuation will rely on auto-generated "Continue if you have next steps"
+					log(`Failed to save compaction and continue: ${err}`);
 				}
 			}
 
@@ -227,35 +268,33 @@ Continue executing the task.`,
 			log(`Injecting Cadence context during compaction for session ${sessionId}`);
 			showToast(ctx, '💾 Compacting Cadence context...');
 
-			const loopIdStr = state.loopId ?? '{loopId}';
-
-			// Inject Cadence state into the compaction context
 			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'}
 - Started: ${state.startedAt}
 - Iteration: ${state.iteration} / ${state.maxIterations}
 - Last activity: ${state.lastActivity}
 
-**CRITICAL: After compaction, you MUST:**
-1. Ask @Agentuity Coder Memory for the latest checkpoint and compaction snapshots
-2. Read the loop state from KV: \`agentuity cloud kv get agentuity-opencode-tasks "loop:${loopIdStr}:state"\`
-3. Emit CADENCE_STATUS tag with current state
-4. Continue the iteration workflow from where you left off
-5. Do NOT restart the task from the beginning
-
-**Memory Keys to Query:**
-- \`loop:${loopIdStr}:state\` - Current loop state
-- \`loop:${loopIdStr}:checkpoint:{N}\` - Iteration checkpoints
-- \`loop:${loopIdStr}:compaction:{N}\` - Compaction snapshots
+**Session Record Location:**
+\`session:${sessionId}\` in agentuity-opencode-memory
 
-Resume the Cadence loop after this compaction completes.
+After compaction, Memory will save this summary and update the cadence state.
+Then Lead will continue the loop from iteration ${state.iteration}.
 `);
 		},
+
+		/**
+		 * Check if a session is currently in Cadence mode.
+		 * Used by session-memory hooks to avoid double-handling.
+		 */
+		isActiveCadenceSession(sessionId: string): boolean {
+			return activeCadenceSessions.has(sessionId);
+		},
 	};
 }
 
@@ -339,9 +378,9 @@ function isCadenceStop(text: string): boolean {
 	);
 }
 
-function showToast(ctx: PluginContext, message: string): void {
+function showToast(ctx: PluginInput, message: string): void {
 	try {
-		ctx.client.tui?.showToast?.({ body: { message } });
+		ctx.client.tui.showToast({ body: { message, variant: 'info' } });
 	} catch {
 		// Toast may not be available
 	}

package/src/plugin/hooks/keyword.ts

@@ -1,4 +1,5 @@
-import type { PluginContext, CoderConfig } from '../../types';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { CoderConfig } from '../../types';
 
 export interface KeywordHooks {
 	onMessage: (input: unknown, output: unknown) => Promise<void>;
@@ -35,7 +36,7 @@ Run \`agentuity ai schema show\` to see all available CLI commands.
 </coder-mode>
 `;
 
-export function createKeywordHooks(ctx: PluginContext, _config: CoderConfig): KeywordHooks {
+export function createKeywordHooks(ctx: PluginInput, _config: CoderConfig): KeywordHooks {
 	const activatedSessions = new Set<string>();
 
 	const log = (msg: string) => {

package/src/plugin/hooks/params.ts

@@ -1,4 +1,5 @@
-import type { PluginContext, CoderConfig } from '../../types';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { CoderConfig } from '../../types';
 
 export interface ParamsHooks {
 	onParams: (input: unknown, output: unknown) => Promise<void>;
@@ -94,7 +95,7 @@ function detectMode(
 	return null;
 }
 
-export function createParamsHooks(ctx: PluginContext, _config: CoderConfig): ParamsHooks {
+export function createParamsHooks(ctx: PluginInput, _config: CoderConfig): ParamsHooks {
 	return {
 		async onParams(input: unknown, output: unknown): Promise<void> {
 			// Input contains: sessionID, agent, model, provider, message
@@ -138,8 +139,11 @@ export function createParamsHooks(ctx: PluginContext, _config: CoderConfig): Par
 			};
 
 			try {
-				ctx.client.tui?.showToast?.({
-					body: { message: modeMessages[detected.mode] || `${detected.mode} mode activated` },
+				ctx.client.tui.showToast({
+					body: {
+						message: modeMessages[detected.mode] || `${detected.mode} mode activated`,
+						variant: 'info',
+					},
 				});
 			} catch {
 				// Toast may not be available in all contexts (e.g., headless)

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

@@ -0,0 +1,137 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { CoderConfig } from '../../types';
+
+export interface SessionMemoryHooks {
+	onEvent: (input: {
+		event: { type: string; properties?: Record<string, unknown> };
+	}) => Promise<void>;
+	onCompacting: (
+		input: { sessionID: string },
+		output: { context: string[]; prompt?: string }
+	) => Promise<void>;
+}
+
+/**
+ * Session memory hooks handle compaction for non-Cadence sessions.
+ *
+ * Strategy:
+ * 1. On compacting: Inject Memory system info into compaction prompt
+ * 2. On session.compacted: Tell Lead to have Memory save the summary (it's already in context!)
+ */
+export function createSessionMemoryHooks(
+	ctx: PluginInput,
+	_config: CoderConfig
+): SessionMemoryHooks {
+	const log = (msg: string) => {
+		ctx.client.app.log({
+			body: {
+				service: 'session-memory',
+				level: 'debug',
+				message: msg,
+			},
+		});
+	};
+
+	return {
+		/**
+		 * Listen for session.compacted event.
+		 * The compaction summary is already in context - just tell Lead to save it.
+		 */
+		async onEvent(input: {
+			event: { type: string; properties?: Record<string, unknown> };
+		}): Promise<void> {
+			const { event } = input;
+			if (event?.type !== 'session.compacted') return;
+
+			const sessionId =
+				(event.properties?.sessionId as string | undefined) ??
+				(event.properties?.sessionID as string | undefined);
+
+			if (!sessionId) return;
+
+			log(`Compaction complete for session ${sessionId} - triggering memory save`);
+
+			try {
+				await ctx.client.session.prompt({
+					path: { id: sessionId },
+					body: {
+						parts: [
+							{
+								type: 'text',
+								text: `[COMPACTION COMPLETE]
+
+The compaction summary above contains our session context.
+
+Have @Agentuity Coder Memory save this compaction:
+1. Get existing session record (or create new): \`agentuity cloud kv get agentuity-opencode-memory "session:${sessionId}" --json --region use\`
+2. Append this compaction summary to the \`compactions\` array with timestamp
+3. Save back: \`agentuity cloud kv set agentuity-opencode-memory "session:${sessionId}" '{...}' --region use\`
+4. Upsert to Vector for semantic search: \`agentuity cloud vector upsert agentuity-opencode-sessions "session:${sessionId}" --document "..." --metadata '...' --region use\`
+
+After saving the compaction:
+1. Read back the session record from KV
+2. Return to Lead the PREVIOUS compactions only (not the one just saved - Lead already has the current compaction in context)
+3. Format as a readable summary with timestamps
+4. Include "what's next" - the user's pending request if there is one
+
+Response format:
+\`\`\`
+## Prior Session History: ${sessionId}
+
+### Compaction 1 (timestamp)
+[summary]
+
+### Compaction 2 (timestamp)
+[summary]
+
+(Current compaction already in your context)
+
+## What's Next
+[User's pending request if there is one]
+\`\`\`
+
+If no prior compactions exist:
+\`\`\`
+## Prior Session History: ${sessionId}
+
+No prior compactions - this is the first one.
+
+## What's Next
+[User's pending request if there is one]
+\`\`\`
+
+Then continue with the current task if there is one.`,
+							},
+						],
+						agent: 'Agentuity Coder Lead',
+					},
+				});
+
+				log(`Memory save triggered for session ${sessionId}`);
+			} catch (err) {
+				log(`Failed to trigger memory save: ${err}`);
+			}
+		},
+
+		/**
+		 * Inject Memory system info during compaction.
+		 * This gets included in OpenCode's generated summary.
+		 */
+		async onCompacting(
+			input: { sessionID: string },
+			output: { context: string[]; prompt?: string }
+		): Promise<void> {
+			const sessionId = input.sessionID;
+			log(`Compacting session ${sessionId}`);
+
+			output.context.push(`
+## Session Memory
+
+This session's context is being saved to persistent memory.
+Session record location: \`session:${sessionId}\` in agentuity-opencode-memory
+
+After compaction, Memory will automatically save this summary for future recovery.
+`);
+		},
+	};
+}

package/src/plugin/hooks/session.ts

@@ -1,10 +1,11 @@
-import type { PluginContext, CoderConfig } from '../../types';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { CoderConfig } from '../../types';
 
 export interface SessionHooks {
 	onMessage: (input: unknown, output: unknown) => Promise<void>;
 }
 
-export function createSessionHooks(_ctx: PluginContext, _config: CoderConfig): SessionHooks {
+export function createSessionHooks(_ctx: PluginInput, _config: CoderConfig): SessionHooks {
 	const initializedSessions = new Set<string>();
 
 	return {

package/src/plugin/hooks/tools.ts

@@ -1,4 +1,5 @@
-import type { PluginContext, CoderConfig } from '../../types';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { CoderConfig } from '../../types';
 import { checkAuth } from '../../services/auth';
 
 export interface ToolHooks {
@@ -33,7 +34,7 @@ const CLOUD_SERVICES: Record<string, { name: string; emoji: string }> = {
 	'agentuity cloud scp': { name: 'File Transfer', emoji: '📤' },
 };
 
-export function createToolHooks(ctx: PluginContext, config: CoderConfig): ToolHooks {
+export function createToolHooks(ctx: PluginInput, config: CoderConfig): ToolHooks {
 	const blockedCommands = config.blockedCommands ?? [];
 
 	return {
@@ -79,7 +80,10 @@ export function createToolHooks(ctx: PluginContext, config: CoderConfig): ToolHo
 					// Check if AGENTUITY_PROFILE already exists (anywhere in the command)
 					if (/AGENTUITY_PROFILE=\S+/.test(command)) {
 						// Replace all existing AGENTUITY_PROFILE occurrences to enforce our profile
-						modifiedCommand = command.replace(/AGENTUITY_PROFILE=\S+/g, `AGENTUITY_PROFILE=${profile}`);
+						modifiedCommand = command.replace(
+							/AGENTUITY_PROFILE=\S+/g,
+							`AGENTUITY_PROFILE=${profile}`
+						);
 					} else {
 						// Prepend AGENTUITY_PROFILE
 						modifiedCommand = `AGENTUITY_PROFILE=${profile} ${command}`;
@@ -90,8 +94,11 @@ export function createToolHooks(ctx: PluginContext, config: CoderConfig): ToolHo
 					const service = detectCloudService(command);
 					if (service) {
 						try {
-							ctx.client.tui?.showToast?.({
-								body: { message: `${service.emoji} Agentuity ${service.name}` },
+							ctx.client.tui.showToast({
+								body: {
+									message: `${service.emoji} Agentuity ${service.name}`,
+									variant: 'info',
+								},
 							});
 						} catch {
 							// Toast may not be available

package/src/plugin/plugin.ts

@@ -1,4 +1,5 @@
-import type { PluginContext, PluginHooks, AgentConfig, CommandDefinition } from '../types';
+import type { PluginInput, Hooks } from '@opencode-ai/plugin';
+import type { AgentConfig, CommandDefinition } from '../types';
 import { agents } from '../agents';
 import { loadCoderConfig, getDefaultConfig, mergeConfig } from '../config';
 import { createSessionHooks } from './hooks/session';
@@ -6,6 +7,7 @@ import { createToolHooks } from './hooks/tools';
 import { createKeywordHooks } from './hooks/keyword';
 import { createParamsHooks } from './hooks/params';
 import { createCadenceHooks } from './hooks/cadence';
+import { createSessionMemoryHooks } from './hooks/session-memory';
 import { z } from 'zod';
 import type { AgentRole } from '../types';
 
@@ -19,7 +21,7 @@ const AGENT_MENTIONS: Record<AgentRole, string> = {
 	expert: '@Agentuity Coder Expert',
 };
 
-export async function createCoderPlugin(ctx: PluginContext): Promise<PluginHooks> {
+export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 	ctx.client.app.log({
 		body: {
 			service: 'agentuity-coder',
@@ -37,6 +39,10 @@ export async function createCoderPlugin(ctx: PluginContext): Promise<PluginHooks
 	const paramsHooks = createParamsHooks(ctx, coderConfig);
 	const cadenceHooks = createCadenceHooks(ctx, coderConfig);
 
+	// 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);
+
 	const configHandler = createConfigHandler(coderConfig);
 
 	// Get the tool helper from Open Code context if available
@@ -48,7 +54,9 @@ export async function createCoderPlugin(ctx: PluginContext): Promise<PluginHooks
 
 	// Show startup toast (fire and forget, don't block)
 	try {
-		ctx.client.tui?.showToast?.({ body: { message: '🚀 Agentuity Coder ready' } });
+		ctx.client.tui.showToast({
+			body: { message: '🚀 Agentuity Coder ready', variant: 'success' },
+		});
 	} catch {
 		// Toast may not be available
 	}
@@ -64,8 +72,26 @@ export async function createCoderPlugin(ctx: PluginContext): Promise<PluginHooks
 		'chat.params': paramsHooks.onParams,
 		'tool.execute.before': toolHooks.before,
 		'tool.execute.after': toolHooks.after,
-		event: cadenceHooks.onEvent,
-		'experimental.session.compacting': cadenceHooks.onCompacting,
+		event: async (input) => {
+			// 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> } }
+				);
+			}
+		},
+		'experimental.session.compacting': async (input, output) => {
+			// Orchestrate: route to appropriate module based on session type
+			if (cadenceHooks.isActiveCadenceSession(input.sessionID)) {
+				await cadenceHooks.onCompacting(input, output);
+			} else {
+				await sessionMemoryHooks.onCompacting(input, output);
+			}
+		},
 	};
 }
 
@@ -304,7 +330,7 @@ $ARGUMENTS
 	};
 }
 
-function createTools(tool: (schema: (s: typeof z) => unknown) => unknown): Record<string, unknown> {
+function createTools(tool: (schema: (s: typeof z) => unknown) => unknown): Hooks['tool'] {
 	const coderDelegate = tool((s) => ({
 		description: `Delegate a task to a specialized Agentuity Coder agent.
 
@@ -333,7 +359,25 @@ Use this to:
 		},
 	}));
 
+	// Type assertion needed because the tool() helper returns unknown
+	// but the runtime type is correct (it's created by OpenCode's tool helper)
 	return {
 		coder_delegate: coderDelegate,
-	};
+	} as Hooks['tool'];
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helper Functions
+// ─────────────────────────────────────────────────────────────────────────────
+
+function extractSessionIdFromEvent(input: unknown): string | undefined {
+	if (typeof input !== 'object' || input === null) return undefined;
+
+	const inp = input as { event?: { properties?: Record<string, unknown> } };
+	if (!inp.event?.properties) return undefined;
+
+	return (
+		(inp.event.properties.sessionId as string | undefined) ??
+		(inp.event.properties.sessionID as string | undefined)
+	);
 }

package/src/types.ts

@@ -1,5 +1,13 @@
 import { z } from 'zod';
 
+// Re-export types from @opencode-ai/plugin
+export type {
+	Plugin,
+	PluginInput,
+	Hooks as PluginHooks,
+	ToolDefinition,
+} from '@opencode-ai/plugin';
+
 export const AgentRoleSchema = z.enum(['lead', 'scout', 'builder', 'reviewer', 'memory', 'expert']);
 export type AgentRole = z.infer<typeof AgentRoleSchema>;
 
@@ -114,55 +122,7 @@ export interface McpConfig {
 	headers?: Record<string, string>;
 }
 
-export interface PluginClient {
-	app: {
-		log: (options: {
-			body: { service: string; level: string; message: string; extra?: unknown };
-		}) => void;
-	};
-	tui?: {
-		showToast?: (options: { body: { message: string } }) => void;
-	};
-	session?: {
-		prompt?: (options: {
-			path: { id: string };
-			body: {
-				parts: Array<{ type: 'text'; text: string }>;
-				agent?: string;
-			};
-			noReply?: boolean;
-		}) => Promise<unknown>;
-	};
-}
-
-export interface PluginContext {
-	directory: string;
-	client: PluginClient;
-}
-
-export interface CompactingInput {
-	sessionID: string;
-}
-
-export interface CompactingOutput {
-	context: string[];
-	prompt?: string;
-}
-
-export interface PluginHooks {
-	agents?: Record<string, AgentConfig>;
-	tool?: Record<string, unknown>; // Open Code tool format (created via tool() helper)
-	config?: (config: Record<string, unknown>) => Promise<void>;
-	'chat.message'?: (input: unknown, output: unknown) => Promise<void>;
-	'chat.params'?: (input: unknown, output: unknown) => Promise<void>;
-	'tool.execute.before'?: (input: unknown, output: unknown) => Promise<void>;
-	'tool.execute.after'?: (input: unknown, output: unknown) => Promise<void>;
-	event?: (input: unknown) => Promise<void>;
-	'experimental.session.compacting'?: (
-		input: CompactingInput,
-		output: CompactingOutput
-	) => Promise<void>;
-}
+// Note: PluginInput and PluginHooks are now imported from @opencode-ai/plugin above.
 
 export interface CommandDefinition {
 	name: string;
@@ -175,8 +135,4 @@ export interface CommandDefinition {
 	subtask?: boolean;
 }
 
-export interface ToolDefinition {
-	description: string;
-	args: unknown; // Zod schema or JSON schema
-	execute: (args: unknown, context: unknown) => Promise<unknown>;
-}
+// ToolDefinition is re-exported from @opencode-ai/plugin above