@agentuity/opencode 1.0.1 → 1.0.2

package/src/background/manager.ts

@@ -1,7 +1,14 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import { agents } from '../agents';
 import type { AgentDefinition } from '../agents';
-import type { BackgroundTask, BackgroundTaskConfig, LaunchInput, TaskProgress } from './types';
+import type {
+	BackgroundTask,
+	BackgroundTaskConfig,
+	BackgroundTaskStatus,
+	LaunchInput,
+	TaskInspection,
+	TaskProgress,
+} from './types';
 import { ConcurrencyManager } from './concurrency';
 
 const DEFAULT_BACKGROUND_CONFIG: BackgroundTaskConfig = {
@@ -106,6 +113,225 @@ export class BackgroundManager {
 		return this.tasks.get(taskId);
 	}
 
+	/**
+	 * Inspect a background task by fetching its session messages.
+	 * Useful for seeing what a child Lead or other agent is doing.
+	 */
+	async inspectTask(taskId: string): Promise<TaskInspection | undefined> {
+		const task = this.tasks.get(taskId);
+		if (!task?.sessionId) return undefined;
+
+		try {
+			// Get session details
+			const sessionResponse = await this.ctx.client.session.get({
+				path: { id: task.sessionId },
+				throwOnError: false,
+			});
+
+			// Get messages from the session
+			const messagesResponse = await this.ctx.client.session.messages({
+				path: { id: task.sessionId },
+				throwOnError: false,
+			});
+
+			const session = unwrapResponse<unknown>(sessionResponse);
+			const rawMessages =
+				unwrapResponse<Array<{ info: unknown; parts: unknown[] }>>(messagesResponse);
+			// Defensive array coercion (response may be non-array when throwOnError is false)
+			const messages = Array.isArray(rawMessages) ? rawMessages : [];
+
+			// Return structured inspection result
+			return {
+				taskId: task.id,
+				sessionId: task.sessionId,
+				status: task.status,
+				session,
+				messages,
+				lastActivity: task.progress?.lastUpdate?.toISOString(),
+			};
+		} catch {
+			// Session might not exist anymore
+			return undefined;
+		}
+	}
+
+	/**
+	 * Refresh task statuses from the server.
+	 * Useful for recovering state after issues or checking on stuck tasks.
+	 */
+	async refreshStatuses(): Promise<Map<string, BackgroundTaskStatus>> {
+		const results = new Map<string, BackgroundTaskStatus>();
+
+		// Get all our tracked session IDs
+		const sessionIds = Array.from(this.tasksBySession.keys());
+		if (sessionIds.length === 0) return results;
+
+		try {
+			// Fetch children for each unique parent (more efficient than individual gets)
+			const parentIds = new Set<string>();
+			for (const task of this.tasks.values()) {
+				if (task.parentSessionId) {
+					parentIds.add(task.parentSessionId);
+				}
+			}
+
+			const completionPromises: Promise<void>[] = [];
+
+			for (const parentId of parentIds) {
+				const childrenResponse = await this.ctx.client.session.children({
+					path: { id: parentId },
+					throwOnError: false,
+				});
+
+				const children = unwrapResponse<Array<unknown>>(childrenResponse) ?? [];
+				for (const child of children) {
+					const childSession = child as { id?: string; status?: { type?: string } };
+					if (!childSession.id) continue;
+
+					const matchedTaskId = this.tasksBySession.get(childSession.id);
+					if (matchedTaskId) {
+						const task = this.tasks.get(matchedTaskId);
+						if (task) {
+							const newStatus = this.mapSessionStatusToTaskStatus(childSession);
+							if (newStatus !== task.status) {
+								// Use proper handlers to trigger side effects (concurrency, notifications, etc.)
+								if (newStatus === 'completed' && task.status === 'running') {
+									completionPromises.push(this.completeTask(task));
+									results.set(matchedTaskId, newStatus);
+								} else if (newStatus === 'error') {
+									this.failTask(task, 'Session ended with error');
+									results.set(matchedTaskId, newStatus);
+								} else {
+									// For other transitions (e.g., pending -> running), direct update is fine
+									task.status = newStatus;
+									results.set(matchedTaskId, newStatus);
+								}
+							}
+						}
+					}
+				}
+			}
+
+			// Wait for all completion handlers to finish
+			await Promise.all(completionPromises);
+		} catch (error) {
+			// Log but don't fail - this is a best-effort refresh
+			console.error('Failed to refresh task statuses:', error);
+		}
+
+		return results;
+	}
+
+	/**
+	 * Recover background tasks from existing sessions.
+	 * Call this on plugin startup to restore state after restart.
+	 *
+	 * This method queries all sessions and reconstructs task state from
+	 * sessions that have JSON-encoded task metadata in their title.
+	 *
+	 * @returns The number of tasks recovered
+	 */
+	async recoverTasks(): Promise<number> {
+		let recovered = 0;
+
+		try {
+			// Get all sessions
+			const sessionsResponse = await this.ctx.client.session.list({
+				throwOnError: false,
+			});
+
+			const sessions = unwrapResponse<Array<unknown>>(sessionsResponse) ?? [];
+
+			for (const session of sessions) {
+				const sess = session as {
+					id?: string;
+					title?: string;
+					parentID?: string;
+					status?: { type?: string };
+				};
+
+				// Check if this is one of our background task sessions
+				// Our sessions have JSON-encoded task metadata in the title
+				if (!sess.title?.startsWith('{')) continue;
+
+				try {
+					const metadata = JSON.parse(sess.title) as {
+						taskId?: string;
+						agent?: string;
+						description?: string;
+						createdAt?: string;
+					};
+
+					// Skip if not a valid task metadata (must have taskId starting with 'bg_')
+					if (!metadata.taskId || !metadata.taskId.startsWith('bg_')) continue;
+
+					// Skip if we already have this task
+					if (this.tasks.has(metadata.taskId)) continue;
+
+					// Skip sessions without an ID
+					if (!sess.id) continue;
+
+					// Reconstruct the task
+					const agentName = metadata.agent ?? 'unknown';
+					const task: BackgroundTask = {
+						id: metadata.taskId,
+						sessionId: sess.id,
+						parentSessionId: sess.parentID ?? '',
+						agent: agentName,
+						description: metadata.description ?? '',
+						prompt: '', // Original prompt not stored in metadata
+						status: this.mapSessionStatusToTaskStatus(sess),
+						queuedAt: metadata.createdAt ? new Date(metadata.createdAt) : new Date(),
+						startedAt: metadata.createdAt ? new Date(metadata.createdAt) : new Date(),
+						concurrencyGroup: this.getConcurrencyGroup(agentName),
+						progress: {
+							toolCalls: 0,
+							lastUpdate: new Date(),
+						},
+					};
+
+					// Add to our tracking maps
+					this.tasks.set(task.id, task);
+					this.tasksBySession.set(sess.id, task.id);
+
+					if (task.parentSessionId) {
+						const parentTasks = this.tasksByParent.get(task.parentSessionId) ?? new Set();
+						parentTasks.add(task.id);
+						this.tasksByParent.set(task.parentSessionId, parentTasks);
+					}
+
+					recovered++;
+				} catch {
+					// Not valid JSON or not our task, skip
+					continue;
+				}
+			}
+		} catch (error) {
+			console.error('Failed to recover tasks:', error);
+		}
+
+		return recovered;
+	}
+
+	private mapSessionStatusToTaskStatus(session: unknown): BackgroundTaskStatus {
+		// Map OpenCode session status to our task status
+		// Session status types: 'idle' | 'pending' | 'running' | 'error'
+		const status = (session as { status?: { type?: string } })?.status?.type;
+		switch (status) {
+			case 'idle':
+				return 'completed';
+			case 'pending':
+				return 'pending';
+			case 'running':
+				return 'running';
+			case 'error':
+				return 'error';
+			default:
+				// Unknown session status - default to pending for best-effort recovery
+				return 'pending';
+		}
+	}
+
 	cancel(taskId: string): boolean {
 		const task = this.tasks.get(taskId);
 		if (!task || task.status === 'completed' || task.status === 'error') {
@@ -220,10 +446,18 @@ export class BackgroundManager {
 		}
 
 		try {
+			// Store task metadata in session title for persistence/recovery
+			const taskMetadata = JSON.stringify({
+				taskId: task.id,
+				agent: task.agent,
+				description: task.description,
+				createdAt: task.queuedAt?.toISOString() ?? new Date().toISOString(),
+			});
+
 			const sessionResult = await this.ctx.client.session.create({
 				body: {
 					parentID: task.parentSessionId,
-					title: task.description,
+					title: taskMetadata,
 				},
 				throwOnError: true,
 			});
@@ -334,6 +568,29 @@ export class BackgroundManager {
 	private async notifyParent(task: BackgroundTask): Promise<void> {
 		if (!task.parentSessionId) 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()}]
 

package/src/background/types.ts

@@ -26,6 +26,7 @@ export interface BackgroundTask {
 	progress?: TaskProgress;
 	concurrencyKey?: string; // Active concurrency slot key
 	concurrencyGroup?: string; // Persistent key for re-acquiring on resume
+	notifiedStatuses?: Set<BackgroundTaskStatus>; // Tracks statuses already notified to prevent duplicates
 }
 
 export interface LaunchInput {
@@ -50,3 +51,19 @@ export interface BackgroundTaskConfig {
 	providerConcurrency?: Record<string, number>;
 	modelConcurrency?: Record<string, number>;
 }
+
+/**
+ * Result of inspecting a background task's session.
+ * Provides access to session details and messages for debugging.
+ */
+export interface TaskInspection {
+	taskId: string;
+	sessionId: string;
+	status: BackgroundTaskStatus;
+	/** Session details from OpenCode SDK */
+	session: unknown;
+	/** Messages from the session */
+	messages: Array<{ info: unknown; parts: unknown[] }>;
+	/** Last activity timestamp from task progress */
+	lastActivity?: string;
+}

package/src/config/loader.ts

@@ -35,6 +35,16 @@ interface CLIConfig {
 }
 
 async function getProfilePath(): Promise<string> {
+	// Check AGENTUITY_PROFILE env var first (matches CLI behavior)
+	if (process.env.AGENTUITY_PROFILE) {
+		const envProfilePath = join(CONFIG_DIR, `${process.env.AGENTUITY_PROFILE}.yaml`);
+		const envFile = Bun.file(envProfilePath);
+		if (await envFile.exists()) {
+			return envProfilePath;
+		}
+	}
+
+	// Then check profile file
 	const profileFile = Bun.file(join(CONFIG_DIR, 'profile'));
 
 	if (await profileFile.exists()) {
@@ -74,7 +84,7 @@ export async function getConfigPath(): Promise<string> {
  * {
  *   "agent": {
  *     "Agentuity Coder Architect": {
- *       "model": "openai/gpt-5.2-codex",
+ *       "model": "openai/gpt-5.3-codex",
  *       "reasoningEffort": "xhigh"
  *     }
  *   }

package/src/plugin/hooks/cadence.ts

@@ -1,5 +1,6 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import type { CoderConfig } from '../../types';
+import type { BackgroundManager } from '../../background';
 
 /** Compacting hook input/output types */
 type CompactingInput = { sessionID: string };
@@ -15,6 +16,23 @@ export interface CadenceHooks {
 
 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',
@@ -48,7 +66,11 @@ interface CadenceSessionState {
  * 4. Trigger continuation after compaction (session.compacted)
  * 5. Clean up on session abort/error
  */
-export function createCadenceHooks(ctx: PluginInput, _config: CoderConfig): CadenceHooks {
+export function createCadenceHooks(
+	ctx: PluginInput,
+	_config: CoderConfig,
+	backgroundManager?: BackgroundManager
+): CadenceHooks {
 	const activeCadenceSessions = new Map<string, CadenceSessionState>();
 
 	const log = (msg: string) => {
@@ -170,6 +192,9 @@ export function createCadenceHooks(ctx: PluginInput, _config: CoderConfig): Cade
 				log(`Compaction completed for Cadence session ${sessionId} - saving and continuing`);
 				showToast(ctx, '🔄 Compaction saved, resuming Cadence...');
 
+				// Get current git branch
+				const branch = await getCurrentBranch();
+
 				try {
 					await ctx.client.session?.prompt?.({
 						path: { id: sessionId },
@@ -181,6 +206,8 @@ export function createCadenceHooks(ctx: PluginInput, _config: CoderConfig): Cade
 
 The compaction summary above contains our Cadence session context.
 
+Current branch: ${branch}
+
 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
@@ -269,6 +296,42 @@ 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();
+
+			// Get active background tasks for this session
+			const tasks = backgroundManager?.getTasksByParent(sessionId) ?? [];
+			let backgroundTaskContext = '';
+
+			if (tasks.length > 0) {
+				const taskList = tasks
+					.map(
+						(t) =>
+							`- **${t.id}**: ${t.description || 'No description'} (session: ${t.sessionId ?? 'pending'}, status: ${t.status})`
+					)
+					.join('\n');
+
+				backgroundTaskContext = `
+
+## 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.
+
+**Tip:** If you spawned child Leads for parallel work, delegate monitoring to BackgroundMonitor:
+\`\`\`typescript
+agentuity_background_task({
+  agent: "monitor",
+  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
 
@@ -277,6 +340,7 @@ 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}
@@ -284,8 +348,20 @@ This session is running in Cadence mode (long-running autonomous loop).
 **Session Record Location:**
 \`session:${sessionId}\` in agentuity-opencode-memory
 
-After compaction, Memory will save this summary and update the cadence state.
-Then Lead will continue the loop from iteration ${state.iteration}.
+**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?
 `);
 		},
 

package/src/plugin/hooks/keyword.ts

@@ -17,9 +17,10 @@ You are now using the Agentuity Coder agent team from Agentuity.
 - **@Agentuity Coder Architect**: Senior implementer - complex autonomous tasks, Cadence mode
 - **@Agentuity Coder Reviewer**: Quality checker - reviews changes, applies fixes
 - **@Agentuity Coder Memory**: Context keeper - remembers decisions, stores checkpoints
+- **@Agentuity Coder Reasoner**: Conclusion extractor - resolves conflicts, surfaces corrections
 - **@Agentuity Coder Expert**: Agentuity specialist - knows CLI commands and cloud services
-- **@Agentuity Coder Planner**: Strategic advisor - complex architecture, deep planning
 - **@Agentuity Coder Runner**: Command executor - runs lint/build/test, returns structured results
+- **@Agentuity Coder Product**: Requirements definer - clarifies scope, validates features, drives clarity
 
 ## Agentuity Cloud Services Available
 When genuinely helpful, use these via the CLI:
@@ -34,8 +35,9 @@ Run \`agentuity ai schema show\` to see all available CLI commands.
 ## Guidelines
 1. Break complex tasks into subtasks
 2. Use @Agentuity Coder Scout before implementing to understand context
-3. Have @Agentuity Coder Reviewer check @Agentuity Coder Builder's work
-4. Use cloud services only when they genuinely help
+3. Use @Agentuity Coder Product for new features or unclear requirements
+4. Have @Agentuity Coder Reviewer check @Agentuity Coder Builder's work
+5. Use cloud services only when they genuinely help
 </coder-mode>
 `;
 

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

@@ -1,5 +1,23 @@
 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';
+	}
+}
 
 export interface SessionMemoryHooks {
 	onEvent: (input: {
@@ -20,7 +38,8 @@ export interface SessionMemoryHooks {
  */
 export function createSessionMemoryHooks(
 	ctx: PluginInput,
-	_config: CoderConfig
+	_config: CoderConfig,
+	backgroundManager?: BackgroundManager
 ): SessionMemoryHooks {
 	const log = (msg: string) => {
 		ctx.client.app.log({
@@ -52,6 +71,8 @@ export function createSessionMemoryHooks(
 			log(`Compaction complete for session ${sessionId} - triggering memory save`);
 
 			try {
+				const branch = await getCurrentBranch();
+
 				await ctx.client.session.prompt({
 					path: { id: sessionId },
 					body: {
@@ -61,12 +82,14 @@ export function createSessionMemoryHooks(
 								text: `[COMPACTION COMPLETE]
 
 The compaction summary above contains our session context.
+Current branch: ${branch}
 
 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\`
+2. Ensure branch field is set to "${branch}"
+3. Append this compaction summary to the \`compactions\` array with timestamp
+4. Save back: \`agentuity cloud kv set agentuity-opencode-memory "session:${sessionId}" '{...}' --region use\`
+5. 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
@@ -129,13 +152,52 @@ 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();
+
+			// Get active background tasks for this session
+			const tasks = backgroundManager?.getTasksByParent(sessionId) ?? [];
+			let backgroundTaskContext = '';
+
+			if (tasks.length > 0) {
+				const taskList = tasks
+					.map(
+						(t) =>
+							`- **${t.id}**: ${t.description || 'No description'} (session: ${t.sessionId ?? 'pending'}, status: ${t.status})`
+					)
+					.join('\n');
+
+				backgroundTaskContext = `
+
+## 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.
+`;
+			}
+
 			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.
+Current branch: ${branch}
+
+**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 consider triggering Reasoner if significant patterns/corrections emerged
 `);
 		},
 	};

package/src/plugin/hooks/tools.ts

@@ -15,6 +15,15 @@ const CLOUD_TOOL_PREFIXES = [
 	'agentuity.sandbox',
 ];
 
+/**
+ * Escape a string for safe use in shell commands.
+ * Wraps in single quotes and escapes any internal single quotes.
+ */
+function shellEscape(str: string): string {
+	// Replace single quotes with '\'' (end quote, escaped quote, start quote)
+	return `'${str.replace(/'/g, "'\\''")}'`;
+}
+
 /**
  * Get the Agentuity profile to use for CLI commands.
  * Defaults to 'production' for safety, but can be overridden via AGENTUITY_CODER_PROFILE.
@@ -74,21 +83,38 @@ export function createToolHooks(ctx: PluginInput, config: CoderConfig): ToolHook
 						return;
 					}
 
-					// Inject AGENTUITY_PROFILE environment variable
-					const profile = getCoderProfile();
-					let modifiedCommand: string;
-
-					// 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}`
-						);
-					} else {
-						// Prepend AGENTUITY_PROFILE
-						modifiedCommand = `AGENTUITY_PROFILE=${profile} ${command}`;
+				// Inject AGENTUITY_PROFILE and AGENTUITY_OPENCODE_SESSION environment variables
+				const profile = getCoderProfile();
+				const sessionId = (input as { sessionID?: string }).sessionID;
+
+				// Escape values for safe shell interpolation
+				const escapedProfile = shellEscape(profile);
+				const escapedSessionId = sessionId ? shellEscape(sessionId) : undefined;
+
+				let modifiedCommand: string;
+
+			// 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=${escapedProfile}`
+			);
+					// Add session ID and agent mode if not already present
+					if (escapedSessionId && !modifiedCommand.includes('AGENTUITY_OPENCODE_SESSION=')) {
+						modifiedCommand = `AGENTUITY_OPENCODE_SESSION=${escapedSessionId} ${modifiedCommand}`;
 					}
+					if (!modifiedCommand.includes('AGENTUITY_AGENT_MODE=')) {
+						modifiedCommand = `AGENTUITY_AGENT_MODE=opencode ${modifiedCommand}`;
+					}
+				} else {
+					// Build environment variable prefix
+					let envVars = `AGENTUITY_PROFILE=${escapedProfile} AGENTUITY_AGENT_MODE=opencode`;
+					if (escapedSessionId) {
+						envVars += ` AGENTUITY_OPENCODE_SESSION=${escapedSessionId}`;
+					}
+					modifiedCommand = `${envVars} ${command}`;
+				}
 					setBashCommand(input, modifiedCommand);
 
 					// Show toast for cloud service usage