@agentuity/opencode 0.1.40 → 0.1.42

package/src/config/loader.ts

@@ -1,22 +1,37 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { YAML } from 'bun';
-import type { CoderConfig } from '../types';
+import type { CoderConfig, SkillsConfig } from '../types';
+import type { BackgroundTaskConfig } from '../background/types';
 import { CoderConfigSchema } from '../types';
+import type { TmuxConfig } from '../tmux/types';
+import { MIN_PANE_WIDTH } from '../tmux/types';
 
 const CONFIG_DIR = join(homedir(), '.config', 'agentuity');
 const DEFAULT_PROFILE = 'production.yaml';
 
+interface CLICoderConfig {
+	tmux?: {
+		enabled?: boolean;
+		maxPanes?: number;
+		mainPaneMinWidth?: number;
+		agentPaneMinWidth?: number;
+	};
+	background?: {
+		enabled?: boolean;
+		defaultConcurrency?: number;
+		staleTimeoutMs?: number;
+		providerConcurrency?: Record<string, number>;
+		modelConcurrency?: Record<string, number>;
+	};
+}
+
 interface CLIConfig {
 	name?: string;
 	preferences?: {
 		orgId?: string;
 	};
-	coder?: {
-		source?: 'npm' | 'local';
-		path?: string;
-		org?: string;
-	};
+	coder?: CLICoderConfig;
 }
 
 async function getProfilePath(): Promise<string> {
@@ -48,6 +63,24 @@ export async function getConfigPath(): Promise<string> {
 	return getProfilePath();
 }
 
+/**
+ * Load plugin configuration.
+ *
+ * This primarily loads the orgId from the Agentuity CLI profile.
+ * Agent model configuration should be done via OpenCode's native opencode.json.
+ *
+ * Users can override agent models in their opencode.json:
+ * ```json
+ * {
+ *   "agent": {
+ *     "Agentuity Coder Architect": {
+ *       "model": "openai/gpt-5.2-codex",
+ *       "reasoningEffort": "xhigh"
+ *     }
+ *   }
+ * }
+ * ```
+ */
 export async function loadCoderConfig(): Promise<CoderConfig> {
 	try {
 		const configPath = await getProfilePath();
@@ -60,8 +93,23 @@ export async function loadCoderConfig(): Promise<CoderConfig> {
 		const content = await configFile.text();
 		const cliConfig = YAML.parse(content) as CLIConfig;
 
+		// Extract orgId from CLI config preferences
+		// Extract coder settings (tmux, background) from CLI config coder section
+		// Agent model overrides should be done via opencode.json
 		const coderConfig: CoderConfig = {
 			org: cliConfig.preferences?.orgId,
+			tmux: cliConfig.coder?.tmux
+				? {
+						...DEFAULT_TMUX_CONFIG,
+						...cliConfig.coder.tmux,
+					}
+				: undefined,
+			background: cliConfig.coder?.background
+				? {
+						...DEFAULT_BACKGROUND_CONFIG,
+						...cliConfig.coder.background,
+					}
+				: undefined,
 		};
 
 		const result = CoderConfigSchema.safeParse(coderConfig);
@@ -86,42 +134,91 @@ const DEFAULT_BLOCKED_COMMANDS = [
 	'auth token', // Don't leak auth tokens
 ];
 
+const DEFAULT_BACKGROUND_CONFIG: BackgroundTaskConfig = {
+	enabled: true,
+	defaultConcurrency: 1,
+	staleTimeoutMs: 30 * 60 * 1000,
+	providerConcurrency: {},
+	modelConcurrency: {},
+};
+
+const DEFAULT_SKILLS_CONFIG: SkillsConfig = {
+	enabled: true,
+	paths: [],
+	disabled: [],
+};
+
+const DEFAULT_TMUX_CONFIG: TmuxConfig = {
+	enabled: false,
+	maxPanes: 4,
+	mainPaneMinWidth: 100,
+	agentPaneMinWidth: MIN_PANE_WIDTH,
+};
+
+/**
+ * Get default configuration.
+ *
+ * Note: Agent model defaults are defined in agent definition files (src/agents/).
+ * Users can override agent models via opencode.json.
+ */
 export function getDefaultConfig(): CoderConfig {
 	return {
-		agents: {
-			lead: { model: 'anthropic/claude-opus-4-5-20251101' },
-			scout: { model: 'anthropic/claude-haiku-4-5-20251001' },
-			builder: { model: 'anthropic/claude-opus-4-5-20251101' },
-			reviewer: { model: 'anthropic/claude-haiku-4-5-20251001' },
-			memory: { model: 'anthropic/claude-haiku-4-5-20251001' },
-			expert: { model: 'anthropic/claude-opus-4-5-20251101' },
-		},
 		disabledMcps: [],
 		blockedCommands: DEFAULT_BLOCKED_COMMANDS,
+		background: DEFAULT_BACKGROUND_CONFIG,
+		skills: DEFAULT_SKILLS_CONFIG,
+		tmux: DEFAULT_TMUX_CONFIG,
 	};
 }
 
 export function mergeConfig(base: CoderConfig, override: CoderConfig): CoderConfig {
-	// Deep merge agents: for each agent, merge base and override properties
-	const mergedAgents: CoderConfig['agents'] = {};
-	const allAgentKeys = new Set([
-		...Object.keys(base.agents ?? {}),
-		...Object.keys(override.agents ?? {}),
-	]);
-
-	for (const key of allAgentKeys) {
-		const baseAgent = base.agents?.[key as keyof typeof base.agents];
-		const overrideAgent = override.agents?.[key as keyof typeof override.agents];
-		mergedAgents[key as keyof typeof mergedAgents] = {
-			...baseAgent,
-			...overrideAgent,
-		};
-	}
-
 	return {
 		org: override.org ?? base.org,
-		agents: mergedAgents,
 		disabledMcps: override.disabledMcps ?? base.disabledMcps,
 		blockedCommands: override.blockedCommands ?? base.blockedCommands,
+		background: mergeBackgroundConfig(base.background, override.background),
+		skills: mergeSkillsConfig(base.skills, override.skills),
+		tmux: mergeTmuxConfig(base.tmux, override.tmux),
+	};
+}
+
+function mergeBackgroundConfig(
+	base?: BackgroundTaskConfig,
+	override?: BackgroundTaskConfig
+): BackgroundTaskConfig | undefined {
+	if (!base && !override) return undefined;
+	return {
+		enabled: override?.enabled ?? base?.enabled ?? true,
+		defaultConcurrency: override?.defaultConcurrency ?? base?.defaultConcurrency ?? 1,
+		staleTimeoutMs: override?.staleTimeoutMs ?? base?.staleTimeoutMs ?? 30 * 60 * 1000,
+		providerConcurrency: {
+			...(base?.providerConcurrency ?? {}),
+			...(override?.providerConcurrency ?? {}),
+		},
+		modelConcurrency: {
+			...(base?.modelConcurrency ?? {}),
+			...(override?.modelConcurrency ?? {}),
+		},
+	};
+}
+
+function mergeSkillsConfig(base?: SkillsConfig, override?: SkillsConfig): SkillsConfig | undefined {
+	if (!base && !override) return undefined;
+	const paths = new Set([...(base?.paths ?? []), ...(override?.paths ?? [])]);
+	const disabled = new Set([...(base?.disabled ?? []), ...(override?.disabled ?? [])]);
+	return {
+		enabled: override?.enabled ?? base?.enabled ?? true,
+		paths: paths.size > 0 ? Array.from(paths) : undefined,
+		disabled: disabled.size > 0 ? Array.from(disabled) : undefined,
+	};
+}
+
+function mergeTmuxConfig(base?: TmuxConfig, override?: TmuxConfig): TmuxConfig | undefined {
+	if (!base && !override) return undefined;
+	return {
+		enabled: override?.enabled ?? base?.enabled ?? false,
+		maxPanes: override?.maxPanes ?? base?.maxPanes ?? 4,
+		mainPaneMinWidth: override?.mainPaneMinWidth ?? base?.mainPaneMinWidth ?? 100,
+		agentPaneMinWidth: override?.agentPaneMinWidth ?? base?.agentPaneMinWidth ?? MIN_PANE_WIDTH,
 	};
 }

package/src/config/presets.ts

@@ -0,0 +1,21 @@
+/**
+ * Model helper utilities.
+ *
+ * Note: Presets have been removed in favor of using OpenCode's native config.
+ * Default models are baked into agent definitions.
+ * Users can override via opencode.json.
+ */
+
+/**
+ * Check if a model ID is from OpenAI.
+ */
+export function isOpenAIModel(model: string): boolean {
+	return model.startsWith('openai/');
+}
+
+/**
+ * Check if a model ID is from Anthropic.
+ */
+export function isAnthropicModel(model: string): boolean {
+	return model.startsWith('anthropic/');
+}

package/src/config/validation.ts

@@ -0,0 +1,70 @@
+import { isOpenAIModel, isAnthropicModel } from './presets';
+
+export interface ConfigWarning {
+	agent: string;
+	message: string;
+}
+
+/**
+ * Minimal config shape for validation - works with both AgentConfig and AgentModelConfig.
+ */
+interface ValidatableConfig {
+	model?: string;
+	reasoningEffort?: string;
+	variant?: string;
+	thinking?: unknown;
+}
+
+/**
+ * Validates agent model configuration and returns warnings for mismatches.
+ * Does not throw - just warns about potentially incorrect configuration.
+ */
+export function validateAgentConfig(agentName: string, config: ValidatableConfig): ConfigWarning[] {
+	const warnings: ConfigWarning[] = [];
+	const model = config.model;
+
+	if (!model) return warnings;
+
+	// Check for OpenAI-specific options on Anthropic models
+	if (isAnthropicModel(model)) {
+		if (config.reasoningEffort) {
+			warnings.push({
+				agent: agentName,
+				message: `'reasoningEffort' is an OpenAI-specific option but model is Anthropic (${model}). Use 'variant' or 'thinking' instead.`,
+			});
+		}
+	}
+
+	// Check for Anthropic-specific options on OpenAI models
+	if (isOpenAIModel(model)) {
+		if (config.variant) {
+			warnings.push({
+				agent: agentName,
+				message: `'variant' is an Anthropic-specific option but model is OpenAI (${model}). Use 'reasoningEffort' instead.`,
+			});
+		}
+		if (config.thinking) {
+			warnings.push({
+				agent: agentName,
+				message: `'thinking' is an Anthropic-specific option but model is OpenAI (${model}). Use 'reasoningEffort' instead.`,
+			});
+		}
+	}
+
+	return warnings;
+}
+
+/**
+ * Validates all agent configs and logs warnings.
+ */
+export function validateAndWarnConfigs(
+	configs: Record<string, ValidatableConfig>,
+	logger: { warn: (msg: string) => void } = console
+): void {
+	for (const [agentName, config] of Object.entries(configs)) {
+		const warnings = validateAgentConfig(agentName, config);
+		for (const warning of warnings) {
+			logger.warn(`[Agentuity Coder] Config warning for ${warning.agent}: ${warning.message}`);
+		}
+	}
+}

package/src/index.ts

@@ -13,6 +13,7 @@ export type {
 	AgentContext,
 	CoderTask,
 	CoderConfig,
+	BackgroundTaskConfig,
 	McpConfig,
 	TaskStatus,
 } from './types';

package/src/plugin/hooks/cadence.ts

@@ -107,6 +107,7 @@ export function createCadenceHooks(ctx: PluginInput, _config: CoderConfig): Cade
 			);
 			if (statusMatch) {
 				const [, loopId, iteration, maxIterations] = statusMatch;
+				if (!iteration || !maxIterations) return;
 				const newIteration = parseInt(iteration, 10);
 				const newMax = parseInt(maxIterations, 10);
 				const changed =
@@ -127,7 +128,7 @@ export function createCadenceHooks(ctx: PluginInput, _config: CoderConfig): Cade
 
 			// Fallback: try to extract iteration from loose "iteration: N" pattern
 			const iterMatch = messageText.match(/iteration[:\s]+(\d+)/i);
-			if (iterMatch) {
+			if (iterMatch && iterMatch[1]) {
 				const newIteration = parseInt(iterMatch[1], 10);
 				if (newIteration !== state.iteration) {
 					state.iteration = newIteration;

package/src/plugin/hooks/keyword.ts

@@ -14,9 +14,12 @@ You are now using the Agentuity Coder agent team from Agentuity.
 - **@Agentuity Coder Lead**: Orchestrator - breaks down tasks, delegates, never implements directly
 - **@Agentuity Coder Scout**: Explorer - finds patterns, researches docs, analyzes codebase (read-only)
 - **@Agentuity Coder Builder**: Implementer - writes code, runs tests, makes changes
+- **@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 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 Cloud Services Available
 When genuinely helpful, use these via the CLI: