@agentuity/opencode 0.1.39 → 0.1.41

package/src/tmux/types.ts

@@ -0,0 +1,106 @@
+/**
+ * Information about a tmux pane
+ */
+export interface TmuxPaneInfo {
+	paneId: string; // e.g., %0, %1
+	width: number; // Columns
+	height: number; // Rows
+	left: number; // Position from left
+	top: number; // Position from top
+	title: string; // Pane title
+	isActive: boolean; // Is this the active pane?
+}
+
+/**
+ * Current state of the tmux window
+ */
+export interface WindowState {
+	windowWidth: number;
+	windowHeight: number;
+	mainPane: TmuxPaneInfo | null; // The pane running the main agent
+	agentPanes: TmuxPaneInfo[]; // Panes for background agents
+}
+
+/**
+ * Tracked session for a background agent in tmux
+ */
+export interface TrackedSession {
+	sessionId: string; // OpenCode session ID
+	paneId: string; // Tmux pane ID
+	description: string; // Task description
+	createdAt: Date;
+	lastSeenAt: Date;
+}
+
+/**
+ * Direction for splitting panes
+ */
+export type SplitDirection = '-h' | '-v'; // -h = horizontal (side by side), -v = vertical (stacked)
+
+/**
+ * Actions for managing panes
+ */
+export type PaneAction =
+	| {
+			type: 'spawn';
+			sessionId: string;
+			description: string;
+			targetPaneId: string;
+			splitDirection: SplitDirection;
+	  }
+	| { type: 'close'; paneId: string; sessionId: string }
+	| {
+			type: 'replace';
+			paneId: string;
+			oldSessionId: string;
+			newSessionId: string;
+			description: string;
+	  };
+
+/**
+ * Decision result from the spawn decision engine
+ */
+export interface SpawnDecision {
+	canSpawn: boolean;
+	actions: PaneAction[];
+	reason?: string;
+}
+
+/**
+ * Capacity configuration for pane layout
+ */
+export interface CapacityConfig {
+	mainPaneMinWidth: number;
+	agentPaneMinWidth: number;
+}
+
+/**
+ * Session mapping for decision engine
+ */
+export interface SessionMapping {
+	sessionId: string;
+	paneId: string;
+	createdAt: Date;
+}
+
+/**
+ * Configuration for tmux integration
+ *
+ * Agents spawn in a dedicated "Agents" window with tiled grid layout.
+ * This keeps the main pane untouched while grouping all agent panes together.
+ */
+export interface TmuxConfig {
+	enabled: boolean;
+	maxPanes: number;
+	mainPaneMinWidth: number;
+	agentPaneMinWidth: number;
+}
+
+// Minimum pane dimensions
+export const MIN_PANE_WIDTH = 52;
+export const MIN_PANE_HEIGHT = 11;
+
+// Polling intervals
+export const POLL_INTERVAL_MS = 2000;
+export const SESSION_MISSING_GRACE_MS = 5000;
+export const SESSION_TIMEOUT_MS = 10 * 60 * 1000;

package/src/tmux/utils.ts

@@ -0,0 +1,85 @@
+import { spawn, spawnSync } from 'bun';
+
+/**
+ * Check if running inside a tmux session
+ */
+export function isInsideTmux(): boolean {
+	return !!process.env.TMUX;
+}
+
+/**
+ * Get the current pane ID
+ */
+export function getCurrentPaneId(): string | undefined {
+	return process.env.TMUX_PANE;
+}
+
+/**
+ * Get the path to the tmux binary
+ */
+export async function getTmuxPath(): Promise<string | null> {
+	try {
+		const proc = spawn(['which', 'tmux'], { stdout: 'pipe' });
+		await proc.exited;
+		const output = await new Response(proc.stdout).text();
+		return output.trim() || null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Run a tmux command and return output
+ */
+export async function runTmuxCommand(
+	args: string[]
+): Promise<{ success: boolean; output: string }> {
+	const tmux = await getTmuxPath();
+	if (!tmux) return { success: false, output: 'tmux not found' };
+
+	const proc = spawn([tmux, ...args], { stdout: 'pipe', stderr: 'pipe' });
+	const exitCode = await proc.exited;
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+
+	return {
+		success: exitCode === 0,
+		output: exitCode === 0 ? stdout.trim() : stderr.trim(),
+	};
+}
+
+/**
+ * Run a tmux command synchronously (for shutdown scenarios)
+ * Uses spawnSync to ensure completion before process exit
+ */
+export function runTmuxCommandSync(args: string[]): { success: boolean; output: string } {
+	const tmux = getTmuxPathSync();
+	if (!tmux) return { success: false, output: 'tmux not found' };
+
+	try {
+		const result = spawnSync([tmux, ...args], { timeout: 2000 });
+		const stdout = result.stdout?.toString() ?? '';
+		const stderr = result.stderr?.toString() ?? '';
+
+		return {
+			success: result.exitCode === 0,
+			output: result.exitCode === 0 ? stdout.trim() : stderr.trim(),
+		};
+	} catch {
+		return { success: false, output: 'tmux command failed' };
+	}
+}
+
+/**
+ * Get the path to the tmux binary synchronously
+ */
+export function getTmuxPathSync(): string | null {
+	try {
+		const result = spawnSync(['which', 'tmux']);
+		if (result.exitCode !== 0) return null;
+		const output = result.stdout?.toString() ?? '';
+		return output.trim() || null;
+	} catch {
+		return null;
+	}
+}

package/src/tools/background.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import type { ToolContext } from '@opencode-ai/plugin';
+import type { AgentRole } from '../types';
+import { AgentRoleSchema } from '../types';
+import { agents } from '../agents';
+import type { BackgroundManager } from '../background';
+
+export const BackgroundTaskArgsSchema = z.object({
+	agent: AgentRoleSchema.describe('Agent role to run the task'),
+	task: z.string().describe('Task prompt to run in the background'),
+	description: z.string().optional().describe('Short description of the task'),
+});
+
+export const BackgroundOutputArgsSchema = z.object({
+	task_id: z.string().describe('Background task ID'),
+});
+
+export const BackgroundCancelArgsSchema = z.object({
+	task_id: z.string().describe('Background task ID'),
+});
+
+export type BackgroundTaskArgs = z.infer<typeof BackgroundTaskArgsSchema>;
+export type BackgroundOutputArgs = z.infer<typeof BackgroundOutputArgsSchema>;
+export type BackgroundCancelArgs = z.infer<typeof BackgroundCancelArgsSchema>;
+
+export function createBackgroundTools(manager: BackgroundManager): {
+	backgroundTaskTool: {
+		name: string;
+		description: string;
+		args: typeof BackgroundTaskArgsSchema;
+		execute: (
+			args: BackgroundTaskArgs,
+			context: ToolContext
+		) => Promise<{
+			taskId: string;
+			status: string;
+			message: string;
+		}>;
+	};
+	backgroundOutputTool: {
+		name: string;
+		description: string;
+		args: typeof BackgroundOutputArgsSchema;
+		execute: (args: BackgroundOutputArgs) => Promise<{
+			taskId: string;
+			status: string;
+			result?: string;
+			error?: string;
+		}>;
+	};
+	backgroundCancelTool: {
+		name: string;
+		description: string;
+		args: typeof BackgroundCancelArgsSchema;
+		execute: (args: BackgroundCancelArgs) => Promise<{
+			taskId: string;
+			success: boolean;
+			message: string;
+		}>;
+	};
+} {
+	const backgroundTaskTool = {
+		name: 'background_task',
+		description: 'Launch a task to run in the background.',
+		args: BackgroundTaskArgsSchema,
+		async execute(
+			args: BackgroundTaskArgs,
+			context: ToolContext
+		): Promise<{
+			taskId: string;
+			status: string;
+			message: string;
+		}> {
+			const agentName = resolveAgentName(args.agent);
+			const task = await manager.launch({
+				description: args.description ?? args.task,
+				prompt: args.task,
+				agent: agentName,
+				parentSessionId: context.sessionID,
+				parentMessageId: context.messageID,
+			});
+
+			return {
+				taskId: task.id,
+				status: task.status,
+				message:
+					task.status === 'error'
+						? (task.error ?? 'Failed to launch background task.')
+						: 'Background task launched.',
+			};
+		},
+	};
+
+	const backgroundOutputTool = {
+		name: 'background_output',
+		description: 'Retrieve output for a background task.',
+		args: BackgroundOutputArgsSchema,
+		async execute(args: BackgroundOutputArgs): Promise<{
+			taskId: string;
+			status: string;
+			result?: string;
+			error?: string;
+		}> {
+			const task = manager.getTask(args.task_id);
+			if (!task) {
+				return {
+					taskId: args.task_id,
+					status: 'error',
+					error: 'Task not found.',
+				};
+			}
+			return {
+				taskId: task.id,
+				status: task.status,
+				result: task.result,
+				error: task.error,
+			};
+		},
+	};
+
+	const backgroundCancelTool = {
+		name: 'background_cancel',
+		description: 'Cancel a running background task.',
+		args: BackgroundCancelArgsSchema,
+		async execute(args: BackgroundCancelArgs): Promise<{
+			taskId: string;
+			success: boolean;
+			message: string;
+		}> {
+			const success = manager.cancel(args.task_id);
+			return {
+				taskId: args.task_id,
+				success,
+				message: success ? 'Background task cancelled.' : 'Unable to cancel task.',
+			};
+		},
+	};
+
+	return { backgroundTaskTool, backgroundOutputTool, backgroundCancelTool };
+}
+
+function resolveAgentName(role: AgentRole): string {
+	const agent = agents[role];
+	return agent?.displayName ?? role;
+}

package/src/tools/delegate.ts

@@ -4,7 +4,7 @@ import type { AgentRole } from '../types';
 // Schema for the delegate tool
 export const DelegateArgsSchema = z.object({
 	agent: z
-		.enum(['scout', 'builder', 'reviewer', 'memory', 'expert'])
+		.enum(['scout', 'builder', 'architect', 'reviewer', 'memory', 'expert', 'planner', 'runner'])
 		.describe('The agent to delegate to'),
 	task: z.string().describe('Clear description of the task to delegate'),
 	context: z.string().optional().describe('Additional context from previous tasks'),
@@ -21,9 +21,12 @@ const AGENT_MENTIONS: Record<AgentRole, string> = {
 	lead: '@Agentuity Coder Lead',
 	scout: '@Agentuity Coder Scout',
 	builder: '@Agentuity Coder Builder',
+	architect: '@Agentuity Coder Architect',
 	reviewer: '@Agentuity Coder Reviewer',
 	memory: '@Agentuity Coder Memory',
 	expert: '@Agentuity Coder Expert',
+	planner: '@Agentuity Coder Planner',
+	runner: '@Agentuity Coder Runner',
 };
 
 export const delegateTool = {
@@ -32,10 +35,13 @@ export const delegateTool = {
 
 Use this to:
 - Scout: Explore codebase, find patterns, research documentation
-- Builder: Implement features, write code, run tests
+- Builder: Implement features, write code, run tests (interactive work)
+- Architect: Complex autonomous tasks, Cadence mode, deep reasoning (GPT Codex)
 - Reviewer: Review changes, catch issues, apply fixes  
 - Memory: Store context, remember decisions across sessions
 - Expert: Get help with Agentuity CLI and cloud services
+- Planner: Strategic advisor for complex architecture and deep planning (read-only)
+- Runner: Run lint/build/test/typecheck/format/clean/install commands, returns structured results
 
 The task will be executed by the specified agent and the result returned.`,
 

package/src/tools/index.ts

@@ -1 +1,10 @@
 export { delegateTool, DelegateArgsSchema, type DelegateArgs } from './delegate';
+export {
+	createBackgroundTools,
+	BackgroundTaskArgsSchema,
+	BackgroundOutputArgsSchema,
+	BackgroundCancelArgsSchema,
+	type BackgroundTaskArgs,
+	type BackgroundOutputArgs,
+	type BackgroundCancelArgs,
+} from './background';

package/src/types.ts

@@ -1,4 +1,7 @@
 import { z } from 'zod';
+import type { BackgroundTaskConfig } from './background/types';
+import type { SkillsConfig } from './skills/types';
+import type { TmuxConfig } from './tmux/types';
 
 // Re-export types from @opencode-ai/plugin
 export type {
@@ -8,7 +11,21 @@ export type {
 	ToolDefinition,
 } from '@opencode-ai/plugin';
 
-export const AgentRoleSchema = z.enum(['lead', 'scout', 'builder', 'reviewer', 'memory', 'expert']);
+export type { BackgroundTaskConfig } from './background/types';
+export type { SkillsConfig, LoadedSkill, SkillMetadata, SkillScope } from './skills';
+export type { TmuxConfig } from './tmux/types';
+
+export const AgentRoleSchema = z.enum([
+	'lead',
+	'scout',
+	'builder',
+	'architect',
+	'reviewer',
+	'memory',
+	'expert',
+	'planner',
+	'runner',
+]);
 export type AgentRole = z.infer<typeof AgentRoleSchema>;
 
 export const TaskStatusSchema = z.enum(['pending', 'running', 'completed', 'failed', 'cancelled']);
@@ -64,6 +81,10 @@ export interface AgentConfig {
 	temperature?: number;
 	/** Maximum agentic steps before forcing text response */
 	maxSteps?: number;
+	/** Reasoning effort for OpenAI models */
+	reasoningEffort?: ReasoningEffort;
+	/** Extended thinking configuration for Anthropic models */
+	thinking?: ThinkingConfig;
 }
 
 export interface AgentContext {
@@ -86,32 +107,84 @@ export interface CoderTask {
 	error?: string;
 }
 
+/** Extended thinking configuration for Anthropic models */
+export const ThinkingConfigSchema = z.object({
+	type: z.enum(['enabled', 'disabled']),
+	budgetTokens: z.number().optional(),
+});
+export type ThinkingConfig = z.infer<typeof ThinkingConfigSchema>;
+
+/** Reasoning effort for OpenAI models */
+export const ReasoningEffortSchema = z.enum(['low', 'medium', 'high', 'xhigh']);
+export type ReasoningEffort = z.infer<typeof ReasoningEffortSchema>;
+
+/** Model variant for Anthropic thinking levels */
+export const ModelVariantSchema = z.enum(['low', 'medium', 'high', 'max']);
+export type ModelVariant = z.infer<typeof ModelVariantSchema>;
+
+/** Enhanced agent model configuration */
+export interface AgentModelConfig {
+	/** Model ID in provider/model-id format */
+	model?: string;
+	/** Temperature for response creativity (0.0-2.0) */
+	temperature?: number;
+	/** Model variant for Anthropic thinking levels */
+	variant?: ModelVariant;
+	/** Reasoning effort for OpenAI models */
+	reasoningEffort?: ReasoningEffort;
+	/** Extended thinking configuration for Anthropic models */
+	thinking?: ThinkingConfig;
+	/** Maximum agentic steps before forcing text response */
+	maxSteps?: number;
+}
+
+export const AgentModelConfigSchema = z.object({
+	model: z.string().optional(),
+	temperature: z.number().min(0).max(2).optional(),
+	variant: ModelVariantSchema.optional(),
+	reasoningEffort: ReasoningEffortSchema.optional(),
+	thinking: ThinkingConfigSchema.optional(),
+	maxSteps: z.number().optional(),
+});
+
 export interface CoderConfig {
 	org?: string;
-	agents?: Partial<Record<AgentRole, AgentModelConfig>>;
 	disabledMcps?: string[];
 	/** CLI command patterns to block for security (e.g., 'cloud secrets', 'auth token') */
 	blockedCommands?: string[];
+	background?: BackgroundTaskConfig;
+	skills?: SkillsConfig;
+	tmux?: TmuxConfig;
 }
 
-export interface AgentModelConfig {
-	model?: string;
-	temperature?: number;
-}
+export const BackgroundTaskConfigSchema = z.object({
+	enabled: z.boolean(),
+	defaultConcurrency: z.number(),
+	staleTimeoutMs: z.number(),
+	providerConcurrency: z.record(z.string(), z.number()).optional(),
+	modelConcurrency: z.record(z.string(), z.number()).optional(),
+});
+
+export const SkillsConfigSchema = z.object({
+	enabled: z.boolean(),
+	paths: z.array(z.string()).optional(),
+	disabled: z.array(z.string()).optional(),
+});
+
+export const TmuxConfigSchema = z.object({
+	enabled: z.boolean(),
+	maxPanes: z.number(),
+	mainPaneMinWidth: z.number(),
+	agentPaneMinWidth: z.number(),
+});
 
 export const CoderConfigSchema = z.object({
 	org: z.string().optional(),
-	agents: z
-		.record(
-			AgentRoleSchema,
-			z.object({
-				model: z.string().optional(),
-				temperature: z.number().min(0).max(2).optional(),
-			})
-		)
-		.optional(),
 	disabledMcps: z.array(z.string()).optional(),
 	blockedCommands: z.array(z.string()).optional(),
+	background: BackgroundTaskConfigSchema.optional(),
+	skills: SkillsConfigSchema.optional(),
+	tmux: TmuxConfigSchema.optional(),
 });
 
 export interface McpConfig {